phase 4.5: registre identites + runbooks + sondes applicatives (cron G9) + G11 + etudes exposition/whatsapp + alignement 08-decommission et S8/S9.2/S11/S14

registre: 10-registry.sh (genere moitie technique + derive) + REGISTRE-BRIQUES.md (21 conteneurs, 13 constats) + lib-notify.sh (payload JSON)
2026-10-12 16:42:41 +02:00 · 2026-10-12 16:17:34 +02:00
24 changed files with 1369 additions and 18 deletions
@@ -411,23 +411,24 @@ Le **Qwen 3.8max** (le LLM principal) consomme **~20 Go VRAM + ~50 Go RAM**. Le
 ## S8 — Communication (Matrix + Jitsi + assistant vocal)
-> **Statut** : ✅ **Tranché** (05/10/2026) — **Matrix + Jitsi + Element** (remplace WhatsApp) + **assistant vocal** via Home Assistant.
+> **Statut** : ✅ **Tranché** (05/10/2026), **révisé 12/10/2026** — **Matrix + Jitsi + Element** = **complément du foyer** (messagerie familiale + canal d'alerte + assistant), **pas un remplacement de WhatsApp**. WhatsApp reste la messagerie principale (famille, amis, travail) — réalité d'usage mesurée, voir `g9-migration/BRIDGE-WHATSAPP.md`.
 ### 8.1 La stack communication
 | Brique | Rôle | Machine | Licence |
 |--------|------|---------|---------|
-| **Matrix (Synapse)** | **Messagerie** (remplace WhatsApp) | J5040 | Apache-2.0 |
+| **Matrix (Synapse)** | **Messagerie du foyer** + **canal d'alerte ops** (complément de WhatsApp) | J5040 | Apache-2.0 |
 | **Jitsi** | **Visioconférence** | J5040 | Apache-2.0 |
-| **Element** | **Client** (Android) | Téléphone | GPL-3.0 |
+| **Element** | **Client** (Android) — 2 adultes d'abord, ados en phase 2 | Téléphone | GPL-3.0 |
 | **Home Assistant** | **Assistant vocal** (enceintes Google) | Freebox | Apache-2.0 |
 ### 8.2 L'usage famille (résilience = usage)
 | Utilisateur | Appareil | Usage quotidien |
 |-------------|----------|-----------------|
-| **Famille** | Téléphone (Element) | **Messagerie** (remplace WhatsApp) |
+| **Famille** | Téléphone (Element) | **Messagerie du foyer** (salon famille) — **WhatsApp garde** les échanges extérieurs (amis, travail, famille élargie) |
 | **Famille** | Téléphone + TV | **Visio** (Jitsi, via Element) |
 | **Moi** | Téléphone + PC | **Salon ops** (alertes backup / sondes / dérive registre) |
 | **Moi** | Enceintes Google ×4-5 | **Assistant vocal** (Home Assistant) → peut déclencher n8n, contrôler Frigate |
 ### 8.3 Le bot hermes ↔ Matrix
@@ -461,7 +462,7 @@ Le **Qwen 3.8max** (le LLM principal) consomme **~20 Go VRAM + ~50 Go RAM**. Le
 | Élément | Détail |
 |---------|--------|
 | **Domaine** | **folzocorp.fr** (principal) + **sous-domaines** par service |
-| **Sous-domaines** | `cloud.folzocorp.fr` (Nextcloud) · `photos.folzocorp.fr` (PhotoPrism) · `media.folzocorp.fr` (Jellyfin) · `matrix.folzocorp.fr` (Matrix) · `git.folzocorp.fr` (Gitea) · `vault.folzocorp.fr` (Vaultwarden) · `ai.folzocorp.fr` (OpenWebUI) |
+| **Sous-domaines** | `cloud.folzocorp.fr` (Nextcloud) · `prisme.folzocorp.fr` (**PhotoPrism**) · `photos.folzocorp.fr` (**Synology Photos** — LAN-only, **temporaire**, disparaît avec le xpenology en Phase 6) · `media.folzocorp.fr` (Jellyfin) · `matrix.folzocorp.fr` (Matrix) · `git.folzocorp.fr` (Gitea) · `pass.folzocorp.fr` (Vaultwarden) · `n8n.folzocorp.fr` (n8n) · `ai.folzocorp.fr` (OpenWebUI) |
 | **TLS** | **Caddy** génère + renouvelle **automatiquement** les certificats Let's Encrypt (pas de script). |
 | **Exposition** | **Seulement** les services **nécessaires** à l'extérieur passent par Caddy. Le **reste** est **LAN-only** (accès via **WireGuard**). |
@@ -555,7 +556,9 @@ Le **Qwen 3.8max** (le LLM principal) consomme **~20 Go VRAM + ~50 Go RAM**. Le
 | **Docker Compose** | **Déclaration** des services (fichiers `docker-compose.yml`) | toutes | Apache-2.0 |
 | **Gitea** | **Versioning** des `docker-compose.yml` + config (source de vérité) | G9 | MIT |
 | **Watchtower** | **Mises à jour** automatiques **sélectives** (stateless auto / stateful exclu + manuel) | J5040 + G9 + PC IA | Apache-2.0 |
-| **Beszel** | **Monitoring** léger + historique + **alertes** | J5040 (hub) + agents | MIT |
+| **Beszel** | **Monitoring** léger + historique + **alertes** (métriques + état conteneurs) | J5040 (hub) + agents | MIT |
 | **Registre** (`11-registry.sh` → `REGISTRE-BRIQUES.md`) | **Inventaire généré** (images épinglées, labels, endpoints, état) + **détection de dérive** par `git diff` | pilot → .24/.27 (lecture seule) | MIT (kit) |
 | **Sondes applicatives** (`12-probes.sh`) | **`up ≠ utilisable`** : sonde la **fonction** (occ status, discovery, healthz, login) + **alertes JSON** + **1 digest/jour** | G9 (cron) | MIT (kit) |
 | **n8n** | **Alertes** + **automatisation** (workflows) | G9 | ⚠️ fair-code |
 ### 11.2 Pourquoi pas Portainer / PaaS
@@ -827,7 +830,7 @@ Phase A (Fondations logicielles) ──► Phase B (Cœur famille) ──► Pha
 | Fédéré / auto-hébergé | ✅ | ❌ | 🟡 |
 | **Verdict** | **✅ Recommandé** | ❌ (GAFAM) | 🟡 (pas d'auto-hébergement facile) |
-> **Recommandation** : **Matrix (Synapse) + Jitsi + Element** (remplace WhatsApp).
+> **Recommandation** : **Matrix (Synapse) + Jitsi + Element** en **complément du foyer** (messagerie familiale + alertes + assistant). **Révisé 12/10/2026** : WhatsApp **n'est pas remplaçable** dans notre usage (famille, amis, travail) → il reste la messagerie principale ; Element couvre le **foyer** et le **canal d'alerte**. Le pont `mautrix-whatsapp` est **étudié, non déployé** : numéro familial **interdit**, risque de bannissement, coût de session (QR / 12 jours). Détail : `g9-migration/BRIDGE-WHATSAPP.md`.
 ### 14.6 MDM enfants
@@ -840,6 +843,39 @@ Phase A (Fondations logicielles) ──► Phase B (Cœur famille) ──► Pha
 > **Recommandation** : **Google Family Link** (maintenant, usage parental) + **MDM OSS** (MicroMDM/Android Enterprise) en **option future**.
 ### 14.7 Coffre famille (décision 12/10/2026)
 | Critère | **Vaultwarden unique (6 personnes)** ✅ | Nextcloud Passwords |
 |---------|----------------------------------------|---------------------|
 | Dépendance | ✅ indépendant des autres briques | ❌ le coffre vit dans la brique qu'il protège (Nextcloud HS = plus les accès pour réparer Nextcloud) |
 | Reset admin d'un compte enfant | ✅ sans effet sur le coffre | ❌ clés dérivées du mot de passe → coffre potentiellement illisible |
 | Modèle familial (organisations, emergency access) | ✅ | ❌ |
 | Coût pour 6 (import, backup, reset, formation) | ✅ 1 chemin | ❌ 2 chemins (registre doublé) |
 | **Verdict** | **✅ Retenu** | ❌ Non retenu (pilote adulte possible, non déclenché) |
 ### 14.8 Identité (décision 12/10/2026, ordre validé)
 | Étape | Décision | Statut |
 |---|---|---|
 | 1 | **Registre d'identités** (moitié générée + moitié humaine) — répond à « quel compte a servi ? » | ✅ posé (`g9-migration/REGISTRE-IDENTITES.md`) |
 | 2 | **Étude exposition internet** avant tout IdP | ✅ étude écrite, 5 décisions à rendre |
 | 3 | **Authelia** en cible, pilote 3 briques (Synapse, Gitea, Jellyfin), **opt-in + break-glass** | 🟡 après étude + Phase 5 |
 | — | Authentik / Keycloak / Samba AD / FreeIPA / Nextcloud-IdP | ❌ écartés (poids, sur-ingénierie, SPOF sur la brique la plus stateful) |
 ### 14.9 Suivi applicatif (décision 12/10/2026)
 | Critère | **Sondes + registre + Diun** ✅ | Grafana/Prometheus (+cAdvisor) | Netdata | Uptime Kuma |
 |---|---|---|---|---|
 | Couvre `up ≠ utilisable` | ✅ (occ, discovery, healthz, login) | ❌ (métriques) | 🟡 | ✅ |
 | Briques ajoutées | **0** (scripts du kit) | 4 | 1 (lourd) | 1 (stateful) |
 | Chevauchement avec Beszel | **complémentaire** | redondant (InfluxDB déjà écarté) | redondant | partiel |
 | Charge de maintenance | faible (cron + 1 digest/jour) | élevée | moyenne | moyenne + fatigue d'alertes |
 | **Verdict** | **✅ Retenu** | ❌ | ❌ | 🟡 reporté (déclencheur écrit, Phase 6 + 2 semaines d'usage) |
 ### 14.10 Autonomie de l'assistante IA (décision 12/10/2026)
 > **Paliers G11** : L0 lecture seule → L1 propose → L2 exécute le **stateless documenté** → L3 stateful **sur GO explicite**. Portes chiffrées (≥ 90 % de propositions pertinentes sur 30 jours ; sinistre simulé sans perte). Interdits permanents : destructif, suppression de données, réseau (G6), wipe, création de privilège, lecture de secrets hors coffre. Détail : `g9-migration/README.md` (charte G11).
 ---
 ## S15 — Critères d'acceptance (AC1–AC10)
@@ -867,6 +903,7 @@ Phase A (Fondations logicielles) ──► Phase B (Cœur famille) ──► Pha
 | Date | Version | Changement |
 |------|---------|------------|
 | 12/10/2026 | **v1.6** | **Identité + suivi applicatif + communication (décisions 12/10)** : **S8 révisé** — Matrix/Jitsi/Element = **complément du foyer**, **pas** remplacement de WhatsApp (Element : 2 adultes d'abord, ados phase 2) ; **S9.2** sous-domaines alignés sur le réel (`pass.folzocorp.fr` = Vaultwarden, **`prisme.folzocorp.fr` = PhotoPrism**, `photos.folzocorp.fr` = Synology Photos **temporaire**, meurt Phase 6) ; **S11** enrichi de deux briques d'ops sans conteneur de plus : **registre généré** (`11-registry.sh` → `REGISTRE-BRIQUES.md`, dérive par `git diff`) et **sondes applicatives** (`12-probes.sh`, `up ≠ utilisable`, alertes **JSON** + 1 digest/jour) ; **S14.7→S14.10** : coffre **unique Vaultwarden** pour 6 (Nextcloud Passwords écarté : boucle de verrouillage + reset admin + pas d'emergency access), identité = **registre → étude exposition → Authelia** (Authentik/Keycloak/Samba AD/FreeIPA écartés), suivi = **sondes + registre + Diun** (Grafana/Prometheus/Netdata écartés, Uptime Kuma reporté avec déclencheur écrit), **G11 paliers d'autonomie IA**. Artéfacts : `g9-migration/{REGISTRE-IDENTITES,REGISTRE-BRIQUES,PARTAGE-SECRET-MAITRE,RESTORE-NAS-USB,EXPOSITION-INTERNET,BRIDGE-WHATSAPP}.md`, `RUNBOOKS/` ×7, charte **G11**. |
 | 10/10/2026 | **v1.5** | **S10.2 — copie 2 (Freebox) EN PLACE sur le G9** : restic 0.19.1 + rclone 1.75.2, repo `rclone:freeboxftp:Freebox/backup/g9` (FTP local 21), snapshot 4.18 GiB, **append-only prouvé**, **restore testée** (sha256), cron 03:30/04:00/09:15 + alerte Matrix ; **mont CIFS abandonné** (restic/`chmod`, FUSE) → backend rclone, **persistance post-reboot sans montage**. **Phase 5 planifiée** (non réalisée) : VM Freebox + `rest-server --append-only` (autostart à valider), `restic copy` → 218play, identifiants `NoAccess`, chroot durci. |
 | 06/10/2026 | **v1.4** | **Cohérence inter-dossiers (source unique)** : (1) **S10.2** — le schéma 3-2-1 ne **re-déclare plus** le tableau → **pointeur** vers `DOSSIER-RECREATION.md` §R4 (source unique) + note outil (restic, quotidien/hebdo) ; (2) **S4.3** — le modèle 2 couches ne **re-déclare plus** le principe → **pointeur** vers `PROJET-SECOND-CERVEAU.md` S4.1 (source unique) + tableau **mapping briques/machines** (spécificité du dossier logiciel) ; (3) **S3.1** — le tableau est **cadré autour des briques fonctionnelles** : la stack \*arr #10 = **1 brique**, les apps Nextcloud 13-15 marquées **↳ apps du socle NC #12** ; note de comptage précisée (**28 lignes = 25 briques fonctionnelles**, dans la cible ≤ ~20 briques de consolidation). |
 | 06/10/2026 | **v1.3** | **Correction mainteneur hermes** : S3.1 #24 — « maintenu (Nous Research) » → « **maintenu (nesquena — `ghcr.io/nesquena/hermes-webui`)** », aligné sur l'image réellement en production (snapshot `ETAT-DE-LART-2026-09-30.md` §2.1). |
@@ -0,0 +1,64 @@
 # BRIDGE WHATSAPP ↔ MATRIX (T-W — étude, **0 installation**)
 > Contexte décidé 12/10 : **WhatsApp est indispensable** (famille, amis, travail) et ne sera **pas**
 > remplacé. Matrix = complément du foyer. Ce document dit ce qu'un pont apporte, ce qu'il ne donne
 > pas, et ce qui est **interdit**. Aucune installation sur le numéro familial.
 ## 1. L'outil
 | Point | Fait |
 |---|---|
 | Projet | `mautrix-whatsapp` (Tulir / mautrix), basé sur `whatsmeow` |
 | Licence | **AGPL-3.0** (compatible avec la règle « OSS + chemin de sortie » de la table rase) |
 | Mécanisme | protocole **WhatsApp Web multi-device** : le serveur tient une session liée par **QR code** |
 | Contrainte téléphone | WhatsApp impose que le **téléphone se connecte au moins tous les 12 jours**, sinon la session est coupée → **re-link** (QR) à refaire |
 | État | DB (messages, préférences) + **session** (clés de liaison) + médias = **brique stateful** |
 | Chiffrement | côté Matrix : E2EE gérable ; **côté WhatsApp : la session standard**, tes correspondants ne voient **que** WhatsApp |
 ## 2. Ce que le pont apporte / ce qu'il ne donne pas
 | Apporte | Ne donne pas |
 |---|---|
 | Miroir des conversations WhatsApp dans Element (MP, groupes, médias), historique importable | un canal commun : un groupe WhatsApp et un salon Matrix ne « se parlent » pas proprement (les membres WhatsApp ne voient pas Matrix) |
 | Répondre depuis Element | la fin de WhatsApp : **WhatsApp reste la source** |
 | Lecture centralisée (1 client pour la famille + les alertes ops) | la garantie de disponibilité : pont cassé = **perte de l'affichage**, pas des messages |
 | Base pour qu'Effi (assistante) **lisse/résume** des MP si tu l'autorises | la conformité : un client non officiel est **contraire aux ToS WhatsApp** |
 ## 3. Risques à nommer (le point qui décide tout)
 | Risque | Détail | Conséquence pour nous |
 |---|---|---|
 | **Bannissement du numéro** | WhatsApp détecte les clients non officiels ; le risque est **réel et non nul** | ton numéro familial est « indispensable » → **interdiction** : jamais le numéro principal sur un pont |
 | Session qui expire | > 12 jours sans connexion du téléphone = déconnexion | re-link manuel = maintenance que tu veux éliminer |
 | Stateful fragile | session + DB + médias ; montée de version du protocole WhatsApp non maîtrisée | épingler par digest, **exclure de Watchtower**, backup session+DB dans restic |
 | Confidentialité | les MP passent par un daemon sur le G9 + stockage local | à accepter explicitement (choix de périmètre) |
 | Surface d'attaque | brique de plus, exposée = non (interne), mais lit un compte de communication | pas d'exposition WAN ; pas d'automatisation d'**envoi** |
 ## 4. Interdits écrits (T-W.3)
 1. **Numéro familial principal** : jamais relié à un pont.
 2. **Alertes ops sur WhatsApp** : le canal d'alerte reste Matrix (S8.4), pas WhatsApp.
 3. **Aucune automatisation qui envoie** des messages WhatsApp (n8n/IA) : lecture seulement, si pilote validé.
 4. Aucune exposition WAN du pont ; aucune ouverture ufw pour lui.
 ## 5. Si un jour GO utilisateur (pilote borné)
 | Étape | Contenu |
 |---|---|
 | 1 | **numéro secondaire isolé** (numero dédié, vide, hors famille) |
 | 2 | conteneur épinglé par digest, label `watchtower.enable=false`, DB + session dans `/data/docker/whatsapp/` |
 | 3 | session + DB **dans les snapshots restic** (vérifié) |
 | 4 | **7 jours de miroir stable** (pas de re-link, pas de perte de messages) |
 | 5 | re-link testé (déconnexion volontaire → QR → reprise) |
 | 6 | rollback documenté : `docker compose -f compose/whatsapp/docker-compose.yml down` (aucune donnée famille concernée) |
 | 7 | journal + grille S14 (décision, raison, coût constaté) |
 ## 6. Verdict de l'étude
 - **Utile** si l'objectif est « lire au même endroit » (Element = foyer + alertes) et que le pilote
  reste sur un **numéro secondaire**.
 - **Pas utile** si l'objectif est de quitter WhatsApp : le pont ne fait pas ça.
 - **Coût de maintenance** : session (QR/12 jours) + DB + médias = exactement le type de charge que
  tu veux supprimer. Le pont **ajoute** de la maintenance pour un gain de confort.
 - Recommandation : **étude validée, pilote non déclenché** ; on en reparle quand Element tourne
  pour le foyer et que les alertes ops sont stables (tâche MATRICE FAMILLE), jamais avant.
@@ -0,0 +1,69 @@
 # ÉTUDE EXPOSITION INTERNET (T-D — étude, **aucune règle posée**)
 > Périmètre : documenter, pas agir. **0 règle ufw modifiée, 0 changement réseau** (G6).
 > Faits mesurés le 12/10/2026 en lecture seule (`ufw status numbered`, `ss -ltnu`, Caddyfile, journal).
 ## 1. Exposition mesurée aujourd'hui
 | Machine | Exposée au WAN (pare-feu) | Observations |
 |---|---|---|
 | **G9 (.24)** | `22/tcp` **Anywhere**, `443/tcp` **Anywhere** (+ v6) | 22 ouvert au WAN = **risque si la Freebox forward** ; 443 = l'ancien edge (TLS **interne**, CA auto-signé) → un endpoint chiffré non reconnu exposé publiquement |
 | **G9 (.24)** LAN-only | 2342, 3000, 3100, 5678, 5984, 8008, 8009, 8080, 8081, 8096, 9980, 2456-2458, SMB (137-139/445) | tout ce qui est « brique » est correctement restreint à `192.168.1.0/24` |
 | **J5040 (.27)** | `80/tcp`, `443/tcp`, `51820/udp` (**Anywhere**) | le **vrai** edge : Caddy + Let's Encrypt (7/7 certs DNS-01) + WireGuard. 80 = redirect ACME |
 | **J5040 (.27)** LAN-only | `53` (DNS AdGuard), `3000` (hub Beszel), `8081` (UI AdGuard) | UI AdGuard = **login local** (bcrypt), pas de 2FA |
 | **Pilot (.11)** | `tailscale0` actif (100.111.222.30) | **voie d'accès distante non documentée** dans le plan S9 → à nommer explicitement (acceptée ou coupée) |
 | **Freebox** | IP publique `82.65.198.114` (`folzocorp.fr`) | les **redirects Freebox** (443 → G9, Valheim UDP 2456-2458) ne sont **pas lisibles** depuis l'infra : inventaire à faire côté Freebox par l'utilisateur |
 ## 2. Grille par brique (actuelle / nécessaire / dangereuse)
 | Brique | Publique aujourd'hui | Publique **nécessaire** | Danger si exposée | Public visé |
 |---|---|---|---|---|
 | Nextcloud (`cloud`) | oui, via J5040 (443) | **oui** (usage famille hors maison) | compte unique = porte d'entrée des fichiers ; 2FA obligatoire | famille |
 | Vaultwarden (`pass`) | oui, via J5040 | **oui** (coffre = besoin nomade) | exposition du coffre = cible n°1 ; 2FA + mot de passe maître fort | famille |
 | Matrix/Synapse + Element (`matrix`, 8009) | matrix via J5040 ; Element web LAN | **non** (Element = client, passe par le homeserver) | 8009 exposé = frontal gratuit ; 8008 exposé = API admin exposée | famille |
 | Gitea (`git`) | oui, via J5040 | **non** (usage interne + pushes) | dépôt du kit + vault second cerveau = **fuites de plans** ; comptes `must_change_password` | moi |
 | Jellyfin (`media`) | oui, via J5040 | **optionnel** (usage hors maison = désirabilité) | compte opérateur `g9ops` exposé ; pas de 2FA | famille |
 | PhotoPrism (`prisme`) | route prévue, pas posée | **optionnel** | 10 ans de photos = **donnée la plus sensible** de la maison | famille |
 | n8n (`n8n`) | oui, via J5040 | **non** | UI d'automatisation = exécution de commandes ; **pas de SSO** (payant) ; owner unique | moi |
 | Beszel hub (3000 .27) | non | non | vue de l'inventaire + alertes | moi |
 | AdGuard UI (8081 .27) | non | non | contrôle du DNS de toute la maison | moi |
 | Collabora (9980) | non | non | WOPI interne | interne |
 | CouchDB (5984) | non | non | **danger LAN** : CouchDB sans auth = lecture/écriture directe | interne |
 | SMB (137-139/445) | non | non | partage famille, invité `guest ok` → **LAN-only strict** | famille |
 | SSH G9 (22) | **oui au pare-feu** | **non** | exposition SSH = 22 en clair sur internet si forward | moi |
 | Edge G9 (443) | **oui au pare-feu** | **non** ( remplacé par J5040 ) | TLS auto-signé exposé, double porte d'entrée | — |
 | Valheim (2456-2458) | non (redirect Freebox UDP existant) | **oui** (amis hors LAN) | jeu, sans donnée sensible | amis |
 | WireGuard (51820 .27) | oui | **oui** (c'est LA porte d'entrée distante) | clé privée = accès total LAN | moi |
 ## 3. Ce que ça change pour l'identité (lien direct avec la tâche Authelia)
 | Constat | Conséquence |
 |---|---|
 | La **forward-auth ne protège que ce qui passe par Caddy** (les 6 sous-domaines) | les ports LAN directs (3000, 5678, 5984, 8009, 8081, 9980, 2342) **restent en login local** : un IdP ne les couvre pas |
 | Tout ce qui est **LAN-only** n'a pas besoin d'un IdP pour être sûr | si la posture reste « LAN + WireGuard », l'apport d'Authelia est **confort** (1 login, 1 2FA) et non sécurité |
 | Tout ce qui est **exposé** (Nextcloud, Vaultwarden, Matrix, Gitea, Jellyfin, n8n) est concerné | plus l'exposition est large, plus l'IdP + 2FA central devient indispensable |
 | `22/tcp` et l'edge G9 sont ouverts au WAN **sans nécessité** | ce sont les 2 décisions les moins chères à prendre (fermer = 2 règles à retirer, pas à poser) |
 | Tailscale sur le pilot | voie distante réelle et silencieuse : à **nommer** (acceptée = documentée ; refusée = désactivée) |
 ## 4. Playbook de durcissement (classé, **non implémenté**)
 | Rang | Action | Coût | Effet | Réversibilité |
 |---|---|---|---|---|
 | 1 | Retirer `22/tcp Anywhere` du G9 (SSH = LAN + WireGuard) | 1 règle | supprime l'expo SSH publique | immédiate |
 | 2 | Retirer `443/tcp` du G9 après la bascule bridge (edge J5040 seul) | 1 règle + démontage | une seule porte d'entrée | immédiate |
 | 3 | 2FA sur Nextcloud + Vaultwarden + Gitea + Synapse (S9.1) | ~1 h | la vraie protection des comptes exposés | par compte |
 | 4 | WireGuard = **seul** chemin distant pour Gitea/n8n/Beszel/AdGuard UI | config Caddy/ufw | 4 briques sortent de la surface publique | immédiate |
 | 5 | Forward-auth Authelia sur les 6 sous-domaines + break-glass | 1 brique | 1 login, 1 2FA, déprovisionnement en 1 point | opt-in par brique |
 | 6 | CouchDB : auth ou bind 127.0.0.1 (l'appli n'a besoin que du réseau Docker) | 1 ligne compose | ferme un trou LAN silencieux | immédiate |
 | 7 | Inventaire des redirects Freebox (443, UDP 2456-2458) + suppression de ce qui est mort | côté Freebox, utilisateur | cohérence réel/plan | immédiate |
 | 8 | Nommer Tailscale (accepté/documenté, ou désactivé) | 1 décision | supprime une voie non documentée | immédiate |
 ## 5. Décisions à rendre (ta main)
 1. Fermer `22` WAN sur le G9 ? (rang 1)
 2. Démonter l'edge G9 à la bascule bridge ? (rang 2)
 3. Garder Gitea et n8n exposés, ou les réserver à WireGuard ? (rang 4)
 4. Tailscale : documenté et assumé, ou coupé ? (rang 8)
 5. PhotoPrism et Jellyfin exposés hors maison, oui/non ? (grille)
 **Tant que ces 5 réponses ne sont pas données, aucune règle n'est posée** (G6).
@@ -0,0 +1,60 @@
 # PARTAGE-SECRET-MAITRE — procédure de secours (T-A.9)
 > Décision 12/10 : aujourd'hui **moi seul** connais le mot de passe maître du coffre (Vaultwarden)
 > et l'`ADMIN_TOKEN`. Objectif : **1 à 2 amis de confiance** capables de déverrouiller le coffre
 > si je suis injoignable. Ce fichier ne contient **aucun secret** : il décrit le contenant, les
 > détenteurs, et ce qu'ils font.
 ## 1. Détenteurs (à nommer par l'utilisateur)
 | Rôle | Personne | Support remis | Date de remise | Test annuel |
 |---|---|---|---|---|
 | Détenteur 1 | _à nommer_ | enveloppe scellée n°1 | _à date_ | _à date_ |
 | Détenteur 2 (optionnel) | _à nommer_ | enveloppe scellée n°2 | _à date_ | _à date_ |
 Règles de sélection (à assumer) : personne joignable physiquement, indépendante de l'infra,
 capable d'appliquer une procédure écrite sous stress, **sans accès** aux machines.
 ## 2. Contenu de l'enveloppe (hors-ligne, scellée)
 - le **mot de passe maître** du coffre (la passphrase, pas les mots de passe du coffre) ;
 - l'**`ADMIN_TOKEN`** en clair (console Vaultwarden) ;
 - la **phrase de récupération E2E** de Matrix (au moins pour les 2 adultes) ;
 - la **clé de chiffrement du repo restic** (`repo.key`) — copie, pas l'originale ;
 - la liste des 6 personnes et des briques concernées (copie de `REGISTRE-IDENTITES.md` §2/§3) ;
 - une **note de datation** : à chaque changement de mot de passe maître, l'enveloppe est
  remplacée et l'ancienne est détruite (journaliser la date).
 Support : papier (pas de clé USB non chiffrée), plié, scellé, signé de la date. Deux copies
 max. Jamais de photo, jamais de fichier non chiffré sur un disque.
 ## 3. Ce que fait le détenteur si je suis injoignable
 1. Ouvrir l'enveloppe **devant témoin** (famille), noter la date.
 2. Déverrouiller le coffre : app Bitwarden → URL du coffre = `https://pass.folzocorp.fr`
   (si le domaine n'est pas joignable, l'accès LAN = `http://192.168.1.24:8081`) →
   identifiant = mon compte → **mot de passe maître** de l'enveloppe.
 3. Si l'app refuse (2FA) : utiliser la console admin `https://pass.folzocorp.fr/admin` avec
   l'`ADMIN_TOKEN` de l'enveloppe → désactiver le 2FA du compte (mesure de dernier recours,
   à journaliser).
 4. Transmettre aux adultes de la famille les entrées nécessaires (organisation `Famille`),
   **sans** diffuser les secrets hors famille.
 5. Journaliser dans `journal.md` : date, ce qui a été ouvert, ce qui a été transmis.
 ## 4. Test annuel (critère)
 Une fois par an, sans casser la production :
 - le détenteur ouvre l'enveloppe (ou une copie d'entraînement identique) ;
 - il déverrouille un **coffre d'entraînement** (vault de test, pas le coffre famille) avec les
  éléments de l'enveloppe ;
 - la procédure est chronométrée et les points de friction sont corrigés dans ce fichier ;
 - la ligne est journalisée : `| date | partage-secret-maitre : test annuel | résultat | remplacement enveloppe |`.
 ## 5. Révocabilité
 | Événement | Action |
 |---|---|
 | Détenteur injoignable/decédé | retirer son accès, remplacer l'enveloppe, journaliser |
 | Perte d'une enveloppe | **changer le mot de passe maître** + régénérer l'`ADMIN_TOKEN`, refaire les enveloppes |
 | Doute sur la confidentialité | idem : rotation complète (mot de passe maître + ADMIN_TOKEN + clés restic) |
@@ -28,7 +28,7 @@ xpenology → G9, phase par phase, quand le G9 sera branché (IP temporaire `.24
 |-----------|---------------------|
 | G1 | Scripts idempotents, en-têtes documentant chaque modification. |
 | G2 | `06-restic-backup.sh` : backup + **test de restauration** avant toute migration. |
-| G3 | `06b-usb-media.sh`, `08-decommission.sh` : drapeau `--i-understand` + saisie du nom du disque / `WIPE XPENOLOGY`. |
+| G3 | `06b-usb-media.sh` : drapeau `--i-understand` + saisie du nom du disque. `08-decommission.sh` : saisie `ETEINDRE XPENOLOGY` — **aucun wipe exécuté par le kit** (décision 12/10 : débrancher, disques intacts, récupération `RESTORE-NAS-USB.md`). |
 | G4 | `07a`–`07d` (+ `07-migrate-stateful.sh` générique) : lecture seule du xpenology + intégrité sha256 ; `08-decommission.sh` exige la validation de toutes les briques avant wipe. |
 | G5 | README (ordre d'exécution) + `08-decommission.sh` : IP `.24`→`.25` uniquement au décommissionnement. |
 | G6 | `01-hardening.sh` : ufw LAN-only (`192.168.1.0/24`), pas d'exposition WAN. |
@@ -36,6 +36,7 @@ xpenology → G9, phase par phase, quand le G9 sera branché (IP temporaire `.24
 | G8 | `journal()` de chaque script → `journal.md` (6 colonnes : date, phase, action, raison, résultat, rollback). |
 | G9 | `.gitignore` (`*.env`, `secrets/`, configs remplis) + `03b-secrets.sh` (chmod 600, non loggué). |
 | G10 | Scripts ne modifient que le G9 ; xpenology en lecture seule (SSH `Master@192.168.1.25:222`, clé SSH — compte `effi` bloqué par Synology 10/2026). |
 | G11 | **Autonomie de l'assistante IA par paliers** (décision 12/10) : **L0** lecture seule → **L1** propose, l'humain exécute → **L2** exécute les actions **stateless documentées** des `RUNBOOKS/` → **L3** actions **stateful** uniquement sur **GO explicite** de l'utilisateur. Portes : L1→L2 = 20 propositions journalisées dont **≥ 90 % pertinentes sur 30 jours** ; L2→L3 = sinistre simulé sur une brique stateful **sans perte de données** + rollback vérifié. Interdits permanents : opérations destructives (G3), suppression de données, modification réseau impactant d'autres appareils (G6), wipe, création de compte ou de privilège, lecture de secrets hors coffre. Traçabilité : chaque action de l'IA = ligne de journal (quoi, pourquoi, résultat, rollback) + notification dans le salon ops. **Aucune exécution L2/L3 sans validation utilisateur tracée.** |
 ## Arborescence
@@ -63,7 +64,14 @@ g9-migration/
 │   ├── restic-notify.sh      ← alerte Matrix des jobs restic (posée par 06)
 │   ├── 09-j5040-dhcp.sh      ← E3 : DHCP dnsmasq sur J5040 (pré-bascule bridge)
 │   ├── 10-verify-restore-photo.sh ← critère 3 : preuve restore photo (sha256 vs .25)
-│   └── 08-decommission.sh    ← T6.4 : décommissionnement xpenology  [DESTRUCTIF]
+│   ├── 11-registry.sh        ← T-A.1/T-A.5 : génère REGISTRE-BRIQUES.md + --check --alert (dérive)
 │   ├── registry_parse.py     ← helper lecture seule de 11-registry.sh (docker ps → lignes + constats)
 │   ├── registry_inputs.py    ← helper : compose du kit + Caddyfile → declarations & endpoints
 │   ├── 12-probes.sh          ← T-C.1/C.2/C.5 : sondes APPLICATIVES + alertes JSON + digest (cron G9)
 │   ├── g9-notify.py          ← poste un payload JSON dans le salon ops (install /usr/local/bin)
 │   ├── g9-verify-alert.py    ← vérifie la conformité des payloads JSON reçus (C-AP2)
 │   ├── lib-notify.sh         ← côté pilot : notifie via g9-notify.py (aucun secret dans le kit)
 │   └── 08-decommission.sh    ← T6.4 : arrêt + débranchement xpenology  [0 wipe — disques intacts]
 ├── compose/                  ← docker-compose.yml versionnés (stockés aussi dans Gitea)
 │   ├── vaultwarden/          ← T4.1
 │   ├── nextcloud/            ← T4.2
@@ -80,6 +88,32 @@ g9-migration/
    └── restic.env.example    ← template restic (T3.1) — REMPLIR les secrets
 ```
 ## Docs d'identité, d'observabilité et d'études (Phase 4.5+)
 | Fichier | Rôle | Nature |
 |---|---|---|
 | `REGISTRE-BRIQUES.md` | **Moitié technique** du registre : briques, images épinglées, labels Watchtower, endpoints, état, backup. | **Générée** par `scripts/11-registry.sh` — ne pas éditer |
 | `REGISTRE-IDENTITES.md` | **Moitié humaine** : quel compte sur quelle brique, type, 2FA, référence d'entrée du coffre, **comment réinitialiser**, responsable. | Versionnée, **0 secret** |
 | `RUNBOOKS/` | `nextcloud` · `matrix` · `jellyfin` · `photoprism` · `vaultwarden` · `registre` · `digest` : symptôme → diagnostic → action → rollback | matière première de l'assistante IA (G11) |
 | `PARTAGE-SECRET-MAITRE.md` | Qui peut déverrouiller le coffre si je suis injoignable : détenteurs, contenu de l'enveloppe, procédure, **test annuel** | 0 secret |
 | `RESTORE-NAS-USB.md` | Lire les disques DSM hors boîtier (mdadm/LVM, **lecture seule**), procédure + contrôles + interdits | test = critère Phase 6 |
 | `EXPOSITION-INTERNET.md` | Étude : exposition mesurée, grille par brique, lien avec l'IdP, playbook classé | **0 règle posée** |
 | `BRIDGE-WHATSAPP.md` | Étude `mautrix-whatsapp` : apports, limites, risque de bannissement, interdits, pilote borné | **0 installation** |
 ### Régler le registre et les sondes (une fois, puis ça tourne)
 ```bash
 # machine de pilotage — lecture seule sur .24/.27
 ./scripts/11-registry.sh                 # génère REGISTRE-BRIQUES.md
 ./scripts/11-registry.sh --check --alert # dérive -> payload JSON dans le salon ops (rc=1)
 # G9 (root) — sondes applicatives + digest
 sudo ./scripts/12-probes.sh --install    # /usr/local/bin/g9-probes.sh + cron */15 + digest 08:30
 sudo ./scripts/12-probes.sh --selftest   # provocation d'un KO -> NOTIFY_OK 200
 sudo ./scripts/g9-verify-alert.py 20     # payloads JSON conformes ? -> VERIFY_OK
 sudo ./scripts/12-probes.sh --uninstall  # rollback complet (cron + script + état)
 ```
 ## Ordre d'exécution (phase par phase)
 | Phase | Script / action | Garde-fou |
@@ -0,0 +1,60 @@
 # REGISTRE-BRIQUES — moitié technique (générée)
 > Source : `scripts/11-registry.sh` (`docker ps` + `docker inspect` en **lecture seule** sur .24 et .27,
 > compose du kit, Caddyfile pour les endpoints). **Ne pas éditer à la main** : la moitié humaine
 > (comptes, 2FA, procédure de réinitialisation, responsable, break-glass) vit dans
 > `REGISTRE-IDENTITES.md`.
 >
 > Périmètre (T-A.10) : **.24 (G9) et .27 (J5040) uniquement**. Le xpenology **.25 est hors périmètre** :
 > il est décrit dans `INVENTAIRE-STATEFUL.md` et ses briques sont **à mourir en Phase 6**.
 >
 > Couverture backup : g9=restic (sources /data /home/folzo /etc, cron 03:30) ; j5040=non (à couvrir Phase 5)
 <!-- GÉNÉRÉ PAR scripts/11-registry.sh — ne pas éditer à la main. ts=2026-10-12 14:17 UTC ; 21 conteneurs -->
 | Machine | Conteneur | Projet / service (compose) | Image | État | Épinglée | Watchtower | Type | Dans le kit | Endpoint (Caddy) |
 |---|---|---|---|---|---|---|---|---|---|
 | g9 | `collabora` | nextcloud / collabora | `collabora/code:26.04.5.1.1` | running | oui | false | stateful | oui | — |
 | g9 | `couchdb` | g9-queue / couchdb | `couchdb:3.3` | running | oui | false | stateful | NON | — |
 | g9 | `edge` | edge / edge | `caddy:2` | running | oui | true | stateless | oui | — |
 | g9 | `element` | matrix / element | `vectorim/element-web:latest` | running | non (latest) | false | stateful | NON | — |
 | g9 | `gitea` | gitea / gitea | `gitea/gitea:1.27.3` | running | oui | false | stateful | oui | git.folzocorp.fr |
 | g9 | `gitea-db` | gitea / gitea-db | `postgres:16` | running | oui | false | stateful | oui | — |
 | g9 | `jellyfin` | jellyfin / jellyfin | `jellyfin/jellyfin:10.9` | running | oui | false | stateful | oui | media.folzocorp.fr |
 | g9 | `n8n` | g9-queue / n8n | `docker.n8n.io/n8nio/n8n:latest` | running | non (latest) | false | stateful | NON | n8n.folzocorp.fr |
 | g9 | `nextcloud` | nextcloud / nextcloud | `nextcloud:35.0.1` | running | oui | false | stateful | oui | cloud.folzocorp.fr |
 | g9 | `nextcloud_db` | nextcloud / db | `mariadb:10.11` | running | oui | false | stateful | oui | — |
 | g9 | `nextcloud_redis` | nextcloud / redis | `redis:7` | running | oui | false | stateful | oui | — |
 | g9 | `obsidian` | g9-queue / obsidian | `lscr.io/linuxserver/obsidian:latest` | running | non (latest) | false | stateful | NON | — |
 | g9 | `photoprism` | photoprism / photoprism | `photoprism/photoprism:260919` | running | oui | false | stateful | oui | photos.folzocorp.fr |
 | g9 | `photoprism_db` | photoprism / db | `mariadb:10.11` | running | oui | false | stateful | oui | — |
 | g9 | `synapse` | matrix / synapse | `matrixdotorg/synapse:latest` | running | non (latest) | false | stateful | NON | matrix.folzocorp.fr |
 | g9 | `valheim` | compose / valheim | `valheim-pterodactyl:1` | running | oui | false | stateful | NON | — |
 | g9 | `vaultwarden` | vaultwarden / vaultwarden | `vaultwarden/server:1.37.4` | running | oui | false | stateful | oui | pass.folzocorp.fr |
 | g9 | `watchtower` | g9-queue / watchtower | `45b54f6dc152` | running | oui (digest) | true | stateless | NON | — |
 | j5040 | `adguard` | adguard / adguard | `aba9e3bf0613` | running | oui (digest) | true | stateless | oui | — |
 | j5040 | `caddy` | edge-j5040 / caddy | `502996b5b60a` | running | oui (digest) | true | stateless | oui | — |
 | j5040 | `sweet_feynman` | - / - | `437a490f7afc` | running | oui (digest) | ABSENT | stateless | NON | — |
 ## Constats automatiques (détection de dérive)
 - g9/valheim: conteneur réel non déclaré dans le kit (compose)
 - g9/n8n: image non épinglée (docker.n8n.io/n8nio/n8n:latest) — S11.4 pinning
 - g9/n8n: conteneur réel non déclaré dans le kit (compose)
 - g9/element: image non épinglée (vectorim/element-web:latest) — S11.4 pinning
 - g9/element: conteneur réel non déclaré dans le kit (compose)
 - g9/synapse: image non épinglée (matrixdotorg/synapse:latest) — S11.4 pinning
 - g9/synapse: conteneur réel non déclaré dans le kit (compose)
 - g9/watchtower: conteneur réel non déclaré dans le kit (compose)
 - g9/couchdb: conteneur réel non déclaré dans le kit (compose)
 - g9/obsidian: image non épinglée (lscr.io/linuxserver/obsidian:latest) — S11.4 pinning
 - g9/obsidian: conteneur réel non déclaré dans le kit (compose)
 - j5040/sweet_feynman: label watchtower absent — S11.4 sélectivité
 - j5040/sweet_feynman: conteneur réel non déclaré dans le kit (compose)
 ## Utiliser ce fichier
 - `./11-registry.sh` : régénère (à lancer après chaque déploiement / MAJ d'image).
 - `./11-registry.sh --check --alert` : régénère, compare à la version commitée, **alerte en payload JSON**
  si le réel a dérivé du registre (label perdu, image non épinglée, conteneur hors kit, état ≠ running).
 - Un `git diff` sur ce fichier est, par construction, la détection de dérive.
@@ -0,0 +1,87 @@
 # REGISTRE-IDENTITES — moitié humaine (comptes, reset, responsables, break-glass)
 > **Règle** : ce fichier ne contient **aucun secret**. Il dit **quel compte** sert sur quelle brique,
 > **qui en est responsable**, **où vit le secret** (référence d'entrée du coffre) et **comment on réinitialise**.
 > Les secrets vivent dans **Vaultwarden** (`db.sqlite3` du G9, déjà dans les snapshots restic).
 > La moitié technique (briques, images épinglées, labels Watchtower, endpoints, état) est **générée**
 > par `scripts/11-registry.sh` dans `REGISTRE-BRIQUES.md` — ne pas la dupliquer ici.
 >
 > Périmètre (T-A.10) : **.24 (G9)** et **.27 (J5040)**. Le xpenology **.25 est hors périmètre** :
 > inventaire dans `INVENTAIRE-STATEFUL.md`, briques **à mourir en Phase 6**.
 >
 > Source des faits : `journal.md` (lignes Phase 4, 2026-10-11) + `PHASE4-RECOLLEMENT.md` §0.
 ## 1. Convention du coffre (T-A.3)
 | Portée | Chemat d'entrée Vaultwarden | Exemples |
 |---|---|---|
 | Infra / services | `infra/<brique>/<compte>` | `infra/gitea/g9ops`, `infra/n8n/api`, `infra/synapse/admin` |
 | Adultes | `famille/<pseudo>/<brique>` | `famille/effi/nextcloud`, `famille/effi/matrix` |
 | Enfants | `enfants/<pseudo>/<brique>` (coffre des parents) | `enfants/lea/jellyfin` |
 Structure du coffre (décision 12/10, coffre **unique** Vaultwarden pour les 6) :
 - organisation `Famille` = 2 adultes (secrets partagés : wifi, DAV, comptes communs) ;
 - organisation `Enfants` = 16 et 13 ans : coffre propre + **emergency access** vers les parents ;
 - 10 et 9 ans : **pas de coffre**, identifiants tenus par les parents sous `enfants/<pseudo>/` ;
 - `ADMIN_TOKEN` (console Vaultwarden) : consigné + copie hors-ligne (voir `PARTAGE-SECRET-MAITRE.md`).
 Comptes d'automatisation : préfixe de rôle, jamais un prénom humain → `ops-bot` (Matrix),
 `g9ops` (Gitea/Jellyfin), `n8n-bot` (à créer si des workflows doivent pousser des logs).
 ## 2. Registre des comptes (.24 G9)
 | Brique | Compte utilisé | Type | 2FA | Entrée coffre | Réinitialisation (break-glass) | Responsable |
 |---|---|---|---|---|---|---|
 | **Vaultwarden** | 1 utilisateur (coffre) | admin humain | **TOTP actif** (importé de la source, `twofactor enabled=1`) | `infra/vaultwarden/maitre` | `ADMIN_TOKEN` (argon2id) → console `/admin` ; emergency access famille activée (`EMERGENCY_ACCESS_ALLOWED=true`) | moi |
 | **Nextcloud** | 8 utilisateurs importés | humains | par utilisateur (à activer) | `famille/<pseudo>/nextcloud` | `docker exec nextcloud php occ user:set-password <uid>` (ou `occ user:resetpassword`) | moi |
 | **MariaDB** (`nextcloud_db`) | root + utilisateur applicatif | service | — | `infra/nextcloud/db` | `docker exec -it nextcloud_db mariadb -u root -p` (mot de passe dans `secrets/`) | moi |
 | **Redis** (`nextcloud_redis`) | sans mot de passe (LAN/bridge) | service | — | — | aucun compte ; accès = réseau Docker uniquement | moi |
 | **Collabora** | mot de passe console (`secrets/collabora.env`, `env_file`) | service | — | `infra/collabora/console` | régénérer `secrets/collabora.env` (600) + restart conteneur | moi |
 | **Gitea** | `master`, `antoine`, `folzo` (importés, **`must_change_password`**), `g9ops` (admin, token API `ops-phase4`) | humains + service | à activer sur le compte principal | `infra/gitea/g9ops`, `infra/gitea/token-ops` | `docker exec -u git gitea /usr/local/bin/gitea admin user create\|change-password …` | moi |
 | **Postgres** (`gitea-db`) | utilisateur applicatif | service | — | `infra/gitea/db` | `docker exec -it gitea-db psql -U postgres` | moi |
 | **Jellyfin** | `g9ops` (admin, créé par le wizard) | service/opérateur | — | `infra/jellyfin/g9ops` | API avec `X-Emby-Authorization` ; si `EnableLocalPassword=0` (piège mesuré du wizard) : `UPDATE Users SET EnableLocalPassword=1` en SQLite + restart | moi |
 | **n8n** | **owner = mon compte** (accès perdu puis recréé, journal 10/10 21:12) | admin humain | à activer | `infra/n8n/owner`, `infra/n8n/api` (clé API dédiée) | UI → Settings → Users ; si accès perdu : créer un owner via CLI n8n (`n8n export:users` n'existe pas → passer par la DB Postgres, procédure §4) | moi |
 | **Synapse (Matrix)** | admin (créé via `registration_shared_secret`) + `ops-bot` (token) | admin + service | **TOTP à activer** | `infra/synapse/admin`, `infra/synapse/token-ops-bot` | API admin v2 (`PUT /_synapse/admin/v2/users/<uid>`), token admin via login ; déactivation propre = `POST /_synapse/admin/v1/deactivate/<uid>` | moi |
 | **Element (web)** | — (frontal, pas de compte) | — | — | — | — | moi |
 | **CouchDB / Obsidian** | locaux (stack du second cerveau) | service | — | `infra/couchdb/admin` | `docker exec` + config du compose | moi |
 | **Valheim** | aucun compte (serveur jeu, whitelist par steamid) | — | — | — | `player.list` dans `data/save` | moi |
 | **Watchtower** (G9) | aucun (socket Docker) | service | — | — | retirer le compose | moi |
 | **edge** (Caddy G9) | aucun (443, TLS interne) | service | — | — | retirer le compose (démontage prévu après bascule J5040) | moi |
 ## 3. Registre des comptes (.27 J5040)
 | Brique | Compte utilisé | Type | 2FA | Entrée coffre | Réinitialisation (break-glass) | Responsable |
 |---|---|---|---|---|---|---|
 | **AdGuard Home** | utilisateurs bcrypt repris de la VM Freebox (UI 8081) | admin humain | — | `infra/adguard/ui` | redéfinir le hash bcrypt dans `AdGuardHome.yaml` + restart | moi |
 | **Caddy OVH** (edge) | aucun ; **clé API OVH** (`secrets/ovh.env`, 600, hors git) | service | — | `infra/ovh/api-key` | recréer une clé dans le manager OVH (droits legacy `/domain/zone/folzocorp.fr/*`), révoquer l'ancienne | moi |
 | **WireGuard** | clés (config hors git, 600) | service | — | `infra/wireguard/` | régénérer `wg genkey` + redéclarer un peer | moi |
 | **dnsmasq (DHCP, E3)** | aucun | service | — | — | `dnsmasq --test` puis restart | moi |
 | **Beszel hub** | utilisateur local Beszel | admin humain | — | `infra/beszel/hub` | `docker exec` + reset dans l'UI ; hub = J5040 (décision C-AP5) | moi |
 ## 4. Procédures de récupération (les 4 qui ont déjà fait mal)
 1. **n8n owner perdu** (subi le 10/10) : `docker exec -it n8n sh` → CLI `n8n export:users` n'existe pas ;
   la récupération passe par Postgres : créer un utilisateur (bcrypt) + le lier au rôle owner,
   puis **consigner** l'identifiant dans `infra/n8n/owner` et créer une **clé API dédiée** (Settings → n8n API).
 2. **Gitea `must_change_password`** (subi le 11/10, bloque l'API) : `gitea admin user change-password -u <uid> --password <nouveau>`
   avec `--must-change-password=false`. **Avant** : lister les remotes qui s'en servent
   (`git remote -v` sur les clones, `~/.git-credentials`) → journal + rollback.
 3. **Jellyfin `EnableLocalPassword=0`** (subi le 11/10) : `UPDATE Users SET EnableLocalPassword=1` en SQLite + restart ;
   API = en-tête **`X-Emby-Authorization`** combiné (sinon 400).
 4. **Synapse sans admin** : ajouter `registration_shared_secret` dans `homeserver.yaml` (sudo), restart,
   `docker exec <synapse> register_new_matrix_user -a -u <admin>`, **retirer** le secret, restart.
 ## 5. Hygiène des secrets (T-A.5)
 | Constat | Action |
 |---|---|
 | `~/.git-credentials` (600) + `credential.helper store` = **token en clair** sur la machine de pilotage | remplacer par un **token dédié** (scopes minima, nommé, révocable) consigné dans `infra/gitea/token-pilot`, helper non persistant en clair (SSH pour `git push`, ou `credential.helper cache`) |
 | Secrets Docker (`secrets/*.env`, 600/644 root) | restent **hors git** (`.gitignore` : `*.env`, `*.cred`, `*.key`, `repo.key`, `matrix.env`) ; **contrôle** : `git ls-files` = 0 fichier de secret, `git grep` des valeurs = 0 |
 | Token Matrix `ops-bot` | vit dans `/etc/restic/matrix.env` (600 root) ; jamais dans un script, jamais affiché |
 | Clé API OVH | `secrets/ovh.env` (600, hors git) ; révocation dans le manager = procédure de rollback |
 ## 6. Ce que le registre ne remplace pas
 Le registre dit **qui** et **comment**. Il ne donne **pas** le login unique (c'est la tâche
 `IDENTITÉ UNIQUE — Authelia`), et ne supprime pas le besoin de coffre (c'est Vaultwarden).
 Tant que l'IdP n'est pas posé, **chaque brique garde son compte local** : c'est voulu (break-glass).
@@ -0,0 +1,72 @@
 # RESTORE-NAS-USB — lire les disques du xpenology hors boîtier (T6.5)
 > Décision 12/10 : le xpenology est **arrêté et débranché, disques conservés intacts**.
 > Ce document rend cette promesse **exécutable**. Il est écrit avant la Phase 6 ; le **test**
 > (1 fichier restauré) est un critère de la Phase 6.
 ## 1. Ce qu'il faut savoir avant de brancher quoi que ce soit
 | Point | Réalité mesurée (journal/`INVENTAIRE-STATEFUL.md`) |
 |---|---|
 | Les volumes DSM ne sont **pas** des partitions lisibles telles quelles | DSM = **md (RAID)** + **LVM** + ext4/btrfs. Un disque seul monté directement = illisible. |
 | Les partages vus dans la GUI sont des **vues** | Exemple mesuré 11/10 : `/volume1/docker-REC` est une **vue multi-volumes** du partage « docker-REC » ; la vérité terrain est `docker inspect` → `nextcloud_app` → **`/volume2/docker-REC/NextCloud/{data,config}`**, `vaultwarden-server-1` → `/volume1/docker/vaultwarden`. |
 | Ordre des disques | Un RAID DSM se reconstitue **sans** respecter l'ordre affiché, mais **tous** les disques du même md doivent être présents. |
 | Chiffrement | Les volumes du NAS ne sont **pas** chiffrés LUKS (le LUKS est la décision G9/backup). |
 ## 2. Matériel
 - boîtier/USB-SATA **un disque à la fois** (ou dock multi-baies), **pas** de branchement sur le contrôleur interne ;
 - machine de lecture = **machine de confiance** (le pilot .11), en **lecture seule** ;
 - aucun disque du NAS branché sur le G9 en production (risque de montage automatique / `fstab`).
 ## 3. Procédure (lecture seule, par disque groupé)
 ```bash
 # 0) identifier les disques (ne rien monter)
 lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT
 sudo blkid
 # 1) repérer les membres md (meta-data DSM en fin de partition)
 sudo mdadm --examine /dev/sdX1 /dev/sdY1 /dev/sdZ1     # tous les disques du même volume
 #   -> noter la « Raid UUID » et le nom du md (ex /dev/md2 = volume 1 DSM)
 # 2) assembler le md en lecture seule (mdadm assemble, pas create)
 sudo mdadm --assemble --force /dev/md-X /dev/sdX1 /dev/sdY1 /dev/sdZ1
 # 3) LVM au-dessus du md
 sudo pvscan ; sudo vgscan ; sudo lvscan
 sudo vgchange -ay -f            # activation en lecture seule si possible
 sudo lvscan
 # 4) monter EN LECTURE SEULE uniquement
 sudo mount -o ro,norecovery /dev/<vg>/<lv> /mnt/nas-ro
 ls -la /mnt/nas-ro              # doit montrer les partages DSM (docker/, photo/, …)
 ```
 ## 4. Ce qu'on vérifie (critère de test, Phase 6)
 | Contrôle | Preuve attendue |
 |---|---|
 | md assemblé | `mdadm --detail /dev/md-X` = `State : clean`, nb disques = attendu |
 | LVM actif | `lvs` liste les LV du volume |
 | Montage RO | `mount | grep nas-ro` contient `ro` |
 | 1 fichier restauré | un fichier de test (photo + sha256 connu) copié hors du montage → `sha256sum` identique à la référence |
 | Démontage propre | `umount` + `vgchange -an` + `mdadm --stop` |
 ## 5. Interdits (écrits, à respecter)
 - **jamais** `mdadm --create`, `pvcreate`, `vgcreate`, `mkfs`, `fdisk`, `parted -l` en écriture, `dd`, `wipefs` ;
 - **jamais** de montage en lecture/écriture ;
 - **jamais** de `fsck` sur un volume du NAS (peut aggraver un souci) ;
 - si `mdadm --assemble` échoue : **s'arrêter**, journaliser, ne pas insister (les données sont
  aussi dans les snapshots restic du G9 pour ce qui a été migré).
 ## 6. Rollback
 Aucun : la procédure est purement lecture. Le seul état créé = des points de montage et des
 périphériques md temporaires, tous démontables (`umount`, `vgchange -an`, `mdadm --stop`).
 ## 7. Statut
 - [x] procédure écrite (ce fichier)
 - [ ] **test réalisé** (1 fichier restauré, journalisé en Phase 6) — *non fait à ce jour*
@@ -0,0 +1,43 @@
 # RUNBOOK — Digest quotidien & chaîne d'alerte
 > Le digest remplace le bruit : **1 message par jour** (briques OK/KO, versions épinglées, dernier
 > backup, MAJ Watchtower) au lieu de N alertes. Les alertes immédiates restent réservées aux KO `high`.
 ## Chaîne
 ```
 12-probes.sh (cron root G9, */15)
   └─ KO → payload JSON → g9-notify.py → salon ops (Synapse .24:8008)
 12-probes.sh --digest (cron root G9, 08:30)
   └─ 1 message récapitulatif
 11-registry.sh --check --alert (machine de pilotage)
   └─ dérive registre/réel → même payload JSON
 Beszel (hub J5040) ────────────────► métriques + état conteneurs (ne remplace pas les sondes)
 restic-notify.sh (cron root G9) ───► backup OK/KO (prose, déjà en place)
 ```
 ## Contrôles
 | Contrôle | Commande (G9, root) | Attendu |
 |---|---|---|
 | Passe de sondes | `/usr/local/bin/g9-probes.sh` | `13 OK / 0 KO` |
 | Provocation non destructive | `/usr/local/bin/g9-probes.sh --selftest` | `NOTIFY_OK 200` |
 | Conformité des payloads | `/usr/local/bin/g9-verify-alert.py 20` | `payloads JSON conformes: N`, `VERIFY_OK` |
 | Digest | `/usr/local/bin/g9-probes.sh --digest` | 1 message `source=digest` |
 | Cron | `sudo crontab -l \| grep -c g9-probes` | `2` |
 ## Symptômes → action
 | Symptôme | Diagnostic | Action | Rollback |
 |---|---|---|---|
 | Plus aucune alerte | `sudo crontab -l`, `/var/lib/g9-probes` | `./12-probes.sh --install` (idempotent) | `--uninstall` |
 | `NOTIFY_KO HTTPError` | `sudo python3 /usr/local/bin/g9-verify-alert.py 5` (401 → token) | régénérer le token `ops-bot`, réécrire `/etc/restic/matrix.env` (600) | restaurer la copie datée du fichier |
 | Alerte répétée chaque sonde | seuil anti-bruit (1 h) + sévérité | remonter la sévérité à `medium` si c'est structurel (ex. endpoint LAN-only) | rétrograder |
 | Digest absent | logs cron, `date`/TZ | relancer `--digest` manuellement | aucun |
 | G9 éteint (sinistre) | Beszel hub sur **J5040** doit alerter quand même | c'est le critère C-AP5 : le monitoring ne vit pas sur la machine surveillée | — |
 ## Ce que le digest ne dit pas (volontairement)
 Pas de métriques fines (Beszel), pas de logs (aller voir `docker logs`), pas de propositions
 d'action : les actions sont dans les `RUNBOOKS/`, et l'autonomie de l'assistante IA est bornée
 par **G11** (paliers).
@@ -0,0 +1,23 @@
 # RUNBOOK — Jellyfin (+ stack *arr/qBittorrent sur .25 pour l'instant)
 > Brique stateful, image épinglée `jellyfin/jellyfin:10.9`. Média servi par **référence**
 > (`/mnt/usb-media` → `/media:ro`, **aucune copie**). Port 8096 LAN-only, `media.folzocorp.fr` via Caddy.
 ## Sonde
 `GET :8096/System/Info/Public` (200 — `/system/info` normal renvoie 401 sans jeton : ne pas s'en servir).
 ## Symptômes → diagnostic → action
 | Symptôme | Diagnostic (lecture seule) | Action | Rollback |
 |---|---|---|---|
 | « Invalid username or password » | `docker exec jellyfin sqlite3 /config/jellyfin.db "SELECT Username,EnableLocalPassword FROM Users;"` | **piège mesuré du wizard** : `EnableLocalPassword=0` → `UPDATE Users SET EnableLocalPassword=1` + restart du conteneur | `UPDATE Users SET EnableLocalPassword=0` |
 | API répond 400 « Value cannot be null » | appel sans en-tête | en-tête **combiné** `X-Emby-Authorization: Emby …` obligatoire (mesuré) | aucun |
 | Médiathèque vide | `GET /Library/VirtualFolders` + `ls /media/films` | supprimer les médiathèques vides doublons (`DELETE /Library/VirtualFolders?name=`) puis recréer sur `/media/…` | recréer la folder |
 | Média non listé après branchement USB | `mount | grep usb-media`, `06c-postboot-check.sh` | remonter (fstab) puis « Scan média library » | démonter |
 | Accès WAN KO | `curl -kI https://media.folzocorp.fr/` | côté J5040 : `docker logs caddy` ; vérifier ufw `ALLOW IN 8096 from 192.168.1.0/24` | retirer la règle ajoutée |
 ## Comptes
 `g9ops` = opérateur (créé par le wizard). Les comptes enfants (tâche SORTIE DE GOOGLE) :
 rôles limités + restrictions de contenu, jamais le compte opérateur.
@@ -0,0 +1,25 @@
 # RUNBOOK — Matrix (Synapse + Element)
 > Brique stateful (base de messages). Image `matrixdotorg/synapse:latest` → **non épinglée**,
 > signalé par `./11-registry.sh` (à corriger lors de la prochaine MAJ : épingler par digest).
 > Usage décidé 12/10 : **complément du foyer** (salon famille + salon ops + Effi), pas de remplacement de WhatsApp.
 ## Sonde
 `GET :8008/_matrix/client/versions` (200) ; Element `GET :8009/` (200) ; le salon ops reçoit les alertes.
 ## Symptômes → diagnostic → action
 | Symptôme | Diagnostic (lecture seule) | Action | Rollback |
 |---|---|---|---|
 | Pas de compte admin | login admin → 403 | ajouter `registration_shared_secret` (sudo, `homeserver.yaml`) → restart → `docker exec <synapse> register_new_matrix_user -a -u <admin>` → **retirer** le secret → restart | retirer la ligne + restart |
 | Création de compte refusée | `PUT /_synapse/admin/v2/users/@<uid>:192.168.1.24` (token admin) | créer avec `admin:false` ; inscription publique reste **coupée** (voulu) | `POST /_synapse/admin/v1/deactivate/<uid>` (conserve la trace) |
 | Alerte non reçue dans le salon | `sudo python3 /usr/local/bin/g9-verify-alert.py 20` ; `sudo bash /usr/local/bin/g9-probes.sh --selftest` | token/room dans `/etc/restic/matrix.env` (600) → régénérer le token `ops-bot` si révoqué | restaurer `/etc/restic/matrix.env` (backup daté) |
 | E2E illisible sur un appareil | session/device inconnu | phrase de récupération E2E **notée sur papier** (procédure B) ; vérifier les devices via API admin | aucun (clé perdue = session perdue, d'où le papier) |
 | Fused de logs / disque | `du -sh /data/*` + logs Synapse | purge via `synapse_stitch_schemas`/`purge` documenté **après** backup | restauration restic |
 | TLS/ACME KO (matrix.folzocorp.fr) | `curl -kI https://matrix.folzocorp.fr/` | côté J5040 : `docker logs caddy --tail 30` + clé API OVH valide (`secrets/ovh.env`) | révoquer/recréer la clé OVH |
 ## Garde-fous
 - Comptes famille : `admin:false`, 2FA sur les comptes admin.
 - Suppression de compte = **désactivation** (propre), jamais purge destructive sans backup (G2/G3).
@@ -0,0 +1,27 @@
 # RUNBOOK — Nextcloud (+ MariaDB, Redis, Collabora)
 > Brique stateful : **exclue de Watchtower**, MAJ manuelle (S11.5). Image épinglée `nextcloud:35.0.1`.
 > Incident de référence : 06/10/2026 — Watchtower non sélectif → migration de schéma interrompue →
 > **maintenance mode 503 alors que le conteneur était up** (leçon : `up ≠ utilisable`).
 ## Sonde
 `./12-probes.sh` : `GET :8080/index.php/login` (2xx) + `occ status` doit contenir `installed: true`.
 ## Symptômes → diagnostic → action
 | Symptôme | Diagnostic (lecture seule) | Action | Rollback |
 |---|---|---|---|
 | 503 / « Maintenance mode » | `docker exec nextcloud php occ status` → `maintenance: true` | backup en place (G2) puis `php occ maintenance:mode --off` ; si schéma inachevé → restaurer la base depuis restic | remettre `maintenance:mode --on` |
 | Écran blanc / erreurs DB | `docker logs nextcloud --tail 50` ; `docker inspect nextcloud_db` (state) | relancer `nextcloud_db` puis `nextcloud` ; vérifier `secrets/dbpass` | `compose down` + `up -d` depuis le compose versionné |
 | Fichiers disparus de la liste | `php occ files:scan --all` (compter, 0 erreur) | scan complet (long, pas de suppression de données) | aucun (scan = lecture/écriture du filecache) |
 | Collabora « office indisponible » | `curl -s http://127.0.0.1:9980/hosting/discovery` (200) ; `php occ config:app:get richdocuments wopi_url` | discovery KO → relancer collabora ; wopi_url KO → `config:app:set richdocuments wopi_url --value=http://127.0.0.1:9980` | `occ config:app:set` avec l'ancienne valeur |
 | Redirect en http / boucle de login | `curl -kI https://cloud.folzocorp.fr/` + `php occ config:system:get overwritehost` | aligner `g9-double-run.config.php` (`overwritehost`, `overwriteprotocol=https`, `trusted_proxies`) : source de vérité du kit, monté `:ro` | retirer le fichier monté |
 | Login KO après import | `php occ user:list` (8 users attendus) | reset ciblé : `php occ user:set-password <uid>` | aucun (mot de passe consigné dans le coffre) |
 ## MAJ manuelle (procédure S11.5, jamais par Watchtower)
 1. `restic daily` récent vérifié (`restic snapshots`) — **pas de MAJ stateful sans backup**.
 2. Épingler la version cible dans le compose (pas de `:latest`), commit dans Gitea.
 3. `docker compose up -d` → `php occ upgrade` → `php occ status` (`installed: true`, `maintenance: false`).
 4. `./12-probes.sh` + `./11-registry.sh` (le registre doit rester propre).
@@ -0,0 +1,29 @@
 # RUNBOOK — PhotoPrism (+ MariaDB `photoprism_db`)
 > Brique stateful, image épinglée `photoprism/photoprism:260919`. Photothèque **copiée** depuis
 > `/volume1/photo` (433 941 fichiers / 567 Go, manifeste 0 écart, échantillon sha256 200/200) ;
 > index progressif. Source .25 **jamais modifiée** (G4, lecture seule).
 ## Sonde
 `GET :2342/` (200, suivre la redirection). Endpoint prévu : **`prisme.folzocorp.fr`**
 (`photos.folzocorp.fr` = Synology Photos, temporaire, meurt en Phase 6).
 ## Symptômes → diagnostic → action
 | Symptôme | Diagnostic (lecture seule) | Action | Rollback |
 |---|---|---|---|
 | UI 502 via le domaine | `curl -s http://127.0.0.1:2342/` puis `docker logs caddy` (J5040) | la route Caddy pointe le bon port (2342) ; ajouter/aligner le site `prisme.folzocorp.fr` | retirer la route Caddy |
 | Index bloqué / RAM | `docker stats --no-stream` (budget S2.4 : ~2-3 Go) | réduire la parallélisation d'indexation, relancer l'index ; ne pas toucher à la copie | aucun |
 | Photos manquantes dans l'UI | comparer le manifeste : `find /data/photos -type f \| wc -l` vs manifeste source | relancer l'index sur le lot manquant ; **ne jamais supprimer depuis l'UI** (la copie est la copie, la source .25 est la vérité tant que Phase 6 n'est pas validée) | aucun |
 | Base DB KO | `docker inspect photoprism_db`, logs | `compose up -d` depuis le compose versionné ; si corrompue → restaurer **la base** depuis restic (pas les photos) | restauration restic |
 | Auto-upload Android ne monte pas | app : statut d'upload + journal | vérifier compte/URL (`https://prisme.folzocorp.fr`), stockage Android, batterie optimisée | aucun |
 ## Preuve de restauration
 `./10-verify-restore-photo.sh` (snapshot restic → sha256 comparé à la source .25) — critère 3, déjà prouvé 12/10.
 ## Interdits
 Pas de suppression de photos depuis l'UI avant la fin du double-run ; pas de `rm` sur `/data/photos`
 sans backup vérifié (G2) ; pas de wipe du .25 (décision 12/10 : débrancher, disques intacts).
@@ -0,0 +1,29 @@
 # RUNBOOK — Registre & dérive (registre, watchtower, edge)
 > Le registre est **généré** : `./11-registry.sh` (lecture seule : `docker ps` + `docker inspect`
 > sur .24/.27 + compose du kit + Caddyfile). Un `git diff` sur `REGISTRE-BRIQUES.md` **est** la
 > détection de dérive.
 ## Contrôles
 | Contrôle | Commande | Attendu |
 |---|---|---|
 | Régénération | `./11-registry.sh` | rc=0, table complète |
 | Dérive + alerte | `./11-registry.sh --check --alert` | rc=0 si propre ; rc=1 + `NOTIFY_OK 200` si dérive |
 | Scope Watchtower | `docker run --rm -v /var/run/docker.sock:ro <watchtower@digest> --label-enable --monitor-only -R` | `scanned=2` (edge + watchtower), les stateful ignorés |
 | Labels stateful | `docker inspect -f '{{.Name}} {{index .Config.Labels "com.centurylinklabs.watchtower.enable"}}' $(docker ps -q)` | `false` partout sauf edge/watchtower |
 | Images non épinglées | section « Constats automatiques » du registre | 0 ligne `image non épinglée` |
 ## Symptômes → action
 | Constat | Action | Rollback |
 |---|---|---|
 | `label watchtower absent` sur un stateful | poser le label via le compose (source de vérité) + `compose up -d` ; conteneurs pilotés hors compose = `docker update --label-add` (indisponible sur docker 24.0.2 DSM → clonage via API socket, procédure journalisée 10/10) | restaurer le compose `.bak` |
 | `image non épinglée (:latest)` | épingler la version courante dans le compose, commit, `compose up -d` | revenir au compose précédent |
 | `conteneur réel non déclaré dans le kit` | écrire le compose correspondant (c'est la production : tout dans git) | supprimer le conteneur **après** validation utilisateur (G3) |
 | `edge` (Caddy G9) déclassé par le J5040 | garder tant que la bascule bridge n'est pas faite ; le retirer ensuite + retirer les règles ufw 443/80 du G9 | `ufw allow 443` + `compose up -d` |
 ## Anti-bruit
 Une alerte par brique et par heure maximum (état dans `/var/lib/g9-probes`). Le digest quotidien
 (08:30) porte l'état complet ; les alertes immédiates sont réservées aux KO `high`.
@@ -0,0 +1,27 @@
 # RUNBOOK — Vaultwarden (coffre famille, brique la plus critique)
 > Brique stateful, image épinglée `vaultwarden/server:1.37.4`. Coffre = `db.sqlite3` (8.8 Mo,
 > 953 ciphers, 1 user), **déjà dans les snapshots restic**. 2FA TOTP actif (importé de la source).
 > Console admin : `ADMIN_TOKEN` **haché argon2id**. `EMERGENCY_ACCESS_ALLOWED=true`, `INVITATIONS_ALLOWED=true`.
 > **Règle durable** : le coffre ne doit pas dépendre d'une brique qu'il protège → il ne vit pas dans Nextcloud.
 ## Sonde
 `GET :8081/alive` (200). WebVault = `GET :8081/` (200).
 ## Symptômes → diagnostic → action
 | Symptôme | Diagnostic (lecture seule) | Action | Rollback |
 |---|---|---|---|
 | `/alive` KO | `docker logs vaultwarden --tail 30` | `docker compose up -d` depuis le compose versionné | `compose down` |
 | Login admin refusé | `POST /admin/register` (token) | token = entrée `infra/vaultwarden/admin-token` ; si perdu : régénérer un hash argon2id (`python3-argon2`, preset bitwarden) dans `secrets/admin` (600) + restart | restaurer `secrets/admin` + restart |
 | Utilisateur bloqué (2FA) | table `twofactor` (`atype`, `enabled`, `last_used`) | **ne pas réinitialiser le TOTP à l'aveugle** : l'app d'authentification de l'utilisateur continue de marcher tant que la graine n'est pas régénérée | restaurer la ligne `twofactor` depuis backup |
 | Coffre corrompu | `sqlite3 db.sqlite3 "PRAGMA integrity_check;"` (après **copy** du fichier) | restaurer `db.sqlite3` depuis restic ; **jamais** d'écriture directe sur la base en service | aucun |
 | Emergency access à activer | UI admin → Emergency | créer la demande parent → enfant (16/13), valider côté enfant | supprimer la demande |
 | Clients Bitwarden KO (ados) | `curl -kI https://pass.folzocorp.fr/` | DOMAIN conservé = `pass.folzocorp.fr` (les clients existants restent valides) — vérifier la route Caddy | aucun |
 ## Interdits
 - Jamais de `rm` sur `/data/docker/vaultwarden` sans backup vérifié (G2) — c'est le coffre des 6.
 - Jamais le mot de passe maître dans un fichier, un commit, un log (G9).
 - La récupération en l'absence de l'opérateur passe par `PARTAGE-SECRET-MAITRE.md`, pas par l'admin console.
@@ -124,3 +124,10 @@
 | 2026-10-12 14:17 | 4 | migrate:photoprism : intégration PhotoPrism | copie de 530 Go à vérifier avant indexation | manifeste chemins+tailles identique (433941 fichiers, 567394182751 o) + échantillon sha256 200/200 | re-copie ciblée via tar/ssh |
 | 2026-10-12 14:18 | 4 | migrate:photoprism : stack PhotoPrism déployée + indexation lancée | T4.3 : stack saine, index progressif (photothèque 530 Go sur le G9) | image épinglée 260919, MariaDB 10.11 (watchtower OFF), secrets via env_file 600, port 2342 LAN ; originals = copie locale | docker compose down + rm -rf /data/docker/photoprism |
 | 2026-10-12 15:07 | 4 | test restauration photo depuis restic | Critère 3 : preuve restore du snapshot incluant les photos | snapshot 06a7e3b89ef3e97d5f5c1dc9098496fab8ad79d48f4455eabdde07255143e33b contient 505836 entrées sous /data/docker/photoprism/originals ; restore 1 fichier ; sha256 restauré == source .25 (00cbfed8da81…) ; chiffrement maintenu (clé locale G9) | rm -rf /tmp/restore-photo-test (fait) |
 | 2026-10-12 14:17 | 4.5 | registre : `11-registry.sh` génère la moitié technique | T-A.1 : inventaire **généré** (pas de saisie manuelle) | `REGISTRE-BRIQUES.md` : **21 conteneurs** (.24+.27), endpoints Caddy mappés, images/labels lus par `docker ps`/`inspect` en **lecture seule** ; **13 constats** réels (4 images `:latest` non épinglées : n8n, element, synapse, obsidian ; 6 conteneurs non déclarés dans le kit : n8n, element, synapse, couchdb, obsidian, valheim ; 1 conteneur inconnu `sweet_feynman` .27 **sans label Watchtower**) | `git rm REGISTRE-BRIQUES.md scripts/11-registry.sh scripts/registry_*.py` (aucun effet sur les briques) |
 | 2026-10-12 14:27 | 4.5 | sondes applicatives : `12-probes.sh` installé sur le G9 (cron root) | T-C.1/C.2/C.5 : le trou mesuré est `up ≠ utilisable` (5 incidents de la semaine avec conteneur up) | install `/usr/local/bin/g9-probes.sh` + **2 lignes cron** (`*/15` + digest 08:30) ; passe = **13 OK / 0 KO** (nextcloud login + `occ status`, vaultwarden /alive, gitea /api/v1/version, jellyfin /System/Info/Public, photoprism /, collabora discovery, n8n healthz, synapse versions, element, edge TCP 443, cloud WAN 200, AdGuard UI) ; **`--selftest` → `NOTIFY_OK 200`** (KO provoqué sans toucher aucune brique) ; `g9-verify-alert.py 20` → **payloads JSON conformes: 1 / non conformes: 0, VERIFY_OK** | `sudo bash /usr/local/bin/g9-probes.sh --uninstall` (cron retiré, script + état supprimés) |
 | 2026-10-12 14:40 | 4.5 | docs identité : `REGISTRE-IDENTITES.md` (moitié humaine) | T-A.2/A.3/A.4/A.8/A.9/A.11 : « quel compte a servi ? » | table par brique (.24 + .27) : compte, type, 2FA, **référence** d'entrée coffre, **comment réinitialiser**, responsable + 4 procédures de récupération (n8n owner, Gitea must_change_password, Jellyfin EnableLocalPassword, Synapse sans admin) + convention coffre `infra/`/`famille/`/`enfants/` + hygiène (`~/.git-credentials` en clair traité en T-A.5) ; **0 secret** (références seules) | `git rm REGISTRE-IDENTITES.md` |
 | 2026-10-12 14:45 | 4.5 | docs : `RUNBOOKS/` ×7, `PARTAGE-SECRET-MAITRE.md`, `RESTORE-NAS-USB.md` | T-C.3 (runbooks = matière première de l'IA, G11) + T-A.9 + T6.5 | 7 runbooks (nextcloud, matrix, jellyfin, photoprism, vaultwarden, registre, digest) sur les **pièges mesurés** du journal ; procédure de partage du secret maître (détenteurs à nommer, enveloppe, test annuel — **test non réalisé**) ; procédure lecture disques DSM hors boîtier (mdadm/LVM, **lecture seule**, interdits — **test non réalisé**, critère Phase 6) | `git rm -r RUNBOOKS PARTAGE-SECRET-MAITRE.md RESTORE-NAS-USB.md` |
 | 2026-10-12 14:50 | 4.5 | études : `EXPOSITION-INTERNET.md` + `BRIDGE-WHATSAPP.md` | T-D (étude, 0 règle) + T-W (étude, 0 install) | exposition **mesurée** (`ufw status numbered` .24/.27, `ss -ltnu` .27) : constats — **22/tcp et 443/tcp ouverts au WAN sur le G9 sans nécessité**, edge G9 en TLS auto-signé, Tailscale actif sur le pilot (voie non documentée), CouchDB 5984 LAN sans auth ; grille par brique + playbook classé 8 rangs + **5 décisions à rendre** ; **0 règle posée**. Pont WhatsApp : AGPL-3.0, session QR/12 jours, **risque de bannissement** → numéro familial interdit, **0 installation** | `git rm EXPOSITION-INTERNET.md BRIDGE-WHATSAPP.md` (aucun changement réseau) |
 | 2026-10-12 14:55 | 4.5 | `08-decommission.sh` : **texte aligné** sur son comportement | T-A.6 : l'en-tête annonçait « ARRÊTE et WIPE » + saisie `WIPE XPENOLOGY` alors que le corps fait arrêt + consignes GUI/débranchement (wipe optionnel) | en-tête = « aucun wipe exécuté par le kit », prereq = « éteint et débranché, disques intacts, 0 effacement », confirmation = `ETEINDRE XPENOLOGY`, étape 3 = étiqueter/conserver + pointeur `RESTORE-NAS-USB.md`, journal rollback = « rebrancher (données intactes) ». **Corps du script inchangé** (mêmes commandes, même gates) | `git checkout scripts/08-decommission.sh` |
 | 2026-10-12 15:00 | 4.5 | charte **G11** + docs `DOSSIER-SOFTWARE.md` v1.6 | G11 (paliers IA) + S8/S9.2/S11/S14 alignés sur les décisions 12/10 | README : G11 (L0→L3, portes chiffrées, interdits, traçabilité) + arborescence (11/12/g9-notify/g9-verify-alert/lib-notify) + docs d'identité/observabilité ; S8 = **complément** (plus « remplace WhatsApp »), S9.2 = `pass`/`prisme`/`photos` alignés, S11 = registre + sondes, S14.7→S14.10 (coffre, identité, suivi, IA) | `git checkout DOSSIER-SOFTWARE.md g9-migration/README.md` |
@@ -4,12 +4,16 @@
 #
 # Garde-fous : G3 (destructif — validation explicite), G4 (double-run terminé), G5 (IP .25), G7 (rollback), G8 (journalisation).
 #
-# ⚠️ OPÉRATION DESTRUCTIVE ET IRRÉVERSIBLE (garde-fous G3 + G4) :
+# ⚠️ OPÉRATION IRRÉVERSIBLE CÔTÉ RÉSEAU (garde-fous G3 + G4) :
-#   Ce script ARRÊTE et WIPE le xpenology. Il ne s'exécute QUE si :
+#   Ce script ARRÊTE le xpenology (arrêt des conteneurs + consignes d'arrêt GUI + débranchement).
 #   **AUCUN WIPE n'est exécuté par ce script** — décision utilisateur 12/10 : disques conservés
 #   intacts, récupération documentée dans `RESTORE-NAS-USB.md`. Le wipe physique reste une
 #   décision séparée (réutilisation/vente), hors périmètre du kit.
 #   Il ne s'exécute QUE si :
 #     1. Toutes les briques sont validées sur le G9 (double-run terminé, G4).
 #     2. Le backup 3-2-1 est fonctionnel + restauration testée (G2).
 #     3. L'IP du G9 est passée à .25 (G5).
-#     4. Validation explicite de l'utilisateur (drapeau + saisie du mot de passe).
+#     4. Validation explicite de l'utilisateur (drapeau + saisie de confirmation).
 #
 # Usage :
 #   sudo ./08-decommission.sh --i-understand
@@ -39,26 +43,28 @@ prereq "Toutes les briques (Vaultwarden, Nextcloud, PhotoPrism, Gitea, n8n, Jell
 prereq "Backup 3-2-1 fonctionnel + restauration testée (données IA incluses)"
 prereq "IP du G9 passée à .25, tous les services résolus et accessibles"
 prereq "Sauvegarde FINALE complète du xpenology effectuée et vérifiée"
-prereq "Je comprends que le xpenology sera WIPÉ (données détruites)"
+prereq "Je comprends que le xpenology sera ÉTEINT et DÉBRANCHÉ, disques conservés intacts (0 effacement)"
 echo
-read -r -p "Saisir 'WIPE XPENOLOGY' pour confirmer la destruction : " CONF
+read -r -p "Saisir 'ETEINDRE XPENOLOGY' pour confirmer l'arrêt et le débranchement : " CONF
-[[ "$CONF" == "WIPE XPENOLOGY" ]] || die "Confirmation non saisie. Abandon."
+[[ "$CONF" == "ETEINDRE XPENOLOGY" ]] || die "Confirmation non saisie. Abandon."
 log "Arrêt des conteneurs + arrêt du système xpenology"
 # L'arrêt propre se fait de préférence via la GUI DSM (arrêt système).
 # En SSH, on arrête les conteneurs puis le système :
 ssh -p 222 Master@"$XP_HOST" "sudo /var/packages/ContainerManager/target/usr/bin/docker stop \$(/var/packages/ContainerManager/target/usr/bin/docker ps -q) 2>/dev/null || true"
-journal "Conteneurs xpenology arrêtés" "Arrêt propre avant wipe (G3)" "docker stop sur tous les conteneurs" "redémarrage du xpenology"
+journal "Conteneurs xpenology arrêtés" "Arrêt propre avant débranchement (G3)" "docker stop sur tous les conteneurs" "redémarrage du xpenology"
 echo
 echo "⚠️  ÉTAPE MANUELLE OBLIGATOIRE :"
 echo "   1. Dans la GUI DSM : arrêter proprement le système."
 echo "   2. Débrancher le xpenology."
-echo "   3. (Optionnel) Wipe physique des disques si réutilisation/vente."
+echo "   3. Étiqueter les disques et les CONSERVER INTACTS (0 effacement — décision 12/10)."
 echo "   4. Récupération ultérieure possible : procédure testée dans RESTORE-NAS-USB.md."
 echo "      (le wipe physique n'est PAS dans le périmètre du kit ; réutilisation/vente = décision séparée)"
 echo
 read -r -p "Une fois le xpenology éteint et débranché, saisir 'DONE' pour journaliser : " FINAL
 [[ "$FINAL" == "DONE" ]] || die "Non confirmé."
-journal "xpenology décommissionné" "G9 = seul cœur famille (G4/G5)" "éteint + débranché, G9 sur .25" "aucun (irréversible) — backup 3-2-1 testé au préalable"
+journal "xpenology éteint et débranché (disques intacts)" "G9 = seul cœur famille (G4/G5)" "éteint + débranché, G9 sur .25, 0 effacement" "rebrancher le xpenology (données intactes) ; backup 3-2-1 testé au préalable"
 log "Terminé. Le G9 est maintenant le seul cœur famille."
@@ -0,0 +1,140 @@
 #!/usr/bin/env bash
 #
 # 11-registry.sh — T-A.1 + T-A.5 : moitié technique du registre, GÉNÉRÉE, + détection de dérive.
 #
 # Lecture seule : `docker ps` / `docker inspect` distants, lecture des compose du kit.
 # Aucun conteneur n'est démarré, arrêté, modifié. Aucun secret n'est lu ni affiché.
 #
 # Modes :
 #   ./11-registry.sh              génère REGISTRE-BRIQUES.md
 #   ./11-registry.sh --check      régénère en mémoire, compare, alerte si dérive (rc=1)
 #   ./11-registry.sh --check --alert   idem + envoie le payload JSON dans le salon ops
 #
 # Sortie : REGISTRE-BRIQUES.md (moitié A, générée — ne pas éditer à la main)
 # La moitié humaine (comptes, reset, responsables) est dans REGISTRE-IDENTITES.md.
 set -euo pipefail
 KIT="$(cd "$(dirname "$0")/.." && pwd)"
 OUT="$KIT/REGISTRE-BRIQUES.md"
 SSH_KEY="${SSH_KEY:-$HOME/.ssh/id_ed25519_openfox11}"
 HOSTS="${HOSTS:-g9:folzo@192.168.1.24 j5040:folzo@192.168.1.27}"
 RESTIC_COVERAGE="${RESTIC_COVERAGE:-g9=restic (sources /data /home/folzo /etc, cron 03:30) ; j5040=non (à couvrir Phase 5)}"
 MODE="generate"
 ALERT=0
 for a in "$@"; do
  if [[ "$a" == "--check" ]]; then MODE="check"; fi
  if [[ "$a" == "--alert" ]]; then ALERT=1; fi
 done
 export SSH_KEY
 TMP="$(mktemp -d)"
 trap 'rm -rf "$TMP"' EXIT
 declared_json="$(python3 "$KIT/scripts/registry_inputs.py" declared)"
 caddy_json="$(python3 "$KIT/scripts/registry_inputs.py" caddy)"
 echo "$caddy_json" > "$TMP/caddy.json"
 rows_all="$TMP/rows.jsonl"
 findings_all="$TMP/findings.txt"
 : > "$rows_all"
 : > "$findings_all"
 for entry in $HOSTS; do
  machine="${entry%%:*}"
  host="${entry#*:}"
  mip="${host#*@}"
  ssh -o ConnectTimeout=8 -o BatchMode=yes -i "$SSH_KEY" "$host" \
    'docker ps -a --format json' > "$TMP/$machine.ps.json" 2>"$TMP/$machine.err" || {
    echo "[registry] SSH/docker indisponible sur $machine ($host)" >&2
    echo "$machine: inaccessible (SSH ou docker)" >> "$findings_all"
    continue
  }
  ssh -o ConnectTimeout=8 -o BatchMode=yes -i "$SSH_KEY" "$host" \
    'docker ps --format "{{.Names}}\t{{.Ports}}"' > "$TMP/$machine.ports.tsv" 2>/dev/null || : > "$TMP/$machine.ports.tsv"
  python3 "$KIT/scripts/registry_inputs.py" endpoints "$TMP/$machine.ports.tsv" "$TMP/caddy.json" "$mip" > "$TMP/$machine.ep.json"
  python3 "$KIT/scripts/registry_parse.py" "$machine" "$(cat "$TMP/$machine.ep.json")" "$declared_json" \
    < "$TMP/$machine.ps.json" > "$TMP/$machine.rows.json" 2>"$TMP/$machine.findings"
  python3 -c 'import json,sys
 for r in json.load(open(sys.argv[1])):
    print(json.dumps(r, ensure_ascii=False))' "$TMP/$machine.rows.json" >> "$rows_all"
  sed -n 's/^#findings# //p' "$TMP/$machine.findings" | python3 -c 'import json,sys
 for line in sys.stdin:
    line=line.strip()
    if line:
        for f in json.loads(line): print(f)' >> "$findings_all"
 done
 nb_conteneurs="$(wc -l < "$rows_all" | tr -d ' ')"
 nb_findings="$(grep -c . "$findings_all" || true)"
 generated="$(python3 - "$rows_all" "$nb_conteneurs" <<'PY'
 import json, sys, datetime
 rows = [json.loads(l) for l in open(sys.argv[1]) if l.strip()]
 ts = datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d %H:%M UTC')
 print(f"<!-- GÉNÉRÉ PAR scripts/11-registry.sh — ne pas éditer à la main. ts={ts} ; {sys.argv[2]} conteneurs -->")
 print()
 print("| Machine | Conteneur | Projet / service (compose) | Image | État | Épinglée | Watchtower | Type | Dans le kit | Endpoint (Caddy) |")
 print("|---|---|---|---|---|---|---|---|---|---|")
 for r in rows:
    print(f"| {r['machine']} | `{r['name']}` | {r['project']} / {r['service']} | `{r['image']}` | {r['state']} | {r['pinned']} | {r['wt']} | {r['stateful']} | {r['kit']} | {r['endpoint'] or '—'} |")
 PY
 )"
 render="$(cat <<EOF
 # REGISTRE-BRIQUES — moitié technique (générée)
 > Source : \`scripts/11-registry.sh\` (\`docker ps\` + \`docker inspect\` en **lecture seule** sur .24 et .27,
 > compose du kit, Caddyfile pour les endpoints). **Ne pas éditer à la main** : la moitié humaine
 > (comptes, 2FA, procédure de réinitialisation, responsable, break-glass) vit dans
 > \`REGISTRE-IDENTITES.md\`.
 >
 > Périmètre (T-A.10) : **.24 (G9) et .27 (J5040) uniquement**. Le xpenology **.25 est hors périmètre** :
 > il est décrit dans \`INVENTAIRE-STATEFUL.md\` et ses briques sont **à mourir en Phase 6**.
 >
 > Couverture backup : $RESTIC_COVERAGE
 $generated
 ## Constats automatiques (détection de dérive)
 $(if [[ -s "$findings_all" ]]; then sed 's/^/- /' "$findings_all"; else echo "- aucun"; fi)
 ## Utiliser ce fichier
 - \`./11-registry.sh\` : régénère (à lancer après chaque déploiement / MAJ d'image).
 - \`./11-registry.sh --check --alert\` : régénère, compare à la version commitée, **alerte en payload JSON**
  si le réel a dérivé du registre (label perdu, image non épinglée, conteneur hors kit, état ≠ running).
 - Un \`git diff\` sur ce fichier est, par construction, la détection de dérive.
 EOF
 )"
 if [[ "$MODE" == "check" ]]; then
  if [[ ! -f "$OUT" ]]; then
    echo "[registry] REGISTRE-BRIQUES.md absent — générer d'abord" >&2
    exit 2
  fi
  base="$(git -C "$KIT" show HEAD:g9-migration/REGISTRE-BRIQUES.md 2>/dev/null || git -C "$KIT" show HEAD:REGISTRE-BRIQUES.md 2>/dev/null || true)"
  body_new="$(printf '%s' "$render" | sed '1,4d')"
  body_old="$(printf '%s' "$base" | sed '1,4d')"
  if [[ -z "$body_old" ]]; then
    echo "[registry] pas de version commitée de comparaison" >&2
    exit 2
  fi
  if [[ "$(printf '%s' "$body_new" | md5sum)" == "$(printf '%s' "$body_old" | md5sum)" ]]; then
    echo "[registry] aucune dérive ($nb_conteneurs conteneurs, $nb_findings constats)"
    exit 0
  fi
  echo "[registry] DÉRIVE détectée :"
  printf '%s\n' "$nb_findings constats"
  if [[ "$ALERT" == "1" ]]; then
    source "$KIT/scripts/lib-notify.sh"
    ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
    payload="$(python3 -c 'import json,sys; print(json.dumps({"ts":sys.argv[1],"source":"10-registry","brique":"registre","host":"g9","check":"registry-drift","http_code":0,"severite":"warn","message":sys.argv[2],"runbook":"RUNBOOKS/registre.md"},ensure_ascii=False))' "$ts" "$nb_conteneurs conteneurs, $nb_findings constats automatiques, diff registre/réel à lire dans REGISTRE-BRIQUES.md")"
    notify_json "$payload"
  fi
  exit 1
 fi
 printf '%s\n' "$render" > "$OUT"
 echo "[registry] $OUT généré : $nb_conteneurs conteneurs, $nb_findings constats automatiques"
@@ -0,0 +1,165 @@
 #!/usr/bin/env bash
 #
 # 12-probes.sh — T-C.1/T-C.2/T-C.5 : sondes APPLICATIVES + alertes JSON + digest.
 #
 # Pourquoi : le trou mesuré est `up ≠ utilisable` (Nextcloud 503 en maintenance, Collabora unhealthy,
 # Jellyfin auth KO, accès n8n perdu, monde Valheim perdu : le conteneur était up dans tous les cas).
 # Beszel répond « le conteneur tourne ». Ici on répond « la fonction répond ».
 #
 # S'exécute SUR LE G9 (root, cron). Lecture seule : HTTP GET + `occ status`. Aucune écriture,
 # aucun conteneur démarré/arrêté.
 #
 # Usage :
 #   ./12-probes.sh                 une passe (imprime les résultats, alerte si KO)
 #   ./12-probes.sh --quiet         une passe sans alerte (usage test)
 #   ./12-probes.sh --digest        digest quotidien (1 message, pas N)
 #   ./12-probes.sh --install       installe /usr/local/bin/g9-probes.sh + cron (*/15 + digest 08:30)
 #   ./12-probes.sh --uninstall     retire le script + les 2 lignes de cron
 #
 # Alertes : payload JSON {ts, source, brique, host, check, http_code, severite, message, runbook}
 # Identifiants Matrix : /etc/restic/matrix.env (600 root, jamais affichés).
 # Anti-bruit : une alerte par brique et par heure max (état dans /var/lib/g9-probes).
 set -euo pipefail
 STATE_DIR="${STATE_DIR:-/var/lib/g9-probes}"
 MATRIX_ENV="${MATRIX_ENV:-/etc/restic/matrix.env}"
 HOST="$(hostname)"
 QUIET=0
 MODE="probe"
 for a in "$@"; do
  if [[ "$a" == "--quiet" ]]; then QUIET=1; fi
  if [[ "$a" == "--digest" ]]; then MODE="digest"; fi
  if [[ "$a" == "--install" ]]; then MODE="install"; fi
  if [[ "$a" == "--selftest" ]]; then MODE="selftest"; fi
  if [[ "$a" == "--uninstall" ]]; then MODE="uninstall"; fi
 done
 case "$MODE" in
  install)
    install -m 755 "$0" /usr/local/bin/g9-probes.sh
    mkdir -p "$STATE_DIR"
    current="$(crontab -l 2>/dev/null || true)"
    printf '%s\n' "$current" | grep -v 'g9-probes.sh' > /tmp/cron.new || true
    cat >> /tmp/cron.new <<'EOF'
 */15 * * * * /usr/local/bin/g9-probes.sh >/dev/null 2>&1
 30 8 * * * /usr/local/bin/g9-probes.sh --digest >/dev/null 2>&1
 EOF
    sed -i '/^$/d' /tmp/cron.new
    crontab /tmp/cron.new
    rm -f /tmp/cron.new
    echo "install OK : /usr/local/bin/g9-probes.sh + 2 lignes cron ($(crontab -l | grep -c 'g9-probes.sh') lignes)"
    exit 0
    ;;
  uninstall)
    crontab -l 2>/dev/null | grep -v 'g9-probes.sh' | crontab - || true
    rm -f /usr/local/bin/g9-probes.sh
    rm -rf "$STATE_DIR"
    echo "uninstall OK (cron retiré, script et état supprimés)"
    exit 0
    ;;
 esac
 mkdir -p "$STATE_DIR"
 notify() {
  local payload="$1"
  if [[ "$QUIET" == "1" ]]; then return 0; fi
  REGISTRY_B64="$(printf '%s' "$payload" | base64 -w0)" python3 /usr/local/bin/g9-notify.py
 }
 alert() {
  local brique="$1" check="$2" code="$3" sev="$4" msg="$5"
  local key ts payload
  key="$(echo "$brique" | tr -c 'a-z0-9' '_')"
  ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
  # anti-bruit : 1 alerte / brique / heure (état séparé des OK)
  if [[ -f "$STATE_DIR/alert-$key" ]] && [[ $(( $(date +%s) - $(stat -c %Y "$STATE_DIR/alert-$key") )) -lt 3600 ]]; then
    echo "KO(ignoré, alerte <1h) $brique $check"
    return 0
  fi
  touch "$STATE_DIR/alert-$key"
  payload="$(python3 -c 'import json,sys; print(json.dumps({"ts":sys.argv[1],"source":"12-probes","brique":sys.argv[2],"host":sys.argv[3],"check":sys.argv[4],"http_code":int(sys.argv[5]) if sys.argv[5].isdigit() else 0,"severite":sys.argv[6],"message":sys.argv[7],"runbook":f"RUNBOOKS/{sys.argv[2]}.md"},ensure_ascii=False))' "$ts" "$brique" "$HOST" "$check" "$code" "$sev" "$msg")"
  echo "KO $brique $check ($code) -> $msg"
  notify "$payload"
 }
 ok() { echo "OK $1 $2"; touch "$STATE_DIR/$(echo "$1" | tr -c 'a-z0-9' '_')"; }
 http_probe() {
  local brique="$1" check="$2" url="$3" expect="$4" sev="${5:-high}"
  local code
  code="$(curl -skL -o /dev/null -w '%{http_code}' -m 10 "$url" 2>/dev/null || true)"
  if [[ -z "$code" ]]; then code="000"; fi
  if [[ "$code" == "$expect" || ( "$expect" == "2xx" && "$code" =~ ^2 ) ]]; then
    ok "$brique" "$check ($code)"
    return 0
  fi
  alert "$brique" "$check" "$code" "$sev" "attendu $expect sur $url"
  return 0
 }
 tcp_probe() {
  local brique="$1" check="$2" host="$3" port="$4"
  if timeout 5 bash -c "</dev/tcp/$host/$port" 2>/dev/null; then
    ok "$brique" "$check"
    return 0
  fi
  alert "$brique" "$check" 0 high "TCP $host:$port refusé/injoignable"
  return 0
 }
 occ_probe() {
  local brique="$1" check="$2" container="$3" grep_for="$4"
  local out
  out="$(docker exec "$container" php occ "$check" 2>/dev/null || true)"
  if printf '%s' "$out" | grep -q "$grep_for"; then
    ok "$brique" "$check"
    return 0
  fi
  alert "$brique" "$check" 0 "high" "occ $check : « $grep_for » absent ($(printf '%s' "$out" | head -c 120))"
  return 1
 }
 run_all() {
  http_probe nextcloud "GET /login" "http://127.0.0.1:8080/index.php/login" 2xx
  occ_probe nextcloud "status" nextcloud "installed: true"
  http_probe vaultwarden "GET /alive" "http://127.0.0.1:8081/alive" 200
  http_probe gitea "GET /api/v1/version" "http://127.0.0.1:3000/api/v1/version" 200
  http_probe jellyfin "GET /System/Info/Public" "http://127.0.0.1:8096/System/Info/Public" 200
  http_probe photoprism "GET /" "http://127.0.0.1:2342/" 200
  http_probe collabora "GET /hosting/discovery" "http://127.0.0.1:9980/hosting/discovery" 200
  http_probe n8n "GET /healthz" "http://127.0.0.1:5678/healthz" 200
  http_probe synapse "GET /_matrix/client/versions" "http://127.0.0.1:8008/_matrix/client/versions" 200
  http_probe element "GET /" "http://127.0.0.1:8009/" 200
  tcp_probe edge "TCP 443 (caddy G9 à l'écoute)" 127.0.0.1 443
 }
 if [[ "$MODE" == "selftest" ]]; then
  # Provocation non destructive : sonde volontairement injoignable → prouve la chaîne
  # détection → payload JSON → salon ops. Aucune brique n'est touchée.
  QUIET=0
  rm -f "$STATE_DIR/alert-selftest"
  alert selftest "TCP 127.0.0.1:9 (sonde volontairement injoignable)" 0 medium "selftest 12-probes : provocation d'un KO pour prouver la chaîne d'alerte"
  exit 0
 fi
 results="$(mktemp)"
 if [[ "$MODE" == "digest" ]]; then QUIET=1; fi
 {
  run_all
  http_probe edge_wan "GET cloud (TLS J5040)" "https://cloud.folzocorp.fr/" 200 "medium"
  http_probe adguard "GET UI .27" "http://192.168.1.27:8081/" 2xx "medium"
 } >"$results" 2>&1 || true
 cat "$results"
 nb_ok="$(grep -c '^OK' "$results" || true)"
 nb_ko="$(grep -c '^KO' "$results" || true)"
 if [[ "$MODE" == "digest" ]]; then
  summary="$(grep '^KO' "$results" | sed 's/^KO //' | head -8 | tr '\n' '; ')"
  ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
  payload="$(python3 -c 'import json,sys; print(json.dumps({"ts":sys.argv[1],"source":"12-probes","brique":"digest","host":sys.argv[2],"check":"daily","http_code":0,"severite":"info","message":f"{sys.argv[3]} OK / {sys.argv[4]} KO — {sys.argv[5]}","runbook":"RUNBOOKS/digest.md"},ensure_ascii=False))' "$ts" "$HOST" "$nb_ok" "$nb_ko" "${summary:-tout OK}")"
  notify "$payload"
 fi
 echo "sonde : $nb_ok OK / $nb_ko KO"
 rm -f "$results"
@@ -0,0 +1,56 @@
 #!/usr/bin/env python3
 """g9-notify.py — poste le payload JSON (base64 dans REGISTRY_B64) dans le salon ops.
 Installé sur le G9 (/usr/local/bin/g9-notify.py). Lit /etc/restic/matrix.env (600 root).
 N'affiche JAMAIS le token. Pattern = restic-notify.sh (Bearer + room URL-encodé + PUT + txnId).
 """
 import base64
 import json
 import os
 import time
 import urllib.parse
 import urllib.request
 ENV_PATH = "/etc/restic/matrix.env"
 def load_env():
    env = {}
    with open(ENV_PATH) as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#") or "=" not in line:
                continue
            k, v = line.split("=", 1)
            env[k] = v.strip().strip('"')
    return env
 def main():
    env = load_env()
    raw = os.environ.get("REGISTRY_B64", "")
    if not raw:
        print("NOTIFY_KO no-payload")
        return
    try:
        payload = json.loads(base64.b64decode(raw).decode())
    except Exception as e:
        print("NOTIFY_KO bad-payload", type(e).__name__)
        return
    body = {"msgtype": "m.text", "body": json.dumps(payload, ensure_ascii=False)}
    room = urllib.parse.quote(env["MATRIX_ROOM"], safe="")
    txn = "openfox-%d" % int(time.time() * 1000)
    url = f"{env['MATRIX_SERVER']}/_matrix/client/v3/rooms/{room}/send/m.room.message/{txn}"
    req = urllib.request.Request(
        url, data=json.dumps(body).encode(), method="PUT",
        headers={"Authorization": "Bearer " + env["MATRIX_TOKEN"],
                 "Content-Type": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=10) as r:
            print("NOTIFY_OK", r.status)
    except Exception as e:
        print("NOTIFY_KO", type(e).__name__)
 if __name__ == "__main__":
    main()
@@ -0,0 +1,64 @@
 #!/usr/bin/env python3
 """g9-verify-alert.py — vérifie que les dernières alertes du salon ops sont des payloads JSON
 conformes au contrat C-AP2 {ts, source, brique, host, check, http_code, severite, message, runbook}.
 Lit /etc/restic/matrix.env (600 root). Lecture seule (GET /messages). N'affiche jamais le token.
 Installé sur le G9 : /usr/local/bin/g9-verify-alert.py
 """
 import json
 import sys
 import urllib.parse
 import urllib.request
 ENV_PATH = "/etc/restic/matrix.env"
 REQUIRED = ["ts", "source", "brique", "host", "check", "http_code", "severite", "message", "runbook"]
 def load_env():
    env = {}
    with open(ENV_PATH) as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#") or "=" not in line:
                continue
            k, v = line.split("=", 1)
            env[k] = v.strip().strip('"')
    return env
 def main():
    limit = int(sys.argv[1]) if len(sys.argv) > 1 else 15
    env = load_env()
    room = urllib.parse.quote(env["MATRIX_ROOM"], safe="")
    url = f"{env['MATRIX_SERVER']}/_matrix/client/v3/rooms/{room}/messages?dir=b&limit={limit}&filter=%7B%22limit%22%3A{limit}%7D"
    req = urllib.request.Request(url, headers={"Authorization": "Bearer " + env["MATRIX_TOKEN"]})
    with urllib.request.urlopen(req, timeout=10) as r:
        data = json.loads(r.read().decode())
    ok = 0
    bad = 0
    seen = []
    for ev in data.get("chunk", []):
        if ev.get("type") != "m.room.message":
            continue
        body = ev.get("content", {}).get("body", "")
        try:
            p = json.loads(body)
        except Exception:
            continue
        if not isinstance(p, dict) or "source" not in p:
            continue
        missing = [k for k in REQUIRED if k not in p]
        if missing:
            bad += 1
            print(f"NON CONFORME source={p.get('source')} manquant={','.join(missing)}")
        else:
            ok += 1
            seen.append((p["source"], p["severite"], p["brique"], p["ts"]))
    print(f"payloads JSON conformes: {ok} | non conformes: {bad}")
    for s in seen[:8]:
        print("  ", s[0], s[1], s[2], s[3])
    print("VERIFY_OK" if ok > 0 else "VERIFY_KO")
 if __name__ == "__main__":
    main()
@@ -0,0 +1,20 @@
 #!/usr/bin/env bash
 # lib-notify.sh — notification Matrix en payload JSON structuré (C-AP2).
 # Identifiants : /etc/restic/matrix.env sur le G9 (600 root, jamais affichés, jamais copiés ici).
 # Usage : source lib-notify.sh puis notify_json '<json>'  (ou notify_simple <source> <brique> <sev> <msg>)
 # Pattern d'envoi identique à restic-notify.sh : Bearer + room URL-encodé + PUT avec txnId.
 G9_SSH="${G9_SSH:-folzo@192.168.1.24}"
 G9_SSH_KEY="${G9_SSH_KEY:-$HOME/.ssh/id_ed25519_openfox11}"
 notify_json() {
  local payload="$1" b64
  b64="$(printf '%s' "$payload" | base64 -w0)"
  ssh -o ConnectTimeout=8 -o BatchMode=yes -i "$G9_SSH_KEY" "$G9_SSH" \
    "REGISTRY_B64='$b64' sudo -E python3 /usr/local/bin/g9-notify.py" 2>&1 | tail -1
 }
 notify_simple() {
  local source="$1" brique="$2" severity="$3" message="$3"
  :
 }
@@ -0,0 +1,99 @@
 #!/usr/bin/env python3
 """Helpers for 10-registry.sh — lit le kit (lecture seule) et fournit les entrées du registre.
  declared  <kit_dir>            -> JSON [{project, service, image}] depuis compose/*/docker-compose.yml
  caddy     <kit_dir>            -> JSON {port: sous-domaine} depuis compose/*/Caddyfile
  endpoints <ports_tsv> <caddy_json> -> JSON {conteneur: sous-domaine}
 Aucun conteneur n'est touché.
 """
 import json
 import os
 import re
 import sys
 def declared(kit):
    out = []
    cdir = os.path.join(kit, "compose")
    if not os.path.isdir(cdir):
        return out
    for project in sorted(os.listdir(cdir)):
        f = os.path.join(cdir, project, "docker-compose.yml")
        if not os.path.isfile(f):
            continue
        try:
            import yaml
            data = yaml.safe_load(open(f)) or {}
        except Exception:
            data = {}
        services = data.get("services") or {}
        for service, spec in services.items():
            image = "-"
            if isinstance(spec, dict):
                image = spec.get("image", "-") or "-"
            out.append({"project": project, "service": service, "image": image})
    return out
 def caddy(kit):
    """Liste [{site, ip, port, source}] — clé = (ip, port), donc pas de collision entre machines."""
    entries = []
    cdir = os.path.join(kit, "compose")
    if not os.path.isdir(cdir):
        return entries
    for project in sorted(os.listdir(cdir)):
        cf = os.path.join(cdir, project, "Caddyfile")
        if not os.path.isfile(cf):
            continue
        site = None
        for line in open(cf):
            s = line.strip()
            if s.startswith("#"):
                continue
            m = re.match(r"^((?:[a-z0-9*-]+\.[a-z0-9.-]+\s+)*[a-z0-9*-]+\.[a-z0-9.-]+)\s*\{$", s)
            if m:
                hosts = m.group(1).split()
                site = next((h for h in hosts if "folzocorp.fr" in h), None)
                continue
            m = re.search(r"reverse_proxy\s+(\S+):(\d+)", s)
            if m and site:
                ip, port = m.group(1), m.group(2)
                if re.match(r"^\d+\.\d+\.\d+\.\d+$", ip):
                    entries.append({"site": site, "ip": ip, "port": port, "source": project})
    return entries
 def endpoints(ports_tsv, caddy_json, machine_ip):
    entries = json.loads(open(caddy_json).read()) if os.path.isfile(caddy_json) else []
    cmap = {(e["ip"], e["port"]): e["site"] for e in entries}
    out = {}
    for line in open(ports_tsv):
        parts = line.rstrip("\n").split("\t")
        if len(parts) < 2:
            continue
        name, ports = parts[0], parts[1]
        found = ""
        for m in re.finditer(r":(\d+)->", ports):
            site = cmap.get((machine_ip, m.group(1)))
            if site:
                found = site
                break
        out[name] = found
    return out
 def main():
    cmd = sys.argv[1]
    kit = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
    if cmd == "declared":
        print(json.dumps(declared(kit)))
    elif cmd == "caddy":
        print(json.dumps(caddy(kit)))
    elif cmd == "endpoints":
        print(json.dumps(endpoints(sys.argv[2], sys.argv[3], sys.argv[4])))
    else:
        sys.exit("usage: registry_inputs.py declared|caddy|endpoints")
 if __name__ == "__main__":
    main()
@@ -0,0 +1,108 @@
 #!/usr/bin/env python3
 """Parse `docker ps -a --format json` (stdin) + kit compose declarations, emit markdown rows.
 Read-only helper for 10-registry.sh. No container is touched.
 """
 import json
 import re
 import sys
 STATEFUL_HINTS = ("mariadb", "postgres", "redis", "influx", "couchdb", "db", "vault", "data")
 LABEL_WT = "com.centurylinklabs.watchtower.enable"
 LABEL_PROJECT = "com.docker.compose.project"
 LABEL_SERVICE = "com.docker.compose.service"
 def is_digest_id(image):
    return bool(re.fullmatch(r"[0-9a-f]{12,64}", image))
 def kit_matches(kit_image, real_image):
    """Le kit épingle par digest : `name@sha256:<hex>` == réel `<hex court>` si préfixe."""
    if not kit_image or kit_image == "-":
        return True
    if kit_image == real_image:
        return True
    if "@sha256:" in kit_image and is_digest_id(real_image):
        digest = kit_image.split("@sha256:", 1)[1]
        return digest.startswith(real_image)
    return False
 def is_stateful(name, image, labels):
    if labels.get(LABEL_WT) == "false":
        return True
    low = f"{name} {image}".lower()
    return any(h in low for h in STATEFUL_HINTS)
 def main():
    machine = sys.argv[1]
    endpoints = json.loads(sys.argv[2]) if len(sys.argv) > 2 else {}
    declared = json.loads(sys.argv[3]) if len(sys.argv) > 3 else []
    declared_keys = {(d["project"], d["service"]) for d in declared}
    declared_images = {f'{d["project"]}/{d["service"]}': d["image"] for d in declared}
    rows = []
    findings = []
    raw = sys.stdin.read().strip()
    if not raw:
        print("[]")
        print("#findings# []", file=sys.stderr)
        return
    for line in raw.splitlines():
        if not line.strip():
            continue
        c = json.loads(line)
        name = c.get("Names", c.get("Name", "?"))
        image = c.get("Image", "?")
        state = c.get("State", "?")
        labels = {}
        for kv in str(c.get("Labels", "")).split(","):
            if "=" in kv:
                k, v = kv.split("=", 1)
                labels[k] = v
        project = labels.get(LABEL_PROJECT, "-")
        service = labels.get(LABEL_SERVICE, "-")
        wt = labels.get(LABEL_WT)
        wt_label = "true" if wt == "true" else ("false" if wt == "false" else "ABSENT")
        pinned = "non (latest)" if image.endswith(":latest") else "oui"
        if is_digest_id(image):
            pinned = "oui (digest)"
        key = f"{project}/{service}"
        declared_state = "oui" if (project, service) in declared_keys else "NON"
        drift_img = ""
        if declared_state == "oui" and not kit_matches(declared_images.get(key), image):
            drift_img = f"image kit={declared_images.get(key)} != réel={image}"
        endpoint = endpoints.get(f"{name}", "")
        rows.append({
            "machine": machine,
            "name": name,
            "project": project,
            "service": service,
            "image": image,
            "state": state,
            "pinned": pinned,
            "wt": wt_label,
            "stateful": "stateful" if is_stateful(name, image, labels) else "stateless",
            "kit": declared_state,
            "endpoint": endpoint,
        })
        if pinned.startswith("non"):
            findings.append(f"{machine}/{name}: image non épinglée ({image}) — S11.4 pinning")
        if wt_label == "ABSENT":
            findings.append(f"{machine}/{name}: label watchtower absent — S11.4 sélectivité")
        if declared_state == "NON":
            findings.append(f"{machine}/{name}: conteneur réel non déclaré dans le kit (compose)")
        if drift_img:
            findings.append(f"{machine}/{name}: {drift_img} — dérive kit/réel")
        if state not in ("running",):
            findings.append(f"{machine}/{name}: état {state}")
    rows.sort(key=lambda r: (r["machine"], r["name"]))
    print(json.dumps(rows, ensure_ascii=False))
    print("#findings# " + json.dumps(findings, ensure_ascii=False), file=sys.stderr)
 if __name__ == "__main__":
    main()
Author	SHA1	Message	Date
openfox	4b26049b8f	phase 4.5: registre identites + runbooks + sondes applicatives (cron G9) + G11 + etudes exposition/whatsapp + alignement 08-decommission et S8/S9.2/S11/S14	2026-10-12 16:42:41 +02:00
openfox	ca64eaaf77	registre: 10-registry.sh (genere moitie technique + derive) + REGISTRE-BRIQUES.md (21 conteneurs, 13 constats) + lib-notify.sh (payload JSON)	2026-10-12 16:17:34 +02:00