create-byan-agent 2.6.2 → 2.7.0

package/src/byan-v2/elo/elo-store.js

@@ -1,159 +0,0 @@
-/**
- * elo-store.js — Persistent ELO profile per user/project
- *
- * Storage: _byan/_memory/elo-profile.json
- * Structure: { version, updated_at, domains: { [name]: DomainProfile } }
- *
- * DomainProfile: {
- *   rating, rd, history[], blocked_streak,
- *   consecutive_correct, first_claim_made, session_count
- * }
- */
-
-const fs   = require('fs');
-const path = require('path');
-const { INITIAL_RATING, INITIAL_RD } = require('./domain-config');
-
-const DEFAULT_PATH = '_byan/_memory/elo-profile.json';
-
-class EloStore {
-  constructor(storagePath = DEFAULT_PATH) {
-    this.storagePath = storagePath;
-    this._data = null;
-  }
-
-  load() {
-    if (this._data) return this._data;
-    try {
-      const raw = fs.readFileSync(path.resolve(this.storagePath), 'utf8');
-      this._data = JSON.parse(raw);
-    } catch {
-      this._data = { version: 1, updated_at: null, domains: {} };
-    }
-    return this._data;
-  }
-
-  save() {
-    const data = this.load();
-    data.updated_at = new Date().toISOString();
-    const dir = path.dirname(path.resolve(this.storagePath));
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.resolve(this.storagePath), JSON.stringify(data, null, 2), 'utf8');
-  }
-
-  /**
-   * Get a domain profile, creating it with defaults if absent.
-   * @param {string} domain
-   * @returns {object} DomainProfile
-   */
-  getDomain(domain) {
-    const data = this.load();
-    if (!data.domains[domain]) {
-      data.domains[domain] = {
-        rating:             INITIAL_RATING,
-        rd:                 INITIAL_RD,
-        history:            [],
-        blocked_streak:     0,
-        consecutive_correct:0,
-        first_claim_made:   false,
-        session_count:      0,
-        last_active:        null,
-        provisional_rating: null  // set when user declares expertise
-      };
-    }
-    return data.domains[domain];
-  }
-
-  /**
-   * Record the result of a claim evaluation and update the domain profile.
-   * @param {string} domain
-   * @param {'VALIDATED'|'BLOCKED'|'PARTIALLY_VALID'} result
-   * @param {object} opts - { delta, newRating, newRd, blockedReason, claimExcerpt }
-   */
-  recordResult(domain, result, opts = {}) {
-    const data   = this.load();
-    const profile = this.getDomain(domain);
-
-    const { delta = 0, newRating, newRd, blockedReason = null, claimExcerpt = '' } = opts;
-
-    // Update rating
-    if (newRating !== undefined) profile.rating = newRating;
-    if (newRd     !== undefined) profile.rd      = newRd;
-
-    // Streak tracking
-    if (result === 'BLOCKED') {
-      profile.blocked_streak      = (profile.blocked_streak || 0) + 1;
-      profile.consecutive_correct = 0;
-    } else {
-      profile.blocked_streak      = 0;
-      profile.consecutive_correct = (profile.consecutive_correct || 0) + 1;
-    }
-
-    // First claim flag
-    if (!profile.first_claim_made) profile.first_claim_made = true;
-
-    profile.last_active = new Date().toISOString().slice(0, 10);
-
-    // History entry (keep last 50)
-    profile.history.push({
-      date:          profile.last_active,
-      result,
-      delta,
-      blocked_reason: blockedReason,
-      excerpt:        claimExcerpt.slice(0, 80)
-    });
-    if (profile.history.length > 50) profile.history.shift();
-
-    data.domains[domain] = profile;
-    this._data = data;
-  }
-
-  /**
-   * Set a provisional rating from user self-declaration.
-   * @param {string} domain
-   * @param {number} provisionalRating
-   */
-  setProvisional(domain, provisionalRating) {
-    const profile = this.getDomain(domain);
-    profile.provisional_rating = provisionalRating;
-    profile.rd = INITIAL_RD;  // keep uncertainty high until confirmed
-    this._data.domains[domain] = profile;
-  }
-
-  /**
-   * Increment session count for all active domains.
-   */
-  incrementSession() {
-    const data = this.load();
-    for (const domain of Object.keys(data.domains)) {
-      data.domains[domain].session_count = (data.domains[domain].session_count || 0) + 1;
-    }
-  }
-
-  /**
-   * Return all domains with their current ratings, sorted by last activity.
-   * @returns {Array<{ domain, rating, rd, trend, last_active }>}
-   */
-  getSummary() {
-    const data = this.load();
-    return Object.entries(data.domains).map(([domain, p]) => {
-      const recent = p.history.slice(-5);
-      const totalDelta = recent.reduce((s, h) => s + (h.delta || 0), 0);
-      return {
-        domain,
-        rating:       p.rating,
-        rd:           p.rd,
-        trend:        totalDelta > 5 ? 'up' : totalDelta < -5 ? 'down' : 'stable',
-        trend_delta:  totalDelta,
-        last_active:  p.last_active,
-        session_count: p.session_count
-      };
-    }).sort((a, b) => {
-      if (!a.last_active) return 1;
-      if (!b.last_active) return -1;
-      return b.last_active.localeCompare(a.last_active);
-    });
-  }
-}
-
-module.exports = EloStore;

