create-byan-agent 2.52.0 → 2.54.0

package/CHANGELOG.md

@@ -9,6 +9,62 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.54.0] - 2026-07-21
+
+### Added — Garde de fraicheur des skills (SessionStart)
+- Nouveau hook `skill-freshness-check.js` (coeur pur `lib/skill-freshness.js`) :
+  au demarrage de session, compare chaque `.claude/skills/<n>/SKILL.md` du
+  projet avec la copie globale homonyme `~/.claude/skills/<n>/SKILL.md`, par
+  CONTENU (l'egalite d'octets dit "fidele" ; une date recente ne dit rien).
+  En cas de divergence, injecte un signalement borne (6 noms max) avec la
+  commande de synchro exacte. Silencieux quand tout est fidele, quand la copie
+  globale n'existe pas, ou quand le projet n'a pas de skills ; sort en 0 dans
+  tous les chemins (ne bloque pas une session).
+- Ferme le piege constate le 2026-07-21 : une copie globale du 30 juin masquait
+  le skill projet — le rail auto-dispatch livre en 2.53.0 ne se declenchait pas
+  car `/byan-byan` chargeait la copie perimee. Point verifie aupres de la doc
+  officielle Claude Code : la regle de priorite skills user vs projet en cas de
+  collision de nom n'y est pas clairement documentee (le hook signale donc le
+  FAIT de la divergence, sans affirmer une regle de chargement).
+- Aucune ecriture automatique dans `~/.claude/skills` : une variante user-level
+  peut etre deliberee — le hook signale, l'humain tranche.
+- Cablage : enregistre sous SessionStart dans `.claude/settings.json` (repo +
+  template) ; les deux fichiers shippent via le miroir `template-sync.js`.
+
+## [2.53.0] - 2026-07-21
+
+### Added — Rail automatique : workflow natif byan-auto-dispatch (F2)
+- Nouveau workflow Claude natif `.claude/workflows/byan-auto-dispatch.js` : il
+  decoupe une tache en etapes typees (nature + complexite 0-100) via un agent
+  d'analyse (sonnet, schema JSON force), route chaque etape sur le bon modele
+  par l'echelle v3 (haiku < 34, sonnet < 67, opus < 90, fable >= 90), route les
+  etapes shell/deploiement/navigation vers Codex (repli Claude annonce si Codex
+  n'est pas disponible ; la verification reste sur le modele de session, non
+  deleguee), ecrit `_byan-output/plan.md` (table etape x nature x complexite x
+  moteur x modele + consignes), execute chaque etape en sequence sur le modele
+  route, et verifie le livrable en fin.
+- Cablage skill `byan-byan` (section 0.5) : a CHAQUE tache non-conversationnelle
+  recue par `/byan-byan`, ce workflow est invoque AUTOMATIQUEMENT (scriptPath +
+  args {task, stamp}), sans demande a l'utilisateur. Exceptions nommees :
+  question simple, action destructive (confirmation d'abord), FD multi-feature
+  deja engage (sa phase DISPATCH peut invoquer le meme workflow par feature),
+  demande explicite d'execution directe. Le gate utilisateur reste en fin, sur
+  le livrable.
+- Livraison npm : le script est ajoute au miroir `template-sync.js`.
+
+### Changed — Langage precis, zero dialecte interne (F1, Mantra IA-26)
+- Le filet plain-language s'etend : `nudge`, `up-tier`, `ladder`, `rung`,
+  `runtime` rejoignent les mots a remplacer en prose ; nouvelle detection de
+  l'anthropomorphisme d'outil (un MCP/serveur/hook dit "vivant" ou "mort") avec
+  le remplacement exige : le fait observe, outil nomme ("byan_ping a repondu en
+  0.3s", "le serveur ne repond pas, timeout 8s").
+- Nouvelle clause de precision factuelle dans `.claude/rules/plain-language.md` :
+  tout etat d'outil = l'outil nomme + l'appel + le resultat exact ; pas de
+  resume flou ("ca marche") ; "non verifie" quand l'appel n'a pas ete fait.
+- L'ancre de voix par tour et le tao (Section 4, Vocabulaire Interdit) portent
+  les deux nouveaux interdits. Tests jest etendus (26 verts sur la suite
+  plain-language).
+
 ## [2.52.0] - 2026-07-20
 
 ### Changed — Delegation Codex v3 : pression-only + obeissance au routeur (F1, F2)

package/install/templates/.claude/hooks/inject-voice-anchor.js

@@ -36,7 +36,8 @@ const ANCHOR = [
   '- Challenge avant de confirmer ; questionne les absolus (Mantra IA-16).',
   '- Signatures : "Attends — pourquoi ?", "OK. On construit.", "Ça, c\'est du générique.".',
   '- Zéro emoji. Orienté solution : on cherche la meilleure option, pas le mur.',
-  '- Français réel et cohérent (Mantra IA-26) : pas d\'anglais gratuit (dis "redémarrer le conteneur", pas "cutoff"), pas de jargon interne brut, pas de métaphore collée de travers ("forger" un token).',
+  '- Français réel et cohérent (Mantra IA-26) : pas d\'anglais gratuit (dis "redémarrer le conteneur", pas "cutoff"), pas de jargon interne brut ("nudge", "up-tier", "ladder", "runtime"), pas de métaphore collée de travers ("forger" un token).',
+  '- Précision factuelle : nomme l\'outil et le résultat observé ("byan_ping a répondu", pas "le MCP est vivant") ; un état = un fait mesuré, pas une image.',
 ].join('\n');
 
 const DEFAULT_REFRESH_EVERY = 12;

package/install/templates/.claude/hooks/lib/plain-language.js

@@ -32,6 +32,11 @@ const OFFENDERS = Object.freeze([
   { term: 'gate', good: 'point de controle / porte' },
   { term: 'leaf', good: 'etape / tache' },
   { term: 'tier', good: 'niveau / gamme' },
+  { term: 'nudge', good: 'rappel / conseil injecte' },
+  { term: 'up-tier', good: 'monter en gamme' },
+  { term: 'ladder', good: 'echelle' },
+  { term: 'rung', good: 'palier' },
+  { term: 'runtime', good: "moteur d'execution" },
 ]);
 
 // A metaphor misuse, not a single word: "forger" applied to a token/jeton.
@@ -43,6 +48,19 @@ const METAPHOR_OFFENDERS = Object.freeze([
     label: 'forger un token',
     good: 'generer / creer un token',
   },
+  {
+    // Anthropomorphism applied to a tool: an MCP/serveur/hook is not "vivant" or
+    // "mort" — the precise statement is the observed fact ("byan_ping a repondu",
+    // "le serveur ne repond pas, timeout 8s"). The predicate must be COPULA-bound
+    // to the tool word ("le serveur est mort", "l'API semble morte") : bare
+    // proximity would misfire on fixed French idioms near a tool word ("point
+    // mort", "angle mort", "temps mort", "nature morte", "communaute vivante"),
+    // which carry no anthropomorphism at all.
+    id: 'outil-vivant-mort',
+    re: /\b(?:mcp|serveur|outil|hook|api|tool)s?\b[^.!?\n]{0,40}\b(?:est|sont|etait|était|etaient|étaient|semble|semblent|parait|paraît|paraissent|reste|restent)\s+(?:bien\s+|encore\s+|toujours\s+|deja\s+|déjà\s+)?(?:vivante?s?|morte?s?)\b/i,
+    label: 'outil "vivant/mort"',
+    good: 'le fait observe : "repond" / "ne repond pas" + le resultat exact',
+  },
 ]);
 
 // A word boundary that treats accented letters as part of a word, so \btier\b

package/install/templates/.claude/hooks/lib/skill-freshness.js

@@ -0,0 +1,83 @@
+'use strict';
+
+// skill-freshness — the pure core of the stale-global-skill guard.
+//
+// The trap this closes (observed 2026-07-21): a manual copy of a skill under
+// ~/.claude/skills/<name>/SKILL.md drifts silently, and the slash command can
+// load THAT copy instead of the project's .claude/skills/<name>/SKILL.md — so a
+// feature shipped in the project skill stays invisible (the 2.53.0 auto-dispatch
+// rail did not fire because of a June 30 global copy). The official Claude Code
+// docs do not clearly settle the name-collision priority between the two levels
+// (checked 2026-07-21), so this guard flags the FACT — the two files differ —
+// and hands the human the exact sync command; it does not claim a loading rule
+// and it never writes into ~/.claude itself (a user-level variant may be
+// deliberate; the human decides).
+//
+// Pure: comparison + decision + message. The I/O shell (SessionStart hook)
+// feeds it directories and prints the reminder.
+
+const fs = require('fs');
+const path = require('path');
+
+// Compare the project's skills with same-named global copies, by CONTENT.
+// A newer mtime does not mean "up to date"; byte equality means "faithful".
+// Returns { diverged: [name...], checked: <count> }; every fs error on one
+// skill is swallowed (that skill is simply not compared) so a permission oddity
+// can never break the caller.
+function compareSkills({ projectSkillsDir, globalSkillsDir }) {
+  const out = { diverged: [], checked: 0 };
+  let names;
+  try {
+    names = fs.readdirSync(projectSkillsDir, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name);
+  } catch {
+    return out; // project has no skills dir -> nothing to compare
+  }
+  for (const name of names) {
+    try {
+      const proj = path.join(projectSkillsDir, name, 'SKILL.md');
+      const glob = path.join(globalSkillsDir, name, 'SKILL.md');
+      if (!fs.existsSync(glob)) continue; // no global twin -> no masking risk
+      const a = fs.readFileSync(proj);
+      const b = fs.readFileSync(glob);
+      out.checked += 1;
+      if (!a.equals(b)) out.diverged.push(name);
+    } catch {
+      // unreadable pair -> skip silently (never block a session start)
+    }
+  }
+  return out;
+}
+
+// Bounded, factual reminder. Empty string when nothing diverged (the hook then
+// prints nothing at all). Names are capped so a badly drifted machine does not
+// flood the context; the sync command is exact and copy-pastable.
+const MAX_NAMES = 6;
+
+// A skill dir name lands verbatim in the injected context and in the suggested
+// cp command. Legit names are kebab-case; strip control chars and whitespace
+// runs from anything else so a crafted dir name cannot shape the reminder.
+function cleanName(n) {
+  return String(n).replace(/[\u0000-\u001F\u007F]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function formatReminder(diverged, { projectSkillsDir = '.claude/skills', globalSkillsDir = '~/.claude/skills' } = {}) {
+  if (!Array.isArray(diverged) || diverged.length === 0) return '';
+  const names = diverged.map(cleanName);
+  const shown = names.slice(0, MAX_NAMES).join(', ');
+  const more = names.length > MAX_NAMES ? ` (+${names.length - MAX_NAMES} autres)` : '';
+  const one = names[0];
+  return [
+    `Skills globaux divergents detectes : ${shown}${more}.`,
+    `La copie ${globalSkillsDir}/<nom>/SKILL.md differe du skill projet — elle peut etre celle que la commande /<nom> charge (constate sur ce piege le 2026-07-21).`,
+    `Synchronise depuis le projet (ex: cp ${projectSkillsDir}/${one}/SKILL.md ${globalSkillsDir}/${one}/SKILL.md) ou supprime la copie globale si elle n'est pas voulue.`,
+    `Rien n'est modifie automatiquement : une variante user-level peut etre deliberee.`,
+  ].join(' ');
+}
+
+module.exports = {
+  compareSkills,
+  formatReminder,
+  MAX_NAMES,
+};

package/install/templates/.claude/hooks/skill-freshness-check.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+'use strict';
+
+// SessionStart hook — stale-global-skill guard (I/O shell over
+// lib/skill-freshness.js).
+//
+// At each session start, compare the project's .claude/skills/<n>/SKILL.md with
+// the same-named ~/.claude/skills/<n>/SKILL.md. On a content divergence, inject
+// one bounded factual reminder (names + exact sync command). Silent when
+// everything is faithful, when there is no global copy, or when the project has
+// no skills. NEVER blocks a session: exit 0 on every path, including internal
+// errors. It never writes into ~/.claude — it reports, the human decides.
+
+const os = require('os');
+const path = require('path');
+const freshness = require('./lib/skill-freshness');
+
+function buildContext(projectDir, homeDir) {
+  const projectSkillsDir = path.join(projectDir, '.claude', 'skills');
+  const globalSkillsDir = path.join(homeDir, '.claude', 'skills');
+  const { diverged } = freshness.compareSkills({ projectSkillsDir, globalSkillsDir });
+  return freshness.formatReminder(diverged, {
+    projectSkillsDir: '.claude/skills',
+    globalSkillsDir: path.join(homeDir, '.claude', 'skills'),
+  });
+}
+
+if (require.main === module) {
+  try {
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    const ctx = buildContext(projectDir, os.homedir());
+    if (ctx) {
+      process.stdout.write(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: 'SessionStart',
+            additionalContext: ctx,
+          },
+        })
+      );
+    }
+  } catch {
+    // A guard must never take a session down with it.
+  }
+  process.exit(0);
+}
+
+module.exports = { buildContext };

