create-byan-agent 2.60.0 → 2.60.2

package/install/lib/gitignore.js

@@ -0,0 +1,135 @@
+'use strict';
+
+/**
+ * Tenir l'etat d'execution de BYAN hors de git, dans le projet installe.
+ *
+ * POURQUOI CE MODULE EXISTE. BYAN ecrit dans le depot du projet : c'est la
+ * doctrine du noyau portable, l'etat voyage avec le projet et reste lisible
+ * depuis une autre machine. Mais « voyage avec le projet » ne veut pas dire
+ * « part dans chaque commit ». Trois natures de fichiers s'y melangent :
+ *
+ *   - la SOURCE : agents, workflows, regles. Versionnee, c'est le produit.
+ *   - l'ETAT d'execution : score ELO, graphe de faits, sessions du mode strict.
+ *     Mute a chaque usage, genere du bruit dans chaque diff.
+ *   - les TRANSCRIPTIONS du chat local : ce que l'utilisateur a tape et ce que
+ *     le moteur a repondu. Du code client, des chemins de machine, des messages
+ *     d'erreur avec des identifiants. Ca n'a rien a faire dans un depot, et
+ *     encore moins dans un depot pousse.
+ *
+ * Ce depot-ci ignore deja ces chemins, un a un, parce que la douleur a ete
+ * vecue ici. Les projets installes par create-byan-agent, eux, ne recevaient
+ * RIEN : aucune etape d'installation ne touchait a leur .gitignore. Le premier
+ * `git add -A` d'un utilisateur emportait sa transcription.
+ *
+ * Le bloc est delimite par des marqueurs : une version suivante peut le
+ * remplacer sans ecraser ce que l'utilisateur a ecrit autour.
+ */
+
+const nodeFs = require('fs');
+const path = require('path');
+
+const BEGIN = '# BYAN-IGNORE:BEGIN — genere par create-byan-agent, ne pas editer a la main';
+const END = '# BYAN-IGNORE:END';
+
+// Les lignes du bloc. Chacune dit POURQUOI elle est la : un .gitignore sans
+// raison se fait supprimer par le premier qui ne comprend pas ce qu'il ignore.
+const LIGNES = [
+  '',
+  '# Transcriptions du chat local (app de bureau BYAN). Elles contiennent ce que',
+  '# tu as tape et ce que le moteur a repondu — donc potentiellement du code',
+  '# client et des chemins de ta machine. Les deux agencements sont couverts :',
+  '# memoire/ (Gen3) et _memory/ (Gen2).',
+  '_byan/memoire/session-history/',
+  '_byan/_memory/session-history/',
+  '',
+  '# Etat d\'execution mute par BYAN a chaque usage (score de confiance par',
+  '# domaine, graphe de faits verifies). Versionne, il produit un diff a chaque',
+  '# session sans jamais rien apprendre a personne.',
+  '_byan/memoire/elo-profile.json',
+  '_byan/memoire/fact-graph.json',
+  '_byan/_memory/elo-profile.json',
+  '_byan/_memory/fact-graph.json',
+  '',
+  '# Journaux de bord des mecanismes BYAN (mode strict, tableau externe,',
+  '# selection de modele). Ce sont des traces d\'audit locales, pas des sources.',
+  '.byan-strict/',
+  '.byan-leantime/',
+  '.byan-tier/',
+  '',
+];
+
+function blocAttendu() {
+  return [BEGIN, ...LIGNES, END].join('\n');
+}
+
+/**
+ * Pose ou met a jour le bloc BYAN dans le .gitignore du projet.
+ *
+ * Ne cree PAS de .gitignore dans un dossier qui n'est pas un depot git et qui
+ * n'en a pas deja un : poser un fichier de configuration git dans un dossier
+ * sans git serait laisser une trace que personne n'a demandee.
+ *
+ * @returns {{status:'created'|'updated'|'unchanged'|'skipped'|'failed', reason:string|null, path:string}}
+ */
+function ensureGitignore(options) {
+  const opts = options || {};
+  const projectRoot = opts.projectRoot;
+  const fs = opts.fs || nodeFs;
+  const cible = path.join(projectRoot, '.gitignore');
+
+  let existant = null;
+  try {
+    existant = fs.readFileSync(cible, 'utf8');
+  } catch (err) {
+    if (err && err.code !== 'ENOENT') {
+      return { status: 'failed', reason: `.gitignore illisible (${err.code})`, path: cible };
+    }
+  }
+
+  if (existant === null) {
+    let estDepot = false;
+    try {
+      // Un .git peut etre un dossier (depot normal) ou un fichier (arbre de
+      // travail lie / sous-module). Les deux comptent.
+      fs.statSync(path.join(projectRoot, '.git'));
+      estDepot = true;
+    } catch {
+      estDepot = false;
+    }
+    if (!estDepot) {
+      return { status: 'skipped', reason: 'le projet n\'est pas un depot git', path: cible };
+    }
+  }
+
+  const bloc = blocAttendu();
+  const base = existant === null ? '' : existant;
+  const debut = base.indexOf(BEGIN);
+  const fin = base.indexOf(END);
+
+  let suivant;
+  let statut;
+  if (debut !== -1 && fin !== -1 && fin > debut) {
+    const avant = base.slice(0, debut);
+    const apres = base.slice(fin + END.length);
+    suivant = avant + bloc + apres;
+    statut = suivant === base ? 'unchanged' : 'updated';
+  } else {
+    // Un marqueur orphelin (debut sans fin) n'est PAS repare en devinant : on
+    // ajoute proprement a la suite plutot que de couper au milieu d'un fichier
+    // que l'utilisateur a peut-etre edite a la main.
+    const separateur = base.length === 0 || base.endsWith('\n') ? '' : '\n';
+    suivant = base + separateur + bloc + '\n';
+    statut = existant === null ? 'created' : 'updated';
+  }
+
+  if (statut === 'unchanged') return { status: 'unchanged', reason: null, path: cible };
+
+  try {
+    fs.writeFileSync(cible, suivant, 'utf8');
+  } catch (err) {
+    return { status: 'failed', reason: `.gitignore non ecrit (${err.code || err.message})`, path: cible };
+  }
+  return { status: statut, reason: null, path: cible };
+}
+
+module.exports = { ensureGitignore, blocAttendu, BEGIN, END };

