@yun520-1/heartflow 0.15.2

package/src/core/emotion/EmotionTransition.js

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

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

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