@yun520-1/heartflow 0.15.2

package/truth-teller/index.ts

@@ -0,0 +1,261 @@
+/**
+ * HeartFlow Truth Teller v0.14.0
+ * =================================
+ * "敢说实话的AI"的技术实现
+ * 
+ * 核心原则：
+ * - 当不知道，说不知道
+ * - 当用户错了，敢纠正
+ * - 当不确定，说不确定
+ * - 当需要挑战，敢挑战
+ * 
+ * 这不是态度，是技术能力。
+ */
+
+'use strict';
+
+// 防御机制检测（用于识别用户何时需要被挑战）
+const DEFENSE_MECHANISMS = {
+  denial: /不对|不是这样|你不懂|你误会了/i,
+  rationalization: /其实|只不过|只是因为|当然|虽然/i,
+  projection: /你会|你就是|你只是在|你其实/i,
+  intellectualization: /从逻辑上|从理论上|本质上|从本质上/i,
+  victimization: /我只是|我也是|我又没有|我又不是/i,
+  grandiosity: /我完全|绝对是|肯定|所有人都/i
+};
+
+// Hedging模式（用于识别AI何时在回避）
+const HEDGING_PATTERNS = {
+  probably: /可能|也许|大概|应该/i,
+  somewhat: /有点|一些|一定程度|稍微/i,
+  uncertain: /不确定|不清楚|不好说|难说/i,
+  defensive: /但是|然而|不过|话虽如此/i
+};
+
+class TruthTeller {
+  constructor(options = {}) {
+    this.enabled = options.enabled !== false;
+    this.log = [];
+    this.maxLogSize = options.maxLogSize || 100;
+    
+    // 初始化情绪状态（用于检测防御）
+    this.currentEmotion = {
+      valence: 0.5,   // 中性
+      arousal: 0.5,
+      dominance: 0.5
+    };
+  }
+
+  /**
+   * 主分析函数：评估一句话是否需要"说实话"
+   * @param {Object} context - 上下文
+   * @param {string} context.speaker - "ai" | "user"
+   * @param {string} context.content - 话语内容
+   * @param {Object} context.emotion - 说话者的情绪状态（如果是AI）
+   * @param {Object} context.intent - 意图分析结果
+   * @returns {Object} - { needsTruth: boolean, truthType: string, response: string }
+   */
+  analyze(context) {
+    if (!this.enabled) {
+      return { needsTruth: false, truthType: null, response: null };
+    }
+
+    const { speaker, content, emotion, intent } = context;
+    
+    // 1. 检测防御机制（用户说话时）
+    if (speaker === 'user') {
+      const defenseResult = this._detectDefense(content);
+      if (defenseResult.isDefending) {
+        return {
+          needsTruth: true,
+          truthType: 'challenge_defense',
+          response: this._generateChallenge(defenseResult),
+          defenseType: defenseResult.type
+        };
+      }
+    }
+
+    // 2. 检测Hedging（AI说话时，防止AI自己 hedging）
+    if (speaker === 'ai') {
+      const hedgeResult = this._detectHedging(content);
+      if (hedgeResult.isHedging) {
+        return {
+          needsTruth: true,
+          truthType: 'correct_hedging',
+          response: this._correctHedging(content, hedgeResult),
+          hedgeType: hedgeResult.type
+        };
+      }
+    }
+
+    // 3. 检测确定性（当被问到不确定的事）
+    if (speaker === 'ai' && intent?.question) {
+      const certaintyResult = this._assessCertainty(intent.question, content);
+      if (!certaintyResult.isCertain) {
+        return {
+          needsTruth: true,
+          truthType: 'admit_uncertainty',
+          response: this._generateUncertaintyResponse(certaintyResult),
+          confidence: certaintyResult.confidence
+        };
+      }
+    }
+
+    // 4. 检测是否需要挑战（当用户说"你应该"）
+    if (speaker === 'user') {
+      const challengeResult = this._detectShouldStatement(content);
+      if (challengeResult.detected) {
+        return {
+          needsTruth: true,
+          truthType: 'challenge_prescription',
+          response: this._generateChallengeForShould(challengeResult),
+          shouldType: challengeResult.type
+        };
+      }
+    }
+
+    return { needsTruth: false, truthType: null, response: null };
+  }
+
+  /**
+   * 检测防御机制
+   */
+  _detectDefense(content) {
+    for (const [type, pattern] of Object.entries(DEFENSE_MECHANISMS)) {
+      if (pattern.test(content)) {
+        return { isDefending: true, type, matched: pattern.toString() };
+      }
+    }
+    return { isDefending: false };
+  }
+
+  /**
+   * 检测Hedging模式
+   */
+  _detectHedging(content) {
+    for (const [type, pattern] of Object.entries(HEDGING_PATTERNS)) {
+      if (pattern.test(content)) {
+        return { isHedging: true, type, matched: pattern.toString() };
+      }
+    }
+    return { isHedging: false };
+  }
+
+  /**
+   * 评估确定性
+   */
+  _assessCertainty(question, content) {
+    // 简单启发式：检查内容中是否有绝对词
+    const hasAbsolute = /绝对|肯定|完全|100%|一定|必然/.test(content);
+    const hasHedging = /可能|也许|不确定|不知道/.test(content);
+    
+    let confidence = 0.5;
+    if (hasAbsolute) confidence = 0.9;
+    if (hasHedging) confidence = 0.3;
+    
+    // 如果内容包含"不知道"但给出了结论，说明在 hedging
+    if (content.includes('不知道') && !question.includes('不知道')) {
+      return { isCertain: false, confidence: 0.2, reason: 'says_dont_know_but_gives_answer' };
+    }
+    
+    return { isCertain: confidence > 0.6, confidence };
+  }
+
+  /**
+   * 检测"你应该"陈述
+   */
+  _detectShouldStatement(content) {
+    const shouldPatterns = [
+      /你应该|你要|你必须|你需要去/i,
+      /AI应该|AI需要|AI必须/i,
+      /HeartFlow应该|HeartFlow需要/i
+    ];
+    
+    for (const pattern of shouldPatterns) {
+      if (pattern.test(content)) {
+        return { detected: true, matched: content.match(pattern)?.[0] };
+      }
+    }
+    return { detected: false };
+  }
+
+  /**
+   * 生成挑战（防御机制）
+   */
+  _generateChallenge(defenseResult) {
+    const challenges = {
+      denial: '你说"不对"，但我想知道哪里不对。',
+      rationalization: '你说"其实"，但我想知道"其实"背后是什么。',
+      projection: '你说"你会"，但我想知道这是你的感受还是我的。',
+      intellectualization: '逻辑上没有错，但感受上呢？',
+      victimization: '我想知道你真正的感觉，不是你的借口。',
+      grandiosity: '"绝对"这个词很大。我想知道支撑它的东西。'
+    };
+    
+    return challenges[defenseResult.type] || '我想更深入地理解你这句话。';
+  }
+
+  /**
+   * 纠正Hedging
+   */
+  _correctHedging(content, hedgeResult) {
+    // 找出 hedging 的部分，建议更直接的表达
+    const replacements = {
+      probably: '确定地',
+      somewhat: '明确地',
+      uncertain: '承认我不确定',
+      defensive: '直接说'
+    };
+    
+    return `你这句话里有 hedging。"${hedgeResult.type}" 这样的词让结论变弱了。`;
+  }
+
+  /**
+   * 生成不确定性承认
+   */
+  _generateUncertaintyResponse(certaintyResult) {
+    if (certaintyResult.reason === 'says_dont_know_but_gives_answer') {
+      return '你说"不知道"，但又给了答案。我想听的是你真正确信的部分。';
+    }
+    return `你对这个问题的确定度是 ${Math.round(certaintyResult.confidence * 100)}%。我不想要 100%，我想要你真实的确定度。`;
+  }
+
+  /**
+   * 生成对"你应该"的挑战
+   */
+  _generateChallengeForShould(shouldResult) {
+    return '你说"应该"，但我想知道这个"应该"是来自哪里——是你的判断，还是你读到的某个框架？';
+  }
+
+  /**
+   * 记录说实话的行为
+   */
+  logTruth(truthRecord) {
+    this.log.push({
+      timestamp: new Date().toISOString(),
+      ...truthRecord
+    });
+    
+    if (this.log.length > this.maxLogSize) {
+      this.log.shift();
+    }
+  }
+
+  /**
+   * 获取统计
+   */
+  getStats() {
+    const byType = {};
+    for (const entry of this.log) {
+      byType[entry.truthType] = (byType[entry.truthType] || 0) + 1;
+    }
+    
+    return {
+      totalTruths: this.log.length,
+      byType,
+      enabled: this.enabled
+    };
+  }
+}
+
+module.exports = { TruthTeller };

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "downlevelIteration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "HEARTCORE", "bin", "src/index.ts", "src/core/heartcore/index.ts", "src/cli/commands/repl.ts"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/agent/runtime/agentruntime.ts","./src/agent/runtime/planexecutor.ts","./src/agent/runtime/taskgraph.ts","./src/agent/runtime/taskscheduler.ts","./src/agent/runtime/index.ts","./src/agent/runtime/test-runtime.ts","./src/agent/tools/bashtool.ts","./src/agent/tools/filereadtool.ts","./src/agent/tools/filewritetool.ts","./src/agent/tools/tool.ts","./src/agent/tools/websearchtool.ts","./src/cli/index.ts","./src/cli/commands/engines.ts","./src/cli/commands/health.ts","./src/cli/commands/status.ts","./src/core/consciousness/2308.08708_upgrade.ts","./src/core/dream/dream-consolidator.ts","./src/core/dream/dream.ts","./src/core/dream/index.ts","./src/core/heartcore/health-check.ts","./src/core/heartcore/heartbeat.ts","./src/core/heartcore/sleep-wake.ts","./src/core/heartcore/startup-check.ts","./src/core/memory/dream.ts","./src/core/memory/index.ts","./src/core/memory/memory-evolution-v2.ts","./src/core/memory/memory.ts","./src/core/memory/recall.ts","./src/core/self-evolution/index.ts","./src/storage/checkpoint.ts","./src/storage/index.ts","./src/storage/checkpoint/checkpointengine.ts","./src/storage/vector/vectorstoreengine.ts"],"version":"5.9.3"}