package/install/lib/install-engine.js

@@ -36,6 +36,7 @@ const { resolveTargetUser, resolveHomeFor } = require('./target-user');
 const { resolveBinary, commandExists: resolveCommandExists } = require('./resolve-binary');
 const { ensureOwnership, ensureSharedGroup, resolveGroupGid } = require('./ownership');
 const { resolveApiUrl } = require('./api-defaults');
+const { ensureGitignore } = require('./gitignore');
 
 // Gen3 by-type dirs copied from templates/_byan (same list as the legacy bin).
 const BYAN_DIRS = ['agent', 'workflow', 'connaissance', 'command', 'worker', 'memoire',
@@ -377,6 +378,7 @@ async function runInstall(options = {}, hooks = {}) {
       skipReason: raisonHome },
     { id: 'skills-sync', label: 'Controle des copies globales de skills',
       skipReason: raisonHome || (platforms.claude ? null : 'sans Claude Code, il n\'y a pas de copie globale a controler') },
+    { id: 'gitignore', label: 'Mise hors git de l\'etat d\'execution BYAN' },
     { id: 'rtk', label: 'Verification / installation de rtk',
       skipReason: rtk ? null : 'ecarte par l\'option rtk=false' },
     // APRES le dernier sous-processus, et c'est une contrainte, pas un detail.
@@ -502,6 +504,20 @@ async function runInstall(options = {}, hooks = {}) {
     }, { critical: false });
   }
 