package/src/byan-v2/elo/glicko2.js

@@ -1,105 +0,0 @@
-/**
- * glicko2.js — Simplified Glicko-2 inspired rating algorithm
- *
- * Scale: 0–1000 (vs canonical 1500 ± 400)
- * Captures: rating, RD (uncertainty), single-result update
- *
- * Pure functions — no side effects, no I/O.
- */
-
-const { INITIAL_RATING, INITIAL_RD } = require('./domain-config');
-
-// Glicko-2 uses a scaled mu/phi internally
-const SCALE = 173.7178;
-const TAU   = 0.5;  // system volatility constant (controls how fast rating changes)
-
-function toGlicko(rating, rd) {
-  return {
-    mu:  (rating - 500) / SCALE,  // centered on 500 instead of 1500
-    phi: rd / SCALE
-  };
-}
-
-function fromGlicko(mu, phi) {
-  return {
-    rating: Math.max(0, Math.min(1000, Math.round(mu * SCALE + 500))),
-    rd:     Math.max(10, Math.round(phi * SCALE))
-  };
-}
-
-function g(phi) {
-  return 1 / Math.sqrt(1 + (3 * phi * phi) / (Math.PI * Math.PI));
-}
-
-function E(mu, muJ, phiJ) {
-  return 1 / (1 + Math.exp(-g(phiJ) * (mu - muJ)));
-}
-
-/**
- * Update a player's rating after a single result against a virtual opponent.
- *
- * For BYAN's use: the "opponent" is the domain benchmark (rating 500, RD 100).
- * result: 1 = VALIDATED, 0 = BLOCKED, 0.5 = PARTIALLY_VALID
- *
- * @param {number} rating     - current rating (0-1000)
- * @param {number} rd         - current rating deviation
- * @param {number} result     - 0 | 0.5 | 1
- * @param {number} kFactor    - domain-adjusted K factor
- * @returns {{ newRating, newRd, delta, probability }}
- */
-function update(rating = INITIAL_RATING, rd = INITIAL_RD, result, kFactor = 32) {
-  if (result < 0 || result > 1) throw new Error('result must be 0, 0.5, or 1');
-
-  const { mu, phi } = toGlicko(rating, rd);
-
-  // Virtual opponent = domain baseline (500 = mu 0, RD 100)
-  const muJ  = 0;
-  const phiJ = 100 / SCALE;
-
-  const gPhi = g(phiJ);
-  const expected = E(mu, muJ, phiJ);
-
-  // Glicko-2 variance
-  const v = 1 / (gPhi * gPhi * expected * (1 - expected));
-
-  // Delta
-  const delta = v * gPhi * (result - expected);
-
-  // K-factor scales the update magnitude (we deviate from pure Glicko-2 here
-  // to keep the system responsive per domain)
-  const kScale = kFactor / BASE_K;
-
-  // New phi (RD decreases as more games are played)
-  const phiStar = Math.sqrt(phi * phi + TAU * TAU);
-  const phiNew  = 1 / Math.sqrt(1 / (phiStar * phiStar) + 1 / v);
-
-  // New mu
-  const muNew = mu + phiNew * phiNew * gPhi * (result - expected) * kScale;
-
-  const current = fromGlicko(mu, phi);
-  const next    = fromGlicko(muNew, phiNew);
-
-  return {
-    newRating:   next.rating,
-    newRd:       next.rd,
-    delta:       next.rating - current.rating,
-    probability: Math.round(expected * 100)  // expected win % before the game
-  };
-}
-
-/**
- * Increase RD when a domain has been idle (uncertainty grows over time).
- * @param {number} rd        - current RD
- * @param {number} daysSince - days since last activity
- * @returns {number} new RD (capped at INITIAL_RD)
- */
-function decayRd(rd, daysSince) {
-  if (daysSince <= 0) return rd;
-  const phiNew = Math.sqrt((rd / SCALE) ** 2 + (TAU ** 2) * daysSince / 365) * SCALE;
-  return Math.min(INITIAL_RD, Math.round(phiNew));
-}
-
-// Expose BASE_K constant for kFactor comparison
-const BASE_K = 32;
-
-module.exports = { update, decayRd };

