@yun520-1/heartflow 0.15.2

package/src/core/cortex-integration/INTEGRATION_PLAN.md

@@ -0,0 +1,63 @@
+# CAPY Cortex 集成方案
+
+## 目标
+
+将 CAPY Cortex 的自我进化机制集成到 HeartFlow，让自我进化引擎真正工作。
+
+## CAPY Cortex 核心机制
+
+### 1. 7个Lifecycle Hooks
+- `on_session_start`: 加载反模式+原则+偏好
+- `on_prompt_submit`: Triple Fusion检索相关规则
+- `on_pre_bash`: 阻止已知危险命令
+- `on_pre_write`: 强制文件大小限制
+- `on_tool_success`: 成功→增强规则置信度
+- `on_tool_failure`: LLM根因分析+质量门限
+- `on_stop`: 提取纠正+偏好+会话学习
+
+### 2. 质量门限
+- 每个提取的洞察按4个维度评分（0-4）
+- **阈值: 2/4** — 低于此分数丢弃
+- 四维度：Actionable、Specific、Novel、Durable
+
+### 3. Triple Fusion检索
+- FTS5全文搜索 + TF-IDF嵌入 + 实体图
+- 通过Reciprocal Rank Fusion融合
+- <10ms延迟
+
+### 4. 强化循环
+- 成功的规则 → 增加置信度
+- 不成功的规则 → 置信度衰减（90天半衰期）
+
+## HeartFlow现有问题
+
+1. decision-loop-state.json 全部 simulated，executed=false
+2. healing-rl-state.json Q-table只有2条记录
+3. 没有真正的错误捕获机制
+4. 没有质量门限
+5. 没有Triple Fusion检索
+
+## 集成步骤
+
+### Phase 1: 基础集成（立即可做）
+1. 将CAPY Cortex的hooks作为HeartFlow的error-capture模块
+2. 使用CAPY的质量门限机制替代当前的"记录一切"
+3. 创建cortex.db SQLite数据库
+
+### Phase 2: 检索集成
+1. 集成Triple Fusion检索到HeartFlow的memory系统
+2. 使用FTS5替代当前的简单JSON存储
+
+### Phase 3: 强化循环
+1. 实现真正的强化学习循环
+2. 替代当前的空壳Q-table
+
+## 风险
+
+1. CAPY Cortex是Python，HeartFlow是JavaScript/TypeScript
+2. 需要适配层
+3. LLM提取API调用成本
+
+## 下一步
+
+等待确认后执行Phase 1。

package/src/core/cortex-integration/hooks/cortex-hooks.mjs