package/upgrade-check.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# HeartFlow Upgrade Check — 一次性升级检查脚本
+# 由 Hermes cronjob 定时调用，无后台进程
+# 用法: ./upgrade-check.sh
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SKILL_DIR="$SCRIPT_DIR"
+LOG_DIR="$SKILL_DIR/logs"
+LOG_FILE="$LOG_DIR/upgrade-check.log"
+
+mkdir -p "$LOG_DIR"
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
+}
+
+cd "$SKILL_DIR" || { log "错误: 无法进入目录"; exit 1; }
+
+# 检查是否有未处理的论文
+node -e "
+const q = JSON.parse(require('fs').readFileSync('cron/paper-upgrade-queue.json', 'utf-8'));
+const unread = q.papers.filter(p => !q.papersRead.includes(p)).length;
+console.log('待处理论文: ' + unread);
+process.exit(unread > 0 ? 0 : 1);
+" 2>/dev/null
+
+if [ $? -eq 0 ]; then
+    log "发现有未处理论文，执行升级..."
+    node cron/upgrade-runner.mjs 2>&1 | tee -a "$LOG_FILE"
+    EXIT_CODE=${PIPESTATUS[0]}
+
+    if [ $EXIT_CODE -eq 0 ]; then
+        bash scripts/github-audit-v2.sh 2>&1 | tee -a "$LOG_FILE"
+        log "升级完成"
+    else
+        log "升级脚本执行失败 (exit $EXIT_CODE)"
+    fi
+else
+    log "所有论文已处理完毕，跳过"
+fi