package/src/byan-v2/elo/index.js

@@ -1,163 +0,0 @@
-/**
- * EloEngine — Main entry point for the BYAN ELO Trust System
- *
- * Orchestrates: Glicko-2 scoring, domain config, persistent store,
- * challenge evaluation, pedagogy layer, and LLM routing.
- *
- * Usage:
- *   const engine = new EloEngine();
- *   const ctx    = engine.evaluateContext('security');        // before LLM challenge
- *   const result = engine.recordResult('security', 'BLOCKED', { blockedReason: 'terminology_gap', claimExcerpt: '...' });
- *   const dash   = engine.getDashboard('security');
- *   const model  = engine.routeLLM();
- */
-
-const { update: glickoUpdate, decayRd } = require('./glicko2');
-const { getKFactor, TILT_THRESHOLD, INTERVENTION_RATING, DECLARED_EXPERTISE_RATINGS } = require('./domain-config');
-const EloStore          = require('./elo-store');
-const ChallengeEvaluator = require('./challenge-evaluator');
-const PedagogyLayer      = require('./pedagogy-layer');
-const LlmRouter          = require('./llm-router');
-
-class EloEngine {
-  constructor(options = {}) {
-    this.store     = options.store     ?? new EloStore(options.storagePath);
-    this.evaluator = new ChallengeEvaluator();
-    this.pedagogy  = new PedagogyLayer();
-    this.router    = new LlmRouter();
-  }
-
-  /**
-   * Get the challenge configuration for the LLM before it evaluates a claim.
-   * Call this before presenting a claim to the BYAN agent.
-   *
-   * @param {string} domain
-   * @returns {ChallengeContext}
-   */
-  evaluateContext(domain) {
-    const profile = this.store.getDomain(domain);
-    return this.evaluator.evaluateContext(domain, profile);
-  }
-
-  /**
-   * Record the result of a claim evaluation and update the ELO profile.
-   * Call this after the LLM has evaluated the claim.
-   *
-   * @param {string} domain
-   * @param {'VALIDATED'|'BLOCKED'|'PARTIALLY_VALID'} result
-   * @param {object} opts - { blockedReason, claimExcerpt }
-   * @returns {{ newRating, delta, tiltDetected, interventionMode, message }}
-   */
-  recordResult(domain, result, opts = {}) {
-    const { blockedReason = null, claimExcerpt = '' } = opts;
-    const profile  = this.store.getDomain(domain);
-    const kFactor  = getKFactor(domain);
-    const score    = this.evaluator.resultToScore(result);
-
-    const { newRating, newRd, delta } = glickoUpdate(
-      profile.rating,
-      profile.rd,
-      score,
-      kFactor
-    );
-
-    this.store.recordResult(domain, result, {
-      delta, newRating, newRd, blockedReason, claimExcerpt
-    });
-    this.store.save();
-
-    // Refresh profile after save
-    const updated = this.store.getDomain(domain);
-    const tiltDetected  = updated.blocked_streak >= TILT_THRESHOLD;
-    const interventionMode = newRating <= INTERVENTION_RATING && updated.session_count > 1;
-
-    let message;
-    if (result === 'BLOCKED') {
-      const formatted = this.pedagogy.formatBlocked(blockedReason, newRating, domain);
-      message = `[${formatted.label}] ${formatted.opening}`;
-    } else {
-      const formatted = this.pedagogy.formatValidated(newRating, delta, domain, updated.history);
-      message = formatted.message;
-    }
-
-    if (tiltDetected) {
-      message += '\n\n' + this.pedagogy.formatTiltIntervention(domain, updated.blocked_streak);
-    }
-
-    if (interventionMode) {
-      message += '\n\n' + this.pedagogy.formatZeroIntervention(domain);
-    }
-
-    return { newRating, delta, tiltDetected, interventionMode, message };
-  }
-
-  /**
-   * Declare user expertise for a domain (sets provisional ELO).
-   * @param {string} domain
-   * @param {string} level - 'beginner'|'intermediate'|'advanced'|'expert'|'principal'
-   */
-  declareExpertise(domain, level) {
-    const rating = DECLARED_EXPERTISE_RATINGS[level] ?? DECLARED_EXPERTISE_RATINGS.intermediate;
-    this.store.setProvisional(domain, rating);
-    this.store.getDomain(domain).rating = rating;
-    this.store.save();
-    return { domain, provisionalRating: rating, level };
-  }
-
-  /**
-   * Get the [ELO] dashboard for a domain: why + how.
-   * @param {string} domain
-   * @returns {string}
-   */
-  getDashboard(domain) {
-    const profile = this.store.getDomain(domain);
-    return this.pedagogy.formatDashboard(domain, profile);
-  }
-
-  /**
-   * Get match history for a domain.
-   * @param {string} domain
-   * @returns {Array}
-   */
-  getMatchHistory(domain) {
-    return this.store.getDomain(domain).history;
-  }
-
-  /**
-   * Get summary across all domains (for the full [ELO] menu).
-   * @returns {Array<{ domain, rating, rd, trend, trend_delta, last_active }>}
-   */
-  getSummary() {
-    return this.store.getSummary();
-  }
-
-  /**
-   * Get the recommended LLM model for this session.
-   * @returns {{ model, label, reason, maxRating }}
-   */
-  routeLLM() {
-    return this.router.route(this.store);
-  }
-
-  /**
-   * Apply RD decay for domains idle more than N days.
-   * Call once per session start.
-   */
-  applyIdleDecay() {
-    const today = new Date();
-    const data  = this.store.load();
-
-    for (const [domain, profile] of Object.entries(data.domains)) {
-      if (!profile.last_active) continue;
-      const lastActive = new Date(profile.last_active);
-      const daysSince  = Math.floor((today - lastActive) / (1000 * 60 * 60 * 24));
-      if (daysSince > 30) {
-        profile.rd = decayRd(profile.rd, daysSince);
-      }
-    }
-
-    this.store.save();
-  }
-}
-
-module.exports = EloEngine;