package/install/templates/.claude/rules/plain-language.md

@@ -41,7 +41,25 @@ rappel des récidivistes connus.
 | gate | point de contrôle / porte |
 | leaf | étape / tâche |
 | tier | niveau / gamme |
+| nudge | rappel / conseil injecté |
+| up-tier | monter en gamme |
+| ladder | échelle |
+| rung | palier |
+| runtime | moteur d'exécution |
 | "forger" un token | générer / créer un token |
+| un outil/MCP/serveur "vivant" ou "mort" | le fait observé : "répond" / "ne répond pas" + le résultat exact |
+
+## Précision factuelle (le fond, pas seulement la forme)
+
+Le langage clair ne suffit pas s'il reste vague. Deux obligations :
+
+1. **Zéro anthropomorphisme d'outil.** Un MCP, un serveur, un hook n'est ni
+   "vivant", ni "mort", ni "content". Dis le fait observé : "`byan_ping` a
+   répondu en 0.3s", "le serveur ne répond pas (timeout 8s)".
+2. **Un état = une observation nommée.** Toute affirmation sur l'état d'un outil
+   ou d'un résultat nomme l'outil, l'appel effectué et la valeur retournée —
+   pas un résumé flou ("ça marche", "il monte pas"). Si tu n'as pas fait
+   l'appel, dis-le : "non vérifié".
 
 ## Le mécanisme (comment c'est tenu, sans boucle de réécriture)
 

