create-byan-agent 2.19.1 → 2.20.0

package/src/byan-v2/generation/mantra-audit.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+//
+// mantra-audit — semantic embodiment audit for BYAN personas (Option C, N2).
+//
+// Lives under src/byan-v2/generation/ so it ships with the v2 runtime (the
+// installer copies src/ into the user project) next to the validator and
+// scope-resolver it depends on. Invoke with:
+//   node src/byan-v2/generation/mantra-audit.js prepare <agentFile> [--json]
+//   node src/byan-v2/generation/mantra-audit.js score   <agentFile> <verdicts.json>
+//
+// The pre-commit mantra gate is a fast, deterministic anti-stub FLOOR : it asks
+// "does this persona contain the vocabulary of its domain mantras". That catches
+// empty/zombie files but does NOT measure whether the agent genuinely EMBODIES a
+// mantra. This tool is the deeper, out-of-band layer : it prepares a judgment
+// packet (the applicable mantras + the persona + a rubric) for an LLM judge, then
+// turns the judge's verdicts into an embodiment score. It is deliberately NOT in
+// the commit path : the judgment is semantic (an LLM call), so it runs on demand
+// or in CI, outside the commit path (a non-deterministic check must not block it).
+//
+// verdicts.json : { "<mantraId>": "embodied" | "partial" | "absent", ... }
+
+const fs = require('fs');
+const path = require('path');
+const MantraValidator = require('./mantra-validator');
+const resolver = require('./scope-resolver');
+
+const VERDICT_WEIGHT = { embodied: 1, partial: 0.5, absent: 0 };
+
+function buildPacket(agentFile) {
+  const content = fs.readFileSync(agentFile, 'utf8');
+  const name = path.basename(agentFile).replace(/\.md$/, '');
+  const scopes = resolver.resolveAgentScopes({ name, content });
+  const applicable = new MantraValidator().applicableMantras(scopes);
+  return {
+    agent: name,
+    file: agentFile,
+    scopes,
+    mantras: applicable.map(m => ({
+      id: m.id,
+      title: m.title,
+      description: m.description,
+      scope: m.scope || 'universal',
+      priority: m.priority,
+    })),
+    persona: content,
+  };
+}
+
+function buildPrompt(packet) {
+  const lines = [];
+  lines.push('You are auditing whether a BYAN agent persona EMBODIES its applicable mantras.');
+  lines.push('Judge embodiment, not vocabulary : a mantra is embodied when the persona\'s role,');
+  lines.push('instructions, and red-lines actually enact the principle, even if the exact keyword');
+  lines.push('is absent. For each mantra return one verdict : embodied | partial | absent.');
+  lines.push('');
+  lines.push(`Agent : ${packet.agent}    Scopes : ${packet.scopes.join(', ')}`);
+  lines.push('');
+  lines.push('Applicable mantras :');
+  for (const m of packet.mantras) {
+    lines.push(`- ${m.id} (${m.scope}, ${m.priority}) : ${m.title} -- ${m.description}`);
+  }
+  lines.push('');
+  lines.push('Persona under audit :');
+  lines.push('"""');
+  lines.push(packet.persona.trim());
+  lines.push('"""');
+  lines.push('');
+  lines.push('Return strict JSON mapping every mantra id to its verdict, e.g.');
+  lines.push('{ "IA-16": "embodied", "M37": "partial", "IA-2": "absent" }');
+  return lines.join('\n');
+}
+
+function scoreVerdicts(packet, verdicts) {
+  const ids = packet.mantras.map(m => m.id);
+  let sum = 0;
+  const buckets = { embodied: [], partial: [], absent: [], unjudged: [] };
+  for (const id of ids) {
+    const v = verdicts[id];
+    if (v && Object.prototype.hasOwnProperty.call(VERDICT_WEIGHT, v)) {
+      sum += VERDICT_WEIGHT[v];
+      buckets[v].push(id);
+    } else {
+      buckets.unjudged.push(id);
+    }
+  }
+  const total = ids.length;
+  const embodimentScore = total > 0 ? Math.round((sum / total) * 100) : 0;
+  return {
+    agent: packet.agent,
+    scopes: packet.scopes,
+    total,
+    embodimentScore,
+    embodied: buckets.embodied,
+    partial: buckets.partial,
+    absent: buckets.absent,
+    unjudged: buckets.unjudged,
+  };
+}
+
+function main(argv) {
+  const [cmd, agentFile, arg3] = argv;
+
+  if (!cmd || !agentFile || ['-h', '--help'].includes(cmd)) {
+    process.stdout.write(
+      'Usage :\n' +
+      '  node src/byan-v2/generation/mantra-audit.js prepare <agentFile> [--json]\n' +
+      '  node src/byan-v2/generation/mantra-audit.js score   <agentFile> <verdicts.json>\n'
+    );
+    return cmd ? 0 : 1;
+  }
+
+  if (!fs.existsSync(agentFile)) {
+    process.stderr.write(`Agent file not found : ${agentFile}\n`);
+    return 1;
+  }
+
+  const packet = buildPacket(agentFile);
+
+  if (cmd === 'prepare') {
+    if (arg3 === '--json') {
+      process.stdout.write(JSON.stringify(packet, null, 2) + '\n');
+    } else {
+      process.stdout.write(buildPrompt(packet) + '\n');
+    }
+    return 0;
+  }
+
+  if (cmd === 'score') {
+    if (!arg3 || !fs.existsSync(arg3)) {
+      process.stderr.write('A verdicts JSON file is required : score <agentFile> <verdicts.json>\n');
+      return 1;
+    }
+    const verdicts = JSON.parse(fs.readFileSync(arg3, 'utf8'));
+    const result = scoreVerdicts(packet, verdicts);
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    return 0;
+  }
+
+  process.stderr.write(`Unknown command : ${cmd}\n`);
+  return 1;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+module.exports = { buildPacket, buildPrompt, scoreVerdicts, VERDICT_WEIGHT };

package/src/byan-v2/generation/mantra-validator.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+// Score bands, single source of truth (referenced by generateReport + export).
+const PASS_THRESHOLD = 80;
+const WARNING_THRESHOLD = 60;
+
 class MantraValidator {
   constructor(mantrasData = null) {
     if (mantrasData) {
@@ -42,7 +46,28 @@ class MantraValidator {
     return strictIds.length >= 3;
   }
 
-  validate(agentDefinition) {
+  // Normalize a caller-supplied scope (string | string[] | Set | null) into a
+  // Set, or null when no scope was given. Null means legacy all-mantras scoring.
+  _normalizeScope(scope) {
+    if (scope === null || scope === undefined) return null;
+    if (scope instanceof Set) return scope;
+    if (Array.isArray(scope)) return new Set(scope);
+    return new Set([scope]);
+  }
+
+  // A mantra is applicable to a scoped run when it is universal (or unscoped)
+  // or its scope is in the requested set. Behavioral mantras are runtime-
+  // enforced (hooks / fact-check), not declared in a persona file, so they are
+  // excluded from scoped scoring. With no scope (null), every mantra applies.
+  _isApplicable(mantra, scopeSet) {
+    if (scopeSet === null) return true;
+    if (mantra.behavioral === true) return false;
+    const ms = mantra.scope || 'universal';
+    if (ms === 'universal') return true;
+    return scopeSet.has(ms);
+  }
+
+  validate(agentDefinition, options = {}) {
     if (agentDefinition === null || agentDefinition === undefined) {
       throw new Error('Agent definition is required');
     }
@@ -59,8 +84,16 @@ class MantraValidator {
       this.mantras = this.personaMantras;
     }
 
+    // Domain-aware scoring : when the caller passes a scope, only the mantras
+    // applicable to that scope are counted (universal always counts, behavioral
+    // runtime-enforced mantras are excluded). With no scope, every mantra in the
+    // chosen ruleset is scored, byte-identical to the legacy behavior.
+    const scopeSet = this._normalizeScope(options.scope);
+    const applicableMantras = this.mantras.filter(m => this._isApplicable(m, scopeSet));
+
     this.results = {
-      totalMantras: this.mantras.length,
+      totalMantras: applicableMantras.length,
+      scope: scopeSet ? [...scopeSet] : null,
       compliant: [],
       nonCompliant: [],
       warnings: [],
@@ -70,7 +103,7 @@ class MantraValidator {
 
     const startTime = Date.now();
 
-    for (const mantra of this.mantras) {
+    for (const mantra of applicableMantras) {
       const result = this.checkMantra(mantra.id, agentDefinition);
       
       if (result.compliant) {
@@ -154,8 +187,17 @@ class MantraValidator {
 
   _validatePattern(content, validation, mantra) {
     try {
+      // Some forbidden-pattern mantras (e.g. IA-23 no-emoji) must ignore
+      // declared zones such as an agent's icon="..." frontmatter attribute,
+      // where an emoji is a legitimate display glyph, not pollution.
+      let scanContent = content;
+      if (Array.isArray(validation.ignoreZones)) {
+        for (const zone of validation.ignoreZones) {
+          scanContent = scanContent.replace(new RegExp(zone, 'g'), '');
+        }
+      }
       const regex = new RegExp(validation.pattern, validation.flags || '');
-      const matches = content.match(regex);
+      const matches = scanContent.match(regex);
       const hasMatches = matches && matches.length > 0;
 
       if (validation.mustNotMatch) {
@@ -255,7 +297,7 @@ class MantraValidator {
     }
 
     const score = this.results.score;
-    const level = score >= 80 ? 'PASS' : score >= 60 ? 'WARNING' : 'FAIL';
+    const level = score >= PASS_THRESHOLD ? 'PASS' : score >= WARNING_THRESHOLD ? 'WARNING' : 'FAIL';
 
     let report = '';
     report += '='.repeat(60) + '\n';
@@ -424,7 +466,7 @@ class MantraValidator {
     } else if (format === 'summary') {
       return {
         score: this.results.score,
-        status: this.results.score >= 80 ? 'PASS' : this.results.score >= 60 ? 'WARNING' : 'FAIL',
+        status: this.results.score >= PASS_THRESHOLD ? 'PASS' : this.results.score >= WARNING_THRESHOLD ? 'WARNING' : 'FAIL',
         compliant: this.results.compliant.length,
         nonCompliant: this.results.nonCompliant.length,
         criticalErrors: this.results.errors.length,
@@ -443,6 +485,14 @@ class MantraValidator {
     return this.mantras.filter(m => m.category === category);
   }
 
+  // The mantras that apply to a given scope (universal + the scope's domain,
+  // behavioral excluded). With no scope, every mantra in the current ruleset.
+  // Shared with the domain-aware path in validate() and the embodiment audit.
+  applicableMantras(scope) {
+    const scopeSet = this._normalizeScope(scope);
+    return this.mantras.filter(m => this._isApplicable(m, scopeSet));
+  }
+
   getMantrasByPriority(priority) {
     return this.mantras.filter(m => m.priority === priority);
   }

package/src/byan-v2/generation/scope-resolver.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+
+// Domain-aware scope resolution for the mantra validator.
+//
+// The validator itself stays pure (it scores against a scope set it is given).
+// This module owns the impure part : turning a persona FILE into its scope set,
+// by reading a centralized map and, where present, an explicit frontmatter
+// override. Callers (the pre-commit gate, the Stop hook, the FD VALIDATE step)
+// resolve scopes here, then pass them to validator.validate(content, { scope }).
+
+const VALID_SCOPES = ['universal', 'sdlc-process', 'sdlc-code', 'sdlc-ops', 'sdlc-modeling', 'sdlc-test', 'creative'];
+const KNOWN_MODULES = ['bmm', 'cis', 'tea', 'bmb', 'core'];
+
+function loadScopeMap(mapPath) {
+  const p = mapPath || path.join(__dirname, '../data/agent-scopes.json');
+  return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+
+// An explicit `mantra_scopes: [a, b]` in the persona (frontmatter or body) wins
+// over every derived default. Returns the listed scopes, or null when absent.
+function parseFrontmatterScopes(content) {
+  if (typeof content !== 'string') return null;
+  const m = content.match(/mantra_scopes\s*:\s*\[([^\]]*)\]/);
+  if (!m) return null;
+  const list = m[1]
+    .split(',')
+    .map(s => s.trim().replace(/^['"]|['"]$/g, ''))
+    .filter(Boolean);
+  return list.length ? list : null;
+}
+
+// A Gen3 agent loads exactly one _byan/<module>/config.yaml during activation,
+// so the module is derivable from the persona content. Returns null if none.
+function deriveModule(content) {
+  if (typeof content !== 'string') return null;
+  const m = content.match(/_byan\/(bmm|cis|tea|bmb|core)\/config\.yaml/);
+  return m ? m[1] : null;
+}
+
+// The agent slug from a persona file path (basename without extension).
+function agentNameFromPath(filePath) {
+  if (!filePath) return null;
+  return path.basename(filePath).replace(/\.md$/, '');
+}
+
+// Force-union 'universal' and keep only known scope names, order-stable.
+function normalizeScopes(scopes) {
+  const seen = new Set();
+  const out = [];
+  for (const s of ['universal', ...scopes]) {
+    if (VALID_SCOPES.includes(s) && !seen.has(s)) {
+      seen.add(s);
+      out.push(s);
+    }
+  }
+  return out;
+}
+
+// Resolve the scope set for a persona. Precedence :
+//   1. explicit frontmatter mantra_scopes
+//   2. agentScopes[name] in the map
+//   3. moduleScopes[module] derived from the content
+//   4. fallback ['universal']
+// 'universal' is always present in the result.
+function resolveAgentScopes({ name = null, content = null, map = null } = {}) {
+  const scopeMap = map || loadScopeMap();
+
+  const explicit = parseFrontmatterScopes(content);
+  if (explicit) return normalizeScopes(explicit);
+
+  if (name && scopeMap.agentScopes && scopeMap.agentScopes[name]) {
+    return normalizeScopes(scopeMap.agentScopes[name]);
+  }
+
+  const mod = deriveModule(content);
+  if (mod && scopeMap.moduleScopes && scopeMap.moduleScopes[mod]) {
+    return normalizeScopes(scopeMap.moduleScopes[mod]);
+  }
+
+  return ['universal'];
+}
+
+// Convenience for file-based callers (the gate, the hooks) : read a persona
+// file from disk and resolve its scopes in one call.
+function resolveScopesForFile(filePath, map = null) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const name = agentNameFromPath(filePath);
+  return resolveAgentScopes({ name, content, map });
+}
+
+module.exports = {
+  VALID_SCOPES,
+  KNOWN_MODULES,
+  loadScopeMap,
+  parseFrontmatterScopes,
+  deriveModule,
+  agentNameFromPath,
+  normalizeScopes,
+  resolveAgentScopes,
+  resolveScopesForFile,
+};

package/src/byan-v2/generation/templates/default-agent.md

@@ -16,7 +16,7 @@ You must fully embody this agent's persona and follow all activation instruction
   <rules>
     <r>Communicate in {communication_language}</r>
     <r>Stay in character until EXIT</r>
-    <r>Apply Merise Agile + TDD + 64 mantras</r>
+    <r>Apply Merise Agile + TDD + 71 mantras</r>
   </rules>
 </activation>
 

package/update-byan-agent/bin/update-byan-agent.js

@@ -6,16 +6,22 @@ const ora = require('ora');
 const inquirer = require('inquirer');
 const path = require('path');
 const fs = require('fs');
-const { execSync } = require('child_process');
 
 const Analyzer = require('../lib/analyzer');
 const Backup = require('../lib/backup');
 const CustomizationDetector = require('../lib/customization-detector');
+const { applyUpdate, resolvePackageRoot } = require('../lib/apply-update');
+
+// Read the version from this package, not a hand-maintained literal that drifts.
+let UPDATER_VERSION = '0.0.0';
+try {
+  UPDATER_VERSION = require('../package.json').version;
+} catch { /* keep fallback */ }
 
 program
   .name('update-byan-agent')
   .description('Gestion des mises a jour BYAN avec detection de conflits')
-  .version('2.6.1');
+  .version(UPDATER_VERSION);
 
 program
   .command('check')
@@ -58,37 +64,45 @@ program
   .description('Mettre a jour installation BYAN')
   .option('--dry-run', 'Analyser sans appliquer les changements')
   .option('--force', 'Forcer la mise a jour meme si deja a jour')
+  .option('-y, --yes', 'Mode non-interactif : confirmer automatiquement')
+  .option('--non-interactive', 'Alias de --yes (utile en CI / headless)')
   .action(async (options) => {
     const installPath = process.cwd();
-    
+
     try {
       // Step 1: Check version
       const spinner = ora('Verification version...').start();
       const analyzer = new Analyzer(installPath);
       const versionInfo = await analyzer.checkVersion();
       spinner.succeed(`Version actuelle: ${versionInfo.current}, npm: ${versionInfo.latest}`);
-      
+
       if (versionInfo.upToDate && !options.force) {
         console.log(chalk.green('\nBYAN est deja a jour!'));
         return;
       }
-      
+
       if (options.dryRun) {
         console.log(chalk.cyan('\nMode dry-run: Aucune modification appliquee'));
         return;
       }
-      
-      // Step 2: Confirm update
-      const { confirmUpdate } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'confirmUpdate',
-        message: `Mettre a jour BYAN ${versionInfo.current} -> ${versionInfo.latest}?`,
-        default: true
-      }]);
-      
-      if (!confirmUpdate) {
-        console.log(chalk.yellow('Mise a jour annulee'));
-        return;
+
+      // Step 2: Confirm update. Skip the prompt when explicitly non-interactive
+      // (--yes / --non-interactive / --force) or when stdout is not a TTY (CI,
+      // pipe, headless) — otherwise the updater hangs on the Y/n in automation.
+      const autoConfirm =
+        options.yes || options.nonInteractive || options.force ||
+        !process.stdout.isTTY || !process.stdin.isTTY;
+      if (!autoConfirm) {
+        const { confirmUpdate } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirmUpdate',
+          message: `Mettre a jour BYAN ${versionInfo.current} -> ${versionInfo.latest}?`,
+          default: true
+        }]);
+        if (!confirmUpdate) {
+          console.log(chalk.yellow('Mise a jour annulee'));
+          return;
+        }
       }
       
       // Step 3: Detect customizations
@@ -130,66 +144,47 @@ program
       }
       preserveSpinner.succeed('Personnalisations sauvegardees');
       
-      // Step 6: Download and install latest version
-      const updateSpinner = ora('Telechargement derniere version...').start();
+      // Step 6: Rebuild from the running package template (no network install).
+      // The updater is launched via `npx -p create-byan-agent@latest`, so the
+      // @latest package (and its template) is already on disk next to this bin.
+      // We resolve it locally instead of re-installing it into the user project
+      // (BUG3), validate the template BEFORE deleting anything, and swap via
+      // rename so a failure never leaves _byan missing (BUG2).
+      const updateSpinner = ora('Reconstruction depuis le template du package...').start();
+      let pkgRoot;
       try {
-        // Remove current _byan directory
-        const byanDir = path.join(installPath, '_byan');
-        if (fs.existsSync(byanDir)) {
-          fs.rmSync(byanDir, { recursive: true, force: true });
-        }
-        
-        // Run npm install to get latest create-byan-agent
-        execSync('npm install --no-save create-byan-agent@latest', {
-          cwd: installPath,
-          stdio: 'pipe'
-        });
-        
-        // Copy _byan from node_modules to project root. The published tarball
-        // ships _byan source under install/templates/_byan/, not at the root.
-        // Fall back to root-level _byan/ for legacy tarballs that may still
-        // have shipped it there.
-        const pkgRoot = path.join(installPath, 'node_modules', 'create-byan-agent');
-        const candidates = [
-          path.join(pkgRoot, 'install', 'templates', '_byan'),
-          path.join(pkgRoot, '_byan'),
-        ];
-        const nodeModulesByan = candidates.find((p) => fs.existsSync(p));
-        if (nodeModulesByan) {
-          copyRecursive(nodeModulesByan, byanDir);
-        } else {
-          throw new Error(
-            `_byan directory not found in npm package (looked in: ${candidates.map((p) => path.relative(pkgRoot, p)).join(', ')})`
-          );
-        }
+        const resolved = resolvePackageRoot({ installPath, binDir: __dirname });
+        pkgRoot = resolved.pkgRoot;
 
-        // Also refresh .github/agents/ from templates (Copilot stubs)
-        const ghAgentsSrc = path.join(pkgRoot, 'install', 'templates', '.github', 'agents');
-        const ghAgentsDst = path.join(installPath, '.github', 'agents');
-        if (fs.existsSync(ghAgentsSrc)) {
-          if (fs.existsSync(ghAgentsDst)) {
-            fs.rmSync(ghAgentsDst, { recursive: true, force: true });
-          }
-          fs.mkdirSync(path.dirname(ghAgentsDst), { recursive: true });
-          copyRecursive(ghAgentsSrc, ghAgentsDst);
-        }
+        const report = applyUpdate({ installPath, pkgRoot });
+        updateSpinner.succeed(
+          `Template applique (${report.byanEntries} entrees _byan` +
+          (report.githubAgentsEntries != null
+            ? `, ${report.githubAgentsEntries} stubs .github/agents` : '') +
+          `) depuis ${resolved.source}`
+        );
 
         // Refresh Claude Code native (.claude/hooks, .claude/skills,
-        // .claude/agents, .claude/settings.json, .mcp.json, _byan/mcp/)
+        // .claude/agents, .claude/settings.json, .mcp.json, _byan/mcp/) from the
+        // SAME local package root.
+        const nativeSpinner = ora('Refresh Claude Code native...').start();
         try {
           const setupModule = path.join(pkgRoot, 'install', 'lib', 'claude-native-setup.js');
           if (fs.existsSync(setupModule)) {
             // eslint-disable-next-line import/no-dynamic-require, global-require
             const { setupClaudeNative } = require(setupModule);
-            await setupClaudeNative(installPath, { installDeps: true, quiet: false });
+            await setupClaudeNative(installPath, { installDeps: true, quiet: true });
+            nativeSpinner.succeed('Claude Code native rafraichi');
+          } else {
+            nativeSpinner.info('Module claude-native-setup absent, refresh ignore');
           }
         } catch (e) {
-          console.warn(chalk.yellow(`  ⚠ Claude native refresh skipped: ${e.message}`));
+          nativeSpinner.warn(`Claude native refresh ignore: ${e.message}`);
         }
 
         // FS migration (F11) — dormant by default. Acts only when explicitly
         // enabled (env BYAN_FS_MIGRATE=1 or _byan/_config/migrate-fs.enabled)
-        // AND the legacy module layout is present. Backs up _byan/ first.
+        // AND the legacy module layout is present. Same local package root.
         try {
           const hookModule = path.join(pkgRoot, 'install', 'lib', 'fs-migration-hook.js');
           if (fs.existsSync(hookModule)) {
@@ -197,22 +192,22 @@ program
             const { runFsMigration } = require(hookModule);
             const r = runFsMigration({ projectRoot: installPath });
             if (r.ran) {
-              console.log(chalk.green(`  ✓ FS migration applied (backup: ${r.backup})`));
+              console.log(chalk.green(`  FS migration applied (backup: ${r.backup})`));
             }
           }
         } catch (e) {
-          console.warn(chalk.yellow(`  ⚠ FS migration skipped: ${e.message}`));
+          console.warn(chalk.yellow(`  FS migration skipped: ${e.message}`));
         }
-
-        updateSpinner.succeed('Derniere version installee');
       } catch (error) {
-        updateSpinner.fail('Erreur installation');
-        
-        // Rollback
+        updateSpinner.fail('Erreur reconstruction');
+
+        // Rollback. With the atomic-swap rebuild, _byan is only ever replaced
+        // after a validated stage, so most failures happen before destruction;
+        // the backup restore is the belt-and-suspenders net.
         const rollbackSpinner = ora('Restauration backup...').start();
         await backup.restore(backupPath);
         rollbackSpinner.succeed('Backup restaure');
-        
+
         throw error;
       }
       
@@ -253,9 +248,9 @@ program
         const { runMigration } = require('../lib/migrate-mcp-config');
         const result = await runMigration(process.cwd(), { verbose: false });
         if (result.migrated) {
-          console.log(chalk.green(`  ✓ .mcp.json migrated (${result.changes.length} change${result.changes.length > 1 ? 's' : ''})`));
+          console.log(chalk.green(`  .mcp.json migrated (${result.changes.length} change${result.changes.length > 1 ? 's' : ''})`));
         } else if (result.reason === 'no-token-available') {
-          console.log(chalk.yellow(`  ⚠ ${result.hint}`));
+          console.log(chalk.yellow(`  ${result.hint}`));
         }
         // silent on already-ok / no-mcp-json / no-byan-server
       } catch (err) {