@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/emotion/EmotionTransition.js

@@ -1,245 +0,0 @@
-/**
- * EmotionTransition - 表层情感转换引擎
- * 基于关键词规则 + DeepEmotion PAD 状态驱动情感转换
- *
- * 优化点：
- * - 从 EmotionKeywords.js 统一导入关键词
- * - padToEmotion() 返回置信度 { emotion, confidence: 0-1 }
- * - transition() 融合关键词 + PAD + 情感历史，计算综合强度
- * - 实现情感衰减：检测自上次情感更新以来经过的时间，应用衰减
- */
-
-const { EmotionTypes, EmotionDefinitions, createEmotionState } = require('./EmotionStates');
-const { detectKeywordsWithWeight, positiveWords, negativeWords, stressWords,
-        tiredWords, excitedWords, calmWords, questionWords } = require('./EmotionKeywords');
-
-/**
- * 从 DeepEmotion PAD 状态推断情感倾向
- * @param {object} pad - { valence, arousal, dominance } 范围约 [-1, 1]
- * @returns {{ emotion: string, confidence: number }}
- */
-function padToEmotion(pad) {
-  const { valence = 0, arousal = 0, dominance = 0 } = pad;
-
-  // 复合置信度计算
-  const score = {};
-  const absV = Math.abs(valence);
-  const absA = Math.abs(arousal);
-  const absD = Math.abs(dominance);
-
-  // 兴奋：高效价 + 高唤醒
-  score[EmotionTypes.EXCITED] = Math.max(0, Math.min(1,
-    (valence > 0.3 ? valence * 0.5 : 0) +
-    (arousal > 0.4 ? arousal * 0.4 : 0) +
-    (absD > 0.2 ? absD * 0.1 : 0)
-  ));
-
-  // 愉悦：高效价 + 低唤醒
-  score[EmotionTypes.JOY] = Math.max(0, Math.min(1,
-    (valence > 0.3 ? valence * 0.6 : 0) +
-    (arousal < 0.3 ? (0.3 - arousal) * 0.3 : 0)
-  ));
-
-  // 好奇：高唤醒
-  score[EmotionTypes.CURIOUS] = Math.max(0, Math.min(1,
-    (arousal > 0.3 ? arousal * 0.5 : 0) +
-    (Math.abs(valence) < 0.3 ? 0.2 : 0)
-  ));
-
-  // 关切：低效价 + 低支配
-  score[EmotionTypes.CONCERNED] = Math.max(0, Math.min(1,
-    (valence < -0.2 ? absV * 0.4 : 0) +
-    (dominance < 0 ? absD * 0.4 : 0)
-  ));
-
-  // 疲惫：低唤醒 + 低效价
-  score[EmotionTypes.TIRED] = Math.max(0, Math.min(1,
-    (arousal < -0.2 ? absA * 0.5 : 0) +
-    (valence < 0 ? absV * 0.3 : 0) +
-    (dominance < 0 ? absD * 0.2 : 0)
-  ));
-
-  // 平静：维度接近零
-  const neutrality = 1 - Math.sqrt(absV * absV + absA * absA + absD * absD) / Math.sqrt(3);
-  score[EmotionTypes.CALM] = Math.max(0, Math.min(1, neutrality * 0.8));
-
-  // 找最高分
-  let maxEmotion = EmotionTypes.CALM;
-  let maxScore = 0;
-  for (const [emotion, conf] of Object.entries(score)) {
-    if (conf > maxScore) {
-      maxScore = conf;
-      maxEmotion = emotion;
-    }
-  }
-
-  return {
-    emotion: maxEmotion,
-    confidence: Math.round(maxScore * 100) / 100
-  };
-}
-
-/**
- * 情感衰减计算
- * @param {object} currentEmotion - 当前情感状态
- * @param {number} elapsedMinutes - 距上次更新的分钟数
- * @returns {object} - { shouldDecay: boolean, decayedIntensity: number, newEmotion: string }
- */
-function applyDecay(currentEmotion, elapsedMinutes) {
-  if (!currentEmotion || !currentEmotion.emotion) {
-    return { shouldDecay: false, decayedIntensity: null, newEmotion: null };
-  }
-
-  const def = EmotionDefinitions[currentEmotion.emotion];
-  const decayMinutes = def?.naturalDecayMinutes;
-
-  // 没有衰减配置
-  if (!decayMinutes) {
-    return { shouldDecay: false, decayedIntensity: currentEmotion.intensity, newEmotion: currentEmotion.emotion };
-  }
-
-  // 未超过衰减时间
-  if (elapsedMinutes < decayMinutes) {
-    return { shouldDecay: false, decayedIntensity: currentEmotion.intensity, newEmotion: currentEmotion.emotion };
-  }
-
-  // 超过衰减时间：强度降低
-  const decaySteps = Math.floor(elapsedMinutes / decayMinutes);
-  const newIntensity = Math.max(1, currentEmotion.intensity - decaySteps);
-
-  return {
-    shouldDecay: true,
-    decayedIntensity: newIntensity,
-    newEmotion: currentEmotion.emotion
-  };
-}
-
-/**
- * 从关键词检测推断情感（带权重）
- * @param {string} text - 用户输入
- * @returns {{ emotion: string|null, confidence: number, matchedWords: string[] }}
- */
-function inferEmotionFromKeywords(text) {
-  const detected = detectKeywordsWithWeight(text);
-
-  // 映射类别到情感类型
-  const categoryMap = {
-    positive: EmotionTypes.JOY,
-    negative: EmotionTypes.CONCERNED,
-    stress: EmotionTypes.CONCERNED,
-    tired: EmotionTypes.TIRED,
-    excited: EmotionTypes.EXCITED,
-    question: EmotionTypes.CURIOUS,
-    calm: EmotionTypes.CALM
-  };
-
-  let bestEmotion = null;
-  let bestScore = 0;
-  let bestMatchedWords = [];
-
-  for (const [category, data] of Object.entries(detected)) {
-    const emotion = categoryMap[category];
-    if (!emotion) continue;
-
-    // 综合得分 = 词数 * 平均权重
-    const score = data.count * data.avgWeight;
-    if (score > bestScore) {
-      bestScore = score;
-      bestEmotion = emotion;
-      bestMatchedWords = data.matchedWords;
-    }
-  }
-
-  return {
-    emotion: bestEmotion,
-    confidence: Math.min(1, bestScore / 3),
-    matchedWords: bestMatchedWords
-  };
-}
-
-/**
- * 核心转换函数
- * @param {string} userInput - 用户输入
- * @param {object} currentPadState - DeepEmotion 的 PAD 状态 { valence, arousal, dominance }
- * @param {object} currentSurfaceEmotion - 当前表层情感状态 { emotion, intensity, timestamp }
- * @returns {{ from, to, intensity, triggers, decayMinutes, confidence, trajectory }}
- */
-function transition(userInput, currentPadState = {}, currentSurfaceEmotion = null) {
-  // 1. 计算情感衰减（如果当前有激活情感）
-  let decayResult = { shouldDecay: false, decayedIntensity: null, newEmotion: null };
-  if (currentSurfaceEmotion && currentSurfaceEmotion.timestamp) {
-    const elapsed = (Date.now() - new Date(currentSurfaceEmotion.timestamp).getTime()) / 60000;
-    decayResult = applyDecay(currentSurfaceEmotion, elapsed);
-  }
-
-  // 2. 从关键词推断情感
-  const keywordResult = inferEmotionFromKeywords(userInput);
-
-  // 3. 从 PAD 状态推断情感
-  const padResult = padToEmotion(currentPadState);
-
-  // 4. 融合决策：关键词优先，PAD 作为置信度调整
-  let targetEmotion;
-  let intensity;
-  let confidence;
-  const triggers = [...keywordResult.matchedWords];
-
-  if (keywordResult.emotion && keywordResult.confidence > 0.2) {
-    // 关键词有明确命中
-    targetEmotion = keywordResult.emotion;
-    // 强度 = 基础值 + 关键词数（上限5）
-    intensity = Math.min(5, 2 + keywordResult.matchedWords.length);
-    confidence = Math.min(1, keywordResult.confidence * 1.2); // 关键词加权提升置信度
-  } else if (padResult.confidence > 0.3) {
-    // PAD 推断为主
-    targetEmotion = padResult.emotion;
-    intensity = Math.min(5, Math.max(2, Math.round(2 + padResult.confidence * 3)));
-    confidence = padResult.confidence * 0.7; // PAD 推断置信度打折
-  } else {
-    // 默认平静
-    targetEmotion = EmotionTypes.CALM;
-    intensity = 2;
-    confidence = 0.5;
-  }
-
-  // 5. 如果检测到情感衰减，降低强度
-  if (decayResult.shouldDecay) {
-    intensity = Math.min(intensity, decayResult.decayedIntensity);
-    // 如果衰减后强度很低，考虑是否切换到平静
-    if (decayResult.decayedIntensity <= 1) {
-      targetEmotion = EmotionTypes.CALM;
-      intensity = 2;
-    }
-  }
-
-  // 6. 如果新输入与当前情感相同，保留或提升强度
-  if (currentSurfaceEmotion && currentSurfaceEmotion.emotion === targetEmotion) {
-    intensity = Math.max(currentSurfaceEmotion.intensity, intensity);
-  }
-
-  // 7. 计算情感轨迹（上升/平稳/下降）
-  let trajectory = 'stable';
-  if (currentSurfaceEmotion) {
-    const prev = currentSurfaceEmotion.intensity || 3;
-    if (intensity > prev + 0.5) trajectory = 'rising';
-    else if (intensity < prev - 0.5) trajectory = 'declining';
-    else trajectory = 'stable';
-  }
-
-  // 8. 获取衰减配置
-  const def = EmotionDefinitions[targetEmotion];
-  const decayMinutes = def?.naturalDecayMinutes ?? null;
-
-  return {
-    from: currentSurfaceEmotion?.emotion || null,
-    to: targetEmotion,
-    intensity,
-    confidence: Math.round(confidence * 100) / 100,
-    triggers,
-    decayMinutes,
-    trajectory,
-    decayed: decayResult.shouldDecay
-  };
-}
-
-module.exports = { transition, padToEmotion, applyDecay, inferEmotionFromKeywords };