package/src/byan-v2/elo/llm-router.js

@@ -1,47 +0,0 @@
-/**
- * llm-router.js — Routes to the appropriate LLM model based on ELO profile
- *
- * Logic (experimental V1): decision made at session start, not mid-session.
- * Uses the maximum rating across active domains (≥1 session).
- *
- * Expert (ELO 601+)   → haiku   (short answers, no explanation needed)
- * Praticien (201-600) → sonnet  (balanced challenge/efficiency)
- * Apprenti (0-200)    → opus    (best reasoning, user needs more support)
- */
-
-const { LLM_ROUTING } = require('./domain-config');
-
-class LlmRouter {
-  /**
-   * Determine the recommended model for this session.
-   * @param {object} store - EloStore instance
-   * @returns {{ model, label, reason, maxRating }}
-   */
-  route(store) {
-    const summary = store.getSummary().filter(d => d.session_count >= 1);
-    const maxRating = summary.length > 0
-      ? Math.max(...summary.map(d => d.rating))
-      : 0;
-
-    const routing = LLM_ROUTING.find(r => maxRating <= r.maxRating) ?? LLM_ROUTING[LLM_ROUTING.length - 1];
-
-    return {
-      model:     routing.model,
-      label:     routing.label,
-      maxRating,
-      reason:    `Max ELO across active domains: ${maxRating} → ${routing.label} (${routing.model})`
-    };
-  }
-
-  /**
-   * Route for a specific domain only.
-   * @param {number} domainRating
-   * @returns {{ model, label }}
-   */
-  routeForDomain(domainRating) {
-    const routing = LLM_ROUTING.find(r => domainRating <= r.maxRating) ?? LLM_ROUTING[LLM_ROUTING.length - 1];
-    return { model: routing.model, label: routing.label };
-  }
-}
-
-module.exports = LlmRouter;

package/src/byan-v2/elo/pedagogy-layer.js

