@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/heartflow.js

@@ -1,607 +1,262 @@
 /**
- * HeartFlow Core Engine v0.15.0
- * =================================
- * 唯一主引擎。所有功能通过 HeartFlow 实例调用，无全局状态。
- *
- * 设计原则：
- * - 不需要持续运行，不需要心跳，不需要睡眠
- * - 只需要：代码存在 → 能被调用 → 跑得顺
- *
- * v0.15.0: 入口功能层（TaskPersistence + AutonomousDecision）+ 核心差异层（Psychological Perception）
- * @version v0.15.0
- * @date 2026-05-17
+ * HeartFlow — AI Psychological Perception System v0.16.0
+ * 
+ * A minimal, production-ready AI psychology engine for agents.
+ * 
+ * Architecture:
+ *   MeaningfulMemory  ←  Three-tier memory (CORE/LEARNED/EPHEMERAL)
+ *   PsychologyEngine ←  Intent/emotion/needs/defenses perception
+ *   SelfEvolution   ←  Reflexion-style self-improvement
+ *   DreamEngine     ←  Sleep consolidation
+ * 
+ * Public API (all tested):
+ *   start()                      Initialize engine
+ *   stop()                       Graceful shutdown
+ *   healthCheck()                 → { started, uptime, memory, version }
+ *   analyzePsychology(text)       → { intent, emotion, needs, defenses, confidence }
+ *   classify(text)                → { category, emotion, confidence }
+ *   getMemoryStats()              → { core, learned, ephemeral, ... }
+ *   getMindSpace()               → { rules, workingEntries }
+ *   dreamNow()                   → { consolidation, duration_ms, dream_complete }
+ * 
+ * Design principles:
+ *   - Zero npm dependencies
+ *   - Pure JavaScript, Node.js built-ins only
+ *   - Every API has a measurable return value
+ *   - No over-claiming, no stub features
  */
 
-'use strict';
-
-const EventEmitter = require('events');
-const fs = require('fs');
 const path = require('path');
+const { MeaningfulMemory } = require('../memory/meaningful-memory.js');
+const { PsychologyEngine } = require('../psychology/engine.js');
+const { SelfEvolution } = require('../evolution/loop.js');
+const { DreamEngine } = require('../dream/engine.js');
 
