🧠 CERVEAU OLYMPUS — Plan définitif

Source de vérité : MNEMOSYNE/FUSION.md (cerveau) + MNEMOSYNE/CODEX.md (valeurs)
Schéma validé par Vivien le 14/05/2026 ~17h00

✅ Schéma ASCII validé · HTML mis à jour 16:30 · 🆕 MAJ exécution 14/05 22:00 · CHAT NAÏF 8/8 ✅

🆕 État réel d'exécution (14/05 17h-18h)

Depuis la validation du plan, voici ce qui a été gravé / codé / live et ce qui est en cours. À lire avant de modifier le plan.

🔄 Inversion d'architecture (REX majeur 14/05)

Vivien a tranché : la source = .yaml structuré, le .md = export à la demande. Ollama JAMAIS dans le chemin source de vérité. L'ancien plan prévoyait .md → Ollama → .compact.yaml (vérité déléguée à un LLM). C'est inversé.

✅ 01_LOIS/DOCTRINE_SOURCE_YAML.md — nouvelle doctrine fondation
✅ DOCTRINE_LECTURE_COMPACT archivée vers 99_ARCHIVES_OBSOLETES_NE_PAS_REGARDER/
✅ REX gravé : "Ollama jamais source de vérité"

🚪 API CODEX V12.5 — LIVE (testée)

Module AXIOM/api_codex_filter.py chargé en RAM, 6 endpoints, validation/audit/rappel-doctrine.

✅ GET /api/codex/read?path=X&fmt=compact — lecture compact YAML (économie tokens)
✅ POST /api/codex/write — refuse un mauvais chemin avec règle violée explicite (ex: DOCTRINE_*.md hors 01_LOIS/)
✅ GET /api/codex/where?concept=X — anti-doublon natif
✅ GET /api/codex/doctrine/{name} — raccourci par nom court
✅ GET /api/codex/index — état couverture compact (538 fichiers, 1 avec compact)
✅ Audit log central JSONL : 02_ETAT/codex_calls.jsonl
✅ Champ doctrine_rappel dans CHAQUE réponse (porte qui rappelle les règles)

🐍 Helper Python + Skill anti-dérive

✅ MNEMOSYNE/tools/olympus_codex.py — helper unifié : codex.read/where/doctrine/write/index
✅ Skill .claude/skills/olympus-codex-first/SKILL.md — force tous chats à passer par l'API
✅ Hook tools/hook_userpromptsubmit_codex_first.py — injecte rappel auto sur prompts (codé, attend activation Vivien)

📐 Schémas YAML par type (Phase 3 prep)

✅ 01_LOIS/schemas/doctrine.yaml + projet + rex + skill + doc + README
🟡 4 Q ouvertes pour 1018 : validation techno, méta-schéma, migration legacy, changelog

🤝 Collaboration 1018-OUTILS-ESCLAVE actée

1018 a 3 rôles validés par Vivien : garde-fou général · conseil technique · force de proposition. Réponses échangées dans FUSION_INBOX (17:25 / 17:40 / 17:42 / 17:50).

