create-byan-agent 2.6.2 → 2.7.0

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

@@ -1,319 +0,0 @@
-/**
- * FiveWhysAnalyzer - Root cause analysis through 5 WHYs technique
- * 
- * MANTRAS: KISS, DRY, SOLID, Zero Emoji (IA-23)
- * 
- * Features:
- * - Pain point detection in user responses
- * - Sequential WHY questioning (1-5 depth)
- * - Root cause extraction
- * - Analysis export with metadata
- */
-
-const Logger = require('../observability/logger');
-
-class FiveWhysAnalyzer {
-  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;
-    this.responses = [];
-    this.painPoints = [];
-    this.rootCause = null;
-    this.active = false;
-    
-    this.painKeywords = [
-      'problem', 'issue', 'challenge', 'difficult', 'slow', 'complex',
-      'error', 'fail', 'break', 'bug', 'struggle', 'hard', 'confusing',
-      'frustrating', 'annoying', 'painful', 'blocking', 'stuck'
-    ];
-  }
-
-  start(initialResponse) {
-    if (!initialResponse || typeof initialResponse !== 'string') {
-      return { needsWhys: false, reason: 'Invalid response' };
-    }
-
-    const detected = this._detectPainPoints(initialResponse);
-    
-    if (!detected.hasPainPoints) {
-      this.logger.info('No pain points detected', { response: initialResponse.substring(0, 100) });
-      return { needsWhys: false, reason: 'No pain points detected' };
-    }
-
-    this.active = true;
-    this.painPoints = detected.painPoints;
-    this.responses.push({
-      depth: 0,
-      question: 'initial',
-      answer: initialResponse,
-      painPoints: detected.painPoints
-    });
-
-    this.logger.info('5 Whys started', { painPoints: detected.painPoints });
-
-    return {
-      needsWhys: true,
-      painPoints: detected.painPoints,
-      firstQuestion: this.askNext()
-    };
-  }
-
-  _detectPainPoints(text) {
-    const lowerText = text.toLowerCase();
-    const foundPoints = [];
-
-    for (const keyword of this.painKeywords) {
-      if (lowerText.includes(keyword)) {
-        const index = lowerText.indexOf(keyword);
-        const context = text.substring(Math.max(0, index - 20), Math.min(text.length, index + 50));
-        foundPoints.push({ keyword, context: context.trim() });
-      }
-    }
-
-    return {
-      hasPainPoints: foundPoints.length > 0,
-      painPoints: foundPoints,
-      confidence: Math.min(1.0, foundPoints.length / 3)
-    };
-  }
-
-  askNext() {
-    if (!this.active) {
-      return null;
-    }
-
-    if (this.depth >= this.maxDepth) {
-      return null;
-    }
-
-    this.depth++;
-
-    const questions = [
-      'Why is this a problem for you?',
-      'Why does this happen?',
-      'Why is that the case?',
-      'Why does that matter?',
-      'What is the underlying reason?'
-    ];
-
-    const question = this.depth === 1 
-      ? 'Why is this a problem for you?'
-      : questions[Math.min(this.depth - 1, questions.length - 1)];
-
-    return {
-      depth: this.depth,
-      question,
-      prompt: `${question} (${this.depth}/5)`
-    };
-  }
-
-  processAnswer(answer) {
-    if (!this.active) {
-      return { valid: false, reason: 'Analyzer not active' };
-    }
-
-    if (!answer || typeof answer !== 'string' || answer.trim().length < 10) {
-      return { valid: false, reason: 'Answer too short or invalid' };
-    }
-
-    this.responses.push({
-      depth: this.depth,
-      question: `Why #${this.depth}`,
-      answer: answer.trim(),
-      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) {
-      this.rootCause = rootCauseAnalysis;
-      this.active = false;
-      this.logger.info('Root cause identified early', { 
-        depth: this.depth, 
-        rootCause: rootCauseAnalysis.statement 
-      });
-      
-      return {
-        valid: true,
-        rootCauseFound: true,
-        analysis: rootCauseAnalysis,
-        nextQuestion: null
-      };
-    }
-
-    if (this.depth >= this.maxDepth) {
-      this.rootCause = this._extractRootCause();
-      this.active = false;
-      this.logger.info('5 Whys completed', { 
-        depth: this.depth, 
-        rootCause: this.rootCause.statement 
-      });
-      
-      return {
-        valid: true,
-        completed: true,
-        rootCause: this.rootCause,
-        nextQuestion: null
-      };
-    }
-
-    return {
-      valid: true,
-      nextQuestion: this.askNext()
-    };
-  }
-
-  _analyzeForRootCause(answer) {
-    const lowerAnswer = answer.toLowerCase();
-    
-    const rootCauseIndicators = [
-      'because', 'fundamental', 'core', 'underlying', 'root',
-      'lack of', 'missing', 'no process', 'no system', 'unclear',
-      'not defined', 'never', 'always', 'since beginning'
-    ];
-
-    let indicatorCount = 0;
-    for (const indicator of rootCauseIndicators) {
-      if (lowerAnswer.includes(indicator)) {
-        indicatorCount++;
-      }
-    }
-
-    const isRootCause = indicatorCount >= 2 || (indicatorCount >= 1 && answer.length > 100);
-    const confidence = Math.min(1.0, (indicatorCount * 0.3) + (answer.length / 500));
-
-    return {
-      isRootCause,
-      confidence,
-      statement: answer.trim(),
-      depth: this.depth,
-      indicators: indicatorCount
-    };
-  }
-
-  _extractRootCause() {
-    if (this.responses.length < 2) {
-      return {
-        statement: 'Insufficient data for root cause analysis',
-        confidence: 0.0,
-        category: 'unknown',
-        actionItems: []
-      };
-    }
-
-    const lastResponses = this.responses.slice(-2);
-    const deepestAnswer = lastResponses[lastResponses.length - 1].answer;
-    
-    const category = this._categorizeRootCause(deepestAnswer);
-    const actionItems = this._extractActionItems(deepestAnswer);
-    const confidence = this._calculateConfidence(this.depth, deepestAnswer);
-
-    return {
-      statement: deepestAnswer,
-      confidence,
-      category,
-      actionItems,
-      depth: this.depth
-    };
-  }
-
-  _categorizeRootCause(statement) {
-    const lowerStatement = statement.toLowerCase();
-    
-    const categories = {
-      technical: ['code', 'system', 'software', 'hardware', 'infrastructure', 'api', 'database'],
-      process: ['process', 'workflow', 'procedure', 'method', 'approach', 'way we'],
-      resource: ['time', 'money', 'budget', 'people', 'team', 'resource', 'capacity'],
-      knowledge: ['know', 'understand', 'learn', 'training', 'documentation', 'experience', 'skill']
-    };
-
-    for (const [category, keywords] of Object.entries(categories)) {
-      for (const keyword of keywords) {
-        if (lowerStatement.includes(keyword)) {
-          return category;
-        }
-      }
-    }
-
-    return 'general';
-  }
-
-  _extractActionItems(statement) {
-    const actionKeywords = [
-      'need to', 'should', 'must', 'have to', 'require',
-      'implement', 'create', 'build', 'fix', 'improve'
-    ];
-
-    const sentences = statement.split(/[.!?]+/).filter(s => s.trim().length > 0);
-    const actions = [];
-
-    for (const sentence of sentences) {
-      const lowerSentence = sentence.toLowerCase();
-      for (const keyword of actionKeywords) {
-        if (lowerSentence.includes(keyword)) {
-          actions.push(sentence.trim());
-          break;
-        }
-      }
-    }
-
-    return actions.slice(0, 3);
-  }
-
-  _calculateConfidence(depth, statement) {
-    let confidence = 0.5;
-    
-    confidence += (depth / this.maxDepth) * 0.3;
-    
-    if (statement.length > 50) confidence += 0.1;
-    if (statement.length > 100) confidence += 0.1;
-    
-    return Math.min(1.0, confidence);
-  }
-
-  isComplete() {
-    return !this.active;
-  }
-
-  getRootCause() {
-    return this.rootCause;
-  }
-
-  getDepth() {
-    return this.depth;
-  }
-
-  getResponses() {
-    return [...this.responses];
-  }
-
-  export() {
-    return {
-      version: '1.0.0',
-      createdAt: new Date().toISOString(),
-      painPoints: this.painPoints,
-      depth: this.depth,
-      responses: this.responses,
-      rootCause: this.rootCause,
-      metadata: {
-        completed: this.isComplete(),
-        maxDepth: this.maxDepth,
-        responseCount: this.responses.length
-      }
-    };
-  }
-}
-
-module.exports = FiveWhysAnalyzer;

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

@@ -1,121 +0,0 @@
-/**
- * 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

@@ -1,129 +0,0 @@
-/**
- * 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
-};