create-byan-agent 2.53.0 → 2.56.0

package/CHANGELOG.md

@@ -9,6 +9,108 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.56.0] - 2026-07-21
+
+### Changed — installation refondue : un moteur, deux visages
+- Nouveau moteur d'installation `install/lib/install-engine.js` : options ->
+  actions reelles (detection, copie `_byan` + `.claude`, configurations natives
+  Claude/Codex, dependances MCP, controle des copies globales de skills,
+  verification finale). La progression est honnete par construction : un
+  evenement d'etape = une action reellement executee. Defauts sans question :
+  Claude + Codex quand detectes, tous les agents, soul createur, rtk installe
+  s'il manque, configuration memorisee reutilisee. Nom du projet et repertoire
+  cible en options. Teste sur fixtures disque (7 cas).
+- `npx create-byan-agent` = installation automatique directe (plus d'interview).
+  Options : `--name`, `--dir`, `--no-launch`, `--no-rtk` ; l'ancienne interview
+  reste accessible via `--legacy`. En fin d'installation, Claude Code est lance
+  (canal byan-channel quand la version du CLI le supporte, sinon `claude`
+  normal ; commande affichee en terminal non interactif).
+- WebUI d'installation branchee sur le MEME moteur : les boutons installer et
+  mettre a jour executaient une simulation (etapes diffusees autour de pauses,
+  echec de l'updater avale puis succes affiche) — ils executent desormais le
+  moteur et l'updater reels, la progression WebSocket relaie chaque etape
+  executee, et l'ecran d'options porte nom du projet + repertoire. 3 tests par
+  injection d'un moteur factice.
+- Memoire d'installation dans le home : `install/lib/home-credentials.js`
+  (`~/.byan/credentials.json`, memes cles que le resolveur du serveur MCP,
+  fichier en mode 600, fusion sans effacement de secret). L'installation
+  reutilise ce qui est memorise et n'exige plus de re-saisie machine par
+  machine.
+- Le client Leantime du serveur MCP resout sa config via `resolve-config`
+  (env -> `~/.byan/credentials.json`) au lieu de lire seulement
+  l'environnement de lancement — le fichier memorise l'atteint enfin. Cadrage
+  Google documente (cle de service account memorisee ; OAuth interactif hors
+  perimetre serveur).
+
+
+## [2.55.0] - 2026-07-21
+
+### Added — l'installation propose la synchro des copies globales divergentes
+- Constate sur le terrain : l'installation pose des skills projet a jour, mais
+  une copie manuelle homonyme sous `~/.claude/skills/` (plus ancienne) peut
+  rester celle que la commande `/<skill>` charge — les nouveautes fraichement
+  installees restent invisibles. La garde de fraicheur (2.54.0) le signale a la
+  session suivante ; l'installeur, lui, voit la divergence au moment ou il la
+  cree et a un terminal pour poser la question.
+- Nouveau module `install/lib/global-skills-sync.js` : en fin d'installation
+  Claude, compare les skills fraichement poses avec les copies globales
+  homonymes (reutilise `compareSkills` du payload `.claude` livre par le meme
+  paquet — zero duplication de la comparaison) et, en terminal interactif,
+  propose la synchronisation projet -> global avec consentement explicite.
+  Refus ou terminal non interactif : signalement clair + la commande exacte a
+  copier ; rien n'est ecrit dans le home sans accord recueilli pendant ce run.
+- Le chemin `update` (corrige en 2.54.1) recoit le meme controle en mode
+  signalement : le resultat porte la liste des skills globaux divergents et la
+  commande de synchro est affichee.
+- Tests jest : 6 cas (divergence detectee via le comparateur livre, oui ->
+  copie effective, non -> rien ecrit, non-interactif -> rien ecrit + commande,
+  pas de dossier global -> silencieux, copies identiques -> silencieux).
+
+## [2.54.1] - 2026-07-21
+
+### Fixed — la commande update ne deployait pas .claude/
+- Cause racine constatee sur le terrain et verifiee dans le code (updater.js
+  lignes 30-31, manifest.js : seule la racine `_byan/` etait comparee et
+  copiee). Tout ce qui vit sous `.claude/` — les skills (dont le rail
+  auto-dispatch 2.53.0), les workflows natifs, les hooks (dont la garde de
+  fraicheur 2.54.0), settings.json et le `.mcp.json` regenere par le setup
+  natif — restait hors du perimetre de `update`. Un projet pouvait donc etre
+  "a jour" avec un `.claude/` vieux de plusieurs mois : rail absent, MCP
+  absent, garde absente.
+- Correctif : `update()` rafraichit aussi `.claude/` comme le fait
+  l'installation complete — sauvegarde dediee `.claude.backup-<ts>` (prefixe
+  distinct de `_byan.backup-` pour ne pas polluer la purge/rollback), copie
+  `templates/.claude` -> projet avec ecrasement, puis `setupClaudeNative`
+  (regenere `.mcp.json`, installe les dependances du serveur MCP, cable les
+  githooks). En cas d'echec, le `.claude/` d'origine est restaure.
+- Testabilite : `options.templateDir` et `options.nativeSetup` injectables ;
+  nouveau test fonctionnel `install/__tests__/yanstaller/updater.test.js`
+  (4 cas : deploiement du rail, projet sans `.claude`, rollback, deja a jour).
+- La sortie de la commande affiche desormais le rafraichissement `.claude` et
+  le chemin de sa sauvegarde.
+
+## [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)

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

@@ -1320,6 +1320,20 @@ async function install(options = {}) {
         )
       );
     }
