@yun520-1/heartflow 0.15.2

package/src/core/dream/sleep-cycle.mjs

@@ -0,0 +1,208 @@
+/**
+ * SleepCycleSimulator - 睡眠周期模拟器 v11.0.2
+ * ==========================================
+ * 论文灵感:
+ *   - Agent PSO: particle swarm optimization for evolving reasoning
+ *   - Population-based reasoning: multiple reasoning candidates compete
+ *   - Swarm intelligence: collective optimization of reasoning strategies
+ *
+ * 功能: 模拟人类睡眠 NREM/REM 周期结构 (约90分钟/周期)
+ *       与 dream.ts 互补: dream.ts生成梦境内容, 本模块建模睡眠神经机制
+ *
+ * 每90分钟周期结构:
+ *   NREM1(5%) -> NREM2(45%) -> NREM3(25%) -> NREM2(15%) -> REM(10%)
+ *
+ * 随夜间进展:
+ *   - 深度睡眠(NREM3)比例减少
+ *   - REM比例增加
+ */
+
+export const SleepStage = {
+  WAKE: 'wake',
+  NREM1: 'nrem1',   // Light sleep - memory filtering
+  NREM2: 'nrem2',   // Moderate - spindle consolidation
+  NREM3: 'nrem3',   // Deep slow-wave - hippocampal->cortical transfer
+  REM: 'rem',         // Dreaming - emotional/procedural integration
+};
+
+const STAGE_LABELS = {
+  [SleepStage.WAKE]:  'Wake',
+  [SleepStage.NREM1]: 'NREM1 (Light)',
+  [SleepStage.NREM2]: 'NREM2 (Spindle)',
+  [SleepStage.NREM3]: 'NREM3 (SWS)',
+  [SleepStage.REM]:   'REM (Dream)',
+};
+
+/**
+ * @typedef {Object} SleepEpoch
+ * @property {string} stage
+ * @property {number} durationSec
+ * @property {number} startTime
+ * @property {string} memoryActivity
+ * @property {string} brainRegion
+ */
+
+/**
+ * @typedef {Object} SleepCycleSummary
+ * @property {number} totalCycles
+ * @property {Object} stageMinutes  - minutes per stage
+ * @property {number} totalSleepMin
+ */
+
+const CYCLE_MIN = 90;
+
+/** NREM3比例随周期递减 */
+function depthRatio(cycleN) {
+  return Math.max(0.3, 1.0 - cycleN * 0.12);
+}
+
+/** REM比例随周期递增 */
+function remRatio(cycleN) {
+  return Math.min(0.28, 0.10 + cycleN * 0.04);
+}
+
+/** 各阶段的记忆活动类型 */
+function memoryActivity(stage) {
+  return {
+    [SleepStage.NREM1]: 'memory_filtering',
+    [SleepStage.NREM2]: 'spindle_consolidation',
+    [SleepStage.NREM3]: 'slow_wave_transfer',
+    [SleepStage.REM]:   'emotional_integration',
+  }[stage] || 'none';
+}
+
+/** 各阶段主要脑区 */
+function brainRegion(stage) {
+  return {
+    [SleepStage.NREM1]: 'thalamus',
+    [SleepStage.NREM2]: 'thalamus_cortex',
+    [SleepStage.NREM3]: 'hippocampus_cortex',
+    [SleepStage.REM]:   'limbic_cortex',
+  }[stage] || 'global';
+}
+
+/**
+ * 模拟睡眠周期
+ * @param {number} numCycles - 周期数（每周期90分钟）
+ * @param {number} [startTime] - 开始时间戳(ms)，默认now
+ * @returns {SleepEpoch[]}
+ */
+export function simulate(numCycles, startTime = Date.now()) {
+  /** @type {SleepEpoch[]} */
+  const epochs = [];
+  let t = startTime;
+
+  for (let cycleN = 0; cycleN < numCycles; cycleN++) {
+    const depth = depthRatio(cycleN);
+    const rem = remRatio(cycleN);
+
+    const stages = [
+      { stage: SleepStage.NREM1, ratio: 0.05 },
+      { stage: SleepStage.NREM2, ratio: 0.45 },
+      { stage: SleepStage.NREM3, ratio: 0.25 * depth },
+      { stage: SleepStage.NREM2, ratio: 0.15 },
+      { stage: SleepStage.REM,   ratio: rem },
+    ];
+
+    for (const { stage, ratio } of stages) {
+      const durMs = ratio * CYCLE_MIN * 60 * 1000;
+      epochs.push({
+        stage,
+        durationSec: Math.round(ratio * CYCLE_MIN * 60),
+        startTime: t,
+        memoryActivity: memoryActivity(stage),
+        brainRegion: brainRegion(stage),
+      });
+      t += durMs;
+    }
+  }
+
+  return epochs;
+}
+
+/**
+ * 获取睡眠统计摘要
+ * @param {SleepEpoch[]} epochs
+ * @returns {SleepCycleSummary}
+ */
+export function summarize(epochs) {
+  /** @type {Record<string, number>} */
+  const byStage = {
+    [SleepStage.WAKE]: 0,
+    [SleepStage.NREM1]: 0,
+    [SleepStage.NREM2]: 0,
+    [SleepStage.NREM3]: 0,
+    [SleepStage.REM]: 0,
+  };
+
+  for (const e of epochs) {
+    byStage[e.stage] += e.durationSec / 60;
+  }
+
+  const totalCycles = Math.floor(epochs.length / 5);
+  const totalSleep = byStage[SleepStage.NREM1] + byStage[SleepStage.NREM2]
+                   + byStage[SleepStage.NREM3] + byStage[SleepStage.REM];
+
+  return {
+    totalCycles,
+    stageMinutes: Object.fromEntries(
+      Object.entries(byStage).map(([k, v]) => [k, Math.round(v * 10) / 10])
+    ),
+    totalSleepMin: Math.round(totalSleep * 10) / 10,
+  };
+}
+
+/**
+ * 将睡眠阶段映射到 dream.ts 的梦境阶段
+ * NREM3 -> consolidation (记忆转移), REM -> dream generation
+ */
+export function toDreamPhase(stage) {
+  return {
+    [SleepStage.NREM1]: 'Light',
+    [SleepStage.NREM2]: 'Light',
+    [SleepStage.NREM3]: 'Deep',    // slow wave = hippocampal->cortical transfer
+    [SleepStage.REM]:   'REM',     // dreaming = emotional integration
+  }[stage] || 'Light';
+}
+
+/**
+ * 注册睡眠阶段回调（供 cortex 或 dream.ts 集成使用）
+ * @param {SleepEpoch[]} epochs
+ * @param {Object} callbacks - { onNREM3?: fn, onREM?: fn, onNREM2?: fn }
+ */
+export function runCallbacks(epochs, callbacks = {}) {
+  for (const epoch of epochs) {
+    if (epoch.stage === SleepStage.NREM3 && callbacks.onNREM3) {
+      callbacks.onNREM3(epoch);
+    } else if (epoch.stage === SleepStage.REM && callbacks.onREM) {
+      callbacks.onREM(epoch);
+    } else if (epoch.stage === SleepStage.NREM2 && callbacks.onNREM2) {
+      callbacks.onNREM2(epoch);
+    }
+  }
+}
+
+// Self-test
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const epochs = simulate(4);
+  console.log(`Cycles: ${epochs.length / 5}`);
+  console.log('First 10 epochs:');
+  for (const e of epochs.slice(0, 10)) {
+    const label = STAGE_LABELS[e.stage] || e.stage;
+    console.log(`  ${label.padEnd(18)} ${String(e.durationSec).padStart(4)}s | ${e.memoryActivity.padEnd(22)} | ${e.brainRegion}`);
+  }
+  console.log('\nSummary:', summarize(epochs));
+
+  // Test dream.ts phase mapping
+  console.log('\nDream phase mapping:');
+  for (const [js, dream] of [
+    [SleepStage.NREM1, toDreamPhase(SleepStage.NREM1)],
+    [SleepStage.NREM2, toDreamPhase(SleepStage.NREM2)],
+    [SleepStage.NREM3, toDreamPhase(SleepStage.NREM3)],
+    [SleepStage.REM,   toDreamPhase(SleepStage.REM)],
+  ]) {
+    console.log(`  ${js} -> ${dream}`);
+  }
+
+  console.log('\nSleepCycleSimulator v11.0.2 OK');
+}