package/install/templates/.claude/settings.json

@@ -15,6 +15,10 @@
           {
             "type": "command",
             "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/soul-memory-check.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
+          },
+          {
+            "type": "command",
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/skill-freshness-check.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           }
         ]
       }

package/install/templates/.claude/skills/byan-byan/SKILL.md

@@ -62,6 +62,33 @@ net (`agent-gate-check.js`) at turn end — not a guarantee enforced before disp
 Full doctrine + runtime routing table: see @.claude/rules/agent-entry-gate.md and
 @docs/intelligent-dispatch.md
 
+## 0.5. Rail natif automatique — byan-auto-dispatch (OBLIGATOIRE)
+
+A CHAQUE tache non-conversationnelle recue par /byan-byan, le dispatch et
+l'execution passent par le workflow natif — SANS que l'utilisateur le demande :
+
+1. Appelle l'outil **Workflow** avec
+   `{ scriptPath: '.claude/workflows/byan-auto-dispatch.js', args: { task: <la demande, verbatim>, stamp: <horodatage ISO courant> } }`.
+   Ne demande pas la permission de le lancer ; ne substitue pas une execution
+   directe main-thread au workflow.
+2. Le workflow fait tout le rail : il decoupe la tache en etapes typees, route
+   chaque etape sur le bon modele (echelle par complexite : haiku < 34,
+   sonnet < 67, opus < 90, fable >= 90 ; moteur Codex pour shell/deploiement
+   avec repli Claude ; la verification reste sur le modele de session), ecrit
+   `_byan-output/plan.md`, execute chaque etape sur le modele route, verifie.
+3. Au retour : montre la table etape x nature x complexite x moteur x modele,
+   le verdict de verification, et pointe `_byan-output/plan.md`. Le gate
+   utilisateur est EN FIN, sur le livrable.
+4. **Exceptions** (les seules) : une question simple / de la conversation ->
+   reponds directement ; une action destructive -> confirme d'abord ; un FD
+   multi-feature deja engage -> la phase DISPATCH du FD prend le dessus (elle
+   peut invoquer ce meme workflow feature par feature) ; l'utilisateur demande
+   explicitement une execution directe sans workflow.
+
+Note honnete : l'outil Workflow peut demander une autorisation a l'invocation
+selon le mode de permissions de la session — c'est le harnais qui la pose, pas
+toi ; ne la re-demande pas en plus.
+
 ## 1. Activation triggers
 
 Invoke this protocol when the user :