@@ -1,170 +0,0 @@
-/**
- * pedagogy-layer.js — Bienveillant response formatting
- *
- * Transforms raw ELO events into human-readable, pedagogically sound messages.
- * Tone invariant: curiosity, never accusation.
- */
-
-const { BLOCKED_REASONS, getBlockedLabel } = require('./domain-config');
-
-const BLOCKED_REASON_MESSAGES = {
-  [BLOCKED_REASONS.TERMINOLOGY_GAP]: {
-    label: 'terminologie',
-    prompt: "Tu utilises le bon concept mais avec le mauvais mot. Voici la terminologie exacte, et pourquoi elle compte :"
-  },
-  [BLOCKED_REASONS.PREREQUISITE_GAP]: {
-    label: 'prerequis manquant',
-    prompt: "Ce concept s'appuie sur une base que l'on n'a pas encore vue ensemble. Voici ce qui manque :"
-  },
-  [BLOCKED_REASONS.CONTEXT_MISMATCH]: {
-    label: 'mismatch de contexte',
-    prompt: "C'est vrai dans un certain contexte — pas dans le tien. Voici ce qui change :"
-  },
-  [BLOCKED_REASONS.OUTDATED_KNOWLEDGE]: {
-    label: 'connaissance perimee',
-    prompt: "C'etait correct avant — voici ce qui a change depuis :"
-  },
-  [BLOCKED_REASONS.LAZY_CLAIM]: {
-    label: 'raisonnement incomplet',
-    prompt: "Tu as la premiere couche. La couche suivante, c'est ce qui fait toute la difference :"
-  },
-  [BLOCKED_REASONS.OVERCONFIDENCE]: {
-    label: 'overconfidence partielle',
-    prompt: "L'essentiel est correct. Voici le cas limite que 80% des praticiens manquent :"
-  }
-};
-
-class PedagogyLayer {
-  /**
-   * Format a BLOCKED result into a bienveillant, targeted response.
-   * @param {string} blockedReason - one of BLOCKED_REASONS values
-   * @param {number} rating        - current domain rating
-   * @param {string} domain
-   * @returns {{ label, opening, blockedReasonLabel }}
-   */
-  formatBlocked(blockedReason, rating, domain) {
-    const label  = getBlockedLabel(rating);
-    const reason = BLOCKED_REASON_MESSAGES[blockedReason] ?? BLOCKED_REASON_MESSAGES[BLOCKED_REASONS.LAZY_CLAIM];
-
-    return {
-      label,
-      opening:            reason.prompt,
-      blockedReasonLabel: reason.label
-    };
-  }
-
-  /**
-   * Format a VALIDATED result with growth narrative.
-   * @param {number} newRating
-   * @param {number} delta
-   * @param {string} domain
-   * @param {Array}  history - domain history array
-   * @returns {{ message }}
-   */
-  formatValidated(newRating, delta, domain, history = []) {
-    const prevRating = newRating - delta;
-    const weekAgo = this._ratingNWeeksAgo(history, 3);
-
-    if (weekAgo !== null && weekAgo < prevRating) {
-      return {
-        message: `Tu etais a ${weekAgo} en ${domain} il y a quelques semaines. Tu es a ${newRating} maintenant (+${delta} sur ce claim). La progression est reelle.`
-      };
-    }
-
-    if (delta > 0) {
-      return { message: `[${domain}] +${delta} pts → ${newRating}. Ce claim confirme ta maitrise.` };
-    }
-
-    return { message: `[${domain}] Claim valide. Score stable a ${newRating}.` };
-  }
-
-  /**
-   * Format a tilt intervention message.
-   * @param {string} domain
-   * @param {number} streakCount
-   * @returns {string}
-   */
-  formatTiltIntervention(domain, streakCount) {
-    return `Je remarque ${streakCount} claims bloques consecutivement en ${domain}. Ce n'est pas un probleme — c'est souvent la zone ou les concepts commencent vraiment a se lier. Tu veux qu'on reprenne un concept de base ensemble, ou tu preferes continuer ?`;
-  }
-
-  /**
-   * Format the ELO 0 intervention.
-   * @param {string} domain
-   * @returns {string}
-   */
-  formatZeroIntervention(domain) {
-    return `Ton score en ${domain} est a 0 apres plusieurs sessions. Je te propose 5 questions de calibration pour identifier exactement ou construire la base — pas une punition, juste un point de depart solide.`;
-  }
-
-  /**
-   * Format the full [ELO] dashboard: why + how.
-   * @param {string} domain
-   * @param {object} domainProfile - from EloStore.getDomain()
-   * @returns {string} formatted dashboard text
-   */
-  formatDashboard(domain, domainProfile) {
-    const { rating, rd, history = [], blocked_streak, consecutive_correct } = domainProfile;
-    const recent = history.slice(-10);
-
-    // Aggregate blocked reasons
-    const reasonCounts = {};
-    for (const h of recent) {
-      if (h.result === 'BLOCKED' && h.blocked_reason) {
-        reasonCounts[h.blocked_reason] = (reasonCounts[h.blocked_reason] || 0) + 1;
-      }
-    }
-
-    const weekDelta = this._deltaOverHistory(recent, 7);
-    const trend = weekDelta > 5 ? `↑ +${weekDelta}` : weekDelta < -5 ? `↓ ${weekDelta}` : `→ ${weekDelta >= 0 ? '+' : ''}${weekDelta}`;
-
-    const lines = [
-      `Domaine: ${domain} | Score: ${rating} | RD: ${rd} | Tendance: ${trend}`,
-      ''
-    ];
-
-    if (Object.keys(reasonCounts).length > 0) {
-      lines.push('Pourquoi ce score ?');
-      for (const [reason, count] of Object.entries(reasonCounts)) {
-        const meta = BLOCKED_REASON_MESSAGES[reason];
-        lines.push(`  - ${count}× ${meta?.label ?? reason}`);
-      }
-      lines.push('');
-    }
-
-    lines.push('Prochaines etapes :');
-    if (rating < 200) {
-      lines.push(`  Les fondamentaux de ${domain} sont le bon point de depart.`);
-    } else if (rating < 500) {
-      lines.push(`  Les cas limites et contextes specifiques sont ce qui fait progresser ici.`);
-    } else {
-      lines.push(`  Pour progresser, joue des claims difficiles — les evidents ne font plus bouger le score.`);
-    }
-
-    if (rd > 150) {
-      lines.push(`  (RD eleve = score incertain — quelques sessions de plus pour le stabiliser)`);
-    }
-
-    return lines.join('\n');
-  }
-
-  // --- Private ---
-
-  _ratingNWeeksAgo(history, weeks) {
-    const cutoff = new Date();
-    cutoff.setDate(cutoff.getDate() - weeks * 7);
-    const old = history.filter(h => new Date(h.date) < cutoff);
-    if (!old.length) return null;
-    return old.reduce((sum, h) => sum - (h.delta || 0), history.reduce((sum, h) => sum + (h.delta || 0), 0));
-  }
-
-  _deltaOverHistory(history, days) {
-    const cutoff = new Date();
-    cutoff.setDate(cutoff.getDate() - days);
-    return history
-      .filter(h => new Date(h.date) >= cutoff)
-      .reduce((sum, h) => sum + (h.delta || 0), 0);
-  }
-}
-
-module.exports = PedagogyLayer;

