Files
Support-Agent/docs/superpowers/plans/2026-10-23-journal-du-matin.md
T

2038 lines
292 KiB
Markdown
Raw Normal View History

2026-10-23 21:52:08 +02:00
# Journal du matin du client : plan de travail
> **Pour l'agent qui reprend ce plan :** ce plan n'est pas linéaire. L'utilisateur nomme **un point** (« exécute le point 7 du plan `docs/superpowers/plans/2026-10-23-journal-du-matin.md` ») ; tu fais ce point seul, en suivant ses étapes (`- [ ]`), avec superpowers:executing-plans **en ligne** (pas de sous-agents sauf demande explicite). Prototype : ni tests ni revue (D-008, utilisateur 2026-10-16 et 2026-10-23) ; on vérifie en lançant et en regardant une capture. Avant de commencer : lis la section « Contraintes » et le point demandé en entier, puis seulement les fichiers qu'il cite. À la fin : coche les étapes faites, mets à jour la colonne **Statut** de l'index, ajoute une ligne datée au « Journal du plan » en bas, et dis à l'utilisateur ce qui reste du point. **Validé** : un point n'est validé que lorsque l'utilisateur le dit ; sa colonne **Statut** devient « validé le AAAA-MM-JJ » et toutes ses étapes sont cochées ; un point validé n'est plus proposé ni repris, sauf si l'utilisateur le rouvre (règle de l'utilisateur, 2026-10-24 : on avance point par point, dans l'ordre, en commençant par le point 1). Si l'utilisateur lance une idée nouvelle en cours de route, ajoute-la au plan aussitôt : un point à la suite des numéros existants (sans renuméroter), rangé dans la partie qui lui va, une ligne dans l'index, une ligne au « Journal du plan » ; et dans `vues-deplacements/contexte/journal-du-matin.md`.
2026-10-23 21:52:08 +02:00
**But :** une page `Journal` dans Explore, que le client lit comme le journal du matin : ses courbes de déplacement sur quelques jours et, dessous, **ce qui s'est passé**, une catégorie claire par événement, la zone invalidée quand il faut l'ignorer, et les images quand elles montrent la cause.
**Architecture :** des détecteurs élémentaires (un fichier chacun dans `detectors/`) trouvent des épisodes dans l'export « advanced » ; un classement les regroupe en **événements catégorisés** (catégories de la carte des événements) ; chaque catégorie déclenche son **processus** (invalider la zone, montrer les images, demander une vérification) ; la maquette Explore (`vues-deplacements/maquette/`) les affiche. Plus tard : les données pompées en masse depuis la plateforme et une boucle où Claude critique et règle les détecteurs hors ligne.
2026-10-23 21:52:08 +02:00
**Technique :** Python, bibliothèque standard pour le calcul ; plotly.js 4.1.1 (CDN) dans le gabarit HTML ; `.venv` (plotly, matplotlib) pour le poste de dev et les vignettes ; Chrome headless pour les captures.
**Spec :** pas de spec séparée, ce plan argumente depuis :
- `vues-deplacements/contexte/journal-du-matin.md` : le brainstorming du 2026-10-23 et le retour de l'utilisateur sur la v0 ;
- `docs/decisions.md`, D-056 et sa précision ;
- `events/carte-des-evenements.md` : les 12 événements et l'arbre de décision ;
2026-10-23 21:52:08 +02:00
- `vues-deplacements/maquette/spec.md`, section « L'onglet Journal ».
## Contraintes (valent pour tous les points)
- **La règle d'or : simple.** L'utilisateur, le 2026-10-23 : « c'est ça, la guideline, l'instruction que je dois m'imposer : ça doit être simple ; il ne faut pas chercher à faire des trucs super complexes. » Le plus bête qui marche sur les events, puis on itère avec lui. Pas d'imagination débordante, pas d'optimal, pas de stylé ; avant d'ajouter une règle ou une constante, se demander si le client en a besoin pour comprendre. À redire à tout sous-agent.
2026-10-23 21:52:08 +02:00
- **Catégorique et complet** (retour du 2026-10-23) : chaque événement a **une** catégorie, dite sans « probably », « most likely » ou « may be » ; la phrase dit ce qui s'est passé et quoi en faire.
- **On garde toutes les données.** Invalider = griser ou mettre en retrait, jamais retirer un point de la courbe brute.
- **Un vrai mouvement n'est jamais invalidé.** CLARIDEN (E-004) doit rester visible et marqué « à vérifier » à chaque changement.
2026-10-23 21:52:08 +02:00
- Code de calcul en **bibliothèque standard**, embarquable ; pas de pandas ; pas de nouvelle dépendance.
- **Heures en UTC** partout ; l'export horaire est en heure suisse sans fuseau (`labeling/connaissances/colonnes-des-deplacements.md`).
2026-10-23 21:52:08 +02:00
- **Documents en français, texte du site en anglais** (D-023).
- **Pas de données synthétiques** (refus explicite de l'utilisateur).
- **Seuils** : chacun est commenté « provisoire, réglé sur E-00x » (règle « aucun seuil sans source » du `CLAUDE.md`, adaptée à l'exploration) et inscrit au registre, `vues-deplacements/contexte/seuils-du-journal.md` (point 17).
2026-10-23 21:52:08 +02:00
- **Identifiants** (`SIM_CCID`, `ip`, secrets de l'application) jamais recopiés ; ne jamais lire de `.env`.
- **Lecture seule** : rien n'écrit dans la base de la plateforme ni dans les dépôts `~/monitoring-dashboard-*` ; Claude ne se connecte jamais à la base, l'utilisateur lance l'extraction.
- **Contrat d'un détecteur** (inchangé) : `detectors/<nom>.py` expose `detect(mesures) -> list[dict]`, `mesures = donnees.charger(dossier)` (`agent-tools/donnees.py`) ; épisode `{"start": iso, "end": iso, "kind": "<nom>", "label": str, "text": str, "ignore": bool, "sensors": [str]}` (heures `donnees.iso`, `sensors` vide = tous) ; un `__main__` qui imprime une ligne par épisode.
2026-10-23 21:52:08 +02:00
- **Décisions** : une décision prise en conversation va dans `docs/decisions.md` (sous D-056 ou nouvelle entrée) ; un savoir métier nouveau dans `docs/displacement/domaine/` ; l'état du chantier dans « État et prochaine étape » de `CLAUDE.md` (qui doit rester sous 200 lignes, D-012).
- **Commit** seulement quand l'utilisateur le demande.
- **Events de la base** : un event n'y entre que sur demande de l'utilisateur (`/new-event`) ; noms codés dans `events/`.
2026-10-23 21:52:08 +02:00
## Points d'attention (ce qui casse le plus probablement)
1. **Un vrai mouvement rangé dans « à ignorer ».** Le classement (point 6) absorbe les sauts dans un épisode de mauvaise visibilité : un saut **durable** ne doit jamais l'être. Contrôle : point 10, ligne CLARIDEN (« Shift to check », non grisé) et ligne NORDEND d'octobre (PR17 le 08/10 à 02:30 reste à part, dans la buée).
2. **Deux étiquettes contradictoires au même moment.** Aujourd'hui, à NORDEND le 14/10 à 05:15, deux lignes disent « Sudden jump » et « Poor visibility ». Le classement doit n'en sortir qu'**un** événement. Contrôle : point 10, toutes les lignes.
3. **Une seule cible grise toutes les courbes.** « Target obscured » sur 4 cibles grise presque une journée à NORDEND. Contrôle : point 18, NORDEND du 13/10 09:45 au 14/10 07:00.
4. **Pas d'image pour l'événement.** PS des Coudres n'a que 24 images (13/10 12:00 → 14/10 11:00) ; NIEDERHORN est horaire. Le processus « images » doit dire « No camera image for this period. » au lieu de casser ou d'afficher une image hors période. Contrôle : point 7, PS des Coudres le 13/10 à 01:15.
5. **Un export qui commence pendant un artefact.** `sauts` prend la place habituelle sur le premier jour, `visibilite` et `turbulence` le niveau habituel sur tout l'export (médiane, MAD, quartile bas) : un export court ou pris en plein épisode fausse les étiquettes (E-002 : l'épisode couvre la plus grande partie de l'export). Contrôle : point 30 (tranches de 3 à 5 jours) et point 31 (la boucle les compare). **Constaté au point 30 (2026-10-24)** : une tranche de 3 jours sans historique absorbe le vrai saut de PR17 ; 3 jours d'historique le rendent.
2026-10-23 21:52:08 +02:00
---
## Index
Types : **Comprendre** (lire, expliquer, rien ne change), **Décider** (l'utilisateur tranche), **Coder**, **Lancer** (l'utilisateur lance quelque chose chez lui). Statuts : à faire, en cours, en attente, **validé le <date>** (par l'utilisateur seul, voir l'en-tête). Mis à jour le 2026-10-29.
2026-10-23 21:52:08 +02:00
| N° | Point | Type | Dépend de | Statut |
|---|---|---|---|---|
| | **I. Comprendre ce qui a été fait** | | | |
| 1 | Visite guidée de l'onglet Journal v0 | Comprendre | — | validé le 2026-10-24 |
| 2 | Les cinq détecteurs en un coup d'œil | Comprendre | — | validé le 2026-10-24 |
| 3 | La carte des événements, à valider par l'expert | Comprendre, Décider | — | validé le 2026-10-24 |
| 4 | Le brainstorming, D-056 et ce qui a été écarté | Comprendre | — | validé le 2026-10-24 |
2026-10-23 21:52:08 +02:00
| | **II. Le journal catégorique (le cœur du retour)** | | | |
| 5 | Les catégories et leurs processus | Décider | 3 | validé le 2026-10-24 |
| 6 | Le classement : des épisodes aux événements catégorisés | Coder | 5 | validé le 2026-10-24 |
| 7 | Le bouton `Images` : la vidéo de l'épisode | Coder | — (après 6 : sur les événements) | validé le 2026-10-24 |
| 8 | La page Journal, catégorique et plus simple | Coder | 6, 7 | validé le 2026-10-24 |
| 9 | Les phrases du journal | Décider, Coder | 5 | validé le 2026-10-24 |
| 10 | Vérifier le journal catégorique sur les six jeux | Lancer, Comprendre | 6 à 9 | validé le 2026-10-24 |
| 38 | Les statuts de visibilité : bonne, moyenne, nulle | Décider, Coder | 11 | validé le 2026-10-24 |
2026-10-23 21:52:08 +02:00
| | **III. Les détecteurs, un par un** | | | |
| 11 | `visibilite` : la version simple d'abord | Coder, Décider | 2 | validé le 2026-10-24 |
| 12 | `sauts` : régler | Coder | 2 | validé le 2026-10-24 |
| 13 | `thermique` : ce que voit vraiment le client | Décider, Coder | 2 | validé le 2026-10-24 |
| 14 | `turbulence` : midis agités et marge de CLARIDEN | Décider, Coder | 2 | validé le 2026-10-24 |
| 15 | `trous` : libellé et sens | Coder | 2 | validé le 2026-10-24 |
| 16 | Les catégories qu'aucun détecteur n'attrape | Coder | 5 | validé le 2026-10-24 |
| 17 | Le registre des seuils provisoires | Comprendre | 11 à 16 | validé le 2026-10-24 |
| 41 | L'effet périodique : une sinusoïde de 24 h, dilatation et contraction thermiques | Décider, Coder | 13 | validé le 2026-10-24 |
2026-10-23 21:52:08 +02:00
| | **IV. La page : défauts et choix d'affichage** | | | |
| 18 | Zones grisées trop larges | Décider, Coder | 8 | validé le 2026-10-24 |
| 19 | Échelle écrasée par un pic | Coder | — | validé le 2026-10-24 |
| 20 | Pixels ou millimètres | Décider, Coder | — | validé le 2026-10-24 |
| 21 | Plage par défaut, « depuis ta dernière visite » | Décider, Coder | — | validé le 2026-10-24 |
| 22 | Interactions jamais essayées | Lancer | 1 | validé le 2026-10-24 |
| 23 | Deux couches : client et support | Décider, Coder | 8 | validé le 2026-10-24 |
| 39 | Les cibles `target02` à `target05` absentes des courbes | Coder | — | validé le 2026-10-24 |
| 40 | Déplier la frise au lieu de tout empiler sur une ligne | Décider, Coder | 8 | validé le 2026-10-24 |
2026-10-23 21:52:08 +02:00
| | **V. Second volet : la courbe nettoyée** | | | |
| 24 | Trancher les trois questions du lissage | Décider | — | validé le 2026-10-24 |
| 25 | Option A : la courbe nettoyée par masquage | Coder | 24, 8 | validé le 2026-10-24 |
| 26 | Options B à E : en réserve | Comprendre | 25 | validé le 2026-10-24 |
2026-10-23 21:52:08 +02:00
| | **VI. Données en masse et boucle Claude** | | | |
| 27 | Premier pompage (option A) | Lancer | — | fait le 2026-10-26 : identique aux exports reçus ; à valider par l'utilisateur |
| 28 | Images différentielles | Lancer, Comprendre | 27 | en cours : NORDEND en a, à regarder avec l'utilisateur |
2026-10-23 21:52:08 +02:00
| 29 | Options B (depuis WSL) et C (route du collègue) | Décider | 27 | en attente |
| 30 | L'outil de tri en lot | Coder | 6, 27 | validé le 2026-10-24 |
| 31 | La boucle Claude, première séance | Lancer, Coder | 30 | construite (D-057), fonctionnement validé le 2026-10-24 ; séance par l'utilisateur, plus tard |
| 32 | Le test « Claude verrait la même chose » | Lancer | 10 | en attente (autre conversation) |
| 42 | Aiguiser la lecture : les outils de lecture de Claude | Décider, Coder | 31 | construit (D-059), essai fait le 2026-10-24 ; séance par l'utilisateur |
| 43 | Une base locale complète et incrémentale, pilotée par Claude | Décider, Coder | 27, 33 | codé le 2026-10-24, lancé le 2026-10-26 avec le point 27 ; `data/` hors de git, repompage à lancer (D-065) |
| 44 | Un modèle appris à côté de la boucle | Décider, Coder | 31 | étiquettes à chaque lot faites le 2026-10-25 (D-061) ; modèle plus tard |
| 45 | Le but de la boucle : chaque instant étiqueté, la précision mesurée | Décider, Coder | 31, 44 | score codé le 2026-10-25 (D-062) ; à juger à la première séance |
| 46 | La page de fin de séance : l'analyste face aux détecteurs | Coder | 31, 45 | codé le 2026-10-26 (D-066) ; à regarder après la prochaine séance |
| 47 | Les détecteurs doivent tout détecter ; l'affichage à part | Décider, Coder | 13, 41, 45 | règle posée le 2026-10-26 (D-068) ; détecteurs à changer par la boucle ; couche d'affichage à faire |
| 48 | Un benchmark des détecteurs sur la base d'events | Décider, Coder | 45, 46 | construit le 2026-10-26 (D-069) ; étiquettes de E-001 à E-005 à relire par l'utilisateur |
2026-10-23 21:52:08 +02:00
| | **VII. Idées gardées pour plus tard** | | | |
| 33 | Les autres métriques de certains projets | Comprendre | 27 | en attente |
| 34 | Météo et HDF5 pour dire la cause | Comprendre | 27 | en attente |
| 35 | Un event de la base par catégorie | Lancer | 5 | en attente |
2026-10-23 21:52:08 +02:00
| 36 | Porter le journal dans la vraie application | Coder | 10 | en attente |
| 49 | Le graphe des éventualités du terrain et deux catégories nouvelles | Décider, Coder | 5 | catégories (D-074) dans la carte, l'analyste et les détecteurs le 2026-10-27 ; à entraîner par `/boucle` |
| 50 | Une ligne Status : la compilation de tous les détecteurs | Décider, Coder | 47, 49 | ligne Status dans `detecteurs.py` le 2026-10-27, refaite le même jour : ce qui se passe, l'événement qui englobe ; ordre des catégories à confirmer |
| 51 | Un analyste qui progresse de séance en séance | Décider | 45, 48 | idée du 2026-10-28 ; compilation dans `events/` (l'utilisateur), la carte apprend à chaque validation (D-087) ; l'analyste consulte la base quand il veut (D-088) ; pas de mesure ; écart E-011 ouvert |
| 52 | Un upgrader et un validateur qui ne laissent pas dériver les détecteurs | Essayer | 51 | `detectors-upgrader` et `detectors-control` (D-089, 2026-10-29) ; à essayer sur une séance |
| 53 | Un agent, une responsabilité : l'analyste lit, un autre critique les détecteurs | Essayer | 51, 52 | `analyser-lot` et `detectors-critic` (D-090, 2026-10-29) ; à essayer sur une séance |
| 54 | Le builder devient `event-builder` | Essayer | 53 | appelé à chaque lot, décide seul ce qui est nouveau, bornes de l'événement (D-091) ; à essayer sur une séance |
| 55 | `/boucle` devient `events-learner` ; l'orchestrateur | Essayer | 54 | renommé, benchmark de fin sur les mêmes events, spec réduite (D-092) ; première séance à faire |
| 56 | `/aiguiser` fondu dans `/events-learner` : l'analyste crée ses outils, un `tool-builder` les fait entrer | Essayer | 52, 53, 55 | `/aiguiser` retiré, `tool-builder` sans retrait ni contrôle (D-097, 2026-10-29) ; à essayer sur une séance |
2026-10-23 21:52:08 +02:00
| | **VIII. Suivi du chantier** | | | |
2026-10-24 15:14:14 +02:00
| 37 | Ménage : commit, `CLAUDE.md`, Mermaid, sorties | Lancer | — | validé le 2026-10-24 |
| | **IX. Dire la cause : l'analyste d'abord, les détecteurs ensuite** | | | |
| 57 | La cause plutôt que l'événement : l'ordre du chantier | Décider | — | idée du 2026-10-29 ; déroulé proposé, à valider |
| 58 | Les trois effets thermiques et leurs temps de chauffe | Décider | 57 | savoir de l'utilisateur noté ici ; trois questions |
| 59 | Les températures de la station dans les outils de lecture, par `/aiguiser` | Décider, Coder, Lancer | 58 (56 ?) | trois questions |
| 60 | Des cas thermiques construits et validés | Lancer, Décider | 58, 59 | à faire |
| 61 | Heat haze : quand il y en a, quand il n'y en a pas | Décider | 58 | à faire |
| 62 | Visibilité réduite ou cible masquée | Décider | 63 | deux voies ; recommandation : regrouper sans qualité |
| 63 | Les métriques de qualité : quelles stations, et la qualité recalculée | Décider | — | choix de l'utilisateur attendu |
| 64 | Les sauts : dire pourquoi | Décider, Coder | 57 | à faire |
| 65 | Un saut marqué dès son début | Coder | — | à faire (détail) |
| 66 | Client et spécialiste : la complexité sur demande | Décider | 58, 62, 64 | idée gardée |
| 67 | Le savoir métier de l'analyste : le mécanisme, sans plus de pages | Décider | 57 | idée du 2026-10-29 ; trois questions |
| 68 | L'expert étiquette lui-même : un outil web | Décider, Coder | — | construit le 2026-10-30 (D-098), `labeling/` ; à essayer par l'utilisateur |
| 69 | Apprendre des étiquettes de l'expert : `/labels-learner` | Décider, Coder | 67, 68 | `/labels-learner` construit le 2026-11-02 (D-099) ; premier essai, sur la perte de référence, à lancer par l'utilisateur |
| 70 | Des étiquettes proposées par l'analyste, vérifiées par l'expert | Décider, Coder | 48, 68, 69 | 2026-11-02 : les étiquettes d'abord, base de connaissance (D-100) ; étiquettes des events validés en cours |
| 71 | Un intégrateur : ce que deviennent les étiquettes | Décider, Coder | 69, 70 | 2026-11-02 : la carte des étiquettes, `/labels-map` (D-104), premier passage ; puis les étiquettes automatiques |
| 72 | `/events-learner` sur les étiquettes de l'étiqueteur | Coder, Essayer | 55, 71 | adapté le 2026-11-02 (D-112) ; première séance à lancer par l'utilisateur sur un lot étiqueté |
| 73 | Revue des étiquettes de l'étiqueteur par l'analyste | Essayer, Coder | 71 | 2026-11-05 : toutes les stations revues, un analyste chacune, sans validation de l'expert (D-130) ; le relecteur améliore, il ne refait pas l'étiquetage (D-128) |
| 74 | Revue croisée des étiquettes automatiques, toutes stations | Décider, Coder | 73 | 2026-11-05 : faite, un analyste par famille, puis finition ; skill `/cross-review-labels` (D-130) |
| 75 | Toute la connaissance du labeling dans `labeling/` | Décider, Coder | 73, 74 | 2026-11-05 : règles, familles, `connaissances/`, carte refaite avec les events et les cas (D-130) |
| 76 | Les métriques de qualité d'image dans l'étiquetage | Coder, Essayer | 73 | 2026-11-04 : outil `qualite.py`, LENZSPITZE d'octobre relue (D-129) ; leçons dans la consigne de l'étiqueteur ; restent la carte, `quality/` des anciennes caméras |
2026-10-23 21:52:08 +02:00
2026-10-24 08:24:30 +02:00
Chemins conseillés : le plus simple et le plus parlant d'abord, **11 (visibilité simple), 38 (ses statuts : bonne, moyenne, nulle) puis 7 (bouton `Images`)**, qui marchent sans le classement ; le cœur du retour, c'est **5 → 6 → 7 → 8 → 9 → 10** ; les points 1 à 4 se lisent avant si l'on veut d'abord tout comprendre ; le point 27 se lance en parallèle (il n'attend rien).
2026-10-23 21:52:08 +02:00
---
## Partie I — Comprendre ce qui a été fait
### Point 1 : Visite guidée de l'onglet Journal v0
**Pourquoi.** L'utilisateur ne peut pas tout ingérer d'un coup : ce point lui montre la page, élément par élément, sur les six jeux, avant toute modification.
**Ce qui existe.**
- Onglet `Journal`, sixième onglet de la maquette Explore (après `Displacements`), ouvert par `#tab=journal` ; vue de départ : les 3 derniers jours ; `#from=AAAA-MM-JJ` part d'un autre jour.
- De haut en bas :
- deux courbes, `Horizontal (px)` = `corr_x` et `Vertical (px)` = `corr_y`, cibles seules (`target` et `ref`, pas les `global_ref`), une couleur par cible, ordonnée recalée sur la plage visible (D-013) ;
- les zones grisées : un rectangle par épisode `ignore` ;
- la frise : une ligne par détecteur, une barre par épisode, label dedans s'il tient, survol = texte et capteurs ; couleurs fixes (`J_COLORS` : bleu visibilité, rouge sauts, orange turbulence, vert cycle thermique, gris trous) ;
- le journal en texte : les épisodes de la plage visible, dans l'ordre du temps, mis à jour au zoom ; clic = zoom sur l'épisode (marge : la moitié de sa durée, 2 h au moins).
- Code : `vues-deplacements/maquette/explore.py` (`journal()` l. 172-185, `COLUMNS` avec `corr_x`, `corr_y`) ; `vues-deplacements/maquette/explore_template.html` (CSS l. ~125, bouton l. ~177, volet `#journal` l. ~254, JS `J_NAMES`, `J_COLORS`, `drawJournal()` à partir de la l. ~914).
- Captures du 2026-10-23 : NORDEND d'octobre (cas `vues-deplacements/cas/2026-10_NORDEND/NORDEND/`), PS des Coudres, NORDEND de juillet, WILDSTRUBEL, CLARIDEN, NIEDERHORN (`data/<STATION>/`).
**Étapes.**
- [x] Construire la page sans l'ouvrir pour chaque jeu (commande en annexe B, « Construire »), puis la capturer (annexe B, « Capturer ») avec `#tab=journal`, et `#tab=journal&from=<premier jour>` pour la période entière.
- [x] Montrer à l'utilisateur, jeu par jeu, une capture et trois phrases : ce qui est grisé, pourquoi (détecteur et cas), ce qui est juste ou faux face à la vérité du point 10.
- [x] Noter ses réactions dans `vues-deplacements/contexte/journal-du-matin.md`, section « Retours », datée.
2026-10-23 21:52:08 +02:00
**Vérifier.** Six captures lues ; aucune n'est blanche ni en erreur (un détecteur qui plante est sauté avec un message sur stderr : le lire).
**Fini quand.** L'utilisateur a vu les six jeux et ses retours sont notés.
### Point 2 : Les cinq détecteurs en un coup d'œil
**Pourquoi.** Savoir ce que chaque détecteur regarde, ce qu'il trouve sur les events et où il se trompe, avant d'en régler un (points 11 à 15).
2026-10-23 21:52:08 +02:00
**Ce qui existe** (méthode et résultats complets dans la docstring de chaque fichier ; résumé des rapports en annexe A).
| Détecteur | Regarde | Sort | Grisé | Bon sur | Se trompe sur |
|---|---|---|---|---|---|
| `visibilite.py` (158 l) | `error_value` relative au capteur (> médiane + 10 MAD et > 2 × médiane) | `Poor visibility`, `Brief obstruction`, `Target obscured` | toujours | E-001 buée, E-002 toile, E-005 pluie, trains, feuilles, NORDEND 09/10 | `Target obscured` bruité à NORDEND (CTR01, PR04, PR09) ; train du 03/10 10:00 manqué (2 cibles) ; 2 obstructions de WILDSTRUBEL probablement fausses |
| `sauts.py` (117 l) | `corr_x`, `corr_y` des cibles : un pas à ≥ 20 bruits du niveau des 4 mesures d'avant | `Sudden jump, back to normal`, `Lasting shift`, `Jump, not back yet` | seulement « back to normal » | E-002, E-003 (le saut d'un pas du 04/09), E-004 non grisé, NORDEND PR17 | trains de NIEDERHORN (1 cible sur 3, et celui de la première mesure) ; une cible seule de CLARIDEN en « Lasting shift » |
2026-10-23 21:52:08 +02:00
| `thermique.py` (128 l) | profil horaire de `corr` sur les jours, répétabilité | `Daily thermal cycle`, un par jour complet | jamais | PS des Coudres (08:00-18:00) | rien ailleurs : la compensation enlève le cycle (point 13) |
| `turbulence.py` (106 l) | agitation d'une mesure à l'autre **et** `error_value`, face au calme du capteur | `Heat shimmer` | si agitation ≥ 2× | E-003 (04:00-15:00, les trois jours) | rien ailleurs ; marge faible sur le matin de CLARIDEN (point 14) |
2026-10-23 21:52:08 +02:00
| `trous.py` (37 l) | cadence de l'export | `No data` | jamais | NORDEND 15/10 22:30 → 16/10 01:15 | — |
- Chargement : `explore.py` charge tous les `detectors/*.py` qui ont `detect` (un fichier sans `detect` est ignoré ; un détecteur qui plante est sauté avec un message).
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Lancer chaque détecteur seul sur un jeu qu'il connaît bien (`python3 detectors/<nom>.py <dossier>`) et montrer sa sortie à l'utilisateur, une ligne par épisode.
- [x] Pour chaque détecteur, lui dire en une phrase ce qu'il regarde et la principale erreur connue (tableau ci-dessus).
2026-10-23 21:52:08 +02:00
**Fini quand.** L'utilisateur sait quel point de la partie III ouvrir pour chaque défaut qu'il voit.
### Point 3 : La carte des événements, à valider par l'expert
**Pourquoi.** L'utilisateur l'a demandée (« il n'y a pas 36 000 options ») : c'est la liste des catégories du journal catégorique (point 5). L'expert, c'est l'utilisateur : il valide chaque ligne.
**Ce qui existe.** `events/carte-des-evenements.md` (72 l) :
2026-10-23 21:52:08 +02:00
- 12 événements : 9 à ignorer (trou de données, pluie / brume / buée, neige, passage, feuilles / plante, références masquées, cycle thermique, turbulence, éclairage / voisin brillant) et 3 à regarder (tout a bougé et reste décalé, une cible a sauté, dérive lente), chacun avec label anglais, phrase au client, signature, cas ou source, détecteur ;
- un arbre Mermaid de 6 questions (mesures manquantes ? `error_value` au-dessus du seuil ? chaque jour aux mêmes heures ? le décalage reste ? une cible ou beaucoup ? références touchées ? durée ?) ;
- 5 lacunes : la cause d'une mauvaise visibilité (météo ou image), les obstructions lentes et contrastes faibles (HDF5), la dérive lente absente du journal, « références masquées » contre « tout a bougé » (Barcelone), la cause d'une cible qui saute.
- Doutes de l'agent : neige, dérive lente, cible qui saute et voisin brillant n'ont aucun event dans la base ; les trains peuvent être un effet optique ou un vrai fléchissement du rail (à revoir par l'expert) ; les seuils « beaucoup », « quelques heures », « des jours » sont à fixer.
2026-10-23 21:52:08 +02:00
- Le diagramme n'a jamais été rendu (pas de `mmdc` ici).
- Écart avec la carte : la carte classe le cycle thermique « à ignorer », le détecteur `thermique` le laisse non grisé (normal). À trancher au point 5.
**Étapes.**
- [x] Rendre le Mermaid (aperçu Markdown de VS Code, ou mermaid.live en collant le bloc) et corriger la syntaxe s'il ne s'affiche pas. Fait le 2026-10-24 (mermaid 10.9.1 dans Chrome headless) : rendu sans erreur, rien à corriger.
- [x] Compléter la carte (consigne de l'utilisateur, 2026-10-24) : tout ce qui peut arriver, vu ou non, en familles ; fait le 2026-10-24 : 33 événements en six familles (pas de mesure, vue gênée, cible changée, références, caméra et support, ouvrage qui bouge), les nouveaux marqués « hypothétique » ; l'arbre Mermaid ne range encore que les 12 premiers.
- [x] Passer le tableau ligne par ligne avec l'utilisateur : label, phrase, à ignorer ou non ; noter ses corrections dans le fichier. Validé en bloc comme base le 2026-10-24, sans correction.
- [x] Poser la question des trains (effet optique ou rail qui fléchit) et noter la réponse. Posée le 2026-10-24 ; la carte garde les deux possibilités (« Passage », « Fléchissement sous une charge ») ; le classement des trains de E-005 reste à trancher au point 5.
- [x] Ajouter en tête du fichier : « Validé par l'utilisateur le <date> » pour les lignes validées.
2026-10-23 21:52:08 +02:00
**Fini quand.** Chaque ligne est validée ou corrigée par l'utilisateur.
### Point 4 : Le brainstorming, D-056 et ce qui a été écarté
**Pourquoi.** Tout ce qui a été dit le 2026-10-23 est dans un document ; ce point le relit avec l'utilisateur pour qu'il complète ce qui manque.
**Ce qui existe.**
- `vues-deplacements/contexte/journal-du-matin.md` : le constat (projet éparpillé, retour au simple, côté support), l'idée (le journal du matin), les pistes par agent, les données et la boucle, où l'on travaille (Support-Agent, pas le dev container), la façon de travailler, les idées gardées, et le retour de l'utilisateur sur la v0.
- `docs/decisions.md`, D-056 : anomalie = moment où ne pas se fier aux données ; onglet `Journal` ; un détecteur par fichier ; prototypé dans Support-Agent ; écartés pour l'instant : le lissage et un LLM au chargement de la page ; précision : diagnostic catégorique.
- Un agent a été envisagé puis non lancé pour le volet « interpréter sans toucher aux données » : c'est ce que font les détecteurs et la page.
**Étapes.**
- [x] Lire le document avec l'utilisateur, section par section ; ajouter ce qu'il dit en plus. Fait le 2026-10-24 ; ajout : la définition de l'anomalie (précision de D-056).
2026-10-23 21:52:08 +02:00
**Fini quand.** L'utilisateur reconnaît son brainstorming dans le document.
---
## Partie II — Le journal catégorique (le cœur du retour)
Le retour de l'utilisateur, en une phrase : **un événement → sa catégorie → le processus de la catégorie**. Exemple de référence : NORDEND, le 14/10 vers 05:15, 11 cibles font un aller-retour de près de 0,5 px en quelques heures ; au même moment, 22 capteurs, références comprises, sont mal vus (taches pâles à l'aube). Aujourd'hui la page dit « Sudden jump, back to normal … most likely a measurement artefact » **et** « Poor visibility … probably rain, fog… ». Demain elle doit dire une seule chose, catégorique : *Loss of visibility*, la zone est invalidée, le saut n'est pas un mouvement, et voici les images où l'on ne distingue pas les cibles.
2026-10-24 08:24:30 +02:00
Précision de l'utilisateur, le même soir : le gros saut, c'est généralement une mauvaise visibilité ; la visibilité se calcule simplement (le taux d'erreur des cibles, une par une ou en moyenne) ; quand elle est mauvaise, on le dit, et un bouton `Images` sur l'épisode ouvre une petite vidéo (timelapse) qui commence un peu avant et finit un peu après : le client voit tout de suite. D'où les points 11 (visibilité simple) et 7 (le bouton).
2026-10-23 21:52:08 +02:00
### Point 5 : Les catégories et leurs processus
**Pourquoi.** Le classement (point 6), les images (point 7) et la page (point 8) en dépendent. C'est une décision de l'utilisateur, sur proposition.
**Proposition à valider** (tirée de la carte, réduite à ce que les détecteurs attrapent aujourd'hui ; les autres lignes de la carte viennent au point 16).
| Clé | Label du site | Familles de la carte | Épisodes qui la font | Zone | Processus |
|---|---|---|---|---|---|
2026-10-24 08:24:30 +02:00
| `visibilite_perdue` | Loss of visibility | pluie, brume, buée, neige, références masquées | `visibilite` « Poor visibility » | invalidée | bouton `Images` (point 7) ; deux niveaux possibles (point 38) |
| `passage` | Passing obstacle | passage (train, véhicule) | `visibilite` « Brief obstruction » | invalidée (l'instant) | bouton `Images` (point 7) |
| `cible_masquee` | Target hidden | feuilles, plante, neige sur une cible, éclairage | `visibilite` « Target obscured » | invalidée pour ces cibles seulement (point 18) | bouton `Images` (point 7) |
2026-10-23 21:52:08 +02:00
| `turbulence` | Heat haze | turbulence | `turbulence` | invalidée si forte | aucune image ; une phrase |
| `cycle_thermique` | Daily thermal cycle | cycle thermique | `thermique` | **gardée** (normal) | aucun ; une phrase |
| `trou` | No data | trou de données | `trous` | rien à griser (pas de point) | aucun |
2026-10-24 08:24:30 +02:00
| `saut_bref` | Brief jump | saut sans autre explication | `sauts` « back to normal » seul | invalidée | bouton `Images` (point 7) |
| `a_verifier` | Shift to check | tout a bougé, une cible a sauté | `sauts` « Lasting shift » ou « Jump, not back yet » | **gardée, jamais invalidée** | bouton `Images` (point 7) et un lien vers `Diagnosis` |
2026-10-23 21:52:08 +02:00
**Règles de regroupement proposées** (appliquées au point 6) :
- un épisode `sauts` « back to normal » qui chevauche un épisode `visibilite` ou `turbulence` est **absorbé** : il n'est plus un événement, la phrase de l'événement dit que le saut de N cibles dans cette période n'est pas un mouvement ;
- un épisode `sauts` durable ou récent n'est **jamais** absorbé : il reste un événement `a_verifier`, même au milieu d'une perte de visibilité (PR17 le 08/10 à 02:30, dans la buée) ;
- deux événements de même catégorie à moins d'une heure l'un de l'autre n'en font qu'un.
**À décider par l'utilisateur.**
- [x] Les huit catégories : à garder, fusionner, renommer ?
- [x] Le cycle thermique : « normal, gardé » (détecteur) ou « à ignorer » (carte) ?
- [x] `saut_bref` : une catégorie à part, ou toujours « Loss of visibility » quand il y a des rejets autour ?
- [x] Une reprise de saut pendant une perte de visibilité (E-002, le 31/07 à 20:30, 13 cibles, une heure avant la fin des données) : `a_verifier` ou absorbée ?
- [x] Le processus de chaque catégorie : le bouton `Images`, oui ou non.
- [x] La perte de visibilité en deux niveaux, « Reduced visibility » (données moyennes) et « No visibility » (on ne voit rien) : point 38.
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Présenter le tableau et les règles ; noter les réponses.
- [x] Écrire le tableau validé dans `events/carte-des-evenements.md`, nouvelle section « 4. Catégories du journal et processus », en reliant chaque catégorie aux lignes de la section 1.
- [x] Ajouter la décision sous D-056 (« Catégories du journal, validées le <date> »).
**Décidé le 2026-10-24** : les huit catégories, les règles et les sept recommandations, telles quelles : catégories gardées, « No data » partout ; cycle thermique pas grisé ; `saut_bref` à part ; reprise de E-002 en `a_verifier` ; bouton `Images` sauf turbulence, cycle thermique et trou ; deux niveaux de visibilité sur le principe (point 38) ; trains de E-005 en `passage`. Écrit dans la carte, section 4, et sous D-056. **Point 38 (2026-10-24)** : `visibilite_perdue` devient `visibilite_reduite` (Reduced visibility, en retrait) et `visibilite_nulle` (No visibility, grisée). **Point 41 (2026-10-24)** : `cycle_thermique` devient `dilatation_thermique` (Thermal expansion) et `contraction_thermique` (Thermal contraction), non grisées.
2026-10-23 21:52:08 +02:00
**Fini quand.** Le tableau est validé et écrit ; c'est l'entrée du point 6.
### Point 6 : Le classement : des épisodes aux événements catégorisés
**Pourquoi.** Une seule étiquette par moment, la catégorie et non le nom du détecteur.
**Fichiers.**
- Créer : `detectors/categories.py` (pas de fonction `detect` : le chargeur l'ignore comme détecteur).
2026-10-23 21:52:08 +02:00
- Modifier : `vues-deplacements/maquette/explore.py` (`journal()` l. 172-185 déménage dans `categories.py` ; `build()` appelle `categories.evenements(mesures)`).
**Interfaces.**
2026-10-24 08:24:30 +02:00
- `CATEGORIES: dict[str, dict]` : clé → `{"label": str, "ignore": bool, "process": "images" | "aucun" | "verifier", "ordre": int}`, recopié du tableau validé au point 5.
- `detecteurs() -> list[module]` : les modules de `detectors/*.py` qui ont `detect` (le code actuel de `explore.journal`, déplacé tel quel).
2026-10-23 21:52:08 +02:00
- `classer(episodes: list[dict], references: set[str]) -> list[dict]` : événements triés par `start`, chacun `{"start", "end", "category", "label", "text", "ignore", "sensors", "process", "episodes": [épisodes absorbés ou d'origine]}` ; `references` = capteurs `global_ref` (pour la phrase : « including the reference points »).
- `evenements(mesures) -> list[dict]` : `classer` appliqué aux épisodes de tous les détecteurs ; c'est ce que la page reçoit dans `D.journal`.
- `__main__` : `python3 detectors/categories.py <dossier>` imprime une ligne par événement : début, fin, catégorie, grisé ou non, nombre de capteurs, nombre d'épisodes absorbés. C'est aussi l'outil de tri du point 30.
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Écrire `CATEGORIES` depuis le tableau du point 5 et la table de correspondance (`kind`, `label` du détecteur) → catégorie.
- [x] Déplacer le chargement de `explore.journal()` dans `categories.detecteurs()` ; `explore.build()` met `categories.evenements(mesures)` dans `D.journal` ; garder les épisodes bruts dans `D.episodes` pour la couche support (point 23).
- [x] Écrire `classer` : correspondance, puis absorption (chevauchement dans le temps), puis fusion des voisins de même catégorie (< 1 h).
- [x] Laisser `text` provisoire (celui de l'épisode principal) : les phrases viennent au point 9.
- [x] Lancer `python3 detectors/categories.py vues-deplacements/cas/2026-10_NORDEND/NORDEND` : le 14/10 à 05:15, une seule ligne `visibilite_perdue` avec un épisode `sauts` absorbé ; le 08/10 à 02:30, une ligne `a_verifier` (PR17), à part.
- [x] Lancer sur `data/CLARIDEN` : le 19/09 à 06:10, `a_verifier`, non grisé.
2026-10-23 21:52:08 +02:00
**Fini quand.** Les deux contrôles ci-dessus passent ; la page se construit encore (annexe B).
**Fait le 2026-10-24.** `categories.py` écrit, `explore.py` et la frise du gabarit passés aux catégories (une ligne et une couleur par catégorie). Les deux contrôles passent ; les six jeux se classent (NORDEND d'octobre : 15 événements, 7 sauts absorbés). Écarts à l'interface, tranchés en route :
- `ordre` retiré de `CATEGORIES` : l'ordre du dictionnaire est celui de la frise ;
- `classer(episodes)` sans `references` : le texte reste provisoire, le point 9 ajoutera le paramètre s'il lui sert ;
- pas de `D.episodes` : chaque événement porte ses épisodes d'origine (`D.journal[i].episodes`), ce que lit le point 23 ;
- un passage absorbe aussi un saut revenu (c'est une perte de visibilité d'un instant ; le point 10 l'attend à NIEDERHORN le 01/10 à 12:00) : règle précisée dans la carte, section 4 ;
- un détecteur inconnu garde son nom comme catégorie, sans planter.
Restent, comme prévu, pour d'autres points : « Target hidden » grise toutes les courbes et chevauche les pertes de visibilité (NORDEND du 13/10 09:45 au 14/10 07:00 : points 11 et 18) ; à NORDEND de juillet (E-002), « Shift to check » et « Loss of visibility » au même moment le 31/07 à 20:30 (voulu par la règle du point 5) ; l'échelle de CLARIDEN écrasée par une cible à 11 px (point 19).
2026-10-24 08:24:30 +02:00
### Point 7 : Le bouton `Images` : la vidéo de l'épisode
2026-10-23 21:52:08 +02:00
2026-10-24 08:24:30 +02:00
**Pourquoi.** Retour de l'utilisateur (2026-10-23) : « comment est-ce qu'on fait pour prouver, montrer au client qu'il y a une mauvaise visibilité ? Une petite vidéo. » Le gros saut qui monte et redescend, c'est généralement une mauvaise visibilité : souvent, pendant plusieurs heures, on ne voit rien. On le dit, et sur l'épisode un bouton ouvre le timelapse des images de la plage, **un peu avant et un peu après**, pour encadrer l'épisode par des moments où tout va bien : le client voit les cibles nettes, puis plus rien, puis nettes à nouveau, et comprend tout de suite que l'anomalie est une mauvaise visibilité. C'est l'idée des petits GIF du brainstorming.
2026-10-23 21:52:08 +02:00
**Ce qui existe.**
2026-10-24 08:24:30 +02:00
- `D.images` : `[{t, src}]`, toutes les images du dossier avec leur heure UTC (déjà dans la page, pour l'onglet View) ; `D.view` : le cadre des capteurs dans l'image (± 150 px) ; l'onglet View sait déjà afficher une image, zoomer sur les cibles, jouer un film (`▶ Play`, 2, 4 ou 8 images par seconde) et dessiner les cercles colorés selon `error_value`.
- `agent-tools/vignettes.py` : grille PNG de vignettes (capteurs × heures), pour l'agent et les fiches d'events ; pas pour la page.
2026-10-23 21:52:08 +02:00
- Images disponibles : NORDEND d'octobre au pas de 15 min (985 images) ; NORDEND de juillet, WILDSTRUBEL, CLARIDEN à 10 min ; NIEDERHORN horaire ; PS des Coudres 24 images horaires (13/10 12:00 → 14/10 11:00).
2026-10-24 08:24:30 +02:00
**Décisions prises ici.**
- Un bouton `▶ Images` sur chaque entrée du journal qui a des images à montrer (perte de visibilité, saut bref, passage, cible masquée) ; un clic ouvre une fenêtre par-dessus la page qui joue le timelapse ; Échap ou un clic à côté la ferme.
- Plage : du début de l'épisode moins une marge à sa fin plus la marge ; marge = la moitié de la durée de l'épisode, 1 h au moins, 6 h au plus (à régler à l'œil avec l'utilisateur).
- Le timelapse : images recadrées sur le cadre des cibles (`D.view`, comme le zoom « Targets » de View), 4 images par seconde, en boucle ; sur chaque image, l'heure UTC et un repère `Before` / `During` / `After` (bord rouge pendant l'épisode) ; boutons pause et image par image. Au-delà de 60 images, on n'en garde qu'une sur deux, une sur trois…
- Pas de fichier GIF : le timelapse est joué dans la page en JS, rien à fabriquer ni à installer (Pillow n'est pas installé). Un vrai GIF ne viendra que si la vraie application en a besoin (point 36).
- Pas d'image dans la plage : le bouton est grisé, avec « No camera image for this period. »
- **Ce point ne dépend pas du classement** (point 6) : il marche dès aujourd'hui sur les épisodes `ignore` des détecteurs ; après le point 6, sur les événements.
2026-10-23 21:52:08 +02:00
2026-10-24 08:24:30 +02:00
**Fichiers.** Modifier `vues-deplacements/maquette/explore_template.html` (volet `#journal`, CSS et JS du journal) ; `vues-deplacements/maquette/spec.md` (section « L'onglet Journal »).
2026-10-23 21:52:08 +02:00
**Interfaces.**
2026-10-24 08:24:30 +02:00
- Consomme : une entrée du journal (`start`, `end`, `ignore`, et `process` après le point 6) ; `D.images`, `D.view`.
- Produit : en JS, `jFrames(ev) -> [{t, src, role}]` (`role` : `"before"`, `"during"` ou `"after"`) et `openTimelapse(ev)`, qui ouvre la fenêtre.
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Écrire `jFrames` (plage avec marge, une image sur n au-delà de 60) et `openTimelapse` (fenêtre, lecture en boucle à 4 images par seconde, pause, image par image, Échap).
- [x] Ajouter le bouton `▶ Images` aux entrées du journal (et au clic sur la barre de la frise, si c'est simple) ; grisé sans image.
- [x] Lire `#tab=journal&play=<n>` dans l'adresse pour ouvrir le timelapse de l'entrée n dès le chargement (pour les captures).
- [x] Contrôle : NORDEND d'octobre, le 14/10 vers 05:15 : le timelapse montre les cibles nettes avant, les taches pâles pendant, nettes après ; capture de la fenêtre ouverte.
- [x] Contrôle du point d'attention 4 : PS des Coudres le 13/10 à 01:15 (`#tab=journal&from=2026-10-12`) : bouton grisé, « No camera image for this period. »
- [x] Montrer à l'utilisateur ; régler la marge et la vitesse à son œil ; mettre la spec à jour. Marge (1 à 6 h) et vitesse (4 images par seconde) gardées telles quelles par l'utilisateur le 2026-10-24.
2026-10-23 21:52:08 +02:00
2026-10-24 08:24:30 +02:00
**Fini quand.** En cliquant sur `▶ Images` le 14/10 à NORDEND, l'utilisateur voit tout de suite que le saut est une perte de visibilité.
2026-10-23 21:52:08 +02:00
**Fait le 2026-10-24.** Bouton et fenêtre dans `explore_template.html`, aussi au clic sur une barre de la frise ; `&frame=<k>` en plus de `&play=<n>` pour capturer une image donnée. Contrôles passés : à NORDEND le 14/10 (événement n° 12), 14 images de 04:15 à 07:30 : cibles nettes la nuit à 04:30, voile gris et cibles pâles à l'aube à 05:45 (bord rouge), paroi et cibles nettes au jour à 07:15 ; à PS des Coudres, la nuit du 13/10 a son bouton grisé et « No camera image for this period. », celle du 13 au 14/10 a le sien actif. Marge et vitesse gardées par l'utilisateur.
2026-10-23 21:52:08 +02:00
### Point 8 : La page Journal, catégorique et plus simple
**Pourquoi.** « Encore plus simple » : une seule ligne d'événements, la catégorie dans la barre, et le journal comme une suite de verdicts.
**Fichiers.** Modifier `vues-deplacements/maquette/explore_template.html` (volet `#journal`, `drawJournal`) ; `vues-deplacements/maquette/spec.md` (section « L'onglet Journal »).
**Décisions prises ici.**
- La frise passe d'une ligne par détecteur à **une seule ligne**, « What happened », une barre par événement, colorée par famille : gris-bleu pour ce qui est invalidé, vert pour ce qui est normal, rouge pour ce qui est à vérifier, gris clair pour l'absence de données.
- Le journal devient une suite de cartes : date et heures, **catégorie en gras**, la phrase (point 9), la bande d'images (point 7) quand la catégorie en a une.
- Les lignes par détecteur ne disparaissent pas : elles passent dans la couche support (point 23).
**Étapes.**
- [x] Remplacer les lignes par détecteur de la frise par la ligne unique ; couleurs par famille (`ignore` vrai, normal, à vérifier, pas de données) au lieu de `J_COLORS`.
- [x] Mettre le journal en cartes, comme ci-dessus ; garder le clic qui zoome.
- [x] Mettre à jour la spec : section « L'onglet Journal » réécrite, ce qui est vérifié et ce qui ne l'est pas.
- [x] Capturer NORDEND d'octobre et WILDSTRUBEL ; les montrer à l'utilisateur.
2026-10-23 21:52:08 +02:00
**Fini quand.** L'utilisateur juge la page assez simple, ou ses retours sont notés pour une passe suivante.
**Fait le 2026-10-24.** Frise d'une seule ligne « What happened », couleurs par famille ; journal en cartes (date, catégorie en gras, texte, `▶ Images`), sans la liste des capteurs. Écart trouvé à la capture et tranché : sur une seule ligne, des événements simultanés se recouvrent (WILDSTRUBEL : turbulence et cible masquée le même matin, étiquettes mêlées) ; les barres sont donc dessinées par portée (`J_ORDER` : une cible en dessous, toute la scène au-dessus, « Shift to check » en haut), et une barre perd son étiquette quand une barre du dessus couvre son milieu. **Validé le 2026-10-24**, l'utilisateur « pas entièrement satisfait » : on pourrait déplier au lieu de tout mettre sur une même ligne (point 40). Limite connue : à NORDEND, les deux « Loss of visibility » des 13 et 14/10, courtes, n'ont pas d'étiquette dans la barre longue « Target hidden » qu'elles recouvrent (points 11 et 18).
2026-10-23 21:52:08 +02:00
### Point 9 : Les phrases du journal
**Pourquoi.** « Il faut donner un diagnostic clair, et puis il faut que le diagnostic il soit complet. » Les phrases actuelles hésitent (« most likely », « probably rain, fog… »).
**Modèle.** La section « Verdict » des fiches d'events (`events/E-00x/event.md`), écrites avec l'agent de diagnostic : une phrase, la cause et son niveau de preuve, la conséquence pour l'ouvrage, l'action (E-002 : « Une toile d'araignée devant l'objectif, vue sur les images : l'ouvrage n'a pas bougé et il n'y a rien à faire. »).
2026-10-23 21:52:08 +02:00
**Règle proposée** (concilie le diagnostic catégorique avec la règle du projet de séparer fait et hypothèse) :
- la **catégorie** est un fait observé (les cibles étaient mal vues, un objet est passé, les mesures manquent) : elle se dit sans conditionnel ;
- la **cause** (pluie, brume, toile, train) n'est écrite que si elle est établie ; sinon on ne l'écrit pas : **les images la montrent** ;
- chaque phrase dit aussi **quoi en faire** : « ignore the curves in this period », « nothing to do », « please check ».
**Phrases proposées** (anglais, à valider ; `{…}` est rempli par le code) :
- `visibilite_perdue` : « The camera could not see {n} points clearly{, including the reference points}. The curves in this period are not reliable: ignore them. » + si un saut est absorbé : « The jump of {k} targets in this period is not a movement. »
- `passage` : « Something passed in front of {n} targets at {hh:mm}. Ignore this point on the curves. »
- `cible_masquee` : « {Target} was hidden several times while the targets around it stayed clear. Ignore its curve in this period. »
- `turbulence` : « Warm air made the readings shake from {hh:mm} to {hh:mm}. The small fast wiggles are not movement. »
- `cycle_thermique` : « Daily thermal cycle: the structure and the camera warm up during the day and cool down at night. This wave comes back every day; nothing to do. »
- `trou` : « No measurement in the export for {durée} (usually one every {pas}). »
- `saut_bref` : « {n} targets jumped and came back within {durée}. This is not a movement: ignore it. »
- `a_verifier` : « {n} targets shifted at {hh:mm} and stayed shifted. This can be a real movement: please check it. »
**Étapes.**
- [x] Faire valider ou réécrire les phrases par l'utilisateur.
- [x] Les écrire dans `CATEGORIES` (point 6), remplir `text` dans `classer` ; harmoniser les labels avec la carte (aujourd'hui « Heat shimmer » contre « Heat haze », « No data » contre « Data gap ») : un seul nom par catégorie, celui du point 5.
- [x] Reporter les phrases validées dans `events/carte-des-evenements.md` (colonne « Phrase au client »).
2026-10-23 21:52:08 +02:00
**Fini quand.** Aucune phrase du journal ne contient « probably », « most likely » ou « may ».
**Fait le 2026-10-24.** Phrases proposées, simplifiées (pas d'heures, déjà sur la carte ; « targets » partout ; « Shift to check » sans « this can be ») et validées telles quelles par l'utilisateur ; écrites dans `categories.phrase()` (et non dans `CATEGORIES` : elles se remplissent selon l'événement) ; `classer(episodes, references)` reçoit les `global_ref` ; `sauts.py` ajoute à ses épisodes la clé `lasting` (cibles restées décalées), pour CLARIDEN : « 18 targets shifted; 4 of them stayed shifted » ; pluriel « The jumps of … are not movements » quand plusieurs sauts sont absorbés. Contrôle : sur les six jeux, 46 événements, aucune phrase avec « probably », « most likely » ou « may ». Phrases reportées dans la carte, section 4, colonne « Phrase du journal ». Les labels étaient déjà harmonisés (« Heat haze », « No data » : points 5 et 6).
2026-10-23 21:52:08 +02:00
### Point 10 : Vérifier le journal catégorique sur les six jeux
**Pourquoi.** C'est le contrôle de toute la partie II, et des points d'attention 1 et 2.
**Attendu** (d'après les rapports des détecteurs du 2026-10-23 et la vérité des events ; à mettre à jour si le point 5 change une règle) :
2026-10-23 21:52:08 +02:00
| Jeu | Événements attendus | Vérité | Obtenu (2026-10-24) |
|---|---|---|---|
| NORDEND octobre (`vues-deplacements/cas/2026-10_NORDEND/NORDEND`) | `visibilite_perdue` 07/10 17:15 → 08/10 12:15 (sauts du 07/10 19:45 et du 08/10 07:15 absorbés) ; `a_verifier` PR17 le 08/10 à 02:30, **à part, non grisé** ; `visibilite_perdue` 09/10 07:45 → 14:00 (saut commun de 08:45 absorbé) et 20:45 → 23:45 (saut de 21:15 absorbé) ; `visibilite_perdue` 14/10 05:15 → 06:30 (saut de 11 cibles absorbé, images de l'aube) ; `trou` 15/10 22:30 → 16/10 01:15 | buée le 08/10, parois ruisselantes le 09/10, 17 rejets à 23:00, taches pâles à l'aube le 14/10 (`parcours.md`) ; PR17 sans explication claire | Tout l'attendu (le saut de PR15 du 08/10 04:45 aussi absorbé). En plus, de `visibilite` : 6 « Target hidden » (CTR01, PR04, PR07, PR09), dont le 13/10 09:45 → 14/10 07:00 qui recouvre la perte de visibilité du 14/10 ; 2 « Passing obstacle » (09/10 18:45, 12/10 14:15) ; une « Loss of visibility » courte (13/10 09:45 → 10:30) → points 11 et 18 |
| E-001 PS des Coudres | `visibilite_perdue` 13/10 23:45 → 14/10 04:45 (2 références) ; aussi 13/10 01:15 → 03:30 (sans image) ; `cycle_thermique` chaque jour complet 08:00 → 18:00 | buée, 2 références sur 3 ; système sain | Conforme |
| E-002 NORDEND juillet | `visibilite_perdue` 28/07 20:45 → 31/07 02:45 (paliers de `sauts` absorbés) ; `a_verifier` le 31/07 à 20:30 (reprise, non absorbée, règle du point 5) | toile d'araignée, vue | Conforme (2 paliers absorbés ; `a_verifier` 31/07 20:30 → 21:30, 13 cibles, non grisé). En plus : « Loss of visibility » 31/07 20:30 → 21:45 (18 capteurs), au même moment, dernière heure de l'export → point 11 |
| E-003 WILDSTRUBEL | `turbulence` les 02, 03 et 04/09, environ 04:00 → 15:00, saut d'un pas du 04/09 06:45 absorbé ; `cible_masquee` PA_9 les matins ; `passage` à 3 instants (2 douteux) | turbulence et plein soleil | Conforme (3 turbulences, saut du 04/09 06:45 absorbé, 3 matins de PA_9, 3 passages) ; sur la frise, la cible masquée est cachée sous la turbulence (point 40) |
| E-004 CLARIDEN | `a_verifier` 19/09 06:10, 18 cibles, **non grisé** ; `a_verifier` une cible le 18/09 15:40 (faux positif connu) ; `passage` 18/09 13:40 et 20/09 06:20 | mouvement réel | Conforme : le 19/09 06:10, « Shift to check », 18 cibles dont 4 restées décalées, **non grisé**. En plus : « Target hidden » PR-284 le 19/09 18:30 → 18:50, qui grise toutes les courbes 20 min, douze heures après le saut → points 11 et 18 ; échelle écrasée par une cible à 11 px (point 19) |
| E-005 NIEDERHORN | `passage` 30/09 22:00, 01/10 12:00 (saut absorbé) et 21:00, 02/10 21:00 ; `visibilite_perdue` 01/10 06:00 → 11:00 et 02/10 03:00 → 11:00 ; `cible_masquee` 02/10 10:00 → 22:00 | 5 trains (celui du 03/10 10:00 manqué), pluie deux nuits, feuilles | Conforme (4 passages, dont le 01/10 12:00 avec son saut absorbé ; 2 pertes de visibilité ; la cible masquée) ; le train du 03/10 10:00 reste manqué ; le 30/09 22:00 n'a pas d'image (elles commencent le 01/10 00:00) |
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Lancer `categories.py` sur les six jeux ; comparer au tableau ; noter chaque écart dans une colonne « Obtenu » ajoutée au tableau, dans ce plan.
- [x] Construire et capturer les six pages ; les montrer à l'utilisateur avec la ligne du tableau.
- [x] Corriger les écarts qui viennent du classement ; ceux qui viennent d'un détecteur vont aux points 11 à 15.
2026-10-23 21:52:08 +02:00
**Fini quand.** CLARIDEN n'est jamais grisé, NORDEND le 14/10 n'a qu'un événement, et l'utilisateur valide les six captures.
**Fait le 2026-10-24.** Aucun écart ne vient du classement : tout l'attendu est là sur les six jeux, et les événements en trop viennent tous de `visibilite` (« Target hidden » trop sensible, un passage et une perte de visibilité en plus), à régler aux points 11 et 18. Les deux contrôles de fin, à la lettre : CLARIDEN, le mouvement du 19/09 n'est pas grisé, mais un « Target hidden » de PR-284 grise toutes les courbes 20 min douze heures plus tard (le point 18 le ramènera à PR-284 seule) ; NORDEND le 14/10, une seule « Loss of visibility », plus de saut contradictoire, mais le long « Target hidden » du 13 au 14/10 couvre le même moment (points 11 et 18). Six captures montrées à l'utilisateur.
2026-10-24 08:24:30 +02:00
### Point 38 : Les statuts de visibilité : bonne, moyenne, nulle
**Pourquoi.** L'utilisateur, le 2026-10-23 : « on peut catégoriser : il y a des events où la visibilité est vraiment affreuse, et des events où elle n'est pas très bonne. Quand il pleut, la visibilité n'est pas très bonne, c'est moyen, les données sont moyennes ; et il y a des moments où vraiment on ne voit rien. » Et : « c'est là où on revient un peu sur les statuts : on veut faire des statuts des cibles. » Comme les statuts des métriques système (Energy, Storage, Cellular, Temperature : vert, orange, rouge), un statut de visibilité, par cible et pour la station. Placé ici, dans la partie II, parce qu'il change la catégorie « perte de visibilité » du point 5.
2026-10-24 08:24:30 +02:00
**Proposition à valider.**
| Statut | Couleur | Ce qu'on voit | Phrase au client (à valider au point 9) | Sur les courbes |
|---|---|---|---|---|
| Good visibility | vert | `error_value` loin du seuil | rien, pas d'entrée au journal | rien |
| Reduced visibility | orange | `error_value` qui approche le seuil, quelques rejets ; la pluie de E-005 (nuits du 01 et du 02/10), sans doute la buée de E-001 | « Visibility was reduced (see images): the data in this period are less precise. » | zone en léger retrait (gris très clair ou hachures), données gardées |
| No visibility | rouge | la plupart des capteurs rejetés : NORDEND le 09/10 à 23:00 (17 capteurs), la toile de E-002 | « The camera could not see the targets: ignore the curves in this period. » | zone grisée |
2026-10-24 08:24:30 +02:00
- **Calcul**, dans l'esprit du point 11 : le rapport `error_value / error_threshold` de chaque cible, et sa moyenne pour la station. La page le colore déjà ainsi dans l'onglet View (`errorColor` dans `explore_template.html` : vert loin du seuil, orange à son approche, rouge au-dessus). Deux limites sur la moyenne (et sur la part de cibles rejetées) séparent les trois statuts.
- **Par cible** : le même statut, cible par cible (une bande par cible dans la couche support, point 23).
- **Statut du jour** : le pire statut tenu au moins une heure dans la journée, comme la couleur du jour des métriques système. C'est ce qu'un bloc `Visibility` pourrait montrer dans la vue client « System Summary » et dans les notifications du support (maquettes, D-039), si l'utilisateur le demande.
- **Effet sur le point 5** : si le tableau est validé, la catégorie `visibilite_perdue` devient deux catégories, `visibilite_reduite` (données gardées, en retrait) et `visibilite_nulle` (invalidée), toutes deux avec le bouton `Images` (point 7).
**À décider par l'utilisateur.**
- [x] Trois statuts, ou plus ?
- [x] « Reduced » : données gardées en retrait, ou invalidées elles aussi ?
- [x] Le statut se montre-t-il comme une bande de couleur continue sous les courbes (plus simple qu'une suite d'épisodes) ?
- [x] Un statut de visibilité du jour dans la vue client et chez le support : maintenant ou plus tard ?
2026-10-24 08:24:30 +02:00
**Fichiers.**
- Modifier : `detectors/visibilite.py` (version simple du point 11) : les épisodes portent un niveau ; contrat d'épisode : champ facultatif `"level": "reduced" | "none"` (les autres détecteurs ne le mettent pas).
2026-10-24 08:24:30 +02:00
- Modifier : `vues-deplacements/maquette/explore_template.html` : une bande de statut sous les courbes du Journal, au-dessus de la frise.
**Étapes.**
- [x] Faire valider le tableau ; reporter le choix au point 5 (catégories) et au point 9 (phrases).
- [x] Dans la version simple de `visibilite.py`, deux limites sur la moyenne, `REDUIT` et `NUL` (provisoires, réglées à l'œil : pluie de E-005 = Reduced, NORDEND le 09/10 à 23:00 = None ; registre du point 17) ; un épisode par période de même statut, avec son `level`.
- [x] Écartée le 2026-10-24 (la frise suffit ; à la place, barre orange et léger retrait pour « Reduced », grisé pour « None »). Texte d'origine : la bande de statut (vert, orange, rouge) sous les courbes du Journal, mesure par mesure ; épisodes `reduced` en léger retrait, `none` grisés.
- [x] Vérifier sur les six jeux et montrer : E-005, les deux nuits de pluie en orange ; E-002, la toile en rouge ; NORDEND le 09/10 à 23:00 en rouge ; E-001 (buée) et E-003 (turbulence) : orange ou rien, à juger par l'utilisateur.
- [x] Reporter les statuts validés dans `events/carte-des-evenements.md` (section 4 du point 5) et sous D-056.
2026-10-24 08:24:30 +02:00
**Fini quand.** L'utilisateur distingue d'un coup d'œil « données moyennes » et « on ne voit rien » sur les six jeux.
**Décidé et fait le 2026-10-24.** Proposition revue après le point 11 (la v0 reste) : la v0 trouve l'épisode, le seuil de la plateforme dit sa gravité, mesure par mesure ; « none » quand au moins la moitié des cibles habituellement vues sont rejetées (`MOITIE`, provisoire), « reduced » sinon. Validé par l'utilisateur avec quatre recommandations : trois statuts ; « Reduced » gardé en léger retrait, barre orange ; pas de bande de statut pour l'instant (la frise suffit ; peut venir avec le point 40) ; statut du jour client et support plus tard. Codé : `visibilite.py` (champ `level`, un épisode par période de même niveau), `categories.py` (`visibilite_reduite`, `visibilite_nulle` ; phrase « Reduced » ; la durée d'un événement et la fusion ne comptent plus les sauts absorbés, qui étiraient « No visibility » le 09/10 jusqu'à 12:45), gabarit (orange, léger retrait). Résultat : NORDEND le 09/10 08:45 → 10:30 et 21:30 → 23:15, le 14/10 05:15 → 06:00 en « No visibility », le reste de ces épisodes en « Reduced » ; buées (NORDEND, E-001), toile (E-002), pluie (E-005) en « Reduced ». Conséquence à connaître : un saut absorbé dans une visibilité réduite n'est plus grisé, seulement en retrait (la phrase dit qu'il n'est pas un mouvement).
2026-10-23 21:52:08 +02:00
---
## Partie III — Les détecteurs, un par un
Chaque point : on le règle sur les events, on relance les six jeux, on met à jour la docstring (méthode et résultats) et le registre du point 17. Ne jamais régler un seuil sur un seul jeu sans relancer les cinq autres.
2026-10-23 21:52:08 +02:00
2026-10-24 08:24:30 +02:00
### Point 11 : `visibilite` : la version simple d'abord
2026-10-23 21:52:08 +02:00
**Pourquoi.** Retour de l'utilisateur (2026-10-23) : la ligne Visibility de la v0 est « super bien », et « c'est facile de calculer la visibilité des cibles : soit individuellement, soit faire la moyenne des visibilités. Et on peut détecter facilement quand les taux d'erreur sont élevés ; dans ces events-là, on indique qu'il y a une mauvaise visibilité ». La guideline est la simplicité. La v0 marche mais a grossi : 11 constantes, médianes et MAD par capteur, trois sorties.
2026-10-23 21:52:08 +02:00
2026-10-24 08:24:30 +02:00
**La version simple, à essayer d'abord.**
- Visibilité d'une cible, à chaque mesure : `error_value / error_threshold` (1 ou plus = mesure rejetée).
- Visibilité de la station : la moyenne de ce rapport sur les capteurs mesurés. C'est exactement la bande du haut de l'onglet View (spec, section « L'onglet View »), déjà calculée en JS pour la page.
- `Loss of visibility` quand la moyenne dépasse un niveau pendant quelques mesures d'affilée ; `Passing obstacle` quand elle le dépasse sur une seule mesure ; `Target hidden` quand une cible dépasse son seuil plusieurs fois alors que la moyenne reste basse. Tout est grisé ; le bouton `Images` du point 7 apporte la preuve.
- Trois constantes au plus (le niveau de la moyenne, le nombre de mesures d'affilée, le nombre de rejets d'une cible), réglées à l'œil sur les events et inscrites au registre du point 17.
- Risque connu : la buée de E-001 reste **sous le seuil** des références ; c'est pour cela que la v0 compare chaque capteur à son propre niveau. La version simple la manquera peut-être : le mesurer et le dire à l'utilisateur, qui tranche (simple et imparfait d'abord, selon sa règle).
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Mettre la v0 de côté : la copier dans `detectors/archive/visibilite_v0.py` (le chargeur ne lit que `detectors/*.py`, pas les sous-dossiers).
- [x] Réécrire `detectors/visibilite.py` en version simple, même contrat, labels du point 9.
- [x] Lancer les six jeux ; un tableau v0 contre version simple, face à la vérité du point 10 : ce que la simple attrape, ce qu'elle manque (E-001, le train à 2 cibles, les feuilles, les obstructions de WILDSTRUBEL).
- [x] Montrer le tableau à l'utilisateur ; garder la simple si elle suffit à ses yeux, sinon ne reprendre de la v0 que ce qui manque. Choix de l'utilisateur le 2026-10-24 : **la v0 reste en service** (`detectors/visibilite.py`), la simple est gardée dans `detectors/archive/visibilite_simple.py`.
- [x] Docstring (méthode et résultats) et registre du point 17 à jour. La docstring de la v0 dit l'essai et son résultat ; le registre ne change pas (constantes de la v0 ; celles de la simple restent dans l'archive).
2026-10-24 08:24:30 +02:00
**La v0, pour mémoire** (de nouveau dans `detectors/visibilite.py` depuis le choix du 2026-10-24) : mesure « haute » = `error_value` > médiane + `K_MAD` (10) MAD **et** > `FACTEUR` (2) × médiane du capteur, sur tout l'export ; `Brief obstruction` si ≥ `BREF_MIN` (3) capteurs hauts à un instant, `SAILLIE` (3) fois plus qu'aux instants voisins ; `Poor visibility` : suites d'au moins `SUITE_MIN` (3) mesures hautes, réunies entre capteurs (≥ 2), réduites aux instants où ≥ `FRAC` (15 %) du pic est haut, coupées par une accalmie de `COUPURE` (2 h) ; `Target obscured` : une cible rejetée et à plus de `K_CIBLE` (5) MAD, au moins `CIBLE_MIN` (3) fois à moins de `CIBLE_ECART` (6 h) ; `ECART` 2,5 pas entre deux mesures d'une suite. Ses défauts connus, à ne corriger que si l'on en garde des morceaux :
2026-10-24 08:24:30 +02:00
- `Target obscured` est la sortie la plus bruitée : à NORDEND d'octobre, CTR01, PR04 et PR09, souvent rejetées, donnent des épisodes jusqu'à un jour ; l'image du 13/10 à 20:00 paraît normale ;
- le train du 03/10 10:00 (E-005, 2 cibles) est manqué (`BREF_MIN` = 3) ;
2026-10-24 08:24:30 +02:00
- la pluie du 01/10 commence à 06:00 contre 05:00 dans la vérité ;
- WILDSTRUBEL : deux `Brief obstruction` (02/09 12:00, 03/09 08:15) probablement dus à la turbulence (à écarter dans le classement, point 6) ; celui du 04/09 14:00 est plausible (véhicule et image fantôme sur la route) ;
- le texte de `Brief obstruction` cite « train, vehicle or animal » même dans le tunnel de CLARIDEN (réglé par le point 9) ;
- le niveau habituel est calculé sur tout l'export, donc après coup.
**Fini quand.** L'utilisateur a choisi entre la version simple et la v0, sur le tableau des six jeux.
2026-10-23 21:52:08 +02:00
**Essai du 2026-10-24.** v0 déplacée (`git mv`) dans `detectors/archive/visibilite_v0.py`, toujours lançable ; version simple écrite dans `detectors/visibilite.py` : une cible est rejetée au-dessus de son seuil ; seules comptent les cibles vues au moins la moitié du temps (PM_G à PS des Coudres, sept références « e » à NIEDERHORN, rejetées 100 % du temps, sont écartées) ; `Poor visibility` quand au moins `NIVEAU` des cibles sont rejetées sur deux mesures ou plus (une mesure basse tolérée entre deux hautes), `Brief obstruction` sur une seule, `Target obscured` quand une cible est rejetée la plupart du temps (au moins la moitié de ses mesures) au moins 3 fois à moins de 6 h, la station voyant clair. `NIVEAU` balayé de 0,15 à 0,3 face à 18 instants de vérité : 0,2 est le meilleur.
| Jeu | v0 | Simple (`NIVEAU` 0,2) |
|---|---|---|
| NORDEND octobre | buée du 07/10 17:15 au 08/10 12:15 en une perte de visibilité ; 09/10 jour et nuit ; 14/10 aube ; 6 « Target hidden » | la buée devient un « Target hidden » de 4 cibles, un passage et deux bouts de perte de visibilité ; 09/10 et 14/10 trouvés ; 4 « Target hidden », dont toujours les deux longs |
| E-001 PS des Coudres | les deux nuits de buée (REF_G, REF_D) | **rien** : la buée reste sous le seuil |
| E-002 NORDEND juillet | la toile en une perte de visibilité (28/07 20:45 → 31/07 02:45) | la toile en 3 morceaux, plus 3 « Target hidden » |
| E-003 WILDSTRUBEL | PA_9 les matins, 3 passages | **8 pertes de visibilité et 7 passages** dans la turbulence (20 à 60 % des cibles rejetées de jour) |
| E-004 CLARIDEN | 2 passages (tunnel), PR-284 20 min | **PR_BG grisé le 19/09 de 06:10 à 06:30, au moment du vrai mouvement** ; PR-284 |
| E-005 NIEDERHORN | pluie 06:00 → 11:00 et 03:00 → 11:00, 4 trains, feuilles | pluie 06:00 → 09:00 et 05:00 → 11:00 (plus courte), 2 trains sur 4, feuilles, 3 « Target hidden » en plus |
Bilan : la simple est moins bonne sur cinq jeux et grise le vrai mouvement de CLARIDEN ; ce qui manque, c'est la comparaison de chaque capteur à son propre niveau (la v0), sans laquelle la buée sous le seuil et la turbulence ne se distinguent pas d'une perte de visibilité. Recommandation : remettre la v0 en service, garder la simple dans l'archive. **Choisi par l'utilisateur** ; les défauts de la v0 restent (« Target hidden » trop sensible : points 18 et 11 bis si besoin).
2026-10-23 21:52:08 +02:00
### Point 12 : `sauts` : régler
**Ce qui existe.** `detectors/sauts.py` : bruit = médiane des écarts d'une mesure à la suivante ; saut = mesure à ≥ `K` (20) bruits de la médiane des `BASE` (4) mesures d'avant ; revenu si `BASE` mesures de suite à moins de la moitié du saut en moins de `BACK_H` (24 h), ou si le jour d'après la cible est à sa place habituelle (premier jour de l'export) ou à celle de la veille ; sauts à moins de `GAP` (1 h) toutes cibles confondues = un épisode ; une seule cible durable suffit à ne pas griser. Depuis le 2026-10-23, un saut non revenu finit avec lui-même (sa barre couvrait la ligne).
2026-10-23 21:52:08 +02:00
**Défauts connus.**
- `K` = 20 : à 15, on attrape les trois cibles du train de NIEDERHORN (17 et 19 bruits) mais deux cibles saines de PS des Coudres sont grisées (17 et 18 bruits) ; aucun seuil ne sépare proprement les deux.
- Les 4 premières mesures ne sont jamais testées (train du 30/09 22:00 manqué) ; marqué `ponytail:`.
- La place habituelle (premier jour) est fausse si l'export commence pendant un artefact ; marqué `ponytail:`.
- Le saut horizontal de PR17 (17 bruits) est sous le seuil.
- CLARIDEN : D-303-A en « Lasting shift » le 18/09 15:40 (0,7 px), sans doute la cible agitée de la fiche ; non grisé, sans danger. Le texte dit « 4 of them stayed shifted », moins que la fiche : chez les autres, le saut du matin revient en partie dans l'heure.
- La dérive lente de `corr_x` la nuit à CLARIDEN n'est pas un saut (point 16).
**Étapes.**
- [x] Avec le classement (point 6), les trains sont attrapés par `visibilite` ; ne pas baisser `K`. Le noter.
- [x] Tester les premières mesures contre les suivantes (niveau d'après au lieu d'avant) pour ne plus manquer le saut de la première mesure ; relancer NIEDERHORN.
- [x] Relancer les six jeux ; docstring et registre.
2026-10-23 21:52:08 +02:00
**Fini quand.** Le train du 30/09 22:00 est vu ou le choix de le laisser est noté, et CLARIDEN reste non grisé.
**Fait le 2026-10-24.** Les `BASE` premières mesures sont testées face au niveau d'après (médiane des `BASE` suivantes) ; un écart y est un saut revenu aussitôt. Le train du 30/09 22:00 est vu (2 cibles) et absorbé par le classement dans son « Passing obstacle » ; sur les cinq autres jeux, la sortie de `sauts` est identique à l'octet près, CLARIDEN reste non grisé. « Ne pas baisser `K` » noté dans la docstring et au commentaire de `K` ; pas de nouvelle constante, registre inchangé. Les autres défauts connus (place habituelle prise sur le premier jour, saut horizontal de PR17 sous le seuil, D-303-A à CLARIDEN) restent, sans effet sur le journal aujourd'hui.
2026-10-23 21:52:08 +02:00
### Point 13 : `thermique` : ce que voit vraiment le client
**Ce qui existe.** `detectors/thermique.py`, sur `corr_x`, `corr_y` par cible : profil horaire sur les jours UTC d'au moins `HEURES_MIN` (20) heures ; un axe a un cycle si chaque jour ressemble aux autres (corrélation ≥ `REPRO`, 0,6) ; cycle de la station si ≥ `PART` (la moitié) des cibles ; heures chaudes = écart au niveau de nuit (`NUIT`, 8 heures les plus plates) ≥ `CHAUD` (0,3) × amplitude ; un épisode par jour complet qui ressemble aux autres (≥ `JOUR`, 0,5).
2026-10-23 21:52:08 +02:00
**La découverte.** Le cycle jour / nuit est dans les **positions brutes** de presque toutes les stations (NORDEND de juillet 1,8 px, WILDSTRUBEL 3,2 px, NIEDERHORN 4,6 px, NORDEND d'octobre 0,78 px), en mode commun (caméra ou mât qui se courbe), et la **compensation l'enlève**. Seule PS des Coudres le garde dans `corr` (11 cibles sur 11, 0,17 px, jusqu'à 0,5 à 0,9 px en `corr_y` sur BJ, PBJ et PM, 08:00 → 18:00, même forme que dans les positions brutes : les cibles bougent vraiment par rapport aux références, par dilatation de l'ouvrage ou compensation partielle, non tranché). NORDEND d'octobre garde un petit cycle (9 cibles sur 19, 0,02 px, soit environ 1 mm avec 55,5 mm/px, juste sous le seuil ; à `PART` = 0,4 : 8 épisodes, sans les 08 et 09/10, jours couverts et du saut de PR17). CLARIDEN n'a aucun cycle sur 3 jours, même brut (non expliqué).
**À décider par l'utilisateur.**
- [x] Les « grosses vagues » qu'il voit sur la plateforme : sur quelles stations, en mm (export horaire) ou dans quelle page ? Si c'est dans les courbes en mm, est-ce le même cycle que celui de `corr` (le facteur mm/px est par cible) ? Réponse (2026-10-24) : il ne se souvient plus du projet ; des ouvrages bougent beaucoup le jour par dilatation thermique et redescendent la nuit, de grosses vagues tout à fait normales ; aucun des six jeux ne les montre dans les courbes corrigées.
- [x] La vague d'environ 1 mm de NORDEND d'octobre : à signaler (`PART` = 0,4) ou non ? Non (recommandation gardée ; la sinusoïde ne la trouve pas non plus).
- [x] Faut-il dire au client que la caméra bouge chaque jour mais que c'est compensé ? (Probablement non : il ne le voit pas.) Non.
- [x] Une étiquette plus générale « Periodic effect » pour toute vague qui revient chaque jour (idée du brainstorming, jugée « encore poussée ») : maintenant ou plus tard ? L'utilisateur la veut : un effet périodique de dilatation et de contraction thermiques, reconnu par une sinusoïde de 24 h ; devient le point 41.
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Selon les réponses, régler `PART` et relancer les six jeux. `PART` inchangé (la vague de NORDEND n'est pas signalée) ; la suite est au point 41.
- [x] Ajouter une note métier `labeling/connaissances/cycle-thermique.md` (< 50 l) : ce qui est brut, ce qui est compensé, ce qui reste, avec les chiffres ci-dessus.
2026-10-23 21:52:08 +02:00
**Fini quand.** La question « le client voit-il la vague » a sa réponse, écrite dans la note.
### Point 14 : `turbulence` : midis agités et marge de CLARIDEN
**Ce qui existe.** `detectors/turbulence.py` : par capteur et par heure, agitation = médiane de |Δ`corr_x`| + |Δ`corr_y`| sur 3 h, et médiane de l'`error_value`, rapportées au quartile bas du capteur ; heure turbulente si ≥ `PART` (la moitié) des capteurs ≥ `RATIO` (1,5) × leur calme **et** `error_value` médiane ≥ `RATIO_ERR` (1,5) × la calme ; épisode d'au moins `DUREE_MIN` (3 h), écarté si plus de `REJET_MAX` (15 %) de rejets (c'est alors de la mauvaise visibilité) ; grisé si agitation ≥ `FORT` (2×). Résultat : WILDSTRUBEL seule, trois jours, ×2,3 à ×2,6, tous grisés ; rien ailleurs. Sans le critère `error_value`, faux positifs partout (8 épisodes à PS des Coudres, 14 à NORDEND d'octobre).
2026-10-23 21:52:08 +02:00
**Points ouverts.**
- Midis agités sans hausse de l'`error_value` à PS des Coudres et NORDEND d'octobre (50 à 100 % des capteurs un peu plus agités à midi) : turbulence légère à signaler, ou rien ?
- Marge faible avec un vrai mouvement : le matin du mouvement de CLARIDEN (06:00-08:00) agite les corrections et fait monter l'`error_value` ; seule la durée minimale de 3 h l'écarte, à une heure près. Danger : point d'attention 1.
- Une vague lente gonfle un peu l'agitation (la pente s'ajoute aux écarts) ; le détecteur ne retranche pas la tendance locale.
- Bords en retard d'environ 30 min au début et d'1 h à la fin face à la vérité de E-003 (03:30 → 16:00).
2026-10-23 21:52:08 +02:00
**À décider par l'utilisateur.**
- [x] Les midis agités : turbulence légère (épisode non grisé) ou rien ? Rien (utilisateur, 2026-10-24).
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Protéger CLARIDEN : ne jamais classer en `turbulence` une période qui chevauche un événement `a_verifier` (règle du classement, point 6) ; relancer CLARIDEN. Fait le 2026-10-24 dans `categories.classer` ; vérifié en abaissant `DUREE_MIN` à 2 h puis 1 h : le détecteur sort le 19/09 06:00 → 08:00 en turbulence, le classement l'écarte du journal ; WILDSTRUBEL garde ses trois turbulences, rien ailleurs.
- [x] Selon la réponse, un niveau « léger » non grisé (agitation ≥ 1,5× sans hausse d'erreur) ; relancer les six jeux. Sans objet : les midis agités ne sont pas signalés.
2026-10-23 21:52:08 +02:00
**Fini quand.** CLARIDEN ne peut plus sortir en turbulence, quelle que soit la durée.
### Point 15 : `trous` : libellé et sens
**Ce qui existe.** `detectors/trous.py` : cadence = écart médian entre instants de mesure ; trou si plus de `MISSING` (2) pas manquent ; label « No data », jamais grisé ; le texte dit que l'export n'a rien, pas que la station était arrêtée (règle : un trou n'est pas une coupure).
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Harmoniser le label avec le point 9 (« No data » ou « Data gap »). Déjà fait aux points 5 et 6 : « No data » partout.
- [x] Ajouter au texte les images s'il y en a pendant le trou (des images sans mesure disent que la caméra tournait) ; vérifier sur NORDEND le 15/10 22:30 → 16/10 01:15.
2026-10-23 21:52:08 +02:00
**Fini quand.** Le trou de NORDEND dit s'il y a des images pendant.
**Fait le 2026-10-24.** Dans `explore.build` (la page connaît les images ; le contrat `detect(mesures)` ne change pas) : « The camera still took N images in this period, so it was running. » ou « There is no camera image for this period either. ». NORDEND, 15/10 22:30 → 16/10 01:15 : aucune image pendant (elles s'arrêtent à 22:30 et reprennent à 01:30), la phrase le dit. La branche « des images pendant » n'a pas de cas dans les six jeux.
2026-10-23 21:52:08 +02:00
### Point 16 : Les catégories qu'aucun détecteur n'attrape
**Pourquoi.** La carte (section 3) et le vocal de l'utilisateur en citent : « plus assez de références, il y a un peu tout qui bouge », la dérive lente, la neige, l'éclairage.
**Pistes, de la plus simple à la plus dure** (une à la fois, sur demande) :
- [x] **Dérive lente** (`Slow drift`, à vérifier) : fait le 2026-10-24, autrement que prévu : pas de fichier `derive.py` (la tendance se calcule sur l'export horaire, hors du contrat `detect(mesures)`), mais les tendances déjà calculées par l'onglet `Displacements` reprises par `explore.build` en événements `derive_lente`, jamais grisés, en trait rouge fin dans la frise ; NORDEND d'octobre : « PR06 drifts slowly and steadily: +0.7 mm in 10 days. Keep watching it. » (6 → 15/10) ; aucune tendance sur les cinq autres jeux. Texte d'origine : réutiliser `find_trend` de `vues-deplacements/maquette/explore.py` (Theil-Sen et tau de Kendall sur les niveaux journaliers de l'export horaire, 5 jours au moins, D-055) dans un détecteur `detectors/derive.py` ; tendance de PR06 à NORDEND d'octobre (+0,7 mm en 10 jours) comme contrôle.
- [x] **Références masquées** (« plus assez de références, tout bouge ») : couvert, sans catégorie à part (utilisateur, 2026-10-24) : la phrase de la perte de visibilité dit « including the reference targets » (point 38) et les sauts communs y sont absorbés. Texte d'origine : un épisode `visibilite` qui touche des `global_ref` **et** un saut commun de nombreuses cibles qui revient (E-002) ; catégorie à part ou phrase de `visibilite_perdue` ; à décider avec l'utilisateur. Règles du projet : ne rien construire sur `inlier` binaire ; `sigma0` seul et le nombre de références ne suffisent jamais.
- [x] **Tout a bougé** contre **références masquées** : remis, impossible sur les mesures seules (2026-10-24). Texte d'origine : impossible sur les mesures seules (Barcelone, `labeling/connaissances/incident-de-barcelone.md`) ; reste `a_verifier`, avec les images.
- [x] **Éclairage, voisin trop brillant** : remis à plus tard, en attente d'un event de l'utilisateur (2026-10-24). Texte d'origine : créneaux jour / nuit sur une ou quelques cibles (E-003) ; à essayer seulement si l'utilisateur apporte un event.
- [x] **Neige** : aucun event ; attendre un hiver et un event (point 35). Remis à plus tard (2026-10-24).
2026-10-23 21:52:08 +02:00
**Fini quand.** Chaque piste est faite ou explicitement remise à plus tard dans l'index.
### Point 41 : L'effet périodique : une sinusoïde de 24 h, dilatation et contraction thermiques
**Pourquoi.** Idée de l'utilisateur au point 13 (2026-10-24) : des ouvrages bougent beaucoup le jour par dilatation thermique et redescendent la nuit : de grosses vagues, tout à fait normales. Il veut un « effet périodique » qui explique ces anomalies : la vague est un événement de **dilatation** (montée) ou de **contraction** (descente) thermique. Méthode qu'il propose : ajuster une fonction en vague (sinus, cosinus) ; si elle colle aux données, l'événement est cyclique, calqué sur le jour et la nuit, et dû à la dilatation thermique.
**Ébauche du 2026-10-24** (script de session, chiffres dans `labeling/connaissances/cycle-thermique.md`) : par cible et par axe, `a + b·sin(2πt/24 h) + c·cos(2πt/24 h)` par moindres carrés (bibliothèque standard), R² = part de la courbe expliquée. Sur les courbes corrigées, R² ≥ 0,3 pour 14 axes sur 22 à PS des Coudres (0,16 px, pic vers 08 h UTC), 0 sur 38 à NORDEND d'octobre, 0 sur 48 à CLARIDEN (le vrai mouvement ne passe pas pour une vague), 14 sur 40 à NIEDERHORN (à vérifier : 3 jours, deux nuits de pluie aux mêmes heures).
**Étapes.**
- [x] Trancher avec l'utilisateur : la sinusoïde remplace-t-elle la méthode actuelle de `thermique.py` (profil horaire répété), ou s'y ajoute-t-elle ?
- [x] Coder dans `detectors/thermique.py` : cycle de la station si la plupart des cibles ont un R² au-dessus d'un seuil (provisoire, registre du point 17) ; un épisode par demi-vague, montée « Thermal expansion », descente « Thermal contraction », ou un épisode par jour (à trancher) ; données gardées, non grisées.
- [x] Catégorie et phrase : la catégorie `cycle_thermique` devient l'effet périodique (carte, section 4 ; phrase à valider, par exemple « The structure expands in the day heat and contracts at night: this daily wave is normal. »).
- [x] Vérifier sur les six jeux : PS des Coudres trouvé, CLARIDEN et NORDEND d'octobre rien, NIEDERHORN expliqué ; capture.
- [ ] Quand des données à grosses vagues arriveront (pompage, partie VI, ou le projet dont l'utilisateur se souvient), les essayer en premier.
**Fini quand.** Une station à vague reçoit ses événements de dilatation et de contraction, et aucune autre.
**Décidé et fait le 2026-10-24.** Choix de l'utilisateur : garder les deux méthodes (le cycle doit être vu par le profil répété **et** par la sinusoïde, `R2_MIN` = 0,3 pour la moitié des cibles) ; montée et descente ; phrases courtes. Le sens d'une courbe dépendant de la direction de la cible, dilatation et contraction sont repérées par l'écart au niveau de nuit (heures chaudes de la méthode actuelle) : « Thermal expansion » de la première heure chaude au plus grand écart, « Thermal contraction » ensuite. Codé dans `thermique.py`, `categories.py` (`dilatation_thermique`, `contraction_thermique` à la place de `cycle_thermique`) et le gabarit. Résultat : PS des Coudres, du 09 au 13/10, dilatation 08:00 → 15:00 puis contraction 15:00 → 18:00 ; rien sur les cinq autres jeux (NIEDERHORN : la sinusoïde voit 14 axes sur 40, la première méthode 3 cibles sur 11 : écarté). Carte (section 4), D-056, spec, note `cycle-thermique.md` et registre (`R2_MIN`) à jour. Reste la dernière étape, quand des données à grosses vagues arriveront.
2026-10-23 21:52:08 +02:00
### Point 17 : Le registre des seuils provisoires
**Pourquoi.** Tous les seuils sont réglés sur 5 events ; quand les données en masse arriveront (partie VI), c'est la liste à revoir.
2026-10-23 21:52:08 +02:00
**Le registre** a quitté ce plan le 2026-10-24 : il vit dans `vues-deplacements/contexte/seuils-du-journal.md`, vérifié contre le code (toutes les valeurs collaient ; ajoutés : `MERGE` du classement et les constantes de tendance de la dérive lente).
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Recopier ce registre dans `vues-deplacements/contexte/seuils-du-journal.md` et le tenir à jour à chaque point de la partie III.
2026-10-23 21:52:08 +02:00
**Fini quand.** Le fichier existe et colle au code (`grep -n '# provisoire' detectors/*.py`).
2026-10-23 21:52:08 +02:00
---
## Partie IV — La page : défauts et choix d'affichage
### Point 18 : Zones grisées trop larges
**Le défaut.** Un épisode qui ne touche qu'une ou quelques cibles grise toutes les courbes : à NORDEND d'octobre, « Target obscured » sur 4 cibles grise presque tout le 13/10 09:45 → 14/10 07:00.
**À décider par l'utilisateur.**
- [x] (a) Griser seulement les événements qui touchent beaucoup de cibles ou des références ; pour les autres, mettre les seules courbes concernées en pointillés pendant l'épisode. (b) Ne rien griser pour une cible seule, l'entrée du journal suffit. (c) Autre.
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Appliquer le choix dans `drawJournal` (le rectangle gris dépend de `sensors` et du nombre de cibles affichées).
- [x] Capturer NORDEND d'octobre sur le 13/10 : plus de journée grisée pour 4 cibles.
**Décidé et fait le 2026-10-24.** Choix de l'utilisateur : (a). Règle retenue, sans compter les cibles : le rectangle gris reste pour ce qui touche toute la scène (perte de visibilité, passage, saut bref, turbulence) ; pour « Target hidden », seules les courbes des cibles concernées passent en gris (trait gris clair par-dessus) pendant l'événement. NORDEND du 13/10 09:45 au 14/10 07:00 : plus de fond gris, les courbes de CTR01, PR04, PR07 et PR09 en gris ; seule la « No visibility » du 14/10 05:15 → 06:00 reste grisée. CLARIDEN : la zone grise de PR-284 (19/09 18:30) a disparu, le mouvement n'a plus aucun fond gris (point d'attention 1 et contrôle du point 10 tenus à la lettre).
2026-10-23 21:52:08 +02:00
### Point 19 : Échelle écrasée par un pic
**Le défaut.** WILDSTRUBEL : le saut d'un pas de PA3_2 (le 04/09 à 06:45, 8 px en horizontal, 30 px en vertical) écrase toutes les autres courbes.
**Proposition.** L'échelle verticale se calcule sans les points des zones invalidées (ils restent dessinés, hors cadre si besoin) ; un bouton `Fit all` remet l'échelle sur tout.
**Étapes.**
- [x] Dans le recalage de l'ordonnée du volet Journal (`AUTOSCALE`), ignorer les points des événements `ignore`.
- [x] Capturer WILDSTRUBEL : les courbes ne sont plus plates.
**Fait le 2026-10-24.** `AUTOSCALE_Y_JS` (`src/common/page.py`, commun à tout le projet) accepte `meta.yskip`, un booléen par point à laisser hors du recalage, sans rien changer aux autres pages ; le Journal y met les points des zones grisées (fond gris) et ceux des cibles masquées pendant leur événement ; bouton `Fit all` (tous les points, pics compris). WILDSTRUBEL : courbes lisibles (±0,3 px), le pic de PA3_2 du 04/09 06:45 sort du cadre ; NORDEND presque inchangé. **Reste, d'une autre nature** : à CLARIDEN, PR_BG bascule entre deux positions après le mouvement (209 mesures sur 429 à environ 11 px, les autres près de 0 ; `error_value` médiane 0,67 pour un seuil de 0,7) ; aucun événement ne la couvre, l'échelle reste écrasée ; à voir avec l'utilisateur (une cible qui saute d'une tache à l'autre ?) ; jugé peu important par l'utilisateur (2026-10-24), laissé noté ici.
2026-10-23 21:52:08 +02:00
### Point 20 : Pixels ou millimètres
**Ce qui a été dit.** Le supérieur suggère les pixels ; l'utilisateur pense qu'on voit la même chose ; mais lors du cas NORDEND (parcours, étape 9), il jugeait les mm plus parlants pour le client. `corr_x`, `corr_y` sont en px (avis de l'utilisateur, `labeling/connaissances/colonnes-des-deplacements.md`) ; l'export horaire est en mm, moyenne horaire, avec un facteur propre à chaque cible (55,5 mm/px pour PR17 à NORDEND).
2026-10-23 21:52:08 +02:00
**À décider par l'utilisateur.**
- [x] px à la cadence native (on voit les trains et les pics d'une mesure), mm à l'heure (ce que la plateforme montre au client), ou un sélecteur px / mm ? Sélecteur, **mm par défaut** (utilisateur, 2026-10-24).
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Si mm : courbes depuis `D.hourly` (déjà dans la page pour l'onglet Displacements), événements inchangés (heures UTC).
- [x] Capturer et montrer.
**Fait le 2026-10-24.** Boutons `mm` / `px` au-dessus des courbes du Journal ; mêmes couleurs par cible, plage de temps gardée, grisés et cibles masquées comme en px ; `#unit=px` pour les captures. En route : les noms des cibles de l'export horaire de NIEDERHORN finissaient par un retour chariot (« …_C09\r ») et ne retrouvaient pas leur cible : `explore.hourly` les nettoie (l'onglet Displacements en profite). Vu en mm à NORDEND : PR17 descend d'environ 3 mm le 12/10 à 23:00, plus net qu'en px ; les détecteurs travaillant en px, le journal n'en dit rien.
2026-10-23 21:52:08 +02:00
### Point 21 : Plage par défaut, « depuis ta dernière visite »
**Ce qui a été dit.** « S'il regarde tous les 2-3 jours, il va mettre la plage 2-3 jours. » Aujourd'hui : les 3 derniers jours ; le sélecteur de dates de l'en-tête est inerte.
**À décider par l'utilisateur.**
- [x] 3 jours fixes, ou depuis la dernière visite (mémorisée dans le navigateur, pour la maquette) ? **3 jours fixes** dans la maquette (utilisateur, 2026-10-24) : sur des exports figés, une dernière visite enregistrée aujourd'hui tomberait après la fin des données ; « depuis ta dernière visite » ira dans la vraie application (point 36).
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Selon la réponse, `localStorage` (avec `try`/`catch`) pour la dernière visite ; le sélecteur de dates de l'en-tête rendu actif pour l'onglet Journal. Sans objet (3 jours fixes, rien à coder).
2026-10-23 21:52:08 +02:00
### Point 22 : Interactions jamais essayées
**Ce qui n'a pas été vérifié** (spec, section « L'onglet Journal ») : le clic sur une entrée (zoom), le survol des barres, le zoom à la souris ; pour l'onglet Displacements : le clic vers Diagnosis, le zoom des courbes.
**Étapes.**
- [x] L'utilisateur ouvre la page (annexe B, « Ouvrir ») et essaie chaque geste ; noter ce qui ne marche pas. Fait le 2026-10-24 sur NORDEND d'octobre : clic sur une carte, survol et clic des barres, molette, glisser, double-clic, `▶ Images` (pause, image par image, Échap), `mm` / `px`, `Fit all`, et dans Displacements le clic vers Diagnosis et le zoom : **tout marche**.
- [x] Corriger, recapturer, cocher dans la spec. Rien à corriger.
2026-10-23 21:52:08 +02:00
### Point 23 : Deux couches : client et support
**Pourquoi.** Le diagnostic va au client et à l'ingénieur support, en couches (D-020). Le client lit les catégories ; le support veut savoir quel détecteur a vu quoi.
**Étapes.**
- [x] Sous chaque carte du journal, un repli `Details` (fermé par défaut) : les épisodes bruts de l'événement (`D.journal[i].episodes`), avec détecteur, label d'origine, capteurs.
- [x] Une case à cocher `Support view` qui remet les lignes par détecteur dans la frise.
**Fait le 2026-10-24.** Les deux étapes sont réunies derrière la seule case `Support view` : le repli `Details` n'apparaît que cochée, pour que la vue du client reste celle du point 8 (règle d'or : simple). Cochée : lignes par détecteur sous « What happened » (épisodes bruts, label d'origine), `Details` sous chaque carte ; capture NORDEND du 13 au 16/10. Le point 40 (déplier la vue du client) reste à part : la vue support répond au support, pas au recouvrement dans la vue repliée.
2026-10-23 21:52:08 +02:00
### Point 39 : Les cibles `target02` à `target05` absentes des courbes
**Pourquoi.** Vu au point 1 (2026-10-24) : à PS des Coudres, les courbes du Journal ne montrent que 3 cibles sur 11 (BJ_G, BJ_C, BJ_D). Les autres ont `pattern_type` = `target02` à `target05`, et le filtre ne garde que `target` et `ref`. Les détecteurs, eux, les voient toutes (`thermique` : 11 cibles sur 11).
**Étapes.**
- [x] `vues-deplacements/maquette/explore_template.html`, `drawJournal()` (l. ~928) : garder tout sauf les `global_ref` (`s.kind !== "global_ref"`) ; chercher le même filtre dans les autres onglets. Fait autrement, à la racine (2026-10-24) : `explore.build` range tout `targetNN` sous `target` ; le Journal (courbes en px) et l'onglet View (couleur des repères par type) en profitent ensemble.
- [x] Reconstruire PS des Coudres, capturer `#tab=journal` : 11 courbes (PM_G n'a pas de `corr_x`). Capturé en px : 10 courbes, PM_G sans position corrigée ; en mm, toutes les cibles y étaient déjà (export horaire).
**Fini quand.** Toutes les cibles de PS des Coudres ont leur courbe.
**Validé le 2026-10-24.**
### Point 40 : Déplier la frise au lieu de tout empiler sur une ligne
**Pourquoi.** Idée de l'utilisateur en validant le point 8 (2026-10-24) : il n'est « pas entièrement satisfait » de la ligne unique « What happened » ; on pourrait « développer au lieu de tout mettre sur une même ligne ». Sur une ligne, des événements simultanés se recouvrent : à NORDEND, les deux « Loss of visibility » des 13 et 14/10 disparaissent presque dans la barre « Target hidden » ; à WILDSTRUBEL, la cible masquée est cachée sous la turbulence.
**Pistes, à trancher avec l'utilisateur.**
- Un bouton (ou un clic sur « What happened ») qui déplie la ligne en une ligne par catégorie présente, et la replie.
- Ou déplier seulement là où des événements se recouvrent (une sous-ligne par événement simultané).
- Voir avec le point 23 : sa case `Support view` remet déjà des lignes par détecteur ; les deux peuvent n'en faire qu'un.
**Étapes.**
- [x] Choisir la piste avec l'utilisateur. Choisi le 2026-10-24 : une ligne par catégorie, derrière une case.
- [x] Coder dans `drawJournal()` (`explore_template.html`) ; capturer NORDEND (13-14/10) et WILDSTRUBEL, replié et déplié ; mettre la spec à jour.
**Fini quand.** Aucun événement n'est caché par un autre, et la vue repliée reste celle du point 8.
**Fait le 2026-10-24.** Choix de l'utilisateur : une ligne par catégorie. Case `Expand` à côté de `Support view` (`#expand` pour les captures) : dépliée, une ligne par catégorie présente dans les données, dans l'ordre de `J_ORDER` (« Shift to check » en haut, « Slow drift » en bas, en barre pleine) ; repliée, la ligne du point 8, inchangée. Captures : à NORDEND, les « No visibility » et « Reduced visibility » des 13 et 14/10 sortent de la barre « Target hidden » ; à WILDSTRUBEL, la cible masquée PA_9 sort de dessous la turbulence. Limite : les lignes valent pour toute la période, une catégorie absente de la plage visible garde une ligne vide (NORDEND du 13 au 16/10 : « Shift to check », « Passing obstacle »). La bande de statut de visibilité (point 38) n'a pas été ajoutée : la ligne par catégorie la remplace.
**Validé le 2026-10-24.**
2026-10-23 21:52:08 +02:00
---
## Partie V — Second volet : la courbe nettoyée
Rapport de l'agent : `vues-deplacements/contexte/lissage.md`. Le cadrage D-044 (`docs/displacement/cadrage.md`) a déjà posé les règles : la brute n'est jamais remplacée, chaque point corrigé porte son statut et sa raison, le calcul est causal, « masque puis médiane glissante » ; la plateforme sait déjà masquer, interpoler et passer une médiane glissante (Data Exploration).
### Point 24 : Trancher les trois questions du lissage
**À décider par l'utilisateur.**
- [x] La courbe nettoyée par défaut avec la brute en option, ou l'inverse ? (Elle ne remplace jamais la brute à l'écran, cadrage Q4.) Réponse : les deux ensemble, la nettoyée en couleur coupée dans les zones à ignorer, la brute en gris fin dans ces zones seulement.
- [x] Un lissage centré (côté serveur, sans retard, le journal paraît une fois le matin) ou causal comme les analyses (1 à 2 h de retard, cadrage Q5) ? Réponse : calculé au moment où le client regarde les courbes, sur tout ce qui est disponible jusque-là ; rien n'est écrit dans la base (impossible à ce stade).
- [x] Le cycle thermique reste-t-il tel quel (cadrage Q8), ou faut-il une vue « sans le cycle » ? Seule une réponse « sans le cycle » justifie l'option D. Réponse : tel quel ; l'option D reste en réserve.
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Noter les réponses sous D-056 et dans `lissage.md`, section 4.
**Décidé le 2026-10-24.** Les trois réponses sont sous D-056 (« Lissage, trois questions tranchées ») et dans `lissage.md`, section 4. Conséquence pour le point 25 : pas de sélecteur au départ, les deux courbes ensemble ; le calcul reste dans la page, au chargement.
**Validé le 2026-10-24.**
2026-10-23 21:52:08 +02:00
### Point 25 : Option A : la courbe nettoyée par masquage
**Principe.** La courbe nettoyée est la brute sans les points des zones invalidées, laissés en **trou** (pas d'interpolation, sinon on cache une marche). Aucun réglage, aucun seuil nouveau ; sa fiabilité est celle du journal.
**Étapes.**
- [x] Dans le volet Journal : brute en gris fin toujours visible ; nettoyée en couleur par-dessus, interrompue aux trous ; un sélecteur `Raw / Cleaned / Both` (`Both` par défaut, ou selon le point 24) ; une ligne de légende : « Cleaned: periods to ignore removed, nothing else changed. » Fait sans sélecteur (point 24) : la brute en gris fin seulement dans les zones à ignorer.
- [x] Capturer NIEDERHORN (trains, pluie) et CLARIDEN (rien ne doit disparaître du mouvement réel).
2026-10-23 21:52:08 +02:00
**Fini quand.** CLARIDEN est identique en brute et en nettoyée autour du 19/09 06:10.
**Fait le 2026-10-24.** Dans `drawJournal()` : chaque courbe est coupée pendant les événements à ignorer (« Target hidden » : seulement sur ses cibles), la brute y reste en gris fin, reliée aux points gardés de part et d'autre (un passage d'une seule mesure se voit). Deux écarts trouvés à la capture et corrigés : la palette avait un gris (`#7f7f7f`), qui faisait passer une cible (PR_BG à CLARIDEN) pour de la brute à ignorer : retiré des couleurs du Journal ; en mm, une moyenne horaire n'était coupée que si l'événement commençait pile à l'heure : elle couvre maintenant toute son heure. Captures : NIEDERHORN, les trains du 30/09 22:00 et du 01/10 12:00 en gris, en mm comme en px ; CLARIDEN, le mouvement du 19/09 06:10 tout en couleur, rien de coupé (aucun événement à ignorer dessus). À savoir : à WILDSTRUBEL, la turbulence est à ignorer, donc les 13 cibles passent en gris de 04:00 à 15:00 chaque jour ; c'est la fiabilité du journal, comme prévu par l'option A.
**Validé le 2026-10-24.**
2026-10-23 21:52:08 +02:00
### Point 26 : Options B à E : en réserve
**Ce que dit le rapport** (ordres de grandeur sur 3 jours d'exports horaires) :
- **B, médiane glissante de 3 h** (ou Hampel) : efface le train de NIEDERHORN (une heure à 14,83 mm sur un niveau de 9,9 ; médiane de 3 h : 9,95) ; garde la marche de CLARIDEN (−4,9 mm en deux paliers) en entier mais **en retard** de 1 h (2 h avec 5 h) ; ne change rien à WILDSTRUBEL (bruit horaire 0,03 à 0,12 mm pour un cycle de 0,3 à 0,75 mm). À faire seulement si le client veut plus lisse, mesuré d'abord sur NIEDERHORN et CLARIDEN, sous le nom « Smoothed (3 h median) », jamais confondu avec la nettoyée.
- **C, moyenne pondérée par `error_value`** : à CLARIDEN, l'erreur de la cible qui saute triple (0,02 → 0,06) **à la marche réelle** : la pondération la rendrait moins crédible ; fonction de poids sans source. Écartée pour l'instant.
- **D, retrait du profil journalier** : sur 3 jours, il aggrave (WILDSTRUBEL, PA3_2, crête à crête 0,46 → 0,67 mm) ; il faut des semaines d'historique ; la dilatation est aussi un mouvement réel. Seulement si le point 24 demande « sans le cycle ».
- **E, Kalman ou lissage centré avec bande d'incertitude** : le plus lourd, réglage sans source ; attend une incertitude par cible (roadmap §5.5).
**Étapes.**
- [ ] Rien tant que l'utilisateur ne le demande ; si oui, B d'abord, comme ci-dessus.
**Ce que change le point 24 (2026-10-24).** D tombe : le cycle thermique reste tel quel. B perd son retard : le calcul se fait quand le client regarde, donc une médiane **centrée** de 3 h (l'heure d'avant, l'heure, l'heure d'après) ne décale plus la marche de CLARIDEN ; seule la dernière heure reste sans voisine d'après. Reste son défaut : un vrai choc d'une heure disparaît. C et E inchangés.
**Validé le 2026-10-24** : B à E restent en réserve (l'utilisateur), la courbe nettoyée du point 25 suffit.
2026-10-23 21:52:08 +02:00
---
## Partie VI — Données en masse et boucle Claude
Rapport de l'agent : `vues-deplacements/contexte/donnees-et-boucle.md`. Script : `extraction/pomper.py` (153 l) et `extraction/README.md`, brouillon jamais lancé. Ce qu'il faut savoir :
- les mesures sont dans une base **PostgreSQL / TimescaleDB partagée avec la production** ; les images dans un stockage S3 (Garage), par `measurement_uuid` ;
- l'export « advanced » reçu à la main est la sortie de `build_advanced_frame` (`app/datapoints.py:285` du dépôt `~/monitoring-dashboard`) : le script le reproduit à l'identique, environ 0,3 Mo par jour et par station ;
2026-10-23 21:52:08 +02:00
- le script ouvre un moteur **en lecture seule** (`default_transaction_read_only=on`, délai de 60 s, fuseau UTC), comme `scripts/domain_diagnostics.py` de l'application, déjà lancé avec succès dans le container le 2026-10-21 ; il n'instancie pas `DatabaseEngine` (son `__init__` lance du DDL et un écouteur NOTIFY) ; `AggregateEngine` est sans effet à sa construction (vérifié dans `app/aggregates.py`) ;
- il lit un jour par requête, fait une pause, reprend où il s'est arrêté, et lit par **numéro de série du système** (`System.serial_number`) ;
- l'authentification de l'application (formulaire ou Auth0) ne garde que les routes HTTP ; la base et S3 sont atteintes par un compte de service (`AIMSIGHT_DATABASE_*`, `AIMSIGHT_S3_*`) ; HTTP est un mauvais chemin aujourd'hui (route parquet par cookie de session, routes d'images `/api/v1` en erreur 500, export CSV par une tâche Celery) ;
- volume : les mesures se comptent en Mo ; les images dominent (environ 1 Go pour 40 jours d'une station à l'heure, six fois plus à 10 min) ; quelques centaines de Go suffisent ; la limite sera le temps de lecture de la base.
### Point 27 : Premier pompage (option A)
**C'est l'utilisateur qui lance** ; Claude prépare et lit les résultats.
**Étapes.**
- [x] Choisir avec l'utilisateur une station déjà reçue à la main, pour comparer (NORDEND, PS des Coudres…), et son **numéro de série de système** (celui de l'URL de la page System). NORDEND, numéro de série `NORDEND` (2026-10-26).
- [x] Dans le container, depuis la racine de l'application, hors des heures chargées, un essai de 2 jours, la commande de `extraction/README.md` (le container monte `~` sur `/workspaces` : le script écrit directement dans `data/<SERIE>/`, sans copie) ; noter le temps par jour. Fait le 2026-10-26, 29 et 30/07 : métriques 1-2 s par jour, déplacements 9 s pour le 29/07, images et images différentielles 24 par jour ; déplacements du 30/07 en échec (`DatabaseError`).
- [x] Claude compare le CSV obtenu à l'export reçu pour la même plage : colonnes, UTC, nombre de lignes (script en bibliothèque standard, `donnees.charger` sur les deux dossiers) ; il lance `categories.py` (ou les détecteurs) sur le nouveau dossier. Fait pour le 29/07 : 2 112 lignes, colonnes et valeurs identiques à l'export reçu ; métriques identiques heure par heure ; images IRON identiques octet pour octet. `categories.py` attend le 30/07 (3 jours d'historique).
- [x] Si l'unité d'acquisition n'est pas unique (règle MER* / ME2S* de `app/base/models.py:268`), le noter. Rien à noter : unité trouvée.
- [x] Noter le résultat dans `donnees-et-boucle.md`, section « Ce qui reste à vérifier », et dans l'index.
- [x] Relancer la même commande (seuls les déplacements du 30/07 manquent) ; lire la cause de l'échec, que le script affiche maintenant. Cause (2026-10-26) : délai de 60 s dépassé (`QueryCanceled`), alors que le 30/07 a autant de mesures que le 29/07 (2 090 lignes contre 2 112 dans l'export reçu) ; option `--delai` ajoutée, relance du 30/07 seul avec `--delai 300` : 93 s, 2 090 lignes, identiques à l'export reçu. `categories.py` sur le dossier pompé : mêmes événements que sur l'export reçu réduit aux mêmes jours ; avec l'export entier (historique dès le 27/07 22:00), la toile de E-002 devient un seul événement `visibilite_reduite` du 28/07 20:45 au 30/07 23:45, coupé en morceaux sans historique : pomper 3 jours de plus avant la période voulue.
2026-10-23 21:52:08 +02:00
**Fini quand.** Un dossier pompé donne les mêmes mesures que l'export reçu, et le temps par jour est connu.
**En attente depuis le 2026-10-24.** L'utilisateur n'a pas accès aux données pour l'instant ; le script sera essayé plus tard, quand le harnais qui exploite les données pompées existera (points 30 et 31). Mis en place sans rien lancer :
- l'application de référence est `~/monitoring-dashboard` (l'utilisateur) ; les dossiers `-displacement` et `-metrics` ne sont que des branches, à ignorer ; README, script, plan et `donnees-et-boucle.md` corrigés ;
- le script relu contre ce code : `build_advanced_frame` y est (`app/datapoints.py:285`) et rend les colonnes de l'export reçu (`time_utc`, `sensor_name` … `pattern_type`, puis les métriques de qualité) ; les trois fonctions reprises de `DatabaseEngine` n'utilisent que `_session`, `aggregates` et `s3client`, que `ReadOnlyDB` fournit ;
- la sortie se branche telle quelle sur le journal : `donnees.charger` lit tous les CSV « advanced » d'un dossier (un par jour, doublons écartés) ; les images pompées portent le nom attendu (`<AAAAMMJJ>T<HHMM>Z_<id>`, D-045) ; les images différentielles (`images_diff/`) sont maintenant laissées de côté par `donnees.trouver`, pour ne pas passer pour des vues de la caméra ;
- à savoir : un dossier pompé n'a pas d'export horaire, donc le Journal s'ouvre en px, et l'onglet Displacements (et la dérive lente) reste vide.
2026-10-23 21:52:08 +02:00
### Point 28 : Images différentielles
**Ce qui existe.** Type de mesure `OPTICAL_SHIFT-DIFF`, en PNG, seulement sur les stations réglées en mode « Differential » ; lesquelles et à quelle cadence : inconnu. Le script les prend avec `--diff`, rangées dans `images_diff/`. D'après le manuel de la station, ce n'est pas la différence entre deux instants mais l'image des réflecteurs, contraste renforcé, celle que mesure l'algorithme par défaut (`labeling/connaissances/images-de-la-camera.md`). L'utilisateur les juge peu utiles pour `/boucle` et `/aiguiser` (2026-10-26) : `--diff` reste une option, hors de la commande de `run.md`.
2026-10-23 21:52:08 +02:00
**Étapes.**
- [ ] Au premier pompage avec `--diff`, compter les images différentielles par jour ; si une station en a, en regarder quelques-unes avec l'utilisateur ; NORDEND en a (2026-10-26) : 24 par jour à une par heure, PNG 16 bits 3088×2064, ~7 Mo l'une ; le 29/07, pendant E-002 (toile d'araignée selon l'expert), de longues traînées claires sur tout le champ et les cibles en points, là où l'image brute ne montre que de faibles bandes sombres ; à confirmer par l'utilisateur : montrent-elles ce qui a changé (toile, eau, neige) mieux que l'image brute ?
2026-10-23 21:52:08 +02:00
- [ ] Si oui : les ajouter au processus « images » (point 7), après l'image brute.
### Point 29 : Options B (depuis WSL) et C (route du collègue)
**B** : le même script lancé depuis WSL, hors container (l'idée de l'utilisateur : se connecter avec les identifiants de l'application, ne récupérer que le nécessaire, et faire le même travail dans un petit site HTML / JS local) ; il faudrait que la base y soit joignable (test `nc -z` par l'utilisateur, hôte lu dans `.env` sans l'afficher), installer sqlalchemy, psycopg2, boto3 et pandas, et copier les identifiants de l'application sur une seconde machine. Seulement si le test réseau passe et si l'utilisateur l'accepte.
**C** : demander au collègue une route d'export ; questions à lui poser : qui délivre un jeton Bearer avec la portée `reads:explore` (`auth_auth0.py`) ; correctif des routes d'images `/api/v1` (erreur 500) ; une route d'images par plage. Seulement si la boucle (point 31) prouve sa valeur.
**Étapes.**
- [ ] Après le point 27, demander à l'utilisateur s'il veut tenter B ; sinon, rien.
### Point 30 : L'outil de tri en lot
**Pourquoi.** La boucle a besoin de faire tourner tous les détecteurs sur beaucoup de tranches sans coût de Claude.
**Interfaces.**
- Consomme : `categories.evenements(mesures)` (point 6) ; `donnees.filtrer(mesures, debut, fin)`.
- Produit : `python3 detectors/categories.py <dossier> [--du AAAA-MM-JJ --au AAAA-MM-JJ] [--tranche 3]` : une table par tranche (début, fin, catégorie, grisé, capteurs, épisodes absorbés), plus une ligne « rien » pour les tranches calmes.
2026-10-23 21:52:08 +02:00
**Étapes.**
- [x] Ajouter `--du`, `--au`, `--tranche` (jours, défaut 3) au `__main__` de `categories.py` ; chaque tranche est classée seule (comme le verrait le client un matin). Fait avec `--tranche` sans valeur par défaut (sans elle, un seul passage, l'usage documenté ailleurs), plus `--historique` (voir plus bas).
- [x] Lancer sur NORDEND d'octobre en tranches de 3 jours ; comparer à un seul passage sur 11 jours : noter ce qui change (point d'attention 5).
**Fait le 2026-10-24.** `python3 detectors/categories.py <dossier> --tranche 3 [--historique 3] [--du AAAA-MM-JJ --au AAAA-MM-JJ]` : un en-tête par tranche (« == début → fin : n » ou « rien »), puis une ligne par événement comme avant ; sans `--tranche`, la sortie d'avant, inchangée (vérifié). Résultat sur NORDEND d'octobre (11 jours, 4 tranches) :
| | Passage unique | Tranches seules | Tranches + 3 jours d'historique |
|---|---|---|---|
| « Shift to check » PR17, 08/10 02:30 | oui | **absorbé** : pris pour un saut revenu dans la buée | oui |
| Cycle thermique les 06 et 07/10 (8 cibles) | non (laissé sous `PART`, point 13) | oui | oui (première tranche : pas d'historique possible) |
| « Target hidden » 13/10 09:45 → 14/10 07:00 (4 cibles) | oui | perdu le 13 ; 14/10 00:00 → 07:00, 2 cibles | 13/10 16:15 → 14/10 07:00, 3 cibles |
| Passage et « Target hidden » du 12/10 14:15 | oui | oui | non |
| Buée du 07/10 17:15 au 08/10 12:15 | un événement | coupée à minuit en deux | un événement |
| Nombre de cibles par événement | — | souvent plus bas (15 à 19 au lieu de 20) | proche |
**Ce que ça dit.** Le point d'attention 5 est réel : les détecteurs prennent leurs niveaux habituels (médiane, MAD, quartile, part des cibles) sur toute la fenêtre qu'on leur donne, donc une tranche courte change les étiquettes. Le plus grave : une tranche qui commence 2 h 30 avant le saut de PR17 le range en saut revenu, absorbé dans la buée (point d'attention 1). Avec 3 jours d'historique (`--historique 3` : les détecteurs voient les 3 jours d'avant, seuls les événements qui touchent la tranche sont montrés), PR17 revient et le reste est proche du passage unique, sans lui être identique. **Recommandation** : toujours donner aux détecteurs plusieurs jours d'avant la plage montrée, dans la boucle (point 31) comme dans la vraie application (point 36), où le calcul se fait quand le client regarde (point 24) ; à faire décider par l'utilisateur.
**Décidé le 2026-10-24** (l'utilisateur) : 3 jours d'historique par défaut dans l'outil (`--historique 3`), et c'est la règle pour la boucle et la vraie application ; noté sous D-056.
**Validé le 2026-10-24.**
2026-10-23 21:52:08 +02:00
### Point 31 : La boucle Claude, première séance
**Le principe** (rapport de l'agent, 8 étapes) : hors ligne, à la main de l'utilisateur, jamais au chargement de la page.
1. **Liste** : l'utilisateur donne les stations et la plage ; `extraction/plan.md` les range en tranches de 3 à 5 jours.
2. **Pompe** : l'utilisateur, dans le container (point 27).
3. **Tri sans image** : l'outil du point 30 ; coût : l'ordinateur seul.
4. **Regard de Claude, choisi** : seulement les tranches où le tri voit quelque chose, ou ne voit rien malgré un signal fort (saut ou tendance de l'onglet Displacements), et seulement les courbes et 4 à 8 vignettes par événement ; un **plafond de tranches par séance**, fixé à l'avance.
5. **Critique** : par événement, d'accord, en retard, en trop, ou manquant ; verdict écrit dans un fichier de revue de la tranche, hors de tout dossier de station (règle de `vues-deplacements/CLAUDE.md`).
6. **Proposition** : au plus deux sorties : un réglage chiffré d'un détecteur, avec les événements qui changent, ou un event candidat (créé seulement si l'utilisateur lance `/new-event`).
2026-10-23 21:52:08 +02:00
7. **Rejeu** : le détecteur modifié est relancé sur **toutes** les tranches déjà vues ; on ne passe à la suite que s'il ne casse rien.
8. **Arrêt** : au plafond, ou quand deux tranches de suite ne donnent plus rien à corriger.
**Étapes** (remplacées le 2026-10-24 par la conception approuvée, `vues-deplacements/contexte/boucle-automatique.md`, D-057 ; le principe en 8 étapes ci-dessus reste pour l'histoire : plus de plafond, plus de rejeu, les réglages et les events sans accord préalable).
2026-10-24 15:14:14 +02:00
- [x] Construire la boucle : plan `docs/superpowers/plans/2026-10-24-boucle-automatique.md`, tâches 1 à 6 (skills `boucle` et `critiquer-lot`, agents `analyste`, `upgrader`, `validateur`, `builder`, fenêtre d'`anonymiser.py`, D-057).
- [x] Essai (2026-10-24) : l'analyste seul sur le lot 1 de NORDEND d'octobre (05/10 → 09/10) : verdict « suggestions » (deux : une référence rejetée qui fausse la compensation de toutes les cibles, fondue dans un épisode au lieu d'être grisée ; un nombre de capteurs faux dans la phrase de la buée), une nouveauté (halo sur la vitre sous PR17 au saut du 08/10 02:30, cause non établie), la buée du 07/10 au 08/10 retrouvée ; 53 appels d'outils, ~250 000 jetons, 8 min 30 (Opus, effort élevé ; les images pèsent le plus). **Fonctionnement validé par l'utilisateur le 2026-10-24.**
- [ ] Première séance (tâche 7 du plan), **par l'utilisateur seul**, plus tard : sur de nouvelles données, lot par lot (il choisit les lots, traités indépendamment ; « on verra comment on fait »), quand les autres développements seront faits ; Claude ne la lance pas. Ensuite, Claude fait les contrôles de la tâche 7 et résume le bilan.
- [ ] Préparer la séance sur NORDEND de septembre (idée de l'utilisateur, 2026-10-26 : « prévoir et créer les lots »), **après `/aiguiser` sur les mêmes données** (point 42, choix de l'utilisateur le même jour) ; septembre pompé dans `data/NORDEND/` (d'abord dans `out/pompage/`, D-065), depuis le 01/09. **Aucun lot à créer** : `/boucle` les découpe elle-même, ce sont les tranches de `categories.py --tranche 4` (essayé sur les 4 premiers jours pompés : un lot, 7 événements). À préparer : les 3 jours d'historique (29 au 31/08, même commande avec `--du 2026-08-29` : la relance ne prend que ce qui manque), sinon lancer la séance avec `--du 2026-09-04` ; les images (`--images`, pompées après tous les déplacements) ; garder `data/NORDEND/` (hors git, D-065) : les étiquettes de septembre ne se comptent que sur les données de NORDEND ; choisir les lots : le tri sans image du mois (`categories.py data/NORDEND --tranche 4`, gratuit) donne les événements de chaque lot, l'utilisateur choisit.
- Règle (point 30, D-056) : chaque tranche est classée avec 3 jours d'historique, le défaut de l'outil.
2026-10-23 21:52:08 +02:00
**Fini quand.** Une séance complète a eu lieu et son bilan est dans `donnees-et-boucle.md`.
**En attente depuis le 2026-10-24.** L'utilisateur a des consignes plus précises sur la boucle, qu'il donnera dans une autre conversation, et il faut les données (point 27). Rien n'a été créé (ni `extraction/plan.md`, ni `vues-deplacements/revues/`). Proposé puis écarté pour l'instant : une séance à blanc sur NORDEND d'octobre et PS des Coudres, les seuls jeux assez longs pour des tranches.
2026-10-24 15:14:14 +02:00
**Consignes de l'utilisateur reçues le 2026-10-24 (brainstorming en cours, rien de décidé ni construit).** Une boucle automatique dans Claude Code : un skill orchestrateur qui appelle des sous-agents, chacun avec son rôle et ses skills ; une station, plusieurs semaines, découpées en lots de 4 à 5 jours, lots indépendants (en parallèle possible).
- **Données** : un script plutôt qu'un agent, depuis la base ou des CSV téléchargés (pompage du point 27, ou CSV à la main).
- **Analyste** : lance les détecteurs sur le lot, puis juge leurs résultats (« LLM as judge ») en regardant lui-même les données et les images, avec un skill de critique ; verdict positif (lot suivant) ou suggestions.
- **Upgrader** : reprend les suggestions et modifie les détecteurs.
- **Validateur** : ne refait pas l'analyse ; vérifie que la modification répond à ce qu'a relevé l'analyste et va dans le bon sens ; **pas trop strict** (aucune modification n'est parfaite) ; aller-retour avec l'upgrader jusqu'à son accord.
- **Builder** : tout ce que l'analyste découvre de nouveau devient un event structuré comme ceux de la base, pour les agents de diagnostic (automatiser ce qui se fait aujourd'hui à la main avec `/new-event`).
- **Ce que la boucle doit laisser** (l'utilisateur) : avoir appris : de nouveaux events tirés des événements des données (le builder construit la base de connaissances), et des détections optimisées (l'upgrader) ; l'analyste et le validateur sont les juges qui y mènent.
2026-10-24 15:14:14 +02:00
- **Précision** (l'utilisateur) : en cas de doute sur les rôles (surtout entre upgrader et validateur), se fier à ses premières consignes, ci-dessus ; d'autres transcriptions suivront.
- **Rôles reformulés par Claude, acceptés par l'utilisateur le 2026-10-24** (« parfait »), avec les ajouts de Claude : les agents ne se parlent pas, chacun écrit son rendu dans le dossier de la séance et l'orchestrateur le transmet ; au plus 3 allers-retours upgrader / validateur, puis on garde la dernière version qui va dans le bon sens ; plusieurs analystes en parallèle plus tard, l'upgrader toujours seul ; les events du builder marqués « appris par Claude, non validé », lus par les analystes des lots suivants (même base que les autres, voir plus bas) ; modifications des détecteurs sur une branche git à part ; déplacements seulement.
- **Réponses de l'utilisateur le 2026-10-24** : tout se commite, chaque modification, pour s'y retrouver et revenir en arrière ; le builder ajoute les events sans attendre (« ça ne peut pas vraiment faire de mal »), une revalidation à la main viendra peut-être plus tard, pas maintenant ; l'upgrader modifie les détecteurs seul, « essayer et voir dans quelle direction ça va » ; **pas de rejeu** des lots déjà vus : on explore des données et on améliore peu à peu, sans chercher l'exhaustif ni tout revalider à chaque fois (remplace le rejeu de l'étape 7 et l'ajout de Claude) ; la crainte : **partir dans trop de complexité**.
2026-10-24 15:14:14 +02:00
- **Conception écrite le 2026-10-24** : `vues-deplacements/contexte/boucle-automatique.md`, **approuvée** par l'utilisateur le 2026-10-24 ; plan de construction : `docs/superpowers/plans/2026-10-24-boucle-automatique.md` (7 tâches) ; rien construit.
- **L'agent de diagnostic n'entre pas en jeu dans la boucle** (l'utilisateur, 2026-10-24) : il n'y a aucun travail, ses consignes ne changent pas ; il sert au diagnostic pour l'utilisateur et sera traité dans une autre conversation. Tous les events restent au même endroit : le builder complète la base `events/` (E-006…, marqués « appris »).
2026-10-24 15:14:14 +02:00
2026-10-23 21:52:08 +02:00
### Point 32 : Le test « Claude verrait la même chose »
**Pourquoi.** L'objectif fixé par l'utilisateur : « si je venais donner à Claude ces données, il puisse voir par lui-même qu'on a bien catégorisé les choses » ; notre solution doit dire ce que Claude dirait.
**Étapes.**
- [ ] Proposer à l'utilisateur (ne pas lancer d'office : règle « cas sans relance ») de donner à l'agent de diagnostic une tranche **sans** le journal : `@agent-diagnostic <dossier> Qu'est-ce qui s'est passé entre <début> et <fin> ? Une catégorie par moment.`
- [ ] Comparer ses catégories à celles du journal, moment par moment ; noter les écarts dans une revue (point 31, étape 5).
- [ ] Commencer par une tranche dont la vérité est connue (NORDEND d'octobre, 13/10 → 16/10).
**En attente depuis le 2026-10-24** : l'utilisateur le traitera dans une autre conversation.
### Point 42 : Aiguiser la lecture : les outils de lecture de Claude
**Pourquoi** (l'utilisateur, 2026-10-24). L'analyste et l'agent de diagnostic jugent à partir des données ; pour bien juger, il faut bien lire. La lecture n'est pas le diagnostic : s'ils lisaient avec les détecteurs, ils seraient biaisés et tendraient à les valider. Un autre processus automatique, à part de `/boucle`, ne travaille que sur les outils de lecture, lot après lot, pour « aiguiser la vision de Claude ».
**Le principe** (brainstorming du 2026-10-24, accepté par l'utilisateur) : un skill de lecture, `lire-les-donnees`, seule source des outils et de leur mode d'emploi, suivi par l'analyste, l'agent de diagnostic et un **lecteur** ; un **correcteur** lit chaque lot à fond avec ses propres scripts, sans ces outils, et cette lecture lente sert de corrigé ; un **optimiseur** modifie le skill d'après l'écart ; un changement sans gain est annulé ; contrôle sur E-001 à E-005 en fin de séance ; `/aiguiser <dossier>`, lancé par l'utilisateur seul.
**Étapes.**
- [x] Conception écrite : `vues-deplacements/contexte/aiguiser-la-lecture.md`.
- [x] Approbation de la conception par l'utilisateur (2026-10-24).
- [x] Plan de construction : `docs/superpowers/plans/2026-10-24-aiguiser-la-lecture.md` (6 tâches).
- [x] Construction (tâches 1 à 5 du plan, D-059) : skill `lire-les-donnees`, agents `lecteur`, `correcteur`, `optimiseur`, skill `/aiguiser`, avec le releveur (D-060).
- [x] Essai (2026-10-24) : lecteur et correcteur sur le lot 1 de NORDEND d'octobre, sans l'optimiseur ; écart `à reprendre`, deux défauts (positions brutes devant une vague commune ; chaque capteur face à lui-même) ; ~210 000 et ~136 000 jetons ; détail au §9 de la spec.
- [ ] Première séance, **par l'utilisateur seul**, dans une session neuve : `/aiguiser <dossier> [--du … --au …]` ; Claude ne la lance pas (tâche 6 du plan).
- [ ] **Avant `/boucle`** (l'utilisateur, 2026-10-26 : les données de septembre sont nombreuses, d'abord affiner la lecture) : première séance sur NORDEND, lot du 01 au 04/09 pompé (`/aiguiser data/NORDEND --du 2026-09-01 --au 2026-09-05`, un lot), quand les images seront pompées (aucune encore le 2026-10-26). Constaté sur ces jours avec les outils actuels : 22 capteurs sur un même graphique, couleurs répétées (CTR02 et PR17 en bleu, CTR03, PR08 et PR18 en orange), on ne sait plus qui est qui ; beaucoup de petits moments (PR04 rejetée 323 fois sur 12 jours, CTR01 plus haute chaque jour, pics à 1,0 de PR07 et PR16 le 03/09 vers 22:00, après-midi agité du 04/09, deux creux de CTR04 en `corr_x` le 04/09 vers 11:15 et 13:45) ; un trou d'une ou deux mesures chaque nuit vers 01:00 ; `inventaire.py` liste un à un les ~800 fichiers de métriques du dossier pompé (880 lignes, 72 ko) : à raccourcir avant la séance si l'utilisateur le veut.
**Fini quand.** `/aiguiser` est construit et son essai montré à l'utilisateur ; les séances, il les lance lui-même.
2026-10-23 21:52:08 +02:00
---
### Point 43 : Une base locale complète et incrémentale, pilotée par Claude
**L'idée** (l'utilisateur, 2026-10-24). Avant de lancer la boucle sur de nouvelles données, récupérer en local, dans `data/<STATION>/`, tout ce que la base a pour les stations et les périodes qu'il choisit (par exemple une station, les 3 dernières semaines) : toutes les métriques, les déplacements, les images IRON et différentielles. Une relance complète ce qu'on a déjà, sans rien re-télécharger. Pas de vraie base de données : des fichiers (CSV, ou un format plus simple s'il y en a un). Claude pilote : l'utilisateur lui dit quoi pomper (à discuter). Dans le container, ou dehors si possible.
**Fait le 2026-10-24** dans `extraction/pomper.py`, sans rien lancer (mode d'emploi : `extraction/README.md`) :
- métriques système : toutes celles de la station, une requête par jour, au format du téléchargement de la page System de l'appli (la requête de `System.get_metrics(..., bucketing="1 hour")`, qui compte en heures avant maintenant, refaite sur un jour fixe : moyenne horaire × `transform_factor` + `transform_offset`, ou la liste des valeurs d'une métrique texte, une ligne vide pour une heure sans mesure) ; un CSV par métrique et par jour, `<SERIE>_<métrique>_<AAAA_MM_JJ>_00_00 to <AAAA_MM_JJ>_23_00.csv`, dans `metrics/` du dossier de la station ;
- déplacements : un fichier par jour, `displacement/<SERIE>_advanced_<AAAAMMJJ>.csv` ; la relance ne lit que les jours absents, quelles que soient les dates ; le jour en cours n'est jamais pompé ; un jour pompé avant la fin de la synchronisation de la station reste incomplet : supprimer ses fichiers ;
- images : le défaut de reprise corrigé (une image déjà là compte pour sa tranche) ;
- une station sans unité d'acquisition reconnue a quand même ses métriques ;
- `common.stations.load_stations` fusionne plusieurs fichiers d'une même métrique (avant : erreur « doublon ») ; vérifié sur WEISSHORN découpé en 1 782 fichiers d'un jour : les 27 séries identiques ; format du CSV des métriques vérifié hors base sur un jour réel de WEISSHORN (numérique, texte, heure vide).
- pilotage : Claude ne se connecte pas (règle de l'appli, `.claude/rules/diagnostics.md`) ; il lit `data/`, donne la commande des jours manquants, l'utilisateur lance.
- reste hors du script : l'export horaire en mm (il exige SQLite et Flask : le Journal s'ouvre en px) ; `data/` est suivi par git, décider avant de committer un dossier pompé avec ses images.
**Étapes.**
- [x] L'utilisateur choisit d'étendre le script avant le premier essai (2026-10-24).
- [x] Métriques système, un fichier par jour, défaut des images corrigé.
- [ ] Liste des types de mesure d'une station : non demandée, au point 33.
- [ ] Mouvements de la caméra (demande de l'utilisateur, 2026-10-26) : `pan`, `tilt`, `scale`, `rotation`, `sigma0` à la minute, médiane et bornes, par la lecture du visualiseur de la plateforme (`get_shifts_aggregate(..., "cam_movements_1min")`, comme `fetch_cam_movements_frame`), un CSV par jour dans `camera/` ; lus par `ensemble.py` et `inventaire.py`, pose lue en premier par le skill `lire-les-donnees` (2026-10-26, D-073). Essayé le 2026-10-26 sur le 30/07 de NORDEND (E-002) : 2 s, 70 lignes, une par mesure (toutes les 15 min, min = max) ; sur les 95 instants des déplacements, 70 ont une pose de la caméra (pan de −0,059 à −0,010, tilt de −0,089 à −0,020), dont 7 seulement un `sigma0`, les mêmes que l'export « advanced » ; les 25 autres, surtout de 15:15 à 22:45, n'ont ni pose ni `sigma0` : pas de recalage de la caméra. La pose existe donc là où l'export n'a pas de `sigma0`. Reste le 29/07.
- [x] Premier lancement par l'utilisateur, avec le point 27 (2026-10-26, les métriques identiques à l'export de la page System) ; comparer aussi une métrique pompée à un export reçu de la page System (WEISSHORN ou NORDEND, même plage).
- [x] `data/` hors de git, seule sortie du pompage (l'utilisateur, 2026-10-26, D-065) : `.gitignore`, `run.md`, `extraction/README.md`, `/aiguiser`, `/boucle` et `/new-event` sur `data/<SERIE>` ; plus de `out/pompage/`.
- [ ] L'utilisateur vide `data/` et repompe les plages des exports reçus, élargies (commandes données le 2026-10-26) ; `out/pompage/NORDEND/` copié dans `data/NORDEND/` à la fin de la séance `/boucle` en cours ; numéro de série de PS des Coudres à trouver (URL de sa page System). Puis Claude vérifie : `inventaire.py`, `categories.py`, les scripts des domaines sur VERMONT, WEISSHORN et NORDEND.
**Fini quand.** Une commande donnée par Claude remplit `data/<STATION>/` sur la période choisie, et sa relance ne télécharge que ce qui manque.
### Point 44 : Un modèle appris à côté de la boucle
**L'idée** (l'utilisateur, 2026-10-25). En complément de la boucle, un algorithme de machine learning, pas très poussé, entraîné sur ce que la boucle a labellisé (pendant une séance ou après), qui fasse le travail des détecteurs : classer les moments dans les catégories du journal (perte de visibilité, passage, cible masquée…).
**Constaté le 2026-10-25.**
- Les labels existent déjà : la table « 1. Ma lecture » de chaque `critique.md` (début, fin, capteurs, ce que l'analyste voit, catégorie), écrite avant de voir les détecteurs. Mais en texte libre (« ~08:30 », « idem », « dilatation / contraction thermique ») : un script ne peut pas la lire.
- Très peu de données : 6 jeux, ~30 jours de station, quelques dizaines d'événements ; aucune séance de la boucle lancée.
- D-044 a écarté un « modèle appris » dans la couche de correction : une nouvelle décision le rouvrirait.
**Proposition de Claude, à discuter.**
1. Tout de suite : l'analyste écrit aussi ses labels dans un `etiquettes.csv` strict (début et fin ISO UTC, capteurs, clé de catégorie de `categories.py`) ; un script compare une version des détecteurs à toutes les étiquettes déjà écrites : le rejeu, écarté parce qu'il coûtait un regard de Claude, devient gratuit.
2. Quand il y aura assez d'étiquettes (quelques dizaines d'événements par catégorie, sur au moins 4 ou 5 stations) : un arbre de décision peu profond, entraîné sur le poste de dev, sur des grandeurs concrètes par cible et par mesure (`error_value` face à son niveau habituel, part des cibles rejetées au même instant, références touchées, saut de `corr` et retour, heure) ; validé en laissant une station de côté, testé sur E-001 à E-005 (labels de l'expert, jamais appris). Lisible (une suite de « si… alors »), embarquable (quelques `if` en bibliothèque standard).
3. Son rôle : à côté des détecteurs, pas à leur place : ses désaccords avec eux choisissent les lots que regarde l'analyste (question ouverte de la boucle), ses coupures proposent des seuils à l'upgrader. « Shift to check » reste aux détecteurs : un vrai mouvement est trop rare pour être appris, et il n'est jamais invalidé.
**Réponse de l'utilisateur (2026-10-25).** Bonnes pistes ; pas de modèle tout de suite : d'abord faire tourner la boucle elle-même. Mais préparer le terrain : chaque lot traité doit laisser des labels, réutilisables plus tard (« super important »). Il regardera ensuite ce que Claude a labellisé : comment lui donner cette visibilité, on verra plus tard.
**Fait le 2026-10-25 (D-061).**
- `<lot>/etiquettes.json`, écrit par l'analyste juste après sa lecture, avant les détecteurs : la station, le lot, puis un moment par ligne de sa lecture (`debut`, `fin`, `capteurs` tous nommés ou `[]` pour tous, `categorie` de la section 4 de la carte ou `aucune`, `evenement` : label du site d'une ligne de la section 1 ou `null`, `preuve` vue ou déduite, `description`, `apres_detecteurs`). Format dans `.claude/skills/critiquer-lot/SKILL.md`.
- Contrôle : `python3 .claude/skills/critiquer-lot/etiquettes.py <dossier> <etiquettes.json>` (vocabulaire lu dans la carte, noms de capteurs lus dans les données ; `--test` sur deux moments réels de l'essai de NORDEND) ; l'analyste corrige jusqu'à « bon », l'orchestrateur le relance et porte le résultat au bilan.
- Toutes les étiquettes : `boucle/*/lot-*/etiquettes.json`, commitées avec la critique, à garder même si une modification est annulée.
**Étapes.**
- [x] L'utilisateur dit le rôle du modèle : pas encore ; les labels d'abord (2026-10-25).
- [x] Étiquettes strictes, écrites à chaque lot (2026-10-25).
- [ ] Première séance de la boucle par l'utilisateur : regarder les premières étiquettes réelles.
- [ ] La visibilité de l'utilisateur sur les étiquettes (une page, une revue) : plus tard, sur sa demande.
- [ ] Le rejeu gratuit (les détecteurs comparés à toutes les étiquettes) : sur demande.
- [ ] Le modèle (arbre de décision peu profond, à côté des détecteurs) : quand il y aura assez d'étiquettes, sur demande.
**Fini quand.** Chaque lot de la boucle laisse des étiquettes bonnes au contrôle (première étape) ; la suite reste à définir avec l'utilisateur.
### Point 45 : Le but de la boucle : chaque instant étiqueté, la précision mesurée
**L'idée** (l'utilisateur, 2026-10-25). Le but de la boucle n'est pas l'interface (images, frise) : c'est la détection. Sur tout le lot (4 jours), chaque instant doit être classé : données valides ou non, et sa catégorie ; un instant sans anomalie n'a pas besoin d'étiquette, mais aucun événement ne doit manquer. C'est la précision de cette détection que la boucle doit perfectionner, que l'algorithme final soit appris ou analytique.
**Constaté le 2026-10-25** (spec de la boucle, `critiquer-lot`, `etiquettes.py`, agents).
- Conforme : la boucle ne touche qu'aux détecteurs (`detectors/*.py`, registre des seuils), jamais à la maquette ; les images ne servent que de preuve à l'analyste. L'analyste lit tout le lot avant les détecteurs ; ses étiquettes couvrent le lot (un instant sans moment : rien vu).
- Écarts :
1. la validité n'est pas une étiquette : elle se déduit de la catégorie (zone grisée ou non, `ignore` de `categories.py`), sauf pour la turbulence (grisée si forte seulement) et `aucune` ;
2. la précision n'est pas mesurée : la comparaison de l'analyste et le jugement du validateur sont qualitatifs (« va dans le bon sens ») ; ni l'upgrader ni le validateur ne lisent les étiquettes ;
3. pas de rejeu : une modification faite au lot 3 n'est jamais vérifiée sur les étiquettes des lots 1 et 2 (régression possible) ;
4. les images sont vues par vignettes toutes les 2 à 3 h, plus serrées là où les courbes bougent : un événement court et invisible sur les courbes peut manquer aux étiquettes.
**Proposition de Claude, à discuter.** Un script de score, en bibliothèque standard : la sortie des détecteurs face à toutes les étiquettes déjà écrites, mesure par mesure et capteur par capteur (valide ou non, catégorie) ; par catégorie, la part des instants anormaux trouvés et la part des instants signalés à tort. Le validateur s'en sert : une modification gardée fait monter le score du lot sans le faire baisser sur les lots d'avant. C'est le rejeu gratuit du point 44, avancé. Un champ `validite` explicite dans les étiquettes si la catégorie ne suffit pas.
**Questions à l'utilisateur.**
1. Validité : trois niveaux (valide, avec prudence, à ignorer : les zones actuelles du journal) ou deux ?
2. Précision comptée par instant (chaque mesure de chaque capteur) ou par événement (trouvé ou non, bornes à une tolérance près) ?
3. Validité par capteur (comme les étiquettes aujourd'hui) ou de toute la station à un instant ?
**Réponse de l'utilisateur (2026-10-25).** Il ne sait pas encore : Claude essaie l'implémentation qui lui paraît la meilleure, avec un test ; l'utilisateur lancera une séance de la boucle dès qu'il aura des données, puis on adaptera.
**Fait le 2026-10-25 (D-062).** Choix de Claude : trois niveaux, un compte par mesure, par capteur.
- `.claude/skills/boucle/score.py <dossier> [etiquettes.json …]` (défaut : toutes les étiquettes de la station sous `boucle/`) : par lot et au total, pour « à ignorer », « prudence » et chaque catégorie, « trouvées » et « justes » ; un lot dont les étiquettes ont des défauts est sauté ; `--test` sur le lot 1 de NORDEND d'octobre (étiquettes copiées des détecteurs : tout juste ; une catégorie oubliée, une étiquette en plus).
- L'orchestrateur écrit `<lot>/score-avant.txt` après l'analyste et `<séance>/score-fin.txt` au bilan ; l'upgrader et le validateur le relancent après une modification et le comparent ; consigne du validateur : la catégorie en cause monte sur le lot, sans baisse nette (un événement entier) sur les lots d'avant.
- Consigne des étiquettes (`critiquer-lot`) : bornes à la mesure près ; un saut qui dure, la mesure du saut seule (convention de `sauts.py`).
- Essai sur les deux seules étiquettes réelles gardées de l'essai de l'analyste (NORDEND, lot 1) : le script tourne (6 512 cases, ~4 s) ; il a montré l'écart de convention du saut de PR17 (l'analyste : 02:30 jusqu'à la fin du lot ; le détecteur : l'instant 02:30), d'où la consigne ; les autres chiffres ne disent rien (deux moments sur sa lecture entière).
**Étapes.**
- [x] Les choix, laissés à Claude (2026-10-25).
- [x] Le script de score, l'orchestrateur, l'upgrader et le validateur qui s'en servent (2026-10-25).
- [ ] Première séance de la boucle par l'utilisateur : lire `score-avant.txt` et `score-fin.txt`, revoir les trois choix.
**Fini quand.** Chaque modification de la boucle est jugée sur un score mesuré, sur toutes les étiquettes déjà écrites.
---
### Point 46 : La page de fin de séance : l'analyste face aux détecteurs
**L'idée** (l'utilisateur, 2026-10-26). À la fin d'une séance de la boucle, une page : la plage en largeur avec les courbes, dessous la classification de l'agent et celle des scripts analytiques, pour voir le diagnostic de l'un et de l'autre sur la même plage. Séance après séance, sur des lots différents, la boucle doit faire coïncider les deux.
**Fait le 2026-10-26 (D-066).** `.claude/skills/boucle/comparaison.py <dossier> <séance>` écrit `out/boucle_<séance>.html`, ouverte en fin de séance (§7 du skill `boucle`) : `corr_x` et `corr_y` de tous les capteurs (gris, références plus foncées, nom au survol), une ligne par catégorie présente, la barre bleue de l'analyste au-dessus de la barre orange des détecteurs (survol : capteurs, preuve, description ou phrase) ; en bas, en gris, la ligne « hors catégorie » : les moments `aucune` de l'analyste, vus mais hors des catégories du journal, sans effet sur les courbes le plus souvent, ou une nouveauté (E-007 et E-008 en viennent) ; retirés un moment à la demande de l'utilisateur (« rien d'anormal »), remis en gris parce qu'ils ne disent pas « tout va bien » ; sous la figure, le score de la séance (`score.py` sur ses étiquettes). Zoom par sélection, pas à la molette (l'utilisateur). Vérifié par capture sur la séance `2026-10-26T1414Z_NORDEND` (01 → 04/09).
**Étapes.**
- [x] La page, branchée en fin de séance (2026-10-26).
- [ ] L'utilisateur la regarde après sa prochaine séance : courbes `corr` ou `x`/`y`, lignes des catégories absentes, une page par séance ou pour toutes les étiquettes de la station.
**Fini quand.** À chaque séance, l'utilisateur voit d'un coup d'œil où l'analyste et les détecteurs divergent.
---
### Point 47 : Les détecteurs doivent tout détecter ; l'affichage à part
**L'idée** (l'utilisateur, 2026-10-26). « Les détecteurs doivent tout détecter. Ce qu'on montre au client ou pas n'est pas la question ici. » Sur le lot 01 de NORDEND (01 → 04/09), l'upgrader avait laissé le cycle thermique sur quelques cibles (suggestion S1) et les trous d'un ou deux pas, parce que ces réglages avaient été pris pour ce que voit le client (points 13 et 41, `MISSING`) ; le score les comptait « manqués » (301 mesures sur 370 étiquetées).
**Fait le 2026-10-26 (D-068).** Règle « tout détecter » dans les consignes de l'upgrader et du validateur, la spec de la boucle et le registre des seuils : un réglage pris pour l'affichage ne les arrête plus. Les points 13 et 41 restent validés pour ce qu'ils disent de l'affichage ; leur côté détection est rouvert.
**Étapes.**
- [x] La règle dans les consignes de la boucle (2026-10-26).
- [ ] Les détecteurs changés par la boucle (une séance, ou une reprise du lot 01) : cycle thermique sur quelques cibles, trous d'un pas, cible masquée sous `CIBLE_MIN`.
- [ ] La couche d'affichage : ce qu'on montre au client parmi tout ce que trouvent les détecteurs (avec l'utilisateur, plus tard) ; d'ici là, l'onglet `Journal` montre tout.
**Fini quand.** Le score mesure la détection seule, et l'onglet `Journal` filtre ce qu'il montre au client.
---
### Point 48 : Un benchmark des détecteurs sur la base d'events
**L'idée** (l'utilisateur, 2026-10-26, après le relevé du releveur « premier lot sans lot d'avant, cas de réglage hors du score »). Une étape benchmark dans `/boucle` : lancer les détecteurs sur les events de la base et mesurer leur correspondance avec le diagnostic de l'agent. Chaque event garde le diagnostic fait à sa création, pour que le benchmark soit purement analytique ; versionné, le score quantifié à chaque passage ; les agents qui améliorent les détecteurs en tiennent compte.
**Proposition de Claude (à valider).**
- **Le diagnostic d'un event** : `etiquettes.json` dans son dossier, au format des étiquettes de l'analyste (D-061), noms codés (`"station": "E-xxx"`, capteurs `C1`, `R1`…), figé à la création comme l'event. Le benchmark est alors `score.py` lancé sur le dossier de l'event avec ce fichier : rien à recoder. Essai du 2026-10-26, dans le scratchpad : les moments du lot 01 dans la fenêtre de E-006, recodés par le registre, donnent 6 moments, contrôle `etiquettes.py` « bon », et `score.py` tourne sans changement (`saut_bref` : 6 mesures trouvées sur 24, 6 justes sur 7).
- **Events appris** : `anonymiser.py` recopie, avec une option, les moments de l'analyste du lot qui touchent la fenêtre de l'event, bornés à la fenêtre et codés ; le builder s'en sert à la création.
- **Events validés E-001 à E-005** (pas d'étiquettes) : un passage unique de l'analyste, étiquettes seules, puis figées ; l'utilisateur les relit sur une page de comparaison.
- **`benchmark.py`** (à côté de `score.py`) : le score sur chaque event et au total, par catégorie ; une ligne par passage, cas et catégorie dans `vues-deplacements/benchmark/historique.csv` (date, séance, lot, étape, version des détecteurs `git rev-parse --short HEAD:detectors`, cas, catégorie, étiquetées, signalées, les deux) : la courbe du score dans le temps, version par version.
- **Dans `/boucle`** : au début de la séance (point de départ) ; après chaque modification, lancé par l'upgrader et lu par le validateur (un recul net est un défaut, une hausse un plus, pas un but : sur une dizaine d'events, les détecteurs se régleraient sur eux) ; après le builder, les nouveaux events y entrent ; en fin de séance, au bilan et sur la page. Il remplace le contrôle « Cas de la base » par `categories.py`, ajouté le même jour.
- **Limite** : la fenêtre d'un event appris est l'événement ± 6 h, sans les 3 jours d'historique d'un lot ; le benchmark mesure les détecteurs sur ce que l'event contient (piste : plus d'historique pour les mesures, les images restant à la fenêtre).
**Questions à l'utilisateur.**
1. Le « diagnostic de l'agent » d'un event : les étiquettes de l'analyste (mesurables), pas le rapport de l'agent de diagnostic (D-046, du texte) ?
2. E-001 à E-005 : un passage unique de l'analyste, que l'utilisateur relit ?
3. Le benchmark : garde-fou et bonus pour l'upgrader, pas un but à atteindre ?
**Réponses de l'utilisateur (2026-10-26).** Oui aux trois : « les étiquettes sont faites pour ça » ; passage unique de l'analyste sur E-001 à E-005, qu'il relira ; le benchmark en garde-fou et bonus.
**Fait le 2026-10-26 (D-069).** `anonymiser.py --etiquettes` (et son test) ; étiquettes de E-006 à E-008 recopiées du lot 01 de la séance de NORDEND, codées ; celles de E-001 à E-005 par cinq analystes en parallèle, lecture propre puis correction par la fiche (`events/E-00x/etiquetage.md`) ; `.claude/skills/boucle/benchmark.py` et `vues-deplacements/benchmark/historique.csv` ; branchement dans `/boucle` (orchestrateur aux trois moments, upgrader, validateur, builder, bilan, page de fin de séance), dans `/new-event` et la spec de l'agent de diagnostic (§11.1) ; le contrôle « Cas de la base » par `categories.py` est remplacé.
**Étapes.**
- [x] Les réponses de l'utilisateur.
- [x] Étiquettes des events, `benchmark.py` et son historique, branchement dans `/boucle` (2026-10-26).
- [ ] L'utilisateur relit les étiquettes de E-001 à E-005.
**Fini quand.** Chaque modification des détecteurs a un score sur toute la base d'events, gardé dans l'historique avec la version des détecteurs.
---
### Point 50 : Une ligne Status : la compilation de tous les détecteurs
**L'idée** (l'utilisateur, 2026-10-27). Chaque détecteur rend ses résultats seul ; une phase finale de compilation les prend tous et produit une ligne de plus, « Status », qui les agrège, instant par instant, selon une hiérarchie qui dit lequel l'emporte quand ils se chevauchent.
**Constat.** Une partie de cette compilation existe déjà, cachée dans `categories.py` (`classer`) : un saut bref qui chevauche une perte de visibilité, un passage ou une turbulence y est absorbé ; une turbulence qui chevauche un saut à vérifier est supprimée. Ces règles modifient les lignes des catégories elles-mêmes, si bien qu'on ne voit pas ce que chaque détecteur a trouvé. Et `score.py` a déjà deux niveaux (`IGNORER`, `PRUDENCE`, fonction `validite`).
**Proposition de Claude (à valider).**
- **Les lignes des catégories** : ce que les détecteurs trouvent, sans absorption ni suppression (la fusion à moins d'une heure dans une même catégorie reste).
- **La ligne Status** : à chaque instant, le niveau le plus haut parmi les événements présents, sur tous les capteurs ; le survol dit quels capteurs et quelles catégories. Hiérarchie, du plus fort au plus faible :
1. **À vérifier** (Shift to check, Slow drift) : un mouvement possible de l'ouvrage n'est jamais masqué par autre chose (règle d'asymétrie) ;
2. **À ignorer** (No visibility, Passing obstacle, Target hidden, Target issue, Brief jump) : les données ne sont pas fiables ;
3. **Prudence** (Reduced visibility, Heat haze) ;
4. **Pas de données** (No data) ;
5. **Normal** (Thermal expansion, Thermal contraction : rien à faire) ;
6. **OK** : aucun événement.
- **Où** : une fonction dans `categories.py` (la hiérarchie en une table, à côté de `CATEGORIES`), affichée par `detecteurs.py`, puis par l'onglet `Journal`.
**Questions à l'utilisateur.**
1. La hiérarchie ci-dessus, en particulier « À vérifier » au-dessus de « À ignorer » (un saut pendant une perte de visibilité reste à vérifier) ?
2. Une seule ligne Status pour la station (le pire des capteurs), ou une par capteur ?
3. Les règles d'absorption quittent `categories.py` pour la ligne Status : les lignes des catégories montrent alors les sauts des trains en plus du passage ; le score de `/boucle` les compterait (l'analyste range un train en passage) : garder le score sur les événements d'aujourd'hui, ou le passer sur le Status ?
**Réponse de l'utilisateur (2026-10-27).** « À vérifier » et « Dérive lente » restent hors du Status : il dit seulement si l'on peut se fier aux données, un mouvement possible garde sa propre ligne. Hiérarchie retenue : À ignorer, Prudence, Pas de données, Normal, OK (question 1 tranchée ; 2 et 3 ouvertes).
**Révision de l'utilisateur (2026-10-27, vu sur WILDSTRUBEL du 24 au 30/09).** Les niveaux OK, Normal, Prudence et À ignorer ne disent pas ce qui se passe, et l'orange fait croire qu'il faut intervenir alors que la turbulence ne fait que dégrader les mesures. Le Status dit plutôt **ce qui se passe**, en un mot : bleu clair (sans nom) quand rien n'est à signaler, bleu foncé quand il y a un événement, nommé par la catégorie (Heat haze, Reduced visibility, No data…). Plusieurs choses à la fois : une seule doit ressortir, celle qui englobe les autres, en une large bande qui couvre l'événement gênant (un saut, un trou) pour que le client voie pourquoi les données sont étonnantes. Ordre des autres catégories : l'utilisateur ne le sait pas encore. Idée écartée par lui pour l'instant : un clic sur un bloc qui zoome la page sur sa plage.
**Règle construite (Claude).** Un bloc = des instants d'événements qui se touchent (les trous de toutes les cibles comptent comme No data) ; son nom = la catégorie qui en couvre le plus d'instants, donc celle qui englobe les autres (à égalité, la première de `CATEGORIES`) ; le survol dit tous les événements du bloc et leurs capteurs ; un nom trop long pour son bloc n'apparaît qu'au survol ou en zoomant. Sur WILDSTRUBEL : chaque matin un bloc « Heat haze » (la turbulence couvre la contraction, la visibilité réduite et, le 29, le trou du petit matin) ; le 26, sans turbulence, « Reduced visibility » (la visibilité nulle dedans) ; le 29 au soir, « Brief jump ». Pas d'ordre fixe entre catégories : l'étendue décide. Limite connue : une catégorie longue et banale (une cible à problème pendant 4 jours sur CLARIDEN, la vague thermique) peut nommer un bloc où se passe quelque chose de plus parlant.
**Étapes.**
- [ ] Les réponses de l'utilisateur (2 et 3).
- [x] La ligne Status dans `detecteurs.py` (2026-10-27, accord de l'utilisateur sur la proposition : une ligne pour la station, `categories.py` et le score inchangés) : `STATUT` et `statut()`, une heatmap sous les catégories, au-dessus de l'Error rate ; les trous de toutes les cibles comblés au pas en « Pas de données » ; le survol dit les événements et leurs capteurs. Constat sur CLARIDEN : une seule cible à problème (PR-283, 4 jours) met toute la station en « À ignorer » ; c'est la limite du pire des capteurs (question 2).
- [x] Le Status refait (2026-10-27, révision de l'utilisateur) : blocs nommés par l'événement qui englobe, bleu clair et bleu foncé ; vérifié par capture sur WILDSTRUBEL du 24 au 30/09.
- [ ] L'utilisateur juge la règle de l'étendue sur d'autres plages (CLARIDEN, NIEDERHORN), et dit s'il faut un ordre fixe pour certaines catégories.
- [ ] La suite (`categories.py` sans absorption, score, onglet `Journal`) selon les réponses.
**Fini quand.** La page des détecteurs montre, sous les catégories, une ligne Status qui dit à chaque instant ce qui l'emporte et pourquoi.
### Point 51 : Un analyste qui progresse de séance en séance
**L'idée** (l'utilisateur, 2026-10-28). L'analyste de `/boucle` doit devenir plus performant au fil des séances ; ce n'est pas le cas aujourd'hui. Plus il est fin, meilleure est sa lecture, donc sa critique.
**Constat (Claude).**
- L'analyste est le plafond de la boucle : ses étiquettes sont la vérité du score (D-062) et ses nouveautés deviennent les events appris (builder). S'il stagne, les détecteurs convergent vers ses erreurs.
- Le modèle est déjà celui de la session (D-063) ; ce qui peut progresser, c'est ce qu'il sait. Sa **lecture** progresse déjà par `/aiguiser` (outils et `lire-les-donnees`). Son **jugement** (à quoi ressemble un train, une buée, une cible à problème) ne progresse pas : il ne lit la base d'events qu'à l'étape 4 de `critiquer-lot`, après ses étiquettes, au plus 3 fiches ; ce qu'apprend la base n'atteint jamais ses étiquettes.
- Risque : l'auto-renforcement. Les events « (appris) » sont ses propres conclusions, non validées ; les lire avant d'étiqueter graverait ses erreurs. Seul ce que l'expert a validé ou corrigé doit lui apprendre.
**Proposition de Claude (à valider).**
- **Sa mémoire = la carte des événements**, qu'il lit déjà avant l'étape 1 : quand l'utilisateur valide ou corrige un event par `/review-event`, la signature de l'event entre dans la carte, sous l'éventualité qui le fait, avec son lien ; une correction (« ce n'était pas X mais Y ») y devient une mise en garde. Les events validés E-001 à E-005 y entrent de même. Rien des events non revus.
- Pas de fiches lues avant les étiquettes (coût, et conclusions possibles sur les données mêmes du lot).
- **Mesurer** : sans mesure, on ne saura pas s'il progresse. Les étiquettes figées des events validés (D-069), relues par l'utilisateur, servent de corrigé : de temps en temps, l'analyste étiquette un event validé sans sa fiche, `score.py` le compare. Une lecture coûte environ 250 000 jetons (D-059) : pas à chaque séance, et un ou deux events témoins restent hors de la carte, sinon la mesure triche.
**Questions à l'utilisateur.**
1. La carte comme mémoire de l'analyste, nourrie par `/review-event` seule ?
2. La mesure de l'analyste sur des events témoins : la vouloir, et à quel rythme ?
**Contre-proposition de l'utilisateur (2026-10-28).** Que l'analyste regarde directement les events qu'il a validés. Avis de Claude : oui, c'est plus simple que la carte, puisqu'il n'y a rien à recopier ni d'étape à ajouter à `/review-event`. Les events validés sont ceux dont le Verdict, dans l'index, ne porte pas « (appris) » (E-001 à E-011 aujourd'hui, environ 40 lignes chacun) : avant l'étape 1, il lit l'index et ces fiches, leurs figures au besoin ; les events « (appris) » restent à l'étape 4. Limites : la lecture grossit avec la base (passer à l'index seul, puis aux fiches proches, quand ce sera trop) ; un lot qui recouvre un event validé y lit la réponse de l'expert (sans mal pour les étiquettes, mais cet event ne mesure plus l'analyste) ; les events témoins de la mesure restent hors de sa lecture.
**Compilation dans `events/` (l'utilisateur, 2026-10-28).** Plutôt que de fouiller les fiches, une compilation de ce que les events enseignent, dans `events/`. Puis la base est restructurée (D-085, skill `read-event` : carte et index, puis fiche, puis données).
**Avis de Claude (2026-10-29) : pas de fichier de plus, la carte apprend.**
- La structure D-085 dit comment retrouver un event, pas ce que l'analyste sait avant l'étape 1 : il n'y lit que la carte, et la carte s'est arrêtée à E-005 (en-tête : « les cinq events de la base ») ; E-006, E-007, E-008, E-010, E-012, E-013, E-014 n'y sont pas, et aucun processus ne la tient (`/new-event` : « l'index est le registre » ; la revue ne touche que l'event et sa ligne d'index ; le builder jamais).
- Les leçons générales dorment dans le **Diagnostic** des fiches, lues après les étiquettes et seulement si l'event ressemble : niveau habituel faussé (E-002, E-003, E-004 ; seule passée dans `lire-les-donnees`, par `/aiguiser`), référence masquée non rejetée (E-012), glissement qui n'est pas une dérive (E-010), valeurs juste sous le seuil gardées (E-004, E-003), cible jumelle (E-011), « très léger » de l'expert (E-006, E-007).
- Une « learning-map » à part serait une troisième description des mêmes events (carte, index, fiche) ; la carte a déjà la forme voulue (par phénomène, « Ce qu'on voit », source) et l'analyste la lit déjà. Il manque l'étape qui la nourrit : à chaque validation, ce que l'event apprend entre dans la carte (ligne enrichie ou ajoutée ; une section courte « faux amis » pour les ressemblances trompeuses).
- Écart relevé : la section 4 range E-011 sous `cible_a_probleme` « mal configurée », quand l'expert l'a validé comme configuration voulue, rien à faire.
**Réponse de l'utilisateur (2026-10-29).** La carte apprend ; pas de fichier à part. Le changement de la carte lui est montré avec la fiche, à chaque validation (D-087).
**Étapes.**
- [x] La carte, mémoire de l'analyste (réponse à la question 1, 2026-10-29, D-087).
- [x] L'étape carte dans `/review-event` (agent `revue` : « Ce que la carte apprendrait » à la présentation, écrit à la validation) et `/new-event` (2026-10-29).
- [x] Le rattrapage de la carte (E-004, E-006, E-007, E-008, E-010, E-011, section 5 « Faux amis »), validé par l'utilisateur le 2026-10-29.
- [ ] L'écart « Target stuck » face à E-011 (configuration voulue, `aucune`).
- [x] L'analyste consulte la base quand il veut, avant ou pendant sa lecture ; un event connu est une piste à vérifier (l'utilisateur, 2026-10-29, D-088).
- [x] La mesure de l'analyste (question 2) : écartée par l'utilisateur, 2026-10-29 (on ne mesure pas ses progrès ; proposées : events témoins, verdicts de `/review-event`).
**Fini quand.** D'une séance à l'autre, l'analyste profite de ce que l'utilisateur a validé ou corrigé.
### Point 52 : Un upgrader et un validateur qui ne laissent pas dériver les détecteurs
**L'idée** (l'utilisateur, 2026-10-29). Après l'analyste (point 51), améliorer la suite de `/boucle` : l'upgrader et le validateur.
**Constat (Claude, 2026-10-29).**
- Le validateur n'a jamais renvoyé une modification : quatre séances avec bilan, quatre « accepté » au premier passage. Il relance le même score et le même benchmark que l'upgrader.
- Les deux jugent une modification face à l'état juste avant, et ne comptent comme recul net qu'un événement entier perdu ou signalé à tort ; des mesures signalées à tort, « même nombreuses », passent. Exemple : WILDSTRUBEL, modification 1, sur les cinq events fondateurs (E-001 à E-005) : +1 310 mesures signalées, 0 juste de plus ; le validateur l'a vu (« les justes baissent sur E-002 et E-003… ce sont des mesures, pas des événements ») et accepté.
- Sur ces cinq events, du premier benchmark au dernier : signalées 10 847 → 15 257, justes 8 445 → 7 612 (part des signalées qui sont justes : 78 % → 50 %). La plus grosse part vient d'un changement hors de la boucle (un détecteur pour chaque catégorie, D-074, entre FLORIDA et WILDSTRUBEL) ; la boucle y ajoute peu à peu.
- L'échelle de l'upgrader n'a que des marches qui ajoutent (constante, règle, détecteur) ; aucune n'enlève. Les détecteurs font 1 183 lignes.
**Proposition de Claude (à valider).**
- **Le validateur garde la base** : sur le lot, il reste « pas trop strict » ; sur le benchmark, une catégorie que la suggestion ne vise pas ne gagne pas de mesures signalées à tort, même aux bornes d'un événement juste. L'upgrader a le même critère, pour ne pas perdre un passage.
- **L'upgrader peut enlever** : une première marche, retirer ou simplifier une règle, quand le défaut vient d'elle.
**Questions à l'utilisateur.**
1. La dérive (plus de mesures signalées, pas plus de justes) te gêne-t-elle, ou « tout détecter » (D-068) la veut-il ?
**Précisions de l'utilisateur (2026-10-29).**
- On se concentre sur l'upgrader, renommé `detectors-upgrader` : il ne touche qu'aux détecteurs, mais tout lui est possible sur eux : ajouter, retirer, modifier un détecteur.
- Son but : des détecteurs meilleurs sur un lot donné, d'après la critique. Il vise les événements significatifs du lot que les détecteurs ont manqués, ou mal bornés dans le temps ; pas un résultat identique à celui de l'analyste, l'alignement n'a pas à être parfait.
- Le validateur reste le contrepoids : ne pas sur-apprendre le lot courant au prix des events de la base ; il faut absolument un moyen de contrebalancer.
- L'analyste est la vérité : l'upgrader lit la critique, qui met déjà l'accent sur ce qui est significatif, et adapte les détecteurs ; pas de question de « fausses alarmes » à part.
- Le contrepoids, `control-detectors` (le validateur renommé) : il lance les détecteurs sur la base d'events (benchmark), regarde toutes les modifications de l'upgrader et en fait une critique ; c'est le garde-fou, il décide au final ; il ne regarde pas les données du lot, ses conclusions viennent des benchmarks ; s'il conteste, ses remarques retournent à l'upgrader, qui adapte.
**Fait le 2026-10-29 (D-089).** Le design de l'utilisateur, avec trois précisions de Claude acceptées : c'est le detectors-upgrader qui vérifie le lot ; le contrôle ne lit de la modification que « Ce qui a changé » et « Pourquoi » ; trois passages au plus, comme avant. Agents renommés (`git mv`) et réécrits ; skill `/boucle`, builder, améliorateur, spec de la boucle, `run.md`, `CLAUDE.md`, `vues-deplacements/CLAUDE.md`, schéma des pipelines. La question 1 tombe : l'analyste est la vérité, la critique relève ce qui compte.
**Étapes.**
- [x] Les réponses de l'utilisateur (2026-10-29).
- [x] `detectors-upgrader` et `detectors-control` (2026-10-29, D-089).
- [ ] Une séance de `/boucle` qui les essaie : le contrôle renvoie-t-il, à bon escient ?
**Fini quand.** Une séance de `/boucle` améliore le lot sans abîmer la base d'events.
### Point 53 : Un agent, une responsabilité
**L'idée** (l'utilisateur, 2026-10-29). L'analyste mêle deux responsabilités : lire un lot et critiquer les détecteurs. Deux options :
1. des agents dédiés à un processus, comme les `detectors-…`, qui suivent une liste de tâches (plusieurs responsabilités) ;
2. des agents plus généraux, une seule responsabilité chacun : l'analyste lit une plage de données, et seulement ça ; la critique des détecteurs est une autre tâche.
**Avis de Claude (2026-10-29) : l'option 2 pour l'analyste, l'option 1 garde son sens pour le processus des détecteurs.**
- L'analyste sert déjà à la seule lecture : `/new-event` l'appelle pour les étiquettes d'un event, étape 1 seulement, sans détecteurs.
- Séparer rend la règle « ta lecture avant les détecteurs » structurelle : l'analyste ne voit jamais les détecteurs.
- La critique devient un `detectors-critic` : `detectors-critic` → `detectors-upgrader` → `detectors-control`, chacun une responsabilité dans le processus des détecteurs. Il lit la lecture de l'analyste (son tableau, ses étiquettes) et la sortie des détecteurs, compare et rend au plus deux suggestions ; les nouveautés et les events connus restent à l'analyste (ils parlent des données).
- Le prix : le critique ne voit pas les données. Un événement juste des détecteurs, absent de la lecture, ne peut plus être vérifié et ajouté aux étiquettes (`"apres_detecteurs"`, étape 3 de `critiquer-lot`) : l'analyste est la vérité, ce qu'il n'a pas vu compte « en trop ». Un appel d'agent de plus par séance.
**Questions à l'utilisateur.**
1. L'option 2 pour l'analyste, avec un `detectors-critic` ?
**Réponse de l'utilisateur (2026-10-29).** Oui pour un nouvel agent `detectors-critic` ; l'analyste garde son nom. Son travail : produire l'analyse la plus précise, avec tous les outils à sa disposition, les détecteurs compris (le « prix » noté plus haut tombe : il peut encore vérifier et ajouter un événement que les détecteurs ont trouvé).
**Proposition de Claude (2026-10-29), à valider.**
- L'analyste : sa lecture (tableau des moments), ses étiquettes, les events connus et les nouveautés, dans `analyse.md` ; plus de verdict ni de suggestions.
- Le `detectors-critic` : l'analyse et la sortie des détecteurs (commande du lot, score) ; la comparaison événement par événement, le verdict, au plus deux suggestions, dans `critique.md` (le chemin que lit déjà le `detectors-upgrader`) ; sans regarder les données (à confirmer).
- L'orchestrateur : analyste, puis `detectors-critic`, puis la suite inchangée ; le builder lit les nouveautés dans `analyse.md`.
**Le critic sans les données ? (question de l'utilisateur, avis de Claude, 2026-10-29).** Sur la dernière critique (NIEDERHORN, lot 01) :
- S1, un saut durable manqué : tout vient de la ligne de la lecture (instant, capteur, ampleur en bruits, niveaux des nuits, voisines) : faisable sans les données.
- S2, un saut bref signalé en trop au sommet de la vague thermique : la critique sait qu'il est en trop, mais le pourquoi (une mesure manquante au sommet de la vague, la caméra qui tourne au même pas) vient d'un regard sur les données à cet instant, que la lecture ne décrit pas (rien n'y est anormal).
- Proposition : le critic dit quoi et où (le défaut, l'exemple, le détecteur en cause, en lisant son code), sans les données ; le pourquoi d'une fausse alarme, et la règle qui la corrige, reviennent au `detectors-upgrader`, qui a les données et le code.
- Correction (question de l'utilisateur) : le `detectors-upgrader` a les données de fait (le dossier de station dans sa demande, Bash, la commande du lot qui les lit), mais sa consigne ne lui dit pas de les regarder ni avec quoi, et aucune des six modifications passées ne s'est servie des outils de lecture. Il faudrait lui ajouter : pour comprendre un défaut, regarder les données aux instants en cause avec les outils de `lire-les-donnees`.
**Fait le 2026-10-29 (D-090).** L'utilisateur : le `detectors-upgrader` reste tel quel (il ne sait pas s'il doit regarder les données) ; ajouter le `detectors-critic`. Skill `critiquer-lot` renommé `analyser-lot` et recentré sur l'analyse ; agent `detectors-critic` ; `/boucle` (étape 2), builder, revue et page de `/review-event`, `/new-event`, `score.py` (import), anonymiseur (texte d'`etiquetage.md`), spec de la boucle, `CLAUDE.md`, `run.md`, docs de `vues-deplacements/`, schéma des pipelines (retouché seulement : il parle encore de branche de séance et de cas).
**Étapes.**
- [x] Les réponses de l'utilisateur (2026-10-29).
- [x] L'analyste recentré, le `detectors-critic` ajouté (2026-10-29, D-090).
- [ ] Une séance de `/boucle` qui les essaie : la critique sans les données suffit-elle au `detectors-upgrader` ?
### Point 54 : Le builder devient `event-builder`
**L'idée** (l'utilisateur, 2026-10-29). Après l'analyste, le critic, l'upgrader et le contrôle, le builder de `/boucle` : il s'appellera `event-builder` ; d'abord comprendre comment il fonctionne et qui l'appelle.
**Constat (Claude, 2026-10-29).** Aujourd'hui, l'analyste propose les nouveautés (« ce que ni la carte ni l'index ne décrivent »), l'orchestrateur n'appelle le builder que s'il y en a, et le builder tranche face à la base (index et fiches). Trou : un événement que la carte décrit comme « hypothétique » n'est jamais une nouveauté ; la base ne reçoit pas son premier exemple réel.
**Proposition de l'utilisateur (2026-10-29).** Le builder est appelé de toute façon ; il consulte la base pour déterminer ce qui est nouveau : c'est sa responsabilité de décider s'il faut un nouvel event.
**Précisions de Claude (à valider).**
- Nouveau = aucun event de la base n'a la signature (ligne d'index ou fiche) ; la carte ne compte plus : le premier exemple réel d'un événement « hypothétique » devient un event.
- Il lit toute l'analyse (chaque moment, les étiquettes, les figures) ; la section « Nouveautés » de l'analyste disparaît, et celle du `detectors-upgrader`, qui ne nourrirait plus personne.
- Un appel de plus par séance quand rien n'est nouveau ; plus d'events à revoir, bornés par « un event par genre, pas par occurrence ».
**Réponse de l'utilisateur (2026-10-29).** Oui, avec deux points : pas de règle « un event par genre, pas par occurrence », c'est à l'agent de décider ; et les bornes : un lot peut couvrir une longue plage, l'event se restreint au moment où l'événement se produit.
**Fait le 2026-10-29 (D-091).** Agent `event-builder` (`git mv`, consigne réécrite) ; nouveautés retirées d'`analyser-lot` et du rendu du `detectors-upgrader` ; `/boucle` (étape 5 à chaque lot, bilan : contradictions), revue et page de `/review-event`, `read-event`, spec de la boucle, `CLAUDE.md`, `run.md`, `vues-deplacements/CLAUDE.md`, spec de l'agent de diagnostic, schéma des pipelines.
**Étapes.**
- [x] Le renommer et le redéfinir (2026-10-29, D-091).
- [ ] Une séance de `/boucle` qui l'essaie : des events bien choisis, bien bornés ?
### Point 55 : `/boucle` devient `events-learner`
**L'idée** (l'utilisateur, 2026-10-29). Le processus est bon après les points 51 à 54 ; `/boucle` se renomme `events-learner`. Le releveur et l'améliorateur sont des agents généraux, pas propres à ce processus : à traiter dans une autre conversation. Reste le skill de l'orchestrateur.
**Revue de l'orchestrateur (Claude, 2026-10-29), propositions à valider.**
1. **Le total du benchmark du bilan compare deux bases différentes** : `benchmark-fin.txt` est calculé après l'event-builder, donc avec les events créés pendant la séance ; « avant → fin » mélange les ensembles d'events (comme de E-001-E-005 à E-001-E-014 entre séances). Proposition : retirer `benchmark-fin.txt` ; le benchmark de fin des détecteurs est celui de la dernière modification gardée (`benchmark-K.txt`, ou `benchmark-avant.txt` si rien n'est gardé), sur les mêmes events ; les events créés se mesurent à la séance suivante.
2. **La spec `vues-deplacements/contexte/boucle-automatique.md` (162 l) redit les agents et le skill** : chaque changement de rôle se recopie en trois endroits (agent, skill, spec), quatre fois le 2026-10-29. Proposition : la réduire à ce qui n'est nulle part ailleurs (pourquoi, buts et non-buts, essais, pistes) et renvoyer aux agents et au skill pour le comment.
3. **Le renommage** : `.claude/skills/boucle/` (skill et scripts) devient `.claude/skills/events-learner/`, le dossier des séances `boucle/` devient `events-learner/` (contenu inchangé), la page `out/boucle_…` devient `out/events-learner_…`, les commits `Loop <STATION> …` deviennent `Learn <STATION> …`.
4. À laisser : le lot unique numéroté `lot-01` (vestige du découpage en lots, D-072) ; le changer toucherait trois scripts et la lecture des six séances passées.
**Fait le 2026-10-29 (D-092).** L'utilisateur : « oui, les trois ». Skill et scripts dans `.claude/skills/events-learner/`, séances dans `events-learner/`, spec `vues-deplacements/contexte/events-learner.md` réduite au pourquoi, page `out/events-learner_…`, commits `Learn <STATION> …` ; plus de `benchmark-fin.txt`. « La boucle automatique » reste le mot courant ; l'historique garde « /boucle ».
**Étapes.**
- [x] Le renommage et l'orchestrateur (2026-10-29, D-092).
- [ ] La première séance de `/events-learner` avec les rôles revus (points 52 à 54).
### Point 56 : `/aiguiser` fondu dans `/events-learner`
**L'idée** (l'utilisateur, 2026-10-29). Optimiser `/aiguiser` de la même manière que `/events-learner` (points 51 à 55).
**Constat (Claude, 2026-10-29).**
- **Le garde-fou n'a jamais renvoyé** : quatre séances (NORDEND deux fois, CLARIDEN, WILDSTRUBEL, 26 et 27/10), neuf modifications, neuf « mieux », aucune annulée. C'est le symptôme du validateur de `/boucle` (point 52).
- **Rien ne regarde hors du lot** : une modification n'est jugée que sur une relecture du même lot, face au corrigé du même correcteur. Depuis D-064, le seul contrôle hors du lot, ce sont les commandes des fiches : elles disent qu'un outil marche encore, pas qu'il n'est pas taillé pour le lot.
- **La complexité, échec nommé par la spec, est là** : les outils sont passés de 419 lignes (spec, §3) à 1 423 (`ensemble.py` 446 l ; `plages.py` et `jours.py`, nouveaux ; `gif.py` vient de `/support`) ; le skill `lire-les-donnees`, de 4,8 Ko à 20,9 Ko. L'échelle de l'optimiseur n'a que des marches qui ajoutent (phrase, option, outil), comme celle de l'upgrader avant D-089.
- **Le correcteur porte trois responsabilités** : la vérité (le corrigé), la critique (l'écart, les fautes, les défauts) et la décision de garder (« mieux, pareil, moins bien »), plus des « Nouveautés » pour le bilan. C'est l'analyste d'avant D-090.
- **Un risque concret, relevé le 2026-10-26 et jamais traité** (`docs/ameliorations-processus.md`, « Annuler un passage efface… ») : l'annulation (`git restore --source=<BASE> -- agent-tools/ …`) efface les changements non commités de l'utilisateur dans les outils, et le commit de l'optimiseur (`git add agent-tools/`) les emporte. `/events-learner` le prévoit (§1), pas `/aiguiser`. Aujourd'hui, `agent-tools/gif.py` est modifié et non commité.
- **La spec** (`vues-deplacements/contexte/aiguiser-la-lecture.md`, 173 l) redit le skill et les agents (§5, §6), comme celle de `/boucle` avant D-092.
**Transposition (Claude), à valider.**
| `/events-learner` | `/aiguiser` aujourd'hui | Proposition |
|---|---|---|
| `analyste` : la vérité (D-090) | correcteur, lecture lente | le correcteur ne fait plus que le corrigé ; il garde son nom, comme l'analyste |
| `detectors-critic` : quoi et où, au plus deux suggestions, sans les données (D-090) | correcteur, écart | `reading-critic` : la lecture face au corrigé (trouvé, manqué, de travers, en trop), la faute, au plus deux défauts, le verdict, et « mieux, pareil, moins bien » face à la lecture précédente ; sans les données |
| `detectors-upgrader` : ajoute, retire, modifie, en commençant par retirer ou simplifier (D-089) | optimiseur | `reading-upgrader` : la même échelle, avec une première marche qui retire ou simplifie |
| `detectors-control` : ne voit pas le lot, juge le diff et la base, décide, renvoie au plus trois fois (D-089) | aucun | `reading-control` : ne voit pas le lot ; juge le diff des outils et du skill (les interdits : un jugement dans ce que rend un outil, du propre à une station, un import des détecteurs ; la complexité ajoutée face au défaut traité ; ce qui casse) et les commandes des fiches ; `garder`, `à reprendre` (remarques à l'upgrader, au plus trois passages) ou `annuler` |
| `event-builder` décide ce qui est nouveau (D-091) | « Nouveautés » du correcteur, au bilan | les retirer : la base d'events n'est pas l'affaire de `/aiguiser` (non-but de la spec) ; c'est l'`event-builder` qui décide |
| la base d'events, mémoire de l'analyste (D-087, D-088) | le lecteur ne lit ni la base ni la carte | rien : le lecteur mesure le skill seul, la base fausserait la mesure |
| nom, orchestrateur, spec réduite (D-092) | — | le nom (à choisir) ; §1 repris de `/events-learner` (fichiers déjà modifiés de l'utilisateur, branche vérifiée avant chaque commit) ; spec réduite au pourquoi |
**Le passage K, proposé.** `reading-upgrader` → commandes des fiches (l'orchestrateur, `commandes-K.txt`, au lieu d'une fois en fin de séance) → `reading-control` (`à reprendre` : retour à l'upgrader) → s'il garde : lecteur → `reading-critic` (`pareil` ou `moins bien` : l'orchestrateur annule, comme aujourd'hui). Le contrôle passe **avant** la relecture : il ne coûte que le diff, et une modification qu'il annule épargne une lecture (~200 000 jetons). Deux portes, chacune une question : la lecture du lot est-elle meilleure (le critic), la modification reste-t-elle générale et simple (le contrôle) ?
**Le prix.** Un appel d'agent de plus par séance (la lecture lente et le premier écart, aujourd'hui une seule demande au correcteur, deviennent deux appels) ; les écarts suivants passent du correcteur au critic, sans les données, donc moins chers. Le critic ne revient plus aux données : le corrigé est la vérité ; un moment juste de la lecture, absent du corrigé, compte « en trop » (il ne fait jamais un défaut, puisqu'un défaut vient d'un moment manqué ou lu de travers). Avec un contrôle qui renvoie, des séances plus longues et des modifications plus souvent annulées, comme pour D-089.
**Écarté par Claude.** Rejouer une lecture sur les events validés comme « benchmark » de la lecture : c'est le contrôle retiré par D-064 (l'utilisateur a validé leurs diagnostics, pas une lecture des données brutes).
**Questions à l'utilisateur.**
1. Le `reading-control`, garde-fou sans le lot, avant la relecture ?
2. Le correcteur scindé : le corrigé seul, et un `reading-critic` sans les données pour les écarts ?
3. Les noms : `reading-critic`, `reading-upgrader` (l'optimiseur), `reading-control` ; le lecteur et le correcteur gardent les leurs ; et le processus : `/aiguiser` garde son nom, ou devient `/reading-learner` ?
4. Le reste : « Nouveautés » retirées, les fichiers non commités de l'utilisateur protégés, les commandes des fiches à chaque modification, la spec réduite au pourquoi ?
**Réponse de l'utilisateur (2026-10-29).** Les propositions lui semblent bonnes ; avancer étape par étape du déroulé, en commençant par la première, pour s'assurer que tout est bon.
**Étape 1 : le lecteur (Claude, 2026-10-29), à valider.** Le déroulé d'une séance : mise en place (l'orchestrateur), lecteur (`lecture-1.md`), correcteur (corrigé et premier écart), passages (optimiseur, lecteur, correcteur), commandes des fiches, bilan, releveur. La mise en place n'est que de la tuyauterie : elle se revoit avec l'orchestrateur, en dernier, comme au point 55 (dont les fichiers non commités de l'utilisateur). La première étape de fond est le lecteur. Sur ses 13 lectures (quatre séances) :
- **Son rôle est déjà unique** : lire le lot avec le seul skill `lire-les-donnees`, dire ce qu'il voit et où le skill lui a manqué ; aveugle au corrigé, aux écarts, aux modifications, à la base d'events ; pas de script. Rien à scinder.
- **Ses manques font grossir les outils** : presque chaque modification répond à un souhait de « Ce qui m'a manqué » (`inventaire.py --debut/--fin`, `resume.py --niveau fenetre`, `vignettes.py --contraste`, `jours.py` pour superposer les jours, `plages.py --min-mesures`). Il ne demande jamais moins.
- **Le trop, il le dit, mais au mauvais endroit** : 13 lectures sur 13 se plaignent de sorties trop longues pour être lues d'un coup (`ensemble.py` 642 à 947 lignes, `plages.py` 54 Ko, `jours.py` 40 Ko, `inventaire.py` 72 Ko), et plusieurs de figures écrasées par un capteur aberrant ; mais dans « Difficultés », qui va au releveur, que personne ne transforme en correction. Le correcteur juge les moments, pas l'effort ; l'optimiseur ne lit que « Ce qui m'a manqué ».
- **Une consigne du skill que tous enfreignent** : « Bash ne sert qu'à lancer ces outils, `ls`, `grep` et `date` » (`lire-les-donnees`, Conventions) ; presque tous les lecteurs ont dû rediriger une sortie vers un fichier, puis `head`, `tail`, `sed`. Relevée le 2026-10-26, jamais corrigée : l'améliorateur ne touche pas à `lire-les-donnees` (D-076), et le correcteur n'en fait pas un défaut de lecture. De même « pas natif de 15 min » (méthode, étape 5), quand CLARIDEN est à 10 min (ses 3 lectures).
- **Déjà réglé** : le `vues-deplacements/CLAUDE.md` injecté dans presque toutes les lectures venait des séances rangées sous `vues-deplacements/aiguiser/` ; elles sont à la racine depuis D-084.
Propositions :
1. Le lecteur garde son rôle, son nom et son aveuglement.
2. Une section « Ce qui m'a encombré », après « Ce qui m'a manqué » : sortie trop longue pour être lue d'un coup, figure illisible ou jamais regardée, option ou consigne suivie sans profit ; l'outil et la commande. Ces plaintes quittent « Difficultés », qui ne garde que le processus de la séance. Elles nourrissent la marche qui retire ou simplifie du `reading-upgrader` (et le `reading-critic`, qui les lit avec « Ce qui m'a manqué »).
3. Les deux consignes du skill, corrigées à la main une fois : Bash permet aussi de ranger une sortie longue dans un fichier du dossier de la lecture et de la lire par `grep`, `head`, `tail`, `sed -n` ; le pas natif est celui que donne l'inventaire (15 min le plus souvent). Elles valent aussi pour l'analyste et l'agent de diagnostic, qui suivent le skill. Qui les tiendra ensuite (l'améliorateur, D-076 ?) : avec le releveur et l'améliorateur, dans l'autre conversation.
**Remise en cause par l'utilisateur (2026-10-29).** Ce processus est-il nécessaire ? Le lecteur extrait des informations sans savoir ce qui est pertinent : parmi une multitude de métriques, il ne peut pas savoir ce qui est intéressant ; même sur beaucoup de données, il n'est pas guidé et refait bêtement le même travail. Celui qui profite des outils, c'est l'analyste, qui évolue par la base d'events ; le lecteur, non. Sans l'analyste, l'utilisateur ne voit pas comment le système peut marcher : combiner `/aiguiser` avec `/events-learner`.
**Avis de Claude (2026-10-29) : l'utilisateur a raison sur le fond.**
- **La vérité de `/aiguiser` ignore la pertinence** : un moment du corrigé, c'est « un capteur ou un groupe qui sort de son niveau habituel », tous égaux (`correcteur.md`). « Mieux » veut donc dire « voir plus d'écarts » : neuf « mieux » sur neuf, jusqu'à 23 moments par lecture, des sorties jusqu'à 947 lignes. La croissance des outils vient de la mesure elle-même, pas d'un réglage.
- **Le lecteur ne peut pas apprendre la pertinence** : il est aveugle à la carte et à la base par construction (pour mesurer le skill seul).
- **L'analyste lit déjà chaque lot de `/events-learner` avec ces outils**, guidé par la carte et la base, pour un but réel (catégories, events) ; `/aiguiser` relit des lots du même genre quatre fois, avec un lecteur moins informé. La raison de la séparation (spec, §1 : un analyste qui lit avec les détecteurs serait biaisé) est tombée avec D-090 : il s'en sert, comme d'une piste.
- **Ce qu'on perdrait** : le correcteur, qui lit sans les outils, a trouvé la seule erreur commune de lecture : à WILDSTRUBEL, 0 rejet compté pour R3 au lieu de 147 (`donnees.py`, modification 1 du 2026-10-27). Un analyste qui lit par les mêmes outils ne peut pas la voir ; les détecteurs non plus (ils lisent par `donnees.py`). C'est la vraie valeur d'un lecteur indépendant, mais elle demande un audit de temps en temps, pas une boucle de quatre lectures. Et la mesure « mieux, pareil, moins bien », qui ne tranchait pas.
**Proposition de Claude, à valider.**
- Dans `/events-learner`, l'analyste ajoute à `analyse.md` ce qui lui a manqué ou l'a encombré dans la lecture, pour son analyse (dater, catégoriser, reconnaître un event) ; il ne touche pas aux outils (un agent, une responsabilité).
- Un agent `reading-upgrader` (l'optimiseur), appelé quand cette section n'est pas vide : il modifie `agent-tools/` et `lire-les-donnees`, en commençant par retirer ou simplifier, vérifie sur le lot et lance les commandes des fiches ; le gain se voit à la séance suivante, comme la carte pour l'analyste.
- Contre la croissance : un `reading-control` qui ne juge que le diff (à décider).
- `/aiguiser` se retire (lecteur, correcteur ; l'historique reste dans `aiguiser/`) ; l'audit indépendant (le correcteur, sans les outils) reste une piste, pour un changement de `donnees.py` ou de nouveaux champs de données.
- À régler : les détecteurs lisent par `agent-tools/donnees.py` ; une modification de la lecture commune change leur entrée, donc le benchmark. Le `reading-upgrader` passe après le `detectors-control`, et un changement de `donnees.py` se mesure (benchmark) ou attend l'utilisateur.
**Proposition de l'utilisateur (2026-10-29) : c'est l'analyste qui change.**
- Un script (ou autre moyen) lui montre les données à sa disposition.
- Il accède aux données et aux outils, et il peut aussi créer ses propres outils.
- Une fois les données bien comprises, il fait son analyse.
- Dans son rapport final, une section « Tools » : les outils dont il s'est servi pour son analyse, existants ou créés pour l'occasion.
- Puis un `tool-builder` lit ce rapport et adapte, modifie, retire ou crée des outils de lecture.
- Le reste de `/events-learner` ne change pas.
**Constat (Claude, 2026-10-29) : l'analyste ne sait pas ce qu'il a.**
- `inventaire.py` liste des fichiers, pas des données : sur NIEDERHORN, « Autres fichiers : 1178 » cache 31 métriques système (`metrics/` : températures de la carte, alimentation, réseau…) ; il ne dit pas quelles colonnes de l'export portent des valeurs.
- L'export « advanced » a 20 colonnes, dont six de qualité d'image par cible (`peak`, `flux`, `sharpness`, `fwhm`, `dominance`, `snr`), remplies à LENZSPITZE et NADELHORN, vides ailleurs (le handoff le dit : « Empty for most devices today ») ; aucun outil, ni le skill, ni `colonnes-des-deplacements.md` ne les cite. Un lecteur de `/aiguiser` voulait justement « une mesure d'éclat ou de largeur de la tache (flux, taille, contraste) » : quatre séances ne l'ont pas trouvée.
- Aujourd'hui, `analyser-lot` lui interdit tout script (« N'écris aucun autre script »), et `lire-les-donnees` limite Bash aux outils, `ls`, `grep` et `date`.
**Précisions de Claude (à valider).**
- **Voir ses données** : `inventaire.py` gagne une section par source, avec ce qu'elle contient sur la fenêtre : colonnes de l'export (remplies ou vides), poses de la caméra, noms des métriques de `metrics/`, images, images différentielles, `quality/` ; des noms et des comptes, jamais de valeurs (`SIM_CCID`, `ip_*` sont des identifiants). Un outil existant étendu plutôt qu'un script de plus. Le sens des colonnes reste à `colonnes-des-deplacements.md`, qui ne dira des six colonnes de qualité que ce qu'en disent les documents AIMsight.
- **Ses outils à lui** : des scripts dans le dossier de son analyse (`<lot>/outils/`), bibliothèque standard, matplotlib par `.venv` ; ils lisent les CSV bruts ou passent par `donnees.py`, à son choix (lire en brut est ce qui a trouvé l'erreur des rejets à WILDSTRUBEL). Commités avec le lot ; seul le `tool-builder` les fait entrer dans `agent-tools/`.
- **Le déroulé d'`analyser-lot`** : 0. les données (l'inventaire, puis ce qu'il faut pour les comprendre) ; 1. la lecture ; 2. les étiquettes ; 3. les events connus ; 4. **Outils** : chaque outil dont il s'est servi, existant ou à lui, à quoi il a servi, ce qu'il a montré, ce qui a manqué ou encombré ; pour un script à lui, son chemin, ce qu'il calcule, pourquoi les outils existants ne suffisaient pas. Le fichier garde son nom, `analyse.md` (lu par `comparaison.py`, la page de `/review-event`, l'`event-builder`), et la section s'écrit en français, comme les autres.
- **Le `tool-builder`** : l'optimiseur renommé et réécrit ; appelé à chaque lot, juste après l'analyste, il décide seul (comme l'`event-builder`) ; il touche `agent-tools/` et `lire-les-donnees`, rien d'autre ; il commence par retirer ou simplifier ; il garde les interdits de l'optimiseur (aucun jugement dans ce que rend un outil, rien de propre à une station, aucun import des détecteurs, bibliothèque standard) et les commandes des fiches qui marchent ; il essaie sur le lot, sans relecture. Pour retirer un outil, il peut lire la section Outils des analyses des séances d'avant : un seul lot ne dit pas qu'un outil ne sert à rien.
- **L'ordre** : analyste → `tool-builder` → étiquettes, score et benchmark → la suite inchangée. Les détecteurs lisent par `donnees.py` : calculés après le `tool-builder`, score et benchmark de la séance portent tous sur la même lecture ; un changement de `donnees.py` se voit d'une séance à l'autre dans l'historique du benchmark, et le bilan le dit.
- **Pas de contrôle** du `tool-builder` dans ce premier temps (le design de l'utilisateur) : la pertinence vient de l'analyste ; le `reading-control` reste une piste, si les outils grossissent encore.
- **`/aiguiser` se retire** : son skill, le lecteur et le correcteur ; `aiguiser/voir.py` part avec lui ; les séances de `aiguiser/` restent, comme historique ; la spec `aiguiser-la-lecture.md` aussi, marquée remplacée. Une décision (D-097) ; l'améliorateur et le releveur perdent `/aiguiser` de leur périmètre ; `CLAUDE.md`, `run.md`, `vues-deplacements/CLAUDE.md`, la spec d'`events-learner`, le schéma des pipelines.
- **`/new-event`**, qui appelle l'analyste pour les étiquettes d'un event : pas de `tool-builder` ; ses scripts éventuels restent dans le dossier de sortie.
**Réponse de l'utilisateur (2026-10-29).** D'accord sur l'inventaire, les scripts de l'analyste, la section Outils, l'ordre et le retrait de `/aiguiser` ; le `tool-builder` optimise ou ajoute des outils, il **n'en retire pas** : un seul lot ne suffit pas pour nettoyer la liste ; pas de contrôle pour l'instant, on regarde comment ça tourne et ce que ça donne.
**Fait le 2026-10-29 (D-097).** `inventaire.py` : une section « Ce que contiennent les données » (colonnes remplies ou vides de l'export, de la pose et de `quality/`, noms des métriques, images, images différentielles) ; `analyser-lot` : étape 0 « Tes données », ses scripts dans `<dossier de sortie>/outils/`, section « 3. Outils » ; agent `tool-builder` (l'optimiseur, `git mv`, réécrit) ; `/events-learner` : étape 2 entre l'analyste et le score, colonne Outils au bilan ; `/aiguiser` retiré (skill, lecteur, correcteur, `voir.py`) ; `colonnes-des-deplacements.md` (les six colonnes de qualité), `lire-les-donnees`, `/new-event`, améliorateur, spec d'`events-learner` (spec d'`aiguiser` marquée remplacée), `run.md`, `README.md`, `CLAUDE.md`, `vues-deplacements/CLAUDE.md`, schéma des pipelines (retouché).
**Étapes.**
- [x] Les réponses de l'utilisateur : étape par étape (2026-10-29).
- [x] Étape 1, le lecteur : sans objet, `/aiguiser` remis en cause.
- [x] Combiner `/aiguiser` avec `/events-learner` : la proposition de l'utilisateur (2026-10-29).
- [x] Les précisions de Claude : acceptées, sauf le retrait d'outils (2026-10-29).
- [x] Construit (2026-10-29, D-097).
- [ ] Une séance de `/events-learner` qui l'essaie : la section Outils guide-t-elle le `tool-builder`, les outils grossissent-ils sans servir ?
- [ ] Les agents, le skill, la spec, une décision ; `CLAUDE.md`, `run.md`, `vues-deplacements/CLAUDE.md`, le schéma des pipelines.
- [ ] Une séance de `/aiguiser` qui les essaie : le contrôle renvoie-t-il, à bon escient ?
**Fini quand.** Une séance de `/events-learner` améliore les outils dont l'analyste se sert, sans les faire grossir pour un lot seul.
---
2026-10-23 21:52:08 +02:00
## Partie VII — Idées gardées pour plus tard
### Point 33 : Les autres métriques de certains projets
L'utilisateur : « il y a d'autres métriques aussi sur certains projets ». Quand le pompage marchera, un agent pourra les inventorier (quels types de mesure existent par station, à quelle cadence) et dire lesquelles aideraient le journal (température, pluie, éclairage).
- [ ] Après le point 27 : lister les types de mesure d'une station (requête en lecture seule, ajoutée au script par l'utilisateur ou par un brouillon de Claude) ; présenter la liste.
### Point 34 : Météo et HDF5 pour dire la cause
La carte, section 3 : la cause d'une perte de visibilité (pluie, brume, buée, neige) ne se dit qu'avec la météo ou l'image ; les obstructions lentes et les contrastes faibles demandent la brillance, la dominance et le flux, présents seulement dans l'export HDF5.
- [ ] Demander à l'utilisateur si une source météo est disponible (station, service) ; si oui, une catégorie peut nommer sa cause sans image.
- [ ] Demander un export HDF5 d'une station pour voir ce qu'il apporte.
### Point 35 : Un event de la base par catégorie
2026-10-23 21:52:08 +02:00
Neige, dérive lente, cible qui saute seule et voisin brillant n'ont aucun event validé.
- [ ] Quand l'utilisateur apporte des données qui en montrent un, et le demande : `/new-event`.
2026-10-23 21:52:08 +02:00
### Point 36 : Porter le journal dans la vraie application
- Plage par défaut « depuis ta dernière visite » (décidé au point 21, 2026-10-24) : à faire ici, avec les données en direct et le compte du client ; la maquette garde 3 jours fixes.
Comme pour les statuts des métriques système (Energy, Storage, Cellular, Temperature) : quand le journal convainc, on le porte dans `~/monitoring-dashboard`. Les détecteurs sont en bibliothèque standard ; l'application calcule au chargement de la page : mesurer d'abord le temps de `categories.evenements` sur 11 jours (NORDEND d'octobre).
- Règle (point 30, D-056) : les détecteurs reçoivent 3 jours de mesures d'avant la plage montrée au client.
2026-10-23 21:52:08 +02:00
- [ ] Mesurer le temps ; le noter ici.
- [ ] Le portage lui-même : sur demande de l'utilisateur, dans une conversation ouverte dans le dépôt de l'application.
### Point 49 : Le graphe des éventualités du terrain et deux catégories nouvelles
Demande de l'utilisateur (2026-10-27) : un graphe simple, sans le détail des données, de ce qui peut arriver sur le terrain vers les catégories du journal ; une éventualité peut en donner plusieurs (la neige sur les cibles : visibilité réduite ou nulle, ou cible masquée). Fait dans `events/eventualites-et-categories.drawio`, en tête de la carte des événements, à la place de l'arbre Mermaid. Les étiquettes de l'analyste (boucles et cas E-001 à E-011) en font sortir une catégorie qui manque : les cibles mal vues ou mal suivies durablement (E-008 à E-011, cibles toujours rejetées), qu'il range aujourd'hui hors catégorie ou à vérifier.
- [x] Le graphe : 23 éventualités en cinq familles, 11 catégories, la vérification d'un `À vérifier` ou d'une dérive lente vers « Cible déplacée ».
- [ ] L'utilisateur relit les liens du graphe dans draw.io.
- [x] Les catégories, définies par l'utilisateur le 2026-10-27 (D-074) : tout ce qui reste inexpliqué dans **À vérifier** (sous-groupes : saut qui dure, gros saut, dérive lente), pour ne pas alarmer le client ; **Target issue** gardée (cible constamment problématique : mal orientée, mal installée, dégradée) ; effet thermique, passage, pas de données, saut bref et turbulences atmosphériques redéfinis ; graphe refait.
- [x] Le véhicule qui fait vibrer l'ouvrage ou la caméra (caméra sur un pont) va dans **Saut bref** (l'utilisateur, 2026-10-27).
- [x] Reporter les définitions dans la carte (section 4, d'où l'analyste tire son vocabulaire), le skill `critiquer-lot` (« aucune » seulement sans effet sur les courbes ; l'inexpliqué en `a_verifier`), `categories.py` et les détecteurs (demande de l'utilisateur, 2026-10-27 : au moins un détecteur par catégorie, pour les entraîner dans `/boucle`). Fait le 2026-10-27, les clés des catégories gardées (les étiquettes déjà écrites restent valides) : `derive.py` (dérive lente, nouveau, sur `corr` de l'export « advanced » ; la maquette ne la prend plus des tendances horaires) ; `degradee` « Target stuck » (cible collée, E-011) ; `sauts` « Target flipping » (cible qui bascule des heures, presque seule : Target issue) et « Large shift » (gros saut, sous « À vérifier ») ; `thermique` « Camera thermal … » (cycle des positions brutes quand `corr` n'en a pas). Benchmark (étiquettes des events, écrites avant D-074) : `toutes` 51 % trouvées, 49 → 47 % confirmées ; les écarts viennent des nouvelles définitions (bascules de E-009 en cible à problème, caméra des E-003 et E-008 en effet thermique, que l'analyste avait mises en saut bref ou hors catégorie).
- [ ] L'utilisateur lance `/boucle` sur de nouvelles données pour entraîner les détecteurs sur les nouvelles définitions ; décider s'il faut relire les étiquettes des events E-001 à E-011 avec D-074.
2026-10-23 21:52:08 +02:00
---
## Partie VIII — Suivi du chantier
### Point 37 : Ménage : commit, `CLAUDE.md`, Mermaid, sorties
- [x] **Commit** : rien n'est commité depuis le 2026-10-23. Fichiers de cette conversation : `detectors/` (5 détecteurs), `vues-deplacements/maquette/explore.py`, `explore_template.html`, `spec.md`, `vues-deplacements/contexte/journal-du-matin.md`, `lissage.md`, `donnees-et-boucle.md`, `events/carte-des-evenements.md`, `extraction/`, `docs/decisions.md` (D-056), `CLAUDE.md`, `vues-deplacements/CLAUDE.md`, ce plan. Déjà modifiés avant par l'utilisateur : `CLAUDE.md`, `docs/ameliorations-faq.md` ; `graphify-out/` n'est pas de cette conversation. Commit sur demande seulement, en séparant ce qui est de l'utilisateur. Fait le 2026-10-24 : commits `4ac95ae` (points 1 à 10), `86547f0` (11 à 17, 38, 41), puis celui des points 18 à 26, 30, 39, 40 et de ce ménage ; aucun fichier de l'utilisateur dans ces changements.
- [x] **`CLAUDE.md`** fait 202 lignes (limite 200, D-012) : raccourcir la puce « Prochaine étape » (la plus longue) en renvoyant à ce plan. Fait le 2026-10-24 : 199 lignes (phrase redite des « Règles de travail » retirée, les deux puces Energy réunies) ; puces du journal du matin et « Prochaine étape » mises à l'état du jour (onze catégories, courbes nettoyées, points en attente) ; `vues-deplacements/CLAUDE.md` aussi (onze catégories).
- [x] **Mermaid** de la carte : à rendre une fois (point 3). Déjà fait au point 3 (arbre rendu sans erreur, journal du plan).
- [x] **Sorties** : `data/NORDEND` et le cas `vues-deplacements/cas/2026-10_NORDEND/NORDEND` écrivent tous deux `out/vues_deplacements_NORDEND.html` ; capturer juste après la construction, ou nommer la sortie par le chemin du dossier. Fait le 2026-10-24 : un dossier de cas écrit la page au nom du cas (`out/vues_deplacements_2026-10_NORDEND.html`), `data/NORDEND` garde `out/vues_deplacements_NORDEND.html` ; `CLAUDE.md`, spec et annexe B à jour.
2026-10-23 21:52:08 +02:00
---
## Partie IX — Dire la cause : l'analyste d'abord, les détecteurs ensuite
Retour de l'utilisateur du 2026-10-29 (vocal), après des exemples des détecteurs sur les données : « globalement c'est assez bon », la couverture est bonne, mais des catégories sont incomplètes ou peu précises. **L'ordre qu'il donne** : rendre l'analyste plus savant (savoir métier, températures, métriques de qualité, cas validés) pour qu'il étiquette mieux ; ensuite c'est lui, par `/events-learner`, qui fait progresser les détecteurs, de « il s'est passé quelque chose » vers « voici la cause ». À sa demande, rien n'est documenté hors de ce plan avant qu'il prenne le point : chaque point dit où son savoir ira.
### Point 57 : La cause plutôt que l'événement : l'ordre du chantier
**L'idée** (l'utilisateur, 2026-10-29). Détecter l'événement était la première chose ; il faut maintenant dire **pourquoi** : la cause d'un saut, l'effet thermique en jeu, une visibilité réduite ou une cible cachée. Ne pas avoir peur de la complexité de ces données ; l'interface la cachera par défaut (point 66).
**Le déroulé proposé (Claude).**
1. Le savoir : les effets thermiques (58), le heat haze (61), visibilité contre occultation (62), la cause des sauts (64). L'utilisateur valide le texte, qui va dans `docs/displacement/domaine/` et la carte des événements.
2. Les données qui le prouvent : les températures (59) et les métriques de qualité (63) dans les outils de lecture, aiguisés par `/aiguiser`.
3. Les cas : des events construits par `/new-event` et validés par l'utilisateur, une cause chacun (60, et ceux des points 62 et 64).
4. L'analyste : `analyser-lot` et la carte reçoivent le tout ; il consulte la base quand il veut (D-088).
5. Les détecteurs : des séances de `/events-learner` sur des lots qui montrent ces causes ; les catégories nouvelles dans `categories.py` et la hiérarchie des status (D-095).
6. Les détails de détection (65) se font quand on veut, sans attendre.
**Les étiquettes de l'expert (2026-10-30).** Elles s'ajoutent à ce déroulé, à ses étapes 1 et 3 : une source de savoir et de cas (points 68 et 69). Leur place exacte reste à décider, après les premières étiquettes.
**L'état des pipelines** (l'utilisateur, 2026-10-29). Certains sont prêts à être lancés : il en a refait quelques-uns, les analystes et les boucles d'apprentissage sont prêts ; il a deux ou trois choses à faire en parallèle, et avance progressivement avec ce plan.
**Question.** Ce déroulé, et par où commencer : les effets thermiques (58, puis 59), recommandé, puisque toutes les stations ont déjà une température ?
- [ ] L'utilisateur valide l'ordre.
### Point 58 : Les trois effets thermiques et leurs temps de chauffe
**Ce qu'en dit l'utilisateur (l'expert, 2026-10-29).** Trois effets thermiques, qui se distinguent par leur **temporalité** : chacun a son propre temps de chauffe et de refroidissement.
1. **L'objectif se déforme** : le soleil sur la station chauffe l'optique ; l'image se déforme.
2. **Le support de la caméra bouge** : la fixation se dilate, la caméra bouge et compense mal ce mouvement, qui passe dans les mouvements des cibles.
3. **L'ouvrage surveillé se dilate** : il lui faut beaucoup plus de temps pour chauffer et refroidir. Les refroidissements très tardifs et les chauffes longues vus ce jour sur les données des détecteurs en sont le cas type.
Les cas se croisent : une caméra posée sur un pont a deux ouvrages, celui qui la porte (effet 2) et celui qu'elle surveille (effet 3). Et encore :
- les vagues de dilatation et de contraction des détecteurs sont justes (un pont se contracte et se détend par vagues) : à garder ;
- le déplacement est souvent plus fort en Y (ça monte, ça descend) qu'en X, mais cela dépend de l'orientation : pas toujours ;
- JUNGFRAU (PS des Coudres, sous un pont) : les effets thermiques sont centrés sur les points d'inflexion du mouvement de la caméra ; ce n'est pas faux, et c'est l'effet 1 ou 2.
**Ce que le projet en sait déjà.** `labeling/connaissances/cycle-thermique.md` (point 13) : une vague de 24 h dans les positions brutes presque partout (la caméra), dans les courbes corrigées seulement à PS des Coudres. Catégories `dilatation_thermique` et `contraction_thermique` (D-074), qui mêlent l'ouvrage et le support de la caméra ; `thermique` « Camera thermal … » (point 49) ; le regroupement Thermal movements, suspendu dans `status.py` (D-095).
**Signatures, hypothèses de Claude à valider.**
| Effet | Où il se voit | Temps | Témoin |
|---|---|---|---|
| Objectif | toute l'image : positions brutes de toutes les cibles, références comprises (plus fort au bord de l'image ?) | le plus court : suit le soleil sur la station | température de la station |
| Support | positions brutes en mode commun (le mouvement de la caméra) ; reste dans `corr` quand la compensation est imparfaite, aux inflexions du mouvement de la caméra | intermédiaire | température de la station, mouvement de la caméra |
| Ouvrage | `corr`, amplitude propre à chaque cible, références stables | le plus long : chauffe lente, refroidissement tardif, en retard sur l'air | température de l'air, absente (sauf peut-être `temperature_deg_c`, point 59) |
**Questions à l'utilisateur.**
1. Les catégories : trois (objectif, support, ouvrage), chacune en dilatation et en contraction ; ou un seul « effet thermique » pour le client, la cause pour le spécialiste (point 66) ?
2. L'objectif et le support se séparent-ils sur les courbes, ou seulement par leur temps ?
3. Les signatures ci-dessus : justes, à corriger ?
- [ ] Les réponses de l'utilisateur.
- [ ] Le savoir validé : `labeling/connaissances/cycle-thermique.md` réécrit (les trois effets, leurs temps, les cas croisés, X et Y) ; la carte des événements (sections 1 et 4) et le graphe des éventualités.
- [ ] Les catégories décidées : entrée dans `docs/decisions.md`, `categories.py`, hiérarchie des status (D-095).
### Point 59 : Les températures de la station dans les outils de lecture, par `/aiguiser`
**L'idée** (l'utilisateur, 2026-10-29). Se servir de `/aiguiser` pour que les outils de lecture lisent aussi les métriques système, d'abord les températures, et que l'analyste les regarde pour séparer les trois effets thermiques.
**Ce qui existe (Claude, 2026-10-29).**
- Toutes les stations de `data/` ont les cinq zones de la carte de calcul (`sensor_A0`, `CPU`, `GPU`, `PLL`, `thermal_deg_c`), en moyennes horaires : la température **dans** la station, chauffée par le soleil et par le calcul, ni celle de l'air ni celle de l'ouvrage. Les zones sont redondantes (`docs/temperature/domaine/point-de-depart.md`) : une seule suffit. Elle témoigne pour l'objectif et le support (effets 1 et 2), mal pour l'ouvrage.
- LENZSPITZE et NADELHORN ont en plus `temperature_deg_c` (capteur inconnu : l'air ?), sur 5 à 12 jours.
- Une moyenne horaire, face à des mesures de 10 ou 15 min, date une chauffe à l'heure près, pas mieux.
- Aucun outil de lecture ne lit `metrics/` (`agent-tools/donnees.py`) ; le lecteur, le correcteur et l'analyste n'en savent rien.
**Proposition (Claude).** Le plus simple d'abord : lire une température (`sensor_thermal_deg_c`, la seule commune à toutes les versions du collecteur) dans `donnees.py` et la tracer sous les courbes dans `graphique.py` ; puis une séance de `/aiguiser` sur un lot thermique (JUNGFRAU), où le correcteur fait son corrigé avec les températures et où l'optimiseur ajoute ce qui manque au lecteur. Sans ce premier pas, le lecteur ne demandera jamais une température qu'il ne sait pas exister.
**Questions à l'utilisateur.**
1. Le premier pas codé à la main, puis `/aiguiser` ; ou `/aiguiser` seul, en disant au lecteur et au correcteur que `metrics/` existe ?
2. Avant ou après la refonte de `/aiguiser` (point 56, étape 1 en cours) ?
3. `temperature_deg_c` : quel capteur ?
- [ ] Les réponses de l'utilisateur.
- [ ] La température dans les outils (selon la réponse 1) ; le skill `lire-les-donnees` dit qu'elle existe.
- [ ] Une séance de `/aiguiser` sur un lot thermique (l'utilisateur la lance, `run.md`).
- [ ] `analyser-lot` : l'analyste regarde la température devant tout effet thermique.
**À revoir (2026-10-29).** `/events-learner` a maintenant un `tool-builder`, et l'analyste écrit ses propres scripts (D-097, autre conversation) : les températures peuvent arriver par là plutôt que par `/aiguiser`.
**Constat (Claude, 2026-10-30).** NADELHORN et LENZSPITZE n'ont aucune valeur de `sensor_*_deg_c` (fichiers vides, 5 et 12 jours) : leur seule température est `temperature_deg_c`. « Toutes les stations » et « la seule commune », ci-dessus, sont à corriger.
### Point 60 : Des cas thermiques construits et validés
**L'idée** (l'utilisateur, 2026-10-29). Construire des cas concrets de chacun des trois effets, dans leurs différentes circonstances (caméra sur un pont, ouvrage seul, les deux), les documenter et qu'il les valide : l'analyste les apprend par la base d'events.
**Proposition (Claude).** Chercher dans `data/` une période candidate par effet (JUNGFRAU pour la caméra ; pour l'ouvrage, la station aux refroidissements tardifs vue ce jour), température tracée (point 59) ; les montrer à l'utilisateur ; il choisit et lance `/new-event` sur chacune. La carte apprend de chaque event validé (D-087).
- [ ] L'utilisateur dit sur quelle station il a vu les refroidissements tardifs.
- [ ] Après les points 58 et 59 : les périodes candidates, présentées à l'utilisateur.
- [ ] `/new-event` par l'utilisateur, un cas par effet ; sa validation.
### Point 61 : Heat haze : quand il y en a, quand il n'y en a pas
**Ce qu'en dit l'utilisateur (2026-10-29).** Le heat haze (catégorie `turbulence`) est un effet thermique à part, une forme de bruit, qui n'apparaît que quand il fait vraiment chaud sur l'ouvrage ; sous un pont, comme à JUNGFRAU, il n'y en a pas. On ne sait pas encore comment le capter.
**À trancher.** Ce qui le distingue des autres bruits (vent fort, mât qui vibre, visibilité moyenne). La carte (section 1) dit déjà : de jour, toutes les cibles, surtout les lointaines, `error_value` 1,5 à 3 fois celle de la nuit ; la température et la qualité (flux, netteté) pourraient le confirmer.
- [ ] L'utilisateur dit les conditions du heat haze (chaleur sur l'ouvrage, soleil, distance des cibles) ; le savoir dans `docs/displacement/domaine/` et la carte.
- [ ] Un cas avec, un cas sans (JUNGFRAU), au point 60.
### Point 62 : Visibilité réduite ou cible masquée
**Ce qu'a vu l'utilisateur (2026-10-29).** À JUNGFRAU (PS des Coudres), du brouillard rangé par les détecteurs en `cible_masquee` (Target hidden) : c'est une visibilité réduite. La distinction compte : une **réduction de visibilité** est une baisse du flux, homogène ; une **occultation**, un objet devant la cible. Un détecteur qui ne lit que les courbes de mouvement les sépare mal ; les métriques de qualité le devraient (flux, pic, netteté, dominance).
**Les deux voies.**
- A. Tout regrouper sous « visibilité réduite », avec les cibles touchées : simple, sans les métriques de qualité.
- B. Deux catégories, avec un critère robuste d'occultation tiré des métriques de qualité (par exemple : le flux d'une ou de quelques cibles voisines tombe d'un coup, les autres gardent le leur ; contre un flux qui baisse partout, plus sur les lointaines). L'utilisateur ne veut pas lâcher cette voie.
**Recommandation (Claude).** A tant qu'une station n'a pas les métriques de qualité, B dès qu'elle les a ; la décision suit le point 63.
- [ ] La décision de l'utilisateur ; entrée dans `docs/decisions.md`, carte (section 4), `categories.py`.
- [ ] Si B : un cas de brouillard (JUNGFRAU) et un cas d'occultation, validés.
### Point 63 : Les métriques de qualité : quelles stations, et la qualité recalculée
**L'idée** (l'utilisateur, 2026-10-29). Sans les métriques de qualité, un diagnostic précis est difficile ; les courbes de mouvement seules ne suffisent pas. Mais peu de stations les ont. Deux choix : ne traiter désormais que les stations qui les ont, ou les recalculer après coup avec l'émulateur (`~/optical_emulator`, travail en cours dans le projet optique).
**Ce qui existe (Claude, 2026-10-29).** Dans `data/`, seul NADELHORN a `quality/` (du 25 au 27/10) : par capteur et par image, `peak`, `flux`, `sharpness`, `fwhm`, `dominance`, `snr`. `donnees.py` reconnaît ces fichiers sans les lire ; `run.md` a déjà les métriques de qualité par l'émulateur. Pas de quoi entraîner un détecteur aujourd'hui.
**Questions à l'utilisateur.** Le choix : stations avec qualité seulement, qualité recalculée, ou selon la station ; quelles stations suivies l'auront, et quand.
- [ ] La décision de l'utilisateur.
- [ ] Les métriques de qualité dans les outils de lecture et le skill (même chemin qu'au point 59 : un premier pas, puis `/aiguiser`).
- [ ] L'analyste s'en sert (`analyser-lot`).
### Point 64 : Les sauts : dire pourquoi
**L'idée** (l'utilisateur, 2026-10-29). Un saut bref revient toujours à la normale, c'est ce qui le rend bénin ; dire « saut » ne suffit pas, il faut dire ce qui l'a causé. Assez souvent, une **référence** est cachée ou moins bien vue : la reprojection décale d'un coup des points, souvent groupés dans une partie de l'image ; au retour de la référence, la recalibration les ramène. Chaque cas est particulier.
**Ce qui existe.** La carte a les éventualités « Références masquées » (`error_value` haut sur une partie des références, `sigma0` qui monte, puis les `corr` qui se décalent) et « Une référence a bougé » ; aucun détecteur ne regarde les références.
**Garde-fou** (`CLAUDE.md`, Règles non négociables). Rien sur `inlier` binaire ni sur `sigma0` seul : poids continus, résidus, `N_eff`, influence ; des références cohérentes ne sont pas forcément fixes.
- [ ] L'utilisateur précise les causes de saut qu'il connaît (référence cachée, perdue, autre) et comment il les voit.
- [ ] Des cas validés (`/new-event`), dont une référence cachée.
- [ ] L'analyste cherche la cause de chaque saut (références, zone de l'image) ; puis `/events-learner`.
### Point 65 : Un saut marqué dès son début
**Ce qu'a vu l'utilisateur (2026-10-29).** `sauts` marque le saut un peu après son début ; l'événement doit englober tout le saut. Un détail : le journal se calcule après coup, on peut reculer le début jusqu'au départ du mouvement.
- [ ] Reculer le début de l'épisode dans `detectors/sauts.py` jusqu'à la dernière mesure au niveau d'avant ; vérifier par la page des détecteurs (NIEDERHORN, du 2026-09-25 au 2026-10-08) et le benchmark.
### Point 66 : Client et spécialiste : la complexité sur demande
**L'idée** (l'utilisateur, 2026-10-29). Les catégories nouvelles (trois effets thermiques, causes des sauts…) ajoutent beaucoup de complexité ; il faut des niveaux d'abstraction : le client voit l'essentiel, le spécialiste déplie le détail sur demande. La page Status (`detectors-view/status.py`) en est une bonne base visuelle. Lié au point 23 (deux couches : client et support) et à la hiérarchie des status (D-095).
- [ ] Quand les catégories des points 58, 62 et 64 sont décidées : pour chacune, le niveau client et le niveau spécialiste.
### Point 67 : Le savoir métier de l'analyste : le mécanisme, sans plus de pages
**L'idée** (l'utilisateur, 2026-10-29). L'analyste a besoin du savoir métier pour faire au mieux son travail ; les documents qu'on lui donne suffisent-ils ? On ne veut pas l'alourdir. Le savoir technique que l'utilisateur dit dans ses vocaux lui serait utile.
**Ce qu'il lit aujourd'hui (Claude, 2026-10-29).** `analyser-lot` (9,5 Ko), `lire-les-donnees` (21,5 Ko), `colonnes-des-deplacements` (6,3 Ko), `pieges-des-donnees` (2,8 Ko), la carte des événements (32,7 Ko), `read-event` et `events/INDEX.md` (12 Ko), puis jusqu'à trois fiches : environ 85 Ko, de l'ordre de 20 000 jetons avant la première donnée.
**Constat (Claude).**
- Son savoir est un **catalogue de symptômes** (carte, section 1 : chaque éventualité et sa signature) et un dictionnaire des colonnes. Il lui manque le **mécanisme** : comment une mesure se fait, et où chaque cause entre dans la chaîne. C'est ce que l'utilisateur sait et dit : une référence cachée, la reprojection décale une zone de l'image, la recalibration la ramène ; le support chauffe, la caméra compense mal ; le brouillard baisse le flux partout, un objet le coupe sur une cible. Avec le mécanisme, l'analyste raisonne sur un cas que la carte ne liste pas ; sans lui, il apparie des signatures (le brouillard de JUNGFRAU pris pour une cible masquée, point 62).
- Les règles non négociables des déplacements (`inlier` binaire, `sigma0` seul, mode commun contre mouvement de l'ouvrage, références cohérentes contre références fixes) sont dans `CLAUDE.md`, que l'analyste ne lit pas (`omitClaudeMd`, et la liste de ce qu'il a le droit de lire) ; aucun de ses documents ne les redit.
- Ce qui pèse sans servir : la carte est lue en entier, avec la « Phrase au client » et la source de chaque éventualité, inutiles pour étiqueter.
**Proposition (Claude).**
1. Une note courte, **la chaîne de mesure** (`labeling/connaissances/chaine-de-mesure.md`, une page), lue par l'analyste avant la carte : les étages (air, obstacle, cible, objectif, caméra et support, références et compensation, ouvrage) ; pour chacun, ce qu'il touche dans les données (positions brutes, `corr`, `error_value`, qualité, `reproj_err` des références, température) et son temps propre ; les règles non négociables en quatre lignes. Les savoirs des points 58, 61, 62 et 64 y entrent à mesure que l'utilisateur les valide, au lieu de s'éparpiller en notes.
2. La carte reste le vocabulaire (section 4, les catégories) ; la section 1 se consulte à la demande (`grep` de l'éventualité), pas en entier : au total, moins lu qu'aujourd'hui.
3. Savoir si c'est mieux, sans deviner : rejouer l'analyste sur un lot dont on connaît la réponse (le brouillard de JUNGFRAU), avant et après la note. Proposé, pas lancé.
**Où la mettre** (question de l'utilisateur, réponse de Claude, 2026-10-29). Dans `docs/displacement/domaine/`, la place du savoir métier des déplacements (règle de travail de `CLAUDE.md`), ajoutée à la liste de ce que l'analyste a le droit de lire. Pas dans `events/` : c'est la base qui grandit par les processus automatiques (l'`event-builder` y écrit, la carte y apprend, D-087), alors que le mécanisme ne change que sur la parole de l'utilisateur. Pas `CLAUDE.md` en partie : c'est la carte du projet pour les conversations, et l'analyste en est tenu à l'écart exprès (des conclusions sur les données) ; seules les quatre règles des déplacements le concernent, recopiées dans la note. La note ne redit ni les colonnes (`colonnes-des-deplacements.md`) ni les signatures (la carte) : elle dit pourquoi.
**Questions à l'utilisateur.**
1. La note de la chaîne de mesure, plutôt que des notes éparses ?
2. La carte lue à la demande ?
3. Le test avant et après, et sur quel lot ?
- [ ] Les réponses de l'utilisateur.
- [ ] Un brouillon de la note, tiré des vocaux du 2026-10-29 et des documents d'AIMsight (référence, §4.3 ; contexte support, §4), relu par l'utilisateur. Brouillon écrit le 2026-10-29 : `labeling/connaissances/chaine-de-mesure.md` (la chaîne en six étages, un tableau des causes par étage, les effets thermiques, les règles de lecture, les hypothèses de Claude marquées [H]) ; reste la relecture.
- [ ] `analyser-lot` : la note parmi ce qu'il lit ; la carte à la demande.
- [ ] Le test, si l'utilisateur le veut.
### Point 68 : L'expert étiquette lui-même : un outil web
**L'idée** (l'utilisateur, 2026-10-30). Une petite page web pour voir les données et les étiqueter soi-même, en expert du domaine : une base sur laquelle le LLM travaille ensuite ; l'analyste regarde ces étiquettes et prend connaissance des phénomènes, en plus de ce qu'on lui explique (point 67). Complémentaire, pas à la place.
**Avis de Claude (2026-10-30) : oui.**
- La seule vérité du projet est aujourd'hui l'analyste : `score.py` et le benchmark jugent les détecteurs sur ses étiquettes (« l'analyste peut se tromper aussi ») ; le plan dit encore à relire celles de E-001 à E-005 (point 48). Aucune étiquette ne vient de l'expert.
- Une étiquette coûte une ligne, un event un dossier (`/new-event`). Les deux se complètent : une étiquette marquante devient un event, et les cas des points 60, 62 et 64, que Claude devait chercher, l'expert les désigne.
- Ce qui fera sa valeur, c'est le **pourquoi** : une plage et le mot « saut » n'apprennent rien à l'analyste ; « référence cachée, la reprojection décale ces cibles, elle revient et tout se recale » lui apprend à raisonner.
**Précisions de l'utilisateur (2026-10-30), qui remplacent la proposition de Claude sur la page Status.** Les données se consultent déjà sur le monitoring : l'outil ne sert qu'à se repérer dans le temps et à écrire. Une page à part, un plot à la fois ; du langage naturel, **aucune catégorie**, pour ne pas borner (on en déduira après coup) ; un bouton Add qui écrit aussitôt dans le fichier, sans Save ; les zones déjà étiquetées restent visibles et peuvent se superposer ; un dossier à la racine, `labeling/`. Le but est d'avoir les étiquettes : un outil local, fonctionnel et très simple, ni parfait ni déployable.
**Description, à approuver par l'utilisateur.** De haut en bas :
1. Le data loader de la page Status (`chargeur.formulaire`) : station, dates, Analyse.
2. Un menu déroulant, comme le menu Advanced d'Explore (`select_graph` de l'application de référence) : Error value, X, Y, Relative shift H et V, Corrected shift H et V (`corr_x`, `corr_y`), References (reproj. error), Camera movement ; seulement les plots qui ont des données (Quality plus tard : seul NADELHORN a `quality/`, et il faudrait un lecteur de plus). Capteurs en légende comme à la page Status ; la plage de temps est gardée quand on change de plot.
3. Le plot : glisser zoome. Les zones étiquetées y sont grisées, sur tous les plots.
4. Dessous, la barre de temps, mêmes abscisses, qui suit le zoom : glisser y sélectionne une plage (box select horizontal de Plotly ; une figure n'a qu'un mode de glissement, d'où deux figures alignées). Chaque étiquette y est une barre, son texte au survol ; celles qui se chevauchent s'empilent, comme les status.
5. Dessous, la plage sélectionnée en UTC, le champ de texte, le bouton Add.
**Choix de Claude, à corriger au besoin.**
- `labeling/<STATION>.jsonl`, une ligne par étiquette : `{"debut": "2026-10-08T01:00Z", "fin": "2026-10-08T02:45Z", "description": "…"}`, les noms de champs de l'analyste, sans ceux qui bornent. Add écrit une ligne ; un `grep` suffit à chercher ; le diff git se lit. Versionné (`data/` ne l'est pas), hors de `events/` (ses seules portes : `/new-event`, `event-builder`).
- Pas de `capteurs` : le texte les dit.
- Pas de modification ni de suppression dans la page : une ligne à retirer du fichier (le texte se modifie dans la page depuis le 2026-10-30, voir plus bas).
- Un seul fichier de code, `labeling/labeling.py` : la page et son serveur (celui du data loader, plus l'enregistrement) ; de la page Status, seule change la cible du formulaire.
- Rien d'autre sur la page : ni images, ni status des détecteurs, que le monitoring montre.
**Ajout de l'utilisateur (2026-10-30).** Les métriques système au menu, « System: … » : celles qui ont des valeurs numériques sur la plage. Les identifiants (`SIM_CCID`, `ip`, `ip_*`) ne sont pas lus : `SIM_CCID` a souvent l'air d'un nombre, il serait tracé. Les métriques texte (`link`, `mode`, `last_sync`…) n'ont pas de courbe.
**Ajout de l'utilisateur (2026-10-30, après ses premières étiquettes).** Un clic sur la barre d'une étiquette l'affiche dans une fenêtre sous la barre ; son texte s'y modifie, Save l'enregistre. Save retrouve la ligne par son contenu et ne touche pas aux autres ; si elle a changé à la main entre-temps, il refuse et le dit. Un texte modifié, non enregistré, ne se perd pas sans une question. Les bornes et le retrait restent dans le fichier.
**Les limites à garder.**
- Une étiquette de l'expert est ponctuelle : un instant sans étiquette n'y veut pas dire « rien vu », contrairement à l'analyste (point 45). Face aux détecteurs, « trouvées » aurait un sens, « justes » non, tant qu'une plage n'est pas marquée relue en entier ; et `score.py` ne lit pas ces étiquettes, faute de catégorie. L'outil sert à apprendre, pas à calculer un score.
- Si l'analyste lit l'étiquette du lot qu'il analyse, il récite : elle lui apprend sur les autres périodes, et peut le mesurer sur la sienne (le test avant et après du point 67). Proposé, pas imposé.
- Pas d'alourdissement (point 67, ~85 Ko) : l'analyste n'y vient qu'une fois assez d'étiquettes écrites, à la demande, par une recherche. Rien à construire de son côté dans l'essai.
- [x] L'utilisateur approuve la description (2026-10-30).
- [x] L'outil : `labeling/labeling.py` (D-098), essayé le 2026-10-30 sur NIEDERHORN du 2026-09-25 au 2026-10-08 par de vrais gestes dans Chrome : sélection et poignées, Add, chevauchement, zoom suivi par la barre, changement de plot, rechargement ; pages de NORDEND (20 Mo, toute la période), CLARIDEN, LENZSPITZE et NADELHORN générées, NORDEND et LENZSPITZE chargées en moins de 2 s, un changement de plot en moins d'une seconde.
- [ ] L'utilisateur l'essaie et le valide (commité avant l'essai, à sa demande, le 2026-10-30).
- [x] Quelques cas étiquetés par l'utilisateur (13 au 2026-11-02) ; regarder ensuite ce que l'analyste en tire (point 69).
### Point 69 : Apprendre des étiquettes de l'expert : `/labels-learner`
**L'idée** (l'utilisateur, 2026-10-30). Les étiquettes ne valent que si elles servent : un processus, sans doute un skill, qui les montre à l'analyste pour qu'il apprenne. On n'est pas en apprentissage automatique : apprendre, ici, c'est de la documentation. Avec les étiquettes et le savoir métier, l'analyste comprend ce que l'expert étiquette, en conclut quelque chose et le documente. Plutôt l'analyste qu'un nouvel agent : c'est lui qui sait lire les données, et les mécanismes lui manquent (point 67). Question ouverte de l'utilisateur : comment tirer le maximum de ces étiquettes.
**Avis de Claude (2026-10-30).**
- L'analyste, oui, pas de nouvel agent. Une limite : il propose, il n'écrit pas dans ses propres documents. « Seul ce que l'expert a validé ou corrigé doit lui apprendre » (point 51) ; « le mécanisme ne change que sur la parole de l'utilisateur » (point 67).
- Pas de document nouveau : la carte pour les signatures et les faux amis (D-087 : une compilation à part est écartée), la chaîne de mesure pour le mécanisme (point 67), `lire-les-donnees` pour la méthode. Les étiquettes restent brutes dans `labeling/` : l'analyste ne les relit pas en séance, il lit ce qu'elles ont apporté (point 67 : ne pas l'alourdir).
- Le texte d'une étiquette n'est que le début. Ce qu'on peut en tirer de plus :
1. **L'écart** : ce que l'analyste aurait dit seul, face à ce que dit l'expert. C'est ce qu'il y a à apprendre.
2. **La signature mesurée** : l'expert dit « référence cachée » ; l'analyste retrouve dans les données quelles colonnes bougent, de combien, dans quel ordre, ce qui rend le savoir utilisable sur une autre station, puis par les détecteurs.
3. **Les questions à l'expert** : ce que l'analyste ne retrouve pas dans les données, ou ce qu'il y voit d'autre, revient à l'expert ; la réponse dit souvent ce que l'étiquette tenait pour acquis.
4. **Les comparaisons** : plusieurs étiquettes d'un même phénomène disent ce qui est général ; deux courbes semblables aux causes différentes donnent un faux ami.
5. **Les hypothèses à trancher** : les [H] de `chaine-de-mesure.md` peuvent devenir [U] ou [D].
**Proposition (Claude), à approuver.** Un skill `/labels-learner <STATION>`, sur les étiquettes que l'utilisateur désigne ; rendus dans `labeling/lecons/<date>_<STATION>/`, versionnés.
1. **Lecture à l'aveugle** : l'analyste lit, par `analyser-lot`, la plage de l'étiquette et sa marge, sans l'étiquette ; des étiquettes voisines, une seule lecture.
2. **Confrontation** : il reçoit l'étiquette et la chaîne de mesure ; pour chacune : déjà vu et bien dit, vu mais autre cause, pas vu, ou introuvable dans les données ; il retourne aux données pour la signature mesurée.
3. **Propositions** : des changements en termes généraux à la carte, à la chaîne de mesure, à `lire-les-donnees`, chacun avec sa source (l'étiquette citée, [U], [D] ou [H]), plus les questions à l'expert. Vu sur un seul cas ou une seule station : reste [H] (« pas de règle spécifique à un site »).
4. **Validation** : l'orchestrateur les présente une à une à l'utilisateur, comme `/review-event` ; rien n'entre dans les documents sans sa parole.
**Pourquoi la lecture à l'aveugle** (proposée, pas imposée). Après avoir lu la réponse, tout paraît évident : l'analyste dirait que la carte suffit, comme pour le brouillard de JUNGFRAU rangé en `cible_masquee` (point 62), et chercherait dans les données ce que dit l'étiquette (le risque nommé par D-088). Sans elle, le processus coûte moins et garde la signature et les questions, mais ne montre plus l'écart. Ce n'est pas une mesure de ses progrès, écartée par l'utilisateur (D-088).
**Limites.**
- Coût : environ 250 000 jetons pour une lecture d'un lot de 4 jours (D-059, chiffre ancien) ; une plage courte devrait coûter moins, à constater au premier essai, sur 3 à 5 étiquettes.
- Aucune étiquette n'existe encore : le skill s'écrit à l'aveugle et se corrigera sur les premières.
- La chaîne de mesure n'est pas encore lue par l'analyste : le point 67 (relecture, et son ajout à ce qu'il lit) doit suivre, sinon ce savoir ne l'atteint pas.
**Pistes à revoir.** Déduire des catégories de toutes les étiquettes (l'utilisateur, point 68) ; une étiquette marquante vers `/new-event` ; les détecteurs, ensuite, par `/events-learner` (l'ordre du point 57).
**Où on en est (l'utilisateur, 2026-10-30).** D'abord quelques étiquettes. La façon d'articuler le tout reste ouverte : `/labels-learner` n'est ni approuvé ni construit, la proposition ci-dessus attend de vraies étiquettes.
**Les pièces à articuler (Claude, 2026-10-30).**
| Pièce | Ce qu'elle apporte | Où | État |
|---|---|---|---|
| Étiquettes de l'expert | des cas bruts, en langage naturel | `labeling/` (point 68) | outil prêt, aucune étiquette |
| Savoirs dits par l'expert | effets thermiques, heat haze, occultation, causes des sauts | points 58, 61, 62, 64 | notés au plan, à valider |
| Chaîne de mesure | le mécanisme, le pourquoi | `labeling/connaissances/chaine-de-mesure.md` (point 67) | brouillon à relire, pas lu par l'analyste |
| Carte des événements | les signatures, les catégories, les faux amis | `events/carte-des-evenements.md` (D-087) | lue par l'analyste ; apprend de chaque event validé |
| Base d'events | des cas documentés et validés | `events/` | par `/new-event`, `/review-event`, `event-builder` |
| Analyste | lit tout cela et étiquette les lots | `analyser-lot` | sa lecture est la vérité de `/events-learner` |
| Détecteurs | le calcul, sans LLM | `detectors/`, par `/events-learner` | après l'analyste (point 57) |
**Le chemin envisagé, à confirmer.** Étiquettes → l'analyste les confronte aux données → ses propositions → la validation de l'utilisateur → chaîne de mesure et carte → l'analyste les lit → ses lectures de lots s'améliorent → `/events-learner` → les détecteurs. Dans le déroulé du point 57, les étiquettes entrent aux étapes 1 (le savoir) et 3 (les cas).
**Les questions, après les premières étiquettes.**
1. Par quoi le processus se lance : étiquette par étiquette, par station, ou par phénomène ?
2. La lecture à l'aveugle, ou non ?
3. Les cas des points 60, 62 et 64 : désignés par des étiquettes, puis `/new-event`, à la place de la recherche de périodes par Claude ?
4. La chaîne de mesure (point 67) : la relire avant, ou à la lumière des étiquettes ?
5. Une étiquette peut-elle un jour juger les détecteurs ? Pas aujourd'hui (D-098) : pas de catégorie, et un instant sans étiquette ne veut pas dire « rien vu ».
**À regarder sur ces étiquettes.** Disent-elles la cause, ou ce qu'on voit ? Comment l'expert l'a su ? Quels plots ? Quelles stations ? Ce qui a gêné dans l'outil.
**Les 13 premières étiquettes, lues par Claude (2026-11-02).** 8 à JUNGFRAU (un pont), 4 à NORDEND (une carrière), 1 à WILDSTRUBEL (une route). Toutes disent la cause **et** comment l'expert l'a sue : les plots cités (`corr`, `error_value`, erreur de reprojection, mouvement de la caméra, températures) et les images ; c'est du mécanisme, ce qui manquait à l'analyste (point 67).
| Phénomène | Étiquettes | Dans la chaîne de mesure ou la carte ? |
|---|---|---|
| Perte de référence : saut, puis caméra aveugle | JUNGFRAU 06/10, 14-15/10, 26/10, 27/10 ; NORDEND 04/09 11:00 | la ligne « Références » oui ; **le témoin `reproj_err` non** |
| Thermique de l'ouvrage (le pont monte en refroidissant), support plus rapide que l'ouvrage, compensation mauvaise | JUNGFRAU 11-12/10, 13/10 | oui (section 3), sans les temps relatifs |
| Thermique de la caméra sur un ouvrage qui ne bouge pas (carrière, route) | NORDEND 25-26/09, WILDSTRUBEL 27/09 | oui ; **le type d'ouvrage qui exclut l'effet de l'ouvrage, non** |
| Tendance de plusieurs jours avec la baisse des températures | JUNGFRAU 16-19/10 | non |
| Visibilité moins bonne, sans coupable | JUNGFRAU 07-08/10 | oui |
| Turbulence de jour, bien compensée | WILDSTRUBEL 27/09 | oui |
| Toile d'araignée contre l'objectif, saturée : **aucun signal** | NORDEND 03-04/09 nuit, 04/09 16:00 | la toile oui ; **l'angle mort non** |
**Vérifié dans les données par Claude [D]** (JUNGFRAU, les quatre plages ; NORDEND, 04/09) : une référence est rejetée dès que son `error_value` dépasse son `error_threshold` (0,7 pour REF_G et REF_D, 0,45 pour REF_CT ; 0,4 à NORDEND). Trois références acceptées : `reproj_err` > 0, `inlier` = 1. **Deux** : `reproj_err` = 0,000 sur les deux, `inlier` vide. **Une** : `reproj_err` vide partout. Cela s'explique : la similitude 2D a quatre inconnues (chaîne de mesure, étage 5), deux points en donnent quatre équations, l'ajustement est exact et le résidu nul, sans contrôle ; un point ne suffit pas. C'est la règle « un petit résidu n'est pas une transformation bien contrainte » dans sa forme la plus nette : `reproj_err` = 0 est un mauvais signe, pas un bon. Deux stations, cinq cas : assez général pour la chaîne de mesure, sur la parole de l'utilisateur.
- JUNGFRAU 14-15/10 : l'ordre est inverse de celui de l'étiquette : `reproj_err` vide de 02:00 à 04:00 (REF_G et REF_D rejetées, il ne reste que REF_CT), puis 0 de 04:30 à 06:00 (REF_G revenue), puis normal à 06:30.
- JUNGFRAU 06/10 : REF_G rejetée une seule mesure, à 06:00 (`error_value` 0,97).
- NORDEND 03-04/09, la toile : `error_value` de CTR04 à 0,08 et `reproj_err` normal toute la nuit : rien ne la voit, comme le dit l'étiquette.
**Ce qu'elles apportent hors des données.** Le contexte de la station, que l'analyste n'a pas : le type d'ouvrage (pont, carrière, route) et ce qu'il exclut ; le nombre de références et où elles sont (hors du pont) ; le fuseau, l'heure du lever lue sur les images (WILDSTRUBEL). Et une règle de lecture : un `error_value` haut n'est pas un problème en soi, ses variations le sont (JUNGFRAU 14-15/10).
**Les doutes de l'expert, des questions pour lui.** NORDEND 03-04/09 : « le système croit toujours en avoir 3 », « pas clair comment c'est calculé ». JUNGFRAU 11-12/10 : « l'erreur reste très stable, ce qui suggère une mauvaise compensation » : stable, donc pas la vue, donc un mouvement ? JUNGFRAU 13/10 : les températures de la station ne suivent pas clairement.
**Réponses proposées par Claude aux cinq questions, à trancher.**
1. **Par phénomène**, pour dire le général plutôt que le site ; d'abord la perte de référence (cinq étiquettes, deux stations), puis le thermique.
2. **À l'aveugle**, pour le premier essai : ni la carte ni la chaîne ne disent `reproj_err` = 0, l'écart se verra ; plages courtes (de 30 min à 6 h), donc peu coûteuses.
3. **Oui** : les étiquettes désignent les cas ; une étiquette marquante vers `/new-event` (la toile de NORDEND, un angle mort).
4. **À la lumière des étiquettes** : elles tranchent déjà une partie de la chaîne (le témoin des références, le type d'ouvrage) ; on la relit avec les propositions du premier essai.
5. **Non**, inchangé (D-098).
- Le contexte de la station : une ligne par station (ouvrage, références) que l'analyste lit, ou le texte des étiquettes suffit ? Question nouvelle.
**Réponses de l'utilisateur (2026-11-02).** Pas de lecture à l'aveugle : il n'en voit pas l'intérêt (question 2). Le texte des étiquettes suffit pour le contexte de la station : pas de fiche de station. Les questions 1, 3, 4 et 5 restent sur la proposition de Claude, sans réponse explicite.
**Le processus, simplifié en conséquence (Claude, à approuver).** `/labels-learner`, sur un phénomène :
1. L'analyste reçoit les étiquettes du phénomène et la chaîne de mesure ; pour chaque étiquette, il va dans les données de sa plage et en tire la **signature mesurée** (quelles colonnes, de combien, dans quel ordre), comme fait ci-dessus pour `reproj_err`.
2. Il compare les étiquettes entre elles (ce qui est général, ce qui tient au site) et rend ses **propositions** à la chaîne de mesure, à la carte et à `lire-les-donnees`, chacune sourcée, plus ses **questions** à l'expert, dont ce que les données contredisent.
3. L'orchestrateur les présente une à une à l'utilisateur ; rien n'entre sans sa parole.
Un seul passage de l'analyste par phénomène, au lieu de deux : moins coûteux ; l'écart entre l'analyste seul et l'expert ne se mesure plus, l'utilisateur n'en voit pas l'usage.
- [x] L'utilisateur réalise quelques étiquettes (`run.md`, « Étiqueter des données ») : 13 au 2026-11-02.
- [x] Les regarder ensemble ; répondre aux questions ci-dessus, décider le processus : lues le 2026-11-02, processus simplifié retenu par l'utilisateur.
- [x] S'il est retenu : le skill, et ce que l'agent `analyste` doit pouvoir faire de plus (la confrontation, hors `analyser-lot`). Fait le 2026-11-02 (D-099) : `.claude/skills/labels-learner/SKILL.md` (l'orchestrateur), `analyste.md` (la consigne de l'analyste, à la place d'`analyser-lot`) ; l'agent `analyste` lit la consigne que sa demande nomme ; `run.md`, « Apprendre des étiquettes ».
**Ajout de l'utilisateur (2026-11-02), qui remplace la validation une à une.** Ce que l'analyste apprend doit être documenté. Il pose ses questions à l'expert tant qu'il n'a pas compris (au plus trois tours) ; quand il a tout compris, il passe ses conclusions à un agent nouveau, le `documentaliste` (`.claude/agents/documentaliste.md`), dont le rôle est de maintenir la documentation du projet : il les place (chaîne de mesure, carte, `lire-les-donnees`, `docs/domaine/`), sans doublon, avec leur source. L'utilisateur relit le diff avant le commit.
- [ ] Le premier essai, sur 3 à 5 étiquettes réelles ; corriger le skill.
### Point 70 : Des étiquettes proposées par l'analyste, vérifiées par l'expert
**Idée de l'utilisateur (2026-11-02).** Un analyste écrit des étiquettes, l'utilisateur les vérifie à la main ; crainte : trop d'étiquettes, qui noient l'agent. Précision de l'utilisateur, le même jour : deux buts, faire progresser l'agent d'analyse, et optimiser les détecteurs sur une multitude d'étiquettes. Les events restent à part (pas de conversion de `events/` en étiquettes).
**Avis de Claude : deux buts, deux sortes d'étiquettes.**
| | 1. Faire progresser l'analyste | 2. Optimiser les détecteurs |
|---|---|---|
| Qui les lit | un agent (`/labels-learner`) | un script (`score.py`, comme `benchmark.py`) |
| Combien | peu : ce dont l'analyste doute | beaucoup : des lots entiers |
| Forme | texte libre, `labeling/<STATION>.jsonl` (D-098) | catégorie, capteurs, plage, période couverte en entier, format `etiquettes.json` (D-061) |
| Ce que vérifie l'expert | il réécrit avec ses mots | il corrige catégorie et bornes, lot par lot |
| Le risque | le cercle : une étiquette de l'analyste lui rend ce qu'il sait déjà ; ses propositions à part (`labeling/propositions/`), jamais lues par `/labels-learner` | la vérification à la main, longue sur des lots denses |
- **Noyer l'agent** ne vaut que pour le but 1, et `/labels-learner` en retient 5 par phénomène. Pour le but 2, c'est un script qui lit : le nombre ne coûte rien, il en faut beaucoup, et sur des périodes couvertes en entier, pour qu'un instant sans étiquette veuille dire « rien vu » (ce que les étiquettes libres ne disent pas, D-098).
- **Le but 2 existe à moitié** : l'analyste étiquette déjà chaque lot de `/events-learner` (`etiquettes.json`), le `detectors-critic` s'y mesure, et le benchmark sur les events (D-069) a des étiquettes figées, dont celles de E-001 à E-005 sont encore à relire (point 48). Manque : garder les étiquettes des lots, les faire vérifier, et un benchmark qui les lit toutes.
- Questions : pour le but 2, comment vérifier vite un lot dense (la page Status avec les étiquettes, ou un tableau à cocher) ? Combien de lots vérifiés avant de régler les détecteurs dessus, et lesquels garder hors réglage pour mesurer ? Pour le but 1, un fichier à part ou un champ `auteur` ?
**Décision de l'utilisateur (2026-11-02, D-100).** D'abord les étiquettes faites à la main : c'est la base de connaissance la plus fondamentale (des plages, le diagnostic et la classification de l'expert) ; le travail de l'analyste est de refaire cette classification sur des plages ; avec assez d'étiquettes, on pourra penser à l'apprentissage automatique. Les events sont gardés, et les validés ont aussi leurs étiquettes, écrites par un agent d'après leur fiche, puis ajoutées au fichier de leur station avec les vrais noms (l'outil ne charge que ceux-là).
- [x] Les étiquettes de E-001 à E-011 (validés), par un agent : 30, dans les fichiers des stations, le 2026-11-02 ; relecture par l'utilisateur (ou le `label-reviewer`).
- [ ] E-012 à E-014 après `/review-event` ; puis brancher l'étiquette dans `/new-event` et `/review-event`, pour chaque event validé plus tard.
- [ ] Le but 2 (les détecteurs) et les propositions de l'analyste : plus tard.
- [x] Un vérificateur des étiquettes de l'utilisateur, l'agent `label-reviewer` (D-101) : il pointe les incohérences et pose ses questions ; construit le 2026-11-02, premier essai sur NIEDERHORN le 2026-11-02 ; devenu le skill `/review-labels`, mené dans la conversation, une étiquette à la fois dans l'ordre chronologique (D-103).
### Point 71 : Un intégrateur : ce que deviennent les étiquettes
**Idée de l'utilisateur (2026-11-02).** Avec 43 étiquettes (7 stations), assez pour commencer à construire ; l'utilisateur les revoit d'abord avec le `label-reviewer`. Les étiquettes sont une base de connaissance, mais seulement une base : il faudra un intégrateur.
**Avis de Claude.** L'étiquette sert trois usages, qui demandent chacun leur intégration :
1. **Le savoir écrit** (le mécanisme, les signatures, les faux amis) : existe, `/labels-learner` puis le `documentaliste` (D-099), jamais lancé. Le lancer une fois avant de construire autre chose.
2. **L'analyste mesuré** (D-100 : son travail est de refaire la classification de l'expert sur les plages) : manque. L'analyste lit une plage étiquetée sans l'étiquette, puis on compare ; le texte libre ne se compare pas par script, il faut un juge (un agent qui dit d'accord, en partie, en désaccord) ou une forme structurée.
3. **Les détecteurs, puis l'apprentissage automatique** : manque ; il leur faut une forme structurée (catégorie, capteurs, plage) et des périodes couvertes en entier (point 70, but 2).
- La pièce commune à 2 et 3 : **dériver, d'une étiquette revue, sa forme structurée** (catégorie de la carte, capteurs, cause, preuve), après coup, comme D-098 le prévoyait, l'expert gardant le dernier mot. C'est peut-être cela, l'intégrateur.
- Pas un seul agent qui fait tout : un rôle par responsabilité (D-088) ; l'intégrateur serait un processus, comme `/events-learner`, qui enchaîne des agents existants.
- Questions : l'ordre (1 d'abord, puis la forme structurée ?) ; la forme structurée, dans la ligne de l'étiquette ou à côté ; un juge pour mesurer l'analyste, ou la forme structurée seulement.
**Demande de l'utilisateur (2026-11-02, D-104).** Après la revue : faire des étiquettes quelque chose d'utilisable par l'analyste, une carte des étiquettes comme la carte des événements ; avec elle, les étiquettes automatiques.
- [x] Le skill `/labels-map` et `labeling/carte-des-etiquettes.md`, premier passage (23 étiquettes, 14 phénomènes) ; relue face aux étiquettes, le skill renforcé.
- [ ] Revue de la carte par l'utilisateur, et ses six écarts avec la carte des événements.
- [ ] La carte lue par l'analyste, puis les étiquettes automatiques (`labeling/auto/`).
- 2026-11-02, premier essai (D-105) : l'analyste, sur la consigne `.claude/skills/analyser-lot/etiquettes-auto.md` (la carte des étiquettes en entier, ni `labeling/manual/` ni les détecteurs), étiquette JUNGFRAU du 20 au 25.10, une plage sans étiquette de l'expert, entre ses étiquettes du 16-19.10 et du 26.10 (pas de fuite par la carte) ; étiquettes au format de l'expert dans `labeling/auto/JUNGFRAU.jsonl`, analyse dans `labeling/auto/2026-11-02_JUNGFRAU/` ; l'outil les montre par son menu Labels (`manual` ou `auto`). L'utilisateur juge leur qualité.
- 2026-11-02 (D-106) : un agent à part, l'`etiqueteur` (`.claude/agents/etiqueteur.md`), un analyste qui ne produit que des étiquettes ; la consigne de l'essai devient son corps, `etiquettes-auto.md` retiré. Appel : `@etiqueteur data/<STATION> du <début> au <fin>`. Pas encore lancé.
- 2026-11-02 (D-107) : une catégorie du journal (ou `aucune`) dans l'étiquette, champ `categorie` ; obligatoire pour l'étiqueteur, au choix dans l'outil (menu Category).
- 2026-11-02 (D-108) : deuxième essai, JUNGFRAU 30.09 → 05.10 (`labeling/auto/2026-11-02_JUNGFRAU_2026-09-30/`), 15 étiquettes, globalement bon ; les deux thermiques réunies en `deplacement_thermique` ; les anomalies seulement.
- 2026-11-02 : l'étiqueteur ne garde que ses étiquettes ; son dossier de travail dans `out/etiqueteur/`, hors de git, comme ceux des deux essais (D-106).
- [x] **Familles d'étiquettes** (idée de l'utilisateur, 2026-11-02) : cinq familles au lieu des catégories du journal : Visibility (on voit moins bien), Obstruction (cible cachée), turbulences atmosphériques (bruit, route chaude), Thermal displacements (composants qui bougent avec la chaleur), Displacements (saut permanent ou dérive lente). Avis de Claude : bon découpage, une famille par cause et par conclusion pour le client ; à trancher : où vont `saut_bref`, `cible_a_probleme` et `trou` ; la frontière Visibility / Obstruction (toile d'araignée) ; la montée de plusieurs jours qui suit la température (Thermal, pas Displacements) ; étiquettes seules ou journal aussi.
- 2026-11-02 (D-109) : acceptées avec les ajustements de Claude : six familles, Target issue en plus ; `labeling/familles.md`, lu par l'étiqueteur ; le menu Category de l'outil ; pour les étiquettes seules.
- [x] **Turbulence et Visibility, une seule famille ?** (impression de l'utilisateur, 2026-11-02, après l'essai WILDSTRUBEL, où l'étiqueteur n'a pas su les séparer). Avis de Claude : deux mécanismes (l'image floue ou faible, l'image qui tremble), mais pour une étiquette la même conclusion pour le client et une séparation que les images fixes ne montrent pas ; réunir en `visibilite`, la description dit la signature vue. À trancher.
- 2026-11-02 (D-110) : réunies, sur la parole de l'utilisateur ; cinq familles.
2026-11-03 15:22:14 +01:00
- [x] **Ce qui apparaît sur corr_x et corr_y, trous compris** (l'utilisateur, 2026-11-02) : l'étiqueteur n'étiquette que ce qui bouge ou manque sur les courbes corrigées ; un trou s'explique comme un pic ; famille `trou` (No data) pour aucune mesure, la famille de la cause pour des cibles rejetées (D-111).
---
### Point 72 : `/events-learner` sur les étiquettes de l'étiqueteur
**Demande de l'utilisateur (2026-11-02).** Le processus qui optimise les détecteurs faisait analyser le lot par l'analyste, puis comparait les détecteurs à son analyse et proposait des améliorations ; ce travail de l'analyste se fait maintenant en amont, dans `labeling/auto/`, avec les étiquettes : adapter le processus pour utiliser les étiquettes produites.
- [x] La séance lit les étiquettes du lot (`labeling/auto/<STATION>.jsonl`), s'arrête s'il n'y en a aucune ; l'analyste, le `tool-builder` et l'`event-builder` sortent de la séance (D-112).
- [x] `score.py --du --au` : par famille et par instant, la correspondance de `labeling/familles.md` ; essayé sur WILDSTRUBEL 01 → 06.09 et JUNGFRAU 30.09 → 06.10.
- [x] `detectors-critic` et `detectors-upgrader` sur les étiquettes et le score par famille ; page de fin de séance par famille (capture sur WILDSTRUBEL).
- [ ] Première séance, lancée par l'utilisateur sur un lot étiqueté et relu (WILDSTRUBEL 01 → 06.09, ou JUNGFRAU 30.09 → 06.10).
- [ ] À trancher par l'utilisateur : rebrancher l'`event-builder` ou le `tool-builder` sur l'étiqueteur, ou les retirer.
### Point 73 : Revue des étiquettes de l'étiqueteur par l'analyste
**Demande de l'utilisateur (2026-11-04).** Un analyste relit les étiquettes de l'`etiqueteur` (`labeling/auto/`) pour en améliorer la qualité ; en faire un skill.
- [x] Consignes du relecteur : `.claude/skills/review-auto-labels/analyste.md` (bornes, un événement, famille, description, oubliées, d'après les règles de l'étiqueteur ; il propose, l'expert décide).
- [x] Premier essai, BREITHORN 01.10 → 01.11 : `labeling/auto/revue/BREITHORN_2026-10-01/revue.md` ; 14 gardées, 10 corrigées, 2 fusionnées, 1 oubliée. L'expert : les écarts de la caméra des nuits froides sont thermiques ; étiquettes proposées appliquées, carte des étiquettes complétée (variante, contexte de BREITHORN).
- [x] Le skill `/review-auto-labels <STATION> <début> <fin>`, plage choisie par l'utilisateur : lancer l'analyste, poser ses questions à l'expert, appliquer ce qu'il valide ; les étiquettes de la plage portent `revue`, la date, comme les manuelles, lues par `/labels-map` (D-128).
- [x] Revues de MICHIGAN et NEBRASKA d'octobre, toutes les suggestions appliquées.
- [x] Les leçons des trois revues dans la consigne de l'étiqueteur (bornes cible par cible, une dérive qui ralentit reste un événement, un phénomène cherché sur tout le lot, « c'est la caméra » vérifié cible par cible, la température du boîtier, « d'après l'expert ») et une frontière de `familles.md` (Thermal displacement ou Visibility).
- [x] Cohérence des trois stations, dans le même bâtiment d'après l'expert (`coherence.md`) : la dérive du mois, commune aux trois caméras, en `Displacement` partout (cause non établie : le bâtiment ou sa température) ; pertes de références du 09/10 et trou du 15-16/10 communs ; matin froid du 26/10 ajouté.
- [x] Revue des huit autres stations (CLARIDEN, FLORIDA, JUNGFRAU, LENZSPITZE, NIEDERHORN, NORDEND, SNCF01, WILDSTRUBEL), un analyste par station sur toutes leurs étiquettes non revues ; l'expert : le relecteur part des étiquettes et de l'analyse de l'étiqueteur (critiquer, améliorer, modifier, supprimer), il ne refait pas l'étiquetage (D-128) ; ses propositions sont appliquées sans validation de l'expert, pour cette fois ; ses nouveaux cas (section « Nouveaux cas » de la revue) intégrés à la fin par un seul `documentaliste`.
- [x] Les leçons qui touchent la carte (contexte de BREITHORN et MICHIGAN, fiches « un véhicule stationne devant des cibles », « la caméra s'incline peu à peu », compensation à deux références) : par le prochain `/labels-map`, qui lit les étiquettes automatiques revues.
### Point 74 : Revue croisée des étiquettes automatiques, toutes stations
**Idée de l'utilisateur (2026-11-04).** Relire sur le même lot que l'étiqueteur n'apporte pas forcément beaucoup ; changer la granularité de la revue, sur toutes les stations à la fois. En faire un skill.
- [x] Choisir le découpage : une famille, toutes les stations, chaque analyste cherchant ses phénomènes dans les autres familles par l'index (D-130). Niveaux déjà là : les étiquettes d'une station, la cohérence de stations voisines (`coherence.md`). Pistes ouvertes : par famille ou par frontière entre familles (nuits froides : `Thermal displacement`, `Displacement` ou `Visibility`) ; par heure, toutes stations (cause commune, surtout `No data`) ; par phénomène (la carte des étiquettes) ; là où les détecteurs ne sont pas d'accord (`compare.py`) ; la cohérence d'une station avec elle-même d'un mois à l'autre ; les règles de forme par script (chiffres, chevauchements).
- [x] Le skill de la revue croisée ; une étiquette déjà revue (`revue`) n'est pas exclue d'office d'une revue croisée (à trancher).
- [x] Le premier passage.
### Point 75 : Toute la connaissance du labeling dans `labeling/`
**Demande de l'utilisateur (2026-11-04).** À la fin : toutes les étiquettes « auto » validées et justes ; toute leur connaissance documentée ; toute la connaissance métier qui sert au labeling dans `labeling/`, les cas et les events compris (« d'une manière ou d'une autre, merger les cas et events au labeling »).
- [x] `labeling/regles-d-etiquetage.md` : comment poser une étiquette (la section « Les étiquettes » de la consigne de l'étiqueteur, plus les règles tranchées par la revue croisée) ; l'étiqueteur et les relecteurs s'y réfèrent.
- [x] `labeling/connaissances/` : la chaîne de mesure, les colonnes des déplacements, les images de la caméra, le cycle thermique, les cas annotés par l'expert, l'incident de Barcelone, déplacés de `docs/` (un renvoi y reste), et les trous (`les-trous.md`, tiré des pièges des données) ; liens mis à jour.
- [x] Les events et leur carte : ce qu'ils apprennent (signature, cause et comment elle a été sue, verdict, faux amis) et la carte des événements (familles, faux amis, ce qu'aucun détecteur n'attrape) entrent dans la carte des étiquettes, sourcés `[E-xxx]` ; `events/` reste l'archive des events et de leurs données, plus lue pour étiqueter.
- [x] La carte des étiquettes refaite sur toutes les étiquettes revues (manuelles et automatiques) et les events ; `familles.md` avec les frontières tranchées ; `/labels-map` lit aussi les events.
- [x] Les deux plages jamais étiquetées (WILDSTRUBEL 07/09 → 01/10, NORDEND 16/08 → 01/10) : étiqueteur, puis revue.
- [x] Contrôle final de toutes les étiquettes automatiques : `labeling/controle.py`, 0 erreur sur 991 ; les nuances d'une cause non établie restent permises (l'utilisateur, 2026-11-05).
### Point 76 : Les métriques de qualité d'image dans l'étiquetage
**Demande de l'utilisateur (2026-11-04).** Les métriques de qualité (`peak` à `snr`, caméras récentes) n'étaient lues ni par l'étiqueteur ni par l'analyste, faute d'outil : relire les étiquettes d'octobre de LENZSPITZE avec elles, et donner les outils aux futurs étiqueteurs (D-129).
- [x] Le menu de `labeling.py` montre les six métriques ; leur définition dans `labeling/connaissances/metriques-de-qualite.md`.
- [x] Revue de LENZSPITZE 16.10 → 01.11 avec les métriques (`labeling/auto/revue/LENZSPITZE_2026-10-01_qualite/revue.md`) : 24 gardées, 39 corrigées, 4 oubliées ; l'expert n'a pu trancher aucune question, défauts de l'analyste gardés ; 67 étiquettes appliquées.
- [x] Les outils de l'analyste dans `agent-tools/qualite.py` (tool-builder), `inventaire.py`, `graphique.py`, `resume.py`, le skill `lire-les-donnees` ; une phrase dans la consigne de l'étiqueteur.
- [x] Les leçons « Pour l'etiqueteur » de la revue dans sa consigne, sur l'accord de l'utilisateur : cause lue sur le flux, cibles nommées sur le flux, `--hors` pour les oubliées, « taches gonflées » face à la `fwhm`.
- [ ] La carte des étiquettes : le contexte de LENZSPITZE et « Ce que disent les métriques par famille », par le prochain `/labels-map` ; la ligne « Les obstructions lentes » de la carte des événements.
- [ ] `quality/` (`~/optical_emulator`) lu par `qualite.py` pour les anciennes caméras, quand une station en aura.
2026-10-23 21:52:08 +02:00
## Annexe A — Les rapports des agents du 2026-10-23, résumés
Huit agents, un par piste, lancés par l'orchestrateur ; tous ont rendu leur travail. Rien n'a été commité.
1. **Page Journal** : onglet construit (`explore.py`, `explore_template.html`, `spec.md`), plus `trous.py` ; captures de NORDEND d'octobre et de NIEDERHORN ; corrections en route : barres en `overlay`, libellés dans les barres, épisodes sans durée dessinés sur 1 h, « 12:00 – 12:00 » devient « 12:00 ». Défaut signalé, corrigé ensuite par l'orchestrateur : le « Lasting shift » couvrait toute la ligne Jumps.
2. **Visibilité** (`visibilite.py`) : critère relatif au capteur et non au seuil (la buée de E-001 reste sous le seuil) ; résultats au point 11 ; E-003 laissé au détecteur turbulence (`error_value` ×1,5 à ×3 seulement), les deux détecteurs se complètent par le taux de rejet.
3. **Sauts** (`sauts.py`) : résultats au point 12 ; ajout d'une troisième étiquette « Jump, not back yet » (moins d'un jour de recul : l'event courant d'un journal du matin) ; aucun seuil ne sépare les trains de NIEDERHORN des cibles saines de PS des Coudres.
2026-10-23 21:52:08 +02:00
4. **Cycle thermique** (`thermique.py`) : découverte au point 13 : le cycle est dans les positions brutes, la compensation l'enlève, sauf à PS des Coudres.
5. **Turbulence** (`turbulence.py`) : résultats au point 14 ; c'est l'`error_value` qui sépare la turbulence des midis agités ; marge faible sur le matin du mouvement de CLARIDEN.
6. **Cartographe** (`carte-des-evenements.md`) : point 3.
7. **Lissage** (`lissage.md`) : partie V ; recommandation : masquer seulement (option A).
8. **Données et boucle** (`donnees-et-boucle.md`, `extraction/`) : partie VI ; recommandation : option A, un seul script ; aucun secret lu, rien lancé, rien modifié dans les dépôts `monitoring-*`.
## Annexe B — Commandes
Depuis `/home/maxime/Support-Agent`.
- **Un détecteur seul** : `python3 detectors/<nom>.py <dossier>` (`<nom>` : `visibilite`, `sauts`, `thermique`, `turbulence`, `trous`).
- **Les événements catégorisés** (après le point 6) : `python3 detectors/categories.py <dossier>` ; en tranches (point 30) : `... <dossier> --tranche 3` (3 jours d'historique par défaut).
2026-10-23 21:52:08 +02:00
- **Construire la page sans l'ouvrir** : `.venv/bin/python -c "import sys; sys.path.insert(0,'vues-deplacements/maquette'); import explore; print(explore.page('<dossier>'))"`.
- **Construire et ouvrir** : `python3 vues-deplacements/maquette/explore.py [dossier]` (défaut : le cas NORDEND d'octobre ; s'ouvre sur l'onglet View).
- **Ouvrir sur l'onglet Journal** : `"/mnt/c/Program Files/Google/Chrome/Application/chrome.exe" "file://///wsl.localhost/Ubuntu/home/maxime/Support-Agent/out/vues_deplacements_<STATION>.html#tab=journal"` (en arrière-plan : la commande ne rend la main qu'à la fermeture si Chrome n'était pas ouvert).
- **Capturer** : `"/mnt/c/Program Files/Google/Chrome/Application/chrome.exe" --headless=new --disable-gpu --hide-scrollbars --window-size=1600,1300 --virtual-time-budget=10000 --screenshot="$(wslpath -w <png>)" "file:///$(wslpath -w out/vues_deplacements_<STATION>.html | sed 's#\\#/#g')#tab=journal"` ; PNG dans le dossier temporaire de la session, jamais dans un dossier de station.
- **Jeux** : `vues-deplacements/cas/2026-10_NORDEND/NORDEND` (11 jours, 15 min, 985 images), `data/PS_DES_COUDRES` (E-001), `data/NORDEND` (E-002), `data/WILDSTRUBEL` (E-003), `data/CLARIDEN` (E-004), `data/NIEDERHORN` (E-005). Le cas NORDEND écrit `out/vues_deplacements_2026-10_NORDEND.html`, `data/NORDEND` écrit `out/vues_deplacements_NORDEND.html` (point 37).
2026-10-23 21:52:08 +02:00
- **Pompage** (utilisateur, dans le container) : `extraction/README.md`.
## Journal du plan
Une ligne par séance : date, point(s) traités, ce qui a changé, ce qui reste.
- 2026-10-23 : plan écrit à partir de la conversation du 2026-10-23 (brainstorming vocal, huit agents, v0 de l'onglet Journal, retour de l'utilisateur sur la v0).
2026-10-24 08:24:30 +02:00
- 2026-10-23 : suggestion de l'utilisateur ajoutée : la simplicité comme règle d'or (Contraintes), la visibilité simple (point 11 réécrit), le bouton `Images` et son timelapse avec marge avant et après (point 7 réécrit) ; chemin conseillé : 11 puis 7.
- 2026-10-23 : suggestion de l'utilisateur ajoutée : les statuts de visibilité, bonne, moyenne (« les données sont moyennes », la pluie) et nulle (« on ne voit rien »), par cible et pour la station, comme les statuts des métriques système (point 38, nouveau, rangé dans la partie II) ; processus du point 5 ramenés au seul bouton `Images`.
- 2026-10-24 : règle de l'utilisateur ajoutée (en-tête, index) : un point n'est « validé » que sur sa parole, et un point validé n'est plus reproposé ; on avance dans l'ordre, à partir du point 1. Point 1 commencé : les six pages construites et capturées (3 derniers jours et période entière) ; visite jeu par jeu en cours.
- 2026-10-24 : **point 1 validé** par l'utilisateur après NORDEND d'octobre (« rien à ajouter ») et PS des Coudres (« tu peux considérer comme validés tous ces jeux de données ») ; défaut vu sur PS des Coudres (3 cibles sur 11 dans les courbes) : point 39, nouveau, partie IV. Point 2 commencé.
- 2026-10-24 : **point 2 validé** par l'utilisateur (sortie des cinq détecteurs sur leur cas, défaut connu et point de la partie III pour chacun). Point 3 commencé.
- 2026-10-24 : point 3 : arbre Mermaid rendu sans erreur ; consigne de l'utilisateur : la carte recense tout ce qui peut arriver, vu ou non, en familles (précision de D-056) ; carte complétée : 33 événements en six familles. Reste : validation de la carte par l'utilisateur, question des trains.
- 2026-10-24 : **point 3 validé** par l'utilisateur : la carte complétée (33 événements, six familles) est validée comme base, à compléter au fil des events ; les trains de E-005 restent à classer au point 5. Point 4 commencé.
- 2026-10-24 : point 4 : brainstorming relu section par section ; précision de l'utilisateur : une anomalie est tout ce qui sort de la norme (courbes pas plates), presque toujours sans gravité, parfois grave (Barcelone, voûte du pont qui s'affaisse) ; reportée dans D-056, `CLAUDE.md`, le brainstorming, la carte et `incident-de-barcelone.md`. Reste : la validation du point 4.
- 2026-10-24 : **point 4 validé** par l'utilisateur. Point 5 commencé.
- 2026-10-24 : **point 5 validé** par l'utilisateur : huit catégories, règles et sept recommandations telles quelles ; écrites dans la carte (section 4, lignes « No data » et cycle thermique retouchées) et sous D-056 ; attendu de E-002 au point 10 mis à jour. Prochain : point 6, le classement.
- 2026-10-24 : point 6 fait : `detectors/categories.py` (catégories, absorption, fusion), page branchée sur les événements (frise par catégorie) ; contrôles NORDEND et CLARIDEN passés ; écarts à l'interface notés au point 6 ; reste la validation de l'utilisateur.
- 2026-10-24 : **point 6 validé** par l'utilisateur. Point 7 commencé.
- 2026-10-24 : point 7 fait : bouton `▶ Images` et timelapse dans la page (marge de 1 à 6 h, 4 images par seconde, bord rouge pendant l'événement) ; contrôles NORDEND (14/10) et PS des Coudres (nuit du 13/10 sans image) passés ; reste le réglage à l'œil et la validation de l'utilisateur.
- 2026-10-24 : **point 7 validé** par l'utilisateur (marge et vitesse gardées). Prochain : point 8, la page Journal catégorique et plus simple.
- 2026-10-24 : point 8 fait : frise d'une ligne « What happened » colorée par famille, dessinée par portée ; journal en cartes ; spec réécrite ; reste le jugement de l'utilisateur.
- 2026-10-24 : **point 8 validé** par l'utilisateur, pas entièrement satisfait ; son idée, déplier la frise au lieu de tout empiler sur une ligne, devient le point 40 (nouveau, partie IV). Point 9 commencé.
- 2026-10-24 : point 9 fait : phrases validées par l'utilisateur et codées (`categories.phrase`, clé `lasting` dans `sauts.py`) ; aucune phrase qui hésite sur les six jeux ; carte, section 4, à jour ; reste à les voir dans la page et la validation.
- 2026-10-24 : **point 9 validé** par l'utilisateur. Point 10 commencé.
- 2026-10-24 : point 10 fait : les six jeux classés et capturés ; tout l'attendu est là, aucun écart du classement ; les événements en trop viennent de `visibilite` (points 11 et 18) ; colonne « Obtenu » ajoutée au tableau du point 10 ; reste la validation des six captures.
- 2026-10-24 : **point 10 validé** par l'utilisateur (six captures) : la partie II, le journal catégorique, est faite, sauf le point 38 (statuts de visibilité, après le point 11). `CLAUDE.md` mis à jour. Prochain : point 11.
- 2026-10-24 : travail des points 1 à 10 commité (`4ac95ae`). Point 11 commencé.
- 2026-10-24 : point 11 : version simple de `visibilite` écrite et comparée à la v0 sur les six jeux (tableau au point 11) : moins bonne sur cinq jeux, grise le vrai mouvement de CLARIDEN ; recommandation : remettre la v0 ; choix de l'utilisateur attendu.
- 2026-10-24 : point 11 : l'utilisateur garde la v0 de `visibilite` (remise dans `detectors/visibilite.py`), la version simple va dans `detectors/archive/visibilite_simple.py`.
- 2026-10-24 : **point 11 validé** par l'utilisateur (v0 gardée). Point 38 commencé.
- 2026-10-24 : point 38 fait : deux niveaux de visibilité (« Reduced », « No visibility ») codés dans `visibilite.py`, `categories.py` et la page ; décision sous D-056 ; carte, spec, registre (`MOITIE`) et point 5 à jour ; reste la validation de l'utilisateur.
- 2026-10-24 : **point 38 validé** par l'utilisateur. Point 12 commencé.
- 2026-10-24 : point 12 fait : `sauts` teste ses premières mesures face au niveau d'après ; le train du 30/09 22:00 de NIEDERHORN est vu et absorbé dans son passage ; les cinq autres jeux inchangés ; reste la validation.
- 2026-10-24 : **point 12 validé** par l'utilisateur. Point 13 commencé.
- 2026-10-24 : point 13 : réponses de l'utilisateur notées (grosses vagues = dilatation thermique de l'ouvrage, normales ; pas de signalement à NORDEND ; rien sur la caméra compensée) ; note `labeling/connaissances/cycle-thermique.md` ; son idée, l'effet périodique par une sinusoïde de 24 h (dilatation et contraction), devient le point 41 (nouveau, partie III), ébauche encourageante ; carte : événement « Dilatation thermique de l'ouvrage » ajouté à la famille F.
- 2026-10-24 : **point 13 validé** par l'utilisateur. Point 41 commencé, à sa demande, avant le point 14.
- 2026-10-24 : point 41 fait : effet périodique dans `thermique.py` (profil répété et sinusoïde de 24 h, les deux exigés), dilatation puis contraction chaque jour à PS des Coudres, rien ailleurs ; carte, D-056, spec, note et registre à jour ; reste la validation (et l'essai sur de grosses vagues, plus tard).
- 2026-10-24 : **point 41 validé** par l'utilisateur (contraction jusqu'au retour au niveau de nuit, gardée). Point 14 commencé.
- 2026-10-24 : point 14 : CLARIDEN protégé dans le classement (une turbulence qui chevauche un saut à vérifier n'est pas gardée), vérifié quelle que soit la durée ; reste la décision sur les midis agités.
- 2026-10-24 : **point 14 validé** par l'utilisateur (midis agités non signalés). Point 15 commencé.
- 2026-10-24 : point 15 fait : la phrase d'un trou dit s'il y a des images pendant (NORDEND : aucune) ; reste la validation.
- 2026-10-24 : **point 15 validé** par l'utilisateur. Point 16 commencé.
- 2026-10-24 : point 16 fait : dérive lente dans le journal (tendances de l'onglet Displacements, PR06 à NORDEND), références masquées couvertes, les trois autres pistes remises ; carte, D-056, spec à jour ; reste la validation.
- 2026-10-24 : **point 16 validé** par l'utilisateur. Point 17 commencé.
- 2026-10-24 : point 17 fait : registre déplacé dans `vues-deplacements/contexte/seuils-du-journal.md`, vérifié contre le code (valeurs conformes ; `MERGE` et les constantes de tendance ajoutés) ; reste la validation.
- 2026-10-24 : **point 17 validé** par l'utilisateur ; la partie III est faite. Travail des points 11 à 17, 38 et 41 commité. Point 18 commencé.
- 2026-10-24 : point 18 fait (option a) : « Target hidden » ne grise plus que les courbes de ses cibles ; NORDEND du 13 au 14/10 et CLARIDEN débarrassés de leurs fonds gris ; reste la validation.
- 2026-10-24 : **point 18 validé** par l'utilisateur. Point 19 commencé.
- 2026-10-24 : point 19 fait : l'échelle du Journal laisse de côté les zones grisées et les cibles masquées, bouton `Fit all` ; WILDSTRUBEL lisible ; PR_BG à CLARIDEN (bascule entre deux positions) signalé à l'utilisateur ; reste la validation.
- 2026-10-24 : **point 19 validé** par l'utilisateur (PR_BG jugé peu important, laissé noté au point 19). Point 20 commencé.
- 2026-10-24 : point 20 fait : sélecteur mm / px, mm par défaut ; noms de l'export horaire nettoyés (NIEDERHORN) ; reste la validation.
- 2026-10-24 : **point 20 validé** par l'utilisateur. Point 21 commencé.
- 2026-10-24 : **point 21 validé** par l'utilisateur (3 jours fixes ; « depuis ta dernière visite » noté au point 36). Point 22 commencé.
- 2026-10-24 : **point 22 validé** par l'utilisateur (tous les gestes marchent). Point 23 commencé.
- 2026-10-24 : point 23 fait : case `Support view` (lignes par détecteur, replis `Details`), vue client inchangée ; reste la validation.
- 2026-10-24 : **point 23 validé** par l'utilisateur. Point 39 commencé.
- 2026-10-24 : point 39 fait : les cibles `target02` à `target05` comptent comme des cibles (`explore.build`) ; PS des Coudres a ses 10 courbes en px ; reste la validation.
- 2026-10-24 : **point 39 validé** par l'utilisateur. Point 40 commencé.
- 2026-10-24 : point 40 fait : case `Expand`, une ligne par catégorie (choix de l'utilisateur) ; NORDEND et WILDSTRUBEL : plus rien de caché ; reste la validation.
- 2026-10-24 : **point 40 validé** par l'utilisateur. Point 24 commencé.
- 2026-10-24 : point 24 : les trois questions du lissage tranchées par l'utilisateur (les deux courbes ensemble ; calcul quand le client regarde, rien dans la base ; cycle thermique tel quel) ; notées sous D-056 et dans `lissage.md` ; reste la validation.
- 2026-10-24 : **point 24 validé** par l'utilisateur. Point 25 commencé.
- 2026-10-24 : point 25 fait : courbes nettoyées par masquage (coupées dans les zones à ignorer, brute en gris fin) ; CLARIDEN intact au 19/09 06:10 ; reste la validation.
- 2026-10-24 : **point 25 validé** par l'utilisateur. Point 26 commencé.
- 2026-10-24 : **point 26 validé** par l'utilisateur (B à E en réserve ; D tombe avec le point 24, B serait centrée). Point 27 commencé.
- 2026-10-24 : point 27 mis en attente : l'utilisateur n'a pas accès aux données pour l'instant ; application de référence `~/monitoring-dashboard` ; script relu contre son code, sortie branchée sur le journal (images différentielles écartées) ; essai plus tard, avec le harnais (points 30 et 31).
- 2026-10-24 : point 30 fait : tri en lot (`--tranche`, `--historique`, `--du`, `--au`) ; sur NORDEND, des tranches seules absorbent le vrai saut de PR17, 3 jours d'historique le rendent ; reste la décision de l'utilisateur sur l'historique et la validation.
- 2026-10-24 : point 30 : règle de l'utilisateur, 3 jours d'historique par défaut dans l'outil, et pour la boucle et la vraie application (D-056) ; reste la validation.
- 2026-10-24 : **point 30 validé** par l'utilisateur. Point 31 commencé.
- 2026-10-24 : point 31 mis en attente : l'utilisateur a des consignes plus précises, pour une autre conversation, et il faut les données ; rien créé.
- 2026-10-24 : point 32 mis en attente : l'utilisateur le traitera dans une autre conversation. Reste à faire dans l'ordre : point 37 (ménage) ; 33 à 36 en attente.
- 2026-10-24 : point 37 fait : `CLAUDE.md` à 199 lignes et à jour, sorties NORDEND séparées, Mermaid déjà rendu au point 3, travail commité ; reste la validation.
2026-10-24 15:14:14 +02:00
- 2026-10-24 : **point 37 validé** par l'utilisateur. Il ne reste que des points en attente : pompage (27 à 29, accès aux données), boucle Claude et test « Claude verrait la même chose » (31, 32, autres conversations), idées pour plus tard (33 à 36).
- 2026-10-24 : point 31 : consignes de l'utilisateur reçues (boucle automatique : analyste, upgrader, validateur, builder) et notées au point 31 ; brainstorming en cours, rien construit.
- 2026-10-24 : point 31 : réponses de l'utilisateur (tout commité, events ajoutés sans attendre, pas de rejeu, crainte de la complexité) ; conception écrite dans `vues-deplacements/contexte/boucle-automatique.md`, à approuver.
- 2026-10-24 : point 31 : conception approuvée par l'utilisateur (agent de diagnostic hors de la boucle, events appris dans la base commune) ; plan de construction écrit, `docs/superpowers/plans/2026-10-24-boucle-automatique.md`.
2026-10-24 15:14:14 +02:00
- 2026-10-24 : point 31 : boucle construite (tâches 1 à 6 du plan `2026-10-24-boucle-automatique.md`, D-057) ; reste la première séance sur NORDEND d'octobre, lancée par l'utilisateur.
- 2026-10-24 : point 31 : essai de l'analyste sur le lot 1 de NORDEND ; **fonctionnement de la boucle validé** par l'utilisateur ; il lancera lui-même les séances, lot par lot, sur de nouvelles données ; travail commité.
- 2026-10-24 : point 42 ajouté (aiguiser la lecture : un skill de lecture, un lecteur, un correcteur qui lit à fond sans les outils, un optimiseur) ; conception écrite dans `vues-deplacements/contexte/aiguiser-la-lecture.md`, à approuver.
- 2026-10-24 : point 42 : conception approuvée par l'utilisateur ; plan de construction écrit, `docs/superpowers/plans/2026-10-24-aiguiser-la-lecture.md` (6 tâches) ; rien construit.
- 2026-10-24 : point 43 ajouté (idée de l'utilisateur : base locale complète et incrémentale, pilotée par Claude) ; écart avec `pomper.py` noté ; rien codé.
- 2026-10-24 : point 43 codé sans lancement : métriques système, un fichier par jour, reprise des images corrigée, `load_stations` fusionne les fichiers d'une même métrique ; essai par l'utilisateur avec le point 27.
- 2026-10-24 : point 42 : `/aiguiser` construit (D-059), avec le releveur (D-060) ; essai du lecteur et du correcteur sur le lot 1 de NORDEND : écart « à reprendre », deux défauts ; reste la première séance, par l'utilisateur.
- 2026-10-25 : point 44 ajouté (idée de l'utilisateur : un modèle de machine learning entraîné sur les labels de la boucle) ; proposition de Claude notée, à discuter ; rien construit.
- 2026-10-25 : point 44 : l'utilisateur garde les labels d'abord, pas de modèle tout de suite ; étiquettes écrites par l'analyste à chaque lot (`etiquettes.json`, contrôle `critiquer-lot/etiquettes.py`, D-061) ; reste la première séance et la visibilité de l'utilisateur sur les labels.
- 2026-10-25 : point 45 ajouté (précision de l'utilisateur : la boucle sert la détection sur tout le lot, chaque instant valide ou non avec sa catégorie) ; écarts constatés (validité implicite, précision non mesurée, pas de rejeu) ; proposition d'un score, trois questions à l'utilisateur ; rien codé.
- 2026-10-25 : point 45 : l'utilisateur laisse Claude choisir ; score codé (`.claude/skills/boucle/score.py`, D-062 : trois niveaux, par mesure, par capteur), branché sur l'orchestrateur, l'upgrader et le validateur ; consigne des sauts dans les étiquettes ; à juger à la première séance.
- 2026-10-26 : points 27, 28 et 43 : premier pompage par l'utilisateur (NORDEND, 29 et 30/07) : métriques, déplacements du 29/07 et images identiques aux exports reçus ; déplacements du 30/07 en échec (`DatabaseError`), cause affichée à la relance ; images différentielles : traînées claires pendant E-002, à confirmer ; mode d'emploi simplifié (le container monte `~` : sortie directe dans `data/`, ou `out/pompage/` pour une station déjà reçue).
- 2026-10-26 : point 27 fait, à valider : le 30/07, en échec par délai dépassé (60 s) alors qu'il n'est pas plus lourd que le 29/07, relancé avec la nouvelle option `--delai 300` (93 s) : identique à l'export reçu ; `categories.py` donne les mêmes événements sur le dossier pompé que sur l'export reçu aux mêmes jours ; pomper 3 jours d'historique en plus.
- 2026-10-26 : point 43 : mouvements de la caméra ajoutés au pompage (demande de l'utilisateur) : `camera/`, un CSV par jour, une ligne par mesure ; essayé sur le 30/07 de NORDEND (70 poses sur 95 instants, `sigma0` sur 7 seulement, comme l'export).
- 2026-10-26 : point 31 : préparer la séance sur NORDEND de septembre (idée de l'utilisateur) : aucun lot à créer, `/boucle` les découpe ; restent l'historique (29 au 31/08), les images, garder `out/pompage/NORDEND/`, choisir les lots sur le tri gratuit du mois.
- 2026-10-26 : point 42 : l'utilisateur fait passer `/aiguiser` avant `/boucle`, sur NORDEND du 01 au 04/09 (données nombreuses) ; constats des outils actuels sur ces jours (graphique illisible à 22 capteurs, inventaire de 880 lignes sur un dossier pompé) ; séance à lancer par l'utilisateur quand les images seront là.
- 2026-10-26 : point 28 : sens des images DIFF et IRON lu dans le manuel de la station (DIFF : les réflecteurs, contraste renforcé, l'image mesurée ; IRON : la scène), noté dans `labeling/connaissances/images-de-la-camera.md` ; l'utilisateur les juge peu utiles pour `/boucle` et `/aiguiser` : `--diff` sorti de la commande de `run.md`, gardé en option.
- 2026-10-26 : point 43 : `data/` sort de git et devient la seule sortie du pompage (demande de l'utilisateur, D-065) ; `/aiguiser`, `/boucle`, `/new-event` branchés dessus ; les exports reçus à la main seront retirés et leurs plages repompées, élargies (commandes données à l'utilisateur).
- 2026-10-26 : point 31 : une séance de la boucle lancée à la demande de l'utilisateur (NORDEND, 01 → 04/09, un lot, dossier `out/pompage/NORDEND`) : 23 étiquettes, modification gardée (`saut_bref` de 0 à 7 mesures trouvées sur 24, faux passage retiré), cas E-006 à E-008 appris ; bilan `boucle/2026-10-26T1414Z_NORDEND/bilan.md`, sur la branche `boucle/2026-10-26T1414Z_NORDEND`.
- 2026-10-26 : point 46 ajouté et codé (idée de l'utilisateur : la page de fin de séance, l'analyste face aux détecteurs, D-066).
- 2026-10-26 : dossier des détecteurs renommé `detectors/` (demande de l'utilisateur, D-067).
- 2026-10-26 : point 47 ajouté (l'utilisateur : les détecteurs doivent tout détecter, l'affichage au client est une autre question, D-068) ; règle posée dans les consignes de la boucle ; page de fin de séance : score en tableau lisible.
- 2026-10-26 : point 31 : relevés du releveur sur la séance de NORDEND traités (13 entrées de `docs/ameliorations-processus.md`) : arguments de `/boucle` (nom de station, `--au` exclu), autre session dans le dépôt, nom de branche de la spec, cas de la base relancés par l'upgrader à chaque modification, détecteur imprimé par `categories.py`, en-tête des fiches apprises, `anonymiser.py` (`camera/`, plus de CSV vides), `ensemble.py` (pas calés sur l'horloge, titre) et `plages.py` (fusion du même sens) ; les 59 commandes des fiches passent.
- 2026-10-26 : point 48 ajouté (idée de l'utilisateur : un benchmark des détecteurs sur la base d'events, versionné, pris en compte par l'upgrader) ; proposition de Claude (étiquettes figées dans chaque event, `score.py` réutilisé, historique CSV), essai sur E-006 ; trois questions à l'utilisateur ; rien construit.
- 2026-10-26 : point 48 : l'utilisateur dit oui aux trois choix ; benchmark construit (D-069) : étiquettes dans chaque event, `benchmark.py`, historique, branché dans `/boucle` et `/new-event` ; reste la relecture des étiquettes de E-001 à E-005 par l'utilisateur.
- 2026-10-26 : point 43 : métriques système dans `data/<SERIE>/metrics/` (demande de l'utilisateur) ; `pomper.py` y écrit, `load_stations` y lit aussi ; fichiers de CLARIDEN et NIEDERHORN déplacés.
- 2026-10-26 : point 48 : tout au même endroit (l'utilisateur) : le rendu d'étiquetage de chaque event devient `etiquetage.md` dans son dossier (E-001 à E-005 déplacés, E-006 à E-008 écrits par `anonymiser.py`, qui l'écrit désormais avec `--etiquettes`) ; `vues-deplacements/benchmark/` ne garde que l'historique.
- 2026-10-26 : point 31 : `/boucle` commite directement sur `master` (demande de l'utilisateur, D-070) ; branches des séances NORDEND et CLARIDEN fusionnées dans `master` et supprimées.
- 2026-10-26 : point 31 : `/boucle --ameliorer` (demande de l'utilisateur, D-071) : après le releveur, l'agent `ameliorateur` corrige le skill et ses agents d'après les entrées de la séance ; sans séance d'essai.
- 2026-10-26 : point 43 : la pose de la caméra entre dans la lecture (demande de l'utilisateur, D-073) : `charger_camera` dans `donnees.py`, panneaux et colonnes `cam_` dans `ensemble.py`, instants sans recalage dans `inventaire.py`, pose lue en premier par `lire-les-donnees`.
- 2026-10-27 : point 49 ajouté (demande de l'utilisateur) : graphe des éventualités du terrain vers les catégories, `events/eventualites-et-categories.drawio`, à la place de l'arbre Mermaid de la carte ; deux catégories proposées, Target issue et Cible déplacée.
- 2026-10-27 : point 49 : catégories définies par l'utilisateur (D-074) : « À vérifier » pour tout ce qui reste inexpliqué, avec la dérive lente et le gros saut en sous-groupes ; Target issue gardée ; graphe refait ; reste à les reporter dans le journal.
- 2026-10-27 : point 49 : le véhicule qui fait vibrer l'ouvrage ou la caméra va dans Saut bref (l'utilisateur).
- 2026-10-27 : point 49 : un détecteur au moins par catégorie (demande de l'utilisateur) : `derive.py`, cible collée et bascule en Target issue, gros saut, effet thermique de la caméra ; carte (section 4) et `critiquer-lot` mis aux définitions de D-074 pour l'analyste.
- 2026-10-27 : point 50 ajouté (idée de l'utilisateur) : une ligne Status qui compile tous les détecteurs selon une hiérarchie ; proposition de Claude (six niveaux, absorption sortie de `categories.py`) ; trois questions ; rien construit.
- 2026-10-27 : point 50 : « À vérifier » et « Dérive lente » hors du Status (l'utilisateur) ; le Status dit si l'on peut se fier aux données.
- 2026-10-27 : point 50 : ligne Status construite dans `detecteurs.py` (une ligne, le pire des capteurs) ; vérifiée par capture sur CLARIDEN ; une seule cible à problème y rend toute la station rouge 4 jours.
- 2026-10-27 : point 50 : Status refait (l'utilisateur) : plus de niveaux OK / Prudence / À ignorer, mais ce qui se passe ; bleu clair rien, bleu foncé un bloc nommé par la catégorie qui le couvre le plus (Heat haze chaque matin sur WILDSTRUBEL) ; ordre des catégories et zoom au clic laissés ouverts.
- 2026-10-27 : page des détecteurs (`detecteurs.py`, et la page de fin de séance de `/boucle`) : plus de recalage de l'ordonnée au zoom (l'utilisateur) ; l'échelle en y reste celle de toute la plage.
- 2026-10-27 : page des détecteurs : sur LENZSPITZE, x et y sont des écarts de moins d'un pixel, pas des positions dans l'image ; le timelapse, recadré dessus, était minuscule ; il montre alors l'image entière.
- 2026-10-27 : page des détecteurs, validé par l'utilisateur : le Status juste sous les courbes, les catégories dessous dans un dérouleur (clic sur « ▾ Status »), déplié au départ ; sans titre « Événements des détecteurs, par catégorie ».
- 2026-10-27 : page des détecteurs, validé par l'utilisateur : un clic sur un bloc du Status zoome la plage sur lui.
- 2026-10-27 : page des détecteurs, validé par l'utilisateur : un clic sur un bloc du Status remplit la section « Details » sous la figure (ses événements, capteurs et phrases) avec un bouton ▶ Images, le timelapse du bloc avec une marge avant et après.
- 2026-10-27 : page des détecteurs, validé par l'utilisateur : Details en deux colonnes, les événements du bloc à gauche, son timelapse à droite, lancé au clic sur le bloc (plus de bouton ▶ Images).
- 2026-10-27 : page des détecteurs, validé par l'utilisateur : dans le timelapse, les capteurs de l'événement entourés à leur position médiane (jaune les cibles, bleu les références) ; positions vérifiées sur WILDSTRUBEL et FLORIDA ; aucune marque sur LENZSPITZE, dont x et y ne sont pas des positions.
- 2026-10-27 : LENZSPITZE laissé de côté (l'utilisateur) : ses données sont différentes, x et y y sont des écarts de moins d'un pixel, pas des positions ; pas de cercles possibles ; le pompage n'est pas modifié.
- 2026-10-27 : page des détecteurs, validé par l'utilisateur (2026-10-28) : bouton ⤓ GIF dans le timelapse, le GIF tel qu'il est montré (Focused ou Global, 1000 px de large au plus, bord rouge pendant, heure en bas) dans les téléchargements du navigateur ; en file:// le navigateur ne lit pas les pixels des images : la page (comme celles de fin de séance et de /review-event) s'ouvre par un serveur local, http://127.0.0.1:8765, lancé en tâche de fond au besoin, qui ne sert que out/ et data/ (`open_served`, `src/common/page.py`). Sur LENZSPITZE, ni Focused ni étiquettes : x et y n'y sont pas des positions.
- 2026-10-28 : page des détecteurs, validé par l'utilisateur : le GIF exporté sans bord rouge, date et heure en bas à droite ; timelapse et GIF jusqu'à 150 images (G_MAX, 60 avant) ; l'explorateur d'images montre déjà toutes les images du dossier sur la plage : pour en avoir plus, pomper avec --every 0 (défaut : une par heure).
- 2026-10-28 : page des détecteurs, validé par l'utilisateur : un clic sur la barre d'un événement (détecteurs ou analyste) fait comme un clic sur un bloc du Status : zoom sur sa plage, ses détails et son timelapse sous la figure ; pour un événement des détecteurs, ses seuls capteurs sur les courbes (plus de second clic).
- 2026-10-28 : point 51, idée de l'utilisateur : un analyste de `/boucle` qui progresse de séance en séance ; proposition de Claude (la carte des événements comme mémoire, nourrie par `/review-event` seule ; une mesure sur des events témoins) et deux questions.
- 2026-10-29 : point 51, idée de l'utilisateur : une compilation de ce que les events enseignent, dans `events/` ; après la restructuration D-085, avis de Claude : pas de fichier de plus, la carte (arrêtée à E-005) apprend à chaque validation ; écart E-011 relevé dans la section 4 de la carte.
- 2026-10-29 : point 51, l'utilisateur choisit la carte comme mémoire de l'analyste, pas de fichier à part.
- 2026-10-29 : point 51, D-087 : la carte apprend à chaque validation, montrée avec la fiche ; étape ajoutée à `/review-event` et `/new-event` ; rattrapage écrit (E-004, E-006, E-007, E-008, E-010, E-011, « Faux amis »), E-009 rejeté retiré de la carte ; à relire par l'utilisateur.
- 2026-10-29 : point 51, l'utilisateur : la base d'events est la base de connaissance de l'analyste, consultée quand il veut (D-088) ; rattrapage de la carte validé.
- 2026-10-29 : point 51, l'utilisateur : on ne mesure pas les progrès de l'analyste.
- 2026-10-29 : point 52 ajouté (idée de l'utilisateur : améliorer l'upgrader et le validateur) ; constat de Claude (validateur toujours d'accord, justes 78 % → 50 % sur E-001 à E-005), proposition et une question.
- 2026-10-29 : point 52, précisions de l'utilisateur : `detectors-upgrader`, qui ajoute, retire ou modifie ; il vise les événements significatifs manqués ou mal bornés, pas l'alignement parfait ; le validateur, contrepoids contre le sur-apprentissage.
- 2026-10-29 : point 52, l'utilisateur : `control-detectors` (le validateur), garde-fou sur la base seule, sans les données du lot, qui décide et renvoie ses remarques à l'upgrader.
- 2026-10-29 : point 52, D-089 : `detectors-upgrader` (ajoute, retire, modifie ; vise les événements manqués ou mal bornés) et `detectors-control` (garde-fou sur la base seule, sans le lot) ; à essayer sur une séance.
- 2026-10-29 : point 53 ajouté (idée de l'utilisateur : un agent, une responsabilité ; deux options) ; avis de Claude : l'analyste lit seulement, un `detectors-critic` critique.
- 2026-10-29 : point 53, l'utilisateur : un nouvel agent `detectors-critic`, l'analyste garde son nom et peut se servir des détecteurs ; proposition de Claude pour le partage des tâches.
- 2026-10-29 : point 53, le critic sans les données : faisable pour un événement manqué ou mal borné, pas pour le pourquoi d'une fausse alarme ; proposition : le critic dit quoi et où, l'upgrader cherche pourquoi.
- 2026-10-29 : point 53, D-090 : l'analyste analyse (skill `analyser-lot`), le `detectors-critic` critique sans les données ; le `detectors-upgrader` reste tel quel ; à essayer sur une séance.
- 2026-10-29 : point 54 ajouté (idée de l'utilisateur : le builder devient `event-builder`).
- 2026-10-29 : point 54, proposition de l'utilisateur : le builder appelé à chaque lot, qui décide seul ce qui est nouveau face à la base ; précisions de Claude.
- 2026-10-29 : point 54, D-091 : `event-builder`, appelé à chaque lot, décide seul ce qui est nouveau face à la base, events bornés à l'événement ; à essayer sur une séance.
- 2026-10-29 : point 55 ajouté (idée de l'utilisateur : `/boucle` devient `events-learner` ; releveur et améliorateur à part, dans une autre conversation).
- 2026-10-29 : point 55, revue de l'orchestrateur : benchmark de fin sur les mêmes events, spec réduite, renommage ; lot unique laissé.
- 2026-10-29 : point 55, D-092 : `/boucle` devient `/events-learner` (skill, scripts, séances, spec, page, commits), plus de benchmark de fin, spec réduite au pourquoi.
- 2026-10-29 : point 56 ajouté (idée de l'utilisateur : optimiser `/aiguiser` comme `/events-learner`) ; constat (neuf modifications, toutes gardées ; outils ×3,4) et transposition de Claude : `reading-critic`, `reading-upgrader`, `reading-control`, orchestrateur, spec ; quatre questions.
- 2026-10-29 : point 56, l'utilisateur : étape par étape du déroulé ; étape 1, le lecteur : rôle inchangé, une section « Ce qui m'a encombré », deux consignes du skill corrigées à la main (Bash, pas natif).
- 2026-10-29 : retour vocal de l'utilisateur sur les détecteurs : partie IX, nouvelle, points 57 à 66 : dire la cause plutôt que l'événement, l'analyste d'abord ; les trois effets thermiques (objectif, support, ouvrage) et leurs temps de chauffe ; les températures par `/aiguiser` ; des cas thermiques ; heat haze ; visibilité réduite ou cible masquée ; les métriques de qualité (seul NADELHORN les a) ; la cause des sauts ; le début d'un saut ; client et spécialiste. Rien documenté hors du plan, à sa demande ; questions dans chaque point.
- 2026-10-29 : point 56, l'utilisateur remet en cause `/aiguiser` (un lecteur sans notion de pertinence ; combiner avec `/events-learner`) ; avis de Claude : d'accord sur le fond ; l'analyste dit ce qui lui manque, un `reading-upgrader` dans `/events-learner`, l'audit indépendant en piste.
- 2026-10-29 : point 56, proposition de l'utilisateur : l'analyste voit ses données, crée ses outils et les décrit (section Outils) ; un `tool-builder` les adapte ; précisions de Claude (inventaire étendu, ordre, pas de contrôle, `/aiguiser` retiré).
- 2026-10-29 : point 67 ajouté (idée de l'utilisateur : le savoir métier de l'analyste suffit-il, sans l'alourdir ?) : constat de Claude (un catalogue de symptômes, pas le mécanisme ; les règles des déplacements de `CLAUDE.md` ne lui parviennent pas ; ~85 Ko lus) ; proposition : une note d'une page, la chaîne de mesure, et la carte lue à la demande ; trois questions. Point 59 : à revoir avec le `tool-builder` (D-097).
- 2026-10-29 : point 56, D-097 : `/aiguiser` retiré ; l'analyste voit ses données (`inventaire.py`), écrit ses scripts, dit ses outils ; le `tool-builder` optimise ou ajoute, sans retrait ni contrôle ; à essayer sur une séance.
- 2026-10-29 : point 67 : brouillon de `labeling/connaissances/chaine-de-mesure.md`, sources marquées ([U] utilisateur, [A] AIMsight, [D] données, [H] hypothèse de Claude) ; pas encore dans ce que lit l'analyste ; reste la relecture de l'utilisateur.
- 2026-10-29 : vocal relu face au plan et à la note : l'état des pipelines ajouté au point 57 ; dans `chaine-de-mesure.md`, le saut qui revient (bénin, la question est sa cause) et l'hésitation de l'utilisateur sur JUNGFRAU (support ou objectif).
- 2026-10-30 : point 68 ajouté (idée de l'utilisateur : une page web pour étiqueter soi-même, en expert) : avis de Claude, oui ; essai proposé sur la page Status, étiquettes libres dans `etiquettes-expert/`, limites notées ; à valider.
- 2026-10-30 : point 68, précisions de l'utilisateur : une page à part dans `labeling/`, un plot à la fois comme le menu Advanced, une barre de temps alignée pour sélectionner, du texte sans catégorie, Add écrit aussitôt, zones étiquetées visibles ; description à approuver.
- 2026-10-30 : point 68, description approuvée, outil construit et essayé (D-098), commité à la demande de l'utilisateur ; reste son essai.
- 2026-10-30 : point 69 ajouté (idée de l'utilisateur : un processus pour que l'analyste apprenne des étiquettes) : avis de Claude, l'analyste propose, l'utilisateur valide, pas de document nouveau ; `/labels-learner` proposé, à approuver.
- 2026-10-30 : point 69, l'utilisateur : d'abord quelques étiquettes, l'articulation reste ouverte ; les pièces, le chemin envisagé et cinq questions notés ; rien de construit.
- 2026-10-30 : point 68, demande de l'utilisateur : les métriques système au menu de `labeling.py`, sans les identifiants ; essayées sur cinq stations. Point 59 : `sensor_*_deg_c` vides sur NADELHORN et LENZSPITZE.
- 2026-10-30 : point 68, demande de l'utilisateur : un clic sur une étiquette la lit dans une fenêtre, Save enregistre son nouveau texte ; essayé sur NIEDERHORN par de vrais gestes, sans toucher aux 13 étiquettes réelles (JUNGFRAU, NORDEND, WILDSTRUBEL).
- 2026-11-02 : point 68, édition des étiquettes commitée. Point 69 : les 13 étiquettes lues ; vérifié dans les données (JUNGFRAU, NORDEND) : deux références acceptées donnent `reproj_err` = 0, une seule le laisse vide ; réponses proposées aux cinq questions, plus le contexte de la station ; choix de l'utilisateur attendu.
- 2026-11-02 : point 69, l'utilisateur : pas de lecture à l'aveugle, le texte des étiquettes suffit (pas de fiche de station) ; processus simplifié en un passage par phénomène, à approuver.
- 2026-11-02 : point 69, `/labels-learner` construit sur le processus simplifié (D-099) ; reste le premier essai, sur la perte de référence (5 étiquettes, JUNGFRAU et NORDEND), lancé par l'utilisateur.
- 2026-11-02 : point 69, demande de l'utilisateur : l'analyste pose ses questions jusqu'à avoir compris, puis passe ses conclusions à un agent nouveau, le `documentaliste`, qui maintient la documentation ; skill, consigne de l'analyste, D-099, `run.md` et `CLAUDE.md` revus.
- 2026-11-02 : point 70 ajouté (idée de l'utilisateur : l'analyste propose des étiquettes, l'expert les vérifie ; crainte de noyer l'agent) : avis de Claude, peu de propositions, celles dont l'analyste doute, à part, réécrites par l'expert ; trois questions ; events et étiquettes restent séparés.
- 2026-11-02 : point 70, l'utilisateur : deux buts (faire progresser l'analyste ; optimiser les détecteurs sur une multitude d'étiquettes) ; point revu, deux sortes d'étiquettes, questions pour chacune.
- 2026-11-02 : point 70, décision de l'utilisateur (D-100) : les étiquettes faites à la main d'abord, base de connaissance ; les events gardés, les validés ont leurs étiquettes dans `labeling/E-xxx.jsonl`, écrites par un agent.
- 2026-11-02 : point 70, demande de l'utilisateur : un vérificateur de ses étiquettes ; agent `label-reviewer` construit (D-101), `revue` sur les étiquettes vérifiées, retiré par un Save.
- 2026-11-02 : point 70, demande de l'utilisateur : les étiquettes des events dans les fichiers des stations, que charge son outil ; 30 étiquettes décodées et ajoutées, `labeling/E-xxx.jsonl` abandonnés.
- 2026-11-02 : point 70, l'utilisateur : champ `source` retiré des étiquettes des events, même format que les autres.
- 2026-11-02 : point 70, l'utilisateur : `labeling/manual/` (à la main, vérifiées avec le `label-reviewer`) et `labeling/auto/` (ce que l'analyste trouvera seul) (D-102) ; les 43 étiquettes dans `manual/`.
- 2026-11-02 : point 70, l'utilisateur, après le premier essai du `label-reviewer` sur NIEDERHORN : un skill `/review-labels` plutôt qu'un agent, une étiquette à la fois, validée ensemble (D-103).
- 2026-11-02 : point 70, revue des étiquettes avec l'utilisateur (`/review-labels`) : 43 → 24, toutes revues sauf PS_DES_COUDRES (pas de données) ; textes qualitatifs, sans valeurs ; doublons et détails mineurs tirés des events retirés, phases d'un même fait fusionnées ; ses propres étiquettes gardées, reformulées.
- 2026-11-02 : point 71 ajouté (idée de l'utilisateur : un intégrateur des étiquettes) : avis de Claude, trois usages, la forme structurée comme pièce commune ; à discuter après la revue des étiquettes.
- 2026-11-02 : point 71, demande de l'utilisateur : la carte des étiquettes ; skill `/labels-map` (D-104), carte écrite, relue face aux étiquettes, skill renforcé.
- 2026-11-02 : point 71, l'utilisateur : mesurer l'analyste sur un lot avec la documentation en place ; premier essai des étiquettes automatiques sur JUNGFRAU du 20 au 25.10 (D-105).
- 2026-11-02 : point 71, demande de l'utilisateur : un agent d'étiquetage, l'`etiqueteur`, inspiré de l'analyste (D-106).
- 2026-11-02 : point 71, demande de l'utilisateur : une catégorie dans l'étiquette, donnée par l'étiqueteur, choisie dans l'outil (D-107).
- 2026-11-02 : point 71, précisions de l'utilisateur pour l'étiqueteur : une étiquette, un seul événement ; un événement répété, une étiquette par fois ; exhaustif mais précis (D-106).
- 2026-11-02 : point 71, deuxième essai de l'étiqueteur, JUNGFRAU 30.09 → 05.10, 15 étiquettes, « globalement bon » ; l'utilisateur : un seul « Thermal displacement », aller et retour deux événements ; les anomalies seulement, rien de ce que la caméra compense (D-108).
- 2026-11-02 : point 71, l'utilisateur : l'étiqueteur ne garde que ses étiquettes ; son dossier de travail dans `out/etiqueteur/`, hors de git, les deux essais y sont déplacés (D-106).
- 2026-11-02 : point 71, idée de l'utilisateur : cinq familles d'étiquettes (Visibility, Obstruction, turbulences, Thermal displacements, Displacements) ; avis de Claude, à trancher.
- 2026-11-02 : point 71, l'utilisateur accepte les familles avec les ajustements de Claude (six, Target issue en plus), documentées pour l'étiqueteur dans `labeling/familles.md` (D-109).
- 2026-11-02 : point 71, troisième essai de l'étiqueteur, sur une autre station (demande de l'utilisateur) : WILDSTRUBEL 01.09 → 06.09, 30 étiquettes (18 obstruction, 6 turbulence, 6 visibilite) ; l'outil montre les étiquettes d'une seule mesure (debut = fin) sur un pas.
- 2026-11-02 : point 71, impression de l'utilisateur : turbulence atmosphérique et Visibility, la même chose ? Avis de Claude : les réunir pour les étiquettes ; à trancher.
- 2026-11-02 : point 71, l'utilisateur : réunir ; `turbulence` dans `visibilite`, cinq familles (D-110).
2026-11-03 15:22:14 +01:00
- 2026-11-02 : point 71, précisions de l'utilisateur pour l'étiqueteur : seulement ce qui apparaît sur `corr_x` et `corr_y` ; un trou est une anomalie à expliquer ; famille `trou` (D-111).
- 2026-11-02 : point 71, l'utilisateur : la largeur minimale des barres retirée de l'outil (il cherchera une autre solution) ; l'étiqueteur borne une étiquette du point juste d'avant au point juste d'après (D-111).
- 2026-11-02 : point 71, quatrième essai de l'étiqueteur, NORDEND 10.08 → 15.08 (`labeling/auto/NORDEND.jsonl`), 19 étiquettes (6 deplacement_thermique, 11 visibilite, 1 obstruction, 1 trou) ; une étiquette thermique par jour, l'aller et le retour ensemble : l'utilisateur, « une par jour va ».
- 2026-11-02 : point 72, nouveau (demande de l'utilisateur) : `/events-learner` lit les étiquettes de l'étiqueteur au lieu de faire analyser le lot ; score et page par famille ; analyste, `tool-builder` et `event-builder` hors de la séance (D-112). Reste la première séance.
- 2026-11-04 : point 73, nouveau (demande de l'utilisateur) : l'analyste relit les étiquettes de l'étiqueteur ; premier essai sur BREITHORN d'octobre, appliqué après la réponse de l'expert (écarts des nuits froides : thermiques). Restent le skill et les leçons pour l'étiqueteur.
- 2026-11-04 : point 73, skill `/review-auto-labels` écrit (D-128), la plage choisie par l'utilisateur ; les 5 étiquettes thermiques de BREITHORN portent la réponse de l'expert (`revue`). Restent les leçons pour l'étiqueteur.
- 2026-11-04 : point 73, `revue` aligné sur les étiquettes manuelles (l'utilisateur) : la date seule, sur les 26 étiquettes de BREITHORN d'octobre ; la réponse de l'expert dans la description.
- 2026-11-04 : point 73, MICHIGAN et NEBRASKA revues par le skill, toutes les suggestions appliquées ; les leçons des trois revues dans la consigne de l'étiqueteur et `familles.md`. Reste : `/labels-map` pour les leçons de la carte.
- 2026-11-04 : point 73, cohérence de BREITHORN, MICHIGAN et NEBRASKA (même bâtiment) : appliquée sur le conseil de Claude, l'expert ne sachant pas trancher la dérive (`Displacement`, à surveiller).
- 2026-11-04 : point 74, nouveau (l'utilisateur) : la revue croisée des étiquettes automatiques ; d'abord, point 73, la revue des huit autres stations, un analyste chacune, appliquée sans validation de l'expert ; le relecteur améliore les étiquettes, il ne refait pas l'étiquetage (D-128).
- 2026-11-04 : points 73 et 74 : les huit revues par station appliquées sans validation de l'expert (692 étiquettes) ; revue croisée lancée, un analyste par famille. Point 75, nouveau (l'utilisateur) : toute la connaissance du labeling dans `labeling/`, cas et events compris.
- 2026-11-04 : point 76, nouveau (l'utilisateur) : les métriques de qualité d'image dans l'étiquetage ; `qualite.py`, LENZSPITZE d'octobre relue avec elles, 67 étiquettes appliquées (D-129).
- 2026-11-04 : point 76, les quatre leçons de la revue de LENZSPITZE dans la consigne de l'étiqueteur (l'utilisateur).
- 2026-11-05 : points 73 à 75 faits (D-130) : 991 étiquettes automatiques revues (par station, croisée par famille, finition, réécriture en mots) ; les trois plages oubliées étiquetées et revues ; la connaissance du labeling dans `labeling/` (`regles-d-etiquetage.md`, `familles.md`, `connaissances/`, la carte refaite sur les étiquettes, les events et les cas) ; `labeling/controle.py`. Restent les contradictions entre l'expert et les étiquettes automatiques, section 6 de la carte.
- 2026-11-05 : point 75 : la carte refaite (40 fiches, 23 règles, 16 faux amis), events rattachés à leurs stations ; PS_DES_COUDRES est JUNGFRAU ; contrôle des étiquettes à 0 erreur.