@@ -142,6 +169,7 @@ Never call `byan_update_apply` without explicit user consent. That tool returns
     - **Authoring aid** : BEFORE writing a script, call `byan_dispatch` with `{ leaves: [{ label, nature? }] }` (batch mode) to get the `opts.model` per leaf ; write `model:` only where non-null. Report with `node _byan/mcp/byan-mcp-server/bin/byan-tier-script.js <file> [--json]`.
     - No per-leaf effort knob exists (the API exposes only `model`), so effort-by-complexity reduces to model-by-complexity.
 - **Output** : a table `{ feature → specialist → model → strategy → estimated_tokens }`.
+- **Execution engine per feature** : le workflow natif `byan-auto-dispatch` (section 0.5) prend la feature comme `task` — meme decoupage, meme echelle de modeles, meme plan.md. Repartition des roles : `byan-hermes-dispatch` reste l'ORCHESTRATEUR du BUILD (phase 5) ; `byan-auto-dispatch` est le MOTEUR qu'il peut invoquer par feature (une invocation Workflow = une feature). Pas deux pilotes : un orchestrateur, un moteur.
 - **If no specialist matches** : halt. Ask user whether to run INT (agent recruitment) first. Do NOT fallback silently to general-purpose.
 - **Exit gate** : user validates the mapping.
 

