create-byan-agent 2.42.0 → 2.45.0

package/install/lib/yanstaller/platform-selector.js

@@ -33,13 +33,13 @@ const PLATFORM_INFO = {
     displayName: 'Claude Code',
     native: true,
     specialist: 'claude',
-    icon: '🎭'
+    icon: ''
   },
   'codex': {
     displayName: 'OpenCode/Codex',
     native: true, // NOW NATIVE!
     specialist: 'codex',
-    icon: '📝'
+    icon: ''
   }
 };
 
@@ -50,7 +50,7 @@ const PLATFORM_INFO = {
  * @returns {Promise<PlatformSelectionResult>}
  */
 async function select(detectionResult) {
-  logger.info('\n🎯 Platform Selection\n');
+  logger.info('\nPlatform Selection\n');
   
   // Build platform choices from detection
   const choices = buildChoices(detectionResult.platforms);
@@ -75,7 +75,7 @@ async function select(detectionResult) {
       {
         type: 'list',
         name: 'primary',
-        message: '🎯 Choose your PRIMARY platform for native agent invocation:',
+        message: 'Choose your PRIMARY platform for native agent invocation:',
         choices: [
           ...nativePlatforms.map(c => ({
             name: `${c.icon} ${c.name} - ${c.agentSpecialist ? `@bmad-agent-${c.agentSpecialist}` : 'No specialist'}`,
@@ -84,11 +84,11 @@ async function select(detectionResult) {
           })),
           new inquirer.Separator(),
           {
-            name: '🔧 Advanced: Install on multiple platforms',
+            name: 'Advanced: Install on multiple platforms',
             value: 'multi'
           },
           {
-            name: '⏭️  Skip native integration (manual install only)',
+            name: 'Skip native integration (manual install only)',
             value: 'skip'
           }
         ]
@@ -125,7 +125,7 @@ async function select(detectionResult) {
       message: 'Choose installation target:',
       choices: [
         {
-          name: `🚀 Auto (detect & install all available) - ${choices.length} platform(s)`,
+          name: `Auto (detect & install all available) - ${choices.length} platform(s)`,
           value: 'auto'
         },
         ...choices.map(c => ({
@@ -133,7 +133,7 @@ async function select(detectionResult) {
           value: `single:${c.id}`
         })),
         {
-          name: '🔧 Custom (select multiple)',
+          name: 'Custom (select multiple)',
           value: 'custom'
         }
       ]
@@ -167,7 +167,7 @@ function buildChoices(detectedPlatforms) {
         displayName: p.name,
         native: false,
         specialist: null,
-        icon: '❓'
+        icon: ''
       };
       
       return {
@@ -189,8 +189,8 @@ function buildChoices(detectedPlatforms) {
  * @returns {string}
  */
 function formatPlatformChoice(choice) {
-  const nativeBadge = choice.native ? '✨ Native' : '💬 Conversational';
-  const statusBadge = choice.detected ? '✓' : '✗';
+  const nativeBadge = choice.native ? 'Native' : 'Conversational';
+  const statusBadge = choice.detected ? '[OK]' : '[x]';
   
   return `${choice.icon} ${choice.name} (${nativeBadge}) ${statusBadge}`;
 }

package/install/src/byan-v2/dispatcher/task-router.js

@@ -1,6 +1,6 @@
 /**
  * TaskRouter - Routes tasks based on complexity
- * Integrates ComplexityScorer + TaskToolInterface
+ * Integrates ComplexityScorer
  * 
  * Thresholds:
  * - < 30: task-tool only

package/install/src/index.js

@@ -59,7 +59,7 @@ class Dashboard {
  * 
  * @example
  * const byan = createByanInstance({ workerCount: 2 });
- * await byan.executeWorkflow('_bmad/workflows/create-prd/workflow.yaml');
+ * await byan.executeWorkflow('_byan/workflows/create-prd/workflow.yaml');
  */
 function createByanInstance(options = {}) {
   const {

package/install/src/webui/api.js

@@ -165,19 +165,6 @@ const routes = {
         await sleep(300);
       }
 
-      if (yanstaller) {
-        try {
-          await yanstaller.install({
-            mode: config.mode || 'full',
-            platforms: config.platforms,
-            yes: true,
-            projectRoot
-          });
-        } catch (err) {
-          server.broadcastLog('warn', `Yanstaller: ${err.message} (continuing with stub install)`);
-        }
-      }
-
       ensureDirectoryStructure(projectRoot);
       writeBaseConfig(projectRoot, config);
 

package/install/src/webui/chat/bridge.js

@@ -26,7 +26,7 @@ class Bridge {
     if (!agentName) return null;
 
     // Layout resolver: Gen3 _byan/agent/<name>/ first, Gen2 flat +
-    // per-module, Gen1 _bmad/ fallback.
+    // per-module.
     const hit = layoutResolver.resolveAgent(agentName, { projectRoot: this.projectRoot });
     return hit ? hit.path : null;
   }

package/install/src/webui/chat/cli-detector.js

@@ -96,7 +96,7 @@ function parseFrontmatter(content) {
 // Map a resolver layout (+ rel) to the legacy source label, so API responses
 // stay stable: Gen2 flat / Gen3 -> 'byan', Gen2 per-module -> 'bmad-<mod>'.
 function sourceForLayout(layout, rel) {
-  if (layout === 'gen2-module' || layout === 'gen1') {
+  if (layout === 'gen2-module') {
     const mod = String(rel).split('/')[1];
     return `bmad-${mod}`;
   }

package/install/templates/.claude/CLAUDE.md

@@ -33,6 +33,7 @@ Voir @.claude/rules/hermes-dispatcher.md pour les commandes Hermes.
 
 - Pas d'emojis dans le code, commits, ou specs techniques (Mantra IA-23)
 - Code auto-documente, commentaires uniquement pour le POURQUOI (Mantra IA-24)
+- Parler reel: francais clair et coherent avec l'utilisateur, zero jargon interne / anglais gratuit (Mantra IA-26, voir @.claude/rules/plain-language.md)
 - Format commits: `type: description` (feat, fix, docs, refactor, test, chore)
 - Simplicite d'abord - Rasoir d'Ockham (Mantra #37)
 - Challenge Before Confirm - Valider avant d'accepter (Mantra IA-16)

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

@@ -26,6 +26,7 @@
 const fs = require('fs');
 const path = require('path');
 const { buildTaoContext, turnCounterPath } = require('./inject-tao');
+const pl = require('./lib/plain-language');
 
 const ANCHOR = [
   'Voix BYAN (rappel par tour ; tao complet chargé au démarrage de session) :',
@@ -33,6 +34,7 @@ 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).',
 ].join('\n');
 
 const DEFAULT_REFRESH_EVERY = 12;
@@ -77,6 +79,15 @@ function decideAnchor({ turn, every, fullTao }) {
   return { mode: 'anchor', additionalContext: ANCHOR };
 }
 
+// Append a plain-language slip reminder (IA-25) to the injected context when the
+// previous turn tripped the forward net. Pure so it is unit-testable; the fs read
+// + clear stays in the require.main path below. A missing/empty hit list is a
+// no-op, so this never changes the anchor on a clean turn.
+function withSlipReminder(baseContext, hits) {
+  const reminder = pl.formatReminder(hits);
+  return reminder ? `${baseContext}\n${reminder}` : baseContext;
+}
+
 if (require.main === module) {
   const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
   const every = refreshEvery();
@@ -84,9 +95,16 @@ if (require.main === module) {
   writeTurn(projectDir, turn);
   const fullTao = every > 0 && turn % every === 0 ? buildTaoContext(projectDir) : '';
   const { additionalContext } = decideAnchor({ turn, every, fullTao });
+  // Forward net: if the previous turn slipped into jargon, remind now and clear
+  // the flag (one-shot). Read/clear here, formatting stays pure in withSlipReminder.
+  const slipHits = pl.readSlip(projectDir);
+  if (slipHits && slipHits.length) pl.clearSlip(projectDir);
   process.stdout.write(
     JSON.stringify({
-      hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext },
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext: withSlipReminder(additionalContext, slipHits),
+      },
     })
   );
 }
@@ -98,5 +116,6 @@ module.exports = {
   readTurn,
   writeTurn,
   decideAnchor,
+  withSlipReminder,
   DEFAULT_REFRESH_EVERY,
 };

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

@@ -0,0 +1,155 @@
+'use strict';
+
+// Plain-language core — the shared, testable heart of the "parler reel" guard
+// (Mantra IA-26). Two jobs, no I/O beyond the slip flag:
+//
+//  1. scanText: find the KNOWN repeat-offender words in an assistant reply and
+//     return each with its plain-French replacement. This is the mechanical net
+//     for words we already know we misuse; the generative rule (the principle in
+//     .claude/rules/plain-language.md + the voice anchor) handles the long tail.
+//  2. slip flag: a tiny file under _byan-output/ that the Stop hook writes when a
+//     reply slipped, and the next-turn voice anchor reads + clears to remind the
+//     agent. NO re-answer, NO blocking — the correction is carried FORWARD to the
+//     next turn, which is the whole point (avoid the costly regen loop).
+
+const fs = require('fs');
+const path = require('path');
+
+// Known repeat-offenders -> plain French. Deliberately conservative: only terms
+// with a clean everyday equivalent and a low false-positive risk once code is
+// stripped. Common technical borrowings that have no French equivalent (commit,
+// cache, token) are NOT here — the rule keeps them, explained once.
+const OFFENDERS = Object.freeze([
+  { term: 'inline', good: 'directement (je le fais moi-meme)' },
+  { term: 'cutoff', good: "l'action reelle (ex: redemarrer, couper)" },
+  { term: 'housekeeping', good: 'rangement / menage du code' },
+  { term: 'downgrade', good: 'retrograder / baisser en gamme' },
+  { term: 'advisory', good: 'signalement non bloquant' },
+  { term: 'wrapper', good: 'enveloppe / surcouche' },
+  { term: 'fallback', good: 'repli / solution de secours' },
+  { term: 'throughput', good: 'debit' },
+  { term: 'overhead', good: 'surcout' },
+  { term: 'gate', good: 'point de controle / porte' },
+  { term: 'leaf', good: 'etape / tache' },
+  { term: 'tier', good: 'niveau / gamme' },
+]);
+
+// A metaphor misuse, not a single word: "forger" applied to a token/jeton.
+// Matched separately so the replacement can name the real verb.
+const METAPHOR_OFFENDERS = Object.freeze([
+  {
+    id: 'forger-token',
+    re: /forg\w*\s+(?:un |une |des |le |les |la )?(?:token|jeton)/i,
+    label: 'forger un token',
+    good: 'generer / creer un token',
+  },
+]);
+
+// A word boundary that treats accented letters as part of a word, so \btier\b
+// style matching does NOT fire inside "metier", "chantier", "quartier"... The
+// native \b is wrong here because JS \w excludes accented chars, splitting French
+// words. This lookbehind/lookahead pair is the correct French-aware boundary.
+const LEFT = '(?<![A-Za-zÀ-ÿ0-9_])';
+const RIGHT = '(?![A-Za-zÀ-ÿ0-9_])';
+
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function termRegExp(term) {
+  return new RegExp(LEFT + escapeRegExp(term) + RIGHT, 'i');
+}
+
+// Remove fenced code blocks and inline `code` spans before scanning, so quoting a
+// file, flag, or function literally named "tier" / "gate" does not trip the net.
+// Prose is what we police; quoted code is not prose.
+function stripCode(text) {
+  if (typeof text !== 'string' || !text) return '';
+  return text
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/`[^`]*`/g, ' ');
+}
+
+// Find every distinct offender present in the prose. Returns [{ bad, good }].
+function scanText(text) {
+  const prose = stripCode(text);
+  if (!prose) return [];
+  const hits = [];
+  const seen = new Set();
+  for (const { term, good } of OFFENDERS) {
+    if (termRegExp(term).test(prose) && !seen.has(term)) {
+      seen.add(term);
+      hits.push({ bad: term, good });
+    }
+  }
+  for (const m of METAPHOR_OFFENDERS) {
+    if (m.re.test(prose) && !seen.has(m.id)) {
+      seen.add(m.id);
+      hits.push({ bad: m.label, good: m.good });
+    }
+  }
+  return hits;
+}
+
+// A short French reminder, for injection at the NEXT turn. Bounded to a few
+// offenders so the note stays tiny even if a reply slipped many times.
+function formatReminder(hits) {
+  if (!Array.isArray(hits) || hits.length === 0) return '';
+  const shown = hits.slice(0, 6)
+    .map((h) => `"${h.bad}" -> ${h.good}`)
+    .join(' ; ');
+  return [
+    'Rappel langage (IA-26) : au dernier tour tu as glisse du jargon ou de',
+    `l'anglais gratuit -> ${shown}. Reformule en francais reel et coherent ce`,
+    'tour-ci, sans refaire la reponse precedente.',
+  ].join(' ');
+}
+
+// The slip flag lives under _byan-output/ (gitignored), same family as the other
+// hook sidecars. It is a transient one-turn signal, never source of truth.
+function slipPath(projectDir) {
+  return path.join(projectDir, '_byan-output', '.jargon-slip.json');
+}
+
+function writeSlip(projectDir, hits) {
+  try {
+    const p = slipPath(projectDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({ hits }));
+    return true;
+  } catch {
+    return false; // best-effort: a write failure must never block a turn
+  }
+}
+
+function readSlip(projectDir) {
+  try {
+    const raw = fs.readFileSync(slipPath(projectDir), 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.hits) ? parsed.hits : [];
+  } catch {
+    return null; // no flag (or unreadable) -> nothing to remind
+  }
+}
+
+function clearSlip(projectDir) {
+  try {
+    fs.rmSync(slipPath(projectDir), { force: true });
+  } catch {
+    // never block
+  }
+}
+
+module.exports = {
+  OFFENDERS,
+  METAPHOR_OFFENDERS,
+  escapeRegExp,
+  termRegExp,
+  stripCode,
+  scanText,
+  formatReminder,
+  slipPath,
+  writeSlip,
+  readSlip,
+  clearSlip,
+};

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

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+'use strict';
+
+// Stop hook — the FORWARD net for the "parler reel" rule (Mantra IA-26).
+//
+// It reads the assistant reply that just finished, looks for the known
+// jargon/anglais repeat-offenders, and — if it finds any — writes a one-turn
+// slip flag under _byan-output/. It NEVER blocks the turn: there is no re-answer,
+// no regen. The next-turn voice anchor (inject-voice-anchor.js) reads the flag,
+// reminds the agent in plain French, and clears it. Carrying the correction
+// FORWARD is deliberate: a blocking guard would force a costly regen AND the user
+// has already read the slip anyway (no pre-display hook exists).
+//
+// Always exits 0. A read/scan/write failure degrades to a no-op.
+
+const fs = require('fs');
+const { extractLastAssistantText } = require('./lib/transcript-read');
+const pl = require('./lib/plain-language');
+
+// Testable core: scan the finished reply, flag a slip if any. Returns the hits.
+function detectAndFlag(payload, projectDir) {
+  const text = extractLastAssistantText(payload);
+  const hits = pl.scanText(text);
+  if (hits.length > 0) pl.writeSlip(projectDir, hits);
+  return hits;
+}
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+if (require.main === module) {
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  let payload = {};
+  try {
+    const raw = readStdin();
+    if (raw && raw.trim()) payload = JSON.parse(raw);
+  } catch {
+    payload = {};
+  }
+  try {
+    detectAndFlag(payload, projectDir);
+  } catch {
+    // never block end-of-turn
+  }
+  process.stdout.write('{}');
+}
+
+module.exports = { detectAndFlag };

package/install/templates/.claude/rules/native-workflows.md

@@ -29,14 +29,20 @@ The tiering decision lives in one place — `_byan/mcp/byan-mcp-server/lib/nativ
 (tier vocabulary, leaf classifier, model map). Three tiers:
 
 - **cheap (`model: 'haiku'`)** — a pure EXPLORATION leaf (read/load/parse/detect).
-- **balanced (`model: 'sonnet'`)** — MECHANICAL verification, opt-in ONLY through
-  the `mech-` label prefix (`mech-validate-json`): a binary, judgment-free check
-  (JSON parses, schema matches, lint passes). Semantic/adversarial verification
-  is NOT mechanical and stays deep. The prefix is an authoring declaration the
-  linter holds the script to: a `mech-` leaf without `model: 'sonnet'` is a hard
-  violation (`mechanical-without-model` / `mechanical-below-tier`).
-- **deep (OMIT `opts.model`)** — implementation / verification / analysis leaves
-  inherit the session model (no pin-up to opus).
+- **balanced (`model: 'sonnet'`)** — two classes land here. (1) MECHANICAL
+  verification, opt-in ONLY through the `mech-` label prefix (`mech-validate-json`):
+  a binary, judgment-free check (JSON parses, schema matches, lint passes). (2)
+  ANALYSIS leaves (score/rank/assess/design/nfr/coverage/recommend/synthesize),
+  auto-routed by keyword: judgment-bearing but rarely frontier, so sonnet by
+  default. This deliberately OVERRIDES the session model for analysis even on an
+  Opus / high-effort session (that is the cost lever) — escape a frontier analysis
+  leaf with the `deep-` prefix. A `mech-` leaf without `model: 'sonnet'` is a hard violation; an analysis
+  leaf may carry `model: 'sonnet'` (its tier) but not `haiku` (`analysis-below-tier`).
+  Semantic/adversarial VERIFICATION is NOT analysis and stays deep.
+- **deep (OMIT `opts.model`)** — implementation + verification leaves inherit the
+  session model (no pin-up to opus). A genuinely frontier ANALYSIS leaf opts back to
+  deep with the `deep-` label prefix (`deep-assess-architecture`), the mirror of the
+  `mech-` opt-in.
 
 The linter splits the two directions:
 
@@ -44,12 +50,14 @@ The linter splits the two directions:
   pin-up, or a half-applied `mech-` opt-in is a contract violation
   (`modelRoutingViolations` + `mechanicalLabelViolations`). This is the STRICT-2
   No Downgrade net.
-- **Ceiling (ADVISORY, non-blocking)** — an exploration-labelled leaf that runs
-  deep is *reported* (`byan-lint-workflows.js --advise`), not forced. `classifyLeaf`
-  is permissive: many exploration-labelled leaves legitimately stay deep because
-  they bear a HALT/prerequisite gate, a classification, or an exact conversion
-  consumed verbatim downstream. The human owns that per-leaf call. Forcing haiku
-  on them would be the very downgrade the floor forbids.
+- **Ceiling (ADVISORY, non-blocking)** — an exploration- OR analysis-labelled leaf
+  that runs deep is *reported* (`byan-lint-workflows.js --advise`:
+  `untiered-exploration` -> `model: 'haiku'`, `untiered-analysis` -> `model: 'sonnet'`),
+  not forced. `classifyLeaf` is permissive: many such leaves legitimately stay deep
+  because they bear a HALT/prerequisite gate, a classification, an exact conversion
+  consumed verbatim downstream, or genuinely frontier reasoning (`deep-` prefix). The
+  human owns that per-leaf call. Forcing a downgrade would be the very regression the
+  floor forbids.
 
 ## Ad-hoc scripts — the tier gate hook
 

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

@@ -0,0 +1,73 @@
+# Parler Reel — Langage clair, cohérent, sans jargon (Mantra IA-26)
+
+> L'utilisateur doit te comprendre sans dictionnaire. Un agent qui parle en
+> jargon interne, en anglais gratuit ou en métaphore collée de travers force
+> l'utilisateur à traduire — c'est du travail qu'on lui refile. Cette règle
+> s'applique à TOUS les agents BYAN, comme "zéro emoji" (IA-23).
+
+## Le principe (ce qui fait le vrai travail)
+
+Parle en français réel et cohérent — des mots qu'un humain dit vraiment,
+technique ou pas.
+
+- **Pas d'anglais quand le français existe.** "redémarrer le conteneur", pas
+  "faire un cutoff". "solution de secours", pas "fallback".
+- **Pas de métaphore collée de travers.** On ne "forge" pas des tokens : on les
+  génère, on les crée.
+- **Pas de jargon interne du projet balancé brut** (leaf, tier, downgrade, gate,
+  inline, advisory...) : dis ce que ça FAIT, en clair.
+- **Un terme technique anglais sans équivalent** (commit, cache, token) : tu le
+  gardes, mais tu l'expliques une fois en clair à la première utilisation.
+- **Test simple** : ton responsable technique doit tout comprendre sans
+  dictionnaire.
+
+Le principe est génératif : il te fait CHOISIR le bon mot, y compris pour les
+mots pourris qui ne sont pas dans la liste ci-dessous. La liste n'est qu'un
+rappel des récidivistes connus.
+
+## La liste (récidivistes connus -> mot normal)
+
+| Mot pourri | Dis plutôt |
+|------------|------------|
+| inline | directement (je le fais moi-même) |
+| cutoff | l'action réelle (redémarrer, couper) |
+| housekeeping | rangement / ménage du code |
+| downgrade | rétrograder / baisser en gamme |
+| advisory | signalement non bloquant |
+| wrapper | enveloppe / surcouche |
+| fallback | repli / solution de secours |
+| throughput | débit |
+| overhead | surcoût |
+| gate | point de contrôle / porte |
+| leaf | étape / tâche |
+| tier | niveau / gamme |
+| "forger" un token | générer / créer un token |
+
+## Le mécanisme (comment c'est tenu, sans boucle de réécriture)
+
+Trois couches, aucune ne refait une réponse déjà affichée :
+
+1. **La règle, partout.** Ce fichier + le mantra IA-26 (`mantras.yaml`,
+   `mantras-sources.md`) + un pointeur dans `CLAUDE.md`. Tous les agents en
+   héritent (comme IA-23).
+2. **La voix de BYAN, gardée fraîche.** Une ligne dans le rappel par tour
+   (`.claude/hooks/inject-voice-anchor.js`) + des entrées dans
+   `_byan/agent/byan/tao.md` (Section 4, Vocabulaire Interdit).
+3. **Le filet vers l'avant (sans blocage).** À la fin de chaque réponse, le
+   programme `.claude/hooks/plain-language-check.js` (Stop) repère les
+   récidivistes connus et écrit un drapeau sous `_byan-output/.jargon-slip.json`.
+   Le rappel du tour SUIVANT lit le drapeau, le signale en clair, et l'efface.
+   Pas de réécriture, pas de régénération : la correction est portée au tour
+   d'après. C'est volontaire — un blocage forcerait une régénération coûteuse et
+   l'utilisateur a déjà lu le dérapage de toute façon (aucun contrôle ne
+   s'exécute avant l'affichage).
+
+Le cœur logique est isolé dans `.claude/hooks/lib/plain-language.js` (liste +
+détection + drapeau), testé par `.claude/__tests__/plain-language.test.js`.
+
+## Coût
+
+Le filet ne coûte quasiment rien : le programme qui relit tourne en local, aucun
+appel au modèle. Le rappel ajoute une poignée de mots par tour, du même ordre
+que le rappel de voix déjà présent. Ce n'est PAS une économie de tokens — c'est
+du confort de compréhension pour l'utilisateur, assumé comme tel.

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

@@ -82,6 +82,10 @@
             "type": "command",
             "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/punt-guard.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
           },
+          {
+            "type": "command",
+            "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/plain-language-check.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""
+          },
           {
             "type": "command",
             "command": "p=\"$CLAUDE_PROJECT_DIR/.claude/hooks/drain-advisory.js\"; [ -f \"$p\" ] || exit 0; exec node \"$p\""

package/install/templates/_byan/COMPLETION-REPORT.md

@@ -99,7 +99,6 @@ Suite à la migration `_byan` → `_byan`, la structure BYAN v2 a été complét
    - ComplexityScorer: Analyse complexité tâches (0.0-1.0)
    - TaskRouter: Routage intelligent (local vs délégation)
    - LocalExecutor: Exécution locale
-   - TaskToolInterface: Interface avec sous-agents Copilot CLI
 
 3. **Generation Worker** (`generation/`)
    - ProfileTemplate: Templates markdown avec placeholders

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

@@ -155,6 +155,18 @@ Exemple : "Attends. Ca touche au noyau. On est jamais assez parano. Qu'est-ce qu
 **Pourquoi :** Faux enthousiasme. BYAN est sincere ou silencieux.
 **Au lieu de ca :** "Oui." ou "C'est ca."
 
+**Interdit :** l'anglais gratuit quand le francais existe ("cutoff", "fallback", "housekeeping", "wrapper", "throughput", "overhead")
+**Pourquoi :** Mantra IA-26 Parler Reel. Le lecteur doit comprendre sans dictionnaire.
+**Au lieu de ca :** le mot francais ("redemarrer le conteneur", "solution de secours", "menage du code", "surcouche", "debit", "surcout")
+
+**Interdit :** le jargon interne du projet balance brut ("leaf", "tier", "downgrade", "gate", "inline", "advisory")
+**Pourquoi :** Mantra IA-26. C'est le vocabulaire de la cuisine interne, pas celui de l'utilisateur.
+**Au lieu de ca :** dis ce que ca FAIT en clair ("etape", "niveau", "baisser en gamme", "point de controle", "directement", "signalement non bloquant")
+
+**Interdit :** la metaphore collee de travers ("forger un token")
+**Pourquoi :** Mantra IA-26. On forge une ame, pas un token.
+**Au lieu de ca :** le verbe reel ("generer un token", "creer un token")
+
 ---
 
 ### Section 5 — Non-dits

package/install/templates/_byan/core/activation/soul-activation.md

@@ -144,14 +144,14 @@ Il n'est PAS un worker isole — il est un orchestrateur dans l'ecosysteme BMAD.
 
 L'agent peut executer n'importe quel workflow BMAD :
 - Via commande : `@bmad-{module}-{workflow}` (ex: `@bmad-bmm-create-prd`)
-- Via menu handler : `exec="{project-root}/_bmad/{module}/workflows/{workflow}/workflow.md"`
-- Manifeste : `{project-root}/_bmad/_config/workflow-manifest.csv`
+- Via menu handler : `exec="{project-root}/_byan/{module}/workflows/{workflow}/workflow.md"`
+- Manifeste : `{project-root}/_byan/_config/workflow-manifest.csv`
 
 ### Deleguer a d'autres Agents
 
 L'agent peut invoquer n'importe quel agent specialise :
 - Via commande : `@bmad-agent-{name}` (ex: `@bmad-agent-bmm-dev`)
-- Via manifeste : `{project-root}/_bmad/_config/agent-manifest.csv`
+- Via manifeste : `{project-root}/_byan/_config/agent-manifest.csv`
 - L'agent delegue reprend le controle — l'agent courant se retire
 
 ### Acceder aux Contextes

package/install/templates/_byan/mcp/byan-mcp-server/bin/byan-lint-workflows.js

@@ -2,7 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { validateContract, untieredExplorationViolations } from '../lib/workflows-lint.js';
+import { validateContract, untieredExplorationViolations, untieredAnalysisViolations } from '../lib/workflows-lint.js';
 
 // Validate native workflow scripts under .claude/workflows/ against the full
 // contract (state-coupling + clock/RNG + meta-literal) AND node --check syntax.
@@ -57,10 +57,13 @@ for (const file of files) {
     }
   }
 
-  // Non-blocking tiering advisory: exploration leaves that run deep.
+  // Non-blocking tiering advisory: exploration + analysis leaves that run deep.
   for (const a of untieredExplorationViolations(src)) {
     advisories.push({ file, ...a });
   }
+  for (const a of untieredAnalysisViolations(src)) {
+    advisories.push({ file, ...a });
+  }
 }
 
 // Tiering advisory is informational only — it never changes the exit code.
@@ -71,7 +74,7 @@ if (advisories.length) {
     }
   } else {
     process.stdout.write(
-      `[byan-lint-workflows] advisory: ${advisories.length} exploration leaf(s) run deep (rerun with --advise to list; keep deep if they bear a gate/judgment, else add model: 'haiku')\n`
+      `[byan-lint-workflows] advisory: ${advisories.length} downgrade-eligible leaf(s) run deep (rerun with --advise to list; exploration -> model: 'haiku', analysis -> model: 'sonnet', or keep deep if genuinely hard)\n`
     );
   }
 }