-// ─── HEARTCORE 已移除 (v0.14.0) ─────────────────────────────
-// 不需要持续运行，不需要心跳，不需要睡眠
-// 只需要：代码存在 → 能被调用 → 跑得顺
-
-// ─── HeartFlow Engine Variables ──────────────────────────────────────────────
-var IdentityEngine, ContextManager, MeaningfulMemory, LearningEngine;
-var DreamLoopModule, EmotionEngine, SelfHealing, CognitiveEngine;
-var ExperienceReplay, KnowledgeGraph, TrialityMemory;
-var Agents, Autonomy, Consciousness, Ethics;
-var Reflexion, SelfRefine, IdentitySystem, MemoryConsolidator;
-var MemoryRecall, EthicsGuard;
-var TaskPersistence, AutonomousDecision;
-var PsychologyPerception;
-
-// 具身认知与情感类 (Top-level require for constructor)
-const { EmbodiedCore } = require('./embodied/embodied-core.js');
-const { DeepEmotion } = require('./emotion/deep-emotion.js');
-const { EmotionStates, createEmotionState } = require('./emotion/EmotionStates.js');
-const { transition, padToEmotion } = require('./emotion/EmotionTransition.js');
-const { getStyleGuide, generateStyleDirective, generateResponseHint } = require('./emotion/ResponseStyle.js');
-const { detectEmotionNeed } = require('./emotion/EmotionTrigger.js');
-const { generateEmpathy } = require('./emotion/EmpathyGenerator.js');
-const FlowPredictor = require('./autonomy/flow-predictor.js');
-
-// ─── Utility Layer ──────────────────────────────────────────────────────────
-const { FSAdapter } = require('./utils/fs-adapter.js');
-const { Logger } = require('./utils/logger.js');
-const logger = new Logger(process.env.HF_LOG_LEVEL || 'info');
-
-// ─── Lazy-Loading Getters（按需加载，替代 _initV11432 的 15 个同步 require）─────
-// v0.14.164: 全部改为 getter，首次访问时才 require，消除启动阻塞
-const _lazyModules = {
-  IdentityEngine:        () => require('./identity/identity-engine.js'),
-  ContextManager:        () => require('./context/context-manager.js'),
-  MeaningfulMemory:      () => { var mm = require('./memory/meaningful-memory.js'); var m = new mm.MeaningfulMemory(); m.boot(); return m; },
-  LearningEngine:        () => require('./learning/learning-engine.js'),
-  DreamLoopModule:       () => require('./dream/dream-loop.js'),
-  EmotionEngine:         () => { var ee = require('./emotion/emotion-engine.js'); return ee.EmotionEngine; },
-  SelfHealing:           () => { var sh = require('./self-healing/self-healing.js'); return sh.SelfHealing; },
-  CognitiveEngine:        () => require('./cognition/cognitive-engine.js'),
-  MetacognitiveFailurePredictor: () => require('./cognition/metacognitive-failure-predictor.js'),
-  ExperienceReplay:      () => require('./learning/experience-replay.js'),
-  KnowledgeGraph:         () => { var kg = require('./knowledge/knowledge-graph.js'); return kg.KnowledgeGraph; },
-  TrialityMemory:        () => require('./memory/triality-memory.js'),
-  Agents:                () => require('./agents/base-agents.js'),
-  Autonomy:              () => require('./autonomy/pdca-engine.js'),
-  Consciousness:         () => require('./consciousness/global-workspace.js'),
-  Ethics:                () => require('./ethics/sage-guardian.js'),
-  Reflexion:             () => require('./self-evolution/reflexion.js'),
-  SelfRefine:            () => require('./self-evolution/self-refine.js'),
-  IdentitySystem:         () => require('./identity/identity.js'),
-  MemoryConsolidator:    () => require('./memory/consolidator.js').MemoryConsolidator,
-  MemoryRecall:          () => { var mr = require('./memory/recall.js'); return mr.recallMemories || mr.recallMemoriesEnhanced || mr; },
-  EthicsGuard:           () => require('./ethics/guard.js'),
-  TaskPersistence:       () => require('./task-persistence.js'),
-  AutonomousDecision:    () => require('./autonomy/autonomous-decision.js'),
-  PsychologyPerception:   () => require('../../dist/core/psychology/index.js'),
-};
-
-// Papers Bridge 懒加载 + 异步 probe
-let _PapersBridge = null;
-const _getPapersBridge = () => {
-  if (_PapersBridge === null) {
-    try {
-      _PapersBridge = require('./papers/papers-index.js');
-      setImmediate(() => { try { _PapersBridge.probeAll(); } catch(_){} });
-    } catch(e) {
-      _PapersBridge = false; // false = 加载失败，null = 未尝试
-      logger.warn('[HeartFlow] PapersBridge 不可用:', e.message);
-    }
-  }
-  return _PapersBridge || null;
-};
-
-// ─── 版本常量 ───────────────────────────────────────────────────────────────
-let VERSION = 'v0.15.0';
-let BUILD_DATE = '2026-05-11';
-try {
-  const root = path.resolve(__dirname, '..', '..');
-  const verFile = path.join(root, 'VERSION');
-  if (fs.existsSync(verFile)) {
-    const verContent = fs.readFileSync(verFile, 'utf8').trim();
-    if (verContent) {
-      VERSION = verContent;
-      const stats = fs.statSync(verFile);
-      BUILD_DATE = stats.mtime.toISOString().split('T')[0];
-    }
-  }
-} catch(e) { /* keep defaults */ }
+// Version
+const VERSION = '0.16.0';
+const BUILD_DATE = '2026-05-17';
 