package/src/core/emotion/EmotionTrigger.js

@@ -1,182 +0,0 @@
-/**
- * EmotionTrigger - 表层情感触发器
- * 检测是否需要情感响应，返回建议情感
- *
- * 优化点：
- * - 从 EmotionKeywords.js 统一导入关键词
- * - detectEmotionNeed() 增加 textAnalysis：检测感叹号数量、问号数量、文本长度
- */
-
-const { EmotionTypes } = require('./EmotionStates');
-const { detectKeywordsWithWeight, gratefulWords, exclamationWords } = require('./EmotionKeywords');
-const { padToEmotion } = require('./EmotionTransition');
-
-/**
- * 情感分类映射
- */
-const categoryEmotionMap = {
-  positive: EmotionTypes.JOY,
-  negative: EmotionTypes.CONCERNED,
-  stress: EmotionTypes.CONCERNED,
-  tired: EmotionTypes.TIRED,
-  excited: EmotionTypes.EXCITED,
-  grateful: EmotionTypes.JOY,
-  question: EmotionTypes.CURIOUS,
-  calm: EmotionTypes.CALM
-};
-
-/**
- * 基于关键词分类推断目标情感
- * @param {object} detected - detectKeywordsWithWeight 的结果
- * @returns {{ emotion: string|null, reason: string }}
- */
-function categorizeToEmotion(detected) {
-  // 感谢优先
-  if (detected.grateful) {
-    return { emotion: EmotionTypes.JOY, reason: '感谢回应' };
-  }
-
-  // 兴奋词检测（优先级高）
-  if (detected.excited) {
-    return { emotion: EmotionTypes.EXCITED, reason: `兴奋词: ${detected.excited.matchedWords.join(', ')}` };
-  }
-
-  // 感叹词（无其他情感词时）
-  if (detected.exclamation && !detected.positive && !detected.negative && !detected.stress && !detected.tired) {
-    return { emotion: EmotionTypes.EXCITED, reason: '感叹表达' };
-  }
-
-  // 正面情绪词
-  if (detected.positive) {
-    return { emotion: EmotionTypes.JOY, reason: `正面情绪词: ${detected.positive.matchedWords.join(', ')}` };
-  }
-
-  // 负面情绪词
-  if (detected.negative) {
-    return { emotion: EmotionTypes.CONCERNED, reason: `负面情绪词: ${detected.negative.matchedWords.join(', ')}` };
-  }
-
-  // 压力词
-  if (detected.stress) {
-    return { emotion: EmotionTypes.CONCERNED, reason: `压力词: ${detected.stress.matchedWords.join(', ')}` };
-  }
-
-  // 疲惫词
-  if (detected.tired) {
-    return { emotion: EmotionTypes.TIRED, reason: `疲惫词: ${detected.tired.matchedWords.join(', ')}` };
-  }
-
-  // 疑问词
-  if (detected.question) {
-    return { emotion: EmotionTypes.CURIOUS, reason: '疑问句' };
-  }
-
-  // 平静词
-  if (detected.calm) {
-    return { emotion: EmotionTypes.CALM, reason: '平静表达' };
-  }
-
-  return null;
-}
-
-/**
- * 文本分析：提取文本特征
- * @param {string} text - 用户输入
- * @returns {{ exclamationCount, questionCount, length, hasPunctuation, sentimentScore }}
- */
-function analyzeText(text) {
-  // 统计感叹号数量（中文！和英文 !）
-  const exclamationCount = (text.match(/[!！]/g) || []).length;
-
-  // 统计问号数量（中文？和英文 ?）
-  const questionCount = (text.match(/[?？]/g) || []).length;
-
-  // 文本长度
-  const length = text.length;
-
-  // 是否包含标点
-  const hasPunctuation = /[,，.。!！?？;；]/.test(text);
-
-  // 简单情感得分（基于标点推断）
-  let sentimentScore = 0;
-  if (exclamationCount > 0) sentimentScore += exclamationCount * 0.15;
-  if (questionCount > 0) sentimentScore -= questionCount * 0.1;
-
-  return {
-    exclamationCount,
-    questionCount,
-    length,
-    hasPunctuation,
-    sentimentScore: Math.round(sentimentScore * 100) / 100
-  };
-}
-
-/**
- * 检测是否需要情感响应
- * @param {string} text - 用户输入
- * @param {object} padState - DeepEmotion PAD 状态（可选）
- * @returns {{ needsEmotion: boolean, matchedKeywords: string[], suggestedEmotion: string|null, reason: string|null, textAnalysis: object }}
- */
-function detectEmotionNeed(text, padState = null) {
-  const detected = detectKeywordsWithWeight(text);
-  const textAnalysis = analyzeText(text);
-  const categorized = categorizeToEmotion(detected);
-
-  // 收集所有匹配的关键词
-  const allKeywords = [];
-  for (const [category, data] of Object.entries(detected)) {
-    if (!data?.matchedWords) continue;
-    allKeywords.push(...data.matchedWords);
-  }
-
-  // 判断是否需要情感响应
-  const needsEmotion = !!(
-    categorized ||
-    textAnalysis.exclamationCount > 0 ||
-    textAnalysis.questionCount > 0 ||
-    textAnalysis.length > 100 ||
-    allKeywords.length > 0
-  );
-
-  // 如果没有明确分类但有 PAD 状态，尝试用 PAD 推断
-  let suggestedEmotion = categorized?.emotion || null;
-  let reason = categorized?.reason || null;
-
-  if (!suggestedEmotion && padState) {
-    const padResult = padToEmotion(padState);
-    if (padResult.confidence > 0.4) {
-      suggestedEmotion = padResult.emotion;
-      reason = `PAD 推断 (置信度: ${padResult.confidence})`;
-    }
-  }
-
-  return {
-    needsEmotion,
-    matchedKeywords: [...new Set(allKeywords)],
-    suggestedEmotion,
-    reason,
-    textAnalysis
-  };
-}
-
-/**
- * 简化版：检测情感关键词
- * @param {string} text - 用户输入
- * @returns {object} - 关键词分类结果
- */
-function matchWordCategories(text) {
-  const detected = detectKeywordsWithWeight(text);
-  const result = { emotion: [], question: false, thanks: false, exclamation: false };
-
-  for (const [category, data] of Object.entries(detected)) {
-    result.emotion.push(...data.matchedWords);
-  }
-
-  result.question = !!(detected.question);
-  result.thanks = !!(detected.grateful);
-  result.exclamation = !!(detected.exclamation);
-
-  return result;
-}
-
-module.exports = { detectEmotionNeed, matchWordCategories, categorizeToEmotion, analyzeText };