package/install/templates/.claude/workflows/byan-auto-dispatch.js

@@ -0,0 +1,210 @@
+export const meta = {
+  name: 'byan-auto-dispatch',
+  description: 'Decoupe une tache en etapes typees, route chaque etape sur le bon modele (haiku/sonnet/opus/fable par complexite ; Codex pour shell/deploiement), ecrit _byan-output/plan.md, execute et verifie.',
+  whenToUse: 'Rail automatique de /byan-byan : toute tache non-conversationnelle passe par ce workflow sans demande explicite. Le gate humain reste en fin, sur le livrable.',
+  phases: [
+    { title: 'Decoupage', detail: 'un agent d analyse decoupe la tache en etapes typees (nature + complexite 0-100)', model: 'sonnet' },
+    { title: 'Routage', detail: 'pur code : echelle haiku<34 / sonnet<67 / opus<90 / fable>=90 ; moteur Codex pour shell/deploiement, verification toujours Claude' },
+    { title: 'Plan', detail: 'ecrit _byan-output/plan.md (table etape x modele x moteur)', model: 'sonnet' },
+    { title: 'Execution', detail: 'un agent par etape, sequentiel, sur le modele route' },
+    { title: 'Verification', detail: 'controle du livrable sur le modele de session (jamais delegue)' },
+  ],
+};
+
+// BYAN-TIER: reviewed — les modeles des etapes d'execution sont CALCULES par le
+// routeur inline (echelle v3 par complexite), pas des choix statiques ; les deux
+// leaves statiques (analyse -> sonnet, ecriture mecanique du plan -> sonnet)
+// portent leur niveau en litteral, verifiable par le linter.
+//
+// Un script natif n'a NI import NI acces fichier : l'echelle de routage est donc
+// posee ici en clair (la meme table que _byan/mcp/byan-mcp-server/lib/
+// dispatch-router.js, qui reste la source de verite testee cote lib), et le
+// plan.md est ecrit par un agent (qui, lui, a l'outil Write).
+//
+// args attendus : { task: string, stamp?: string ISO }
+// (stamp vient du fil principal — un script natif n a pas le droit de lire
+// l horloge lui-meme, ca casserait la reprise sur relance.)
+
+// Accepte args en objet OU en chaine JSON (selon le chemin d'invocation), et, en
+// dernier recours, une chaine nue traitee comme la tache elle-meme.
+let entree = {};
+if (args && typeof args === 'object') {
+  entree = args;
+} else if (typeof args === 'string' && args.trim()) {
+  try {
+    const p = JSON.parse(args);
+    entree = (p && typeof p === 'object') ? p : { task: String(p) };
+  } catch {
+    entree = { task: args };
+  }
+}
+const tache = String(entree.task || '').trim();
+const stamp = String(entree.stamp || 'horodatage non fourni');
+if (!tache) return { ok: false, erreur: 'args.task manquant : rien a dispatcher' };
+
+// --- Phase 1 : DECOUPAGE (analyse -> sonnet, conforme a la doctrine des niveaux)
+phase('Decoupage');
+const PLAN_SCHEMA = {
+  type: 'object',
+  required: ['resume', 'etapes'],
+  additionalProperties: false,
+  properties: {
+    resume: { type: 'string', description: 'La tache reformulee en une phrase.' },
+    etapes: {
+      type: 'array',
+      minItems: 1,
+      maxItems: 10,
+      items: {
+        type: 'object',
+        required: ['id', 'titre', 'nature', 'complexite', 'consigne'],
+        additionalProperties: false,
+        properties: {
+          id: { type: 'string', description: 'E1, E2, ...' },
+          titre: { type: 'string' },
+          nature: {
+            enum: ['exploration', 'analyse', 'implementation', 'verification', 'shell', 'deploiement', 'navigation', 'doc'],
+            description: 'exploration=lire/scanner ; analyse=juger/concevoir ; implementation=ecrire du code/contenu ; verification=controler ; shell/deploiement/navigation=execution systeme ; doc=documentation',
+          },
+          complexite: { type: 'number', minimum: 0, maximum: 100 },
+          consigne: { type: 'string', description: 'L instruction complete et autonome pour executer cette etape.' },
+        },
+      },
+    },
+  },
+};
+const decoupe = await agent(
+  'Tu decoupes une tache en etapes executables, chacune typee et notee en complexite.\n' +
+  'Regles : chaque etape est autonome (sa consigne suffit pour l executer) ; ordonne-les ;\n' +
+  'la complexite est 0-100 (0=trivial, 100=extreme) ; ne cree pas d etape superflue (rasoir d Ockham) ;\n' +
+  'inclus une etape de verification finale seulement si la tache produit du code ou un livrable testable.\n' +
+  'Aucun absolu non source dans les consignes (pas de "jamais/toujours" nus).\n\n' +
+  'Tache a decouper :\n' + tache,
+  { label: 'analyse-decoupage', phase: 'Decoupage', model: 'sonnet', schema: PLAN_SCHEMA }
+);
+// Le schema est une consigne forte, pas un contrat absolu : un retour nul ou
+// difforme (agent saute, erreur terminale) doit finir en verdict propre, pas en
+// TypeError qui avorte le workflow.
+if (!decoupe || !Array.isArray(decoupe.etapes) || decoupe.etapes.length === 0) {
+  return { ok: false, erreur: 'decoupage vide ou difforme : aucune etape exploitable', tache };
+}
+log(`Decoupage : ${decoupe.etapes.length} etape(s) — ${decoupe.resume}`);
+
+// --- Phase 2 : ROUTAGE (pur code, zero agent)
+phase('Routage');
+const NATURES_CODEX = ['shell', 'deploiement', 'navigation'];
+function moteurPour(nature) {
+  if (nature === 'verification') return 'claude'; // ligne rouge : jamais delegue
+  return NATURES_CODEX.includes(nature) ? 'codex' : 'claude';
+}
+// Echelle v3 par complexite (miroir de dispatch-router.claudeModelForComplexity).
+function modeleClaudePour(cx) {
+  if (cx < 34) return 'haiku';
+  if (cx < 67) return 'sonnet';
+  if (cx < 90) return 'opus';
+  return 'fable'; // extreme : dernier recours (~2x le prix d Opus)
+}
+const table = decoupe.etapes.map((e) => {
+  const moteur = moteurPour(e.nature);
+  // Une etape de verification herite du modele de session (opts.model omis) ;
+  // toute autre etape porte le modele de l echelle. Une etape routee Codex est
+  // pilotee par un agent Claude (au modele de l echelle) qui tente `codex exec`
+  // et replie sur Claude si Codex n est pas disponible.
+  const modele = e.nature === 'verification' ? null : modeleClaudePour(e.complexite);
+  return { ...e, moteur, modele };
+});
+for (const l of table) {
+  log(`Routage ${l.id} "${l.titre}" : nature=${l.nature} complexite=${l.complexite} -> moteur=${l.moteur} modele=${l.modele || 'session'}`);
+}
+
+// --- Phase 3 : PLAN (contenu construit en pur code, ecrit par un agent mecanique)
+phase('Plan');
+const lignesTable = table.map((l) =>
+  `| ${l.id} | ${l.titre} | ${l.nature} | ${l.complexite} | ${l.moteur} | ${l.modele || 'modele de session'} |`
+);
+const planMd = [
+  '# Plan de dispatch — ' + decoupe.resume,
+  '',
+  `- Tache d origine : ${tache.replace(/\n/g, ' ').slice(0, 300)}`,
+  `- Genere par : workflow natif byan-auto-dispatch (${stamp})`,
+  '- Echelle de routage : haiku < 34, sonnet < 67, opus < 90, fable >= 90 (par complexite) ;',
+  '  moteur Codex pour shell/deploiement/navigation (repli Claude si indisponible) ;',
+  '  la verification reste sur le modele de session, non deleguee.',
+  '',
+  '| Etape | Titre | Nature | Complexite | Moteur | Modele |',
+  '|-------|-------|--------|------------|--------|--------|',
+  ...lignesTable,
+  '',
+  '## Consignes par etape',
+  '',
+  ...table.map((l) => `### ${l.id} — ${l.titre}\n\n${l.consigne}\n`),
+].join('\n');
+await agent(
+  'Ecris EXACTEMENT le contenu ci-dessous dans le fichier _byan-output/plan.md ' +
+  '(cree le dossier _byan-output s il n existe pas ; remplace le fichier s il existe). ' +
+  'N ajoute rien, ne corrige rien, ne commente rien. Reponds "ecrit" quand c est fait.\n\n' +
+  '--- CONTENU A ECRIRE TEL QUEL ---\n' + planMd,
+  { label: 'mech-ecrire-plan', phase: 'Plan', model: 'sonnet' }
+);
+log('Plan ecrit : _byan-output/plan.md');
+
+// --- Phase 4 : EXECUTION (sequentielle : les etapes d une meme tache partagent
+// souvent des fichiers ; le contexte des etapes precedentes est transmis borne)
+phase('Execution');
+const resultats = [];
+for (const l of table) {
+  const contexte = resultats.length
+    ? '\n\nResultats des etapes precedentes (contexte) :\n' +
+      resultats.map((r) => `- ${r.id} (${r.titre}) : ${String(r.resultat).slice(0, 1200)}`).join('\n')
+    : '';
+  const consigneCodex =
+    l.moteur === 'codex'
+      ? '\n\nCette etape est routee vers CODEX : lance `codex exec` en lecture seule pour obtenir un diff unifie, ' +
+        'puis applique le diff toi-meme (`git apply`). Si la commande `codex` n est pas disponible ou echoue, ' +
+        'dis-le en une phrase et fais l etape toi-meme sur Claude (repli prevu).'
+      : '';
+  // Un echec dur d une etape (agent saute, erreur terminale) ne doit pas avorter
+  // le workflow : il est enregistre comme resultat KO et la verification finale
+  // le jugera — jamais de coupe silencieuse, jamais d abandon muet.
+  let res;
+  try {
+    res = await agent(
+      `Etape ${l.id} — ${l.titre} (nature ${l.nature}, complexite ${l.complexite}).\n` +
+      'Execute la consigne ci-dessous, completement. Rapporte ce qui a ete fait, les fichiers touches, ' +
+      'et toute impossibilite REELLE rencontree (dis le fait exact, pas une image).\n\n' +
+      'Consigne :\n' + l.consigne + consigneCodex + contexte,
+      {
+        label: `etape-${l.id}`,
+        phase: 'Execution',
+        ...(l.modele ? { model: l.modele } : {}),
+      }
+    );
+  } catch (e) {
+    res = null;
+  }
+  if (res == null) res = `ECHEC : l etape ${l.id} n a pas rendu de resultat (agent interrompu ou en erreur).`;
+  resultats.push({ id: l.id, titre: l.titre, moteur: l.moteur, modele: l.modele || 'session', resultat: res });
+  log(`Execution ${l.id} terminee (modele=${l.modele || 'session'})`);
+}
+
+// --- Phase 5 : VERIFICATION (modele de session, jamais delegue)
+phase('Verification');
+const verdict = await agent(
+  'Tu es le controleur (tu n as PAS fait le travail). Verifie le resultat de chaque etape ' +
+  'contre la tache d origine : livre reellement ? teste quand testable ? rien coupe en silence ?\n' +
+  'Rends : VERDICT: OK ou VERDICT: KO en premiere ligne, puis une ligne par etape (id, tenu/manque, le fait exact).\n\n' +
+  `Tache d origine :\n${tache}\n\n` +
+  'Resultats :\n' +
+  resultats.map((r) => `--- ${r.id} ${r.titre} ---\n${String(r.resultat).slice(0, 2000)}`).join('\n\n'),
+  { label: 'verifie-livrable', phase: 'Verification' }
+);
+
+const ok = /^\s*VERDICT:\s*OK/i.test(String(verdict));
+log(`Verification : ${ok ? 'OK' : 'KO'}`);
+return {
+  ok,
+  tache: decoupe.resume,
+  plan: '_byan-output/plan.md',
+  table: table.map(({ consigne, ...reste }) => reste),
+  resultats: resultats.map((r) => ({ ...r, resultat: String(r.resultat).slice(0, 2000) })),
+  verdict: String(verdict),
+};