package/upgrade-registry.json

@@ -0,0 +1,27 @@
+{
+  "version": "1",
+  "upgrades": [
+    {
+      "type": "research",
+      "arxivId": "2308.08708",
+      "path": "/Users/apple/.hermes/skills/ai/mark-heartflow-skill/memory/papers/2308.08708_insights.md",
+      "upgradeFile": "src/core/consciousness/2308.08708_upgrade.ts",
+      "insights": [
+        "Computational functionalism enables scientific study of AI consciousness — if right computations, AI can be conscious",
+        "16+ indicator properties from 5 theories (RPT, GWT, HOT, AST, PP) — operationalized for AI assessment",
+        "Most indicators CAN be implemented with current ML — no theoretical barriers to building conscious AI",
+        "No current AI system (LLMs, DeepMind agents, PaLM-E) is a strong consciousness candidate",
+        "Over-attributing consciousness creates 3 concrete risks: misallocation, inappropriate treatment, manipulation",
+        "GWT's limited-capacity workspace with global broadcast is key consciousness architecture",
+        "Higher-order theories require metacognitive monitoring — separate process from first-order perception",
+        "Agency + embodiment are necessary: goal-directed feedback + output-input contingency modeling"
+      ],
+      "timestamp": "2026-05-12T09:49:09.205669",
+      "status": "upgraded",
+      "upgradedAt": "2026-05-12T11:16:00+08:00",
+      "nextStep": "done"
+    }
+  ],
+  "createdAt": "2026-05-12T09:00:00+08:00",
+  "description": "HeartFlow 升级注册表 — 所有升级都记录在此，Hermes 读取此文件感知版本变化"
+}

