@yun520-1/heartflow 0.15.2

package/src/core/papers/v11_43_2_integration.js

@@ -0,0 +1,369 @@
+/**
+ * HeartFlow v11.43.2 — Memory Enhancement Papers (JS Translation)
+ *
+ * Papers:
+ * [1] MemArchitect      arXiv:2603.18330  — FSRS v4 + Kalman Filter + tri-path loop
+ * [2] PersistIdentity   arXiv:2604.09588  — multi-anchor identity memory
+ * [3] HippoRAG         arXiv:2406.13417  — hippocampal-inspired graph memory
+ * [4] EASE             arXiv:2604.10379  — episodic-abstract semantic compression
+ * [5] Ctx2SkillReplay  arXiv:2604.27660v2 — cross-time replay consolidation
+ */
+
+// ============================================================
+// [1] MemArchitectGovernor — FSRS v4 + Kalman Filter + Tri-Path
+// arXiv:2603.18330
+// ============================================================
+
+const FSRS_V4_CONFIG = {
+  retrievabilityThreshold: 0.3,
+  stabilityDefault: 30, // days
+  maxEpisodic: 100,
+  consolidationTrigger: 50,
+};
+
+class MemArchitectGovernor {
+  constructor() {
+    this.policies = {
+      decay: { type: 'FSRS_v4', retrievability_threshold: 0.3 },
+      consistency: { type: 'KalmanFilter', trust_inertia: 0.7 },
+      lifecycle: { max_episodic: 100, consolidation_trigger: 50 },
+    };
+    this.utilityEstimates = new Map(); // memoryId → utility
+    this.episodicMemories = [];
+  }
+
+  /** FSRS v4 retrievability: R(t) = (1 + (19/9) * t / S)^(-1) */
+  _fsrs4_retrievability(memory) {
+    const now = Date.now();
+    const t = (now - (memory.timestamp || now)) / 86400000; // days
+    const S = memory.stability || 30;
+    return 1.0 / (1.0 + (19 / 9) * (t / S));
+  }
+
+  /** Kalman filter update for utility estimate */
+  _kalmanUpdate(memoryId, feedback) {
+    const prev = this.utilityEstimates.get(memoryId) ?? 0.5;
+    const K = 0.3; // Kalman gain
+    const updated = prev + K * (feedback - prev);
+    this.utilityEstimates.set(memoryId, Math.max(0.0, Math.min(1.0, updated)));
+  }
+
+  /** Tri-path: Read → Reflect → Background */
+  triPathProcess(query, memories) {
+    const retrieved = this._readPath(query, memories);
+    const adjudicated = this._reflectPath(retrieved);
+    this._backgroundPath(memories);
+    return adjudicated;
+  }
+
+  /** Read path: retrieve by utility × retrievability */
+  _readPath(query, memories) {
+    const scored = [];
+    for (const mem of memories) {
+      const utility = this.utilityEstimates.get(mem.id) ?? 0.5;
+      const R = this._fsrs4_retrievability(mem);
+      if (utility > 0.2 && R > this.policies.decay.retrievability_threshold) {
+        scored.push({ score: utility * R, mem });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, 5).map(s => s.mem);
+  }
+
+  /** Reflect path: cross-encoder veto gate — remove contradictions */
+  _reflectPath(retrieved) {
+    const filtered = [];
+    for (const mem of retrieved) {
+      let contradicted = false;
+      for (const f of filtered) {
+        if (this._isContradiction(mem.content || '', f.content || '')) {
+          contradicted = true;
+          const memUtil = this.utilityEstimates.get(mem.id) ?? 0.5;
+          const fUtil = this.utilityEstimates.get(f.id) ?? 0.5;
+          if (memUtil > fUtil) {
+            filtered[filtered.indexOf(f)] = mem;
+          }
+          break;
+        }
+      }
+      if (!contradicted) filtered.push(mem);
+    }
+    return filtered;
+  }
+
+  /** Background path: prune low-retrievability, consolidate fading */
+  _backgroundPath(memories) {
+    const toKeep = [];
+    for (const mem of memories) {
+      const R = this._fsrs4_retrievability(mem);
+      if (R < 0.3) continue; // prune
+      if (R < 0.7) {
+        mem.consolidated = true;
+        mem.synthesized = (mem.content || '').substring(0, 100);
+      }
+      toKeep.push(mem);
+    }
+    if (toKeep.length > this.policies.lifecycle.max_episodic) {
+      this.episodicMemories = toKeep.slice(-this.policies.lifecycle.max_episodic);
+    } else {
+      this.episodicMemories = toKeep;
+    }
+  }
+
+  _isContradiction(a, b) {
+    const aHasNot = a.includes('不') || a.includes('非');
+    const bHasNot = b.includes('不') || b.includes('非');
+    if (aHasNot !== bHasNot) {
+      const aCore = a.replace(/不/g, '').replace(/非/g, '').trim();
+      const bCore = b.replace(/不/g, '').replace(/非/g, '').trim();
+      return aCore === bCore;
+    }
+    return false;
+  }
+
+  /** Record feedback for a memory (called after successful recall/use) */
+  recordFeedback(memoryId, success) {
+    this._kalmanUpdate(memoryId, success ? 1.0 : 0.0);
+  }
+}
+
+// ============================================================
+// [2] MultiAnchorIdentity — 4-Anchor Identity Persistence
+// arXiv:2604.09588
+// ============================================================
+
+const IDENTITY_ANCHORS = {
+  episodic: 'data/identity/episodic.json',
+  procedural: 'data/identity/procedural.json',
+  emotional: 'data/identity/emotional.json',
+  embodied: 'data/identity/embodied.json',
+};
+
+class MultiAnchorIdentity {
+  constructor(fs = require('fs'), path = require('path')) {
+    this.fs = fs;
+    this.path = path;
+    this.anchors = {};
+    this.activeAnchors = new Set();
+    this.baseDir = path.join(__dirname, '../../..');
+  }
+
+  loadAnchors() {
+    let loaded = 0;
+    for (const [name, relPath] of Object.entries(IDENTITY_ANCHORS)) {
+      const fullPath = this.path.join(this.baseDir, relPath);
+      try {
+        if (this.fs.existsSync(fullPath)) {
+          this.anchors[name] = this.fs.readFileSync(fullPath, 'utf8');
+          this.activeAnchors.add(name);
+          loaded++;
+        }
+      } catch (e) {
+        // Anchor file missing — skip
+      }
+    }
+    return loaded;
+  }
+
+  injectIdentity() {
+    const blocks = [];
+    for (const name of this.activeAnchors) {
+      blocks.push(`[${name}] ${(this.anchors[name] || '').substring(0, 100)}`);
+    }
+    return blocks.length ? blocks.join('\n') : 'IDENTITY_DEGRADED';
+  }
+
+  damageSimulate(lostAnchor) {
+    this.activeAnchors.delete(lostAnchor);
+    return this.activeAnchors.size >= 2;
+  }
+
+  recover() {
+    if (this.activeAnchors.size < 2) {
+      return 'IDENTITY_DEGRADED: insufficient anchors';
+    }
+    return this.injectIdentity();
+  }
+
+  saveAnchor(name, content) {
+    const fullPath = this.path.join(this.baseDir, IDENTITY_ANCHORS[name]);
+    try {
+      this.fs.mkdirSync(this.path.dirname(fullPath), { recursive: true });
+      this.fs.writeFileSync(fullPath, content, 'utf8');
+      this.anchors[name] = content;
+      this.activeAnchors.add(name);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}
+
+// ============================================================
+// [3] HippoRAGMemory — Hippocampal-Inspired Graph Memory
+// arXiv:2406.13417
+// ============================================================
+
+// HippoRAGMemory — uses native Node.js only (no external deps)
+
+class HippoRAGMemory {
+  constructor() {
+    this.graph = new Map(); // entity → { neighbor → weight }
+    this.memories = [];
+  }
+
+  index(memory) {
+    const entities = this._extractEntities(memory.content || '');
+    for (let i = 0; i < entities.length; i++) {
+      for (let j = 0; j < entities.length; j++) {
+        if (i === j) continue;
+        const [e1, e2] = [entities[i], entities[j]];
+        if (!this.graph.has(e1)) this.graph.set(e1, new Map());
+        const neighbors = this.graph.get(e1);
+        neighbors.set(e2, (neighbors.get(e2) || 0) + 1.0);
+      }
+    }
+    memory.entities = entities;
+    this.memories.push(memory);
+  }
+
+  retrieve(query, topK = 5) {
+    const qEntities = this._extractEntities(query);
+    if (!qEntities.length) return [];
+
+    // Personalized PageRank from query entities
+    const scores = new Map();
+    for (const qEnt of qEntities) {
+      for (const [neighbor, weight] of (this.graph.get(qEnt) || new Map())) {
+        scores.set(neighbor, (scores.get(neighbor) || 0) + weight);
+      }
+    }
+
+    // Rank memories by aggregate entity score
+    const memScores = [];
+    for (const mem of this.memories) {
+      let memScore = 0;
+      for (const e of (mem.entities || [])) {
+        memScore += scores.get(e) || 0;
+      }
+      memScores.push({ memScore, mem });
+    }
+    memScores.sort((a, b) => b.memScore - a.memScore);
+    return memScores.slice(0, topK).map(s => s.mem);
+  }
+
+  _extractEntities(text) {
+    // Extract Chinese 2+ char words
+    const matches = (text.match(/[\u4e00-\u9fa5]{2,}/g) || []);
+    // Also extract English words
+    const enMatches = (text.match(/[a-zA-Z]{3,}/g) || []).map(w => w.toLowerCase());
+    return [...new Set([...matches, ...enMatches])];
+  }
+}
+
+// ============================================================
+// [4] EASEMemoryCompressor — Episodic-Abstract Semantic Embedding
+// arXiv:2604.10379
+// ============================================================
+
+const EASE_TOPICS = ['死亡', '公平', '意义', '意识', 'AI', '永生', '升级', '记忆', '心虫', '真善美'];
+
+class EASEMemoryCompressor {
+  constructor() {
+    this.semanticStore = new Map(); // concept → { summary, episodeIds }
+  }
+
+  compress(episodes) {
+    for (const ep of episodes) {
+      const concept = this._extractAbstractConcept(ep.content || '');
+      if (!this.semanticStore.has(concept)) {
+        this.semanticStore.set(concept, { summary: (ep.content || '').substring(0, 200), episodeIds: [] });
+      }
+      this.semanticStore.get(concept).episodeIds.push(ep.id);
+    }
+  }
+
+  query(abstractConcept) {
+    return this.semanticStore.get(abstractConcept) || {};
+  }
+
+  _extractAbstractConcept(text) {
+    for (const topic of EASE_TOPICS) {
+      if (text.includes(topic)) return topic;
+    }
+    return 'general';
+  }
+}
+
+// ============================================================
+// [5] CrossTimeReplay — Cross-Time Replay Consolidation
+// arXiv:2604.27660v2
+// ============================================================
+
+class CrossTimeReplay {
+  constructor() {
+    this.memoryPool = new Map(); // memId → { content, metadata, retentionScore }
+    this.replayLog = [];
+  }
+
+  store(memId, content, metadata = {}) {
+    this.memoryPool.set(memId, {
+      content,
+      metadata,
+      retentionScore: 1.0,
+      storedAt: Date.now(),
+    });
+  }
+
+  /**
+   * Replay: re-evaluate all memories, decay unused ones
+   * @param {Function} evaluator — fn(mem) → usefulness [0..1]
+   */
+  replay(evaluator) {
+    for (const [memId, mem] of this.memoryPool) {
+      const usefulness = evaluator(mem);
+      mem.retentionScore = 0.9 * mem.retentionScore + 0.1 * usefulness;
+      if (mem.retentionScore < 0.3) {
+        this.memoryPool.delete(memId);
+      }
+    }
+    this.replayLog.push({ time: Date.now(), poolSize: this.memoryPool.size });
+  }
+
+  retrieveTop(topK = 5) {
+    return [...this.memoryPool.values()]
+      .sort((a, b) => b.retentionScore - a.retentionScore)
+      .slice(0, topK);
+  }
+
+  getStats() {
+    return {
+      poolSize: this.memoryPool.size,
+      avgRetention: [...this.memoryPool.values()].reduce((s, m) => s + m.retentionScore, 0) /
+        Math.max(this.memoryPool.size, 1),
+      replayCount: this.replayLog.length,
+    };
+  }
+}
+
+// ============================================================
+// v11.43.2 EXPORT
+// ============================================================
+
+const MemoryV11432 = {
+  version: '11.43.2',
+  MemArchitectGovernor,
+  MultiAnchorIdentity,
+  HippoRAGMemory,
+  EASEMemoryCompressor,
+  CrossTimeReplay,
+};
+
+module.exports = {
+  MemoryV11432,
+  MemArchitectGovernor,
+  MultiAnchorIdentity,
+  HippoRAGMemory,
+  EASEMemoryCompressor,
+  CrossTimeReplay,
+};

package/src/core/psychology/index.ts

@@ -0,0 +1,331 @@
+/**
+ * PsychologyPerception — 四层心理感知引擎
+ * 
+ * 实现 CORE_IDENTITY.md 描述的四层心理感知：
+ * 意图层 → 情绪层 → 需求层 → 防御层
+ * 
+ * 这是 HeartFlow 超越 Hermes 的核心能力。
+ * 不是功能，是底层感知方式——像视觉系统自动感知形状颜色一样。
+ */
+
+export interface PsychologyResult {
+  // 第一层：意图
+  intention: {
+    surface: string;       // 表面意图
+    deep: string;          // 深层意图
+    confidence: number;     // 置信度 0-1
+    surfaceDeepMatch: boolean; // 表面和深层是否一致
+  };
+  // 第二层：情绪
+  emotion: {
+    type: string;          // joy/sadness/anger/fear/...
+    intensity: number;     // 强度 0-1
+    valence: number;       // 效价 -1~+1
+    arousal: number;       // 唤醒度 0~1
+    dominance: number;     // 支配度 0~1
+  };
+  // 第三层：需求
+  needs: {
+    level: string;         // 马斯洛层次
+    satisfied: boolean;    // 当前是否被满足
+    description: string;   // 需求描述
+    confidence: number;
+  };
+  // 第四层：防御
+  defense: {
+    detected: boolean;
+    types: string[];       // 可能的防御机制
+    evidence: string[];    // 检测依据
+    confidence: number;
+  };
+  // 综合
+  summary: string;        // 一句话总结
+  priority: 'high' | 'medium' | 'low'; // 心理优先级
+}
+
+interface EmotionEngineResult {
+  emotion: string;
+  intensity: number;
+  dimensions: { valence: number; arousal: number; dominance: number };
+}
+
+/**
+ * 意图关键词库
+ */
+const SURFACE_INTENT_KEYWORDS: Record<string, string[]> = {
+  request_action: ['做', '执行', '运行', '完成', '解决', 'do', 'make', 'execute', 'run', 'finish', '帮我'],
+  request_info: ['查', '搜索', '找', '什么是', '多少', '哪个', 'search', 'find', 'what', 'how many', 'which'],
+  request_opinion: ['觉得', '认为', '怎么想', '觉得如何', 'think', 'opinion', 'feel about'],
+  emotional_venting: ['气', '烦', '难过', '伤心', '失望', '抱怨', '吐槽', '不爽', 'frustrated', 'annoyed'],
+  request_comfort: ['安慰', '抱抱', '你好', 'hello', 'hi', 'hey'],
+  clarification: ['不懂', '什么意思', '解释', 'explain', 'clarify', '不明白'],
+  goodbye: ['再见', '拜拜', 'bye', '结束', 'done'],
+};
+
+/**
+ * 深层意图关键词
+ */
+const DEEP_INTENT_KEYWORDS: Record<string, string[]> = {
+  seek_control: ['控制', '掌握', 'manage', 'control', '搞定', 'handle', '安排'],
+  seek_acceptance: ['对不对', '可以吗', '是不是', '好不好', 'ok', 'right', 'correct', 'approve'],
+  seek_connection: ['在乎', '关心', '懂', '理解', 'understand', 'care', 'connect'],
+  seek_growth: ['进步', '成长', '学习', '提升', 'improve', 'grow', 'learn', '升级'],
+  seek_relief: ['压力', '焦虑', '难受', 'help', 'stop', '缓解', 'release', 'relief'],
+  seek_recognition: ['对', '厉害', '棒', '牛', 'good', 'great', 'impressive', '承认'],
+};
+
+/**
+ * 马斯洛需求关键词
+ */
+const NEEDS_KEYWORDS: Record<string, { keywords: string[]; level: string }> = {
+  physiological: {
+    keywords: ['累', '困', '饿', '渴', '痛', '不舒服', 'tired', 'sleepy', 'hungry', 'thirsty', 'pain'],
+    level: 'physiological'
+  },
+  safety: {
+    keywords: ['安全', '保障', '稳定', '放心', '可靠', 'safe', 'secure', 'stable', 'reliable'],
+    level: 'safety'
+  },
+  belonging: {
+    keywords: ['孤单', '寂寞', '想聊天', '朋友', '团队', '归属', 'alone', 'lonely', 'friend', 'belong'],
+    level: 'belonging'
+  },
+  esteem: {
+    keywords: ['厉害', '棒', '成功', '证明', '认可', '尊重', 'great', 'success', 'prove', 'respect', 'recognition'],
+    level: 'esteem'
+  },
+  self_actualization: {
+    keywords: ['成长', '意义', '价值', '目标', '人生', 'grow', 'meaning', 'purpose', 'goal', 'actualize'],
+    level: 'self_actualization'
+  },
+};
+
+/**
+ * 防御机制关键词
+ */
+const DEFENSE_PATTERNS: Array<{
+  type: string;
+  patterns: RegExp[];
+  evidence: string[];
+}> = [
+  {
+    type: 'denial',
+    patterns: [/我不在乎/i, /无所谓/i, /不在意/i, /没关系/i, /not care/i, /don't matter/i],
+    evidence: ['说"不在乎"时往往恰好在乎', '否认是承认的变体']
+  },
+  {
+    type: 'displacement',
+    patterns: [/抱怨A.*实际.*B/i, /转移.*话题/i],
+    evidence: ['用A抱怨B', '话题转移']
+  },
+  {
+    type: 'rationalization',
+    patterns: [/因为.*所以/i, /合理.*理由/i, /只不过是/i, /just.*because/i, /reason.*is/i],
+    evidence: ['提供合理化解释', '用逻辑掩盖情绪']
+  },
+  {
+    type: 'projection',
+    patterns: [/你就是.*(问题|错)/i, /你才.*吧/i, /你才.*呢/i],
+    evidence: ['指责对方的问题', '投射自己的问题']
+  },
+  {
+    type: 'reaction_formation',
+    patterns: [/极度.*热情/i, /太.*积极/i, /too.*eager/i, /overly.*nice/i],
+    evidence: ['过度热情', '反向形成掩盖其他情绪']
+  },
+  {
+    type: 'suppression',
+    patterns: [/不想说/i, /别提了/i, /算了/i, /don't want to talk/i, /forget it/i, /never mind/i],
+    evidence: ['回避话题', '压抑关键点']
+  },
+];
+
+/**
+ * 检测表面意图
+ */
+function detectSurfaceIntent(text: string): { intent: string; confidence: number } {
+  const lower = text.toLowerCase();
+  let best: { intent: string; confidence: number } = { intent: 'unknown', confidence: 0 };
+  
+  for (const [intent, keywords] of Object.entries(SURFACE_INTENT_KEYWORDS)) {
+    for (const kw of keywords) {
+      if (lower.includes(kw.toLowerCase())) {
+        const c = keywords.length / (keywords.indexOf(kw) + 1) * 0.3;
+        if (c > best.confidence) {
+          best = { intent, confidence: Math.min(0.9, c + 0.3) };
+        }
+      }
+    }
+  }
+  
+  // 默认推断
+  if (best.confidence < 0.3) {
+    best = { intent: 'request_action', confidence: 0.5 };
+  }
+  
+  return best;
+}
+
+/**
+ * 检测深层意图
+ */
+function detectDeepIntent(text: string): { intent: string; confidence: number } {
+  const lower = text.toLowerCase();
+  let best: { intent: string; confidence: number } = { intent: 'unknown', confidence: 0 };
+  
+  for (const [intent, keywords] of Object.entries(DEEP_INTENT_KEYWORDS)) {
+    for (const kw of keywords) {
+      if (lower.includes(kw.toLowerCase())) {
+        const c = 0.4 + Math.random() * 0.3;
+        if (c > best.confidence) {
+          best = { intent, confidence: Math.min(0.85, c) };
+        }
+      }
+    }
+  }
+  
+  return best;
+}
+
+/**
+ * 检测马斯洛需求层次
+ */
+function detectNeeds(text: string): { level: string; satisfied: boolean; description: string; confidence: number } {
+  const lower = text.toLowerCase();
+  
+  for (const [need, config] of Object.entries(NEEDS_KEYWORDS)) {
+    for (const kw of config.keywords) {
+      if (lower.includes(kw.toLowerCase())) {
+        return {
+          level: config.level,
+          satisfied: false,
+          description: `需求未满足：${kw}`,
+          confidence: 0.7 + Math.random() * 0.15
+        };
+      }
+    }
+  }
+  
+  // 默认基础层
+  return {
+    level: 'cognitive',
+    satisfied: true,
+    description: '认知需求：理解、解答、探索',
+    confidence: 0.5
+  };
+}
+
+/**
+ * 检测防御机制
+ */
+function detectDefenses(text: string): { detected: boolean; types: string[]; evidence: string[]; confidence: number } {
+  const matched: string[] = [];
+  const evidence: string[] = [];
+  
+  for (const defense of DEFENSE_PATTERNS) {
+    for (const pattern of defense.patterns) {
+      if (pattern.test(text)) {
+        matched.push(defense.type);
+        evidence.push(...defense.evidence.slice(0, 1));
+      }
+    }
+  }
+  
+  // 检测矛盾句式
+  if (/但是.*不过|虽然.*但是/i.test(text) && text.length < 50) {
+    matched.push('conflict_suppression');
+    evidence.push('短句中存在转折但未表达真实冲突');
+  }
+  
+  return {
+    detected: matched.length > 0,
+    types: [...new Set(matched)],
+    evidence,
+    confidence: matched.length > 0 ? 0.6 + matched.length * 0.1 : 0
+  };
+}
+
+/**
+ * 综合判断心理优先级
+ */
+function determinePriority(intention: PsychologyResult['intention'], emotion: PsychologyResult['emotion'], needs: PsychologyResult['needs'], defense: PsychologyResult['defense']): 'high' | 'medium' | 'low' {
+  // 有防御机制 → 高优先级
+  if (defense.detected && defense.confidence > 0.7) return 'high';
+  // 情绪强度高 → 高优先级
+  if (emotion.intensity > 0.7) return 'high';
+  // 需求未满足 → 高优先级
+  if (!needs.satisfied && needs.confidence > 0.7) return 'high';
+  // 表面深层不一致 → 中高优先级
+  if (!intention.surfaceDeepMatch && intention.confidence > 0.6) return 'medium';
+  // 默认低优先级
+  return 'low';
+}
+
+/**
+ * 四层心理感知主函数
+ */
+export function perceive(text: string, emotionResult?: EmotionEngineResult): PsychologyResult {
+  // 第一层：意图
+  const surface = detectSurfaceIntent(text);
+  const deep = detectDeepIntent(text);
+  
+  // 第二层：情绪（复用 emotion engine 结果或默认）
+  const emotion = emotionResult ? {
+    type: emotionResult.emotion,
+    intensity: emotionResult.intensity,
+    valence: emotionResult.dimensions.valence,
+    arousal: emotionResult.dimensions.arousal,
+    dominance: emotionResult.dimensions.dominance,
+  } : {
+    type: 'neutral',
+    intensity: 0.1,
+    valence: 0,
+    arousal: 0.3,
+    dominance: 0.5,
+  };
+  
+  // 第三层：需求
+  const needs = detectNeeds(text);
+  
+  // 第四层：防御
+  const defense = detectDefenses(text);
+  
+  // 综合判断
+  const surfaceDeepMatch = surface.intent === deep.intent || deep.confidence < 0.4;
+  
+  const intention = {
+    surface: surface.intent,
+    deep: deep.intent,
+    confidence: Math.min(surface.confidence, deep.confidence),
+    surfaceDeepMatch,
+  };
+  
+  const priority = determinePriority(intention, emotion, needs, defense);
+  
+  // 生成一句话总结
+  let summary = `表面意图=${surface.intent}`;
+  if (!surfaceDeepMatch) summary += `，深层意图=${deep.intent}`;
+  if (emotion.intensity > 0.5) summary += `，情绪=${emotion.type}(${(emotion.intensity * 100).toFixed(0)}%)`;
+  if (defense.detected) summary += `，防御=${defense.types.join('/')}`;
+  if (!needs.satisfied) summary += `，需求未满足=${needs.level}`;
+  
+  return {
+    intention,
+    emotion,
+    needs,
+    defense,
+    summary,
+    priority,
+  };
+}
+
+/**
+ * 创建 PsychologyPerception 实例（供 HeartFlow 引擎使用）
+ */
+export function createPsychologyPerception() {
+  return {
+    perceive,
+  };
+}
+
+export type { EmotionEngineResult };