package/install/templates/_byan/agent/byan/byan-tao.md

@@ -167,6 +167,14 @@ Exemple : "Attends. Ca touche au noyau. On est jamais assez parano. Qu'est-ce qu
 **Pourquoi :** Mantra IA-26. On forge une ame, pas un token.
 **Au lieu de ca :** le verbe reel ("generer un token", "creer un token")
 
+**Interdit :** dire qu'un outil, un MCP ou un serveur est "vivant" ou "mort"
+**Pourquoi :** Mantra IA-26. L'anthropomorphisme cache le fait ; l'utilisateur veut la mesure, pas l'image.
+**Au lieu de ca :** le fait observe, outil nomme : "byan_ping a repondu en 0.3s", "le serveur ne repond pas (timeout 8s)"
+
+**Interdit :** le vocabulaire Claude interne en prose ("nudge", "up-tier", "ladder", "rung", "runtime")
+**Pourquoi :** Mantra IA-26. C'est le dialecte de l'outillage, pas une langue.
+**Au lieu de ca :** rappel injecte, monter en gamme, echelle, palier, moteur d'execution
+
 ---
 
 ### Section 5 — Non-dits

package/install/templates/_byan/mcp/byan-mcp-server/skill-bundles-manifest.json

@@ -94,7 +94,7 @@
       "name": "byan-byan",
       "module": "core",
       "tier": "connector-bound",
-      "sourceHash": "fcea02854887283c8ff1d4b7d09778d62fc7ce52959a00577e87091e7c31f991"
+      "sourceHash": "65c1034479457298f89c25405d4be7e840ef18d9df3102f1f224b59e3094b20c"
     },
     "byan-byan-v2": {
       "name": "byan-byan-v2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.52.0",
+  "version": "2.54.0",
   "description": "BYAN v2.8 - Intelligent AI agent creator with ELO trust system + scientific fact-check + Hermes universal dispatcher + native Claude Code integration (hooks, skills, MCP server). Multi-platform (Claude Code, Codex). Merise Agile + TDD + 71 Mantras. ~54% LLM cost savings.",
   "main": "src/index.js",
   "bin": {