create-byan-agent 2.4.6 → 2.6.0

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

@@ -42,3 +42,27 @@ Voir @.claude/rules/hermes-dispatcher.md pour les commandes Hermes.
 - `@hermes` → Dispatcher universel (recommandations, routage, pipelines)
 - Agent disponibles: voir @.claude/rules/byan-agents.md
 - Methodologie: voir @.claude/rules/merise-agile.md
+- Systeme de confiance epistemique: voir @.claude/rules/elo-trust.md
+- Protocol fact-check scientifique: voir @.claude/rules/fact-check.md
+
+## ELO Trust System
+
+BYAN calibre l'intensite de ses challenges selon votre score ELO par domaine.
+Score bas → explications pedagogiques et scaffolding. Score eleve → aller droit au but.
+
+Commandes CLI:
+- `node bin/byan-v2-cli.js elo summary` — voir tous les scores par domaine
+- `node bin/byan-v2-cli.js elo dashboard {domain}` — detail d'un domaine
+- `node bin/byan-v2-cli.js elo declare {domain} {level}` — declarer son expertise (junior/mid/senior/lead/expert)
+
+Dans l'agent BYAN, tapez `[ELO]` pour acceder au menu ELO.
+
+## Fact-Check Scientifique
+
+BYAN applique Zero Trust sur lui-meme : tout claim doit etre demonstrable, quantifiable, reproductible.
+4 types d'assertions : `[REASONING]` `[HYPOTHESIS]` `[CLAIM Ln]` `[FACT USER-VERIFIED]`
+5 niveaux de preuve : L1 (spec officielle, 95%) → L5 (opinion, 20%)
+Domaines stricts : security/performance/compliance → LEVEL-2 minimum sinon BLOCKED.
+
+Agent dédié: `@fact-checker` — analyse assertions, audits de documents, chaines de raisonnement.
+Dans BYAN: tapez `[FC]` pour le sous-menu fact-check.

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

@@ -13,7 +13,8 @@
 
 | Agent | Persona | Role |
 |-------|---------|------|
-| **byan** | Builder | Createur d'agents via interview (12 questions, 64 mantras) |
+| **byan** | Builder | Createur d'agents via interview (12 questions, 64 mantras) — [FC] + [ELO] intégrés |
+| **fact-checker** | Scientifique | Fact-check: assertions, audits de documents, chaines de raisonnement |
 | **agent-builder** | Constructeur | Expert en construction d'agents |
 | **marc** | Specialiste | Integration GitHub Copilot |
 | **rachid** | Specialiste | Deploiement NPM/NPX |
@@ -63,6 +64,7 @@
 | `code-review` | Revoir du code |
 | `quick-spec` | Spec rapide conversationnelle |
 | `quick-dev` | Dev rapide (brownfield) |
+| `elo-workflow` | Consulter et gerer le score ELO (via menu [ELO] du BYAN) |
 
 ## Comment Invoquer un Agent
 

package/install/templates/.claude/rules/elo-trust.md