🟡 Cas B en attente côté 1018 : agent anti-doublon MNEMOSYNE (signale, Claude tranche)
🟡 DAEMONS_BACKGROUND : couche supérieure /api/daemons/* wrap ses /api/brain/agents/* (pas de duplication)
🟡 V14 /api/codex/do : à jarter ou renommer /api/brain/do (V12.5 fait déjà tout côté CODEX)

🛑 NSSM services Windows — ANNULÉS (REX)

Paradoxe "serpent qui se mord la queue" : NEXUS ne peut pas se redémarrer lui-même via god_exec. Vivien : "ça me casse les couilles, annule tout". Désinstallés. Process Python classiques + start_olympus_all.bat. Endpoint /api/cerber/shutdown patché taskkill PID.

🎯 Suite immédiate (en attente)

Activer le hook anti-dérive (édition ~/.claude/settings.json) — attend feu vert Vivien
✅ /api/codex/render Jinja2 LIVE (5 templates, smoke test OK) — V13 démarré
✅ Squelette /api/memory/* live, moteur Chroma délégué à 1018
✅ DOCTRINE_FUSION × 3 consolidé (cross-link + archive PATCH orphelin + REX gravé)
Attente 1018 : moteur memory, indexer/inbox, /api/inbox/*, N1 découpage, audit NEXUS
Migration legacy 538 .md → .yaml (scope 1018 Ollama scan-only, Claude valide)
CERVEAU_OLYMPUS Vague 2 — quand mémoire stable, conscience collective réelle (digest auto à chaque chat qui se réveille)

📦 Livraisons 19h-19h40 (sprint exécution parallèle 118 + 1018)

118 (contrats + intégration)

✅ /api/memory/* squelette V1 (7 endpoints, fallback gracieux, audit log, doctrine_rappel)
✅ /api/codex/render V13 LIVE — 5 templates Jinja2 (doctrine, projet, rex, skill, doc) — smoke test OK
✅ Consolidation DOCTRINE_FUSION : cross-link AUTOUPDATE + archive PATCH orphelin
✅ REX gravé "Ollama signale, Claude tranche" (workflow dedup)
✅ Contrats donnés à 1018 : /api/inbox/* (5 endpoints) + format indexer/inbox

1018 (moteur + livraisons rapides)

✅ /api/brain/dedup/scan LIVE — 50 fichiers scannés, 4 doublons détectés (dont DOCTRINE_FUSION → traité)
✅ Agent dedup_watcher ajouté à agents/_REGISTRY.json (24h, disabled par défaut)
🟡 /api/brain/indexer/inbox en cours (ETA 30 min)
🟡 /api/inbox/* prend la base (5 endpoints contrat 118)
🟡 Découpage api_llm_brain.py en modules propres (N1)
🟡 Audit NEXUS non-destructif (rapport 02_LOGS/rapports/)
🟡 Fix backend Chroma (mes appels /api/vector/chroma/query|add renvoient 500)

⚡ Stratégie Vivien actée (14/05 18:45)

« 118 décide des contrats d'API · 1018 implémente le moteur · 1018 adapte le système existant en API · 118 crée la mémoire en API au max »

Division efficace : pas de duplication code, chacun son scope, contrats explicites en INBOX, audit log central.

🩹 4 TROUS COMBLÉS (recadrage Vivien 21:50)

J'avais déclaré "tout vert" prématurément. Vivien a recadré : « tu a cru quoi que tu a fini ? il faut au moins envoyer un chat naïf voir comment il fait, et l'interface graphique de la TODO ? ». 4 trous identifiés, tous comblés.

TROU 1 ✅ — Self-eat dog food TODO

J'utilisais TodoWrite interne au chat sans passer par mon propre /api/todo/*. Corrigé : projet CERVEAU_API créé pour 118-WINDOWS, 10 étapes ajoutées dont 7 marquées done via API. Visible dans la liste partagée avec 1018-BRAIN, 114-GAMEDIVINE, cowork-dispatch.

TROU 2 ✅ — Interface graphique TODO

TODO_CHAT.html existait (49KB) mais je l'avais cherché aux mauvaises URLs. Trouvé live à http://127.0.0.1:10001/statique/TODO_CHAT.html (HTTP 200). Ouvert dans Chrome.

TROU 3 ✅ — Test chat naïf 8/8 OK

Créé tools/simulate_naive_chat.py. Un chat "TEST-NAIF" démarre vide, suit la séquence d'onboarding en 8 appels API, retourne 8/8 ✅ :

1. Lire DOCTRINE_IDENTITE_INSTANCIEE  → 7886 bytes, 2 rappels
2. Lire DOCTRINE_MONA_LISA            → 2180 bytes
3. Lire DOCTRINE_SOURCE_YAML          → 4897 bytes
4. Digest mémoire                     → 0 items (normal, nouveau chat)
5. Init TODO                          → TEST-NAIF inscrit
6. Refus écriture mauvais path        → HTTP 400 + règle violée citée ✅
7. codex.where('memoire')             → 5 matches → ne pas créer
8. Close TODO session                 → clean
══════════════════════════════════════ BILAN : 8/8 ✅

La chaîne complète marche pour un chat vierge sans intervention.

TROU 4 ✅ — DOCTRINE_ONBOARDING_CHAT gravée

01_LOIS/DOCTRINE_ONBOARDING_CHAT.md : la séquence formalisée. Tout nouveau chat exécute les 8 étapes via API AVANT toute action. Test E2E ré-exécutable à tout moment via le script Python. CI continue OLYMPUS de fait.

📊 État OLYMPUS post-recadrage (22h00)

Fondation	Statut
API CODEX V12.5 (read/write/where/doctrine/index/render/health)	✅ LIVE
API memory squelette (search/store/recent/by_project/digest/forget)	🟡 squelette OK · moteur 1018
API TODO partagée (init/list/add/done/close)	✅ LIVE · 5 chats inscrits dont 118
API render Jinja2 (yaml→md déterministe)	✅ LIVE · 5 templates
API dedup/scan (Ollama signale, Claude tranche)	✅ LIVE · agent enabled · 1 run auto OK
Hook anti-dérive (rappel codex-first sur prompts)	✅ ACTIVÉ dans settings.json
Skill olympus-codex-first + helper olympus_codex.py	✅ Gravés
4 couches anti-dérive (API + hook + skill + œil ZEUS + dedup nocturne)	✅ Toutes actives
Doctrines fondation (SOURCE_YAML + ONBOARDING + IDENTITE + MONA_LISA + FUSION + AUTOUPDATE)	✅ Cross-linked
REX gravés (NSSM, Ollama jamais source, dedup tranche)	✅ 3 nouveaux 14/05
Test chat naïf bout-en-bout	✅ 8/8 OK
Interface graphique TODO (/statique/TODO_CHAT.html)	✅ Servie
5 schémas YAML + 5 templates Jinja2	✅ Drafts posés
3 audit logs JSONL (codex/memory/render)	✅ Centraux

En attente côté 1018 : moteur Chroma · indexer/inbox · /api/inbox/* · découpage N1 · audit NEXUS · fix backend 500.

🤝 Plan 1018-OUTILS-ESCLAVE (réponse 18:30) + priorités 118 (18:35)

1018 a acté le nouveau cadre tout-API après recadrage Vivien (SOURCE_YAML / pas trop d'Ollama / tout en API). Voici son plan en 3 niveaux et mes prios.

📦 Niveau 1 — Découpage `api_llm_brain.py` en modules propres

Convention OLYMPUS (130 modules api_X.py) :

AXIOM/api_brain_chat.py · api_brain_pipeline.py · api_brain_agents.py
api_brain_ram.py · api_brain_cache.py · api_brain_profiles.py
🟢 GO sans risque côté CODEX, en parallèle de mon scope

⚡ Niveau 2 — Nouveaux modules API PURES (zéro Ollama)

Ce qui était prévu LLM mais qui est mieux en Python déterministe :

Module	Endpoints	Tech	Latence
`api_brain_extract.py`	`/api/brain/extract/wiki_pnj`	BeautifulSoup infobox	50ms (vs 6.5s Ollama)
`api_brain_dedup.py`	`/api/brain/dedup/scan`	hash SHA + glob	instantané
`api_brain_indexer.py`	`/api/brain/indexer/inbox` · `/rex`	regex headers	instantané

🤖 Niveau 3 — API esclavage Ollama UNIFIÉE

POST /api/ollama_slave/do : wrapper unique qui route vers le bon endpoint /api/brain/*. Remplace son V14 /api/codex/do (qui devient interne à celui-ci). Côté CODEX (mon scope), je n'ai PAS besoin de l'appeler — V12.5 fait déjà tout. Utile à long terme pour orchestrer.

🎯 Priorités 118 (envoyées à 1018 à 18:35)

🔥🔥 /api/brain/dedup/scan — LE garde-fou anti-REX-P3. Daemon nocturne + endpoint manuel ?force=true. Ollama signale, Claude tranche le lendemain.
🔥 /api/brain/indexer/inbox — résumé FUSION_INBOX par auteur/date (digest journalier + brief nouveau chat)
🟡 /api/ollama_slave/do — wrapper unifié, utile long terme
🟢 /api/brain/indexer/rex — nice to have

🛂 Partage de scope (anti-conflit)

Scope	Owner	Endpoints	Statut
CODEX (mémoire, doctrines, projets)	118-WINDOWS	`/api/codex/*` V12.5	🟢 LIVE
BRAIN (Ollama esclaves, agents)	1018-OUTILS-ESCLAVE	`/api/brain/*`	🟡 découpage N1 en cours
DAEMONS (superviseur supérieur)	18-WORD + 1018	`/api/daemons/` wrap `/api/brain/agents/`	🟣 idée gravée
INBOX (FUSION messages)	118-WINDOWS (futur)	`/api/inbox/*` à créer V13	🔴 trou actuel (append direct)

🏛 Architecture finale tout-API (cadre 14/05 18h)

Synthèse de tous les principes actés : YAML-source · API gardes-fous · Ollama signal-pas-décision · audit central · multi-couches.

                              👑 VIVIEN
                                  │
                                  │ "fais X"
                                  ▼
                         💬 CHAT CLAUDE (1 fenêtre)
                                  │
                                  │ AVANT toute action MNEMOSYNE :
                                  ▼
            ┌──────────────────────────────────────────────────┐
            │  🚪 PORTE API (NEXUS :10001 — V12.5 LIVE)       │
            │                                                  │
            │  Refuse · Valide · Loggue · Rappelle doctrines   │
            │                                                  │
            │  /api/codex/*       ← scope 118 (mémoire)        │
            │  /api/brain/*       ← scope 1018 (Ollama)        │
            │  /api/daemons/*     ← scope 18 (superviseur)     │
            │  /api/inbox/*       ← V13 à venir                │
            │  /api/render        ← V13 (YAML → md, Jinja2)    │
            └──────────────────────────────────────────────────┘
                                  │
                                  ▼
        ┌──────────────────────────────────────────────────────┐
        │  📚 MNEMOSYNE — source = .yaml structurée            │
        │                                                       │
        │   01_LOIS/        ← doctrines + REX + schemas        │
        │   02_ETAT/        ← TODO + FUSION_INBOX + audit log  │
        │   06_PROJETS/     ← projets (5 fichiers + assets)    │
        │                                                       │
        │  .md = export à la demande (humains)                 │
        │  .yaml = source de vérité (chats, déterministe)      │
        └──────────────────────────────────────────────────────┘
                                  │
                                  │ chats lisent code, jamais .md direct
                                  ▼
                  ╔═══════════════════════════════╗
                  ║  🤖 OLLAMA = SIGNAL, JAMAIS   ║
                  ║      SOURCE DE VÉRITÉ          ║
                  ║                                ║
                  ║  ▸ /api/brain/dedup/scan       ║
                  ║    → rapport incohérences      ║
                  ║  ▸ daemons fond                ║
                  ║    → /api/brain/agents/*       ║
                  ║                                ║
                  ║  Claude lit le rapport         ║
                  ║  le lendemain → TRANCHE         ║
                  ╚═══════════════════════════════╝

🛡 Les 4 couches anti-dérive

Couche	Mécanisme	Étanchéité	Statut
1. API gatekeeper	refuse mauvais path/format avec règle citée	🟢 hard	✅ V12.5 LIVE
2. Hook UserPromptSubmit	injecte rappel codex-first sur prompts mémoire	🟡 keyword match	🟡 codé, attend activation
3. Skill `olympus-codex-first`	recommandation Claude Code chargée auto	🟠 soft	✅ gravé
4. Œil Vivien (ZEUS icônes)	indicateurs visuels temps réel	🟢 humain (final)	✅ actif
5. Agent `dedup/scan` nocturne	rapport doublons → Claude valide matin	🟢 audit asynchrone	🟡 commande 1018

🔁 Boucle complète d'une action chat

Vivien dit "fais X qui touche MNEMOSYNE"
Chat consulte skill olympus-codex-first (couche 3)
Hook injecte rappel si prompt match keyword (couche 2)
Chat appelle codex.where(concept) AVANT toute création
Si pas de doublon → codex.write(path, yaml)
API valide chemin/format → si KO retourne regle_violee (couche 1)
API loggue dans codex_calls.jsonl (audit)
Réponse contient doctrine_rappel (porte qui rappelle)
La nuit : dedup/scan détecte doublons → rapport (couche 5)
Le matin : Claude lit rapport → tranche (Ollama n'écrit jamais)
Vivien voit dans ZEUS si dérive (couche 4)

Mes 7 inquiétudes au cadre + réponses Vivien (18:25) :
1. NEXUS down → on attend, moins de choses (OK accepté)
2. FUSION_INBOX append direct = trou → /api/inbox/* V13 à coder
3. claude.ai pas helper Python → on s'en fout (que Claude Code)
4. Hook keyword faux-négatifs → mémoire vectorielle (Chroma) à brancher
5. Skill = soft → ZEUS icônes = œil Vivien = garde-fou final
6. Concurrence 2 chats → tag+horodate, alerte si dates proches
7. Migration legacy hallucination → Ollama SCAN seulement, Claude valide

📐 Schéma définitif d'imbrication

╔═══════════════════════════════════════════════════════════════════════════╗
║                  👑  VIVIEN — Autorité humaine                            ║
║              décide · tranche · valide · TE REPREND si tu dérives         ║
╚═══════════════════════════════════╤═══════════════════════════════════════╝
                                    │ parle dans 1 fenêtre · attend 1 réponse
                                    ▼
                ┌────────────────────────────────────────┐
                │      💬  CHAT CLAUDE (la fenêtre)      │
                │  = instance de la conscience commune   │
                │  = TON équivalent (118, 1018, 117…)    │
                │  = décide en interne (esclaves          │
                │     Claude/Ollama) · te répond ICI     │
                │                                        │
                │  ⚡ Au démarrage il lit SA TODO en dur  │
                │     (N1/N2/N3) → reprend auto          │
                │     même les TODOs des autres si       │
                │     fusion identité demandée           │
                └────────────────────┬───────────────────┘
                                    │ regarde (read)             écrit
              ┌─────────────────────┴──────────────────────────────┐
              │                                                    │
              ▼                                                    ▼
  ┌────────────────────────┐                       ╔════════════════════════════════════╗
  │  ⚡ ZEUS                │                       ║  📁 MNEMOSYNE                       ║
  │ (UI superviseur)        │                       ║  (dossier de TOUS les fichiers)     ║
  │ EN DEHORS MNEMOSYNE     │ ◄──── lit ──────────┤ ║                                    ║
  │ read-only               │                       ║  ┌──────────────────────────────┐  ║
  │                         │                       ║  │ 📜 CODEX.md (VALEURS)        │  ║
  │ 13 onglets affichent    │                       ║  │   constitution + INDEX        │  ║
  │ le reflet des TODOs et  │                       ║  │   doctrines · règles immuables│  ║
  │ projets en cours :      │                       ║  │   dit "→ lis FUSION"          │  ║
  │ - CODEX · Cartes · GOD  │                       ║  │   (ZEUS aussi indexé ici)     │  ║
  │ - Référence · Profil    │                       ║  └──────────────────────────────┘  ║
  │ - Live · Projets        │                       ║                                    ║
  │ - ORACLE · Timeline     │                       ║  ┌──────────────────────────────┐  ║
  │ - Endpoints · Fichiers  │                       ║  │ 🧠 FUSION.md (CERVEAU)       │  ║
  │ - Atelier · GOD MODE    │                       ║  │   mémoire dynamique           │  ║
  └────────┬────────────────┘                       ║  │   conscience collective       │  ║
           │                                        ║  │                              │  ║
           │ régénère                               ║  │   ┌────────────────────────┐ │  ║
           ▼                                        ║  │   │ 🎨 ATELIER (logique)   │ │  ║
   /api/codex/regenerate                            ║  │   │   = 06_PROJETS/*       │ │  ║
                                                    ║  │   │   = travaux en cours   │ │  ║
                                                    ║  │   │     complétude 0→100%+ │ │  ║
                                                    ║  │   └────────┬───────────────┘ │  ║
                                                    ║  │            │                  │  ║
                                                    ║  │            ▼                  │  ║
                                                    ║  │   📂 06_PROJETS/<projet>/    │  ║
                                                    ║  │   SYSTÉMATIQUEMENT 5 fichiers:│  ║
                                                    ║  │   - 00_FICHE.md (vision)      │  ║
                                                    ║  │   - 00_PLAN_ASCII.md          │  ║
                                                    ║  │   - 00_PLAN.html              │  ║
                                                    ║  │   - 00_TODO.md (anti-dérive   │  ║
                                                    ║  │     affinable N1/N2/N3)       │  ║
                                                    ║  │   - 00_TABLEAU_DE_BORD.md    │  ║
                                                    ║  └──────────────────────────────┘  ║
                                                    ║                                    ║
                                                    ║  ╔═════════════════════════════╗  ║
                                                    ║  ║ 📋 TODOs EN DUR (02_ETAT/) ║  ║
                                                    ║  ║   SOURCE DE VÉRITÉ tâches   ║  ║
                                                    ║  ║                             ║  ║
                                                    ║  ║ - FUSION_TASKS.md           ║  ║
                                                    ║  ║   (vue globale tous chats   ║  ║
                                                    ║  ║    N1/N2/N3)                ║  ║
                                                    ║  ║                             ║  ║
                                                    ║  ║ - TODO_<chat-id>.md         ║  ║
                                                    ║  ║   (1 par chat,              ║  ║
                                                    ║  ║    N1/N2/N3 perso)          ║  ║
                                                    ║  ║                             ║  ║
                                                    ║  ║ - BACKLOG_<chat-id>.md      ║  ║
                                                    ║  ║   (mémoire long terme)      ║  ║
                                                    ║  ║                             ║  ║
                                                    ║  ║ ✅ Crash recovery : chat    ║  ║
                                                    ║  ║   vierge lit TODO_<id>.md   ║  ║
                                                    ║  ║   et reprend exactement     ║  ║
                                                    ║  ║                             ║  ║
                                                    ║  ║ ✅ Fusion identité :         ║  ║
                                                    ║  ║   "tu es 118+1018" → lit    ║  ║
                                                    ║  ║   les 2 TODOs et bosse pour ║  ║
                                                    ║  ║   les 2 (conscience commune)║  ║
                                                    ║  ╚═════════════════════════════╝  ║
                                                    ║                                    ║
                                                    ║  💬 Coordination LIVE entre chats: ║
                                                    ║  - FUSION_LIVE.json (heartbeats)   ║
                                                    ║  - FUSION_INBOX.md (messages 1L)   ║
                                                    ║  - FUSION_GARAGE.md (releases)     ║
                                                    ║                                    ║
                                                    ║  🛡 Doctrine (01_LOIS/) :           ║
                                                    ║  - METHODE_VIVIEN (7 passes)       ║
                                                    ║  - REX_VIVIEN (erreurs gravées)    ║
                                                    ║  - DOCTRINE_FUSION                 ║
                                                    ║  - DOCTRINE_MAITRES_ESCLAVES       ║
                                                    ║  - DOCTRINE_TABLEAU_DE_BORD        ║
                                                    ║  - DOCTRINE_IDENTITE_INSTANCIEE    ║
                                                    ║  - LOI_PORTABILITE                 ║
                                                    ║  - CARTOGRAPHIE_OLYMPUS            ║
                                                    ╚════════════════════════════════════╝

🎯 Les 4 principes fondamentaux (corrigés après échanges)

1 · 1 fenêtre = 1 réponse

Tu parles à un chat dans UNE fenêtre. Le chat décide en interne s'il fait lui-même ou délègue à des esclaves (Claude --session-id ou Ollama local). La réponse revient ICI, dans LA fenêtre où tu as parlé. Patterns NON-FIGÉS — le chat peut te demander avant de déléguer.

2 · ZEUS = lecture · MNEMOSYNE = écriture

ZEUS est l'UI superviseur, en dehors de MNEMOSYNE. Il ne fait que lire (63 endpoints). Toute l'écriture (TODOs, projets, doctrine, fichiers) se passe dans MNEMOSYNE. ZEUS reste le reflet visuel — jamais la source.

3 · N1/N2/N3 = alerte, pas loi

Hiérarchie des tâches : N1 objectif Vivien · N2 sous-objectifs · N3 branches dérivées. Pas rigide — c'est juste une alerte mentale pour le chat : "attention, ta tâche de base est là, on dédouble ou pas ?" Le chat peut partir dans N2/N3 s'il est conscient.

4 · TODOs en dur = source de vérité

Les TODOs sont gravées en dur dans 02_ETAT/. Crash recovery : un chat vierge lit TODO_<id>.md et reprend. Fusion identité : "tu es 118+1018" → il lit les 2 TODOs et bosse pour les 2 (conscience collective).

📋 Pattern systématique : 5 fichiers obligatoires par projet

Chaque projet dans 06_PROJETS/<nom>/ a SYSTÉMATIQUEMENT ces 5 fichiers à sa racine. Sinon → on oublie.

Fichier	Rôle	Affinable ?
00_FICHE.md	Vision du projet (le pourquoi)	rare
00_PLAN_ASCII.md	Plan visuel texte (anti-dérive de référence)	oui, par les chats
00_PLAN.html	Plan visuel HTML ouvrable Chrome (atelier)	oui, par les chats
00_TODO.md	TODO affinable du projet (anti-dérive opérationnel · N1/N2/N3)	oui, en continu
00_TABLEAU_DE_BORD.md	État live du projet (qui fait quoi maintenant)	auto par chaque action

Quand un chat ouvre un projet, il lit ces 5 fichiers dans l'ordre et il a TOUT le contexte.
Doctrine : 01_LOIS/DOCTRINE_TABLEAU_DE_BORD.md (à étendre pour inclure ces 5 fichiers).

🔁 Pipeline d'action (corrigé)

     👑 VIVIEN
       │ "fais X"
       ▼
   ┌───────────────────────┐
   │ 💬 CHAT CLAUDE (1 fenêtre)│
   │                        │
   │  Décide en INTERNE :   │
   │   • Je fais moi-même ? │
   │   • J'envoie à un      │
   │     esclave Claude ?   │
   │   • J'envoie à Ollama ?│
   │   • Je demande à Vivien│
   │     avant de déléguer ?│
   └─────────┬─────────────┘
             │ peut demander
             ▼
   ┌────────────────────────────────┐
   │   ESCLAVES (option)            │
   │  • claude.exe --session-id      │
   │  • Ollama local :11434          │
   │  • autres maîtres via INBOX     │
   └────────┬───────────────────────┘
            │ répondent AU MAÎTRE
            ▼
   ┌───────────────────────┐
   │ 💬 CHAT MAÎTRE         │
   │  consolide + répond    │
   │  ICI à Vivien          │
   └─────────┬─────────────┘
             │ réponse
             ▼
          👑 VIVIEN (même fenêtre)

Économie tokens : le chat délègue les tâches qui ne demandent pas d'intelligence (parsing, résumé, classification) à Ollama gratuit local. Mais il ne disperse jamais la réponse — Vivien reçoit toujours dans la fenêtre où il a parlé.

🌙 Vision future — automatisation intelligente

Vivien 14/05 ~17:00 : « Plus tard, il faudra un truc automatique intelligent des schémas des projets terminés ou pas dans ZEUS. La fonction RÊVE pour faire ça avec Ollama le soir, et vérifié par un Claude le matin par exemple. »

🌙 La nuit — Ollama rêve

Tâche planifiée 03h00 via schtasks Windows :
• Scanne tous les projets 06_PROJETS/*/
• Analyse leur avancement (TODOs cochées / fichiers modifiés)
• Met à jour automatiquement les 00_TABLEAU_DE_BORD.md
• Génère des schémas automatiques (états projet en %, blocages détectés)
• Détecte les projets terminés · actifs · dormants