+
+    // Stale global copies check : a same-named ~/.claude/skills/<n> that
+    // diverges from what was JUST installed can be the copy the slash command
+    // loads — the fresh features would stay invisible. Ask (TTY) or notice
+    // (non-TTY) ; no silent write into the user's home, ever.
+    try {
+      const { offerGlobalSkillsSync } = require('../lib/global-skills-sync');
+      const ask = process.stdout.isTTY
+        ? async (message) => (await inquirer.prompt([{ type: 'confirm', name: 'ok', message, default: true }])).ok
+        : null;
+      await offerGlobalSkillsSync(projectRoot, templateDir, { ask, log: (l) => console.log(chalk.yellow(l)) });
+    } catch (error) {
+      console.log(chalk.gray(`  [INFO] Global skills check skipped: ${error.message}`));
+    }
   }
 
   if (needsCodex) {
@@ -1887,13 +1901,77 @@ async function install(options = {}) {
   console.log(chalk.blue('Happy agent building! '));
 }
 
+// Default path since 2.56.0: the zero-question automatic install running the
+// shared engine (install/lib/install-engine.js) — the same engine the web
+// wizard calls. Claude+Codex by default (when detected), every agent, creator
+// soul, rtk installed when missing, stored home credentials reused. The legacy
+// ~20-question interview stays reachable behind --legacy only.
+async function installAuto(options) {
+  const engine = require('../lib/install-engine');
+  const projectRoot = path.resolve(options.dir || process.cwd());
+
+  console.log(chalk.cyan.bold(`\n  BYAN ${BYAN_VERSION} — installation automatique`));
+  console.log(chalk.gray(`  Projet : ${options.name || path.basename(projectRoot)}  |  Repertoire : ${projectRoot}`));
+  console.log(chalk.gray('  (interview complete : --legacy ; assistant web : create-byan-agent web)\n'));
+
+  let spinner = null;
+  const isTTY = Boolean(process.stdout.isTTY);
+  const ask = isTTY
+    ? async (message) => (await inquirer.prompt([{ type: 'confirm', name: 'ok', message, default: true }])).ok
+    : null;
+
+  try {
+    const result = await engine.runInstall({
+      projectRoot,
+      projectName: options.name || undefined,
+      rtk: options.rtk !== false,
+    }, {
+      onStep: ({ index, total, label }) => {
+        if (spinner) spinner.succeed();
+        spinner = ora(`[${index}/${total}] ${label}`).start();
+      },
+      log: (line) => { if (spinner) spinner.info(chalk.gray(line)).start(); else console.log(chalk.gray(line)); },
+      ask,
+    });
+    if (spinner) spinner.succeed();
+
+    console.log('');
+    console.log(chalk.green.bold(`  Installation terminee — verification ${result.verify.passed}/${result.verify.total}`));
+
+    // End-of-install launch (F5): start Claude Code, with the byan-channel
+    // when this CLI version supports it. --no-launch or a non-interactive
+    // terminal prints the command instead of running it.
+    if (result.launch) {
+      if (options.launch !== false && isTTY) {
+        console.log(chalk.cyan(`  Lancement de Claude Code : ${result.launch.command}\n`));
+        const { spawnSync } = require('child_process');
+        spawnSync(result.launch.command, { stdio: 'inherit', shell: true });
+      } else {
+        console.log(chalk.gray(`  Pour lancer Claude Code : ${result.launch.command}`));
+      }
+    } else {
+      console.log(chalk.gray('  Claude Code introuvable sur cette machine — installe-le puis lance `claude` dans le projet.'));
+    }
+  } catch (error) {
+    if (spinner) spinner.fail();
+    console.error(chalk.red.bold('\nInstallation en echec :'));
+    console.error(chalk.red(`  ${error.message}`));
+    process.exit(1);
+  }
+}
+
 // CLI Program
 program
   .name('create-byan-agent')
   .description('Install BYAN v2.2.0 - Builder of YAN with Model Selector and multi-platform support')
   .version(BYAN_VERSION)
   .option('--skip-version-check', 'Bypass the npm freshness guard (not recommended)')
-  .action(install);
+  .option('--name <name>', 'Nom du projet (defaut : nom du dossier)')
+  .option('--dir <dir>', 'Repertoire d installation (defaut : dossier courant)')
+  .option('--no-launch', 'Ne pas lancer Claude Code en fin d installation')
+  .option('--no-rtk', 'Ne pas installer rtk automatiquement')
+  .option('--legacy', 'Interview complete d origine (l ancien parcours a questions)')
+  .action(async (options) => (options.legacy ? install(options) : installAuto(options)));
 
 // Update Command (Yanstaller v3)
 program
@@ -1957,6 +2035,20 @@ program
       if (result.filesSkipped > 0) {
         console.log(chalk.yellow(`  Files skipped: ${result.filesSkipped} (user-modified)`));
       }
+      if (result.claudeRefreshed) {
+        console.log(chalk.green('  Claude Code:   .claude/ refreshed (skills, workflows, hooks) + native setup (.mcp.json, MCP deps)'));
+        if (result.claudeBackupPath) {
+          console.log(chalk.gray(`  .claude backup: ${path.basename(result.claudeBackupPath)}`));
+        }
+      }
+      if (result.globalSkillsDiverged && result.globalSkillsDiverged.length > 0) {
+        const { syncCommand } = require('../lib/global-skills-sync');
+        console.log(chalk.yellow(`  [!] Copies globales ~/.claude/skills divergentes : ${result.globalSkillsDiverged.join(', ')}`));
+        console.log(chalk.yellow('      Elles peuvent masquer les skills fraichement mis a jour. Pour les synchroniser :'));
+        for (const line of syncCommand(result.globalSkillsDiverged).split('\n')) {
+          console.log(chalk.gray(`        ${line}`));
+        }
+      }
       if (result.backupPath) {
         console.log(chalk.gray(`  Backup: ${path.basename(result.backupPath)}`));
       }

package/install/lib/global-skills-sync.js

@@ -0,0 +1,118 @@
+'use strict';
+
+/**
+ * GLOBAL SKILLS SYNC — closes the "stale global copy masks the fresh install"
+ * trap at INSTALL TIME.
+ *
+ * Field failure (2026-07-21): the installer laid a fully up-to-date
+ * .claude/skills/ in the project, but the user's manual copies under
+ * ~/.claude/skills/ (same names, months old) kept being the ones the slash
+ * command loaded — the freshly installed features stayed invisible. The
+ * session-start freshness hook flags this at the NEXT session; the installer
+ * can flag it at the very moment it creates the situation, and it has a TTY to
+ * ask. Red line kept from the hook: no silent write into the user's home —
+ * consent is asked, refusal or a non-interactive terminal degrades to a clear
+ * notice with the exact command.
+ *
+ * The comparison core is NOT duplicated: we require compareSkills from the
+ * .claude payload this very package ships (templates/.claude/hooks/lib/
+ * skill-freshness.js), the same tested module the session hook uses.
+ */
+
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+
+function loadComparator(templateDir) {
+  return require(path.join(templateDir, '.claude', 'hooks', 'lib', 'skill-freshness.js'));
+}
+
+/**
+ * Compare the project's freshly installed skills with same-named global copies.
+ * Silent-safe: any failure (no global dir, unreadable comparator) yields an
+ * empty result — this check must never break an install.
+ *
+ * @returns {Promise<{diverged: string[], checked: number}>}
+ */
+async function checkGlobalSkills(projectRoot, templateDir, { homeDir = os.homedir() } = {}) {
+  try {
+    const globalSkillsDir = path.join(homeDir, '.claude', 'skills');
+    if (!await fs.pathExists(globalSkillsDir)) return { diverged: [], checked: 0 };
+    const { compareSkills } = loadComparator(templateDir);
+    return compareSkills({
+      projectSkillsDir: path.join(projectRoot, '.claude', 'skills'),
+      globalSkillsDir,
+    });
+  } catch {
+    return { diverged: [], checked: 0 };
+  }
+}
+
+/**
+ * Copy the project SKILL.md over the global copy, per name. Only called after
+ * explicit consent. Returns the names actually synced (a per-name failure is
+ * skipped, never thrown).
+ */
+async function syncGlobalSkills(projectRoot, names, { homeDir = os.homedir() } = {}) {
+  const synced = [];
+  for (const name of names) {
+    try {
+      const src = path.join(projectRoot, '.claude', 'skills', name, 'SKILL.md');
+      const dest = path.join(homeDir, '.claude', 'skills', name, 'SKILL.md');
+      await fs.copy(src, dest, { overwrite: true });
+      synced.push(name);
+    } catch {
+      // one bad copy must not abort the others
+    }
+  }
+  return synced;
+}
+
+/** The exact copy-paste command shown when we do not write ourselves. */
+function syncCommand(names, { homeDir = os.homedir() } = {}) {
+  const globalDir = path.join(homeDir, '.claude', 'skills');
+  return names
+    .map((n) => `cp .claude/skills/${n}/SKILL.md ${path.join(globalDir, n, 'SKILL.md')}`)
+    .join('\n');
+}
+
+/**
+ * End-of-install offer.
+ *
+ * @param {string} projectRoot
+ * @param {string} templateDir
+ * @param {Object} opts
+ * @param {(question: string) => Promise<boolean>} [opts.ask] - Consent
+ *   collector (inquirer in the CLI). Absent (non-interactive) -> never write,
+ *   notice only.
+ * @param {(line: string) => void} [opts.log]
+ * @returns {Promise<{diverged: string[], synced: string[]}>}
+ */
+async function offerGlobalSkillsSync(projectRoot, templateDir, { ask = null, homeDir = os.homedir(), log = console.log } = {}) {
+  const { diverged } = await checkGlobalSkills(projectRoot, templateDir, { homeDir });
+  if (diverged.length === 0) return { diverged: [], synced: [] };
+
+  log(`  [!] ${diverged.length} skill(s) globaux divergents dans ~/.claude/skills : ${diverged.join(', ')}`);
+  log('      Ces copies datent d\'avant cette installation et peuvent etre celles que la');
+  log('      commande /<skill> charge — les nouveautes resteraient invisibles.');
+
+  let synced = [];
+  if (typeof ask === 'function') {
+    const yes = await ask('Synchroniser ces copies globales depuis le projet (sauvegarde du contenu : aucune — elles seront ecrasees) ?');
+    if (yes) {
+      synced = await syncGlobalSkills(projectRoot, diverged, { homeDir });
+      log(`  [OK] ${synced.length} copie(s) globale(s) synchronisee(s) depuis le projet`);
+      return { diverged, synced };
+    }
+  }
+  log('      Rien n\'a ete modifie dans ~/.claude. Pour synchroniser toi-meme :');
+  for (const line of syncCommand(diverged, { homeDir }).split('\n')) log(`        ${line}`);
+  return { diverged, synced };
+}
+
+module.exports = {
+  checkGlobalSkills,
+  syncGlobalSkills,
+  syncCommand,
+  offerGlobalSkillsSync,
+};

package/install/lib/home-credentials.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * HOME CREDENTIALS — the write side of the per-user install memory.
+ *
+ * The byan MCP server already RESOLVES its config from
+ * ~/.byan/credentials.json (env -> file -> default, see
+ * _byan/mcp/byan-mcp-server/lib/resolve-config.js). This module is the
+ * installer-side counterpart: read what a previous install stored, merge in
+ * what the user provides once, and never ask again on the next machine-wide
+ * install. os.homedir() covers Linux/macOS/Windows.
+ *
+ * Guarantees: reading never throws (missing/garbage file -> {}), writing is a
+ * merge (unknown keys already in the file are preserved), the file lands with
+ * mode 0600 (it holds tokens), and no value is ever logged by this module.
+ */
+
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+
+// Same key set the MCP server resolver understands — one vocabulary, two sides.
+const KNOWN_KEYS = Object.freeze([
+  'BYAN_API_URL',
+  'BYAN_API_TOKEN',
+  'LEANTIME_API_URL',
+  'LEANTIME_API_TOKEN',
+  'GOOGLE_APPLICATION_CREDENTIALS',
+  'GDOC_TEMPLATE_ID',
+  'GDOC_LOGO_PNG_URL',
+]);
+
+function credentialsPath(homeDir = os.homedir()) {
+  return path.join(homeDir, '.byan', 'credentials.json');
+}
+
+/** Read the stored credentials. Missing or invalid file -> {}. */
+function readCredentials({ homeDir = os.homedir() } = {}) {
+  try {
+    const parsed = fs.readJSONSync(credentialsPath(homeDir));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Merge-write: existing keys are kept unless the patch overrides them with a
+ * non-empty value. Empty/undefined patch values never erase a stored secret.
+ * Returns the merged object actually written.
+ */
+function writeCredentials(patch, { homeDir = os.homedir() } = {}) {
+  const current = readCredentials({ homeDir });
+  const merged = { ...current };
+  for (const [key, value] of Object.entries(patch || {})) {
+    // Only known keys are written from a patch. The patch can reach here from
+    // an HTTP body (the web wizard) ; an unknown key would be junk in the
+    // secret store. Keys already present in the file are preserved (the spread
+    // above), unknown ones just cannot be ADDED by a patch.
+    if (!KNOWN_KEYS.includes(key)) continue;
+    if (typeof value === 'string' && value.trim() !== '') merged[key] = value;
+  }
+  const file = credentialsPath(homeDir);
+  fs.ensureDirSync(path.dirname(file));
+  try {
+    fs.chmodSync(path.dirname(file), 0o700); // the dir holds only secrets
+  } catch {
+    // best-effort (Windows ACLs) — the 0600 file mode below is the real guard
+  }
+  fs.writeJSONSync(file, merged, { spaces: 2, mode: 0o600 });
+  try {
+    fs.chmodSync(file, 0o600); // writeJSON mode applies on create only; enforce on rewrite
+  } catch {
+    // chmod best-effort (e.g. Windows ACLs) — the write itself succeeded
+  }
+  return merged;
+}
+
+/** The keys among KNOWN_KEYS that are present and non-empty in the store. */
+function storedKeys({ homeDir = os.homedir() } = {}) {
+  const current = readCredentials({ homeDir });
+  return KNOWN_KEYS.filter((k) => typeof current[k] === 'string' && current[k].trim() !== '');
+}
+
+module.exports = {
+  KNOWN_KEYS,
+  credentialsPath,
+  readCredentials,
+  writeCredentials,
+  storedKeys,
+};

package/install/lib/install-engine.js

@@ -0,0 +1,297 @@
+'use strict';
+
+/**
+ * INSTALL ENGINE — the single real installation engine, one engine for two
+ * faces (terminal CLI and local web wizard).
+ *
+ * Why this module exists (field record, 2026-07-21): the whole install logic
+ * lived inline in a 2103-line interactive bin, so the web installer could not
+ * call it and shipped a SIMULATION instead (9 broadcast steps around sleep()
+ * calls). Three install/update gaps were fixed in three days because the logic
+ * had no single owner. This engine is that owner.
+ *
+ * Contract:
+ *   - options in, real actions out. No prompt in here, ever: consent-needing
+ *     choices arrive AS options (the faces collect them).
+ *   - progress is honest by construction: onStep fires once per step and each
+ *     step body performs the real action it names. No step, no broadcast.
+ *   - side steps that must not kill an install (rtk, skills sync, credentials)
+ *     record ok:false instead of throwing; core steps (copy, config) throw.
+ *
+ * Defaults are the zero-question install: Claude + Codex when detected, every
+ * agent, creator soul, rtk installed when missing.
+ */
+
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+const yaml = require('js-yaml');
+
+const { setupClaudeNative } = require('./claude-native-setup');
+const { setupCodexNative } = require('./codex-native-setup');
+const { offerGlobalSkillsSync } = require('./global-skills-sync');
+const homeCreds = require('./home-credentials');
+
+// Gen3 by-type dirs copied from templates/_byan (same list as the legacy bin).
+const BYAN_DIRS = ['agent', 'workflow', 'connaissance', 'command', 'worker', 'memoire',
+  'core', 'bmb', 'bmm', 'tea', 'cis', '_config', 'data'];
+
+function defaultTemplateDir() {
+  const p = path.join(__dirname, '..', 'templates');
+  return fs.existsSync(p) ? p : null;
+}
+
+function commandExists(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: 'ignore', shell: '/bin/sh' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Detection: platforms on this machine + stored credentials. Facts only. */
+function detectEnvironment({ homeDir = os.homedir() } = {}) {
+  return {
+    claude: fs.existsSync(path.join(homeDir, '.claude')) || commandExists('claude'),
+    codex: fs.existsSync(path.join(homeDir, '.codex')) || commandExists('codex'),
+    rtk: commandExists('rtk'),
+    storedCredentialKeys: homeCreds.storedKeys({ homeDir }),
+  };
+}
+
+/**
+ * The Claude Code launch command for the end of install. The byan-channel is a
+ * Claude Code research-preview feature behind an explicit flag; when the
+ * installed CLI does not know the flag, the plain `claude` command is the
+ * fallback. We only BUILD the command here — executing it is the caller's move.
+ */
+function claudeLaunchCommand() {
+  if (!commandExists('claude')) return null;
+  let helpText = '';
+  try {
+    helpText = execSync('claude --help', { encoding: 'utf8', timeout: 8000 });
+  } catch {
+    return { command: 'claude', channel: false };
+  }
+  const supportsChannel = helpText.includes('dangerously-load-development-channels');
+  return supportsChannel
+    ? { command: 'claude --dangerously-load-development-channels server:byan-channel', channel: true }
+    : { command: 'claude', channel: false };
+}
+
+/**
+ * Run the full installation.
+ *
+ * @param {object} options
+ * @param {string}  options.projectRoot   target directory (created if absent)
+ * @param {string}  [options.projectName] defaults to basename(projectRoot)
+ * @param {object}  [options.platforms]   {claude, codex} — defaults to detection
+ * @param {string}  [options.templateDir]
+ * @param {string}  [options.userName='Developer']
+ * @param {string}  [options.language='Francais']
+ * @param {boolean} [options.rtk=true]        install rtk when missing
+ * @param {object}  [options.credentials]     values to persist in ~/.byan/credentials.json
+ * @param {string}  [options.homeDir]
+ * @param {object}  [hooks]
+ * @param {(step:{index:number,total:number,id:string,label:string})=>void} [hooks.onStep]
+ * @param {(line:string)=>void} [hooks.log]
+ * @param {(q:string)=>Promise<boolean>} [hooks.ask]  consent collector for the
+ *        global-skills offer (absent -> notice only, nothing written in home)
+ * @param {Function} [hooks.claudeSetup] [hooks.codexSetup] [hooks.rtkInstall]  test injection
+ * @returns {Promise<{ok:boolean, steps:Array, verify:{passed:number,total:number,failed:string[]}, launch:{command:string,channel:boolean}|null}>}
+ */
+async function runInstall(options = {}, hooks = {}) {
+  const {
+    projectRoot,
+    projectName = path.basename(options.projectRoot || ''),
+    templateDir = defaultTemplateDir(),
+    userName = 'Developer',
+    language = 'Francais',
+    rtk = true,
+    credentials = null,
+    homeDir = os.homedir(),
+  } = options;
+  const onStep = hooks.onStep || (() => {});
+  const log = hooks.log || (() => {});
+  const claudeSetup = hooks.claudeSetup || setupClaudeNative;
+  const codexSetup = hooks.codexSetup || setupCodexNative;
+
+  if (!projectRoot) throw new Error('projectRoot est requis');
+  if (!templateDir || !fs.existsSync(path.join(templateDir, '_byan'))) {
+    throw new Error(`templates introuvables (${templateDir || 'aucun chemin'})`);
+  }
+
+  // Detection is injectable so tests do not depend on what THIS machine has.
+  const detected = hooks.detect ? hooks.detect() : detectEnvironment({ homeDir });
+  const platforms = options.platforms || { claude: detected.claude, codex: detected.codex };
+  const byanDir = path.join(projectRoot, '_byan');
+  const results = [];
+
+  // Step plan is computed FIRST so index/total are stable and honest.
+  const plan = [
+    { id: 'detect', label: 'Detection de l\'environnement' },
+    { id: 'copy-byan', label: 'Copie de la plateforme _byan/' },
+    { id: 'config', label: 'Ecriture de la configuration du projet' },
+  ];
+  if (platforms.claude) plan.push({ id: 'claude', label: 'Installation Claude Code (.claude + serveur MCP + .mcp.json)' });
+  if (platforms.codex) plan.push({ id: 'codex', label: 'Installation Codex (~/.codex)' });
+  if (credentials && Object.keys(credentials).length) plan.push({ id: 'credentials', label: 'Memorisation de la configuration (~/.byan/credentials.json)' });
+  if (platforms.claude) plan.push({ id: 'skills-sync', label: 'Controle des copies globales de skills' });
+  if (rtk) plan.push({ id: 'rtk', label: 'Verification / installation de rtk' });
+  plan.push({ id: 'verify', label: 'Verification finale' });
+
+  let index = 0;
+  const step = async (id, label, fn, { critical = true } = {}) => {
+    index += 1;
+    onStep({ index, total: plan.length, id, label });
+    try {
+      const detail = await fn();
+      results.push({ id, ok: true, detail: detail || '' });
+    } catch (err) {
+      results.push({ id, ok: false, detail: err.message });
+      if (critical) throw err;
+      log(`[!] etape ${id} en echec (non bloquant) : ${err.message}`);
+    }
+  };
+
+  await step('detect', plan[0].label, async () => {
+    log(`Claude: ${detected.claude ? 'present' : 'absent'} ; Codex: ${detected.codex ? 'present' : 'absent'} ; rtk: ${detected.rtk ? 'present' : 'absent'}`);
+    if (detected.storedCredentialKeys.length) {
+      log(`Configuration memorisee reutilisee (${detected.storedCredentialKeys.length} cle(s), rien a re-saisir)`);
+    }
+    return `claude=${detected.claude} codex=${detected.codex} rtk=${detected.rtk}`;
+  });
+
+  await step('copy-byan', 'Copie de la plateforme _byan/', async () => {
+    const src = path.join(templateDir, '_byan');
+    await fs.ensureDir(byanDir);
+    let copied = 0;
+    for (const dir of BYAN_DIRS) {
+      const s = path.join(src, dir);
+      if (await fs.pathExists(s)) {
+        await fs.copy(s, path.join(byanDir, dir), { overwrite: true });
+        copied += 1;
+      }
+    }
+    for (const file of await fs.readdir(src)) {
+      const full = path.join(src, file);
+      if ((await fs.stat(full)).isFile()) await fs.copy(full, path.join(byanDir, file), { overwrite: true });
+    }
+    return `${copied} dossiers copies`;
+  });
+
+  await step('config', 'Ecriture de la configuration du projet', async () => {
+    const bmbDir = path.join(byanDir, 'bmb');
+    await fs.ensureDir(bmbDir);
+    const configContent = {
+      bmb_creations_output_folder: '{project-root}/_byan-output/bmb-creations',
+      user_name: userName,
+      communication_language: language,
+      document_output_language: language,
+      output_folder: '{project-root}/_byan-output',
+      project_name: projectName,
+      platform: Object.entries(platforms).filter(([, v]) => v).map(([k]) => k).join(',') || 'none',
+      install_mode: 'engine-auto',
+      byan_version: readOwnVersion(),
+    };
+    await fs.writeFile(path.join(bmbDir, 'config.yaml'), yaml.dump(configContent), 'utf8');
+    return 'config.yaml ecrit';
+  });
+
+  if (platforms.claude) {
+    await step('claude', 'Installation Claude Code', async () => {
+      const claudeSource = path.join(templateDir, '.claude');
+      if (await fs.pathExists(claudeSource)) {
+        await fs.ensureDir(path.join(projectRoot, '.claude', 'rules'));
+        await fs.copy(claudeSource, path.join(projectRoot, '.claude'), { overwrite: true });
+      }
+      await claudeSetup(projectRoot);
+      return '.claude copie + configuration native (hooks, skills, .mcp.json, dependances MCP)';
+    });
+  }
+
+  if (platforms.codex) {
+    await step('codex', 'Installation Codex', async () => {
+      await codexSetup(projectRoot, { templateDir, force: true });
+      return 'squelettes .codex + config';
+    }, { critical: false });
+  }
+
+  if (credentials && Object.keys(credentials).length) {
+    await step('credentials', 'Memorisation de la configuration', async () => {
+      const merged = homeCreds.writeCredentials(credentials, { homeDir });
+      return `${Object.keys(merged).length} cle(s) en memoire dans ${homeCreds.credentialsPath(homeDir)}`;
+    }, { critical: false });
+  }
+
+  if (platforms.claude) {
+    await step('skills-sync', 'Controle des copies globales de skills', async () => {
+      const r = await offerGlobalSkillsSync(projectRoot, templateDir, { ask: hooks.ask || null, homeDir, log });
+      return r.diverged.length === 0 ? 'copies globales fideles' : `${r.diverged.length} divergente(s), ${r.synced.length} synchronisee(s)`;
+    }, { critical: false });
+  }
+
+  if (rtk) {
+    await step('rtk', 'Verification / installation de rtk', async () => {
+      if (detected.rtk) return 'rtk deja present';
+      const rtkInstall = hooks.rtkInstall || (() => {
+        // The official rtk setup script shipped with this package. Non-TTY
+        // safe: it runs unattended; a failure is reported, never fatal.
+        const script = path.join(__dirname, '..', 'setup-rtk.js');
+        const r = spawnSync(process.execPath, [script], { encoding: 'utf8', timeout: 300000 });
+        if (r.status !== 0) throw new Error(`setup-rtk sortie ${r.status}: ${(r.stderr || '').slice(0, 200)}`);
+        return 'rtk installe';
+      });
+      return rtkInstall();
+    }, { critical: false });
+  }
+
+  let verify = { passed: 0, total: 0, failed: [] };
+  await step('verify', 'Verification finale', async () => {
+    const checks = [
+      { name: 'Dossier agents', p: path.join(byanDir, 'agent') },
+      { name: 'Agent BYAN', p: path.join(byanDir, 'agent', 'byan', 'byan.md') },
+      { name: 'Workflows', p: path.join(byanDir, 'workflow') },
+      { name: 'Config', p: path.join(byanDir, 'bmb', 'config.yaml') },
+    ];
+    if (platforms.claude) {
+      checks.push(
+        { name: 'CLAUDE.md', p: path.join(projectRoot, '.claude', 'CLAUDE.md') },
+        { name: 'Regles Claude', p: path.join(projectRoot, '.claude', 'rules') },
+        { name: 'Skill byan-byan', p: path.join(projectRoot, '.claude', 'skills', 'byan-byan', 'SKILL.md') },
+        { name: 'Workflow auto-dispatch', p: path.join(projectRoot, '.claude', 'workflows', 'byan-auto-dispatch.js') },
+      );
+    }
+    const failed = [];
+    for (const c of checks) {
+      if (!await fs.pathExists(c.p)) failed.push(c.name);
+    }
+    verify = { passed: checks.length - failed.length, total: checks.length, failed };
+    if (failed.length) throw new Error(`verification incomplete : ${failed.join(', ')}`);
+    return `${verify.passed}/${verify.total} controles OK`;
+  });
+
+  return {
+    ok: results.every((r) => r.ok || !['detect', 'copy-byan', 'config', 'claude', 'verify'].includes(r.id)),
+    steps: results,
+    verify,
+    launch: claudeLaunchCommand(),
+  };
+}
+
+function readOwnVersion() {
+  try {
+    return fs.readJSONSync(path.join(__dirname, '..', '..', 'package.json')).version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+module.exports = {
+  runInstall,
+  detectEnvironment,
+  claudeLaunchCommand,
+  BYAN_DIRS,
+};

package/install/lib/yanstaller/updater.js

@@ -12,6 +12,7 @@ const path = require('path');
 const { compareVersions, getLatestVersion } = require('../utils/version-compare');
 const { diffFiles } = require('../utils/file-differ');
 const { readManifest, writeManifest, generateManifest, detectUserModifications } = require('../utils/manifest');
+const { setupClaudeNative } = require('../claude-native-setup');
 const backuper = require('./backuper');
 const logger = require('../utils/logger');
 
@@ -137,11 +138,15 @@ async function update(projectRoot, options = {}) {
       backupPath: null,
       filesUpdated: 0,
       filesAdded: 0,
-      filesSkipped: 0
+      filesSkipped: 0,
+      claudeRefreshed: false,
+      claudeBackupPath: null
     };
   }
 
-  const templateDir = getTemplateDir();
+  // templateDir is injectable so the flow is testable without touching the
+  // packaged templates (and so a caller can point at a staged template set).
+  const templateDir = options.templateDir || getTemplateDir();
   if (!templateDir) {
     throw new Error('Template directory not found. Is the package installed correctly?');
   }
@@ -170,6 +175,10 @@ async function update(projectRoot, options = {}) {
   let filesUpdated = 0;
   let filesAdded = 0;
   let filesSkipped = 0;
+  let claudeRefreshed = false;
+  let claudeBackupPath = null;
+  let globalSkillsDiverged = [];
+  const installedClaude = path.join(projectRoot, '.claude');
 
   try {
     // Apply updated files (skip user-modified unless forced)
@@ -195,6 +204,38 @@ async function update(projectRoot, options = {}) {
       filesAdded++;
     }
 
+    // --- .claude refresh -------------------------------------------------
+    // The update must deploy what the full install deploys. Historically it
+    // only diffed _byan/, so everything living under .claude/ (skills with the
+    // auto-dispatch rail, native workflows, hooks, settings, and the .mcp.json
+    // regenerated by the native setup) was NEVER refreshed by `update` — an
+    // up-to-date _byan/ next to a months-old .claude/. Same contract as the
+    // full install (copy with overwrite), with a dedicated backup first. The
+    // backup uses its own `.claude.backup-` prefix : reusing the `_byan.backup-`
+    // prefix would make pruneBackups/rollback treat it as a _byan backup.
+    const templateClaude = path.join(templateDir, '.claude');
+    if (await fs.pathExists(templateClaude) && await fs.pathExists(installedClaude)) {
+      claudeBackupPath = path.join(projectRoot, `.claude.backup-${Date.now()}`);
+      await fs.copy(installedClaude, claudeBackupPath);
+      await fs.copy(templateClaude, installedClaude, { overwrite: true });
+      // Same native pass as the full install : regenerates .mcp.json, installs
+      // the MCP server dependencies, wires git hooks. Injectable for tests.
+      const nativeSetup = options.nativeSetup || setupClaudeNative;
+      await nativeSetup(projectRoot);
+      claudeRefreshed = true;
+      logger.debug(`.claude refreshed from templates (backup: ${claudeBackupPath})`);
+
+      // Stale global copies check (notice-only on the update path : no TTY
+      // conversation here, and the home is never written without consent).
+      // The CLI surfaces the diverged names + the exact sync command.
+      try {
+        const { checkGlobalSkills } = require('../global-skills-sync');
+        globalSkillsDiverged = (await checkGlobalSkills(projectRoot, templateDir)).diverged;
+      } catch {
+        // the check must never fail an update
+      }
+    }
+
     // Regenerate manifest with new state
     const newManifest = await generateManifest(installedByan, latest);
     await writeManifest(projectRoot, newManifest);
@@ -206,6 +247,11 @@ async function update(projectRoot, options = {}) {
     // Rollback on failure
     logger.error(`Update failed, restoring backup: ${error.message}`);
     await backuper.restore(backupResult.backupPath, installedByan);
+    if (claudeBackupPath && await fs.pathExists(claudeBackupPath)) {
+      await fs.remove(installedClaude);
+      await fs.copy(claudeBackupPath, installedClaude);
+      logger.error('.claude restored from its pre-update backup');
+    }
     throw error;
   }
 
@@ -216,7 +262,10 @@ async function update(projectRoot, options = {}) {
     backupPath: backupResult.backupPath,
     filesUpdated,
     filesAdded,
-    filesSkipped
+    filesSkipped,
+    claudeRefreshed,
+    claudeBackupPath,
+    globalSkillsDiverged
   };
 }
 

package/install/src/webui/api.js

@@ -53,6 +53,18 @@ function json(res, statusCode, data) {
   res.end(JSON.stringify(data));
 }
 
+// Confine an HTTP-supplied install/update directory to the server's launch
+// directory. A relative value resolves inside base; base itself, or any path
+// that escapes it (../, absolute elsewhere), collapses back to base. The
+// installer targets the project the wizard was launched in — nothing else.
+function confineToBase(candidate, base) {
+  if (!candidate || typeof candidate !== 'string') return base;
+  const resolved = path.resolve(base, candidate);
+  const rel = path.relative(base, resolved);
+  const escapes = rel === '' ? false : (rel.startsWith('..') || path.isAbsolute(rel));
+  return escapes ? base : resolved;
+}
+
 function readPackageVersion() {
   try {
     const pkg = JSON.parse(
@@ -141,39 +153,54 @@ const routes = {
     });
   },
 
+  // Runs the REAL install engine (install/lib/install-engine.js) — the same
+  // one the CLI uses. Every progress broadcast maps 1:1 to a real action; the
+  // previous handler here simulated 9 steps around sleep() calls and only
+  // created directories, which is exactly the dishonest-progress trap the
+  // engine forbids. `server.installEngine` is injectable for tests.
   'POST install': async (req, res, server) => {
     json(res, 200, { status: 'started' });
 
     const config = req.body || {};
-    const projectRoot = server.projectRoot;
-    const steps = [
-      'Detecting environment',
-      'Validating prerequisites',
-      'Creating directory structure',
-      'Installing core module',
-      'Installing selected modules',
-      'Configuring platforms',
-      'Generating agent stubs',
-      'Writing configuration',
-      'Validating installation'
-    ];
+    // projectDir comes from the HTTP body — it must NOT be an arbitrary path
+    // sink (the engine writes files and spawns processes). Confine it to the
+    // directory the server was launched in: the wizard installs "here", the
+    // exact intent of `create-byan-agent web` run in a project.
+    const projectRoot = confineToBase(config.projectDir, server.projectRoot);
 
     try {
-      for (let i = 0; i < steps.length; i++) {
-        server.broadcastProgress(i + 1, steps.length, steps[i]);
-        server.broadcastLog('info', steps[i] + '...');
-        await sleep(300);
-      }
-
-      ensureDirectoryStructure(projectRoot);
-      writeBaseConfig(projectRoot, config);
+      const installEngine = server.installEngine || require('../../lib/install-engine');
+      // The wizard form sends platforms as an array (['claude','codex']); the
+      // engine takes an object. An empty selection means "let the engine detect".
+      const platformList = Array.isArray(config.platforms) ? config.platforms : null;
+      const platforms = platformList && platformList.length
+        ? { claude: platformList.includes('claude'), codex: platformList.includes('codex') }
+        : (config.platforms && !Array.isArray(config.platforms) ? config.platforms : undefined);
+      const result = await installEngine.runInstall({
+        projectRoot,
+        projectName: config.projectName || undefined,
+        platforms,
+        userName: config.userName || undefined,
+        language: config.language || undefined,
+        rtk: config.rtk !== false,
+        credentials: config.credentials || null,
+      }, {
+        onStep: ({ index, total, label }) => {
+          server.broadcastProgress(index, total, label);
+          server.broadcastLog('info', label);
+        },
+        log: (line) => server.broadcastLog('info', line),
+        // No consent prompt over HTTP: the global-skills offer degrades to a
+        // notice with the exact command (same non-interactive contract as CI).
+        ask: null,
+      });
 
-      server.broadcastProgress(steps.length, steps.length, 'Complete');
-      server.broadcastComplete(true, {
-        message: 'BYAN installed successfully',
+      server.broadcastComplete(result.ok, {
+        message: result.ok ? 'Installation BYAN terminee' : 'Installation terminee avec des etapes en echec',
         projectRoot,
-        mode: config.mode || 'auto',
-        platforms: config.platforms || detectPlatforms(projectRoot)
+        verify: result.verify,
+        steps: result.steps,
+        launch: result.launch,
       });
     } catch (err) {
       server.broadcastLog('error', err.message);
@@ -181,34 +208,29 @@ const routes = {
     }
   },
 
+  // Runs the REAL updater (yanstaller.update, which since 2.54.1 refreshes
+  // _byan AND .claude + native setup). The previous handler simulated 6 steps,
+  // called update with a wrong argument, swallowed its failure and broadcast
+  // success regardless — the result is now the truth, including failures.
   'POST update': async (req, res, server) => {
     json(res, 200, { status: 'started' });
-
-    const steps = [
-      'Checking current version',
-      'Creating backup',
-      'Downloading update',
-      'Applying changes',
-      'Merging configuration',
-      'Validating update'
-    ];
+    const projectRoot = confineToBase(req.body && req.body.projectDir, server.projectRoot);
 
     try {
-      for (let i = 0; i < steps.length; i++) {
-        server.broadcastProgress(i + 1, steps.length, steps[i]);
-        server.broadcastLog('info', steps[i] + '...');
-        await sleep(400);
-      }
-
-      if (yanstaller && yanstaller.update) {
-        try {
-          await yanstaller.update('latest');
-        } catch (err) {
-          server.broadcastLog('warn', `Update module: ${err.message}`);
-        }
+      if (!yanstaller || !yanstaller.update) {
+        throw new Error('Module de mise a jour indisponible dans ce paquet');
       }
-
-      server.broadcastComplete(true, { message: 'BYAN updated successfully' });
+      server.broadcastProgress(1, 2, 'Mise a jour en cours (_byan + .claude + configuration native)');
+      const result = await (server.updater || yanstaller.update)(projectRoot, {});
+      server.broadcastProgress(2, 2, 'Terminee');
+      server.broadcastComplete(true, {
+        message: `Mise a jour ${result.previousVersion} -> ${result.newVersion}`,
+        filesUpdated: result.filesUpdated,
+        filesAdded: result.filesAdded,
+        filesSkipped: result.filesSkipped,
+        claudeRefreshed: result.claudeRefreshed === true,
+        globalSkillsDiverged: result.globalSkillsDiverged || [],
+      });
     } catch (err) {
       server.broadcastLog('error', err.message);
       server.broadcastComplete(false, { message: err.message });

package/install/src/webui/public/app.js

@@ -200,6 +200,15 @@ class ByanApp {
         <label for="cfg-name">Your Name</label>
         <input id="cfg-name" type="text" value="${this.escapeHtml(this.config.userName)}" placeholder="Yan">
       </div>
+      <div class="form-group">
+        <label for="cfg-project-name">Project Name</label>
+        <input id="cfg-project-name" type="text" value="${this.escapeHtml(this.config.projectName || '')}" placeholder="mon-projet">
+      </div>
+      <div class="form-group">
+        <label for="cfg-project-dir">Project Directory</label>
+        <input id="cfg-project-dir" type="text" value="${this.escapeHtml(this.config.projectDir || this.status?.projectRoot || '')}" placeholder="/chemin/vers/le/projet">
+        <div class="form-hint">Defaults to the directory the wizard was launched from.</div>
+      </div>
       <div class="form-group">
         <label for="cfg-lang">Communication Language</label>
         <select id="cfg-lang">
@@ -239,9 +248,13 @@ class ByanApp {
   readConfigForm() {
     const nameEl = document.getElementById('cfg-name');
     const langEl = document.getElementById('cfg-lang');
+    const projNameEl = document.getElementById('cfg-project-name');
+    const projDirEl = document.getElementById('cfg-project-dir');
 
     if (nameEl) this.config.userName = nameEl.value.trim() || 'User';
     if (langEl) this.config.language = langEl.value;
+    if (projNameEl) this.config.projectName = projNameEl.value.trim();
+    if (projDirEl) this.config.projectDir = projDirEl.value.trim();
 
     const platforms = [];
     document.querySelectorAll('input[name="platform"]:checked').forEach(el => platforms.push(el.value));
@@ -264,7 +277,8 @@ class ByanApp {
       ['Language', this.config.language],
       ['Platforms', this.config.platforms.join(', ') || 'auto-detect'],
       ['Modules', this.config.modules.join(', ')],
-      ['Project Root', this.status?.projectRoot || '(auto)']
+      ['Project Name', this.config.projectName || '(nom du dossier)'],
+      ['Project Root', this.config.projectDir || this.status?.projectRoot || '(auto)']
     ];
 
     container.innerHTML = rows.map(([k, v]) =>

package/install/src/webui/server.js

@@ -50,7 +50,12 @@ class ByanWebUI {
     });
 
     return new Promise((resolve) => {
-      this.server.listen(this.port, () => {
+      // Bind to loopback ONLY. Without a host argument Node binds to :: (every
+      // interface), which made the installer LAN-reachable — and since it runs
+      // the real install engine (file writes + child processes), that exposed
+      // an arbitrary-write surface to the local network. A local installer has
+      // no business listening off-host.
+      this.server.listen(this.port, '127.0.0.1', () => {
         const addr = this.server.address();
         const assignedPort = (addr && typeof addr === 'object') ? addr.port : this.port;
         const url = `http://localhost:${assignedPort}`;

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

@@ -61,6 +61,25 @@ const METAPHOR_OFFENDERS = Object.freeze([
     label: 'outil "vivant/mort"',
     good: 'le fait observe : "repond" / "ne repond pas" + le resultat exact',
   },
+  {
+    // BYAN in-house doctrine shorthand dropped raw in prose (field complaint,
+    // 2026-07-21). "le rail" means the byan-auto-dispatch workflow; a reader
+    // without the internal doctrine cannot decode it — same offence as raw
+    // English jargon (IA-26). The article-bound match spares ordinary French
+    // ("un rail de guidage", "rail ferroviaire").
+    id: 'jargon-doctrine-rail',
+    re: /\b(?:le|ce|du)\s+rail\b(?!\s+(?:de|d'|ferroviaire))/i,
+    label: '"le rail" (jargon doctrine)',
+    good: 'dis-le en clair : le workflow automatique de dispatch (byan-auto-dispatch)',
+  },
+  {
+    // "voie/option armee" means: option enabled AND Codex linked. Say the fact.
+    // The noun-bound match spares the ordinary word ("l'armee").
+    id: 'jargon-doctrine-armee',
+    re: /\b(?:voie|option|lane)\s+(?:est\s+|n'est\s+pas\s+)?arm[ée]e?s?\b/i,
+    label: 'voie/option "armee" (jargon doctrine)',
+    good: 'dis le fait : option activee ET Codex connecte (ou pas)',
+  },
 ]);
 
 // 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/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/_byan/mcp/byan-mcp-server/lib/leantime-sync.js

@@ -21,6 +21,12 @@
 // format against projets.acadenice.com. Items tagged VERIFY@F0 are the ones the
 // recon could not confirm without a live call.
 
+// Config resolution goes through resolve-config (env -> ~/.byan/credentials.json
+// -> empty), the same chain the rest of the server uses. Reading process.env
+// directly here was the gap that made the per-user credentials file invisible
+// to the Leantime client.
+import { resolveConfig } from './resolve-config.js';
+
 const DEFAULT_TIMEOUT_MS = 5000;
 const RPC_PATH = '/api/jsonrpc';
 
@@ -62,11 +68,11 @@ const DEFAULT_STATUS_MAP = {
 };
 
 function apiBase() {
-  return (process.env.LEANTIME_API_URL || '').replace(/\/+$/, '');
+  return (resolveConfig().LEANTIME_API_URL || '').replace(/\/+$/, '');
 }
 
 function apiToken() {
-  return process.env.LEANTIME_API_TOKEN || '';
+  return resolveConfig().LEANTIME_API_TOKEN || '';
 }
 
 // Leantime authenticates the JSON-RPC API with its own header, NOT an

package/install/templates/docs/intelligent-dispatch.md

@@ -86,3 +86,14 @@ dev leaf holds the Bash tool and is what actually invokes `codex exec`.
 `codex mcp-server` is wired, Codex becomes a tool Claude can call mid-reasoning
 (and Codex can call BYAN tools back) — the closest thing to live. It drops in as a
 new transport behind the same F2 seam, with no change to F1 or the loop.
+
+## Config des integrations (Leantime, Google) — une seule memoire
+
+Depuis 2.56.0, le client Leantime du serveur MCP resout sa config par la meme
+chaine que le reste du serveur : variables d'environnement d'abord, puis
+`~/.byan/credentials.json`, ecrit par l'installeur a la premiere saisie. Google
+suit le meme fichier (`GOOGLE_APPLICATION_CREDENTIALS`, `GDOC_TEMPLATE_ID`,
+`GDOC_LOGO_PNG_URL`, deja compris par `resolve-config.js`) : l'acces Google
+passe par une cle de service account dont le CHEMIN est memorise — le portage
+d'un OAuth interactif complet dans le serveur MCP reste hors perimetre (le
+serveur tourne sans navigateur), c'est le cadrage assume.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.53.0",
+  "version": "2.56.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": {