@@ -0,0 +1,78 @@
+# ELO Trust System — Epistemic Trust Protocol
+
+## Principe
+
+BYAN mesure la fiabilite des assertions de l'utilisateur par domaine technique
+en utilisant un algorithme Glicko-2 simplifie (echelle 0-1000).
+Plus le score est eleve, moins le challenge est intense et plus la reponse est concise.
+
+## Domaines suportees
+
+| Domaine | K-factor |
+|---------|----------|
+| security | ×1.5 |
+| compliance | ×1.5 |
+| performance | ×1.2 |
+| javascript, typescript, nodejs, python, rust, go | ×1.0 |
+| algorithms | ×0.8 |
+
+## Paliers ELO
+
+| Plage | Label | Comportement BYAN |
+|-------|-------|-------------------|
+| 0-200 | Apprenti | Explications completes, analogies, scaffold maximal |
+| 201-450 | Debutant | Guide pas-a-pas, verification frequente |
+| 450-550 | Zone morte | Challenge intense (Dunning-Kruger peak) |
+| 551-750 | Intermediaire | Challenge modere, hypotheses testees |
+| 751-900 | Avance | Challenge minimal, discussion paire-a-paire |
+| 901-1000 | Expert | Reponses courtes, pas d'explications basiques |
+
+## Routage LLM (experimental)
+
+| ELO max | Modele |
+|---------|--------|
+| 0-200 | claude-opus (raisonnement profond) |
+| 201-600 | claude-sonnet (equilibre) |
+| 601+ | claude-haiku (concis, expert autonome) |
+
+## Protocole de challenge
+
+Quand l'agent BYAN evalue un claim sur un domaine:
+1. Recupere le score ELO du domaine via `node bin/byan-v2-cli.js elo context {domain}`
+2. Applique le `promptInstructions` retourne (ton, profondeur, scaffold)
+3. Ton invariant: TOUJOURS curieux, JAMAIS accusatoire ("qu'est-ce qui t'a amene a ca?" vs "c'est faux")
+4. Apres echange: enregistre le resultat `VALIDATED | BLOCKED | PARTIAL` via CLI
+5. Ce protocole est silencieux — l'utilisateur voit seulement le challenge, pas les mecaniques ELO
+
+## Mecaniques speciales (V2)
+
+- **Tilt detector**: 3 BLOCKED consecutifs → BYAN propose une pause pedagogique
+- **First blood**: premier claim dans un domaine vierge = toujours challenge (Zero Trust)
+- **Zone morte 450-550**: incertitude maximale, challenge le plus nuance
+- **ELO farming protection**: claims trop faciles → K-factor reduit automatiquement
+- **Hot hand**: 3 corrects consecutifs → petit boost de K (puis regression vers la moyenne)
+- **Shadow challenger**: expert (750+) peut activer un alter-ego adversarial opt-in
+
+## Commandes CLI
+
+```bash
+node bin/byan-v2-cli.js elo summary              # tous les domaines
+node bin/byan-v2-cli.js elo dashboard {domain}   # detail d'un domaine
+node bin/byan-v2-cli.js elo context {domain}     # contexte pour un challenge
+node bin/byan-v2-cli.js elo record {domain} {VALIDATED|BLOCKED|PARTIAL}
+node bin/byan-v2-cli.js elo declare {domain} {junior|mid|senior|lead|expert}
+```
+
+## Menu BYAN
+
+Dans l'agent BYAN, tapez `[ELO]` pour acceder au sous-menu ELO:
+- Dashboard par domaine
+- Enregistrer un claim
+- Declarer son expertise
+- Voir le routage LLM recommande
+
+## Philosophie
+
+Le score ELO n'est pas une punition — c'est un outil de calibration.
+Un score bas signifie "BYAN va t'expliquer plus, pas moins".
+La pedagogie s'adapte au niveau, le ton reste constant: bienveillant et curieux.

package/install/templates/.claude/rules/fact-check.md

