@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/papers/v11_43_2_integration.js

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

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