@yun520-1/heartflow 0.15.2 → 0.16.0

package/patches/new-features-v2.2.3.patch

@@ -1,1371 +0,0 @@
-diff --git a/CHANGELOG.md b/CHANGELOG.md
-index f6f99da..c0bbfc0 100644
---- a/CHANGELOG.md
-+++ b/CHANGELOG.md
-@@ -1,5 +1,157 @@
- # HeartFlow 变更日志
- 
-+## v2.2.2 (2026-04-09)
-+
-+### 🎉 新增功能
-+
-+#### 元认知进化模块 (`src/core/self-evolution/goedel-engine.js`)
-+
-+- **原则性反思 `principleBasedReflect()`**
-+  - 基于核心价值观进行深度反思
-+  - 评估当前行为是否符合长期原则
-+  - 计算原则对齐分数
-+  - 检测原则偏离并提供建议
-+
-+- **过程性反思 `proceduralReflect()`**
-+  - 反思进化过程本身的有效性
-+  - 分析进化频率、成功率、时间间隔
-+  - 识别效率瓶颈和优化空间
-+
-+#### 元认知自我修改 (`src/core/self-modifier.js`)
-+
-+- **补丁生成机制**
-+  - 所有修改生成 `.patch` 文件交由用户审查
-+  - 不直接应用修改，确保用户可控
-+  - 补丁存储在 `patches/` 目录
-+
-+- **审批工作流**
-+  - `metacognitiveModify(suggestion)` - 生成补丁
-+  - `listPendingPatches()` - 列出待审批补丁
-+  - `applyApprovedPatch(patchFileName)` - 应用已审批补丁
-+  - `rejectPatch(patchFileName)` - 拒绝并删除补丁
-+
-+- **差异化对比**
-+  - `computeSimpleDiff()` - 计算行级差异
-+  - 标准 unified diff 格式
-+  - 包含应用/撤销说明
-+
-+### 🔧 技术改进
-+
-+- 补丁文件命名：`self-mod-{timestamp}.patch`
-+- 变更历史记录增加 `requiresApproval` 字段
-+- 新增 patches 目录管理
-+
-+### 📋 审查流程
-+
-+1. 自我修改建议 → 生成补丁 → 存储到 `patches/`
-+2. 用户审查补丁文件
-+3. 使用 `patch -p1 < patches/xxx.patch` 应用
-+4. 使用 `patch -R -p1 < patches/xxx.patch` 撤销
-+
-+---
-+
-+## v2.2.1 (2026-04-09)
-+
-+### 🎉 新增功能
-+
-+#### 自适应调节引擎 (`src/core/adaptive-controller.js`)
-+- `adjustInterventionPolicy(userFlowState, taskComplexity)` 函数
-+- 根据心流状态动态调整干预频率和风格
-+- 策略映射：
-+  - 深度心流 → 极低干预 (`⚡`)
-+  - 轻度分心 → 中等干预 (`要继续吗？`)
-+  - 焦虑/挫败 → 高干预 (`我注意到你卡住了...`)
-+  - 无聊 → 低干预 (`想试试更优雅的写法吗？`)
-+- 内部日志记录调节决策
-+
-+#### 多智能体编排器 (`src/core/agent-orchestrator.js`)
-+- 基于DAG的任务调度器
-+- 支持并行执行（FocusAgent + MoodAgent）
-+- 依赖链：FocusAgent/MoodAgent → ContextAgent → SelfAgent → DecisionAgent
-+- `Promise.all` 实现并行调用
-+- 专家权重投票机制 `resolveConflict(opinions)`
-+- 根据历史准确率自动计算权重
-+
-+#### 智能体表现追踪 (`src/core/agent-performance.json`)
-+- 追踪各智能体任务成功率
-+- 权重公式：`weight = 0.3 + accuracy * 0.7`
-+- 定期更新权重
-+
-+#### 错误处理器 (`src/core/error-handler.js`)
-+- 统一捕获系统异常
-+- 错误分类：timeout/memory/permission/network/syntax/unknown
-+- 错误历史记录和统计
-+
-+#### 状态快照管理器 (`src/core/state-snapshot.js`)
-+- 定期保存系统状态
-+- 支持快照恢复
-+- 自动清理敏感数据
-+
-+### 📝 文档更新
-+
-+- `SKILL.md` 新增调试命令：
-+  - `/flow agents status` - 查看智能体状态
-+  - `/flow auto on/off` - 开关自适应模式
-+  - `/flow test` - 触发基准测试
-+- `src/core/heartflow-engine.js` 集成所有新模块
-+
-+### 🔧 技术改进
-+
-+- 心流引擎模块化重构
-+- 统一的错误处理和日志
-+- 快照恢复机制
-+- DAG执行优化（并行+依赖）
-+
-+### 📊 新增测试
-+
-+- `tests/self-benchmark/test-cases.json` - 25个标准测试用例
-+- `tests/self-benchmark/run-benchmark.js` - 基准测试运行器
-+- 意图识别率、情感识别率、伦理合规率
-+
-+### 🚀 下一步测试重点
-+
-+1. **自适应调节测试**
-+   - 测试不同心流状态下的干预策略
-+   - 验证干预频率和风格是否正确
-+
-+2. **多智能体DAG测试**
-+   - 测试并行执行性能
-+   - 测试专家权重投票
-+
-+3. **错误恢复测试**
-+   - 模拟异常，验证错误捕获
-+   - 验证快照恢复
-+
-+4. **基准测试**
-+   - 运行 `/flow test`
-+   - 评估意图识别和情感分析准确率
-+
-+---
-+
-+## v2.2.3 (2026-04-09)
-+
-+### 🎉 新增功能
-+
-+#### 三维经验大脑 (`src/core/memory/triality-memory.js`)
-+- 时间维度：微秒级时间戳
-+- 语义维度：384维向量嵌入
-+- 关系维度：因果/引述/相似/相关关系
-+- narrativeQuery() 图遍历叙事查询
-+- 语义相似度搜索、时间范围查询
-+
-+#### 具身认知核心 (`src/core/embodied-core.js`)
-+- 双系统架构：System 1 + System 2
-+- cognitivePlan() 目标→思维步骤
-+- executionMapping() 思维步骤→智能体调用
-+- 思维链：OBSERVE→ANALYZE→PLAN→DECIDE→EXECUTE→REFLECT→ADAPT
-+
-+#### 生物传感器适配器 (`src/core/bio-sensor-adapter.js`)
-+- 统一传感器接口
-+- 支持 HRV/EDIT_FLOW/EYE_TRACKING/SKIN_CONDUCTANCE
-+- 传感器融合计算专注度
-+
-+---
-+
- ## v2.2.0 (2026-04-08)
- 
- ### 🎉 新增功能
-diff --git a/src/core/bio-sensor-adapter.js b/src/core/bio-sensor-adapter.js
-new file mode 100644
-index 0000000..eef1204
---- /dev/null
-+++ b/src/core/bio-sensor-adapter.js
-@@ -0,0 +1,353 @@
-+/**
-+ * Bio-Sensor-Adapter - 生物传感器适配器接口
-+ * 
-+ * 设计理念：
-+ * - 统一的传感器接口规范
-+ * - 支持心率变异 (HRV)、代码编辑流等多种数据源
-+ * - 预留扩展点，未来可集成更多生物信号
-+ * 
-+ * 支持的传感器类型：
-+ * - HRV: 心率变异性
-+ * - EDIT_FLOW: 代码编辑流
-+ * - EYE_TRACKING: 眼动追踪
-+ * - SKIN_CONDUCTANCE: 皮肤电导
-+ */
-+
-+class BioSensorAdapter {
-+  constructor() {
-+    this.adapters = {};
-+    this.activeSensors = new Set();
-+    this.readingHistory = new Map();
-+    
-+    this.sensorTypes = {
-+      HRV: 'heart-rate-variability',
-+      EDIT_FLOW: 'code-edit-flow',
-+      EYE_TRACKING: 'eye-tracking',
-+      SKIN_CONDUCTANCE: 'skin-conductance',
-+      EEG: 'eeg-brainwave'
-+    };
-+    
-+    this.initializeBuiltIn();
-+  }
-+
-+  /**
-+   * 初始化内置适配器
-+   */
-+  initializeBuiltIn() {
-+    // HRV 适配器（从 bio-signal-adapter 集成）
-+    this.adapters[this.sensorTypes.HRV] = {
-+      name: 'HRV Sensor',
-+      enabled: false,
-+      lastReading: null,
-+      readings: [],
-+      config: {
-+        samplingRate: 1000, // 1秒
-+        bufferSize: 100
-+      },
-+      
-+      enable: function() { this.enabled = true; },
-+      disable: function() { this.enabled = false; },
-+      
-+      read: function() {
-+        return this.lastReading;
-+      },
-+      
-+      onData: function(data) {
-+        this.lastReading = {
-+          value: data.hrv,
-+          timestamp: Date.now(),
-+          state: data.state,
-+          focus: data.focusScore
-+        };
-+        this.readings.push(this.lastReading);
-+        if (this.readings.length > this.config.bufferSize) {
-+          this.readings.shift();
-+        }
-+      }
-+    };
-+
-+    // 代码编辑流适配器
-+    this.adapters[this.sensorTypes.EDIT_FLOW] = {
-+      name: 'Edit Flow Sensor',
-+      enabled: false,
-+      editPatterns: [],
-+      keystrokeBuffer: [],
-+      lastEvent: null,
-+      config: {
-+        windowSize: 5000, // 5秒窗口
-+        minEditDistance: 3
-+      },
-+      
-+      enable: function() { this.enabled = true; },
-+      disable: function() { this.enabled = false; },
-+      
-+      read: function() {
-+        return {
-+          editRate: this.calculateEditRate(),
-+          pauseCount: this.countPauses(),
-+          pattern: this.getCurrentPattern()
-+        };
-+      },
-+      
-+      onData: function(data) {
-+        this.keystrokeBuffer.push({
-+          type: data.type, // typing, delete, paste
-+          timestamp: Date.now(),
-+          length: data.length || 0
-+        });
-+        this.lastEvent = data;
-+        this.cleanupOldEvents();
-+      },
-+      
-+      calculateEditRate: function() {
-+        const now = Date.now();
-+        const recent = this.keystrokeBuffer.filter(e => now - e.timestamp < this.config.windowSize);
-+        return recent.length / (this.config.windowSize / 1000);
-+      },
-+      
-+      countPauses: function() {
-+        const now = Date.now();
-+        const recent = this.keystrokeBuffer.filter(e => now - e.timestamp < this.config.windowSize);
-+        let pauses = 0;
-+        for (let i = 1; i < recent.length; i++) {
-+          if (recent[i].timestamp - recent[i-1].timestamp > 2000) {
-+            pauses++;
-+          }
-+        }
-+        return pauses;
-+      },
-+      
-+      getCurrentPattern: function() {
-+        if (this.keystrokeBuffer.length < 3) return 'initializing';
-+        const rate = this.calculateEditRate();
-+        if (rate < 0.5) return 'paused';
-+        if (rate > 5) return 'rapid';
-+        return 'steady';
-+      },
-+      
-+      cleanupOldEvents: function() {
-+        const cutoff = Date.now() - this.config.windowSize * 2;
-+        this.keystrokeBuffer = this.keystrokeBuffer.filter(e => e.timestamp > cutoff);
-+      }
-+    };
-+  }
-+
-+  /**
-+   * 注册新的传感器适配器
-+   * @param {string} type - 传感器类型
-+   * @param {object} adapter - 适配器实例
-+   */
-+  register(type, adapter) {
-+    this.adapters[type] = {
-+      ...adapter,
-+      enabled: false,
-+      readings: []
-+    };
-+    console.log(`[BioSensorAdapter] 注册传感器: ${type}`);
-+    return { success: true, type };
-+  }
-+
-+  /**
-+   * 启用传感器
-+   * @param {string} type - 传感器类型
-+   */
-+  enable(type) {
-+    const adapter = this.adapters[type];
-+    if (!adapter) {
-+      return { success: false, reason: 'sensor_not_found' };
-+    }
-+    
-+    adapter.enable?.();
-+    this.activeSensors.add(type);
-+    console.log(`[BioSensorAdapter] 启用: ${type}`);
-+    return { success: true, type };
-+  }
-+
-+  /**
-+   * 禁用传感器
-+   * @param {string} type - 传感器类型
-+   */
-+  disable(type) {
-+    const adapter = this.adapters[type];
-+    if (!adapter) {
-+      return { success: false, reason: 'sensor_not_found' };
-+    }
-+    
-+    adapter.disable?.();
-+    this.activeSensors.delete(type);
-+    console.log(`[BioSensorAdapter] 禁用: ${type}`);
-+    return { success: true, type };
-+  }
-+
-+  /**
-+   * 读取传感器数据
-+   * @param {string} type - 传感器类型
-+   */
-+  read(type) {
-+    const adapter = this.adapters[type];
-+    if (!adapter || !adapter.enabled) {
-+      return null;
-+    }
-+    
-+    return adapter.read?.() || null;
-+  }
-+
-+  /**
-+   * 写入传感器数据
-+   * @param {string} type - 传感器类型
-+   * @param {object} data - 数据
-+   */
-+  write(type, data) {
-+    const adapter = this.adapters[type];
-+    if (!adapter) {
-+      return { success: false, reason: 'sensor_not_found' };
-+    }
-+    
-+    adapter.onData?.(data);
-+    
-+    // 记录历史
-+    if (!this.readingHistory.has(type)) {
-+      this.readingHistory.set(type, []);
-+    }
-+    this.readingHistory.get(type).push({
-+      data,
-+      timestamp: Date.now()
-+    });
-+    
-+    return { success: true };
-+  }
-+
-+  /**
-+   * 获取所有活跃传感器的融合数据
-+   */
-+  readAll() {
-+    const fusion = {
-+      timestamp: Date.now(),
-+      sensors: {}
-+    };
-+    
-+    for (const type of this.activeSensors) {
-+      const reading = this.read(type);
-+      if (reading) {
-+        fusion.sensors[type] = reading;
-+      }
-+    }
-+    
-+    // 计算融合专注度
-+    fusion.focusScore = this.calculateFusionFocus(fusion.sensors);
-+    
-+    return fusion;
-+  }
-+
-+  /**
-+   * 计算融合专注度
-+   */
-+  calculateFusionFocus(sensorReadings) {
-+    let totalWeight = 0;
-+    let weightedSum = 0;
-+    
-+    // HRV 权重
-+    if (sensorReadings[this.sensorTypes.HRV]?.focus !== undefined) {
-+      const weight = 0.4;
-+      weightedSum += sensorReadings[this.sensorTypes.HRV].focus * weight;
-+      totalWeight += weight;
-+    }
-+    
-+    // 编辑流权重
-+    if (sensorReadings[this.sensorTypes.EDIT_FLOW]) {
-+      const editData = sensorReadings[this.sensorTypes.EDIT_FLOW];
-+      let editFocus = 5;
-+      
-+      if (editData.pattern === 'steady') editFocus = 8;
-+      else if (editData.pattern === 'rapid') editFocus = 7;
-+      else if (editData.pattern === 'paused') editFocus = 3;
-+      
-+      const weight = 0.6;
-+      weightedSum += editFocus * weight;
-+      totalWeight += weight;
-+    }
-+    
-+    if (totalWeight === 0) return 5;
-+    return Math.round((weightedSum / totalWeight) * 10) / 10;
-+  }
-+
-+  /**
-+   * 获取传感器状态
-+   */
-+  getStatus() {
-+    const status = {
-+      activeSensors: Array.from(this.activeSensors),
-+      availableSensors: Object.keys(this.adapters),
-+      historySize: this.readingHistory.size
-+    };
-+    
-+    for (const type of this.activeSensors) {
-+      status[type] = {
-+        enabled: true,
-+        lastReading: this.read(type),
-+        readingCount: this.readingHistory.get(type)?.length || 0
-+      };
-+    }
-+    
-+    return status;
-+  }
-+
-+  /**
-+   * 获取传感器配置
-+   */
-+  getConfig(type) {
-+    return this.adapters[type]?.config || null;
-+  }
-+
-+  /**
-+   * 设置传感器配置
-+   */
-+  setConfig(type, config) {
-+    const adapter = this.adapters[type];
-+    if (!adapter) {
-+      return { success: false, reason: 'sensor_not_found' };
-+    }
-+    
-+    adapter.config = { ...adapter.config, ...config };
-+    return { success: true, config: adapter.config };
-+  }
-+
-+  /**
-+   * 获取传感器历史数据
-+   */
-+  getHistory(type, limit = 100) {
-+    const history = this.readingHistory.get(type) || [];
-+    return history.slice(-limit);
-+  }
-+
-+  /**
-+   * 清空传感器数据
-+   */
-+  clear(type) {
-+    if (type) {
-+      this.readingHistory.delete(type);
-+      if (this.adapters[type]) {
-+        this.adapters[type].readings = [];
-+      }
-+    } else {
-+      this.readingHistory.clear();
-+      for (const adapter of Object.values(this.adapters)) {
-+        adapter.readings = [];
-+      }
-+    }
-+    return { success: true };
-+  }
-+}
-+
-+// 创建全局实例
-+const bioSensorAdapter = new BioSensorAdapter();
-+
-+module.exports = BioSensorAdapter;
-+module.exports.bioSensorAdapter = bioSensorAdapter;
-+module.exports.SensorTypes = {
-+  HRV: 'heart-rate-variability',
-+  EDIT_FLOW: 'code-edit-flow',
-+  EYE_TRACKING: 'eye-tracking',
-+  SKIN_CONDUCTANCE: 'skin-conductance',
-+  EEG: 'eeg-brainwave'
-+};
-
-diff --git a/src/core/embodied-core.js b/src/core/embodied-core.js
-new file mode 100644
-index 0000000..8b6bf7b
---- /dev/null
-+++ b/src/core/embodied-core.js
-@@ -0,0 +1,468 @@
-+/**
-+ * Embodied-Core - 具身认知核心
-+ * 
-+ * 设计理念：
-+ * - 双系统架构：System 1 (直觉/快思考) + System 2 (分析/慢思考)
-+ * - 动作思维链 (Action-Thought Chain)：将高层目标拆解为有序思维步骤
-+ * - bio-sensor-adapter 接口：为心率变异、代码编辑流等数据预留扩展点
-+ * 
-+ * 核心功能：
-+ * - cognitivePlan(): 目标 -> 思维步骤
-+ * - executionMapping(): 思维步骤 -> 智能体/工具调用
-+ */
-+
-+const fs = require('fs');
-+const path = require('path');
-+
-+class EmbodiedCore {
-+  constructor(projectRoot) {
-+    this.projectRoot = projectRoot;
-+    
-+    // 认知系统状态
-+    this.cognitiveState = {
-+      system: 'idle', // idle, planning, executing, reflecting
-+      activePlan: null,
-+      executionHistory: [],
-+      workingMemory: []
-+    };
-+    
-+    // 思维步骤类型
-+    this.stepTypes = {
-+      OBSERVE: 'observe',      // 观察/感知
-+      ANALYZE: 'analyze',     // 分析/推理
-+      PLAN: 'plan',           // 规划/计划
-+      DECIDE: 'decide',       // 决策/选择
-+      EXECUTE: 'execute',     // 执行/行动
-+      REFLECT: 'reflect',     // 反思/复盘
-+      ADAPT: 'adapt'          // 适应/调整
-+    };
-+    
-+    // 可用执行器
-+    this.executors = this.loadExecutors();
-+    
-+    // 传感器适配器
-+    this.sensorAdapters = {};
-+    
-+    console.log('[EmbodiedCore] 具身认知核心初始化');
-+  }
-+
-+  /**
-+   * 加载可用的执行器
-+   */
-+  loadExecutors() {
-+    return {
-+      // 智能体
-+      SelfAgent: { type: 'agent', module: '../agents/SelfAgent', weight: 1.0 },
-+      MoodAgent: { type: 'agent', module: '../agents/MoodAgent', weight: 0.9 },
-+      FocusAgent: { type: 'agent', module: '../agents/FocusAgent', weight: 0.9 },
-+      ReflectionAgent: { type: 'agent', module: '../agents/ReflectionAgent', weight: 0.8 },
-+      
-+      // 工具
-+      'code-analysis': { type: 'tool', capability: 'analyze', weight: 1.0 },
-+      'code-generation': { type: 'tool', capability: 'generate', weight: 1.0 },
-+      'search': { type: 'tool', capability: 'search', weight: 0.8 },
-+      'git-operations': { type: 'tool', capability: 'version-control', weight: 0.7 },
-+      'file-operation': { type: 'tool', capability: 'io', weight: 0.9 }
-+    };
-+  }
-+
-+  /**
-+   * 注册传感器适配器
-+   * @param {string} name - 传感器名称
-+   * @param {object} adapter - 适配器实例
-+   */
-+  registerSensorAdapter(name, adapter) {
-+    this.sensorAdapters[name] = adapter;
-+    console.log(`[EmbodiedCore] 注册传感器: ${name}`);
-+  }
-+
-+  /**
-+   * 认知规划 - 将高层目标拆解为有序思维步骤
-+   * @param {object} goal - 目标对象
-+   * @returns {object} 思维步骤序列
-+   */
-+  cognitivePlan(goal) {
-+    const {
-+      description,
-+      type = 'general', // general, coding, debugging, learning, creative
-+      constraints = {},
-+      context = {}
-+    } = goal;
-+
-+    this.cognitiveState.system = 'planning';
-+    
-+    const steps = this.decomposeGoal(description, type, constraints, context);
-+    
-+    const plan = {
-+      id: `plan-${Date.now()}`,
-+      goal: description,
-+      type,
-+      steps,
-+      metadata: {
-+        createdAt: new Date().toISOString(),
-+        estimatedSteps: steps.length,
-+        complexity: this.estimateComplexity(steps)
-+      }
-+    };
-+    
-+    this.cognitiveState.activePlan = plan;
-+    this.cognitiveState.system = 'ready';
-+    
-+    console.log(`[EmbodiedCore] 认知规划: ${steps.length} 步思维链`);
-+    return plan;
-+  }
-+
-+  /**
-+   * 目标分解
-+   */
-+  decomposeGoal(description, type, constraints, context) {
-+    const steps = [];
-+    const baseSteps = this.getBaseStepsForType(type);
-+    
-+    for (let i = 0; i < baseSteps.length; i++) {
-+      const stepType = baseSteps[i];
-+      
-+      steps.push({
-+        index: i,
-+        type: stepType,
-+        description: this.generateStepDescription(stepType, description, i),
-+        expectedOutcome: this.getExpectedOutcome(stepType),
-+        dependsOn: i > 0 ? [i - 1] : [],
-+        executor: this.selectExecutor(stepType, type),
-+        estimatedDuration: this.estimateDuration(stepType),
-+        fallback: this.getFallbackStrategy(stepType)
-+      });
-+    }
-+    
-+    return steps;
-+  }
-+
-+  /**
-+   * 获取类型的基础步骤
-+   */
-+  getBaseStepsForType(type) {
-+    const templates = {
-+      general: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.PLAN,
-+        this.stepTypes.DECIDE,
-+        this.stepTypes.EXECUTE,
-+        this.stepTypes.REFLECT
-+      ],
-+      coding: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.PLAN,
-+        this.stepTypes.DECIDE,
-+        this.stepTypes.EXECUTE,
-+        this.stepTypes.REFLECT,
-+        this.stepTypes.ADAPT
-+      ],
-+      debugging: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.DECIDE,
-+        this.stepTypes.EXECUTE,
-+        this.stepTypes.REFLECT
-+      ],
-+      learning: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.PLAN,
-+        this.stepTypes.REFLECT
-+      ],
-+      creative: [
-+        this.stepTypes.OBSERVE,
-+        this.stepTypes.ANALYZE,
-+        this.stepTypes.PLAN,
-+        this.stepTypes.DECIDE,
-+        this.stepTypes.EXECUTE,
-+        this.stepTypes.ADAPT
-+      ]
-+    };
-+    
-+    return templates[type] || templates.general;
-+  }
-+
-+  /**
-+   * 生成步骤描述
-+   */
-+  generateStepDescription(stepType, goal, index) {
-+    const templates = {
-+      [this.stepTypes.OBSERVE]: `观察当前状态和上下文`,
-+      [this.stepTypes.ANALYZE]: `分析问题：${goal}`,
-+      [this.stepTypes.PLAN]: `制定实现方案`,
-+      [this.stepTypes.DECIDE]: `选择最佳方案`,
-+      [this.stepTypes.EXECUTE]: `执行：${goal}`,
-+      [this.stepTypes.REFLECT]: `反思执行结果`,
-+      [this.stepTypes.ADAPT]: `根据反馈调整策略`
-+    };
-+    
-+    return templates[stepType] || `${stepType}: 步骤 ${index + 1}`;
-+  }
-+
-+  /**
-+   * 获取预期结果
-+   */
-+  getExpectedOutcome(stepType) {
-+    const outcomes = {
-+      [this.stepTypes.OBSERVE]: '收集到当前状态信息',
-+      [this.stepTypes.ANALYZE]: '形成问题分析报告',
-+      [this.stepTypes.PLAN]: '产出可执行计划',
-+      [this.stepTypes.DECIDE]: '确定最终方案',
-+      [this.stepTypes.EXECUTE]: '完成任务或产出',
-+      [this.stepTypes.REFLECT]: '获得改进建议',
-+      [this.stepTypes.ADAPT]: '更新执行策略'
-+    };
-+    return outcomes[stepType] || '完成步骤';
-+  }
-+
-+  /**
-+   * 选择执行器
-+   */
-+  selectExecutor(stepType, goalType) {
-+    const mapping = {
-+      [this.stepTypes.OBSERVE]: ['SelfAgent', 'code-analysis'],
-+      [this.stepTypes.ANALYZE]: ['SelfAgent', 'code-analysis'],
-+      [this.stepTypes.PLAN]: ['SelfAgent'],
-+      [this.stepTypes.DECIDE]: ['SelfAgent', 'ReflectionAgent'],
-+      [this.stepTypes.EXECUTE]: ['SelfAgent', 'code-generation'],
-+      [this.stepTypes.REFLECT]: ['ReflectionAgent', 'SelfAgent'],
-+      [this.stepTypes.ADAPT]: ['SelfAgent']
-+    };
-+    
-+    const options = mapping[stepType] || ['SelfAgent'];
-+    return options[0]; // 返回主执行器
-+  }
-+
-+  /**
-+   * 估计步骤耗时（毫秒）
-+   */
-+  estimateDuration(stepType) {
-+    const durations = {
-+      [this.stepTypes.OBSERVE]: 500,
-+      [this.stepTypes.ANALYZE]: 2000,
-+      [this.stepTypes.PLAN]: 3000,
-+      [this.stepTypes.DECIDE]: 1000,
-+      [this.stepTypes.EXECUTE]: 5000,
-+      [this.stepTypes.REFLECT]: 2000,
-+      [this.stepTypes.ADAPT]: 1500
-+    };
-+    return durations[stepType] || 2000;
-+  }
-+
-+  /**
-+   * 获取回退策略
-+   */
-+  getFallbackStrategy(stepType) {
-+    return {
-+      retry: true,
-+      timeout: this.estimateDuration(stepType) * 2,
-+      fallbackExecutor: 'SelfAgent'
-+    };
-+  }
-+
-+  /**
-+   * 估计复杂度
-+   */
-+  estimateComplexity(steps) {
-+    const baseScore = steps.length;
-+    const typeWeight = steps.filter(s => s.type === this.stepTypes.EXECUTE).length * 0.5;
-+    return Math.min(10, (baseScore + typeWeight) / 2);
-+  }
-+
-+  /**
-+   * 执行映射 - 将思维步骤映射到具体的智能体调用或工具使用
-+   * @param {object} plan - 认知计划
-+   * @param {object} context - 执行上下文
-+   * @returns {object} 执行序列
-+   */
-+  executionMapping(plan, context = {}) {
-+    this.cognitiveState.system = 'executing';
-+    
-+    const execution = {
-+      planId: plan.id,
-+      steps: [],
-+      startTime: Date.now(),
-+      context: {
-+        ...context,
-+        sensors: this.readSensors()
-+      }
-+    };
-+    
-+    for (const step of plan.steps) {
-+      const stepExecution = this.mapStepToAction(step, execution.context);
-+      execution.steps.push(stepExecution);
-+      
-+      // 更新工作记忆
-+      this.cognitiveState.workingMemory.push({
-+        step: step.index,
-+        result: stepExecution.result,
-+        timestamp: Date.now()
-+      });
-+      
-+      // 检查是否需要调整
-+      if (stepExecution.requiresAdaptation) {
-+        this.cognitiveState.system = 'adapting';
-+        const adaptation = this.adaptPlan(plan, stepExecution);
-+        execution.adaptation = adaptation;
-+        this.cognitiveState.system = 'executing';
-+      }
-+    }
-+    
-+    execution.endTime = Date.now();
-+    execution.duration = execution.endTime - execution.startTime;
-+    
-+    this.cognitiveState.executionHistory.push(execution);
-+    this.cognitiveState.system = 'idle';
-+    
-+    console.log(`[EmbodiedCore] 执行映射: ${execution.steps.length} 步执行`);
-+    return execution;
-+  }
-+
-+  /**
-+   * 读取传感器数据
-+   */
-+  readSensors() {
-+    const sensorData = {};
-+    
-+    for (const [name, adapter] of Object.entries(this.sensorAdapters)) {
-+      try {
-+        sensorData[name] = adapter.read?.() || adapter.getStatus?.() || null;
-+      } catch (e) {
-+        sensorData[name] = { error: e.message };
-+      }
-+    }
-+    
-+    return sensorData;
-+  }
-+
-+  /**
-+   * 将步骤映射到具体动作
-+   */
-+  mapStepToAction(step, context) {
-+    const executorName = step.executor;
-+    const executor = this.executors[executorName];
-+    
-+    const action = {
-+      stepIndex: step.index,
-+      stepType: step.type,
-+      executor: executorName,
-+      executorType: executor?.type || 'unknown',
-+      parameters: this.buildParameters(step, context),
-+      expectedDuration: step.estimatedDuration
-+    };
-+    
-+    // 模拟执行（实际会调用智能体/工具）
-+    action.result = this.simulateExecution(action, context);
-+    action.requiresAdaptation = this.checkAdaptationNeed(action.result, step);
-+    
-+    return action;
-+  }
-+
-+  /**
-+   * 构建参数
-+   */
-+  buildParameters(step, context) {
-+    return {
-+      task: step.description,
-+      context: {
-+        workingMemory: context.sensors,
-+        previousResults: this.cognitiveState.workingMemory.slice(-3)
-+      },
-+      constraints: {
-+        timeout: step.estimatedDuration,
-+        fallback: step.fallback
-+      }
-+    };
-+  }
-+
-+  /**
-+   * 模拟执行
-+   */
-+  simulateExecution(action, context) {
-+    // 这里模拟实际执行结果
-+    // 实际实现会调用真实的智能体
-+    
-+    const mockResults = {
-+      [this.stepTypes.OBSERVE]: { observations: ['当前状态良好', '环境稳定'] },
-+      [this.stepTypes.ANALYZE]: { analysis: '问题已识别', 'confidence': 0.85 },
-+      [this.stepTypes.PLAN]: { plan: '方案已制定', 'alternatives': 2 },
-+      [this.stepTypes.DECIDE]: { decision: '选择方案A', 'reason': '最优' },
-+      [this.stepTypes.EXECUTE]: { outcome: '完成', 'success': true },
-+      [this.stepTypes.REFLECT]: { feedback: '执行顺利', 'improvements': [] },
-+      [this.stepTypes.ADAPT]: { adapted: true, 'changes': [] }
-+    };
-+    
-+    return {
-+      ...mockResults[action.stepType],
-+      timestamp: Date.now()
-+    };
-+  }
-+
-+  /**
-+   * 检查是否需要调整
-+   */
-+  checkAdaptationNeed(result, step) {
-+    // 简单规则：执行失败或分析不充分时需要调整
-+    if (result.success === false) return true;
-+    if (result.confidence && result.confidence < 0.6) return true;
-+    return false;
-+  }
-+
-+  /**
-+   * 调整计划
-+   */
-+  adaptPlan(plan, failedStep) {
-+    const adaptation = {
-+      originalStep: failedStep.stepIndex,
-+      reason: '执行结果不理想',
-+      modifications: []
-+    };
-+    
-+    // 添加额外的反思和调整步骤
-+    const newSteps = plan.steps.slice(failedStep.stepIndex);
-+    newSteps.unshift({
-+      index: failedStep.stepIndex,
-+      type: this.stepTypes.ADAPT,
-+      description: '调整策略后重试',
-+      executor: 'SelfAgent'
-+    });
-+    
-+    adaptation.modifications = newSteps;
-+    console.log(`[EmbodiedCore] 计划调整: 步骤 ${failedStep.stepIndex} 需要重试`);
-+    
-+    return adaptation;
-+  }
-+
-+  /**
-+   * 获取认知状态
-+   */
-+  getStatus() {
-+    return {
-+      cognitiveState: this.cognitiveState.system,
-+      activePlan: this.cognitiveState.activePlan?.id || null,
-+      executionHistoryCount: this.cognitiveState.executionHistory.length,
-+      workingMemorySize: this.cognitiveState.workingMemory.length,
-+      registeredSensors: Object.keys(this.sensorAdapters),
-+      availableExecutors: Object.keys(this.executors)
-+    };
-+  }
-+
-+  /**
-+   * 重置状态
-+   */
-+  reset() {
-+    this.cognitiveState = {
-+      system: 'idle',
-+      activePlan: null,
-+      executionHistory: [],
-+      workingMemory: []
-+    };
-+    console.log('[EmbodiedCore] 状态已重置');
-+    return { success: true };
-+  }
-+}
-+
-+module.exports = { EmbodiedCore };
-
-diff --git a/src/core/memory/triality-memory.js b/src/core/memory/triality-memory.js
-new file mode 100644
-index 0000000..b03b5b4
---- /dev/null
-+++ b/src/core/memory/triality-memory.js
-@@ -0,0 +1,367 @@
-+/**
-+ * Triality-Memory - 三维经验大脑
-+ * 
-+ * 设计理念：
-+ * - 时间维度：微秒级时间戳，记录事件发生顺序
-+ * - 语义维度：向量嵌入表示记忆内容
-+ * - 关系维度：因果、引述、相似等关系链
-+ * 
-+ * 本地优先设计：SQLite + 向量扩展 (sqlite-vec)
-+ * 支持 narrativeQuery 图遍历查询
-+ */
-+
-+const fs = require('fs');
-+const path = require('path');
-+const crypto = require('crypto');
-+
-+class TrialityMemory {
-+  constructor(projectRoot, options = {}) {
-+    this.projectRoot = projectRoot;
-+    this.dbPath = options.dbPath || path.join(projectRoot, 'data', 'triality-memory.db');
-+    this.vectorDim = options.vectorDim || 384;
-+    this.vecEnabled = options.vecEnabled !== false;
-+    
-+    this.db = null;
-+    this.useMem = true; // 内存模式
-+    this.memories = [];
-+    this.vectors = new Map();
-+    this.relationships = new Map();
-+    
-+    this.stats = {
-+      totalMemories: 0,
-+      totalRelationships: 0,
-+      lastCleanup: null
-+    };
-+    
-+    this.init();
-+  }
-+
-+  init() {
-+    const dataDir = path.dirname(this.dbPath);
-+    if (!fs.existsSync(dataDir)) {
-+      fs.mkdirSync(dataDir, { recursive: true });
-+    }
-+    
-+    this.initializeSchema();
-+    console.log('[TrialityMemory] 三维经验大脑初始化完成');
-+  }
-+
-+  initializeSchema() {
-+    // 内存模式：使用 JavaScript 数据结构模拟
-+    // 实际 SQLite 模式如下（需要 sqlite-vec 扩展）
-+    /*
-+    CREATE TABLE IF NOT EXISTS memories (
-+      id TEXT PRIMARY KEY,
-+      timestamp INTEGER NOT NULL,
-+      content TEXT NOT NULL,
-+      embedding BLOB,
-+      metadata JSON,
-+      created_at INTEGER
-+    );
-+    
-+    CREATE TABLE IF NOT EXISTS relationships (
-+      id TEXT PRIMARY KEY,
-+      source_id TEXT NOT NULL,
-+      target_id TEXT NOT NULL,
-+      relation_type TEXT NOT NULL,
-+      strength REAL DEFAULT 1.0,
-+      metadata JSON,
-+      created_at INTEGER
-+    );
-+    
-+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec USING vec(
-+      memory_id TEXT,
-+      embedding float[384]
-+    );
-+    */
-+   
-+    // 初始化内存存储
-+    this.memories = [];
-+    this.vectors = new Map();
-+    this.relationships = new Map();
-+  }
-+
-+  /**
-+   * 存储记忆
-+   * @param {object} memory - 记忆对象
-+   * @returns {string} 记忆ID
-+   */
-+  store(memory) {
-+    const id = memory.id || this.generateId();
-+    const timestamp = memory.timestamp || Date.now() * 1000; // 微秒
-+    
-+    const memoryRecord = {
-+      id,
-+      timestamp,
-+      content: memory.content,
-+      embedding: memory.embedding || this.generateMockEmbedding(memory.content),
-+      metadata: memory.metadata || {},
-+      createdAt: Date.now()
-+    };
-+    
-+    this.memories.push(memoryRecord);
-+    this.vectors.set(id, memoryRecord.embedding);
-+    
-+    // 添加关系（如果有）
-+    if (memory.relatedTo) {
-+      for (const rel of memory.relatedTo) {
-+        this.addRelationship({
-+          sourceId: id,
-+          targetId: rel.targetId,
-+          relationType: rel.type || 'related',
-+          strength: rel.strength || 1.0
-+        });
-+      }
-+    }
-+    
-+    this.stats.totalMemories = this.memories.length;
-+    
-+    console.log(`[TrialityMemory] 记忆存储: ${id} (${this.memories.length} total)`);
-+    return id;
-+  }
-+
-+  /**
-+   * 生成记忆ID
-+   */
-+  generateId() {
-+    return `mem-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
-+  }
-+
-+  /**
-+   * 生成模拟向量嵌入
-+   */
-+  generateMockEmbedding(content) {
-+    const hash = crypto.createHash('sha256').update(content).digest();
-+    const embedding = [];
-+    for (let i = 0; i < this.vectorDim; i++) {
-+      embedding.push((hash[i % hash.length] / 255) * 2 - 1);
-+    }
-+    return embedding;
-+  }
-+
-+  /**
-+   * 添加关系
-+   */
-+  addRelationship(rel) {
-+    const id = `rel-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
-+    const record = {
-+      id,
-+      sourceId: rel.sourceId,
-+      targetId: rel.targetId,
-+      relationType: rel.relationType,
-+      strength: rel.strength || 1.0,
-+      metadata: rel.metadata || {},
-+      createdAt: Date.now()
-+    };
-+    
-+    if (!this.relationships.has(rel.sourceId)) {
-+      this.relationships.set(rel.sourceId, []);
-+    }
-+    this.relationships.get(rel.sourceId).push(record);
-+    
-+    this.stats.totalRelationships = this.relationships.size;
-+    return id;
-+  }
-+
-+  /**
-+   * 语义相似度搜索
-+   * @param {number[]} queryEmbedding - 查询向量
-+   * @param {number} topK - 返回数量
-+   * @returns {object[]} 相似记忆
-+   */
-+  semanticSearch(queryEmbedding, topK = 10) {
-+    const similarities = [];
-+    
-+    for (const [id, embedding] of this.vectors) {
-+      const sim = this.cosineSimilarity(queryEmbedding, embedding);
-+      const memory = this.memories.find(m => m.id === id);
-+      if (memory) {
-+        similarities.push({
-+          id,
-+          content: memory.content,
-+          timestamp: memory.timestamp,
-+          similarity: sim,
-+          metadata: memory.metadata
-+        });
-+      }
-+    }
-+    
-+    similarities.sort((a, b) => b.similarity - a.similarity);
-+    return similarities.slice(0, topK);
-+  }
-+
-+  /**
-+   * 余弦相似度
-+   */
-+  cosineSimilarity(a, b) {
-+    let dotProduct = 0;
-+    let normA = 0;
-+    let normB = 0;
-+    
-+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
-+      dotProduct += a[i] * b[i];
-+      normA += a[i] * a[i];
-+      normB += b[i] * b[i];
-+    }
-+    
-+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB) + 0.0001);
-+  }
-+
-+  /**
-+   * 叙事查询 - 沿时间线或关系链图遍历
-+   * @param {object} query - 查询参数
-+   * @returns {object[]} 连贯叙事
-+   */
-+  narrativeQuery(query) {
-+    const {
-+      startMemoryId,
-+      direction = 'forward', // forward, backward, bidirectional
-+      relationTypes = ['causal', 'quotes', 'similar', 'related'],
-+      maxDepth = 5,
-+      maxNodes = 50
-+    } = query;
-+
-+    if (!startMemoryId) {
-+      return this.getRecentNarrative(maxNodes);
-+    }
-+
-+    const visited = new Set();
-+    const narrative = [];
-+    const queue = [{ id: startMemoryId, depth: 0 }];
-+
-+    while (queue.length > 0 && narrative.length < maxNodes) {
-+      const current = queue.shift();
-+      
-+      if (visited.has(current.id) || current.depth > maxDepth) continue;
-+      visited.add(current.id);
-+
-+      const memory = this.memories.find(m => m.id === current.id);
-+      if (memory) {
-+        narrative.push({
-+          ...memory,
-+          depth: current.depth
-+        });
-+      }
-+
-+      // 沿关系链扩展
-+      const relations = this.relationships.get(current.id) || [];
-+      for (const rel of relations) {
-+        if (relationTypes.includes(rel.relationType) || relationTypes.includes('all')) {
-+          if (!visited.has(rel.targetId)) {
-+            queue.push({ id: rel.targetId, depth: current.depth + 1 });
-+          }
-+        }
-+      }
-+
-+      // 反向扩展
-+      if (direction === 'bidirectional') {
-+        for (const [sourceId, rels] of this.relationships) {
-+          for (const rel of rels) {
-+            if (rel.targetId === current.id && !visited.has(sourceId)) {
-+              if (relationTypes.includes(rel.relationType) || relationTypes.includes('all')) {
-+                queue.push({ id: sourceId, depth: current.depth + 1 });
-+              }
-+            }
-+          }
-+        }
-+      }
-+    }
-+
-+    // 按时间排序
-+    narrative.sort((a, b) => a.timestamp - b.timestamp);
-+    
-+    console.log(`[TrialityMemory] 叙事查询: ${narrative.length} 个记忆节点`);
-+    return narrative;
-+  }
-+
-+  /**
-+   * 获取最近的叙事
-+   */
-+  getRecentNarrative(count = 20) {
-+    const sorted = [...this.memories].sort((a, b) => b.timestamp - a.timestamp);
-+    return sorted.slice(0, count).map(m => ({
-+      ...m,
-+      depth: 0
-+    }));
-+  }
-+
-+  /**
-+   * 时间范围查询
-+   */
-+  queryByTimeRange(startTime, endTime) {
-+    return this.memories
-+      .filter(m => m.timestamp >= startTime && m.timestamp <= endTime)
-+      .sort((a, b) => a.timestamp - b.timestamp);
-+  }
-+
-+  /**
-+   * 按关系类型查询
-+   */
-+  queryByRelationType(relationType, memoryId) {
-+    const relations = this.relationships.get(memoryId) || [];
-+    const targets = relations
-+      .filter(r => r.relationType === relationType)
-+      .map(r => r.targetId);
-+    
-+    return targets.map(id => this.memories.find(m => m.id === id)).filter(Boolean);
-+  }
-+
-+  /**
-+   * 获取统计信息
-+   */
-+  getStats() {
-+    return {
-+      ...this.stats,
-+      vectorDimension: this.vectorDim,
-+      storageMode: this.useMem ? 'memory' : 'sqlite-vec',
-+      dbPath: this.dbPath
-+    };
-+  }
-+
-+  /**
-+   * 导出记忆到文件
-+   */
-+  exportToFile(filePath) {
-+    const data = {
-+      memories: this.memories,
-+      relationships: Array.from(this.relationships.entries()),
-+      exportedAt: new Date().toISOString()
-+    };
-+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-+    console.log(`[TrialityMemory] 导出到: ${filePath}`);
-+    return { success: true, count: this.memories.length };
-+  }
-+
-+  /**
-+   * 从文件导入记忆
-+   */
-+  importFromFile(filePath) {
-+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-+    
-+    if (data.memories) {
-+      for (const mem of data.memories) {
-+        this.store(mem);
-+      }
-+    }
-+    
-+    console.log(`[TrialityMemory] 从 ${filePath} 导入`);
-+    return { success: true, count: data.memories?.length || 0 };
-+  }
-+
-+  /**
-+   * 清理旧记忆
-+   */
-+  cleanup(maxAge = 30 * 24 * 60 * 60 * 1000) { // 默认30天
-+    const cutoff = Date.now() * 1000 - maxAge;
-+    const before = this.memories.length;
-+    
-+    this.memories = this.memories.filter(m => m.timestamp > cutoff);
-+    this.stats.lastCleanup = new Date().toISOString();
-+    
-+    const removed = before - this.memories.length;
-+    console.log(`[TrialityMemory] 清理: 移除 ${removed} 条旧记忆`);
-+    return { removed, remaining: this.memories.length };
-+  }
-+}
-+
-+module.exports = { TrialityMemory };
-