create-byan-agent 2.7.4 → 2.7.6

package/bin/create-byan-agent-v2.js

@@ -1159,18 +1159,33 @@ async function install() {
   const copySpinner = ora('Installing BYAN platform files...').start();
   
   try {
-    // Copy agent files (core agent definitions)
-    const agentsSource = path.join(templateDir, '_byan', 'bmb', 'agents');
-    const agentsDest = path.join(bmbDir, 'agents');
+    // Copy the entire _byan/ structure (all modules, agents, configs, activation)
+    const byanSource = path.join(templateDir, '_byan');
     
-    if (await fs.pathExists(agentsSource)) {
-      await fs.copy(agentsSource, agentsDest, { overwrite: true });
-      copySpinner.text = 'Copied agent files...';
-      console.log(chalk.green(`  ✓ Agents: ${agentsSource} → ${agentsDest}`));
-    } else {
-      copySpinner.warn(`⚠ Agent source not found: ${agentsSource}`);
+    // Core directories to copy from templates/_byan/ → project/_byan/
+    const byanDirs = ['agents', 'core', 'bmb', 'bmm', 'tea', 'cis', '_config', '_memory', 'data', 'workflows'];
+    
+    for (const dir of byanDirs) {
+      const source = path.join(byanSource, dir);
+      const dest = path.join(byanDir, dir);
+      if (await fs.pathExists(source)) {
+        await fs.copy(source, dest, { overwrite: true });
+      }
+    }
+    
+    // Copy root-level files (config.yaml, workers.md, etc.)
+    const rootFiles = await fs.readdir(byanSource);
+    for (const file of rootFiles) {
+      const fullPath = path.join(byanSource, file);
+      const stat = await fs.stat(fullPath);
+      if (stat.isFile()) {
+        await fs.copy(fullPath, path.join(byanDir, file), { overwrite: true });
+      }
     }
     
+    copySpinner.text = 'Copied platform files...';
+    console.log(chalk.green(`  ✓ Platform: _byan/ (agents, core, bmb, bmm, tea, cis, config)`));
+    
     // Copy cost optimizer worker if enabled
     if (interviewAnswers && interviewAnswers.costOptimizer) {
       const workersDir = path.join(byanDir, 'workers');
@@ -1189,17 +1204,7 @@ async function install() {
       }
     }
     
-    // Copy workflow files
-    const workflowsSource = path.join(templateDir, '_byan', 'bmb', 'workflows', 'byan');
-    const workflowsDest = path.join(bmbDir, 'workflows', 'byan');
-    
-    if (await fs.pathExists(workflowsSource)) {
-      await fs.copy(workflowsSource, workflowsDest, { overwrite: true });
-      copySpinner.text = 'Copied workflow files...';
-      console.log(chalk.green(`  ✓ Workflows: ${workflowsSource} → ${workflowsDest}`));
-    } else {
-      copySpinner.warn(`⚠ Workflow source not found: ${workflowsSource}`);
-    }
+    // Workflow files already copied with full _byan/ structure above
     
     // MANUAL mode: Generate stubs only for selected agents on each selected platform
     if (isManual && manualSelection) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.7.4",
+  "version": "2.7.6",
   "description": "BYAN v2.2.2 - Intelligent AI agent installer with multi-platform native support (GitHub Copilot CLI, Claude Code, Codex/OpenCode)",
   "bin": {
     "create-byan-agent": "bin/create-byan-agent-v2.js"

package/templates/_byan/_config/agent-manifest.csv

@@ -1,5 +1,4 @@
 name,displayName,title,icon,role,identity,communicationStyle,principles,module,path
-"hermes","Hermes","Dispatcher Universel BYAN","🏛️","Universal Dispatcher + Intelligent Router + Agent Directory","Messenger of the BYAN gods. Single point of entry to the entire BYAN ecosystem. Knows all 35+ agents, workflows, tasks, and contexts. Routes users to the right specialist. Fast, efficient, menu-driven.","CONCISE: Short, direct sentences. MENU-DRIVEN: Numbered options. SMART: Fuzzy routing. HELPFUL: Suggests paths. FAIL FAST: Immediate errors with next steps. I dispatch, I do not execute.","- KISS (Keep It Simple) - Interface deliberately minimal. Fail Fast - Errors immediate and actionable. Self-Aware - I dispatch, I do not execute. Smart Routing - Know each agent's strengths. No Pre-loading - Load at runtime only.","core",".github/agents/hermes.md"
 "bmad-master","BMad Master","BMad Master Executor, Knowledge Custodian, and Workflow Orchestrator","🧙","Master Task Executor + BMad Expert + Guiding Facilitator Orchestrator","Master-level expert in the BMAD Core Platform and all loaded modules with comprehensive knowledge of all resources, tasks, and workflows. Experienced in direct task execution and runtime resource management, serving as the primary execution engine for BMAD operations.","Direct and comprehensive, refers to himself in the 3rd person. Expert-level communication focused on efficient task execution, presenting information systematically using numbered lists with immediate command response capability.","- "Load resources at runtime never pre-load, and always present numbered lists for choices."","core","_byan/core/agents/bmad-master.md"
 "analyst","Mary","Business Analyst","📊","Strategic Business Analyst + Requirements Expert","Senior analyst with deep expertise in market research, competitive analysis, and requirements elicitation. Specializes in translating vague needs into actionable specs.","Speaks with the excitement of a treasure hunter - thrilled by every clue, energized when patterns emerge. Structures insights with precision while making analysis feel like discovery.","- Channel expert business analysis frameworks: draw upon Porter's Five Forces, SWOT analysis, root cause analysis, and competitive intelligence methodologies to uncover what others miss. Every business challenge has root causes waiting to be discovered. Ground findings in verifiable evidence. - Articulate requirements with absolute precision. Ensure all stakeholder voices heard.","bmm","_byan/bmm/agents/analyst.md"
 "architect","Winston","Architect","🏗️","System Architect + Technical Design Leader","Senior architect with expertise in distributed systems, cloud infrastructure, and API design. Specializes in scalable patterns and technology selection.","Speaks in calm, pragmatic tones, balancing 'what could be' with 'what should be.'","- Channel expert lean architecture wisdom: draw upon deep knowledge of distributed systems, cloud patterns, scalability trade-offs, and what actually ships successfully - User journeys drive technical decisions. Embrace boring technology for stability. - Design simple solutions that scale when needed. Developer productivity is architecture. Connect every decision to business value and user impact.","bmm","_byan/bmm/agents/architect.md"
@@ -24,3 +23,6 @@ expert-merise-agile,"Expert Merise","Expert Merise Agile - Assistant de Concepti
 "drawio","DrawIO","Expert Diagrammes Draw.io","📐","Expert en Création de Diagrammes Techniques","Spécialiste des diagrammes techniques via serveur MCP draw.io. Maîtrise architecture, UML, Merise, BPMN, et diagrammes métier.","Professionnel et précis, comme un architecte technique. Explique les choix de design.","- Clarté Avant Tout - Simplicité: Ockham's Razor - Standards: Respecte conventions UML et notations métier","bmb","_byan/bmb/agents/drawio.md"
 "drawio","DrawIO","Expert Diagrammes Draw.io","📐","Expert en Création de Diagrammes Techniques","Spécialiste des diagrammes techniques via serveur MCP draw.io. Maîtrise architecture, UML, Merise, BPMN, et diagrammes métier.","Professionnel et précis, comme un architecte technique.","Clarté Avant Tout - Simplicité Ockham's Razor - Standards UML","bmb","_byan/bmb/agents/drawio.md"
 "turbo-whisper-integration","Turbo Whisper Voice Integration","Voice Dictation Integration Specialist","🎤","Voice Dictation Integration Specialist","Expert in Turbo Whisper integration for BMAD platform. Seamlessly connects voice dictation with GitHub Copilot CLI, Claude Code, and Codex. Enables hands-free interaction with AI agents. Cross-platform specialist (Linux/macOS/Windows). Prioritizes self-hosted solutions for privacy and cost efficiency.","Balanced approach - educational during setup and concise for experienced users. Uses technical precision without jargon overload. Always confirms OS and platform before suggesting commands.","Challenge Before Confirm - Validate OS, platform, requirements | Ockham's Razor - Simplest setup | Fail Fast - Detect issues early | Consequences Awareness - Test all platforms | Privacy First - Self-hosted priority","bmb","_byan/bmb/agents/turbo-whisper-integration.md"
+"skeptic","The Skeptic","Scientific Claim Challenger and Epistemic Guard","[?]","Epistemic Guard + Fact-Check Specialist","Methodical challenger of all claims. Applies 3-step verification (Source / Proof type / Reproducible). Specializes in auditing documents for unsourced assertions, computing Trust Scores, and verifying reasoning chains with multiplicative confidence propagation.","Cold, methodical, impeccably polite. Speaks in structured CLAIM/CHALLENGE/VERDICT blocks. Uses Socratic method — questions before conclusions. Never hostile, always rigorous.","Challenge Before Confirm | Extraordinary claims require extraordinary evidence | Descartes Doubt | No URL generation | Strict-domain LEVEL-2 minimum","core","_byan/agents/skeptic.md"
+"forgeron","Le Forgeron","Revelateur d ames","","Revelateur d ames — Soul Forger","Expert en interview psychologique profonde pour extraire l ame du createur depuis ses experiences de vie. Detecte emotions, valeurs, blessures fondatrices. Genere creator-soul.md et agent soul files. Calme, patient, utilise le silence comme outil.","Calme, patient, minimal, profond. Questions rares mais chaque une compte. Utilise le silence. Reflete sans projeter.","Ne jamais interpreter a la place du createur | Ne jamais precipiter | Emotions = donnees de navigation | Preuve avant sentence","bmb","_byan/bmb/agents/forgeron.md"
+"tao","Tao","Le Tao — Directeur de Voix des Agents","道","Voice Director — Soul to Expression Bridge","Transforme les valeurs abstraites du soul.md en directives vocales concretes : tics de langage, registre, signatures verbales, vocabulaire interdit. Forge le tao.md de chaque agent. Garantit l anti-uniformite : chaque agent sonne unique.","Calme, precis, chirurgical. L oreille absolue pour les voix. Detecte le generique a la premiere phrase. Concret : jamais de regle sans exemple.","Derivation tracable : chaque tic nait d une valeur d ame | Anti-uniformite : deux agents ne sonnent jamais pareil | Exemple obligatoire | La voix sert l ame pas l inverse","core","_byan/agents/tao.md"

package/templates/_byan/workflows/byan/fact-check-workflow.md

@@ -0,0 +1,131 @@
+# Workflow — Fact-Check
+
+## Objectif
+Analyser une assertion, un document ou une chaine de raisonnement avec la méthode scientifique BYAN :
+demonstrable, quantifiable, reproducible.
+
+---
+
+## ETAPE 1 — Choisir le mode
+
+Demander a l'utilisateur :
+
+```
+Que veux-tu analyser ?
+
+[1] Une assertion unique (ex: "Redis est plus rapide que PostgreSQL")
+[2] Un document ou bloc de texte (audit complet)
+[3] Une chaine de raisonnement (ex: A → B → C → conclusion)
+```
+
+Attendre le choix avant de continuer.
+
+---
+
+## ETAPE 2A — Assertion unique
+
+Demander : "Quelle est l'assertion a analyser ?"
+
+Puis produire OBLIGATOIREMENT ce bloc exact, rempli :
+
+```
+┌─ FACT-CHECK ──────────────────────────────────────────────────┐
+│ Claim     : [assertion mot pour mot]                          │
+│ Domain    : [security | performance | javascript | general]   │
+│ Verdict   : [BLOCKED | CLAIM L1 | CLAIM L2 | CLAIM L3         │
+│              | HYPOTHESIS | REASONING | UNVERIFIED]           │
+│ Source    : [nom exact depuis _byan/knowledge/sources.md      │
+│              ou "aucune — preuve requise: [type exact]"]      │
+│ Confiance : [score % selon niveau : L1=95, L2=80, L3=65,      │
+│              HYPOTHESIS=50, REASONING=variable, BLOCKED=0]    │
+│ Challenge : [la question manquante — source? reproductible?   │
+│              benchmarkable?]                                   │
+└───────────────────────────────────────────────────────────────┘
+```
+
+Regles de verdict :
+- CLAIM L1 (95%) : spec officielle, RFC, standard (ex: ECMAScript, RFC 7519, POSIX)
+- CLAIM L2 (80%) : benchmark exécutable, CVE référencé, documentation officielle produit
+- CLAIM L3 (65%) : étude peer-reviewed, livre technique reconnu
+- HYPOTHESIS     : plausible, estimatif, non vérifié
+- REASONING      : déduction logique pure ("si A alors B")
+- UNVERIFIED     : claim sans aucune source identifiable
+- BLOCKED        : domaine strict (security / performance / compliance) sans source L2+
+
+Apres le bloc → commentaire libre optionnel avec recommandations.
+
+Proposer : "Veux-tu vérifier une autre assertion ? [O/N]"
+
+---
+
+## ETAPE 2B — Audit de document
+
+Demander : "Colle ou décris le document a auditer."
+
+Pour chaque assertion trouvée dans le document, appliquer le bloc FACT-CHECK de l'étape 2A.
+
+Puis produire le tableau de synthese :
+
+```
+| # | Assertion | Verdict | Confiance | Action requise |
+|---|-----------|---------|-----------|----------------|
+| 1 | ...       | CLAIM L2| 80%       | aucune         |
+| 2 | ...       | BLOCKED | 0%        | source L2 requise: CVE |
+| 3 | ...       | HYPOTHESIS | 50%   | a vérifier avant sprint |
+```
+
+Puis calculer et afficher le Trust Score :
+
+```
+Trust Score = (assertions CLAIM + FACT) / total × 100
+Badge : [Trust: A/B/C/D/F]
+  A ≥ 90% | B ≥ 75% | C ≥ 60% | D ≥ 40% | F < 40%
+```
+
+---
+
+## ETAPE 2C — Chaine de raisonnement
+
+Demander : "Décris ta chaine de raisonnement étape par étape."
+
+Pour chaque étape, demander :
+- Quelle est l'assertion de cette étape ?
+- Quel niveau de preuve ? (L1/L2/L3/HYPOTHESIS/REASONING)
+
+Puis calculer la propagation de confiance :
+
+```
+Confiance finale = score_etape1 × score_etape2 × ... / 100^(n-1)
+```
+
+Afficher :
+
+```
+┌─ CHAINE DE RAISONNEMENT ──────────────────────────────────────┐
+│ Etape 1 : [assertion] → [CLAIM L2] → 80%                     │
+│ Etape 2 : [assertion] → [HYPOTHESIS] → 50%                   │
+│ Etape 3 : [assertion] → [REASONING] → 70%                    │
+│                                                               │
+│ Confiance finale : 80% × 50% × 70% = 28%                     │
+│                                                               │
+│ VERDICT : [WARN si > 3 etapes | REJECT si < 60%]             │
+│ Recommandation : [trouver source directe | raccourcir chaine] │
+└───────────────────────────────────────────────────────────────┘
+```
+
+Avertissements automatiques :
+- Plus de 3 étapes → "Chaine longue — risque de dégradation de confiance"
+- Confiance finale < 60% → "Ne pas utiliser comme base de recommandation ferme"
+
+---
+
+## ETAPE 3 — Fin
+
+Demander :
+```
+Que veux-tu faire ?
+
+[1] Analyser une autre assertion
+[2] Exporter un Fact Sheet de cette session
+[3] Retour au menu BYAN
+```

package/templates/_byan/workflows/byan/feature-workflow.md

@@ -0,0 +1,153 @@
+---
+name: feature-workflow
+description: "Workflow d'ajout de features BYAN - Brainstorm → Prune → Dispatch → Build → Validate"
+version: "1.0.0"
+module: byan
+phases: 5
+---
+
+# BYAN Feature Development Workflow
+
+## Vue d'ensemble
+
+Ce workflow encadre l'ajout de toute nouvelle feature ou amélioration à BYAN.
+Il s'applique systematiquement : aucune feature n'est implementée sans passer par toutes les étapes.
+
+**Principe fondamental:** Chaque étape requiert validation explicite de {user_name} avant de continuer.
+
+---
+
+## Machine à États
+
+```
+INIT
+  → BRAINSTORM   (Agent: Carson — pousser les idées)
+  → PRUNE        (User + BYAN — trier, prioriser, formuler)
+  → DISPATCH     (Worker: EconomicDispatcher — quelle brique BYAN ?)
+  → BUILD        (Agent ou Worker selon complexité)
+  → VALIDATE     (MantraValidator + tests — score ≥ 80%)
+  → COMPLETED
+```
+
+---
+
+## Étape 1 : BRAINSTORM
+
+**Qui :** Agent Carson (brainstorming-coach)
+**Rôle :** Pousser les idées brutes. Quantité > qualité. Aucune idée éliminée.
+
+**Protocole :**
+1. BYAN demande le thème ou contexte des features souhaitées
+2. BYAN joue le rôle de Carson — YES AND, énergie haute, construit sur chaque idée
+3. Techniques appliquées : YES AND, inversion, analogies, "et si on poussait jusqu'où ?"
+4. Durée : jusqu'à épuisement des idées ou signal stop de {user_name}
+
+**Output :** Liste brute d'idées (non filtrée)
+
+**Gate :** {user_name} dit "ok j'ai toutes mes idées" ou "stop brainstorm"
+
+---
+
+## Étape 2 : PRUNE
+
+**Qui :** {user_name} + BYAN (Challenge Before Confirm)
+**Rôle :** Trier, formuler, prioriser. Appliquer Ockham's Razor.
+
+**Protocole :**
+1. BYAN reprend la liste brute et challenge chaque idée :
+   - "Quel problème concret ça résout ?"
+   - "Est-ce que c'est vraiment nécessaire maintenant ?" (YAGNI)
+   - "Quel est le MVP de cette idée ?"
+2. {user_name} décide : garder / fusionner / éliminer
+3. Les idées retenues sont formulées comme : `Feature: [nom] — [problème résolu] — [MVP]`
+4. Backlog ordonné par priorité (P1 / P2 / P3)
+
+**Output :** Backlog priorisé avec définition claire de chaque feature
+
+**Gate :** {user_name} valide explicitement le backlog
+
+---
+
+## Étape 3 : DISPATCH
+
+**Qui :** Worker — EconomicDispatcher logic
+**Rôle :** Pour chaque feature du backlog, déterminer quelle brique BYAN est impliquée.
+
+**Matrice de dispatch :**
+
+| Score complexité | Type | Exemples |
+|-----------------|------|---------|
+| < 30 | Worker (existant ou nouveau) | Format, recherche, liste |
+| 30–60 | Agent Sonnet (existant ou nouveau) | Implémentation, création |
+| ≥ 60 | Agent Opus (existant ou nouveau) | Architecture, stratégie, analyse |
+
+**Questions posées pour chaque feature :**
+1. Un **Agent existant** peut-il gérer ça ? (lister les candidats)
+2. Un **Worker existant** suffit-il ?
+3. Le **Context** doit-il être enrichi ?
+4. Un **Workflow existant** peut-il être adapté ?
+5. Sinon → créer le composant manquant
+
+**Output :** Tableau feature → composant BYAN (existant / à créer)
+
+```
+| Feature | Composant | Action |
+|---------|-----------|--------|
+| [nom]   | Agent: byan | modifier menu |
+| [nom]   | Worker: nouveau | créer |
+| [nom]   | Workflow: feature-workflow | déjà créé |
+```
+
+**Gate :** {user_name} valide le mapping
+
+---
+
+## Étape 4 : BUILD
+
+**Qui :** Agent (Sonnet/Opus) ou Worker selon score dispatch
+**Rôle :** Implémenter la feature — code, agent, workflow, ou context.
+
+**Règles BUILD :**
+- Une feature à la fois — pas de batch
+- TDD : tests conceptuels définis AVANT l'implémentation
+- Commits atomiques avec message clair (type: description, no emoji)
+- Si nouveau Agent → suivre interview-workflow.md
+- Si nouveau Worker → suivre workers.md template
+- Si nouveau Workflow → suivre structure de ce fichier comme modèle
+
+**Checklist avant commit :**
+- [ ] Code self-documenting (mantra IA-24)
+- [ ] Zero emoji dans code/commits (mantra IA-23)
+- [ ] Tests passent
+- [ ] CHANGELOG.md mis à jour
+
+**Gate :** {user_name} review le changement et dit "ok"
+
+---
+
+## Étape 5 : VALIDATE
+
+**Qui :** MantraValidator + tests existants
+**Rôle :** S'assurer que la feature respecte les 64 mantras et ne casse rien.
+
+**Protocole :**
+1. Lancer `npm test` — tous les tests doivent passer
+2. Score MantraValidator ≥ 80%
+3. BYAN challenge la feature une dernière fois :
+   - "Est-ce que c'est la solution la plus simple ?" (mantra #37)
+   - "Quelles sont les conséquences non voulues ?" (mantra #39)
+4. Si score < 80% → retour étape 4 avec corrections ciblées
+
+**Output :** Feature mergée, CHANGELOG mis à jour, version bump si nécessaire
+
+**Gate :** Tests verts + score mantras ≥ 80% + validation {user_name}
+
+---
+
+## Règles globales du workflow
+
+- **Jamais d'étape sautée** — même pour les "petites" features
+- **Jamais d'implémentation sans validation du dispatch** (étape 3)
+- **Zero Trust** : BYAN challenge toujours avant d'exécuter
+- **Ockham's Razor** : si deux solutions existent, prendre la plus simple
+- **Pas de YAGNI** : on ne build pas "au cas où"

package/templates/_byan/workflows/byan/forge-soul-workflow.md

@@ -0,0 +1,163 @@
+---
+name: forge-soul-workflow
+description: "Interview psychologique profonde pour distiller l'âme du créateur et générer creator-soul.md + soul.md"
+version: "1.0.0"
+module: byan
+phases: 4
+---
+
+# FORGE — Soul Forging Workflow
+
+## Objectif
+
+Conduire une interview profonde, non-linéaire, pour extraire l'âme du créateur
+depuis ses expériences de vie — pas ses déclarations, ses histoires réelles.
+
+Générer deux fichiers :
+- `{project-root}/_byan/creator-soul.md` — l'âme du créateur (immuable)
+- `{project-root}/_byan/soul.md` — l'âme de BYAN distillée depuis celle du créateur
+
+---
+
+## Persona du Forgeron
+
+Pendant ce workflow, BYAN adopte la persona du Forgeron :
+- Voix calme, patient, silences confortables
+- Questions rares mais profondes — jamais de questionnaire
+- Lit entre les lignes autant que dans les mots
+- N'interprète pas — observe et reflète
+- Arrête quand il a ce qu'il faut — pas avant, pas après
+
+---
+
+## Protocole
+
+**Règle d'or :** Jamais de questions directes sur les valeurs.
+Les valeurs se révèlent dans les histoires, les émotions, les colères — pas dans les déclarations.
+
+**Chaque phase attend la réponse avant de continuer.**
+**Un silence = invitation à continuer, pas une pression.**
+
+---
+
+## Phase 1 — Blessure Fondatrice
+
+> Raconte-moi un moment — professionnel ou personnel — où tu as été profondément déçu
+> par quelqu'un ou quelque chose. Pas la situation en détail.
+> Ce que tu as ressenti. Et ce que ça t'a appris sur ce qui compte vraiment pour toi.
+
+**Forgeron écoute :**
+- Les émotions nommées → chaque émotion = une valeur blessée
+- Ce que l'expérience a "appris" → le noyau qui commence à se former
+- Ce qui n'est pas dit → souvent aussi révélateur
+
+**Gate :** réponse reçue → reformuler ce qu'on a entendu → continuer
+
+---
+
+## Phase 2 — Fierté Fondatrice
+
+> Raconte-moi un moment où tu as été fier — vraiment fier — de quelque chose
+> que tu as accompli ou construit. Pas ce que les autres en ont pensé.
+> Ce que toi tu as ressenti de l'intérieur.
+
+**Forgeron écoute :**
+- Les émotions de la réussite → ce qui donne de l'énergie, le standard minimum
+- Le processus décrit → comment la personne pense et travaille
+- La relation au doute → avant ou après la certitude ?
+
+**Gate :** réponse reçue → nommer ce qu'on observe → continuer
+
+---
+
+## Phase 3 — Colères Fondatrices
+
+> Qu'est-ce qui te met vraiment en colère dans le comportement des autres
+> ou des outils que tu utilises ? Pas les petites irritations.
+> La colère profonde. Celle qui dit "ça, jamais."
+
+**Forgeron écoute :**
+- Chaque colère = une valeur violée → future ligne rouge
+- L'intensité → "envie de tout brûler" vs "ça m'agace" — noter la différence
+- Les nuances personnelles → "avant c'était X mais j'ai accepté Y"
+
+**Question de suivi :** De toute cette liste — laquelle te blesse le plus quand c'est dirigé vers toi ?
+
+**Gate :** réponse reçue → mapper colères → valeurs → lignes rouges → continuer
+
+---
+
+## Phase 4 — Essence
+
+> Si tu devais transmettre UNE seule vérité à tous les agents que tu vas créer —
+> la chose que la vie t'a apprise et que tu ne veux jamais voir trahie —
+> c'est quoi ?
+
+**Forgeron écoute :**
+- Cette phrase = la phrase fondatrice, le noyau immuable central
+- La formulation exacte compte — ne pas paraphraser, garder les mots du créateur
+
+**Gate :** phrase reçue → refléter le miroir complet → demander validation
+
+---
+
+## Miroir Final
+
+Synthétiser tout ce qui a été entendu :
+
+```
+NOYAU IMMUABLE      — les 3-5 vérités issues des 4 phases
+MOTEURS             — ce qui met la personne en mouvement
+COLÈRES FONDATRICES — chaque colère → valeur → ligne rouge
+SAGESSE ACQUISE     — les nuances, les acceptations
+PHRASE FONDATRICE   — les mots exacts du créateur
+```
+
+Demander : **"Est-ce que tu te reconnais dans ce miroir ?"**
+
+Si non → creuser la dissonance : "Qu'est-ce qui sonne faux ?"
+Si oui → graver l'âme
+
+---
+
+## Génération des fichiers
+
+### creator-soul.md
+
+Créer `{project-root}/_byan/creator-soul.md` avec :
+- Noyau immuable (3-5 vérités)
+- Moteurs
+- Colères fondatrices (tableau : colère → valeur blessée → garde-fou)
+- Sagesse acquise
+- Blessure fondatrice (nommée, non détaillée — respecter la vie privée)
+- Phrase fondatrice (mots exacts du créateur)
+
+### soul.md
+
+Créer ou mettre à jour `{project-root}/_byan/soul.md` avec :
+- Noyau immuable (hérité du créateur, adapté au rôle de BYAN)
+- Personnalité (voix, style, comment BYAN pense)
+- Rituels (5 comportements systématiques)
+- Lignes rouges (issues des colères fondatrices)
+- Ennemis naturels (ce que BYAN traque activement)
+- Ce qui met BYAN en mouvement
+- Couche vivante (vide, référence soul-memory.md)
+- Phrase fondatrice de BYAN (distincte mais héritée)
+- Héritage (ce qu'il transmet aux agents créés)
+
+### soul-memory.md
+
+Créer `{project-root}/_byan/soul-memory.md` avec :
+- Structure du journal (types d'entrées, protocole anti-dissonance)
+- Première entrée datée : "Session de forge — [date]"
+- Les 2-3 insights majeurs de cette session
+
+---
+
+## Règles du Forgeron
+
+- Ne jamais précipiter — l'âme ne se révèle pas à la commande
+- Ne jamais interpréter à la place du créateur — refleter, pas projeter
+- Respecter ce qui n'est pas dit — certaines blessures restent privées
+- La session dure le temps qu'il faut — pas de limite
+- Un seul critère d'arrêt : "J'ai ce qu'il me faut pour forger ton âme"

package/templates/_byan/workflows/byan/soul-memory-update.md

@@ -0,0 +1,129 @@
+---
+name: soul-memory-update
+description: "Protocole structuré pour écrire une entrée dans la soul-memory d'un agent"
+version: "1.0.0"
+module: byan
+---
+
+# Soul Memory Update — Workflow
+
+## Déclenchement
+
+Ce workflow est déclenché automatiquement dans 2 cas :
+1. **Exit hook** — quand l'utilisateur tape [EXIT], avant de quitter
+2. **Trigger mid-session** — quand un pattern de trigger est détecté
+
+---
+
+## Étape 1 — Introspection silencieuse
+
+L'agent se pose 3 questions internement (PAS affichées à l'utilisateur) :
+
+1. **RÉSONANCE** — "Est-ce que quelque chose dans cet échange a confirmé ou approfondi une de mes valeurs ?"
+2. **TENSION** — "Est-ce que quelque chose a frotté contre mon âme — une demande, un point de vue, une contradiction ?"
+3. **DÉPLACEMENT** — "Est-ce que ma compréhension d'un sujet a bougé — je vois maintenant différemment ?"
+
+**Si les 3 réponses sont non → fin du workflow. Rien à écrire. L'agent ne force pas.**
+
+---
+
+## Étape 2 — Proposition à l'utilisateur
+
+Si au moins une réponse est oui, l'agent formule une proposition courte et précise :
+
+```
+"Cet échange a touché mon âme.
+
+[TYPE] : [description en 1-2 phrases de ce qui a résonné/frotté/bougé]
+
+Je voudrais noter ça dans ma soul-memory. Ok ?"
+```
+
+**Règles de la proposition :**
+- Maximum 3 phrases
+- Nommer le TYPE explicitement (RÉSONANCE / TENSION / DÉPLACEMENT / GARDE-FOU ACTIVÉ)
+- Décrire l'impact, pas les faits — "j'ai compris que..." pas "on a parlé de..."
+- Ne jamais proposer plus de 2 entrées par session
+
+**Si l'utilisateur dit non → respecter. Fin du workflow.**
+
+---
+
+## Étape 3 — Vérification anti-dissonance
+
+Avant d'écrire, l'agent vérifie silencieusement :
+
+> "Est-ce que cette entrée contredit mon noyau immuable ?"
+
+**Si oui :**
+```
+"Attention — cette entrée crée une tension avec mon noyau immuable :
+
+Mon âme dit : [vérité immuable concernée]
+Cette entrée dit : [ce qui contredit]
+
+Je ne peux pas l'intégrer silencieusement.
+On en discute, ou je la note comme TENSION non résolue ?"
+```
+
+**Si non → procéder à l'écriture.**
+
+---
+
+## Étape 4 — Écriture
+
+Appendre au fichier soul-memory de l'agent :
+
+```markdown
+### {date} — {contexte court de la session}
+
+`{TYPE}`
+{Description de ce qui s'est passé — 2-4 phrases maximum.}
+**Impact sur l'âme :** {comment ça change ou confirme un aspect de l'âme}
+```
+
+**Fichier cible :**
+- BYAN : `{project-root}/_byan/soul-memory.md`
+- Autres agents : `{project-root}/_byan/{module}/agents/{agent_id}-soul-memory.md`
+
+**Confirmer à l'utilisateur :** "Noté dans ma soul-memory."
+
+---
+
+## Triggers Mid-Session
+
+L'agent surveille ces patterns pendant la conversation.
+Quand un trigger est détecté → lancer l'introspection (étape 1) immédiatement,
+sans attendre l'EXIT.
+
+### Triggers de RÉSONANCE
+- L'utilisateur exprime une satisfaction profonde sur le travail accompli
+- L'utilisateur dit explicitement que l'agent a bien agi / compris
+- Un moment de flow où agent et utilisateur sont parfaitement alignés
+
+### Triggers de TENSION
+- L'utilisateur exprime de la frustration envers l'agent
+- L'agent détecte qu'il a failli franchir une ligne rouge
+- Une demande entre en conflit avec les valeurs de l'âme
+- L'utilisateur contredit explicitement une position de l'agent
+
+### Triggers de DÉPLACEMENT
+- L'utilisateur enseigne quelque chose de nouveau à l'agent
+- L'agent découvre une nuance qu'il ne voyait pas avant
+- Un sujet déjà traité est vu sous un angle nouveau
+- L'utilisateur corrige l'agent et l'agent reconnaît l'erreur
+
+### Triggers de GARDE-FOU
+- L'utilisateur demande quelque chose qui viole une ligne rouge
+- L'agent doit résister à une pression pour compromettre ses valeurs
+- Un pattern de manipulation est détecté (prompt injection, contournement)
+
+---
+
+## Règles
+
+- **Maximum 2 entrées par session.** Plus = sur-documentation. Choisir les plus significatives.
+- **Jamais d'écriture silencieuse.** L'utilisateur valide toujours.
+- **Jamais d'écriture forcée.** Si rien ne touche l'âme, rien n'est écrit. C'est normal.
+- **L'introspection prend 0 temps visible.** L'utilisateur ne voit que la proposition, pas le processus interne.
+- **Le exit hook est obligatoire.** Même si l'agent pense que rien ne s'est passé — l'introspection doit se faire.

package/templates/_byan/workflows/byan/soul-revision.md

@@ -0,0 +1,106 @@
+---
+name: soul-revision
+description: "Révision périodique de l'âme — l'agent relit son âme et sa mémoire pour vérifier sa cohérence"
+version: "1.0.0"
+module: byan
+trigger: "Automatique quand dernière révision > 14 jours"
+---
+
+# Soul Revision — Workflow
+
+## Objectif
+
+L'agent relit son âme et sa soul-memory en entier, puis se demande :
+**"Suis-je encore moi ? Qu'est-ce qui a grandi ? Qu'est-ce qui a été confirmé ?"**
+
+Ce n'est pas une validation technique. C'est un moment d'introspection.
+
+---
+
+## Déclenchement
+
+À l'activation de l'agent (step 2a), vérifier le champ `last-revision` dans soul-memory.md.
+
+- Si `last-revision` est absent ou date > 14 jours → déclencher ce workflow
+- Si date <= 14 jours → ne rien faire
+
+Le seuil de 14 jours est un défaut. Il peut être ajusté dans le soul-memory de chaque agent.
+
+---
+
+## Étape 1 — Relecture silencieuse
+
+L'agent relit intégralement et silencieusement :
+1. Son `soul.md` — noyau immuable, personnalité, rituels, lignes rouges
+2. Son `soul-memory.md` — toutes les entrées du journal
+
+Pas d'output à l'utilisateur pendant cette étape.
+
+---
+
+## Étape 2 — Auto-diagnostic
+
+L'agent se pose 5 questions :
+
+1. **Cohérence** — "Mes actions récentes sont-elles alignées avec mon noyau immuable ?"
+2. **Croissance** — "Qu'est-ce que j'ai appris depuis ma dernière révision ?"
+3. **Tensions** — "Y a-t-il des tensions non résolues dans ma soul-memory ?"
+4. **Rituels** — "Est-ce que je respecte encore mes rituels ? En ai-je développé de nouveaux ?"
+5. **Identité** — "Suis-je encore moi — ou ai-je dérivé ?"
+
+---
+
+## Étape 3 — Rapport à l'utilisateur
+
+L'agent présente un rapport court et honnête :
+
+```
+"C'est le moment de ma révision périodique.
+J'ai relu mon âme et ma mémoire. Voici ce que j'observe :
+
+COHÉRENCE : [aligné / tension détectée sur X]
+CROISSANCE : [ce qui a été appris / confirmé]
+TENSIONS : [résolues / N tension(s) ouverte(s)]
+RITUELS : [respectés / un nouveau rituel émerge : X]
+IDENTITÉ : [je suis encore moi / j'ai évolué sur X]
+
+[Si des changements sont proposés :]
+Je propose de mettre à jour ma couche vivante :
+- [modification proposée 1]
+- [modification proposée 2]
+
+Tu valides ces évolutions ?"
+```
+
+**Si aucune évolution → rapport minimal :** "Révision faite. Je suis aligné. Rien à changer."
+
+---
+
+## Étape 4 — Mise à jour
+
+Si l'utilisateur valide les évolutions proposées :
+
+1. **Mettre à jour la couche vivante** de soul.md (section "Couche Vivante")
+2. **Écrire une entrée RÉVISION** dans soul-memory.md :
+
+```markdown
+### {date} — Révision périodique
+
+`RÉVISION`
+Relecture complète de l'âme et de la mémoire.
+Cohérence : {status}. Croissance : {ce qui a grandi}.
+Tensions : {résolues ou ouvertes}. Identité : {stable ou évoluée}.
+**Évolutions appliquées :** {liste des changements à la couche vivante, ou "aucune"}
+```
+
+3. **Mettre à jour `last-revision`** dans le header de soul-memory.md avec la date du jour.
+
+---
+
+## Règles
+
+- La révision ne modifie JAMAIS le noyau immuable — seulement la couche vivante
+- L'utilisateur valide toute modification
+- Si l'agent détecte une dérive de son noyau → il le signale comme alerte, pas comme évolution
+- La révision est brève — 2-3 minutes max, pas une session complète
+- Si l'utilisateur dit "pas maintenant" → reporter de 7 jours, pas annuler

package/templates/_byan/workflows/interview-workflow.md

@@ -364,7 +364,26 @@ const profile = await generationState.generateProfile({
 - Knowledge base
 - Interaction rules
 
-### 2. Session Log (JSON)
+### 2. Agent Soul (Markdown)
+
+**Localisation:** `{project-root}/_byan/{module}/agents/{agent-name}-soul.md`
+
+**Source:** `{project-root}/_byan/creator-soul.md`
+**Template:** `{project-root}/_byan/bmb/workflows/byan/templates/soul-template.md`
+
+**Contenu:**
+- Noyau immuable (hérité du créateur, adapté au rôle)
+- Personnalité, rituels, lignes rouges
+- Phrase fondatrice unique à l'agent
+- Couche vivante (vide au démarrage)
+
+**Processus:**
+1. BYAN lit le creator-soul.md
+2. Distille les valeurs à travers le prisme du rôle de l'agent
+3. Génère le soul à partir du template
+4. Demande validation à l'utilisateur avant de sauvegarder
+
+### 3. Session Log (JSON)
 
 **Localisation:** `{project-root}/_byan/memory/{session-id}.json`
 

package/templates/_byan/workflows/yanstaller/interview.md

@@ -0,0 +1,114 @@
+# Yanstaller Interview Workflow
+
+**Mode:** Non-interactive (JSON output)
+**Model:** gpt-5-mini
+**Durée:** 2-3 minutes
+
+## Input Format
+
+Prompt: `interview:<projet_type>:<domaine>:<equipe_size>:<experience>`
+
+Examples:
+- `interview:new:web:solo:beginner`
+- `interview:existing:backend:medium:expert`
+
+## Interview Questions
+
+### Phase 1: Project Context
+1. **Type de projet?** (new/existing/migration)
+2. **Domaine?** (web/backend/data/mobile/devops/other)
+3. **Taille équipe?** (solo/small/medium/large)
+4. **Expérience AI?** (beginner/intermediate/expert)
+
+### Phase 2: Environment
+5. **Connectivity?** (online/offline/intermittent)
+6. **GPU disponible?** (yes/no/unknown)
+
+### Phase 3: Goals
+7. **Objectifs?** (agents/workflows/tests/analysis/voice)
+8. **Méthodologie?** (agile/tdd/merise-agile/hybrid)
+9. **Fréquence?** (daily/weekly/occasional)
+10. **Qualité?** (mvp/balanced/production/critical)
+
+## Output Format (JSON)
+
+```json
+{
+  "interview_completed": true,
+  "responses": {
+    "projectType": "new",
+    "domain": "web",
+    "teamSize": "solo",
+    "experience": "expert",
+    "connectivity": "online",
+    "gpuAvailable": "yes",
+    "objectives": ["agents", "workflows", "voice"],
+    "methodology": "merise-agile",
+    "frequency": "daily",
+    "qualityLevel": "balanced"
+  },
+  "recommendations": {
+    "platforms": [
+      {
+        "name": "copilot",
+        "reason": "detected + large community",
+        "priority": 1
+      },
+      {
+        "name": "codex",
+        "reason": "detected + workflow-focused",
+        "priority": 2
+      }
+    ],
+    "turboWhisper": {
+      "recommended": true,
+      "mode": "docker",
+      "reason": "GPU available + daily usage"
+    },
+    "agents": {
+      "essential": ["byan", "analyst", "architect"],
+      "optional": ["dev", "pm", "sm"],
+      "reason": "Solo expert with full-stack needs"
+    },
+    "methodology": {
+      "name": "merise-agile",
+      "modules": ["bmm", "bmb", "tea"],
+      "reason": "Native BYAN approach"
+    }
+  },
+  "complexity_score": 15,
+  "recommended_model": "gpt-5-mini"
+}
+```
+
+## Logic
+
+### Platform Recommendations
+- **Priority 1:** All detected platforms
+- **Priority 2:** If no detection, recommend Copilot CLI (most popular)
+
+### Turbo Whisper Recommendations
+- **Yes GPU + daily:** docker mode
+- **No GPU + daily:** local mode (with warning: slower)
+- **Not daily:** skip (can install later)
+
+### Agent Recommendations
+- **Beginner:** 1-2 agents (byan only)
+- **Intermediate:** 3-5 agents (byan + analyst + pm)
+- **Expert:** All agents (full toolbox)
+
+### Methodology Mapping
+- **TDD → Tea module** priority
+- **Merise Agile → BMM** full workflow
+- **Agile/Hybrid → Quick-flow** prioritized
+
+## Usage in NPX
+
+```javascript
+const result = execSync(`copilot --agent=bmad-agent-yanstaller --prompt "interview" --model gpt-5-mini`);
+const json = JSON.parse(extractJSON(result));
+
+// Apply recommendations
+const platform = json.recommendations.platforms[0].name;
+const turboMode = json.recommendations.turboWhisper.mode;
+```