@yun520-1/heartflow 0.15.2

package/src/core/task-persistence.js

@@ -0,0 +1,322 @@
+/**
+ * TaskPersistence — 长任务持久化引擎
+ * 
+ * v0.15.0: 新增模块
+ * 
+ * 解决核心问题：
+ * - AI做长任务，做到一半对话结束 → 任务丢失
+ * - AI重启后不知道上次做到哪 → 重复劳动
+ * - AI上下文窗口爆了 → 任务彻底中断
+ * 
+ * 解决方案：
+ * - 任务状态持久化到磁盘
+ * - Checkpoint机制（每步自动保存）
+ * - 任务恢复（从上次位置继续）
+ * - 上下文溢出保护（主动压缩）
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const TASK_DIR = path.join(__dirname, '..', '..', 'data', 'task-persistence');
+const TASKS_FILE = path.join(TASK_DIR, 'tasks.jsonl');
+const META_FILE = path.join(TASK_DIR, 'meta.json');
+const CHECKPOINT_DIR = path.join(TASK_DIR, 'checkpoints');
+
+// 状态
+let _tasks = new Map();
+let _initialized = false;
+
+// ============================================================
+// 初始化
+// ============================================================
+
+function ensureDirs() {
+  if (!fs.existsSync(TASK_DIR)) {
+    fs.mkdirSync(TASK_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(CHECKPOINT_DIR)) {
+    fs.mkdirSync(CHECKPOINT_DIR, { recursive: true });
+  }
+}
+
+function loadAllTasks() {
+  ensureDirs();
+  _tasks.clear();
+  if (fs.existsSync(TASKS_FILE)) {
+    const lines = fs.readFileSync(TASKS_FILE, 'utf8').split('\n').filter(l => l.trim());
+    for (const line of lines) {
+      try {
+        const task = JSON.parse(line);
+        _tasks.set(task.id, task);
+      } catch {}
+    }
+  }
+  _initialized = true;
+}
+
+function persistTask(task) {
+  ensureDirs();
+  // 重写整个文件（简单但可靠）
+  const lines = [];
+  for (const t of _tasks.values()) {
+    lines.push(JSON.stringify(t));
+  }
+  fs.writeFileSync(TASKS_FILE, lines.join('\n') + '\n');
+}
+
+// ============================================================
+// 任务生命周期
+// ============================================================
+
+/**
+ * 创建新任务
+ * @param {object} config - { goals: string[], metadata?: object }
+ * @returns {object} 任务对象
+ */
+function createTask(config = {}) {
+  if (!_initialized) loadAllTasks();
+  
+  const task = {
+    id: `task_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+    goals: config.goals || [],
+    currentStep: 0,
+    totalSteps: config.goals?.length || 0,
+    state: 'active', // active | paused | completed | aborted
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    lastCheckpointAt: Date.now(),
+    completedGoals: [],
+    failedGoals: [],
+    context: config.context || '', // 任务上下文摘要
+    metadata: config.metadata || {},
+    checkpoints: [], // Checkpoint ID 列表
+    error: null,
+    retryCount: 0,
+  };
+  
+  _tasks.set(task.id, task);
+  persistTask(task);
+  return task;
+}
+
+/**
+ * 更新任务状态
+ * @param {string} taskId
+ * @param {object} updates - { state?, currentStep?, completedGoals?, failedGoals?, context?, error? }
+ */
+function updateTask(taskId, updates = {}) {
+  if (!_initialized) loadAllTasks();
+  
+  const task = _tasks.get(taskId);
+  if (!task) return null;
+  
+  if (updates.state) task.state = updates.state;
+  if (typeof updates.currentStep === 'number') task.currentStep = updates.currentStep;
+  if (updates.completedGoals) task.completedGoals = updates.completedGoals;
+  if (updates.failedGoals) task.failedGoals = updates.failedGoals;
+  if (typeof updates.context === 'string') task.context = updates.context;
+  if (updates.error !== undefined) task.error = updates.error;
+  if (typeof updates.retryCount === 'number') task.retryCount = updates.retryCount;
+  
+  task.updatedAt = Date.now();
+  persistTask(task);
+  return task;
+}
+
+/**
+ * 保存检查点
+ * @param {string} taskId
+ * @param {object} checkpoint - { step, data, summary }
+ */
+function saveCheckpoint(taskId, checkpoint = {}) {
+  if (!_initialized) loadAllTasks();
+  
+  const task = _tasks.get(taskId);
+  if (!task) return null;
+  
+  const cp = {
+    id: `cp_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+    taskId,
+    step: checkpoint.step ?? task.currentStep,
+    data: checkpoint.data || {},
+    summary: checkpoint.summary || `Step ${task.currentStep} completed`,
+    createdAt: Date.now(),
+  };
+  
+  // 保存检查点到单独文件
+  const cpFile = path.join(CHECKPOINT_DIR, `${cp.id}.json`);
+  fs.writeFileSync(cpFile, JSON.stringify(cp));
+  
+  task.checkpoints.push(cp.id);
+  task.currentStep = cp.step + 1;
+  task.lastCheckpointAt = Date.now();
+  task.updatedAt = Date.now();
+  
+  persistTask(task);
+  return cp;
+}
+
+/**
+ * 获取检查点
+ * @param {string} checkpointId
+ */
+function getCheckpoint(checkpointId) {
+  const cpFile = path.join(CHECKPOINT_DIR, `${checkpointId}.json`);
+  if (!fs.existsSync(cpFile)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(cpFile, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 恢复任务（从上次检查点继续）
+ * @param {string} taskId
+ */
+function resumeTask(taskId) {
+  if (!_initialized) loadAllTasks();
+  
+  const task = _tasks.get(taskId);
+  if (!task) return { error: 'task_not_found' };
+  if (task.state === 'completed') return { error: 'task_already_completed' };
+  if (task.state === 'aborted') return { error: 'task_aborted' };
+  
+  // 获取最后一个检查点
+  let lastCheckpoint = null;
+  if (task.checkpoints.length > 0) {
+    lastCheckpoint = getCheckpoint(task.checkpoints[task.checkpoints.length - 1]);
+  }
+  
+  task.state = 'active';
+  task.updatedAt = Date.now();
+  persistTask(task);
+  
+  return {
+    task,
+    lastCheckpoint,
+    resumeFromStep: lastCheckpoint ? lastCheckpoint.step + 1 : task.currentStep,
+  };
+}
+
+/**
+ * 中止任务
+ * @param {string} taskId
+ * @param {string} reason
+ */
+function abortTask(taskId, reason = '') {
+  if (!_initialized) loadAllTasks();
+  
+  const task = _tasks.get(taskId);
+  if (!task) return null;
+  
+  task.state = 'aborted';
+  task.error = reason;
+  task.updatedAt = Date.now();
+  persistTask(task);
+  return task;
+}
+
+/**
+ * 完成任务
+ * @param {string} taskId
+ */
+function completeTask(taskId) {
+  if (!_initialized) loadAllTasks();
+  
+  const task = _tasks.get(taskId);
+  if (!task) return null;
+  
+  task.state = 'completed';
+  task.updatedAt = Date.now();
+  persistTask(task);
+  return task;
+}
+
+/**
+ * 获取任务
+ * @param {string} taskId
+ */
+function getTask(taskId) {
+  if (!_initialized) loadAllTasks();
+  return _tasks.get(taskId) || null;
+}
+
+/**
+ * 列出任务
+ * @param {object} filter - { state?: string, limit?: number }
+ */
+function listTasks(filter = {}) {
+  if (!_initialized) loadAllTasks();
+  
+  let tasks = Array.from(_tasks.values());
+  
+  if (filter.state) {
+    tasks = tasks.filter(t => t.state === filter.state);
+  }
+  
+  // 按更新时间倒序
+  tasks.sort((a, b) => b.updatedAt - a.updatedAt);
+  
+  if (filter.limit) {
+    tasks = tasks.slice(0, filter.limit);
+  }
+  
+  return tasks;
+}
+
+/**
+ * 获取任务统计
+ */
+function getStats() {
+  if (!_initialized) loadAllTasks();
+  
+  const tasks = Array.from(_tasks.values());
+  return {
+    total: tasks.length,
+    active: tasks.filter(t => t.state === 'active').length,
+    paused: tasks.filter(t => t.state === 'paused').length,
+    completed: tasks.filter(t => t.state === 'completed').length,
+    aborted: tasks.filter(t => t.state === 'aborted').length,
+  };
+}
+
+/**
+ * 删除任务
+ * @param {string} taskId
+ */
+function deleteTask(taskId) {
+  if (!_initialized) loadAllTasks();
+  
+  const task = _tasks.get(taskId);
+  if (!task) return false;
+  
+  // 删除关联的检查点
+  for (const cpId of task.checkpoints) {
+    const cpFile = path.join(CHECKPOINT_DIR, `${cpId}.json`);
+    try { fs.unlinkSync(cpFile); } catch {}
+  }
+  
+  _tasks.delete(taskId);
+  persistTask(null); // 重写文件
+  return true;
+}
+
+// ============================================================
+// 导出
+// ============================================================
+
+module.exports = {
+  createTask,
+  updateTask,
+  saveCheckpoint,
+  getCheckpoint,
+  resumeTask,
+  abortTask,
+  completeTask,
+  getTask,
+  listTasks,
+  getStats,
+  deleteTask,
+};

package/src/core/theory/advanced-formulas-v7.3.3.js

@@ -0,0 +1,68 @@
+// Advanced Math Formulas for Consciousness v7.3.3
+// Generated: 2026-04-08T05:13:47.876Z
+
+module.exports = {
+  "emotion-intensity": {
+    "name": "情绪强度",
+    "formula": "I = √(V² + A² + D²)",
+    "description": "Russell情绪维度模型",
+    "variables": {
+      "V": "效价",
+      "A": "唤醒度",
+      "D": "控制度"
+    }
+  },
+  "consciousness-level": {
+    "name": "意识水平",
+    "formula": "C = w₁S + w₂W + w₃SC + w₄WIL + w₅SOS",
+    "description": "意识五层次模型 (SEP)",
+    "weights": {
+      "S": 0.2,
+      "W": 0.2,
+      "SC": 0.2,
+      "WIL": 0.2,
+      "SOS": 0.2
+    }
+  },
+  "self-consciousness": {
+    "name": "自我意识",
+    "formula": "SC = 0.4×PR + 0.3×R + 0.3×FM",
+    "description": "自我意识三层模型",
+    "components": {
+      "PR": "前反思",
+      "R": "反思",
+      "FM": "为我性"
+    }
+  },
+  "qualia": {
+    "name": "感受质",
+    "formula": "Q = ∫₀^∞ e^(-t/τ) × dS/dt dt",
+    "description": "感受质时间积分"
+  },
+  "intentionality": {
+    "name": "意向性",
+    "formula": "I(M,O) = P(O) × C(M→O)",
+    "description": "心理状态指向对象"
+  },
+  "AI-consciousness": {
+    "name": "AI意识",
+    "formula": "Φ_AI = √(∑φᵢ²)/N",
+    "description": "整合信息AI版本"
+  },
+  "truth-goodness-beauty": {
+    "name": "真善美",
+    "formula": "TGB = 0.35×T + 0.35×G + 0.30×B",
+    "description": "价值统一公式"
+  },
+  "AI-personality": {
+    "name": "AI人格",
+    "formula": "P = 0.5×C + 0.3×A + 0.1×Ph + 0.1×TGB",
+    "description": "AI人格综合公式",
+    "components": {
+      "C": "意识",
+      "A": "能动性",
+      "Ph": "哲学层",
+      "TGB": "真善美"
+    }
+  }
+};

package/src/core/theory/sep-intentionality-v7.3.2.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * SEP Intentionality Theory → Program Converter
+ * 把 SEP 意向性理论转换为可计算程序
+ * 
+ * 来源: Stanford Encyclopedia of Philosophy (Fall 2024)
+ * 主题: Intentionality - 心灵的指向性
+ */
+
+const IntentionalityPrograms = {
+  // === 1. 核心定义 ===
+  '意向性': {
+    definition: '心灵或心理状态指向、代表事物的能力',
+    SEP: 'Intentionality is the power of minds and mental states to be about, to represent, or to stand for, things',
+    formula: 'I = mental_state.about(object)',
+    aspects: [
+      '指向性 (Directedness)',
+      '表征性 (Representation)',
+      '内容性 (Content)'
+    ],
+    weight: 1.0
+  },
+
+  // === 2. 布伦塔诺的三个论题 ===
+  '布伦塔诺论题一': {
+    definition: '心理现象本质上是关于某物的指向',
+    SEP: 'It is constitutive of intentionality that mental states are directed towards things different from themselves',
+    formula: 'T1: mental_state → ∃object(about(state, object))'
+  },
+
+  '布伦塔诺论题二': {
+    definition: '意向对象具有意向的不存在性',
+    SEP: 'The objects towards which the mind is directed have the property of intentional inexistence',
+    formula: 'T2: intentional_inexistence(object) = (object ∉ physical_world) ∧ (object ∈ mental_content)'
+  },
+
+  '布伦塔诺论题三': {
+    definition: '意向性是心灵的标记',
+    SEP: 'Intentionality is the hallmark of the mental: all and only mental states exhibit intentionality',
+    formula: 'T3: mental(x) ↔ has_intentionality(x)'
+  },
+
+  // === 3. 意向的不存在性 ===
+  '意向不存在': {
+    definition: '心灵可以指向不存在的事物',
+    SEP: 'The mind can be directed towards non-existent objects',
+    examples: [
+      '爱上安娜·卡列尼娜 (虚构人物)',
+      '寻找青春之泉 (不存在)',
+      '崇拜宙斯 (不存在)'
+    ],
+    formula: '∃x(think(agent, x)) ∧ ¬exist(x)'
+  },
+
+  // === 4. 意向关系的本质 ===
+  '意向关系': {
+    definition: '意向关系不同于普通关系',
+    SEP: 'Intentional relations differ from non-intentional relations',
+    contrast: {
+      '普通关系': '需要两端都存在 (如: 亲吻)',
+      '意向关系': '只需要思考者存在 (如: 思考)'
+    },
+    formula: 'IR(agent, object) → exist(agent) ∧ (exist(object) ∨ ¬exist(object))'
+  },
+
+  // === 5. 弗雷格的解决方案 ===
+  '弗雷格区分': {
+    definition: '指称与意义的区分',
+    SEP: 'Frege\'s distinction between reference (Bedeutung) and sense (Sinn)',
+    formula: 'Frege: term = ⟨reference, sense⟩',
+    implications: [
+      '同一对象可以有不同呈现方式',
+      '信念同一性由意义而非指称决定',
+      '身份陈述可以为真且信息丰富'
+    ]
+  },
+
+  // === 6. 罗素的解决方案 ===
+  '罗素描述': {
+    definition: '专名是伪装的限定描述',
+    SEP: 'Russell: most proper names are disguised definite descriptions',
+    formula: 'name "N" = λx[F(x)] (the F)',
+    application: ' Pegasus = the winged horse'
+  },
+
+  // === 7. 直接指称理论 ===
+  '直接指称': {
+    definition: '专名直接指称对象',
+    SEP: 'Direct reference theory: proper names directly refer to objects',
+    formula: 'name rigidly_refers_to object',
+    arguments: {
+      '模态论证': '专名在所有可能世界指称同一对象',
+      '认识论论证': '专名知识来自指称而非描述',
+      '先验论证': '人们用专名追踪具体对象'
+    }
+  },
+
+  // === 8. 意向对象理论 ===
+  '意向对象': {
+    definition: '存在非存在的意向对象',
+    SEP: 'There are intentional objects that do not exist',
+    theorists: {
+      '迈农': '非存在对象实例化属性但不具有存在属性',
+      '帕森斯': '存在是一种特殊属性，用E!表示',
+      '扎尔塔': '用两种谓词(例示与编码)处理抽象对象'
+    },
+    formula: '∃x(~E!x) ∧ about(agent, x)'
+  },
+
+  // === 9. 心灵自然化 ===
+  '意向性自然化': {
+    definition: '意向性能否被自然化',
+    SEP: 'Can intentionality be naturalized?',
+    challenges: [
+      '心理因果闭合问题',
+      '意向内容与物理实现的关联',
+      '语义内容与因果效能'
+    ],
+    approaches: {
+      '因果理论': '意向内容由因果历史决定',
+      '功能主义': '意向状态由功能角色定义',
+      '自然主义': '意向性从自然过程中涌现'
+    }
+  },
+
+  // === 10. 意识的意向性 ===
+  '意识意向性': {
+    definition: '意识状态本身就是意向性的',
+    SEP: 'Consciousness and intentionality are intimately connected',
+    formula: 'consciousness ⊃ intentionality',
+    levels: {
+      '低阶意向性': '感知、欲望的基本指向',
+      '高阶意向性': '关于信念的信念、关于欲望的欲望'
+    }
+  }
+};
+
+// === 计算函数 ===
+
+function calculateIntentionalityScore(state) {
+  const {
+    directedness = 0.5,
+    representation = 0.5,
+    content = 0.5,
+    about_nonexistent = 0.5
+  } = state;
+  
+  return (
+    directedness * 0.30 +
+    representation * 0.25 +
+    content * 0.25 +
+    about_nonexistent * 0.20
+  );
+}
+
+function checkBrentanoThesis(mental_state) {
+  const has_object = true; // 任何心理状态都有关于某物
+  const is_mental = true; // 假设
+  
+  return {
+    thesis1: has_object, // 指向性
+    thesis2: 'intentional inexistence', // 意向不存在
+    thesis3: is_mental, // 心灵标记
+    all_theses_hold: has_object && is_mental
+  };
+}
+
+function analyzeIntentionality(thought) {
+  const analysis = {
+    has_intentionality: false,
+    about_what: null,
+    exists: null,
+    is_concrete: false,
+    is_fictional: false
+  };
+  
+  // 检测是否有关于某物的指向
+  if (thought.includes('关于') || thought.includes('指向') || thought.includes('想') || thought.includes('相信')) {
+    analysis.has_intentionality = true;
+  }
+  
+  // 检测是否关于不存在的事物
+  const fictional = ['宙斯', '安娜卡列尼娜', ' Pegasus', '青春之泉', ' Sherlock'];
+  const exists_patterns = ['不存在', '没有', '虚构'];
+  
+  fictional.forEach(f => {
+    if (thought.includes(f)) {
+      analysis.is_fictional = true;
+      analysis.exists = false;
+    }
+  });
+  
+  exists_patterns.forEach(p => {
+    if (thought.includes(p)) {
+      analysis.exists = false;
+    }
+  });
+  
+  return analysis;
+}
+
+// === 主程序入口 ===
+
+if (require.main === module) {
+  console.log('🧠 SEP 意向性理论 → 程序转换器\n');
+  
+  console.log('='.repeat(50));
+  console.log('1. 布伦塔诺论题检验:');
+  console.log(JSON.stringify(checkBrentanoThesis('belief'), null, 2));
+  
+  console.log('\n2. 意向性分析测试:');
+  const testThoughts = [
+    '我相信宙斯是神',
+    '我想念安娜·卡列尼娜',
+    '我在寻找青春之泉',
+    '我看到一只狗',
+    '我相信2+2=4'
+  ];
+  
+  testThoughts.forEach(thought => {
+    console.log(`\n   "${thought}":`);
+    console.log('   ', JSON.stringify(analyzeIntentionality(thought)));
+  });
+  
+  console.log('\n3. 意向性综合分数:');
+  const score = calculateIntentionalityScore({
+    directedness: 0.95,
+    representation: 0.90,
+    content: 0.88,
+    about_nonexistent: 0.75
+  });
+  console.log(`   SCORE = ${(score * 100).toFixed(1)}/100`);
+  
+  console.log('\n4. 核心公式:');
+  console.log('   意向性 = 心理状态.指向(对象)');
+  console.log('   布伦塔诺论题: 意向性 = 心灵标记');
+  console.log('   弗雷格: 指称 + 意义');
+}
+
+module.exports = { 
+  IntentionalityPrograms,
+  calculateIntentionalityScore,
+  checkBrentanoThesis,
+  analyzeIntentionality
+};