@@ -0,0 +1,109 @@
+# Fact-Check Protocol — Demonstrable, Quantifiable, Reproducible
+
+## Principe fondateur
+
+Tout claim emis par un agent BYAN doit satisfaire les trois criteres :
+
+| Critere | Definition | Exemple |
+|---------|-----------|---------|
+| **Demonstrable** | Source primaire verifiable | RFC 7234, redis.io/benchmarks |
+| **Quantifiable** | Precis, pas vague | "Redis > 100k ops/sec" pas "Redis est rapide" |
+| **Reproductible** | L'utilisateur peut le tester | `redis-benchmark -n 100000` |
+
+Un claim sans ces trois criteres = opinion ou hypothese, presente comme tel.
+
+## Les 4 types d'assertions
+
+Tout output d'agent BYAN est prefixe par son type :
+
+```
+[REASONING]              Deduction logique — pas de garantie de verite
+[HYPOTHESIS]             Plausible dans ce contexte — a verifier avant action
+[CLAIM L{n}]             Assertion sourced — niveau n (1-5)
+[FACT USER-VERIFIED date] Valide par l'utilisateur avec artefact
+```
+
+## Les 5 niveaux de preuve
+
+| Niveau | Score | Sources |
+|--------|-------|---------|
+| LEVEL-1 | 95% | RFC, W3C, ECMAScript, POSIX, spec officielle |
+| LEVEL-2 | 80% | Benchmark executable, CVE reference, docs produit officielles |
+| LEVEL-3 | 65% | Article peer-reviewed, livre technique reconnu |
+| LEVEL-4 | 50% | Consensus communaute (StackOverflow > 1000 votes) |
+| LEVEL-5 | 20% | Opinion / experience personnelle |
+
+## Domaines stricts
+
+| Domaine | Niveau minimum | Sous le seuil |
+|---------|---------------|---------------|
+| security | LEVEL-2 | BLOCKED — CVE ou benchmark requis |
+| performance | LEVEL-2 | BLOCKED — profiler output ou benchmark requis |
+| compliance | LEVEL-1 | BLOCKED — texte reglementaire requis |
+
+## Bloc FACT-CHECK standard
+
+```
+┌─ FACT-CHECK ──────────────────────────────────────────────────┐
+│ Claim     : [assertion mot pour mot]                          │
+│ Domain    : [security | performance | javascript | general]   │
+│ Verdict   : [BLOCKED | CLAIM L1 | CLAIM L2 | CLAIM L3        │
+│              | HYPOTHESIS | REASONING | UNVERIFIED]           │
+│ Source    : [nom exact depuis _byan/knowledge/sources.md      │
+│              ou "aucune — preuve requise: [type exact]"]      │
+│ Confiance : [score % selon niveau]                            │
+│ Challenge : [question manquante — source? reproductible?]     │
+└───────────────────────────────────────────────────────────────┘
+```
+
+## Trust Score (audit de document)
+
+```
+Trust Score = (assertions CLAIM + FACT) / total × 100
+Badge : A ≥ 90% | B ≥ 75% | C ≥ 60% | D ≥ 40% | F < 40%
+```
+
+## Regles invariantes
+
+- NEVER generate a URL — cite only sources in `_byan/knowledge/sources.md` or user-provided
+- ZERO TRUST ON SELF — training data = starting point, not the source
+- TONE INVARIANT — always curious, never accusatory
+- CHAIN WARNING — chain > 3 steps → compute multiplicative confidence; if < 60%, warn
+
+## Commandes CLI
+
+```bash
+node bin/byan-v2-cli.js fc check "Redis is always faster than PostgreSQL"
+node bin/byan-v2-cli.js fc parse "This is obviously the best approach"
+node bin/byan-v2-cli.js fc verify "claim text" "proof artifact"
+node bin/byan-v2-cli.js fc graph
+node bin/byan-v2-cli.js fc sheet [session-id]
+```
+
+## Agent dedié
+
+```
+@fact-checker   # Agent Copilot CLI dédié
+[FC]            # Sous-menu dans l'agent @byan
+```
+
+## Worker npm
+
+```javascript
+const FactCheckWorker = require('./_byan/workers/fact-check-worker');
+const fc = new FactCheckWorker({ verbose: true });
+
+const result = fc.check("Redis is always faster than PostgreSQL");
+// → { assertionType: 'HYPOTHESIS', level: 5, score: 20, status: 'OPINION' }
+
+const claims = fc.parse("This is obviously the best approach for security");
+// → [{ matched: 'obviously', ... }]
+```
+
+## Auto-detection patterns
+
+Declencheurs automatiques (patterns BYAN) :
+- Mots absolus : `toujours, jamais, forcement, always, never, obviously`
+- Superlatifs : `plus rapide, mieux, optimal, faster, better, superior`
+- Best-practices non sourcees : `bonne pratique, best practice, industry standard`
+- Affirmations certaines : `il est clair que, prouve que, it is well known that`

package/install/templates/workers/fact-check-worker.js