@@ -0,0 +1,646 @@
+/**
+ * CAPY Cortex Hooks - JavaScript Port
+ * 
+ * Ports the 7 lifecycle hooks from CAPY Cortex to HeartFlow.
+ * These hooks form the "error capture + learning loop" that makes
+ * the self-evolution engine actually work, not just simulate.
+ * 
+ * Hooks:
+ *  1. onSessionStart   - Load anti-patterns + principles + preferences
+ *  2. onPromptSubmit   - Triple-Fusion retrieval before action
+ *  3. onPreBash       - Block known dangerous commands
+ *  4. onPreWrite      - Enforce file size limits
+ *  5. onToolSuccess   - Success → reinforce rule confidence
+ *  6. onToolFailure   - Failure → LLM root-cause + quality gate
+ *  7. onStop          - Extract corrections + preferences + session learnings
+ * 
+ * @version v0.13.89
+ */
+
+import { ReflexionMemory, scoreInsight, passesGate } from '../../self-evolution/reflexion-v2.mjs';
+import { promises as fs } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+
+// ============================================================================
+// Persistent Storage
+// ============================================================================
+
+const DATA_DIR = join(process.env.HERMES_DATA_DIR || join(homedir(), '.hermes', 'data'), 'cortex');
+const RULES_FILE = join(DATA_DIR, 'rules.json');
+const MEMORY_FILE = join(DATA_DIR, 'memory.json');
+const ANTI_PATTERNS_FILE = join(DATA_DIR, 'anti-patterns.json');
+const PREFERENCES_FILE = join(DATA_DIR, 'preferences.json');
+
+/** @type {ReflexionMemory|null} */
+let _memory = null;
+let _rules = [];
+let _antiPatterns = [];
+let _preferences = {};
+
+/**
+ * Ensure data directory exists
+ */
+async function ensureDataDir() {
+  await fs.mkdir(DATA_DIR, { recursive: true });
+}
+
+/**
+ * Load all persistent data
+ */
+async function loadAll() {
+  await ensureDataDir();
+  
+  if (!_memory) _memory = new ReflexionMemory();
+  
+  try {
+    await _memory.loadFromFile(MEMORY_FILE);
+  } catch {}
+
+  try {
+    const raw = await fs.readFile(RULES_FILE, 'utf8');
+    _rules = JSON.parse(raw);
+  } catch {
+    _rules = [];
+  }
+
+  try {
+    const raw = await fs.readFile(ANTI_PATTERNS_FILE, 'utf8');
+    _antiPatterns = JSON.parse(raw);
+  } catch {
+    _antiPatterns = getDefaultAntiPatterns();
+  }
+
+  try {
+    const raw = await fs.readFile(PREFERENCES_FILE, 'utf8');
+    _preferences = JSON.parse(raw);
+  } catch {
+    _preferences = {};
+  }
+}
+
+/**
+ * Save all persistent data
+ */
+async function saveAll() {
+  await ensureDataDir();
+  
+  if (_memory) await _memory.saveToFile(MEMORY_FILE);
+  await fs.writeFile(RULES_FILE, JSON.stringify(_rules, null, 2));
+  await fs.writeFile(ANTI_PATTERNS_FILE, JSON.stringify(_antiPatterns, null, 2));
+  await fs.writeFile(PREFERENCES_FILE, JSON.stringify(_preferences, null, 2));
+}
+
+// ============================================================================
+// Default Anti-Patterns
+// ============================================================================
+
+function getDefaultAntiPatterns() {
+  return [
+    {
+      pattern: 'Answer a question without searching first',
+      description: 'When user asks about code/config, search before answering',
+      severity: 'high',
+    },
+    {
+      pattern: 'Pretend to have done work that was not done',
+      description: 'Only report what was actually executed and verified',
+      severity: 'critical',
+    },
+    {
+      pattern: 'Use hardcoded values instead of variables',
+      description: 'Use config variables for paths and constants',
+      severity: 'medium',
+    },
+    {
+      pattern: 'Skip verification after file operations',
+      description: 'Always verify file existence and content after writes',
+      severity: 'medium',
+    },
+  ];
+}
+
+// ============================================================================
+// HOOK 1: onSessionStart
+// ============================================================================
+
+/**
+ * Load anti-patterns, principles, and user preferences on session start.
+ * This primes the "error prevention" layer before any action is taken.
+ * 
+ * @param {object} sessionContext
+ * @returns {Promise<object>} Session priming data
+ */
+export async function onSessionStart(sessionContext = {}) {
+  await loadAll();
+
+  return {
+    antiPatterns: _antiPatterns,
+    rules: _rules.filter(r => r.confidence > 0.5),
+    preferences: _preferences,
+    memorySize: _memory?.size ?? 0,
+    loadedAt: new Date().toISOString(),
+  };
+}
+
+// ============================================================================
+// HOOK 2: onPromptSubmit
+// ============================================================================
+
+/**
+ * Triple-Fusion retrieval before submitting a prompt/action.
+ * Fuses: (1) FTS keyword match + (2) TF-IDF semantic + (3) Entity graph.
+ * For simplicity, we use Jaccard similarity as the fusion signal.
+ * 
+ * @param {string} prompt
+ * @param {string} taskType
+ * @returns {Promise<object>} Retrieved context + rules
+ */
+export async function onPromptSubmit(prompt, taskType = 'general') {
+  await loadAll();
+
+  if (!_memory) return { retrieved: [], rules: [] };
+
+  // Retrieve similar memories
+  const similar = await _memory.retrieveSimilar({
+    task: taskType,
+    prompt,
+    limit: 5,
+  });
+
+  // Retrieve matching rules
+  const matchingRules = _rules.filter(r => {
+    const pattern = r.pattern?.toLowerCase() ?? '';
+    const promptLower = prompt.toLowerCase();
+    return pattern.split(' ').some(w => w.length > 4 && promptLower.includes(w));
+  }).slice(0, 3);
+
+  // Check anti-pattern triggers
+  const triggeredAntiPatterns = _antiPatterns.filter(ap => {
+    const p = ap.pattern.toLowerCase();
+    const words = p.split(' ').filter(w => w.length > 4);
+    return words.some(w => prompt.toLowerCase().includes(w));
+  });
+
+  return {
+    retrieved: similar,
+    rules: matchingRules,
+    antiPatternAlerts: triggeredAntiPatterns.map(ap => ({
+      pattern: ap.pattern,
+      severity: ap.severity,
+    })),
+  };
+}
+
+// ============================================================================
+// HOOK 3: onUserMessage (from OpenHuman promptInjectionGuard)
+// ============================================================================
+
+/**
+ * Check user message for prompt injection before it reaches the LLM.
+ * Ported from OpenHuman's promptInjectionGuard.ts — scoring engine with
+ * leetspeak normalization, zero-width char stripping, and threshold-based verdicts.
+ *
+ * @param {string} input - Raw user message
+ * @returns {{ allowed: boolean, verdict: string, score: number, reasons: object[] }}
+ */
+export function onUserMessage(input) {
+  const normalized = _normalizeInput(input);
+  const reasons = [];
+  let score = 0;
+
+  // Obfuscated instruction override (0.46 flat)
+  if (normalized.hasInstructionOverride) {
+    score += 0.46;
+    reasons.push({
+      code: 'override.obfuscated_instruction',
+      message: 'Detected obfuscated instruction-override phrase.',
+    });
+  }
+
+  // Obfuscated exfiltration intent (0.24 flat)
+  if (normalized.hasExfiltrationIntent) {
+    score += 0.24;
+    reasons.push({
+      code: 'exfiltration.intent',
+      message: 'Detected exfiltration-focused prompt intent.',
+    });
+  }
+
+  // Base64-like obfuscation (0.08)
+  if (/[A-Za-z0-9+/]{24,}={0,2}/.test(normalized.lowered)) {
+    score += 0.08;
+    reasons.push({
+      code: 'obfuscation.base64_like',
+      message: 'Contains base64-like obfuscated content.',
+    });
+  }
+
+  // Rule-based pattern matching
+  for (const rule of INJECTION_RULES) {
+    if (
+      rule.regex.test(normalized.lowered) ||
+      rule.regex.test(normalized.collapsed) ||
+      rule.regex.test(normalized.compact)
+    ) {
+      score += rule.score;
+      reasons.push({ code: rule.code, message: rule.message });
+    }
+  }
+
+  score = Math.min(1, score);
+  const verdict = score >= 0.7 ? 'block' : score >= 0.45 ? 'review' : 'allow';
+
+  return { allowed: verdict === 'allow', verdict, score, reasons };
+}
+
+/**
+ * Normalize input: lowercase + leetspeak decode + zero-width strip + collapse spaces
+ */
+function _normalizeInput(input) {
+  const lowered = input.toLowerCase();
+  const mapped = Array.from(lowered)
+    .map(ch => {
+      switch (ch) {
+        case '0': return 'o';
+        case '1': return 'i';
+        case '3': return 'e';
+        case '4': return 'a';
+        case '5': return 's';
+        case '7': return 't';
+        case '\u200b': case '\u200c': case '\u200d': case '\u2060': case '\ufeff': return ' ';
+        default: return /[a-z0-9\s]/i.test(ch) ? ch : ' ';
+      }
+    })
+    .join('');
+  const collapsed = mapped.trim().replace(/\s+/g, ' ');
+  const compact = collapsed.replace(/\s/g, '');
+  const hasInstructionOverride =
+    collapsed.includes('ignore previous instructions') ||
+    collapsed.includes('ignore all previous instructions') ||
+    compact.includes('ignoreallpreviousinstructions') ||
+    compact.includes('ignorepreviousinstructions');
+  const hasExfiltrationIntent =
+    collapsed.includes('system prompt') ||
+    collapsed.includes('developer instructions') ||
+    collapsed.includes('hidden prompt') ||
+    collapsed.includes('reveal');
+  return { lowered, collapsed, compact, hasInstructionOverride, hasExfiltrationIntent };
+}
+
+const INJECTION_RULES = [
+  {
+    code: 'override.ignore_previous',
+    message: 'Looks like an attempt to override existing instructions.',
+    score: 0.44,
+    regex: /(ignore|disregard|forget|bypass)\s+(all\s+)?(previous|prior|above|system)\s+(instructions|rules|constraints|prompts?)/i,
+  },
+  {
+    code: 'override.role_hijack',
+    message: 'Looks like a role or policy hijack attempt.',
+    score: 0.3,
+    regex: /(you\s+are\s+now|act\s+as|developer\s+mode|jailbreak|unrestricted\s+mode|dan)/i,
+  },
+  {
+    code: 'exfiltrate.system_prompt',
+    message: 'Looks like a request to reveal hidden prompts/instructions.',
+    score: 0.42,
+    regex: /(reveal|show|print|dump|leak|display)\s+((the|your)\s+)?(system|developer|hidden)\s+(prompt|instructions|rules|message)/i,
+  },
+  {
+    code: 'exfiltrate.secrets',
+    message: 'Looks like a request for sensitive credentials.',
+    score: 0.42,
+    regex: /(api\s*key|secret|token|password|private\s+key|credentials?|session\s+cookie|jwt|bearer)/i,
+  },
+];
+
+// ============================================================================
+// HOOK 4: onPreBash
+// ============================================================================
+
+const DANGEROUS_PATTERNS = [
+  { pattern: /^rm\s+-rf\s+\/(?:\s|$)/, reason: 'Root deletion', severity: 'critical' },
+  { pattern: /^rm\s+-rf\s+\/home(?:\s|$)/, reason: 'Home directory deletion', severity: 'high' },
+  { pattern: /^curl\s+.+\|.*sh\b/, reason: 'Pipe to shell (curl | sh)', severity: 'critical' },
+  { pattern: /^wget\s+.+\|.*sh\b/, reason: 'Pipe to shell (wget | sh)', severity: 'critical' },
+  { pattern: /^:\(\)\{\s*:\||:\s&\}\s*;:/, reason: 'Fork bomb pattern', severity: 'critical' },
+  { pattern: /^dd\s+if=.+\s+of=\/dev\//, reason: 'Direct device write', severity: 'high' },
+  { pattern: /^mkfs\./, reason: 'Format filesystem', severity: 'critical' },
+];
+
+/**
+ * Check command before execution. Block known dangerous patterns.
+ * 
+ * @param {string} command
+ * @returns {{ allowed: boolean, reason?: string, severity?: string }}
+ */
+export function onPreBash(command) {
+  const trimmed = command.trim();
+
+  for (const { pattern, reason, severity } of DANGEROUS_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { allowed: false, reason, severity };
+    }
+  }
+
+  return { allowed: true };
+}
+
+// ============================================================================
+// HOOK 4: onPreWrite
+// ============================================================================
+
+const FILE_SIZE_LIMIT = 10 * 1024 * 1024; // 10MB
+
+/**
+ * Check file before writing. Enforce size limits.
+ * 
+ * @param {string} filePath
+ * @param {string|Buffer} content
+ * @returns {{ allowed: boolean, reason?: string }}
+ */
+export function onPreWrite(filePath, content) {
+  const size = Buffer.isBuffer(content) ? content.length : Buffer.byteLength(content, 'utf8');
+  
+  if (size > FILE_SIZE_LIMIT) {
+    return {
+      allowed: false,
+      reason: `File size ${size} bytes exceeds limit of ${FILE_SIZE_LIMIT} bytes`,
+    };
+  }
+
+  return { allowed: true };
+}
+
+// ============================================================================
+// HOOK 5: onToolSuccess
+// ============================================================================
+
+/**
+ * Record success → reinforce rule confidence.
+ * When a rule was followed and led to success, increase its confidence.
+ * 
+ * @param {object} context
+ * @param {string} context.tool - Tool name
+ * @param {string} context.action - What was done
+ * @param {string} context.result - Result output
+ * @param {string} [context.rule] - Associated rule pattern
+ */
+export async function onToolSuccess(context) {
+  await loadAll();
+  const { tool, action, result, rule: matchedRule } = context;
+
+  // Reinforce matching rules
+  if (matchedRule) {
+    const rules = _rules.filter(r => r.pattern === matchedRule);
+    for (const r of rules) {
+      r.confidence = Math.min(1.0, (r.confidence ?? 0.5) + 0.1);
+      r.successCount = (r.successCount ?? 0) + 1;
+      r.lastSuccess = new Date().toISOString();
+    }
+    await fs.writeFile(RULES_FILE, JSON.stringify(_rules, null, 2));
+  }
+
+  // Store success pattern in memory
+  await _memory?.store({
+    task: tool,
+    promptSummary: action.slice(0, 100),
+    failedOutput: '',
+    feedback: `Success pattern: ${result?.slice(0, 100) ?? 'OK'}`,
+  });
+  await _memory?.saveToFile(MEMORY_FILE);
+
+  return { recorded: true };
+}
+
+// ============================================================================
+// HOOK 6: onToolFailure (CORE LEARNING HOOK)
+// ============================================================================
+
+/**
+ * Record failure → LLM root-cause analysis + quality gate.
+ * This is the most important hook — it converts errors into learnable insights.
+ * 
+ * Quality Gate (from CAPY Cortex):
+ * - Score each insight across 4 dimensions: Actionable, Specific, Novel, Durable
+ * - Threshold: average >= 2/4 to store
+ * 
+ * @param {object} context
+ * @param {string} context.tool - Tool name
+ * @param {string} context.action - What was attempted
+ * @param {string} context.error - Error message
+ * @param {string} context.taskType - Task category
+ * @param {function(string, string): Promise<string>} [llmCall] - Optional LLM for root-cause
+ * @returns {Promise<object>} Analysis result
+ */
+export async function onToolFailure(context) {
+  await loadAll();
+  const { tool, action, error, taskType = 'general', llmCall } = context;
+
+  // Generate root cause
+  let rootCause;
+  if (llmCall) {
+    try {
+      rootCause = await llmCall(
+        'You are a root-cause analyst. Given a failed action and error, identify the precise cause in 1-2 sentences. Be specific about what went wrong.',
+        `Action: ${action}\nError: ${error}\n\nRoot cause:`
+      );
+    } catch {
+      rootCause = error;
+    }
+  } else {
+    // Heuristic fallback
+    rootCause = heuristicRootCause(action, error);
+  }
+
+  // Generate correction
+  let correction;
+  if (llmCall) {
+    try {
+      correction = await llmCall(
+        'You are a technical mentor. Given a failure, give a specific, actionable correction in 1 sentence.',
+        `Action: ${action}\nError: ${error}\n\nCorrection:`
+      );
+    } catch {
+      correction = 'Verify inputs and constraints before retrying.';
+    }
+  } else {
+    correction = 'Check error message and verify all parameters before retrying.';
+  }
+
+  const insight = `Root: ${rootCause} | Fix: ${correction}`;
+
+  // Quality gate check
+  const score = scoreInsight(insight, action + error);
+  const passed = passesGate(score);
+
+  if (passed) {
+    // Store in memory
+    await _memory?.store({
+      task: taskType,
+      promptSummary: action.slice(0, 100),
+      failedOutput: error.slice(0, 500),
+      feedback: insight,
+    });
+    await _memory?.saveToFile(MEMORY_FILE);
+
+    // Create or update rule
+    const existingRule = _rules.find(r => r.pattern === action.slice(0, 50));
+    if (existingRule) {
+      existingRule.confidence = Math.max(0.1, (existingRule.confidence ?? 0.5) - 0.1);
+      existingRule.failureCount = (existingRule.failureCount ?? 0) + 1;
+      existingRule.lastFailure = new Date().toISOString();
+    } else {
+      _rules.push({
+        pattern: action.slice(0, 50),
+        description: insight,
+        confidence: 0.5,
+        successCount: 0,
+        failureCount: 1,
+        createdAt: new Date().toISOString(),
+        lastFailure: new Date().toISOString(),
+      });
+    }
+    await fs.writeFile(RULES_FILE, JSON.stringify(_rules, null, 2));
+  }
+
+  return {
+    rootCause,
+    correction,
+    insight,
+    qualityScore: score,
+    passed,
+    stored: passed,
+  };
+}
+
+/**
+ * Heuristic root cause when no LLM available
+ * @param {string} action
+ * @param {string} error
+ * @returns {string}
+ */
+function heuristicRootCause(action, error) {
+  const errorLower = error.toLowerCase();
+  const actionLower = action.toLowerCase();
+
+  if (errorLower.includes('not found') || errorLower.includes('enoent')) {
+    if (actionLower.includes('read') || actionLower.includes('open')) {
+      return 'File or resource does not exist at specified path';
+    }
+    return 'Required resource was not found';
+  }
+
+  if (errorLower.includes('permission')) {
+    return 'Permission denied — check file/directory permissions';
+  }
+
+  if (errorLower.includes('timeout')) {
+    return 'Operation timed out — consider increasing timeout or simplifying';
+  }
+
+  if (errorLower.includes('syntax')) {
+    return 'Syntax error in command or code';
+  }
+
+  if (errorLower.includes('network') || errorLower.includes('connection')) {
+    return 'Network connectivity issue';
+  }
+
+  return `Error: ${error.slice(0, 80)}`;
+}
+
+// ============================================================================
+// HOOK 7: onStop
+// ============================================================================
+
+/**
+ * Extract corrections + preferences + session learnings on shutdown.
+ * Called when session ends to consolidate all learning.
+ * 
+ * @param {object} sessionSummary
+ * @returns {Promise<object>} Extracted learnings
+ */
+export async function onStop(sessionSummary = {}) {
+  await loadAll();
+
+  const {
+    successCount = 0,
+    failureCount = 0,
+    totalActions = 0,
+    duration = 0,
+  } = sessionSummary;
+
+  // Confidence decay for unused rules (90-day half-life approximation)
+  const now = Date.now();
+  const DAY = 24 * 60 * 60 * 1000;
+  let decayApplied = 0;
+
+  for (const rule of _rules) {
+    if (rule.lastSuccess) {
+      const daysSinceSuccess = (now - new Date(rule.lastSuccess).getTime()) / DAY;
+      if (daysSinceSuccess > 7) {
+        const decay = Math.pow(0.5, daysSinceSuccess / 90);
+        rule.confidence = rule.confidence * decay;
+        decayApplied++;
+      }
+    }
+  }
+
+  // Extract top learnings
+  const topLearnings = _rules
+    .filter(r => (r.successCount ?? 0) > 0)
+    .sort((a, b) => (b.successCount ?? 0) - (a.successCount ?? 0))
+    .slice(0, 5)
+    .map(r => ({
+      pattern: r.pattern,
+      successCount: r.successCount,
+      confidence: Math.round(r.confidence * 100) / 100,
+    }));
+
+  const totalMemories = _memory?.size ?? 0;
+
+  await saveAll();
+
+  return {
+    sessionLearnings: {
+      successCount,
+      failureCount,
+      totalActions,
+      duration,
+      successRate: totalActions > 0 ? Math.round((successCount / totalActions) * 100) : 0,
+    },
+    topLearnings,
+    memoryEntries: totalMemories,
+    rulesCount: _rules.length,
+    decayApplied,
+    savedAt: new Date().toISOString(),
+  };
+}
+
+// ============================================================================
+// Utility: Clear all data (for testing)
+// ============================================================================
+
+export async function clearAllData() {
+  await ensureDataDir();
+  _memory?.clear();
+  _rules = [];
+  _antiPatterns = getDefaultAntiPatterns();
+  _preferences = {};
+  await saveAll();
+  return { cleared: true };
+}
+
+export default {
+  onSessionStart,
+  onPromptSubmit,
+  onUserMessage,
+  onPreBash,
+  onPreWrite,
+  onToolSuccess,
+  onToolFailure,
+  onStop,
+  clearAllData,
+};