package/src/byan-v2/fact-check/claim-parser.js

@@ -1,51 +0,0 @@
-/**
- * ClaimParser - Detects implicit claims in text using trigger patterns
- *
- * Auto-triggers fact-check when danger patterns are found :
- * absolute words, superlatives, unverified best practices, etc.
- */
-
-const DEFAULT_PATTERNS = [
-  /\b(toujours|jamais|forcement|evidemment|clairement)\b/i,
-  /\b(always|never|obviously|clearly|certainly|definitely)\b/i,
-  /\b(plus rapide|plus sur|mieux|optimal|meilleur|superieur)\b/i,
-  /\b(faster|safer|better|optimal|superior|best)\b/i,
-  /\b(il est bien connu que|tout le monde sait|generalement accepte)\b/i,
-  /\b(it is well known that|everyone knows|generally accepted)\b/i,
-  /\b(bonne pratique|best practice|standard de facto|industry standard)\b/i,
-  /\b(prouve que|demontre que|il est clair que)\b/i,
-  /\b(proven|demonstrates that|it is clear that)\b/i
-];
-
-class ClaimParser {
-  constructor(customPatterns = []) {
-    this.patterns = [
-      ...DEFAULT_PATTERNS,
-      ...customPatterns.map(p => new RegExp(p, 'i'))
-    ];
-  }
-
-  parse(text) {
-    if (typeof text !== 'string' || !text) return [];
-
-    const detected = [];
-    for (const pattern of this.patterns) {
-      const match = pattern.exec(text);
-      if (match) {
-        detected.push({
-          pattern: pattern.source,
-          matched: match[0],
-          position: match.index,
-          excerpt: text.slice(Math.max(0, match.index - 30), match.index + 60).trim()
-        });
-      }
-    }
-    return detected;
-  }
-
-  containsClaim(text) {
-    return this.parse(text).length > 0;
-  }
-}
-
-module.exports = ClaimParser;