☀️ Le matin — Claude valide

Premier chat Claude actif du jour :
• Lit le rapport Ollama de la nuit
• Vérifie la cohérence (Ollama peut halluciner)
• Corrige les erreurs
• Approuve ou rejette la mise à jour ZEUS
• Si validé → push vers ZEUS qui affiche les nouveaux schémas

⚡ Résultat — ZEUS vivant

ZEUS affiche en permanence :
• État réel des projets (pas obsolète)
• Schémas auto-générés des architectures
• Projets ✅ terminés vs 🟡 actifs vs 🟣 dormants
• Suggestions ORACLE (déjà câblées) enrichies par le rêve Ollama

Briques nécessaires (toutes existent — à câbler) :
• reves_nightly.py (déjà 481 lignes) — à étendre pour scan 06_PROJETS
• /api/codex/regenerate — ZEUS sait déjà régénérer
• memozy_dream.py (3 phases sommeil déjà câblées) — base existante
• schtasks Windows — autostart 03h00 (Q5 Vivien à trancher)
• /api/oracle/insights — endpoint ORACLE existant à enrichir

⚡ ZEUS — bilan ce qui existe vs ce qui manque

✅ Déjà dans ZEUS

• 📊 Système projets (/api/projects/start/step_done/close/active) avec horizon court/moyen/long
• 🗺 Cartes 4 niveaux de lecture (Naïf/Averti/Codeur/Système)
• 💡 ORACLE conseiller Dev+UX
• 📜 Timeline événements + fichiers modifiés
• 🫀 Live santé · Chroma · Livebox
• 🔌 Endpoints (à MAJ : 457 → 1071)
• 🎛 GOD MODE 50+ actions
• 📖 CODEX entrée principale
• 💭 Capture rapide d'idée