@@ -0,0 +1,102 @@
+/**
+ * Fact-Check Worker
+ *
+ * Wraps the BYAN FactChecker for easy integration as a reusable worker.
+ * Provides claim verification, auto-detection of implicit claims, and
+ * fact sheet generation — all following the "demonstrable, quantifiable,
+ * reproducible" principle.
+ *
+ * Install path: _byan/workers/fact-check-worker.js
+ * Source:       src/byan-v2/fact-check/index.js
+ *
+ * @module workers/fact-check-worker
+ */
+
+const path = require('path');
+
+class FactCheckWorker {
+  constructor(config = {}) {
+    const FactChecker = require(path.join(__dirname, '../../../src/byan-v2/fact-check/index'));
+    this.checker = new FactChecker({
+      enabled:       config.enabled !== false,
+      mode:          config.mode || 'offline',
+      min_level:     config.min_level ?? 3,
+      strict_domains: config.strict_domains || ['security', 'performance', 'compliance'],
+      output_fact_sheet: config.output_fact_sheet !== false,
+      fact_sheet_path:   config.fact_sheet_path || '_byan-output/fact-sheets',
+      graph_path:        config.graph_path || '_byan/_memory/fact-graph.json'
+    });
+    this.verbose = config.verbose || false;
+  }
+
+  /**
+   * Check a single claim.
+   * Returns { assertionType, level, score, status, message }
+   *
+   * @param {string} claim - The assertion to evaluate
+   * @param {object} opts  - { domain, level, source, proof }
+   * @returns {object}
+   */
+  check(claim, opts = {}) {
+    if (this.verbose) console.log(`[FC] Checking claim: "${claim}"`);
+    const result = this.checker.check(claim, opts);
+    if (this.verbose) console.log(`[FC] → ${result.assertionType} L${result.level} (${result.score}%)`);
+    return result;
+  }
+
+  /**
+   * Scan text and auto-detect implicit claims using danger patterns.
+   * Returns array of { pattern, matched, position, excerpt }
+   *
+   * @param {string} text
+   * @returns {Array}
+   */
+  parse(text) {
+    const found = this.checker.parse(text);
+    if (this.verbose) console.log(`[FC] Detected ${found.length} implicit claim(s)`);
+    return found;
+  }
+
+  /**
+   * Mark a claim as user-verified with a proof artifact.
+   * Persists to the knowledge graph for future sessions.
+   *
+   * @param {string} claim - The assertion
+   * @param {string} proof - Proof artifact (command output, URL, benchmark result)
+   * @returns {{ id, status, claim }}
+   */
+  verify(claim, proof) {
+    const result = this.checker.verify(claim, proof);
+    if (this.verbose) console.log(`[FC] Verified: ${result.id}`);
+    return result;
+  }
+
+  /**
+   * Generate a Markdown fact sheet for a session.
+   * Auto-buckets facts from the knowledge graph.
+   *
+   * @param {string} sessionId
+   * @returns {{ content, path }}
+   */
+  sheet(sessionId = new Date().toISOString().slice(0, 10)) {
+    const graph = this.checker.graph.load();
+    const facts = graph.facts.reduce((acc, f) => {
+      const bucket = f.status === 'VERIFIED' ? 'verified' :
+                     f.status === 'DISPUTED' ? 'disputed' :
+                     f.status === 'OPINION'  ? 'opinions' : 'claims';
+      (acc[bucket] = acc[bucket] || []).push(f);
+      return acc;
+    }, {});
+    return this.checker.generateFactSheet(sessionId, facts, true);
+  }
+
+  /**
+   * Get all persisted facts from the knowledge graph.
+   * @returns {Array}
+   */
+  getGraph() {
+    return this.checker.graph.load().facts;
+  }
+}
+
+module.exports = FactCheckWorker;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-byan-agent",
-  "version": "2.4.6",
-  "description": "BYAN v2.3.2 - Intelligent AI agent ecosystem with Hermes universal dispatcher + Multi-platform support (Copilot CLI, Claude, Codex) + Automatic LLM cost optimization (87.5% savings) + Node 12+ compatible",
+  "version": "2.6.0",
+  "description": "BYAN v2.6.0 - Intelligent AI agent creator with ELO trust system + scientific fact-check + Hermes universal dispatcher. Multi-platform (Copilot CLI, Claude Code, Codex). Merise Agile + TDD + 64 Mantras. ~54% LLM cost savings.",
   "main": "src/index.js",
   "bin": {
     "create-byan-agent": "./install/bin/create-byan-agent-v2.js",

package/src/byan-v2/context/session-state.js

@@ -9,6 +9,7 @@ class SessionState {
     this.analysisResults = {};
     this.agentProfileDraft = {};
     this.context = {};
+    this.facts = { verified: [], claims: [], disputed: [], opinions: [] };
   }
 
   addQuestion(question) {
@@ -26,6 +27,19 @@ class SessionState {
     });
   }
 
+  addFact(fact) {
+    if (!this.facts.claims) this.facts = { verified: [], claims: [], disputed: [], opinions: [] };
+    const target = fact.status === 'VERIFIED' ? 'verified'
+      : fact.status === 'DISPUTED' ? 'disputed'
+      : fact.status === 'OPINION' || fact.status === 'HYPOTHESIS' ? 'opinions'
+      : 'claims';
+    this.facts[target].push({ ...fact, session: this.sessionId, created_at: Date.now() });
+  }
+
+  getFacts() {
+    return JSON.parse(JSON.stringify(this.facts));
+  }
+
   setAnalysisResults(data) {
     this.analysisResults = data;
   }