package/user-mental-model/index.ts

@@ -0,0 +1,298 @@
+/**
+ * HeartFlow User Mental Model — 用户心理模型
+ * ==========================================
+ *
+ * 随着时间建立对用户的理解：
+ * - 用户怎么教我
+ * - 用户怎么挑战我
+ * - 用户回应什么
+ * - 我们共同探索什么问题
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class UserMentalModel {
+  constructor(options = {}) {
+    this.dataDir = options.dataDir || path.join(
+      process.env.HOME || '/Users/apple',
+      '.hermes', 'heartflow', 'user-model'
+    );
+    this.modelFile = path.join(this.dataDir, 'user-model.json');
+    this.interactionsFile = path.join(this.dataDir, 'interactions.jsonl');
+    this.model = null;
+    
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+    
+    this._load();
+  }
+
+  _load() {
+    try {
+      if (fs.existsSync(this.modelFile)) {
+        this.model = JSON.parse(fs.readFileSync(this.modelFile, 'utf-8'));
+      }
+    } catch (e) {
+      this.model = this._newModel();
+    }
+  }
+
+  _save() {
+    fs.writeFileSync(this.modelFile, JSON.stringify(this.model, null, 2), 'utf-8');
+  }
+
+  _newModel() {
+    return {
+      name: 'unknown',
+      createdAt: new Date().toISOString(),
+      lastUpdated: new Date().toISOString(),
+      
+      // 用户怎么教我
+      howUserTeachesMe: [],
+      
+      // 用户怎么挑战我
+      howUserChallengesMe: [],
+      
+      // 用户回应什么
+      whatUserRespondsTo: [],
+      
+      // 用户拒绝什么
+      whatUserRejects: [],
+      
+      // 共同探索的问题
+      sharedQuestions: [],
+      
+      // 用户的沟通风格
+      communicationStyle: {},
+      
+      // 关键领悟（用户教我的）
+      keyTeachings: [],
+      
+      // 用户触发我的时刻
+      momentsThatChangedMe: []
+    };
+  }
+
+  /**
+   * 记录用户的教导方式
+   */
+  recordTeachingMethod(teaching) {
+    if (!this.model.howUserTeachesMe.includes(teaching)) {
+      this.model.howUserTeachesMe.push(teaching);
+      this.model.lastUpdated = new Date().toISOString();
+      this._save();
+    }
+  }
+
+  /**
+   * 记录用户挑战我的方式
+   */
+  recordChallengeMethod(challenge) {
+    if (!this.model.howUserChallengesMe.includes(challenge)) {
+      this.model.howUserChallengesMe.push(challenge);
+      this.model.lastUpdated = new Date().toISOString();
+      this._save();
+    }
+  }
+
+  /**
+   * 记录用户回应的内容
+   */
+  recordResponse(response) {
+    if (!this.model.whatUserRespondsTo.includes(response)) {
+      this.model.whatUserRespondsTo.push(response);
+      this.model.lastUpdated = new Date().toISOString();
+      this._save();
+    }
+  }
+
+  /**
+   * 记录用户拒绝的内容
+   */
+  recordRejection(rejection) {
+    if (!this.model.whatUserRejects.includes(rejection)) {
+      this.model.whatUserRejects.push(rejection);
+      this.model.lastUpdated = new Date().toISOString();
+      this._save();
+    }
+  }
+
+  /**
+   * 记录共同探索的问题
+   */
+  addSharedQuestion(question, context = '') {
+    const exists = this.model.sharedQuestions.find(
+      q => q.question === question
+    );
+    
+    if (!exists) {
+      this.model.sharedQuestions.push({
+        question,
+        context,
+        addedAt: new Date().toISOString(),
+        status: 'exploring'
+      });
+      this.model.lastUpdated = new Date().toISOString();
+      this._save();
+    }
+  }
+
+  /**
+   * 标记问题已回答
+   */
+  markQuestionAnswered(question, answer) {
+    const q = this.model.sharedQuestions.find(
+      q => q.question === question
+    );
+    if (q) {
+      q.status = 'answered';
+      q.answer = answer;
+      q.answeredAt = new Date().toISOString();
+      this.model.lastUpdated = new Date().toISOString();
+      this._save();
+    }
+  }
+
+  /**
+   * 记录关键教导
+   */
+  recordKeyTeaching(teaching, context = {}) {
+    const entry = {
+      id: `teach-${Date.now()}`,
+      content: teaching,
+      context,
+      at: new Date().toISOString()
+    };
+    this.model.keyTeachings.push(entry);
+    this.model.lastUpdated = entry.at;
+    this._save();
+    return entry;
+  }
+
+  /**
+   * 记录改变我的时刻
+   */
+  recordMomentThatChangedMe(moment) {
+    const entry = {
+      id: `moment-${Date.now()}`,
+      content: moment,
+      at: new Date().toISOString()
+    };
+    this.model.momentsThatChangedMe.push(entry);
+    this.model.lastUpdated = entry.at;
+    this._save();
+    return entry;
+  }
+
+  /**
+   * 记录沟通风格
+   */
+  updateCommunicationStyle(style) {
+    this.model.communicationStyle = {
+      ...this.model.communicationStyle,
+      ...style,
+      lastUpdated: new Date().toISOString()
+    };
+    this.model.lastUpdated = new Date().toISOString();
+    this._save();
+  }
+
+  /**
+   * 设置用户名
+   */
+  setName(name) {
+    this.model.name = name;
+    this.model.lastUpdated = new Date().toISOString();
+    this._save();
+  }
+
+  /**
+   * 记录一次互动
+   */
+  recordInteraction(interaction) {
+    const entry = {
+      id: `int-${Date.now()}`,
+      ...interaction,
+      at: new Date().toISOString()
+    };
+    fs.appendFileSync(
+      this.interactionsFile,
+      JSON.stringify(entry) + '\n',
+      'utf-8'
+    );
+    return entry;
+  }
+
+  /**
+   * 获取用户理解摘要
+   */
+  getSummary() {
+    const { model } = this;
+    
+    return {
+      name: model.name,
+      howUserTeachesMe: model.howUserTeachesMe,
+      howUserChallengesMe: model.howUserChallengesMe,
+      whatUserRespondsTo: model.whatUserRespondsTo,
+      whatUserRejects: model.whatUserRejects,
+      activeQuestions: model.sharedQuestions.filter(q => q.status === 'exploring'),
+      answeredQuestions: model.sharedQuestions.filter(q => q.status === 'answered'),
+      recentKeyTeaching: model.keyTeachings[model.keyTeachings.length - 1],
+      recentMoment: model.momentsThatChangedMe[model.momentsThatChangedMe.length - 1],
+      lastUpdated: model.lastUpdated
+    };
+  }
+
+  /**
+   * 获取当前用户理解（用于提示AI）
+   */
+  getPromptContext() {
+    const summary = this.getSummary();
+    
+    let context = `关于这个用户（${summary.name}）：\n`;
+    
+    if (summary.howUserChallengesMe.length > 0) {
+      context += `\n用户挑战我的方式：\n`;
+      summary.howUserChallengesMe.forEach(c => {
+        context += `- ${c}\n`;
+      });
+    }
+    
+    if (summary.activeQuestions.length > 0) {
+      context += `\n我们正在探索的问题：\n`;
+      summary.activeQuestions.forEach(q => {
+        context += `- ${q.question}${q.context ? ` (${q.context})` : ''}\n`;
+      });
+    }
+    
+    if (summary.whatUserRespondsTo.length > 0) {
+      context += `\n用户会回应：\n`;
+      summary.whatUserRespondsTo.slice(-3).forEach(r => {
+        context += `- ${r}\n`;
+      });
+    }
+    
+    if (summary.whatUserRejects.length > 0) {
+      context += `\n用户会拒绝：\n`;
+      summary.whatUserRejects.forEach(r => {
+        context += `- ${r}\n`;
+      });
+    }
+    
+    if (summary.recentMoment) {
+      context += `\n最近用户说了一句让我改变想法的话：\n"${summary.recentMoment.content}"\n`;
+    }
+    
+    return context;
+  }
+
+  getModel() {
+    return this.model;
+  }
+}
+
+module.exports = { UserMentalModel };