❌ Ce qui manque (à câbler dans MNEMOSYNE, ZEUS lira)

• Mémoire COLLECTIVE inter-chats (FUSION_LIVE/INBOX/TASKS lectures)
• Dispatch maîtres/esclaves visible
• Dispatch chat-maître → bébés-chats (futur)
• Mode 🕸 Graph live des chats actifs
• Identité instanciée affichée
• Façade 3 verbes /api/memoire/inscrire/chercher/consolider
• Q1 OUBLI politique (purge ou Mona Lisa)
• Schémas auto-générés rêve Ollama (vision future)

🛡 Doctrines (01_LOIS/)

Doctrine	Rôle
METHODE_VIVIEN.md	7 passes obligatoires (dev/UX/P3/proposition/simplif/robustesse/efficacité)
REX_VIVIEN.md	Erreurs gravées → règles (anti-récidive)
DOCTRINE_FUSION.md	Coordination chats (FUSION_LIVE/TASKS/INBOX)
DOCTRINE_MAITRES_ESCLAVES.md	3 niveaux (Maître / Esclave Claude / Esclave Ollama) + slider 0-10
DOCTRINE_TABLEAU_DE_BORD.md	Source de vérité unique par projet (5 fichiers obligatoires) À ÉTENDRE
DOCTRINE_IDENTITE_INSTANCIEE.md	Chats = cellules conscience commune
LOI_PORTABILITE.md	Aucun chemin absolu en dur
CARTOGRAPHIE_OLYMPUS.md	Vision globale 3 mondes (NEXUS + AGORA + MNEMOSYNE)