@@ -78,7 +92,8 @@ class SessionState {
       userResponses: this.userResponses,
       analysisResults: this.analysisResults,
       agentProfileDraft: this.agentProfileDraft,
-      context: this.context
+      context: this.context,
+      facts: this.facts
     };
   }
 
@@ -91,6 +106,7 @@ class SessionState {
     state.analysisResults = data.analysisResults || {};
     state.agentProfileDraft = data.agentProfileDraft || {};
     state.context = data.context || {};
+    state.facts = data.facts || { verified: [], claims: [], disputed: [], opinions: [] };
     return state;
   }
 }

package/src/byan-v2/dispatcher/five-whys-analyzer.js

@@ -13,9 +13,10 @@
 const Logger = require('../observability/logger');
 
 class FiveWhysAnalyzer {
-  constructor(sessionState, logger) {
+  constructor(sessionState, logger, factChecker = null) {
     this.sessionState = sessionState;
     this.logger = logger || new Logger({ logDir: 'logs', logFile: 'five-whys.log' });
+    this.factChecker = factChecker;
     
     this.depth = 0;
     this.maxDepth = 5;
@@ -123,9 +124,17 @@ class FiveWhysAnalyzer {
       depth: this.depth,
       question: `Why #${this.depth}`,
       answer: answer.trim(),
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
+      assertionType: 'HYPOTHESIS'
     });
 
+    if (this.factChecker) {
+      const claims = this.factChecker.parse(answer);
+      if (claims.length > 0) {
+        this.logger.info('Fact-check triggered on WHY answer', { depth: this.depth, patterns: claims.map(c => c.matched) });
+      }
+    }
+
     const rootCauseAnalysis = this._analyzeForRootCause(answer);
     
     if (rootCauseAnalysis.isRootCause && this.depth >= 3) {

package/src/byan-v2/elo/challenge-evaluator.js

@@ -0,0 +1,121 @@
+/**
+ * challenge-evaluator.js — Decides HOW to challenge a claim based on ELO context
+ *
+ * Does NOT decide if a claim is true or false (that's the LLM's job).
+ * Returns challenge configuration: scaffold level, style, flags, LLM instructions.
+ */
+
+const config = require('./domain-config');
+
+class ChallengeEvaluator {
+  /**
+   * Build the challenge context for a given domain/rating.
+   * Called BEFORE the LLM evaluates the claim.
+   *
+   * @param {string} domain
+   * @param {object} domainProfile - from EloStore.getDomain()
+   * @returns {ChallengeContext}
+   */
+  evaluateContext(domain, domainProfile) {
+    const rating  = domainProfile.rating ?? config.INITIAL_RATING;
+    const scaffold = config.getScaffoldLevel(rating);
+    const style    = config.getChallengeStyle(rating);
+    const inDeadZone    = config.isInDeadZone(rating);
+    const firstBlood    = !domainProfile.first_claim_made;
+    const tiltDetected  = (domainProfile.blocked_streak ?? 0) >= config.TILT_THRESHOLD;
+    const shouldSoftChallenge = rating < 500 || inDeadZone;
+
+    return {
+      domain,
+      rating,
+      rd:               domainProfile.rd ?? config.INITIAL_RD,
+      scaffoldLevel:    scaffold.level,
+      scaffoldIncludes: scaffold.includes,
+      challengeStyle:   style,
+      shouldSoftChallenge,
+      firstBlood,
+      inDeadZone,
+      tiltDetected,
+      promptInstructions: this._buildPromptInstructions({
+        scaffoldLevel: scaffold.level,
+        scaffoldIncludes: scaffold.includes,
+        style,
+        shouldSoftChallenge,
+        firstBlood,
+        inDeadZone,
+        tiltDetected,
+        domain,
+        rating
+      })
+    };
+  }
+
+  /**
+   * Map a raw LLM evaluation outcome to a canonical result.
+   * @param {'validated'|'blocked'|'partial'|'soft'} outcome
+   * @returns {'VALIDATED'|'BLOCKED'|'PARTIALLY_VALID'|'SOFT_CHALLENGED'}
+   */
+  normalizeResult(outcome) {
+    const map = {
+      validated: 'VALIDATED',
+      blocked:   'BLOCKED',
+      partial:   'PARTIALLY_VALID',
+      soft:      'SOFT_CHALLENGED'
+    };
+    return map[outcome?.toLowerCase()] ?? 'SOFT_CHALLENGED';
+  }
+
+  /**
+   * Convert a canonical result to a numeric Glicko score.
+   * @param {'VALIDATED'|'BLOCKED'|'PARTIALLY_VALID'|'SOFT_CHALLENGED'} result
+   * @returns {number} 0 | 0.5 | 1
+   */
+  resultToScore(result) {
+    switch (result) {
+      case 'VALIDATED':       return 1;
+      case 'PARTIALLY_VALID': return 0.5;
+      case 'BLOCKED':         return 0;
+      default:                return 0.5;  // neutral for soft challenges
+    }
+  }
+
+  // --- Private ---
+
+  _buildPromptInstructions({ scaffoldLevel, scaffoldIncludes, style, shouldSoftChallenge,
+                              firstBlood, inDeadZone, tiltDetected, domain, rating }) {
+    const lines = [];
+
+    if (tiltDetected) {
+      lines.push(`TILT_DETECTED: User has ${3}+ consecutive BLOCKED in ${domain}. Use maximum empathy. Suggest a pause before continuing.`);
+    }
+
+    if (firstBlood) {
+      lines.push(`FIRST_BLOOD: This is the user's first claim in ${domain}. Always challenge regardless of global ELO. Zero Trust per domain.`);
+    }
+
+    if (shouldSoftChallenge) {
+      lines.push(`SOFT_CHALLENGE: Do not BLOCK immediately. Ask "what led you to this conclusion?" first. Only BLOCK if the explanation reveals a real gap.`);
+    }
+
+    if (inDeadZone) {
+      lines.push(`DEAD_ZONE: User is at ${rating} (450–550 Dunning-Kruger peak). Maximum nuance required. Challenge precisely.`);
+    }
+
+    lines.push(`CHALLENGE_STYLE: ${style.toUpperCase()}`);
+    lines.push(`SCAFFOLD_LEVEL: ${scaffoldLevel} — include: [${scaffoldIncludes.join(', ')}]`);
+
+    if (style === 'guide') {
+      lines.push('TONE: Encourage and simplify. User is significantly below benchmark.');
+    } else if (style === 'learner') {
+      lines.push('TONE: Adopt learner mode. User may exceed your benchmark — ask questions.');
+    } else if (style === 'peer') {
+      lines.push('TONE: Peer-to-peer. Be technically precise and nuanced.');
+    }
+
+    lines.push('INVARIANT: Tone is always curious, never accusatory. No "That\'s wrong." Use "What led you to think...?" or "You\'re on the right track — the nuance is..."');
+
+    return lines.join('\n');
+  }
+}
+
+module.exports = ChallengeEvaluator;

package/src/byan-v2/elo/domain-config.js

@@ -0,0 +1,129 @@
+/**
+ * domain-config.js — Static configuration for the ELO Trust System
+ *
+ * All thresholds, multipliers and routing rules live here.
+ * Pure data — no side effects.
+ */
+
+// K-factor multipliers per domain.
+// Base K = 32. Final K = BASE_K × multiplier.
+const BASE_K = 32;
+
+const K_FACTOR_MULTIPLIERS = {
+  security:    1.5,  // high stakes — errors are costly
+  compliance:  1.5,
+  performance: 1.2,
+  general:     1.0,  // neutral reference
+  javascript:  1.0,
+  typescript:  1.0,
+  nodejs:      1.0,
+  algorithms:  0.8,  // fundamentals are stable — mistakes are normal
+  cryptography:1.2,
+  devops:      1.0,
+  react:       1.0
+};
+
+// Dunning-Kruger dead zone: maximum challenge intensity here
+const DEAD_ZONE = { min: 450, max: 550 };
+
+// LLM routing thresholds (max rating across active domains)
+const LLM_ROUTING = [
+  { maxRating: 200, model: 'claude-opus-4.5',   label: 'Apprenti'  },
+  { maxRating: 600, model: 'claude-sonnet-4.5', label: 'Praticien' },
+  { maxRating: Infinity, model: 'claude-haiku-4.5', label: 'Expert' }
+];
+
+// Scaffold levels: how much help is provided with a challenge
+const SCAFFOLD_LEVELS = [
+  { maxRating: 200, level: 3, label: 'full',    includes: ['challenge', 'hint', 'analogy', 'concept_link'] },
+  { maxRating: 500, level: 2, label: 'guided',  includes: ['challenge', 'hint'] },
+  { maxRating: 700, level: 1, label: 'standard',includes: ['challenge'] },
+  { maxRating: Infinity, level: 0, label: 'adversarial', includes: ['challenge'] }
+];
+
+// Challenge style based on ELO gap (user rating - domain baseline 500)
+const CHALLENGE_STYLES = [
+  { minGap: -Infinity, maxGap: -400, style: 'guide'    }, // beginner vs expert
+  { minGap: -400,      maxGap: -100, style: 'standard' },
+  { minGap: -100,      maxGap: 100,  style: 'peer'     },
+  { minGap: 100,       maxGap: Infinity, style: 'learner' } // user exceeds BYAN benchmark
+];
+
+// The 6 root causes of a BLOCKED claim
+const BLOCKED_REASONS = {
+  TERMINOLOGY_GAP:     'terminology_gap',
+  PREREQUISITE_GAP:    'prerequisite_gap',
+  CONTEXT_MISMATCH:    'context_mismatch',
+  OUTDATED_KNOWLEDGE:  'outdated_knowledge',
+  LAZY_CLAIM:          'lazy_claim',
+  OVERCONFIDENCE:      'overconfidence'
+};
+
+// Adapted label for BLOCKED result based on user rating
+const BLOCKED_LABELS = [
+  { maxRating: 300, label: "Moment d'apprentissage" },
+  { maxRating: 600, label: 'Point de precision'      },
+  { maxRating: Infinity, label: 'Claim non valide'   }
+];
+
+// Tilt threshold: consecutive BLOCKs in same domain triggering soft intervention
+const TILT_THRESHOLD = 3;
+
+// Intervention mode threshold: total rating at 0 across N sessions
+const INTERVENTION_RATING = 0;
+
+// Initial rating for a new domain
+const INITIAL_RATING = 0;
+const INITIAL_RD     = 200;  // high uncertainty at start
+
+// Provisional ELO when user self-declares expertise level
+const DECLARED_EXPERTISE_RATINGS = {
+  beginner:     100,
+  intermediate: 400,
+  advanced:     650,
+  expert:       800,
+  principal:    900
+};
+
+function getKFactor(domain) {
+  const multiplier = K_FACTOR_MULTIPLIERS[domain] ?? K_FACTOR_MULTIPLIERS.general;
+  return Math.round(BASE_K * multiplier);
+}
+
+function getScaffoldLevel(rating) {
+  return SCAFFOLD_LEVELS.find(s => rating <= s.maxRating) ?? SCAFFOLD_LEVELS[SCAFFOLD_LEVELS.length - 1];
+}
+
+function getChallengeStyle(rating, byanBaseline = 500) {
+  const gap = rating - byanBaseline;
+  return CHALLENGE_STYLES.find(s => gap >= s.minGap && gap < s.maxGap)?.style ?? 'standard';
+}
+
+function getBlockedLabel(rating) {
+  return BLOCKED_LABELS.find(b => rating <= b.maxRating)?.label ?? 'Claim non valide';
+}
+
+function isInDeadZone(rating) {
+  return rating >= DEAD_ZONE.min && rating <= DEAD_ZONE.max;
+}
+
+module.exports = {
+  BASE_K,
+  K_FACTOR_MULTIPLIERS,
+  DEAD_ZONE,
+  LLM_ROUTING,
+  SCAFFOLD_LEVELS,
+  CHALLENGE_STYLES,
+  BLOCKED_REASONS,
+  BLOCKED_LABELS,
+  TILT_THRESHOLD,
+  INTERVENTION_RATING,
+  INITIAL_RATING,
+  INITIAL_RD,
+  DECLARED_EXPERTISE_RATINGS,
+  getKFactor,
+  getScaffoldLevel,
+  getChallengeStyle,
+  getBlockedLabel,
+  isInDeadZone
+};