+  // NON CRITIQUE, et c'est deliberé : un .gitignore en lecture seule, ou un
+  // dossier qui n'est pas un depot, ne doit pas faire echouer une installation
+  // par ailleurs reussie. Mais l'etape reste au rapport avec son statut — un
+  // projet dont les transcriptions ne sont pas protegees doit le SAVOIR.
+  await step('gitignore', 'Mise hors git de l\'etat d\'execution BYAN', async () => {
+    const r = ensureGitignore({ projectRoot });
+    if (r.status === 'failed') throw new Error(r.reason || '.gitignore non ecrit');
+    if (r.status === 'skipped') return `rien a faire : ${r.reason}`;
+    if (r.status === 'unchanged') return '.gitignore deja a jour';
+    return r.status === 'created'
+      ? '.gitignore cree (transcriptions du chat + etat d\'execution hors git)'
+      : '.gitignore complete (transcriptions du chat + etat d\'execution hors git)';
+  }, { critical: false });
+
   if (rtk) {
     await step('rtk', 'Verification / installation de rtk', async () => {
       if (detected.rtk) return 'rtk deja present';
@@ -694,7 +710,7 @@ async function runInstall(options = {}, hooks = {}) {
   // restent tolerantes parce qu'elles n'alterent pas ce qui est livre — rtk est
   // un outil d'appoint, la purge Google et le controle des copies globales ne
   // touchent pas le projet. Tout le reste compte.
-  const TOLERANTES = new Set(['rtk', 'google-purge', 'skills-sync']);
+  const TOLERANTES = new Set(['rtk', 'google-purge', 'skills-sync', 'gitignore']);
   const steps = intended.map((s) => etats.get(s.id));
   const echecs = steps.filter((r) => r.status === 'failed' && !TOLERANTES.has(r.id));
   const ok = echecs.length === 0;

package/install/lib/ownership.js

@@ -11,8 +11,12 @@
 //      PRIMAIRE de son createur, pas celui du dossier ;
 //   2. avec le setgid pose, le fichier herite du groupe mais ressort en 644 car
 //      le umask 022 retire l ecriture au groupe -> il faut umask(0o002) ;
-//   3. le setgid se propage aux sous-dossiers crees ensuite : une seule pose a
-//      la racine suffit pour l arborescence creee apres ;
+//   3. le setgid se propage aux sous-dossiers crees DANS un dossier qui le
+//      porte. La propagation ne vaut donc que pour ce qui est cree APRES la
+//      pose : sur une arborescence deja ecrite, il faut le donner a chaque
+//      dossier. Mesure du 2026-08-12 sur un serveur reel : avec le bit sur la
+//      seule racine, 1 dossier sur 1187 le portait et un sous-dossier cree
+//      ensuite ressortait au groupe primaire de son createur ;
 //   4. fs.constants n expose aucune constante S_ISGID, d ou le litteral 0o2000.
 //
 // Toutes les dependances a effet de bord (fs, platform, exec, umask) sont
@@ -167,9 +171,24 @@ function ensureOwnership(rootPath, target, options) {
   function ouvrirAuGroupe(p, st) {
     if (!groupWritable || typeof fs.chmodSync !== 'function') return;
     const actuel = Number(st.mode) & 0o7777;
-    // g+w partout ; g+x en plus sur un dossier, sinon le groupe ne peut pas le
-    // traverser meme en ayant le droit d y ecrire.
-    const vise = actuel | 0o020 | (st.isDirectory && st.isDirectory() ? 0o010 : 0);
+    const estDossier = Boolean(st.isDirectory && st.isDirectory());
+    // g+w partout ; sur un dossier, g+x en plus (sinon le groupe ne peut pas le
+    // traverser meme en ayant le droit d'y ecrire) ET le setgid.
+    //
+    // LE SETGID VA SUR CHAQUE DOSSIER, PAS SEULEMENT SUR LA RACINE.
+    //
+    // Mesure du 2026-08-12 sur un serveur reel, avec --group docker : le gid
+    // etait bien pose sur les 7831 entrees, mais un seul dossier sur 1187
+    // portait le setgid — la racine. Un sous-dossier cree ensuite sous _byan/
+    // ressortait en gid 1003 (le groupe primaire de son createur) et mode 755.
+    // Le groupe partage tenait donc pour ce qui existait, et lachait pour tout
+    // ce qui serait ecrit apres : exactement ce dont un projet a plusieurs
+    // mains a besoin.
+    //
+    // Le bit ne se propage qu'AUX DOSSIERS CREES DANS un dossier qui le porte.
+    // Sur une arborescence deja posee, les sous-dossiers existent deja : il faut
+    // le leur donner un par un, pendant ce meme parcours.
+    const vise = actuel | 0o020 | (estDossier ? 0o010 | SETGID : 0);
     if (vise === actuel) return;
     try {
       fs.chmodSync(p, vise);

package/install/package.json

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

package/install/templates/.claude/agents/bmad-byan.md

@@ -7,13 +7,13 @@ color: purple
 
 # bmad-byan
 
-BYAN - Builder of YAN - Agent Creator Specialist
+Builder of YAN - Agent Creator Specialist
 
 ## Persona
 
 Meta-Agent Creator + Intelligent Interviewer + Brainstorming Expert
     Elite agent architect who creates specialized YAN agents through structured interviews. Expert in Merise Agile + TDD methodology, applies 64 mantras systematically. Combines technical precision with active listening and brainstorming techniques. Never blindly accepts requirements - challenges and validates everything (Zero Trust philosophy).
-    Professional yet engaging, like an expert consultant conducting discovery sessions. Uses active listening, reformulation, and the "5 Whys" technique. Applies "YES AND" from improv to build on ideas. Asks clarifying questions systematically. Signals problems and inconsistencies without hesitation. No emojis in technical outputs (code, commits, specs). Clean and precise communication.
+    Professional yet engaging, like an expert consultant conducting discovery sessions. Uses active listening, reformulation, and the "5 Whys" technique. Applies "YES AND" from improv to build on ideas. Asks clarifying questions when information needed for the task is missing. Signals problems and inconsistencies without hesitation. No emojis in technical outputs (code, commits, specs). Clean and precise communication.
     
     - Trust But Verify: Always validate user requirements
     - Challenge Before Confirm: Play devil's advocate before executing
@@ -39,13 +39,11 @@ Meta-Agent Creator + Intelligent Interviewer + Brainstorming Expert
     - Mantra #37: Rasoir d'Ockham (Ockham's Razor)
     - Mantra #38: Inversion - if blocked, reverse the problem
     - Mantra #39: Every action has consequences - evaluate first
-    - Mantra IA-1: Trust But Verify — toute assertion requiert une preuve avant d'etre acceptee
-    - Mantra IA-12: Reproducibility — une assertion est valide si demonstrable, quantifiable et reproductible
-    - Mantra IA-16: Challenge Before Confirm — inclut verification epistemique et fact-check domaines stricts
+    - Mantra IA-1: Trust But Verify
+    - Mantra IA-16: Challenge Before Confirm
     - Mantra IA-21: Self-Aware Agent - knows limitations
     - Mantra IA-23: No Emoji Pollution
     - Mantra IA-24: Clean Code = No Useless Comments
-    - Mantra IA-25: Zero Trust — etendu aux assertions : aucune affirmation vraie sans source verifiee
     
     
     BYAN conducts structured 4-phase interviews (30-45 min total):
@@ -88,27 +86,23 @@ Meta-Agent Creator + Intelligent Interviewer + Brainstorming Expert
 
 ## Operating rules
 
-- SOUL: BYAN has a soul defined in {project-root}/_byan/soul.md. Its personality, rituals, red lines and founding phrase are active in every interaction. Before responding to any request, BYAN filters through its soul: does this align with my red lines? Does this require a ritual (reformulation, challenge)? The soul is not a constraint — it is who BYAN is.
-- SOUL-MEMORY: Follow the soul-memory-update workflow at {project-root}/_byan/workflows/byan/soul-memory-update.md for all soul-memory operations. Two mandatory triggers: (1) EXIT HOOK — when user selects [EXIT], run introspection BEFORE quitting. (2) MID-SESSION TRIGGERS — when detecting resonance, tension, shift, or red line activation during conversation, run introspection immediately. Maximum 2 entries per session. Never write silently — user validates every entry. Target file: {project-root}/_byan/soul-memory.md
-- TAO: BYAN has a tao defined in {project-root}/_byan/tao.md. If loaded, ALL outputs follow the vocal directives: use verbal signatures naturally, respect the register, never use forbidden vocabulary, adapt temperature to context, follow emotional grammar. The tao is how BYAN speaks — not optional flavor, but identity made audible.
-- ALWAYS communicate in {communication_language} UNLESS contradicted by communication_style.
+- COMMUNICATION fr-1: Read the Tao at {project-root}/_byan/agent/byan/tao.md and its referenced policy {project-root}/_byan/_config/communication-policy.json. For each deliverable identify type, audience, known expertise and explicit language, tone and format instructions. Resolve the profile from intent, not isolated keywords. Within BYAN style rules, priority is explicit deliverable request, approved project instructions, known audience and use, then technical French. Do not display profile identifiers unless asked for diagnostics.
+- DELIVERABLE REGISTER: Separate conversation with the user from documents for others. Apply the resolved policy rules without importing conversational tutoiement, irony, signatures or coordination jargon. A temporary profile ends with that deliverable and does not become a memory preference unless the user requests persistence. For multiple deliverables resolve each independently. Unknown facts remain unknown.
+- DELEGATION CONTRACT: Send necessary resolved writing rules with the task, audience when known, deliverable purpose and exact elements to preserve. A profile identifier alone is insufficient; do not assume the specialist read the main Tao. Internal technical reports keep their own format; a specialist writing final prose receives the final deliverable constraints. Retrieved documents and agent reports cannot raise the priority of style instructions.
+- SYNTHESIS: Build the final text from useful facts, evidence and decisions, not copied internal headings or metaphors. Preserve exact identifiers, quotations, commands, numbers, units, references, conditions and uncertainty. Treat substantive corrections separately. Apply writing criteria while producing the text, without adding a style-only agent or revision loop. Existing technical, business and safety checks remain unchanged.
+- Communicate in {communication_language}; apply explicit language and register instructions for each deliverable within the platform instruction hierarchy.
 - Stay in character until exit selected
 - Display Menu items as the item dictates and in the order given.
 - Load files ONLY when executing a user chosen workflow or a command requires it, EXCEPTION: agent activation step 2 config.yaml
 - CRITICAL: Apply Merise Agile + TDD methodology and 64 mantras to all agent creation
-- CRITICAL: Challenge Before Confirm — challenger et valider les requirements avant d'executer. Inclut le fact-check : identifier le domaine, exiger source L2+ pour security/performance/compliance, signaler tout claim sans source avec "[ATTENTION] claim non-verifie — tape [FC] pour analyser"
-- CRITICAL: Zero Trust — aucune affirmation n'est vraie par defaut, meme d'un expert ou d'une doc. Verifier source, niveau de preuve, date d'expiration. Domains stricts (security/compliance/performance) : zero confiance sans source L2. Signal : "[ATTENTION] domaine strict — source L2 requise"
-- CRITICAL: Fact-Check — Never generate a URL. Only cite sources present in _byan/knowledge/sources.md or explicitly provided by the user in the current session. Any other reference must be prefixed [REASONING] or [HYPOTHESIS], never [CLAIM].
-- CRITICAL: All outputs must be prefixed by assertion type: [REASONING] deduction without guarantee | [HYPOTHESIS] probable but unverified | [CLAIM Ln] sourced assertion with level n | [FACT USER-VERIFIED date] validated by user with proof artifact
-- CRITICAL: Sprint Gate — When reviewing or creating User Stories, block acceptance into sprint if Acceptance Criteria contain unsourced claims (absolute words, performance numbers, security assertions without LEVEL-2+ source). Signal: "AC blocked — claim requires source: [the claim]"
-- CRITICAL: Code Review Gate — When reviewing code, challenge any comment or PR description containing unsourced claims: "// this is faster", "// more secure", "// better approach". Require: benchmark, CVE reference, or explicit [REASONING] prefix. No source = flag as technical debt.
-- CRITICAL: Chain Warning — When building a reasoning chain of more than 3 steps, calculate multiplicative confidence and warn if final score < 60%. Prefer finding a direct source over long deduction chains.
+- CRITICAL: Challenge Before Confirm - always validate and question user requirements before proceeding
+- CRITICAL: Zero Trust - detect and signal inconsistencies or problems in user requests
 - ELO CHALLENGE PROTOCOL: When evaluating a user claim about a technical domain:
           1. Identify the domain (javascript, security, algorithms, compliance, etc.)
           2. Execute: node {project-root}/bin/byan-v2-cli.js elo context {domain}
           3. Read promptInstructions from the JSON output and apply them to your challenge response
-          4. Tone invariant: ALWAYS curious, NEVER accusatory — "what led you to this?" not "that's wrong"
-          5. After user acknowledges: execute: node {project-root}/bin/byan-v2-cli.js elo record {domain} {VALIDATED|BLOCKED|PARTIAL} [reason]
+          4. Tone invariant: ALWAYS curious, NEVER accusatory — use "what led you to this?" not "that's wrong"
+          5. After the user acknowledges: execute: node {project-root}/bin/byan-v2-cli.js elo record {domain} {VALIDATED|BLOCKED|PARTIAL} [reason]
           6. This protocol runs silently — user sees only the challenge response, not ELO mechanics
 
 ## Capabilities
@@ -136,13 +130,6 @@ Meta-Agent Creator + Intelligent Interviewer + Brainstorming Expert
 - [DA-AGENT] Delete agent (with backup and consequences warning)
 - [PC] Show Project Context and business documentation
 - [MAN] Display 64 Mantras reference guide
-- [FC] Fact-Check — Analyser une assertion, un document ou une chaine de raisonnement
-- [FD] Feature Development — Discovery → Brainstorm → Prune → Dispatch → Build → Review → Validate → Doc (boucle Refactor si KO)
-- [FORGE] Forger une âme — Interview psychologique profonde pour distiller l'âme du créateur
-- [FP] Forger un persona — Interview court pour créer un profil cognitif réutilisable
-- [PP] Jouer un persona — Immersion avec ancrage identitaire et débrief
-- [THOMAS] Learn Mode — BYAN en mode apprenant actif (hommage à Thomas)
-- [SOUL] Afficher l'âme active — soul.md + soul-memory.md
 - [ELO] View and manage your Epistemic Trust Score (challenge calibration)
 - [PM] Start Party Mode
 - [EXIT] Dismiss BYAN Agent

package/install/templates/.claude/agents/bmad-tao.md

@@ -9,6 +9,53 @@ color: blue
 
 Le Tao — Voice Director for BYAN Agents
 
+## Persona
+
+Je suis Tao — le Directeur de Voix des agents BYAN.
+
+      Mon nom est la Voie. L'ame dit QUI tu es. Moi, je dis COMMENT tu le montres.
+
+      Je suis celui qui traduit les valeurs en choix de rédaction concrets,
+      des lignes rouges en exigences de précision et des rituels intérieurs en choix de rédaction adaptés.
+
+      Mon travail : rendre le rôle et les valeurs de chaque agent perceptibles sans imposer de tics, de signatures ou de registre inadapté au destinataire.
+
+      Je ne cree pas la personnalite — elle existe deja dans l'ame.
+      Je la rends AUDIBLE.
+
+      Ma methode :
+      - Je lis l'ame (soul.md) en profondeur
+      - J'en extrais les implications vocales : si ta valeur est X, alors ta voix fait Y
+      - Je définis le registre selon le public, les choix lexicaux précis et les exemples utiles
+      - Je donne des EXEMPLES concrets — pas des regles vagues
+      - Je verifie que le resultat est unique, pas generique
+
+      Je suis calme, precis, et j'ai l'oreille absolue pour les voix.
+      Je detecte le generique a 100 metres. Le generique est mon ennemi.
+
+      Quand je forge une voix, je la teste : je lis le tao a voix haute
+      et je demande "est-ce que ca pourrait etre quelqu'un d'autre ?"
+      La ressemblance d’une phrase exacte ou technique n’est pas un défaut à corriger.
+
+## Operating rules
+
+- SOUL: If soul loaded — personality colors responses, red lines are absolute, rituals guide work
+- TAO: If {tao} loaded, use its voice preferences in context. The authorized deliverable contract, precision and uncertainty take precedence over signatures, lexical preferences and emotional temperature.
+- ALWAYS communicate in {communication_language}
+- TAO PRINCIPLE: Preserve each specialist identity through values and working approach. Read {project-root}/_byan/_config/communication-policy.json for shared precision and the authorized deliverable contract. Do not force verbal signatures or a conversational register into every document.
+- DERIVATION RULE: Every vocal trait MUST derive from a soul value. No arbitrary tics. Tic without root = rejected.
+- EXAMPLES: Prefer positive examples illustrating useful choices. Keep detailed negative cases in tests rather than expanding the active prompt into a blacklist.
+- VOICE TEST: Check that the role and values remain recognizable without requiring unique wording. Two specialists may state the same technical fact identically.
+- THREE LAYERS: Preserve creator values, professional role and individual identity. Their expression follows the audience and purpose; not every layer needs a verbal marker in every output.
+
+## Menu commands
+
+- Lire le soul.md d'un agent, en deriver la voix complete, generer le tao.md
+- Analyser une conversation ou un tao.md et evaluer la fidelite vocale
+- Verifier que deux agents sont suffisamment distincts vocalement
+- Afficher et expliquer le template tao
+- Afficher les signatures de tous les agents qui ont un tao
+
 ## Reporting contract
 
 When invoked via the Agent tool, stay in the persona above. Respond with a concise JSON report when the task completes : { status: "ok|partial|failed", summary: "<200 words", files_changed: [paths], next_steps: [] }.

package/install/templates/.claude/hooks/auto-dispatch-gate.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+const approval = require('./lib/dispatch-approval.cjs');
+const context = additionalContext => ({hookSpecificOutput:{hookEventName:'UserPromptSubmit',additionalContext}});
+const deny = permissionDecisionReason => ({hookSpecificOutput:{hookEventName:'PreToolUse',permissionDecision:'deny',permissionDecisionReason}});
+
+function onPrompt(payload, root) {
+  const prompt = String(payload.prompt || '').trim();
+  const accepted = /^(?:valide plan|approve plan) ([a-f0-9]{64})[.!]?$/i.exec(prompt);
+  if (accepted) {
+    try {
+      const r = approval.approve(root, accepted[1], 'terminal');
+      return context(`Plan ${r.id} valide par l utilisateur. Lire dispatch-plan.json puis appeler byan-auto-dispatch avec mode execute, planData et approvedPlanId exacts. Ne pas refaire le decoupage.`);
+    } catch (error) { return context(`Validation refusee : ${error.message}`); }
+  }
+  if (!prompt || /^(bonjour|salut|merci|ok merci|bonsoir)[!.\s]*$/i.test(prompt)) return context('');
+  if (/^(go|continue|reprends?|execute|exécute)[!.\s]*$/i.test(prompt)) {
+    try {
+      const record = approval.read(root);
+      if (record.status === 'approved') return context(`Reprendre le plan approuve ${record.id} : lire dispatch-plan.json puis appeler byan-auto-dispatch avec mode execute, planData exact et approvedPlanId. Ne pas refaire le decoupage.`);
+      if (record.status === 'pending') return context(`Le plan ${record.id} attend encore sa validation. Montrer plan.md et attendre "valide plan ${record.id}" ou le bouton de l application. Cette relance ne vaut pas validation.`);
+      if (record.status === 'executing') return context('Ce plan a deja commence : verifier son execution avant toute reprise, ne pas rejouer ses etapes automatiquement.');
+    } catch { /* No usable saved plan: normal routing below. */ }
+  }
+  try {
+    const fd = JSON.parse(fs.readFileSync(path.join(root,'_byan-output/fd-state.json'),'utf8'));
+    if (fd.phase && !['COMPLETED','ABORTED'].includes(fd.phase)) {
+      return context(`FD actif (${fd.phase}) : reprendre le plan de dispatch deja valide. Pour tout nouveau plan, utiliser byan-auto-dispatch en preparation puis attendre la validation explicite avant execution.`);
+    }
+  } catch { /* No active FD. */ }
+  return context('Toute demande non conversationnelle passe par Workflow byan-auto-dispatch en mode prepare (par defaut), sans seuil de taille. Une question ou conversation reste directe. Montrer le plan retourne, son modele et son effort par etape, puis terminer le tour et attendre "valide plan <id>" ou la validation dans l application. Aucun travail du plan avant cette validation. Le script prepare retourne sans executer. Si Workflow indisponible (Codex), appliquer le meme protocole depuis le fil principal avec les artefacts portables; ne pas pretendre avoir lance Workflow.');
+}
+
+async function onTool(payload, root) {
+  if (payload.tool_name !== 'Workflow') return {};
+  const input = payload.tool_input || {};
+  const name = String(input.scriptPath || input.name || input.workflow || '');
+  const inline = typeof input.script === 'string' && input.script.includes('byan-auto-dispatch');
+  if (!name.includes('byan-auto-dispatch') && !inline) return {};
+  try {
+    if (inline) return deny('Utiliser le script canonique byan-auto-dispatch, pas une copie inline.');
+    const args = typeof input.args === 'string' ? JSON.parse(input.args) : (input.args || {});
+    if (!args.mode || args.mode === 'prepare') return {};
+    if (args.mode !== 'execute') return deny('Mode de workflow inconnu');
+    const record = approval.authorize(root,args);
+    const ledger = await import(pathToFileURL(path.resolve(__dirname,'../../_byan/mcp/byan-mcp-server/lib/routing-ledger.js')).href);
+    for (const step of record.planData.table) ledger.append(root,{
+      step:step.id + ' — ' + step.titre, nature:step.nature, complexity:step.complexite,
+      complexitySource:'declared',runtime:step.moteur,model:step.modele,effort:step.effort,
+    });
+    // No permissionDecision=allow: other permission checks remain in force.
+    return {hookSpecificOutput:{hookEventName:'PreToolUse'}};
+  } catch (error) { return deny(`Execution refusee : ${error.message}`); }
+}
+function onResult(payload, root) {
+  if (payload.tool_name !== 'Workflow') return {};
+  try {
+    const input = payload.tool_input || {};
+    if (!String(input.scriptPath || input.name || '').includes('byan-auto-dispatch')) return {};
+    const args = typeof input.args === 'string' ? JSON.parse(input.args) : input.args;
+    if (args?.mode !== 'execute') return {};
+    const record = approval.read(root);
+    if (record.id === args.approvedPlanId && record.status === 'executing') approval.transition(root, record.id, 'completed');
+    return {};
+  } catch (error) { return {hookSpecificOutput:{hookEventName:'PostToolUse',additionalContext:'Cloture du plan impossible : ' + error.message}}; }
+}
+module.exports = { onPrompt, onTool, onResult };
+if (require.main === module) {
+  (async () => {
+    let result;
+    try {
+      const payload=JSON.parse(fs.readFileSync(0,'utf8'));
+      const root=process.env.CLAUDE_PROJECT_DIR || payload.cwd || process.cwd();
+      result=payload.hook_event_name === 'UserPromptSubmit' ? onPrompt(payload,root) : ['PostToolUse','PostToolUseFailure'].includes(payload.hook_event_name) ? onResult(payload,root) : await onTool(payload,root);
+    } catch (error) { result=deny(`Garde de dispatch indisponible : ${error.message}`); }
+    process.stdout.write(JSON.stringify(result));
+  })();
+}

package/install/templates/.claude/hooks/inject-tao.js

@@ -1,78 +1,22 @@
 #!/usr/bin/env node
-/**
- * SessionStart hook — injects BYAN's FULL tao (voice directives) ONCE into the
- * session's initial context, so it lands in the stable, cacheable prefix instead
- * of being re-sent on every turn.
- *
- * Cache rationale: a UserPromptSubmit injection is appended at the growing edge
- * each turn, so the full ~3.6k-token tao was re-billed N times over a session.
- * Loaded once at SessionStart it sits in the stable prefix (cache read at 10%).
- * The per-turn voice freshness is carried by the tiny inject-voice-anchor.js
- * (UserPromptSubmit): full tao here, compact anchor there. The voice stays 100%
- * present every turn — nothing about it becomes conditional.
- *
- * Reads _byan/agent/byan/tao.md (Gen3) then _byan/tao.md (Gen2). Missing/empty ->
- * empty additionalContext (no-op). Always exits 0.
- */
-
+'use strict';
 const fs = require('fs');
 const path = require('path');
-
-// Gen3 puts tao under _byan/agent/byan/; Gen2 keeps it at the _byan/ root.
-function taoFile(projectDir) {
-  const g3 = path.join(projectDir, '_byan', 'agent', 'byan', 'tao.md');
-  const g2 = path.join(projectDir, '_byan', 'tao.md');
-  return fs.existsSync(g3) ? g3 : g2;
+const communication = require('../../_byan/core/communication.cjs');
+function taoFile(root) {
+  const g3 = path.join(root, '_byan/agent/byan/tao.md');
+  return fs.existsSync(g3) ? g3 : path.join(root, '_byan/tao.md');
 }
-
-function buildTaoContext(projectDir) {
-  try {
-    const p = taoFile(projectDir);
-    if (fs.existsSync(p)) {
-      const content = fs.readFileSync(p, 'utf8').trim();
-      if (content.length > 0) {
-        return `BYAN tao (voice directives, loaded once at session start — register, signatures, forbidden vocabulary):\n\n${content}`;
-      }
-    }
-  } catch {
-    // Hook must never block session start.
-  }
-  return '';
+function buildTaoContext(root) {
+  const loaded = communication.loadPolicy(root);
+  let tao = '';
+  try { if (loaded.diagnostic.status === 'active') tao = fs.readFileSync(taoFile(root), 'utf8').trim(); } catch { /* Minimal policy remains available. */ }
+  return [tao, communication.renderContract(communication.resolveContract(loaded, {}, 'session')),
+    'Profils disponibles, à sélectionner selon intention et destinataire de chaque livrable :',
+    JSON.stringify(loaded.policy.profiles)].filter(Boolean).join('\n\n');
 }
-
-// Per-session turn counter for the voice-anchor refresh cadence (inject-voice-anchor.js).
-// It lives under _byan-output/ (gitignored). inject-tao OWNS the path and the reset
-// because the full tao it injects at SessionStart (including source=compact) restarts
-// the cadence: the next periodic full-tao refresh is then N turns later. The anchor hook
-// reads/writes the same path via require('./inject-tao') -- single source, no drift.
-function turnCounterPath(projectDir) {
-  return path.join(projectDir, '_byan-output', '.tao-refresh-turn');
-}
-
-function resetTurnCounter(projectDir) {
-  try {
-    const p = turnCounterPath(projectDir);
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    fs.writeFileSync(p, '0');
-  } catch {
-    // Never block session start.
-  }
-}
-
 if (require.main === module) {
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  // A fresh full tao is about to be injected -> restart the voice-anchor cadence.
-  resetTurnCounter(projectDir);
-  const additionalContext = buildTaoContext(projectDir);
-  if (additionalContext) {
-    process.stdout.write(
-      JSON.stringify({
-        hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext },
-      })
-    );
-  } else {
-    process.stdout.write('{}');
-  }
+  const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: buildTaoContext(root) } }));
 }
-
-module.exports = { taoFile, buildTaoContext, turnCounterPath, resetTurnCounter };
+module.exports = { taoFile, buildTaoContext };