package/src/core/embodied/embodied-core.js

@@ -0,0 +1,276 @@
+/**
+ * Embodied-Core - 具身认知核心
+ * 
+ * 设计理念：
+ * - 双系统架构：System 1 (直觉/快思考) + System 2 (分析/慢思考)
+ * - 动作思维链 (Action-Thought Chain)
+ */
+
+class EmbodiedCore {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    
+    this.cognitiveState = {
+      system: 'idle',
+      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', weight: 1.0 },
+      MoodAgent: { type: 'agent', weight: 0.9 },
+      FocusAgent: { type: 'agent', weight: 0.9 },
+      ReflectionAgent: { type: 'agent', 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 }
+    };
+  }
+
+  registerSensorAdapter(name, adapter) {
+    this.sensorAdapters[name] = adapter;
+    console.log(`[EmbodiedCore] 注册传感器: ${name}`);
+  }
+
+  cognitivePlan(goal) {
+    const { description, type = 'general', 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: ['observe', 'analyze', 'plan', 'decide', 'execute', 'reflect'],
+      coding: ['observe', 'analyze', 'plan', 'decide', 'execute', 'reflect', 'adapt'],
+      debugging: ['observe', 'analyze', 'decide', 'execute', 'reflect'],
+      learning: ['observe', 'analyze', 'plan', 'reflect'],
+      creative: ['observe', 'analyze', 'plan', 'decide', 'execute', 'adapt']
+    };
+    return templates[type] || templates.general;
+  }
+
+  generateStepDescription(stepType, goal, index) {
+    const templates = {
+      observe: `观察当前状态和上下文`,
+      analyze: `分析问题：${goal}`,
+      plan: `制定实现方案`,
+      decide: `选择最佳方案`,
+      execute: `执行：${goal}`,
+      reflect: `反思执行结果`,
+      adapt: `根据反馈调整策略`
+    };
+    return templates[stepType] || `${stepType}: 步骤 ${index + 1}`;
+  }
+
+  getExpectedOutcome(stepType) {
+    const outcomes = {
+      observe: '收集到当前状态信息',
+      analyze: '形成问题分析报告',
+      plan: '产出可执行计划',
+      decide: '确定最终方案',
+      execute: '完成任务或产出',
+      reflect: '获得改进建议',
+      adapt: '更新执行策略'
+    };
+    return outcomes[stepType] || '完成步骤';
+  }
+
+  selectExecutor(stepType, goalType) {
+    const mapping = {
+      observe: ['SelfAgent', 'code-analysis'],
+      analyze: ['SelfAgent', 'code-analysis'],
+      plan: ['SelfAgent'],
+      decide: ['SelfAgent', 'ReflectionAgent'],
+      execute: ['SelfAgent', 'code-generation'],
+      reflect: ['ReflectionAgent', 'SelfAgent'],
+      adapt: ['SelfAgent']
+    };
+    const options = mapping[stepType] || ['SelfAgent'];
+    return options[0];
+  }
+
+  estimateDuration(stepType) {
+    const durations = { observe: 500, analyze: 2000, plan: 3000, decide: 1000, execute: 5000, reflect: 2000, 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 === 'execute').length * 0.5;
+    return Math.min(10, (baseScore + typeWeight) / 2);
+  }
+
+  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';
+        execution.adaptation = this.adaptPlan(plan, stepExecution);
+        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 = {
+      observe: { observations: ['当前状态良好', '环境稳定'] },
+      analyze: { analysis: '问题已识别', confidence: 0.85 },
+      plan: { plan: '方案已制定', alternatives: 2 },
+      decide: { decision: '选择方案A', reason: '最优' },
+      execute: { outcome: '完成', success: true },
+      reflect: { feedback: '执行顺利', improvements: [] },
+      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: '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 };