package/src/core/emotion/EmotionalMomentum.js

@@ -1,270 +0,0 @@
-/**
- * EmotionalMomentum - 情感惯性引擎
- *
- * 基于情感累积效应理论：
- * - 情绪不会瞬间消失，而是逐渐衰减
- * - 同向情绪会叠加（momentum）
- * - 反向情绪会抵消
- * - 情感记忆越近，惯性越大
- *
- * 同时实现 Plutchik 情感轮混合：
- * - joy + trust → love
- * - joy + surprise → delight
- * - anger + disgust → contempt
- * - fear + surprise → alarm
- * - sadness + disgust → remorse
- * - sadness + surprise → disappointment
- * - joy + anticipation → optimism
- * - anticipation + surprise → distraction
- * - fear + anger → panic
- */
-
-const { EmotionTypes } = require('./EmotionStates');
-
-/**
- * Plutchik 情感轮混合规则
- * 每对情感按权重比例混合成新情感
- */
-const PLUTCHIK_BLEND_RULES = [
-  { primary: 'joy', secondary: 'trust', result: 'love', ratio: 0.6 },
-  { primary: 'joy', secondary: 'surprise', result: 'delight', ratio: 0.5 },
-  { primary: 'anger', secondary: 'disgust', result: 'contempt', ratio: 0.6 },
-  { primary: 'fear', secondary: 'surprise', result: 'alarm', ratio: 0.5 },
-  { primary: 'sadness', secondary: 'disgust', result: 'remorse', ratio: 0.5 },
-  { primary: 'sadness', secondary: 'surprise', result: 'disappointment', ratio: 0.5 },
-  { primary: 'joy', secondary: 'anticipation', result: 'optimism', ratio: 0.5 },
-  { primary: 'anticipation', secondary: 'surprise', result: 'distraction', ratio: 0.5 },
-  { primary: 'fear', secondary: 'anger', result: 'panic', ratio: 0.5 },
-  // 额外映射（与表面6情感对应）
-  { primary: 'joy', secondary: 'curiosity', result: 'excitement', ratio: 0.4 },
-  { primary: 'sadness', secondary: 'fear', result: 'despair', ratio: 0.5 },
-  { primary: 'anger', secondary: 'fear', result: 'hostility', ratio: 0.5 }
-];
-
-/**
- * DeepEmotion 情绪 → SurfaceEmotion 映射
- */
-const DEEP_TO_SURFACE = {
-  joy: EmotionTypes.JOY,
-  sadness: EmotionTypes.CONCERNED,
-  anger: EmotionTypes.CONCERNED,
-  fear: EmotionTypes.CONCERNED,
-  surprise: EmotionTypes.CURIOUS,
-  disgust: EmotionTypes.TIRED,
-  trust: EmotionTypes.JOY,
-  anticipation: EmotionTypes.CURIOUS,
-  love: EmotionTypes.JOY,
-  hope: EmotionTypes.EXCITED,
-  pride: EmotionTypes.EXCITED,
-  shame: EmotionTypes.CONCERNED,
-  gratitude: EmotionTypes.JOY,
-  compassion: EmotionTypes.CONCERNED,
-  curiosity: EmotionTypes.CURIOUS,
-  wonder: EmotionTypes.CURIOUS,
-  delight: EmotionTypes.EXCITED,
-  contempt: EmotionTypes.CONCERNED,
-  alarm: EmotionTypes.CONCERNED,
-  remorse: EmotionTypes.CONCERNED,
-  disappointment: EmotionTypes.CONCERNED,
-  optimism: EmotionTypes.JOY,
-  distraction: EmotionTypes.CURIOUS,
-  panic: EmotionTypes.CONCERNED,
-  excitement: EmotionTypes.EXCITED,
-  despair: EmotionTypes.CONCERNED,
-  hostility: EmotionTypes.CONCERNED
-};
-
-/**
- * 情感惯性配置
- */
-const MOMENTUM_CONFIG = {
-  // 同向情感叠加系数
-  sameDirectionBoost: 0.15,
-  // 反向情感抵消系数
-  oppositeDirectionCancel: 0.25,
-  // 最大惯性值
-  maxMomentum: 1.0,
-  // 惯性衰减率（每分钟）
-  decayPerMinute: 0.02,
-  // 情感方向分组
-  emotionGroups: {
-    positive: [EmotionTypes.JOY, EmotionTypes.EXCITED],
-    negative: [EmotionTypes.CONCERNED, EmotionTypes.TIRED],
-    neutral: [EmotionTypes.CALM, EmotionTypes.CURIOUS]
-  }
-};
-
-class EmotionalMomentum {
-  constructor() {
-    this.momentum = 0;           // 当前惯性值 [-1, 1]
-    this.recentEmotions = [];     // 最近情感历史 [{ emotion, intensity, timestamp, deepEmotion }]
-    this.blendedEmotion = null;   // 当前混合情感
-    this.blendIntensity = 0;      // 混合强度
-    this.lastUpdateTime = Date.now();
-    this.direction = 'neutral';   // 'positive' | 'negative' | 'neutral'
-  }
-
-  /**
-   * 获取情感方向组
-   */
-  getEmotionGroup(emotion) {
-    for (const [group, emotions] of Object.entries(MOMENTUM_CONFIG.emotionGroups)) {
-      if (emotions.includes(emotion)) return group;
-    }
-    return 'neutral';
-  }
-
-  /**
-   * 判断两个情感是否同向
-   */
-  isSameDirection(e1, e2) {
-    return this.getEmotionGroup(e1) === this.getEmotionGroup(e2);
-  }
-
-  /**
-   * 判断两个情感是否反向
-   */
-  isOppositeDirection(e1, e2) {
-    const g1 = this.getEmotionGroup(e1);
-    const g2 = this.getEmotionGroup(e2);
-    return g1 !== 'neutral' && g1 !== g2;
-  }
-
-  /**
-   * 更新情感惯性
-   * @param {string} surfaceEmotion - 表面情感类型
-   * @param {number} intensity - 强度 1-5
-   * @param {string} deepEmotion - DeepEmotion 原始情绪
-   * @param {number} deepIntensity - DeepEmotion 原始强度 0-1
-   */
-  update(surfaceEmotion, intensity, deepEmotion = null, deepIntensity = 0.5) {
-    // 先应用时间衰减
-    this._applyTimeDecay();
-
-    // 归一化强度
-    const normIntensity = (intensity - 1) / 4; // 1-5 → 0-1
-
-    // 获取当前情感方向组
-    const currentGroup = this.getEmotionGroup(surfaceEmotion);
-
-    // 检查上一个情感
-    if (this.recentEmotions.length > 0) {
-      const last = this.recentEmotions[this.recentEmotions.length - 1];
-
-      if (this.isSameDirection(last.emotion, surfaceEmotion)) {
-        // 同向叠加
-        this.momentum = Math.min(MOMENTUM_CONFIG.maxMomentum,
-          this.momentum + MOMENTUM_CONFIG.sameDirectionBoost * normIntensity);
-      } else if (this.isOppositeDirection(last.emotion, surfaceEmotion)) {
-        // 反向抵消
-        const cancelAmount = MOMENTUM_CONFIG.oppositeDirectionCancel * (last.intensity / 4);
-        this.momentum = Math.max(-MOMENTUM_CONFIG.maxMomentum, this.momentum - cancelAmount);
-        // 反向时，方向切换
-        this.direction = currentGroup;
-      }
-    }
-
-    // 检查是否触发情感混合
-    const blend = this._checkBlend(surfaceEmotion, deepEmotion, deepIntensity);
-    if (blend) {
-      this.blendedEmotion = blend.emotion;
-      this.blendIntensity = blend.intensity;
-    } else {
-      this.blendedEmotion = surfaceEmotion;
-      this.blendIntensity = intensity;
-    }
-
-    // 更新方向
-    this.direction = currentGroup;
-
-    // 记录历史
-    this.recentEmotions.push({
-      emotion: surfaceEmotion,
-      intensity,
-      deepEmotion,
-      deepIntensity,
-      timestamp: Date.now()
-    });
-
-    // 限制历史长度
-    if (this.recentEmotions.length > 20) {
-      this.recentEmotions.shift();
-    }
-
-    this.lastUpdateTime = Date.now();
-  }
-
-  /**
-   * 检查是否触发 Plutchik 情感混合
-   */
-  _checkBlend(currentSurface, currentDeep, currentDeepIntensity) {
-    if (!currentDeep) return null;
-
-    for (const rule of PLUTCHIK_BLEND_RULES) {
-      const recent = this.recentEmotions
-        .filter(e => e.deepEmotion)
-        .slice(-5);
-
-      for (const prev of recent) {
-        // 检查是否匹配混合规则
-        if ((rule.primary === currentDeep || rule.secondary === currentDeep) &&
-            (rule.primary === prev.deepEmotion || rule.secondary === prev.deepEmotion)) {
-          // 匹配成功，生成混合情感
-          const avgIntensity = (currentDeepIntensity + prev.deepIntensity) / 2;
-          const surfaceResult = DEEP_TO_SURFACE[rule.result] || currentSurface;
-          return {
-            emotion: surfaceResult,
-            intensity: Math.round(avgIntensity * 4) + 1,
-            blendRule: `${rule.primary}+${rule.secondary}→${rule.result}`
-          };
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * 应用时间衰减
-   */
-  _applyTimeDecay() {
-    const now = Date.now();
-    const elapsedMinutes = (now - this.lastUpdateTime) / 60000;
-    if (elapsedMinutes > 0) {
-      const decay = MOMENTUM_CONFIG.decayPerMinute * elapsedMinutes;
-      this.momentum = this.momentum > 0
-        ? Math.max(0, this.momentum - decay)
-        : Math.min(0, this.momentum + decay);
-    }
-  }
-
-  /**
-   * 获取当前惯性状态
-   */
-  getState() {
-    return {
-      momentum: Math.round(this.momentum * 100) / 100,
-      direction: this.direction,
-      blendedEmotion: this.blendedEmotion,
-      blendIntensity: this.blendIntensity,
-      recentCount: this.recentEmotions.length,
-      isRising: this.momentum > 0.2,
-      isFalling: this.momentum < -0.2,
-      trajectory: this.momentum > 0.2 ? 'rising' : this.momentum < -0.2 ? 'falling' : 'stable'
-    };
-  }
-
-  /**
-   * 重置惯性
-   */
-  reset() {
-    this.momentum = 0;
-    this.recentEmotions = [];
-    this.blendedEmotion = null;
-    this.blendIntensity = 0;
-    this.direction = 'neutral';
-    this.lastUpdateTime = Date.now();
-  }
-}
-
-module.exports = { EmotionalMomentum, PLUTCHIK_BLEND_RULES, DEEP_TO_SURFACE };