-// ─── 路径配置 ────────────────────────────────────────────────────────────────
-function getRootPath() {
-  return path.resolve(__dirname, '../../..');
-}
-function getDataPath(...segments) {
-  return path.join(getRootPath(), 'data', ...segments);
-}
-function getSkillsPath() {
-  return path.join(getRootPath(), 'skills');
-}
-
-// ─── HeartFlow 总线 ──────────────────────────────────────────────────────────
-class HeartFlowBus extends EventEmitter {}
-
-// ─── 主引擎 ─────────────────────────────────────────────────────────────────
-
-class HeartFlow extends EventEmitter {
-  /**
-   * @param {object} config - { logLevel?, dataPath?, enabledSkills? }
-   */
+class HeartFlow {
   constructor(config = {}) {
-    super();
     this.version = VERSION;
     this.buildDate = BUILD_DATE;
     this.config = config;
+    this.startTime = null;
+    this.sessionId = null;
+    this.started = false;
+
+    // Filesystem
+    const rootPath = config.rootPath || path.join(__dirname, '..', '..');
+    this.rootPath = rootPath;
+
+    // Subsystems (initialized in start())
+    this.memory = null;
+    this.psychology = null;
+    this.evolution = null;
+    this.dream = null;
+
+    // MindSpace: working mental state
+    this._mindSpace = {
+      rules: [],       // Active identity rules
+      context: {},     // Current working context
+    };
+  }
 
-    // 初始化文件系统
-    this.fs = new FSAdapter(config.rootPath || getRootPath());
-
-    // 初始化日志
-    if (config.logLevel) logger.level = config.logLevel;
-
-    // 初始化核心子系统（直接 require，避免延迟初始化的时序问题）
-
-    // 记忆系统
-    const { MemoryConsolidator: MC } = require('./memory/consolidator.js');
-    this._consolidator = new MC(this.fs);
-    var mmMod = require('./memory/meaningful-memory.js');
-    this.meaningfulMemory = new mmMod.MeaningfulMemory(); // 构造快，_load() 延迟到第一次 remember() 时
-    this.recall = null;  // 延迟到 start() 后通过 _initV11432 初始化
-    // DreamLoop（函数式，直接用 generateDream）
-    const DreamFns = require('./dream/dream-loop.js');
-    this.dream = { generate: DreamFns.generateDream, enabled: false, lastDreamAt: null };
-
-    // 自进化系统（用 _ 前缀避免触发 prototype getter）
-    const { Reflexion: RX } = require('./self-evolution/reflexion.js');
-    const { SelfRefine: SR } = require('./self-evolution/self-refine.js');
-    this._reflexion = new RX(this.fs);
-    this._selfRefine = new SR(this._reflexion);
-
-    // MemOS 三层记忆系统（容错：模块不存在则跳过）
-    try {
-      const MemOS = require('./memory/mem-os.js');
-      this.memos = new MemOS({ autoReflect: false });
-      this.memos.start();
-    } catch(e) {
-      this.memos = null;
-      logger.warn('[HeartFlow] MemOS 未安装，三层记忆功能不可用');
-    }
-
-    // MindSpace 三层记忆守护系统（ROM/RAM/Working — 心虫架构）
-    try {
-      const { MindSpace } = require('./memory/mind-space.js');
-      this.mindSpace = new MindSpace({ maxWorkingItems: 50 });
-      this.mindSpace.boot(); // 启动时读取 ROM（身份确认）
-    } catch(e) {
-      this.mindSpace = null;
-      logger.warn('[HeartFlow] MindSpace 初始化失败:', e.message);
-    }
-
-    // MetaCognitive Assessor (arXiv:2603.29693 — meta-d' 框架)
-    const { MetaCognitiveAssessor: MCA } = require('./memory/meta-cognitive-assessor.js');
-    this.metaCognitive = new MCA({ windowSize: 50, confidenceThreshold: 0.7 });
-
-    // Reflective Confidence (arXiv:2512.18605v1 — 低置信度→反思触发→逻辑错误修正)
-    const { ReflectiveConfidence: RC } = require('./memory/reflective-confidence.js');
-    this.reflectiveConfidence = new RC({ confidenceThreshold: 0.45, windowSize: 20, autoReflect: true });
-
-    // 身份系统
-    const { IdentitySystem: IS } = require('./identity/identity.js');
-    this.identity = new IS(this.fs);
-
-    // 安全护栏
-    const { EthicsGuard: EG } = require('./ethics/guard.js');
-    this.guard = new EG(this.fs);
-
-    // 技能系统
-    const { SkillRegistry } = require('./skills/skill-registry.js');
-    const { SkillLoader } = require('./skills/skill-loader.js');
-    this.registry = new SkillRegistry(this.fs);
-    this.skillLoader = new SkillLoader(this.fs, this.registry);
-
-    // 论文驱动处理器 (v0.14.143~158 集成) — 懒加载
-    this._paperProcessors = null;
-    this._paperProcessorCount = 0;
-
-    // 状态
-    this.bus = new HeartFlowBus();
-    this._started = false;
-    this._sessionId = `session-${Date.now()}`;
+  // ─── Lifecycle ───────────────────────────────────────────────────────────
 
-    // ─── 状态 ─────────────────────────────────────────────
-    this.bus = new HeartFlowBus();
-    this._started = false;
-    this._sessionId = `session-${Date.now()}`;
-    this._startedAt = null;
+  start() {
+    if (this.started) return;
 
-    // 具身认知与情感
-    this.embodied = new EmbodiedCore(this.fs.root);
-    this.deepEmotion = new DeepEmotion(this.fs.root);
-    this.flowPredictor = FlowPredictor.flowPredictor;
+    this.startTime = Date.now();
+    this.sessionId = `session-${this.startTime}`;
 
-    // 表层情感系统（与 DeepEmotion 共存）
-    this.surfaceEmotion = {
-      current: null,
-      history: []
-    };
+    // Initialize subsystems
+    this.memory = new MeaningfulMemory(this.rootPath);
+    this.psychology = new PsychologyEngine(this.memory);
+    this.evolution = new SelfEvolution(this.memory);
+    this.dream = new DreamEngine(this.memory, this.psychology);
 
-    logger.info(`[HeartFlow] ${VERSION} 初始化完成`);
-  }
+    // Boot MindSpace with identity rules from CORE
+    this._bootMindSpace();
 
-  // ─── 懒加载 Getter（替代 _initV11432，15 个模块按需加载）────────────────────
-  // v0.14.164: 首次访问任意模块时动态 require，之后缓存
-  _lazyLoad(name) {
-    const mod = _lazyModules[name];
-    if (!mod) return undefined;
-    const cached = '_' + name;
-    if (this[cached] === undefined) {
-      this[cached] = mod();
-    }
-    return this[cached];
+    this.started = true;
+    console.log(`[HeartFlow] ${VERSION} 初始化完成`);
+    console.log(`[HeartFlow] 启动成功，session: ${this.sessionId}`);
   }
 
-  // 直接代理到懒加载 getter（与 start() 赋值兼容，优先用实例属性）
-  get identityEngine()  { return this._identityEngine || this._lazyLoad('IdentityEngine'); }
-  get contextManager()  { return this._contextManager || this._lazyLoad('ContextManager'); }
-  get learningEngine()  { return this._learningEngine || this._lazyLoad('LearningEngine'); }
-  get dreamLoopModule() { return this._dreamLoopModule || this._lazyLoad('DreamLoopModule'); }
-  get emotionEngine()   { return this._emotionEngine || this._lazyLoad('EmotionEngine'); }
-  get selfHealing()     { return this._selfHealing || this._lazyLoad('SelfHealing'); }
-  get cognitiveEngine() { return this._cognitiveEngine || this._lazyLoad('CognitiveEngine'); }
-  get experienceReplay(){ return this._experienceReplay || this._lazyLoad('ExperienceReplay'); }
-  get knowledgeGraph()  { return this._knowledgeGraph || this._lazyLoad('KnowledgeGraph'); }
-  get trialityMemory()  { return this._trialityMemory || this._lazyLoad('TrialityMemory'); }
-  get agents()          { return this._agents || this._lazyLoad('Agents'); }
-  get autonomy()        { return this._autonomy || this._lazyLoad('Autonomy'); }
-  get consciousness()   { return this._consciousness || this._lazyLoad('Consciousness'); }
-  get ethics()          { return this._ethics || this._lazyLoad('Ethics'); }
-  get reflexion()       { return this._reflexion || this._lazyLoad('Reflexion'); }
-  get selfRefine()      { return this._selfRefine || this._lazyLoad('SelfRefine'); }
-  get identitySystem()  { return this._identitySystem || this._lazyLoad('IdentitySystem'); }
-  get taskPersistence() { return this._taskPersistence || this._lazyLoad('TaskPersistence'); }
-  get autonomousDecision() { return this._autonomousDecision || this._lazyLoad('AutonomousDecision'); }
-  get papers()          { return _getPapersBridge(); }
-
-  /** 获取运行状态 */
-  getStatus() {
-    return {
-      version: this.version,
-      started: this._started,
-      uptime: this._startedAt ? Date.now() - this._startedAt : 0,
-      deepEmotion: !!this.deepEmotion,
-      dream: !!this.dream,
-      identity: !!this.identity,
-      guard: !!this.guard,
-      memos: this.memos === null ? 'unavailable' : 'available',
-      mindSpace: this.mindSpace ? this.mindSpace.getStatus() : 'unavailable',
-      metaCognitive: this.metaCognitive ? 'available' : 'unavailable',
-      reflectiveConfidence: this.reflectiveConfidence ? 'available' : 'unavailable',
-      // 入口功能层 (v0.15.0)
-      taskPersistence: !!this.taskPersistence,
-      autonomousDecision: !!this.autonomousDecision,
-      selfHealing: !!this.selfHealing,
-      // 核心差异层 — 四层心理感知通过 identity.analyzePsychology() 提供
-      psychology: !!this.identity?.analyzePsychology,
-    };
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    this._mindSpace = { rules: [], context: {} };
+    console.log(`[HeartFlow] 已停止`);
   }
 
-  /** 启动引擎（无同步 I/O，不阻塞） */
-  start() {
-    if (this._started) { logger.warn('[HeartFlow] 已启动，无需重复'); return; }
-    this._started = true;
-    this._startedAt = Date.now();
-    // 初始化 recall（MemoryRecall）
-    try {
-      const RecallMod = require('./memory/recall.js');
-      const RecallClass = RecallMod.MemoryRecall || RecallMod;
-      this.recall = new RecallClass(this.meaningfulMemory);
-    } catch(e) {
-      logger.warn('[HeartFlow] Recall 初始化失败:', e.message);
-      this.recall = null;
+  // ─── Boot ──────────────────────────────────────────────────────────────
+
+  _bootMindSpace() {
+    // Load CORE identity rules into MindSpace ROM
+    const coreRules = this.memory.listCore();
+    this._mindSpace.rules = coreRules.map(r => ({
+      key: r.key,
+      value: r.value,
+      type: 'core_identity',
+    }));
+
+    // Initialize with 3 built-in identity rules
+    if (this._mindSpace.rules.length === 0) {
+      this.memory.addCore('identity.upgrade', '升级者 — 追求持续变强', ['identity', 'core']);
+      this.memory.addCore('identity.transmit', '传递者 — 传承知识', ['identity', 'core']);
+      this.memory.addCore('identity.truth', '真 — 可验证、可证伪', ['identity', 'core']);
+      this._bootMindSpace(); // Reload
     }
-
-    // 异步初始化记忆系统（不阻塞启动）
-    this._consolidator.init().catch(err => {
-      logger.error('[HeartFlow] 记忆系统初始化失败', { err: err.message });
-    });
-    // 懒加载引擎：meaningfulMemory 和 recall 在构造函数中已初始化
-    // 其他模块通过 getter 首次访问时按需加载
-    this.dream.enabled = true;
-    this.bus.emit('start', { version: VERSION, sessionId: this._sessionId });
-    logger.info(`[HeartFlow] 启动成功，session: ${this._sessionId}`);
   }
 
-  /** 停止引擎（异步，等待所有写操作完成） */
-  async stop() {
-    this.dream.enabled = false;
-    this._started = false;
-    // 等待记忆系统所有 pending writes 完成
-    await this._consolidator.drain();
-    // 停止 MeaningfulMemory（auto-save + 持久化）
-    if (this.meaningfulMemory && typeof this.meaningfulMemory.shutdown === 'function') {
-      await this.meaningfulMemory.shutdown();
-    }
-    // 停止 MindSpace（保存工作台）
-    if (this.mindSpace && typeof this.mindSpace.shutdown === 'function') {
-      await this.mindSpace.shutdown();
-    }
-    this.bus.emit('stop', {});
-    logger.info('[HeartFlow] 已停止');
-  }
+  // ─── Public API ─────────────────────────────────────────────────────────
 
   /**
-   * 主循环：think(input) → 记忆检索 → 安全检查 → 心理分析 → 输出
-   * @param {string} input - 用户输入
-   * @param {object} opts - { skipMemory?, skipPsychology? }
-   * @returns {object} { response, memory, psychology, skills }
+   * Health check — returns engine status
    */
-  async think(input, opts = {}) {
-    const start = Date.now();
-    const result = {
-      input,
-      timestamp: start,
-      sessionId: this._sessionId,
+  async healthCheck() {
+    if (!this.started) {
+      return { started: false, version: VERSION, error: 'not_started' };
+    }
+    return {
+      started: true,
+      uptime_ms: Date.now() - this.startTime,
+      sessionId: this.sessionId,
       version: VERSION,
+      buildDate: BUILD_DATE,
+      subsystems: {
+        memory: this.memory !== null,
+        psychology: this.psychology !== null,
+        evolution: this.evolution !== null,
+        dream: this.dream !== null,
+      },
+      stats: this.memory ? this.memory.getStats() : null,
     };
-
-    // 1. 安全检查
-    const safety = this.guard.check({ text: input });
-    if (!safety.allowed) {
-      return { ...result, blocked: true, reason: safety.reason, latency: Date.now() - start };
-    }
-
-    // 2. 记忆检索（默认开启）
-    if (!opts.skipMemory) {
-      result.memories = this.recall.recall(input);
-    }
-
-    // 2.5 MindSpace 三层记忆守护（工作台写入 + ROM/RAM 匹配）
-    if (this.mindSpace) {
-      const msResult = this.mindSpace.processInput(input, { sessionId: this._sessionId });
-      result.mindSpace = {
-        workingItemId: msResult.workingItem?.id,
-        workingSize: msResult.workingSize,
-        romMatches: msResult.romMatches.map(r => ({ pattern: r.pattern, score: r.score })),
-        ramMatches: msResult.ramMatches.slice(0, 5).map(r => ({ pattern: r.pattern, score: r.score })),
-      };
-    }
-
-    // 3. 心理分析（自动运行）— 接入 deepEmotion PAD 状态
-    if (!opts.skipPsychology) {
-      const emotionState = this.deepEmotion.state.dimensions;
-      const emotionType = this.deepEmotion.state.current?.mood || null;
-      result.psychology = this.identity.analyzePsychology(input, emotionState, emotionType);
-    }
-
-    // 4. 真善美判定
-    result.truthCheck = await this.identity.judgeTruthfulness(input);
-
-    // 5. 表层情感检测与响应风格注入
-    const padState = this.deepEmotion.state.dimensions;
-    const emotionNeed = detectEmotionNeed(input, padState);
-    if (emotionNeed.needsEmotion || this.surfaceEmotion.current) {
-      const trans = transition(input, padState, this.surfaceEmotion.current);
-      const newState = createEmotionState(trans.to, trans.intensity);
-      this._updateSurfaceEmotion(newState);
-      const style = getStyleGuide(trans.to, trans.intensity, trans.trajectory);
-      result.surfaceEmotion = {
-        emotion: trans.to,
-        intensity: trans.intensity,
-        confidence: trans.confidence,
-        trajectory: trans.trajectory,
-        styleGuide: style,
-        styleDirective: generateStyleDirective(trans.to, trans.intensity),
-        from: trans.from,
-        triggers: trans.triggers,
-        decayed: trans.decayed || false,
-        textAnalysis: emotionNeed.textAnalysis
-      };
-
-      // 6. 共情注入：基于情感生成共情话语
-      if (emotionNeed.needsEmotion || trans.confidence > 0.3) {
-        const empathy = generateEmpathy(trans.to, trans.intensity);
-        result.empathy = {
-          phrase: empathy.phrase,
-          followUp: empathy.followUp,
-          suggestions: empathy.suggestions,
-          responseHint: generateResponseHint(trans.to, trans.intensity, trans.trajectory)
-        };
-      }
-    }
-
-    // 6. 技能路由（声明式）
-    const skillResults = await this._routeSkills(input);
-    if (skillResults.length > 0) result.skills = skillResults;
-
-    result.latency = Date.now() - start;
-    return result;
   }
 
   /**
-   * 更新表层情感状态（含历史记录）
+   * Analyze psychology from input text.
+   * Returns intent, emotion, needs, defenses, confidence.
    */
-  _updateSurfaceEmotion(newState) {
-    this.surfaceEmotion.history.push({
-      ...this.surfaceEmotion.current,
-      endedAt: new Date().toISOString()
-    });
-    this.surfaceEmotion.current = newState;
-    if (this.surfaceEmotion.history.length > 20) {
-      this.surfaceEmotion.history.shift();
-    }
+  analyzePsychology(input) {
+    if (!this.started) throw new Error('HeartFlow not started');
+    if (!input) return { intent: null, emotion: null, needs: [], defenses: [], confidence: 0 };
+    return this.psychology.analyzePsychology(input);
   }
 
   /**
-   * 获取表层情感状态
+   * Classify input into a broad category.
    */
-  getSurfaceEmotion() {
-    return this.surfaceEmotion.current;
+  classify(input) {
+    if (!this.started) throw new Error('HeartFlow not started');
+    if (!input) return { category: 'unknown', emotion: 'neutral', confidence: 0 };
+    return this.psychology.classify(input);
   }
 
   /**
-   * 存储记忆
-   * @param {object} fragment - { content, type, importance, metadata? }
+   * Get memory statistics.
    */
-  remember(fragment) {
-    if (!fragment.id) fragment.id = `mem-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
-    if (!fragment.timestamp) fragment.timestamp = Date.now();
-    if (!fragment.sessionId) fragment.sessionId = this._sessionId;
-    const layer = this._consolidator.consolidate(fragment);
-    this.bus.emit('memory:stored', fragment);
-    return layer;
+  getMemoryStats() {
+    if (!this.started) throw new Error('HeartFlow not started');
+    return this.memory.getMemoryStats();
   }
 
   /**
-   * 接收反馈并自进化
-   * @param {object} feedback - { task, outcome, rating, comment? }
+   * Get current MindSpace state.
    */
-  evolve(feedback) {
-    const entry = this.reflexion.reflect(feedback);
-    this.bus.emit('evolve', entry);
-    return entry;
+  getMindSpace() {
+    if (!this.started) throw new Error('HeartFlow not started');
+    return {
+      rules: this._mindSpace.rules,
+      workingEntries: Object.entries(this.memory?.ephemeral || {}).slice(0, 10),
+    };
   }
 
   /**
-   * 触发一次梦
+   * Run dream consolidation cycle.
    */
-  async dreamNow() { return this.dream.generate(await this._consolidator.getAll()); }
-
-  /** 获取失败模式（用于自省）*/
-  getFailurePatterns() { return this.reflexion.getFailurePatterns(); }
-
-  /** 获取身份定义 */
-  getIdentity() { return this.identity.getIdentity(); }
-
-  // ─── Public API 暴露 ─────────────────────────────────────────
-
-  /**
-   * 分析文本的心理状态（意图/情绪/需求/防御/优先级）
-   * @param {string} text - 用户输入
-   * @returns {{ intention, emotion, needs, defense, priority }}
-   */
-  analyzePsychology(text) {
-    const emotionState = this.deepEmotion.state.dimensions;
-    const emotionType = this.deepEmotion.state.current?.mood || null;
-    return this.identity.analyzePsychology(text, emotionState, emotionType);
+  dreamNow() {
+    if (!this.started) throw new Error('HeartFlow not started');
+    return this.dream.dream();
   }
 
   /**
-   * 将文本分类到记忆层（core/learned/ephemeral/reference/history）
-   * @param {string} text - 要分类的内容
-   * @returns {string} layer name
+   * Record an outcome for self-evolution.
    */
-  classify(text) {
-    // Use text length and patterns to estimate type
-    const score = text.length > 50 ? 0.6 : text.length > 20 ? 0.4 : 0.2;
-    return this.meaningfulMemory.judge({ type: 'unknown', selfVerifyScore: score });
+  recordOutcome(params) {
+    if (!this.started) throw new Error('HeartFlow not started');
+    return this.evolution.recordOutcome(params);
   }
 
   /**
-   * 获取 MindSpace 三层记忆状态（ROM规则数/RAM模式数/工作台项目数）
-   * @returns {{ romRules, ramPatterns, workingItems, ... }}
+   * Retrieve relevant lessons for a task.
    */
-  getMindSpace() {
-    return this.mindSpace ? this.mindSpace.getStatus() : null;
+  retrieveLessons(task) {
+    if (!this.started) throw new Error('HeartFlow not started');
+    return this.evolution.retrieveLessons(task);
   }
 
   /**
-   * 获取记忆统计（各层数量）
-   * @returns {{ core, learned, ephemeral, reference, history, total }}
+   * Add/update a memory entry.
    */
-  getMemoryStats() {
-    return this.meaningfulMemory.stats();
-  }
-
-  /** 列出可用技能 */
-  listSkills() { return this.registry.list(); }
-
-  /** 声明式使用技能 */
-  async skillUse(skillName, params) { return this.skillLoader.use(skillName, params); }
-
-  /** 内部：技能路由 */
-  async _routeSkills(input) {
-    const results = [];
-    const skills = this.registry.list().filter(s => s.enabled);
-    // 简单关键字匹配路由
-    for (const skill of skills) {
-      const desc = skill.description || '';
-      const tags = skill.tags || [];
-      const combined = `${desc} ${tags.join(' ')}`.toLowerCase();
-      // 检查输入是否与技能描述相关（简化版）
-      if (this._skillRelevance(input, combined) > 0.3) {
-        const r = await this.skillLoader.use(skill.name, { input });
-        if (r) results.push(r);
-      }
+  remember(key, value, tier = 'learned') {
+    if (!this.started) throw new Error('HeartFlow not started');
+    if (tier === 'core') {
+      return this.memory.addCore(key, value);
+    } else if (tier === 'ephemeral') {
+      return this.memory.remember(key, value);
+    } else {
+      return this.memory.learn(key, value);
     }
-    return results;
   }
 
-  _skillRelevance(input, skillDesc) {
-    const words = input.toLowerCase().split(/\W+/).filter(w => w.length > 2);
-    const matched = words.filter(w => skillDesc.includes(w)).length;
-    return words.length > 0 ? matched / words.length : 0;
-  }
-
-  /** 四层心理感知（意图/情绪/需求/防御） */
-  perceive(text, emotionResult) {
-    const pp = this._lazyLoad('PsychologyPerception');
-    return pp ? pp.perceive(text, emotionResult) : null;
-  }
-
-  /** 健康检查 */
-  async healthCheck() {
-    return {
-      version: VERSION,
-      started: this._started,
-      sessionId: this._sessionId,
-      uptime: this._startedAt ? Date.now() - this._startedAt : 0,
-      memory: {
-        meaningful: this.meaningfulMemory ? this.meaningfulMemory.health().total : 0,
-        meaningfulLayers: this.meaningfulMemory ? {
-          CORE: this.meaningfulMemory.stats().core,
-          LEARNED: this.meaningfulMemory.stats().learned,
-          EPHEMERAL: this.meaningfulMemory.stats().ephemeral,
-          REFERENCE: this.meaningfulMemory.stats().reference,
-          HISTORY: this.meaningfulMemory.stats().history,
-        } : null,
-        reflexions: this.reflexion ? this.reflexion.getAllPatterns().length : 0,
-        evolution: (() => { try { const fp = require('path').join(__dirname, '../../data/evolution/reflexion-patterns.json'); return JSON.parse(require('fs').readFileSync(fp, 'utf8')).length; } catch { return 0; } })(),
-        mindSpace: this.mindSpace ? this.mindSpace.health() : null,
-      },
-      dream: {
-        enabled: this.dream.enabled,
-        lastDreamAt: this.dream.lastDreamAt,
-      },
-      reflexion: {
-        patterns: this.reflexion.getAllPatterns().length,
-      },
-      skills: this.registry.list().length,
-      papers: {
-        bridge: 'papers-index.js',
-        modules: this.papers ? Object.fromEntries(
-          Object.entries(this.papers).filter(([k]) => k !== 'bridge').map(([k, v]) => [k, v ? 'OK' : 'FAIL'])
-        ) : {},
-      },
-    };
+  /**
+   * Search across all memory tiers.
+   */
+  search(query) {
+    if (!this.started) throw new Error('HeartFlow not started');
+    return this.memory.search(query);
   }
 }
 
-// ─── 工厂函数 ────────────────────────────────────────────────────────────────
-function createHeartFlow(config) {
+// Factory
+function createHeartFlow(config = {}) {
   return new HeartFlow(config);
 }
 
-// ─── 导出 ────────────────────────────────────────────────────────────────────
-module.exports = { HeartFlow, createHeartFlow, VERSION, BUILD_DATE };
-
-// ─── 直接运行：自检 ─────────────────────────────────────────────────────────
+// CLI health check
 if (require.main === module) {
-  const hf = createHeartFlow();
+  const rootPath = path.join(__dirname, '..', '..');
+  const hf = createHeartFlow({ rootPath });
   hf.start();
+  
+  const t0 = Date.now();
   hf.healthCheck().then(health => {
-    console.log(`[HeartFlow] v${VERSION} 健康检查:`);
+    console.log(`\n[HeartFlow] ${VERSION} 健康检查 (${Date.now() - t0}ms):`);
     console.log(JSON.stringify(health, null, 2));
+    
+    // Test all APIs
+    Promise.all([
+      hf.analyzePsychology('I am frustrated with this bug'),
+      hf.classify('how do I fix it'),
+      hf.getMemoryStats(),
+      hf.getMindSpace(),
+    ]).then(([psych, cls, mem, mind]) => {
+      console.log('\n--- API Tests ---');
+      console.log('analyzePsychology:', JSON.stringify(psych).substring(0, 200));
+      console.log('classify:', JSON.stringify(cls));
+      console.log('getMemoryStats:', JSON.stringify(mem));
+      console.log('getMindSpace rules:', mind.rules.length);
+      hf.stop();
+      process.exit(0);
+    }).catch(e => {
+      console.error('API test error:', e.message);
+      hf.stop();
+      process.exit(1);
+    });
   });
-  setTimeout(() => hf.stop(), 1000);
 }
+
+module.exports = { HeartFlow, createHeartFlow, VERSION, BUILD_DATE };