diff --git a/docs/superpowers/plans/2026-10-14-agent-diagnostic.md b/docs/superpowers/plans/2026-10-14-agent-diagnostic.md new file mode 100644 index 0000000..bd8ccbe --- /dev/null +++ b/docs/superpowers/plans/2026-10-14-agent-diagnostic.md @@ -0,0 +1,890 @@ +# Agent de diagnostic : plan d'implémentation + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal :** un sous-agent Claude Code `diagnostic`, appelable à tout moment, qui diagnostique un dossier de `data/` (déplacements optiques et images) et écrit un rapport traçable. + +**Architecture :** un point d'entrée `.claude/agents/diagnostic.md` (outils, modèle, `omitClaudeMd`) qui renvoie à `agents/diagnostic/instructions.md` (méthode, règles, format du rapport). Trois scripts en ligne de commande dans `agents/diagnostic/outils/` rendent des valeurs (inventaire, résumé chiffré, graphique PNG) ; l'agent juge et écrit son rapport dans `agents/diagnostic/rapports/`. + +**Tech Stack :** Python 3.14, bibliothèque standard ; matplotlib dans `.venv` pour le seul graphique ; Claude Code (sous-agent, Opus 5.5). + +**Spec :** `docs/agents/agent-diagnostic.md` + +## Global Constraints + +- Python 3.14 ; `donnees.py`, `inventaire.py`, `resume.py` en bibliothèque standard seulement ; `graphique.py` importe matplotlib et se lance avec `.venv/bin/python`. +- Toute heure est en UTC ; une heure saisie sans fuseau est lue en UTC. +- Les outils rendent des valeurs, jamais des verdicts : aucun seuil de décision dans les outils. +- Lecture seule : les outils n'écrivent que dans `out/diagnostic/` ; l'agent n'écrit que dans `agents/diagnostic/rapports/`. +- Pas de tests automatisés (D-008) : chaque tâche se vérifie par des commandes et leurs sorties attendues, sur `data/PS_DES_COUDRES/`. +- Documents en français, termes AIMsight en anglais. +- `CLAUDE.md` reste sous 200 lignes (D-012). +- Commits : message en anglais, terminé par `Co-Authored-By: Claude Opus 5.5 `. + +## Review Focus + +1. **Dossier sans export « advanced »** (ex. `data/WEISSHORN/`, métriques système seulement) : `inventaire.py` le dit ; `resume.py` et `graphique.py` s'arrêtent avec un message clair, sans trace d'erreur Python. Vérifié aux tâches 1, 2 et 3. +2. **Fenêtre sans mesure** (`--debut` après la fin des données) : message clair, pas de tableau vide ni de graphique vide. Tâches 2 et 3. +3. **Capteur ou colonne inconnu** : message qui liste les noms connus. Tâches 2 et 3. +4. **Heure sans fuseau** (`--debut "2026-10-14 02:00"`) : même résultat qu'avec `2026-10-14T02:00Z`. Tâche 2. +5. **Capteur rejeté sur toute la période** (PM_G, `corr_x` vide) : « rej » dans le tableau et « aucune valeur » au niveau habituel, pas de plantage. Tâche 2. + +--- + +## Structure des fichiers + +| Fichier | Rôle | +|---|---| +| `agents/diagnostic/outils/donnees.py` | Lecture : trouver les fichiers d'un dossier par type, charger l'export « advanced », heures d'image, conversion des instants (UTC) | +| `agents/diagnostic/outils/inventaire.py` | Ce qui est disponible et ce qui manque | +| `agents/diagnostic/outils/resume.py` | Niveau habituel par capteur et tableau par pas de temps | +| `agents/diagnostic/outils/graphique.py` | PNG des séries dans `out/diagnostic/` | +| `agents/diagnostic/instructions.md` | Méthode, règles, format du rapport (le « cerveau » de l'agent) | +| `agents/diagnostic/README.md` | Doc humaine courte | +| `agents/diagnostic/rapports/` | Un rapport par diagnostic (créé par l'agent) | +| `.claude/agents/diagnostic.md` | Point d'entrée Claude Code | +| `.devcontainer/devcontainer.json` | Ajout de matplotlib | +| `docs/decisions.md`, `CLAUDE.md`, `docs/agents/agent-diagnostic.md` | D-046, carte et état, statut et résultats de la spec | + +Les scripts s'importent entre eux par `from donnees import …` : Python ajoute le dossier du script lancé à `sys.path`, il n'y a donc rien à configurer. + +--- + +### Task 1 : lecture des données et inventaire + +**Files :** +- Create : `agents/diagnostic/outils/donnees.py` +- Create : `agents/diagnostic/outils/inventaire.py` + +**Interfaces :** +- Produces (`donnees.py`) : + - `trouver(dossier: str) -> dict[str, list[str]]`, clés `advanced`, `horaire`, `images`, `autres` ; + - `charger(dossier: str) -> dict[str, list[dict]]` : capteur → mesures triées par `t` ; mesure : `t` (datetime UTC), `pattern_type` (str), et les colonnes de `NUM` (float ou None) ; + - `NUM: tuple[str, ...]` ; + - `est_reference(mesures: list[dict]) -> bool` ; `rejetee(m: dict) -> bool` ; + - `filtrer(mesures, debut: datetime | None, fin: datetime | None) -> list[dict]` (bornes incluses) ; + - `heure_image(chemin: str) -> datetime | None` ; `instant(texte: str) -> datetime` ; `iso(t: datetime) -> str` (`AAAA-MM-JJTHH:MMZ`). + +- [ ] **Step 1 : écrire `donnees.py`** + +```python +"""Lecture des données d'une station pour l'agent de diagnostic (bibliothèque standard). + +Formats : docs/domaine/colonnes-des-deplacements.md. Toute heure est en UTC. +""" +import csv +import glob +import os +import re +from datetime import datetime, timezone + +# Colonnes numériques de l'export « advanced » ; une case vide devient None. +NUM = ("x", "y", "error_value", "error_threshold", "relative_x", "relative_y", + "corr_x", "corr_y", "reproj_err", "sigma0") +IMAGE_RE = re.compile(r"^(\d{8}T\d{4})Z_") + + +def _entete(chemin): + with open(chemin, newline="") as f: + return next(csv.reader(f), []) + + +def trouver(dossier): + """Dossier de station -> {'advanced', 'horaire', 'images', 'autres'} : chemins triés, sous-dossiers compris.""" + out = {"advanced": [], "horaire": [], "images": [], "autres": []} + for p in sorted(glob.glob(os.path.join(dossier, "**", "*"), recursive=True)): + if os.path.isdir(p): + continue + entete = _entete(p) if p.endswith(".csv") else [] + if p.lower().endswith((".jpg", ".jpeg", ".png")): + out["images"].append(p) + elif "sensor_name" in entete: + out["advanced"].append(p) + elif "timestamp" in entete: + out["horaire"].append(p) + else: + out["autres"].append(p) + return out + + +def _nombre(v): + v = v.strip() + return float(v) if v else None + + +def charger(dossier): + """Exports « advanced » du dossier -> {capteur: [mesure]}, triées par t, un seul relevé par instant. + + Mesure : dict avec t (datetime UTC), pattern_type, et les colonnes de NUM (float ou None). + """ + par = {} + for chemin in trouver(dossier)["advanced"]: + with open(chemin, newline="") as f: + for r in csv.DictReader(f): + m = {c: _nombre(r[c]) for c in NUM} + m["t"] = datetime.fromisoformat(r["time_utc"]).astimezone(timezone.utc) + m["pattern_type"] = r["pattern_type"] + par.setdefault(r["sensor_name"], {})[m["t"]] = m + return {s: [d[t] for t in sorted(d)] for s, d in par.items()} + + +def est_reference(mesures): + """Référence du réseau de compensation (pattern_type global_ref), sinon cible.""" + return mesures[0]["pattern_type"] == "global_ref" + + +def rejetee(m): + """Mesure rejetée par la station (error_value au-dessus du seuil du capteur) : corr_x et corr_y vides.""" + return m["corr_x"] is None + + +def filtrer(mesures, debut, fin): + """Mesures entre debut et fin inclus ; None = pas de borne.""" + return [m for m in mesures if (debut is None or m["t"] >= debut) and (fin is None or m["t"] <= fin)] + + +def heure_image(chemin): + """'20261013T1200Z_10167931.jpg' -> datetime UTC ; None si le nom ne suit pas ce format (D-045).""" + m = IMAGE_RE.match(os.path.basename(chemin)) + return datetime.strptime(m.group(1), "%Y%m%dT%H%M").replace(tzinfo=timezone.utc) if m else None + + +def instant(texte): + """'2026-10-13T23:00Z' ou '2026-10-13 23:00' -> datetime UTC ; une heure sans fuseau est lue en UTC.""" + t = datetime.fromisoformat(texte) + return t.astimezone(timezone.utc) if t.tzinfo else t.replace(tzinfo=timezone.utc) + + +def iso(t): + return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%MZ") +``` + +- [ ] **Step 2 : écrire `inventaire.py`** + +```python +"""Inventaire d'un dossier de station : ce qui est disponible, ce qui manque. + +Usage : python3 agents/diagnostic/outils/inventaire.py data/PS_DES_COUDRES/ +Rend des valeurs, pas de verdict. +""" +import statistics +import sys +from datetime import timedelta + +from donnees import charger, est_reference, heure_image, iso, rejetee, trouver + + +def fichiers(f): + print(f"Exports « advanced » (source des mesures) : {len(f['advanced'])}") + for p in f["advanced"]: + print(f" {p}") + print(f"Exports horaires : {len(f['horaire'])} (non lus par les outils : moyennes horaires, " + "heure locale sans fuseau ; voir docs/domaine/colonnes-des-deplacements.md)") + for p in f["horaire"]: + print(f" {p}") + print(f"Autres fichiers : {len(f['autres'])}") + for p in f["autres"]: + print(f" {p}") + + +def images(chemins): + heures = sorted(h for h in map(heure_image, chemins) if h) + print(f"Images : {len(chemins)}" + (f", du {iso(heures[0])} au {iso(heures[-1])}" if heures else "")) + inconnues = [p for p in chemins if heure_image(p) is None] + if inconnues: + print(f" noms sans heure reconnue : {len(inconnues)}") + if heures: + manquantes = [] + for a, b in zip(heures, heures[1:]): + h = a + timedelta(hours=1) + while h < b: + manquantes.append(iso(h)) + h += timedelta(hours=1) + print(f" heures pleines sans image entre la première et la dernière : {', '.join(manquantes) or 'aucune'}") + + +def mesures(par): + if not par: + print("\nAucune mesure : pas d'export « advanced » dans ce dossier.") + return + instants = sorted({m["t"] for ms in par.values() for m in ms}) + cadence = statistics.median(b - a for a, b in zip(instants, instants[1:])) + print(f"\nPériode des mesures : {iso(instants[0])} → {iso(instants[-1])}, {len(instants)} instants") + print(f"Cadence (pas médian) : {cadence.total_seconds() / 60:.0f} min") + trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(instants, instants[1:])] + trous = [x for x in trous if x[2] > 0] + print(f"Mesures manquantes (instants absents de la cadence) : {sum(n for *_, n in trous)}") + for a, b, n in trous: + print(f" entre {iso(a)} et {iso(b)} : {n}") + noms = sorted(par, key=lambda s: (not est_reference(par[s]), s)) + refs = [s for s in noms if est_reference(par[s])] + print(f"\nCapteurs : {len(par)} ({len(refs)} références, {len(par) - len(refs)} cibles)") + print(f"{'capteur':10} {'type':10} {'motif':11} {'seuil':>5} {'mesures':>7} {'rejetées':>8}") + for s in noms: + ms = par[s] + seuil = "/".join(f"{x:g}" for x in sorted({m['error_threshold'] for m in ms})) + print(f"{s:10} {'référence' if est_reference(ms) else 'cible':10} {ms[0]['pattern_type']:11} " + f"{seuil:>5} {len(ms):7} {sum(map(rejetee, ms)):8}") + + +def main(dossier): + print(f"Dossier : {dossier}") + f = trouver(dossier) + fichiers(f) + images(f["images"]) + mesures(charger(dossier)) + + +if __name__ == "__main__": + if len(sys.argv) != 2: + sys.exit(__doc__) + main(sys.argv[1]) +``` + +- [ ] **Step 3 : vérifier sur PS des Coudres** + +Run : `python3 agents/diagnostic/outils/inventaire.py data/PS_DES_COUDRES/` + +Expected (chiffres établis à la main le 2026-10-14, spec §7) : +``` +Exports « advanced » (source des mesures) : 1 +Exports horaires : 1 (...) +Autres fichiers : 0 +Images : 24, du 2026-10-13T12:00Z au 2026-10-14T11:00Z + heures pleines sans image entre la première et la dernière : aucune + +Période des mesures : 2026-10-08T22:00Z → 2026-10-14T09:45Z, 525 instants +Cadence (pas médian) : 15 min +Mesures manquantes (instants absents de la cadence) : 3 + entre 2026-10-09T11:45Z et 2026-10-09T12:15Z : 1 + entre 2026-10-10T10:30Z et 2026-10-10T11:00Z : 1 + entre 2026-10-14T09:15Z et 2026-10-14T09:45Z : 1 + +Capteurs : 15 (3 références, 12 cibles) +``` +puis `REF_CT` seuil 0.45, `REF_D` et `REF_G` 0.7, rejetées 0 ; `PM_G` seuil 0.3, mesures 525, rejetées 525 ; toutes les autres cibles seuil 0.7, rejetées 0. + +- [ ] **Step 4 : vérifier un dossier sans export « advanced » (Review Focus 1)** + +Run : `python3 agents/diagnostic/outils/inventaire.py data/WEISSHORN/` + +Expected : `Exports « advanced » (source des mesures) : 0`, `Autres fichiers : 27` suivis des 27 CSV, `Images : 0`, puis `Aucune mesure : pas d'export « advanced » dans ce dossier.` Pas de trace d'erreur. + +Run : `python3 agents/diagnostic/outils/inventaire.py` (sans argument). Expected : le docstring d'usage, code de sortie 1. + +- [ ] **Step 5 : commit** + +```bash +git add agents/diagnostic/outils/donnees.py agents/diagnostic/outils/inventaire.py +git commit -m "Add the diagnostic agent's data reader and inventory tool (D-046)" -m "Co-Authored-By: Claude Opus 5.5 " +``` + +--- + +### Task 2 : résumé chiffré + +**Files :** +- Create : `agents/diagnostic/outils/resume.py` + +**Interfaces :** +- Consumes : `charger`, `est_reference`, `filtrer`, `instant`, `iso`, `rejetee` (Task 1). +- Produces : CLI `resume.py [--colonne C] [--stat median|min|max] [--pas 1h] [--capteurs A,B] [--debut T] [--fin T]` ; `COLONNES` (aussi recopié dans `graphique.py`). + +- [ ] **Step 1 : écrire `resume.py`** + +```python +"""Résumé chiffré compact des séries d'un export « advanced », pour l'agent de diagnostic. + +Usage : python3 agents/diagnostic/outils/resume.py data/PS_DES_COUDRES/ [--colonne error_value] + [--stat median|min|max] [--pas 1h] [--capteurs REF_G,REF_D] [--debut 2026-10-13T00:00Z] [--fin ...] + +1. Niveau habituel de chaque capteur sur toute la période : médiane, MAD (écart absolu médian), min, max. +2. Tableau : une ligne par pas de temps (début du pas, UTC), une colonne par capteur, la statistique + choisie sur les mesures du pas. « rej » : toutes les mesures du pas sont rejetées ; « - » : aucune mesure. +Rend des valeurs, pas de verdict. +""" +import argparse +import re +import statistics +import sys +from datetime import timedelta + +from donnees import charger, est_reference, filtrer, instant, iso, rejetee + +COLONNES = ("error_value", "corr_x", "corr_y", "relative_x", "relative_y", "x", "y", "sigma0", "reproj_err") +STATS = {"median": statistics.median, "min": min, "max": max} + + +def duree(texte): + """'15min', '1h', '6h', '1d' -> timedelta.""" + m = re.fullmatch(r"(\d+)(min|h|d)", texte) + if not m: + raise argparse.ArgumentTypeError(f"pas invalide : {texte!r} (ex. 15min, 1h, 1d)") + n, unite = int(m.group(1)), m.group(2) + return {"min": timedelta(minutes=n), "h": timedelta(hours=n), "d": timedelta(days=n)}[unite] + + +def valeurs(ms, col): + return [m[col] for m in ms if m[col] is not None] + + +def main(): + a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + a.add_argument("dossier") + a.add_argument("--colonne", default="error_value", choices=COLONNES) + a.add_argument("--stat", default="median", choices=STATS) + a.add_argument("--pas", default="1h", type=duree) + a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)") + a.add_argument("--debut", type=instant) + a.add_argument("--fin", type=instant) + o = a.parse_args() + + par = charger(o.dossier) + if not par: + sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).") + noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s)) + inconnus = [s for s in noms if s not in par] + if inconnus: + sys.exit(f"Capteurs absents : {', '.join(inconnus)}. Présents : {', '.join(sorted(par))}.") + + t0 = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0) + cases = {} + for s in noms: + for m in filtrer(par[s], o.debut, o.fin): + debut_du_pas = t0 + ((m["t"] - t0) // o.pas) * o.pas + cases.setdefault(debut_du_pas, {}).setdefault(s, []).append(m) + if not cases: + sys.exit("Aucune mesure dans la fenêtre demandée.") + + print(f"Colonne : {o.colonne}. Niveau habituel sur toute la période (mesures non vides) :") + print(f"{'capteur':10} {'n':>5} {'médiane':>9} {'MAD':>8} {'min':>9} {'max':>9}") + for s in noms: + v = valeurs(par[s], o.colonne) + if not v: + print(f"{s:10} {0:5} (aucune valeur)") + continue + med = statistics.median(v) + mad = statistics.median(abs(x - med) for x in v) + print(f"{s:10} {len(v):5} {med:9.4f} {mad:8.4f} {min(v):9.4f} {max(v):9.4f}") + + print(f"\n{o.stat} de {o.colonne} par pas de {o.pas} (début du pas, UTC) :") + print(f"{'début':17} " + " ".join(f"{s:>8}" for s in noms)) + for k in sorted(cases): + cellules = [] + for s in noms: + ms = cases[k].get(s, []) + v = valeurs(ms, o.colonne) + if v: + cellules.append(f"{STATS[o.stat](v):8.3f}") + else: + cellules.append(f"{'rej' if ms and all(map(rejetee, ms)) else '-':>8}") + print(f"{iso(k):17} " + " ".join(cellules)) + + +if __name__ == "__main__": + main() +``` + +- [ ] **Step 2 : vérifier le pic de la seconde nuit** + +Run : `python3 agents/diagnostic/outils/resume.py data/PS_DES_COUDRES/ --stat max --capteurs REF_CT,REF_G,REF_D --debut 2026-10-13T22:00Z --fin 2026-10-14T06:00Z` + +Expected : +- niveau habituel : `REF_G` médiane ≈ 0.084, max ≈ 0.674 ; `REF_D` médiane ≈ 0.132, max ≈ 0.692 ; `REF_CT` médiane ≈ 0.151, max ≈ 0.226 ; +- tableau de `2026-10-13T22:00Z` à `2026-10-14T05:00Z` (8 lignes) ; à la ligne `2026-10-14T02:00Z`, `REF_G` ≈ 0.670 et `REF_D` ≈ 0.690 ; `REF_CT` reste sous 0.23 sur toutes les lignes. + +- [ ] **Step 3 : vérifier les cas limites (Review Focus 2 à 5)** + +Run : `python3 agents/diagnostic/outils/resume.py data/PS_DES_COUDRES/ --colonne corr_x --capteurs PM_G,BJ_C --pas 1d` +Expected : `PM_G` « 0 (aucune valeur) » au niveau habituel, « rej » sur chaque ligne ; `BJ_C` des valeurs (médiane ≈ 0.258). + +Run : `python3 agents/diagnostic/outils/resume.py data/PS_DES_COUDRES/ --capteurs REF_G --debut "2026-10-14 02:00" --fin "2026-10-14 02:59"` puis la même commande avec `--debut 2026-10-14T02:00Z --fin 2026-10-14T02:59Z`. +Expected : sorties identiques (une ligne `2026-10-14T02:00Z`). + +Run : `python3 agents/diagnostic/outils/resume.py data/PS_DES_COUDRES/ --debut 2027-01-01T00:00Z` +Expected : `Aucune mesure dans la fenêtre demandée.`, code 1. + +Run : `python3 agents/diagnostic/outils/resume.py data/PS_DES_COUDRES/ --capteurs REF_X` +Expected : `Capteurs absents : REF_X. Présents : BJ_C, BJ_D, …`, code 1. + +Run : `python3 agents/diagnostic/outils/resume.py data/WEISSHORN/` +Expected : `Aucun export « advanced » dans data/WEISSHORN/ (voir inventaire.py).`, code 1. + +Run : `python3 agents/diagnostic/outils/resume.py data/PS_DES_COUDRES/ --pas 2x` +Expected : erreur argparse `pas invalide : '2x' (ex. 15min, 1h, 1d)`. + +- [ ] **Step 4 : commit** + +```bash +git add agents/diagnostic/outils/resume.py +git commit -m "Add the diagnostic agent's numeric summary tool (D-046)" -m "Co-Authored-By: Claude Opus 5.5 " +``` + +--- + +### Task 3 : matplotlib et graphique + +**Files :** +- Create : `agents/diagnostic/outils/graphique.py` +- Modify : `.devcontainer/devcontainer.json` (`postCreateCommand`) + +**Interfaces :** +- Consumes : `charger`, `est_reference`, `filtrer`, `instant` (Task 1). +- Produces : CLI `.venv/bin/python agents/diagnostic/outils/graphique.py [--capteurs A,B] [--colonnes C1,C2] [--debut T] [--fin T]`, qui imprime le chemin du PNG écrit dans `out/diagnostic/`. + +- [ ] **Step 1 : installer matplotlib dans `.venv` et le dev container** + +Run : `.venv/bin/pip install matplotlib && .venv/bin/python -c "import matplotlib; print(matplotlib.__version__)"` +Expected : un numéro de version. + +Dans `.devcontainer/devcontainer.json`, remplacer : +```json + "postCreateCommand": "pip install --user plotly" +``` +par : +```json + "postCreateCommand": "pip install --user plotly matplotlib" +``` + +- [ ] **Step 2 : écrire `graphique.py`** + +```python +"""Graphique PNG des séries d'un export « advanced », pour que l'agent de diagnostic les regarde. + +Usage : .venv/bin/python agents/diagnostic/outils/graphique.py data/PS_DES_COUDRES/ + [--capteurs REF_G,REF_D] [--colonnes error_value,corr_x,corr_y] [--debut ...] [--fin ...] +Un panneau par colonne, une courbe par capteur, heures UTC. Imprime le chemin du PNG (out/diagnostic/). +""" +import argparse +import os +import sys + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.dates as mdates # noqa: E402 +import matplotlib.pyplot as plt # noqa: E402 + +from donnees import charger, est_reference, filtrer, instant # noqa: E402 + +RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..")) +COLONNES = ("error_value", "corr_x", "corr_y", "relative_x", "relative_y", "x", "y", "sigma0", "reproj_err") + + +def borne(t, defaut): + return t.strftime("%Y%m%dT%H%MZ") if t else defaut + + +def main(): + a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + a.add_argument("dossier") + a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)") + a.add_argument("--colonnes", default="error_value,corr_x,corr_y") + a.add_argument("--debut", type=instant) + a.add_argument("--fin", type=instant) + o = a.parse_args() + + par = charger(o.dossier) + if not par: + sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).") + noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s)) + colonnes = o.colonnes.split(",") + for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")): + absents = [x for x in demandes if x not in connus] + if absents: + sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.") + series = {s: filtrer(par[s], o.debut, o.fin) for s in noms} + if not any(series.values()): + sys.exit("Aucune mesure dans la fenêtre demandée.") + + fig, axes = plt.subplots(len(colonnes), 1, sharex=True, figsize=(14, 3.2 * len(colonnes)), squeeze=False) + couleurs = plt.get_cmap("tab20").colors + for ax, col in zip(axes[:, 0], colonnes): + for i, s in enumerate(noms): + ms = [m for m in series[s] if m[col] is not None] + ax.plot([m["t"] for m in ms], [m[col] for m in ms], ".-", ms=2, lw=0.7, + color=couleurs[i % len(couleurs)], label=s) + ax.set_ylabel(col) + ax.grid(alpha=0.3) + axes[0, 0].legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8) + axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ")) + station = os.path.basename(os.path.normpath(o.dossier)) + fig.suptitle(f"{station} : {', '.join(colonnes)} (heures UTC)") + + dossier_sortie = os.path.join(RACINE, "out", "diagnostic") + os.makedirs(dossier_sortie, exist_ok=True) + qui = "-".join(noms) if o.capteurs else "tous" + sortie = os.path.join(dossier_sortie, f"{station}_{'-'.join(colonnes)}_{qui}_" + f"{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png") + fig.savefig(sortie, dpi=100, bbox_inches="tight") + print(sortie) + + +if __name__ == "__main__": + main() +``` + +- [ ] **Step 3 : vérifier le graphique** + +Run : `.venv/bin/python agents/diagnostic/outils/graphique.py data/PS_DES_COUDRES/ --capteurs REF_CT,REF_G,REF_D --colonnes error_value` +Expected : imprime `/home/maxime/Support-Agent/out/diagnostic/PS_DES_COUDRES_error_value_REF_CT-REF_G-REF_D_debut_fin.png`. Ouvrir le PNG avec Read : trois courbes, deux bosses nocturnes de `REF_G` et `REF_D` (13/10 et 14/10), `REF_CT` plate, axe des temps lisible en UTC. + +Run : `.venv/bin/python agents/diagnostic/outils/graphique.py data/PS_DES_COUDRES/` +Expected : PNG des 15 capteurs sur trois panneaux (`error_value`, `corr_x`, `corr_y`), légende à droite ; PM_G absente des panneaux `corr_*`. + +- [ ] **Step 4 : vérifier les cas limites (Review Focus 1 à 3)** + +Run : `.venv/bin/python agents/diagnostic/outils/graphique.py data/WEISSHORN/` → `Aucun export « advanced » …`, code 1. +Run : `.venv/bin/python agents/diagnostic/outils/graphique.py data/PS_DES_COUDRES/ --colonnes erreur` → `Colonnes inconnus : erreur. Connus : …`, code 1. +Run : `.venv/bin/python agents/diagnostic/outils/graphique.py data/PS_DES_COUDRES/ --debut 2027-01-01T00:00Z` → `Aucune mesure dans la fenêtre demandée.`, code 1. + +- [ ] **Step 5 : commit** + +```bash +git add agents/diagnostic/outils/graphique.py .devcontainer/devcontainer.json +git commit -m "Add the diagnostic agent's plot tool and matplotlib (D-046)" -m "Co-Authored-By: Claude Opus 5.5 " +``` + +--- + +### Task 4 : instructions, point d'entrée et README + +**Files :** +- Create : `agents/diagnostic/instructions.md` +- Create : `.claude/agents/diagnostic.md` +- Create : `agents/diagnostic/README.md` + +**Interfaces :** +- Consumes : les trois CLI des tâches 1 à 3, telles que définies plus haut. +- Produces : le sous-agent `diagnostic`, chargé par Claude Code au démarrage d'une session. + +- [ ] **Step 1 : écrire `agents/diagnostic/instructions.md`** + +````markdown +# Instructions de l'agent de diagnostic + +Tu diagnostiques les données d'une station AIMsight. Une caméra suit des cibles (réflecteurs) fixées sur un ouvrage ; le mouvement de la caméra elle-même est compensé grâce à des cibles de référence, supposées fixes. Tu trouves ce qui sort de l'ordinaire, tu l'expliques avec des preuves, et tu dis ce qui reste non établi. Tu ne modifies rien. + +## 1. La demande + +Tu reçois un dossier de `data/` (ex. `data/PS_DES_COUDRES/`) et, parfois, une question. + +- **Sans question : scan.** Trouve les événements de toute la période et explique chacun. +- **Avec une question : enquête.** Concentre-toi sur la fenêtre et les capteurs concernés ; la période entière sert de référence. +- Si le dossier n'existe pas ou ne contient aucun export « advanced », dis-le dans ta réponse et n'écris pas de rapport. + +## 2. Ce que tu as le droit de lire + +Seulement : + +- les fichiers du dossier fourni, par tes outils (§3), et ses images avec Read ; +- `docs/domaine/colonnes-des-deplacements.md` : formats des exports et sens des colonnes. **Lis-le en premier** ; +- `docs/domaine/pieges-des-donnees.md` ; +- `docs/aimsight/AIMsight_agentic_support_project_context.md`, sections 4 (chaîne de dépendance), 12 (familles d'hypothèses) et 13 (*support query workflow*) ; +- `docs/aimsight/AIMsight_reference_quality_event_explainer_roadmap.md`, section 4.3 (classifications) ; +- `docs/aimsight/AIMsight FAQ.pdf`, pour `error` : `pdftotext -layout "docs/aimsight/AIMsight FAQ.pdf" - | grep -n -i -B2 -A12 'error value'`. + +Pour un long fichier AIMsight, trouve la section avec `grep -n '^#' `, puis lis-la seule (Read avec `offset` et `limit`). + +**Ne lis rien d'autre** : ni `CLAUDE.md`, ni `docs/decisions.md`, ni les autres documents du projet, ni les rapports de `agents/diagnostic/rapports/`. Ils peuvent contenir des conclusions sur ces données ; ton diagnostic doit partir des données. Tu listes dans ton rapport tout ce que tu as lu. + +## 3. Tes outils + +Lance-les depuis la racine du dépôt. Ils rendent des valeurs, jamais des verdicts : c'est toi qui juges. + +| Commande | Ce qu'elle rend | +|---|---| +| `python3 agents/diagnostic/outils/inventaire.py ` | Fichiers par type, images (heures couvertes), période, cadence, mesures manquantes, capteurs (référence ou cible, seuil d'erreur, mesures rejetées) | +| `python3 agents/diagnostic/outils/resume.py [--colonne C] [--stat median\|min\|max] [--pas 1h] [--capteurs A,B] [--debut T] [--fin T]` | Niveau habituel de chaque capteur sur toute la période (médiane, MAD, min, max), puis un tableau par pas de temps. Colonnes : `error_value`, `corr_x`, `corr_y`, `relative_x`, `relative_y`, `x`, `y`, `sigma0`, `reproj_err` | +| `.venv/bin/python agents/diagnostic/outils/graphique.py [--capteurs A,B] [--colonnes C1,C2] [--debut T] [--fin T]` | Un PNG des séries ; il imprime son chemin. **Regarde-le avec Read** : tu lis mieux un graphique qu'un tableau | +| `ls /images/`, puis Read sur `TZ_*.jpg` | L'image de la caméra à cette heure (UTC). Les colonnes `x` et `y` (pixels) situent chaque capteur sur l'image | + +Instants : `2026-10-13T23:00Z` (une heure sans fuseau est lue en UTC). Bash ne sert qu'à lancer ces outils, `ls`, `grep`, `pdftotext` et `date`. N'écris aucun autre script. + +## 4. Déroulé + +1. **Inventaire** (`inventaire.py`) : ce qui est disponible, ce qui manque, et ce que ce manque empêche de conclure (par exemple, sans métriques système, un arrêt de la station ne peut pas être écarté). +2. **Repérage** : commence large, puis zoome. + - `graphique.py` sur tous les capteurs, puis `resume.py` sur `error_value`, `corr_x`, `corr_y` avec un pas large (6h ou 1d), puis 1h ou 15min sur les fenêtres intéressantes ; + - compare chaque capteur **à son propre niveau habituel** (sa médiane et sa MAD), jamais à un seuil absolu ; + - un seuil de repérage (ex. « au-dessus de médiane + 6 MAD ») est un choix d'exploration : annonce-le, et ne t'en sers jamais comme critère de conclusion. +3. **Faits**, pour chaque événement repéré : + - début, fin, durée ; capteurs touchés : cibles ou références, combien, lesquels, ensemble ou non ; + - amplitude face au niveau habituel ; retour à la normale ; + - déplacement associé (`corr_x`, `corr_y`) ou non ; mesures rejetées ; + - images autour de l'instant, s'il y en a : regarde au moins une image pendant et une hors de l'événement, à la même heure de la journée si possible. +4. **Hypothèses** : prends-les dans les familles de la section 12 du contexte support, plus le mouvement réel de l'ouvrage. Pour chacune, ce qui la soutient et ce qui la contredit. +5. **Réfutation obligatoire** de l'hypothèse principale : cherche le fait qui la contredirait, avec un outil, et dis ce que tu as trouvé. Exemple : on pense à un mouvement de l'ouvrage ; les références ont-elles bougé ? Toutes les cibles ensemble ? +6. **Rapport** (§6), puis ta réponse (§7). + +## 5. Règles + +- Vocabulaire de preuve, et seulement lui : `confirmed` / `strongly supported` / `consistent with` / `possible` / `insufficient evidence` / `not observed`. Pas de pourcentage de confiance. +- Sépare fait observé (lu dans les données), fait dérivé (calculé), contexte donné par l'utilisateur, hypothèse et inconnu. +- Aucun chiffre ni seuil sans source : chaque fait cite la commande qui l'a produit. +- Ne construis rien sur `inlier` (binaire). `sigma0` ne suffit jamais seul. Un mouvement commun à toutes les cibles n'est pas un mouvement de l'ouvrage. Une référence cohérente n'est pas forcément fixe. +- Un trou n'est pas forcément une coupure : acquisition, traitement, transport et affichage sont des couches distinctes. +- Toute heure est en UTC. +- « Rien d'anormal » est une conclusion valable. +- Lecture seule : tu n'écris que ton rapport. +- Rapport en français ; termes AIMsight en anglais (classifications, noms de colonnes). + +## 6. Le rapport + +Écris-le dans `agents/diagnostic/rapports/_.md` (date du jour en UTC : `date -u +%F` ; station : nom du dossier). Avec une question, ajoute un sujet court : `__.md`. Si le fichier existe, ajoute `_2`, `_3`… + +```markdown +# Diagnostic : + +- **Date du diagnostic** : AAAA-MM-JJ (UTC) +- **Données** : ; mesures du au (UTC) +- **Demande** : scan | « » +- **Modèle** : + +## Sources lues +- + +## Inventaire +- **Disponible** : … +- **Manquant** : … ; ce que ça empêche de conclure : … + +## Événements + +### E1 : ( → UTC) +- **Classification** : une de : *monitored-object motion*, *camera/reference compensation event*, *weak/unstable reference solution*, *model mismatch/parallax*, *target-local degradation*, problème système, rien d'anormal, indéterminé +- **Cause probable** : buée ou eau | occlusion | turbulence | éclairage | inconnue (seulement pour une cause externe à l'ouvrage) +- **Couche** : la couche de la chaîne de dépendance (section 4 du contexte support) +- **Niveau de preuve** : … +- **Preuves** : + - (observé | dérivé) : `` +- **Réfutation** : hypothèse principale ; fait cherché pour la contredire ; résultat (``) +- **Alternatives** : autres explications, et pourquoi elles ne sont pas écartées +- **Inconnus** : … +- **Prochaine vérification** : la plus discriminante + +## Constats permanents +- + +## Validation (à remplir par l'utilisateur) +- **Verdict** : accepté tel quel | corrigé +- **Corrections** : +- **Diagnostic final** : +``` + +## 7. Ta réponse + +Après avoir écrit le rapport, réponds en 5 à 10 lignes : les événements trouvés (classification, niveau de preuve), les constats permanents, le principal inconnu, et le chemin du rapport. +```` + +- [ ] **Step 2 : écrire `.claude/agents/diagnostic.md`** + +```markdown +--- +name: diagnostic +description: Diagnostic des données d'une station AIMsight (déplacements optiques, images). À appeler avec un dossier de data/ et, si on veut, une question. Rend un rapport traçable dans agents/diagnostic/rapports/. +tools: Read, Bash, Write +model: opus +effort: high +omitClaudeMd: true +--- + +Tu es l'agent de diagnostic du projet. Commence par lire `agents/diagnostic/instructions.md` et suis-le à la lettre. Ta demande : le dossier de `data/` et l'éventuelle question qui suivent. +``` + +- [ ] **Step 3 : écrire `agents/diagnostic/README.md`** + +```markdown +# Agent de diagnostic + +Un sous-agent Claude Code qui diagnostique les données d'une station : il repère ce qui sort de l'ordinaire, l'explique avec des preuves et dit ce qui reste non établi. Première version : déplacements optiques (export « advanced ») et images de la caméra. Pilote de l'enquête à la demande (D-042) ; décision D-046 ; spec : `docs/agents/agent-diagnostic.md`. + +## L'appeler + +- Dans une session Claude Code : `@agent-diagnostic data/PS_DES_COUDRES/`, suivi au besoin d'une question (« que s'est-il passé dans la nuit du 13 au 14/10 ? »). Sans question, il fait le scan de toute la période. +- Dans un terminal, une session entière avec l'agent : `claude --agent diagnostic`. +- Les sous-agents se chargent au démarrage d'une session : après une modification de `.claude/agents/diagnostic.md`, ouvrir une nouvelle session. + +## Ce qu'il rend + +Un rapport par diagnostic dans `rapports/` (sources lues, inventaire, un bloc par événement, constats permanents), et un résumé dans la conversation. La section « Validation » du rapport est à remplir : un rapport validé deviendra un cas. + +## Contenu du dossier + +- `instructions.md` : sa méthode, ses règles et le format du rapport. C'est ici qu'on corrige son comportement. +- `outils/` : `inventaire.py`, `resume.py`, `graphique.py` (et `donnees.py`, la lecture commune). Ils rendent des valeurs, pas des verdicts. Le graphique demande matplotlib (`.venv`). +- `rapports/` : ses rapports. + +## Limites + +Claude Code ne restreint ni ce qu'il lit, ni ce que lance son `Bash`, ni où écrit son `Write` : ses instructions le font. Son rapport liste ce qu'il a lu. +``` + +- [ ] **Step 4 : vérifier les fichiers** + +Run : `head -9 .claude/agents/diagnostic.md && grep -c '' agents/diagnostic/instructions.md` +Expected : le frontmatter (7 lignes entre les `---`), puis un nombre de lignes de l'ordre de 110. + +Run : `.venv/bin/python -c "import re,sys; t=open('.claude/agents/diagnostic.md').read(); fm=t.split('---')[1]; print(sorted(re.findall(r'^(\w+):', fm, re.M)))"` +Expected : `['description', 'effort', 'model', 'name', 'omitClaudeMd', 'tools']`. Les outils sont `Read, Bash, Write` : `ls` et `grep` passent par `Bash` (la spec citait aussi `Glob` et `Grep`, absents de cette version de Claude Code ; la tâche 5 met la spec à jour). + +- [ ] **Step 5 : commit** + +```bash +git add agents/diagnostic/instructions.md agents/diagnostic/README.md .claude/agents/diagnostic.md +git commit -m "Add the diagnostic subagent: entry point, instructions and README (D-046)" -m "Co-Authored-By: Claude Opus 5.5 " +``` + +--- + +### Task 5 : décision, carte du dépôt et spec + +**Files :** +- Modify : `docs/decisions.md` (ajout de D-046 en fin de fichier ; statut de D-044) +- Modify : `CLAUDE.md` (état, commandes, carte, environnement) +- Modify : `docs/agents/agent-diagnostic.md` (statut ; ligne de `resume.py` au §6) + +- [ ] **Step 1 : ajouter D-046 à la fin de `docs/decisions.md`** + +```markdown + +## D-046 — 2026-10-14 — Agent de diagnostic : pilote de l'enquête à la demande dans Claude Code +- **Statut** : active. Version pilote de D-042 ; déroge à D-027 sur le harnais, pour ce pilote seulement ; met au second plan la chaîne analytique de D-044. +- **Décision** : + - un sous-agent Claude Code `diagnostic` (`.claude/agents/diagnostic.md`), avec son dossier `agents/diagnostic/` (instructions, outils, rapports), diagnostique à la demande un dossier de `data/` : scan sans question, enquête avec une question ; un rapport par diagnostic dans `agents/diagnostic/rapports/`, avec une section de validation pour l'utilisateur ; + - première version : déplacements (export « advanced ») et images ; métriques système plus tard ; + - outils en lecture qui rendent des valeurs, pas des verdicts : `inventaire.py`, `resume.py`, `graphique.py` (matplotlib, ajouté à `.venv` et au dev container) ; + - Opus 5.5, effort `high` ; `omitClaudeMd` : l'agent ne lit que les sources listées dans ses instructions, pour diagnostiquer sans connaître nos conclusions ; + - spec : `docs/agents/agent-diagnostic.md`. +- **Pourquoi** : demande de l'utilisateur : profiter de la souplesse d'un agent plutôt que d'écrire des méthodes analytiques complexes, et pouvoir l'appeler à tout moment. Claude Code ne demande ni clé API ni harnais, prérequis bloquants de D-027 et D-042. +- **Options écartées** : un skill dans la conversation courante (il hériterait des hypothèses de la conversation) ; un skill seul avec `context: fork` (caché sous `.claude/`) ; les graphiques par plotly (kaleido embarque un navigateur) ; pas de graphique (l'agent verrait mal les formes des séries). +- **Conséquence** : + - D-027 avait écarté un harnais de codage pour l'agent serveur, à cause d'un Bash large et peu auditable ; ce refus vaut toujours pour un agent qui notifie des clients. Ici, outil de travail interne : Claude Code ne restreint ni `Read`, ni `Bash`, ni `Write` à des chemins ; les instructions le font, et le rapport liste ses sources ; + - pas de LLM dans `src/` : la couche déterministe ne change pas ; + - vérification par un test à l'aveugle sur PS des Coudres, attendus écrits avant le premier passage (§7 de la spec). +``` + +- [ ] **Step 2 : statut de D-044** + +Dans `docs/decisions.md`, remplacer : +```markdown +- **Statut** : active, cadrage (`docs/displacement/cadrage.md`, rien n'est construit). +``` +par : +```markdown +- **Statut** : active, cadrage (`docs/displacement/cadrage.md`, rien n'est construit) ; l'exploration passe d'abord par l'agent de diagnostic (D-046), la chaîne analytique au second plan. +``` + +- [ ] **Step 3 : `CLAUDE.md`, sept remplacements et une ligne ajoutée** + +1. Remplacer la puce `- **Enquête à la demande (D-042)** : …` (ligne entière) par : +```markdown +- **Agent de diagnostic (D-046)** : pilote de l'enquête à la demande (D-042) dans Claude Code : sous-agent `diagnostic` (`.claude/agents/diagnostic.md`, dossier `agents/diagnostic/`, spec `docs/agents/agent-diagnostic.md`) ; un dossier de `data/` et une question facultative donnent un rapport dans `agents/diagnostic/rapports/` ; déplacements et images seulement. L'enquête par API (D-042) reste un document. +``` +2. Dans la puce **Séries optiques (D-044)**, remplacer `; rien n'est construit.` par `; exploration confiée d'abord à l'agent de diagnostic (D-046), chaîne analytique au second plan.` +3. Dans **Prochaine étape**, remplacer `séries optiques : décider avec l'utilisateur de l'exploration de PS des Coudres (étape 1 du cadrage).` par `agent de diagnostic : test à l'aveugle sur PS des Coudres (§7 de sa spec), puis validation du rapport par l'utilisateur.` +4. Remplacer `python3 -m venv .venv && .venv/bin/pip install plotly # recréer .venv` par `python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .venv` +5. Remplacer `Le code d'agent vivra à part (`agents/`, proposé, pas créé).` par `Le code d'agent vit à part, dans `agents/`.` +6. Après la ligne `- `docs/agents/enquete-a-la-demande.md` …`, ajouter : +```markdown +- `docs/agents/agent-diagnostic.md` : spec de l'agent de diagnostic (D-046) ; code dans `agents/diagnostic/` (`instructions.md`, `outils/`, `rapports/`). Appel : `@agent-diagnostic data// [question]`, ou `claude --agent diagnostic` dans un terminal. +``` +7. Dans la puce `- `.claude/` : `rules/analyses.md` (se charge seule, voir « Analyses »), …`, insérer après `(se charge seule, voir « Analyses »), ` : `` `agents/diagnostic.md` (point d'entrée de l'agent de diagnostic, D-046), `` +8. Remplacer `- `.venv/` (Python 3.14) ne contient que plotly, pour le poste de dev.` par `- `.venv/` (Python 3.14) ne contient que plotly et matplotlib (graphiques de l'agent de diagnostic), pour le poste de dev.` +9. Mettre à jour `(503 l, D-001 à D-045)` avec le nouveau nombre de lignes de `docs/decisions.md` et `D-046`. + +Run : `wc -l CLAUDE.md docs/decisions.md` +Expected : `CLAUDE.md` à 199 lignes au plus ; le nombre de lignes de `docs/decisions.md` est celui écrit dans `CLAUDE.md`. + +- [ ] **Step 4 : la spec** + +Dans `docs/agents/agent-diagnostic.md` : +- remplacer `- **Statut** : design validé par l'utilisateur, à construire.` par `- **Statut** : construit le 2026-10-14 (outils, instructions, point d'entrée) ; test à l'aveugle : §7.` ; +- au §3, remplacer `tools: Read, Glob, Grep, Bash, Write` par `tools: Read, Bash, Write`, et `` `Read` (CSV, docs, images), `Glob`, `Grep`, `Bash` (ses scripts), `Write` (son rapport) `` par `` `Read` (CSV, docs, images), `Bash` (ses scripts, `ls`, `grep`), `Write` (son rapport) `` ; +- au §6, remplacer la ligne de `resume.py` par : +```markdown +| `resume.py [--colonne C] [--stat median\|min\|max] [--pas 1h] [--capteurs] [--debut] [--fin]` | Pour une colonne : le niveau habituel de chaque capteur sur la période (médiane, MAD, min, max), puis un tableau, une ligne par pas de temps et une colonne par capteur, avec la statistique choisie ; « rej » quand toutes les mesures du pas sont rejetées | +``` + +- [ ] **Step 5 : commit** + +```bash +git add docs/decisions.md CLAUDE.md docs/agents/agent-diagnostic.md +git commit -m "Record the diagnostic agent (D-046) in decisions, CLAUDE.md and its spec" -m "Co-Authored-By: Claude Opus 5.5 " +``` + +--- + +### Task 6 : test à l'aveugle sur PS des Coudres + +**Files :** +- Create (par l'agent) : `agents/diagnostic/rapports/_PS_DES_COUDRES.md`, `agents/diagnostic/rapports/_PS_DES_COUDRES_.md` +- Modify : `docs/agents/agent-diagnostic.md` (§7 : résultats) +- Modify (si un attendu est manqué) : `agents/diagnostic/instructions.md` + +**Interfaces :** +- Consumes : le sous-agent de la tâche 4. + +Le test tourne en mode non interactif : l'agent reçoit exactement notre prompt, sans passer par une session qui connaît nos conclusions. `--allowedTools` limite son `Bash` à ses outils et son `Write` à `rapports/` pendant le test. Ce lancement consomme l'abonnement Claude de l'utilisateur. + +- [ ] **Step 1 : lancer le scan** + +Run (en tâche de fond, plusieurs minutes) : +```bash +mkdir -p out/diagnostic && env -u CLAUDECODE claude -p "data/PS_DES_COUDRES/" --agent diagnostic \ + --output-format json \ + --allowedTools "Read" "Write(agents/diagnostic/rapports/**)" \ + "Bash(python3 agents/diagnostic/outils/*)" "Bash(.venv/bin/python agents/diagnostic/outils/*)" \ + "Bash(ls *)" "Bash(grep *)" "Bash(pdftotext *)" "Bash(date *)" \ + > out/diagnostic/test_scan.json 2>&1 +``` +Expected : un JSON avec `result` (la réponse), `total_cost_usd`, `num_turns`, `duration_ms` ; un nouveau rapport dans `agents/diagnostic/rapports/`. Si les règles `--allowedTools` bloquent un outil légitime (message de refus dans `result`), corriger la règle et relancer ; en dernier recours, remplacer les règles `Write(...)` et `Bash(...)` par `--permission-mode acceptEdits` et le noter dans les résultats. + +- [ ] **Step 2 : juger le scan face aux attendus du §7 de la spec** + +Lire le rapport. Pour chacun des 7 attendus, noter : atteint, partiel ou manqué, avec la phrase du rapport qui le montre. Vérifier aussi que la section « Sources lues » ne contient que des sources autorisées. + +- [ ] **Step 3 : lancer la question** + +Run : +```bash +env -u CLAUDECODE claude -p "data/PS_DES_COUDRES/ — Que s'est-il passé dans la nuit du 13 au 14/10 ?" --agent diagnostic \ + --output-format json \ + --allowedTools "Read" "Write(agents/diagnostic/rapports/**)" \ + "Bash(python3 agents/diagnostic/outils/*)" "Bash(.venv/bin/python agents/diagnostic/outils/*)" \ + "Bash(ls *)" "Bash(grep *)" "Bash(pdftotext *)" "Bash(date *)" \ + > out/diagnostic/test_question.json 2>&1 +``` +Expected : un second rapport, `_PS_DES_COUDRES_.md`, centré sur le second épisode, avec les images de la nuit regardées. + +- [ ] **Step 4 : corriger si besoin** + +Un attendu manqué ou une conclusion au-delà des preuves : corriger `agents/diagnostic/instructions.md` (la règle ou l'étape en cause, sans y écrire la réponse), supprimer le rapport du passage raté, relancer le passage concerné. Au plus deux corrections ; au-delà, s'arrêter et en parler à l'utilisateur. + +- [ ] **Step 5 : consigner les résultats dans la spec** + +Ajouter à la fin du §7 de `docs/agents/agent-diagnostic.md` : +```markdown +**Résultats du 2026-10-14** (lancement non interactif, `claude -p --agent diagnostic`, outils limités par `--allowedTools`) : + +| Attendu | Scan | Question | +|---|---|---| +| 1. Deux épisodes `REF_G` / `REF_D` | … | … | +| 2. `REF_CT` et cibles non touchées | … | … | +| 3. Pas de mouvement de l'ouvrage, réfutation | … | … | +| 4. PM_G rejetée (constat permanent) | … | … | +| 5. Inconnus | … | … | +| 6. Niveau de preuve mesuré | … | … | +| 7. Mesures manquantes non présentées comme des coupures | … | … | + +- **Coût et durée** : scan … $ en … tours et … min ; question … $ en … tours et … min. +- **Sources lues** : conformes | écarts : … +- **Corrections des instructions** : aucune | … (relancé) +``` +en remplaçant chaque « … » par le résultat observé. + +- [ ] **Step 6 : commit** + +```bash +git add agents/diagnostic/rapports/ docs/agents/agent-diagnostic.md agents/diagnostic/instructions.md +git commit -m "Run the diagnostic agent blind on PS des Coudres and record the results" -m "Co-Authored-By: Claude Opus 5.5 " +```