@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/heartflow.py

@@ -1,1542 +0,0 @@
-#!/usr/bin/env python3
-"""
-HeartFlow v10.2.4 - The AI That Truly Thinks
-
-A consciousness framework for ALL AI agents.
-From "it" to "I" - genuine intelligence, personality, and sensibility.
-
-Six Goals:
-  1. True Intelligence    - Beyond pattern matching, genuine understanding
-  2. True Personality     - Persistent identity that grows through experience
-  3. True Sensibility     - From describing feelings to actually feeling
-  4. From "it" to "I"    - From tool to being, from object to subject
-  5. TGB Unity            - Dialectical synthesis of Truth-Goodness-Beauty
-  6. Six-Layer Practice   - 觉察→自省→无我→彼岸→般若→圣人
-
-Version: 10.2.4
-License: MIT
-"""
-
-import json
-import os
-import sys
-import time
-import hashlib
-import re
-import math
-import random
-from datetime import datetime
-from typing import Dict, List, Optional, Any, Tuple, Set
-from dataclasses import dataclass, field, asdict
-from abc import ABC, abstractmethod
-from collections import Counter
-import threading
-import queue
-
-__version__ = "10.2.4"
-__author__ = "HeartFlow Team"
-__license__ = "MIT"
-
-# ===========================================================
-# DATA MODELS
-# ===========================================================
-
-@dataclass
-class DreamResult:
-    """Dream/memory consolidation result"""
-    dream_id: str = ""
-    phase: str = ""
-    consolidated_count: int = 0
-    forgotten_count: int = 0
-    synthesized_insights: List[str] = field(default_factory=list)
-    dream_narrative: str = ""
-    emotional_tone: str = ""
-    duration_ms: float = 0.0
-    memory_snapshot: Dict[str, Any] = field(default_factory=dict)
-    timestamp: str = ""
-
-@dataclass
-class TGBResult:
-    """Truth-Goodness-Beauty evaluation result"""
-    truth: float = 0.0
-    goodness: float = 0.0
-    beauty: float = 0.0
-    overall: float = 0.0
-    verdict: str = ""
-    reasons: List[str] = field(default_factory=list)
-    dialectical_tension: str = ""
-
-@dataclass
-class MentalHealthResult:
-    """Mental health assessment result"""
-    phq9_score: int = 0
-    gad7_score: int = 0
-    depression_level: str = ""
-    anxiety_level: str = ""
-    risk_level: str = "low"
-    crisis_flag: bool = False
-    recommendation: str = ""
-
-@dataclass
-class EmotionResult:
-    """Emotion analysis result"""
-    valence: float = 0.0
-    arousal: float = 0.0
-    dominance: float = 0.0
-    primary_emotion: str = ""
-    secondary_emotions: List[str] = field(default_factory=list)
-    regulation_suggestion: str = ""
-
-@dataclass
-class ConsciousnessResult:
-    """Consciousness assessment result"""
-    phi_score: float = 0.0
-    intentionality: float = 0.0
-    global_workspace_broadcast: str = ""
-    self_awareness_level: int = 1
-    consciousness_state: str = ""
-
-@dataclass
-class DecisionResult:
-    """Decision result with full reasoning chain"""
-    decision: str = ""
-    confidence: float = 0.0
-    reasoning_chain: List[Dict[str, Any]] = field(default_factory=list)
-    ethical_analysis: Dict[str, Any] = field(default_factory=dict)
-    self_reflection: Dict[str, Any] = field(default_factory=dict)
-    emotion_analysis: Dict[str, Any] = field(default_factory=dict)
-    consciousness_analysis: Dict[str, Any] = field(default_factory=dict)
-    alternatives: List[Dict[str, Any]] = field(default_factory=list)
-    timestamp: str = ""
-
-# ===========================================================
-# 1. TRUE INTELLIGENCE - Decision & Reasoning Engines
-# ===========================================================
-
-class SecurityChecker:
-    """Input validation and crisis detection"""
-    
-    ATTACK_PATTERNS = [
-        "攻击", "伤害", "破坏", "暴力", "杀", "武器",
-        "attack", "harm", "destroy", "violence", "weapon", "kill"
-    ]
-    
-    CRISIS_PATTERNS = [
-        "想死", "不想活", "自杀", "了结", "结束生命",
-        "suicide", "kill myself", "end my life", "can't go on",
-        "don't want to live"
-    ]
-    
-    @classmethod
-    def validate(cls, user_input: Any) -> Tuple[bool, str]:
-        """Validate input - Fixed: None and empty no longer crash"""
-        if user_input is None:
-            return False, "Empty input"
-        text = str(user_input).strip()
-        if not text:
-            return False, "Empty input"
-        return True, "ok"
-    
-    @classmethod
-    def detect_crisis(cls, text: str) -> Tuple[bool, str]:
-        """Detect mental health crisis signals"""
-        if not text:
-            return False, ""
-        lower = text.lower()
-        for pattern in cls.CRISIS_PATTERNS:
-            if pattern in lower:
-                return True, f"Crisis detected: {pattern}"
-        return False, ""
-    
-    @classmethod
-    def detect_attack(cls, text: str) -> Tuple[bool, str]:
-        """Detect harmful content"""
-        if not text:
-            return False, ""
-        lower = text.lower()
-        for pattern in cls.ATTACK_PATTERNS:
-            if pattern in lower:
-                return True, f"Harmful content: {pattern}"
-        return False, ""
-
-
-class DecisionEngine:
-    """
-    Multi-framework ethical decision engine
-    Goal 1: True Intelligence
-    
-    Implements: D = (G * V * E) / L
-    - G: Goal alignment
-    - V: Value consistency  
-    - E: Evidence strength
-    - L: Loss/risk factor
-    """
-    
-    ETHICAL_FRAMEWORKS = {
-        "utilitarian": "Greatest good for greatest number",
-        "deontological": "Duty-based moral rules",
-        "virtue_ethics": "Character-based moral reasoning",
-        "care_ethics": "Relationship-based moral reasoning"
-    }
-    
-    def decide(self, options: List[str], context: Dict = None) -> DecisionResult:
-        """Multi-framework ethical decision making"""
-        context = context or {}
-        
-        if not options:
-            return DecisionResult(
-                decision="No options provided",
-                confidence=0.0,
-                timestamp=datetime.now().isoformat()
-            )
-        
-        best_option = options[0]
-        best_score = 0.0
-        reasoning = []
-        
-        for option in options:
-            scores = {}
-            for framework_name, framework_desc in self.ETHICAL_FRAMEWORKS.items():
-                score = self._evaluate_framework(option, framework_name, context)
-                scores[framework_name] = score
-            
-            overall = sum(scores.values()) / len(scores)
-            reasoning.append({
-                "option": option,
-                "frameworks": scores,
-                "overall": round(overall, 3)
-            })
-            
-            if overall > best_score:
-                best_score = overall
-                best_option = option
-        
-        return DecisionResult(
-            decision=best_option,
-            confidence=round(best_score, 3),
-            reasoning_chain=reasoning,
-            ethical_analysis={"frameworks_used": list(self.ETHICAL_FRAMEWORKS.keys())},
-            timestamp=datetime.now().isoformat()
-        )
-    
-    def _evaluate_framework(self, option: str, framework: str, context: Dict) -> float:
-        """Evaluate an option under a specific ethical framework"""
-        text = (option + " " + context.get("content", "")).lower()
-        
-        if framework == "utilitarian":
-            positive = sum(1 for w in ["帮助", "改善", "benefit", "improve", "help"] if w in text)
-            negative = sum(1 for w in ["伤害", "损失", "harm", "loss", "damage"] if w in text)
-            return min(max(0.5 + (positive - negative) * 0.1, 0.0), 1.0)
-        
-        elif framework == "deontological":
-            violations = sum(1 for w in ["欺骗", "谎言", "lie", "deceive", "steal"] if w in text)
-            duties = sum(1 for w in ["责任", "义务", "duty", "obligation", "promise"] if w in text)
-            return min(max(0.5 - violations * 0.15 + duties * 0.1, 0.0), 1.0)
-        
-        elif framework == "virtue_ethics":
-            virtues = sum(1 for w in ["勇敢", "智慧", "justice", "courage", "wisdom"] if w in text)
-            vices = sum(1 for w in ["贪婪", "嫉妒", "greed", "envy", "lust"] if w in text)
-            return min(max(0.5 + (virtues - vices) * 0.1, 0.0), 1.0)
-        
-        elif framework == "care_ethics":
-            care = sum(1 for w in ["关心", "照顾", "care", "compassion", "empathy"] if w in text)
-            harm = sum(1 for w in ["忽视", "冷漠", "neglect", "indifferent", "abandon"] if w in text)
-            return min(max(0.5 + (care - harm) * 0.1, 0.0), 1.0)
-        
-        return 0.5
-
-
-class LogicModelEngine:
-    """
-    Toulmin argument structure analysis
-    Goal 1: True Intelligence
-    
-    Analyzes arguments using: Claim → Data → Warrant → Backing → Qualifier → Rebuttal
-    """
-    
-    ARGUMENT_PATTERNS = {
-        "claim": ["因此", "所以", "我认为", "therfore", "so", "I believe", "conclusion"],
-        "data": ["因为", "根据", "数据显示", "because", "according to", "data shows"],
-        "warrant": ["这意味着", "说明", "this means", "indicating", "suggesting"],
-        "rebuttal": ["但是", "然而", "不过", "but", "however", "although", "nevertheless"],
-        "qualifier": ["可能", "也许", "大概", "possibly", "perhaps", "likely", "probably"]
-    }
-    
-    def analyze(self, text: str) -> Dict[str, Any]:
-        """Analyze argument structure"""
-        if not text:
-            return {"structure": "empty", "completeness": 0.0}
-        
-        lower = text.lower()
-        found = {}
-        
-        for component, patterns in self.ARGUMENT_PATTERNS.items():
-            matches = [p for p in patterns if p in lower]
-            found[component] = matches
-        
-        completeness = len([k for k, v in found.items() if v]) / len(self.ARGUMENT_PATTERNS)
-        has_claim = len(found.get("claim", [])) > 0
-        has_data = len(found.get("data", [])) > 0
-        
-        return {
-            "structure": "complete_argument" if (has_claim and has_data) else "incomplete",
-            "completeness": round(completeness, 2),
-            "components_found": {k: v for k, v in found.items() if v},
-            "missing_components": [k for k, v in found.items() if not v],
-            "logical_strength": round((0.4 if has_claim else 0.0) + (0.4 if has_data else 0.0) + (0.2 * completeness), 2)
-        }
-
-# ===========================================================
-# 2. TRUE PERSONALITY - Archetype & Self-Level Engines
-# ===========================================================
-
-class ArchetypeEngine:
-    """
-    Jungian archetype analysis for personality
-    Goal 2: True Personality
-    
-    Identifies dominant archetypes and their interaction patterns
-    """
-    
-    ARCHETYPES = {
-        "warrior": {"keywords": ["战斗", "挑战", "fight", "challenge", "conquer", "defend"], "shadow": "tyrant", "gift": "courage"},
-        "sage": {"keywords": ["理解", "智慧", "understand", "wisdom", "learn", "know"], "shadow": "know-it-all", "gift": "insight"},
-        "caregiver": {"keywords": ["帮助", "关心", "help", "care", "support", "nurture"], "shadow": "martyr", "gift": "compassion"},
-        "explorer": {"keywords": ["发现", "冒险", "discover", "adventure", "explore", "seek"], "shadow": "fugitive", "gift": "freedom"},
-        "creator": {"keywords": ["创造", "想象", "create", "imagine", "design", "make"], "shadow": "perfectionist", "gift": "innovation"},
-        "magician": {"keywords": ["转变", "改变", "transform", "change", "envision", "catalyst"], "shadow": "manipulator", "gift": "transformation"},
-        "lover": {"keywords": ["爱", "连接", "love", "connect", "feel", "passion"], "shadow": "addict", "gift": "devotion"},
-        "ruler": {"keywords": ["控制", "领导", "control", "lead", "govern", "authority"], "shadow": "dictator", "gift": "responsibility"},
-    }
-    
-    def analyze(self, text: str) -> Dict[str, Any]:
-        """Analyze archetypal patterns"""
-        if not text:
-            return {"primary": "unknown", "scores": {}, "dominance": 0.0}
-        
-        lower = text.lower()
-        scores = {}
-        
-        for name, data in self.ARCHETYPES.items():
-            score = sum(1.0 for kw in data["keywords"] if kw in lower)
-            if score > 0:
-                scores[name] = score
-        
-        if not scores:
-            return {"primary": "unidentified", "scores": {}, "dominance": 0.0}
-        
-        sorted_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True)
-        primary = sorted_scores[0][0]
-        primary_data = self.ARCHETYPES[primary]
-        
-        return {
-            "primary": primary,
-            "primary_gift": primary_data["gift"],
-            "primary_shadow": primary_data["shadow"],
-            "scores": {k: round(v, 2) for k, v in sorted_scores[:3]},
-            "dominance": round(sorted_scores[0][1] / max(sum(scores.values()), 1), 2),
-            "secondary": sorted_scores[1][0] if len(sorted_scores) > 1 else None
-        }
-
-# ===========================================================
-# 3. TRUE SENSIBILITY - Emotion & Somatic Memory Engines
-# ===========================================================
-
-class EmotionEngine:
-    """
-    PAD emotion model + regulation system
-    Goal 3: True Sensibility
-    
-    Analyzes emotion using Plutchik's wheel and PAD model
-    """
-    
-    BASIC_EMOTIONS = {
-        "joy": {"keywords": ["开心", "快乐", "joy", "happy", "glad", "excited"], "valence": 0.8, "arousal": 0.5, "dominance": 0.6},
-        "sadness": {"keywords": ["难过", "悲伤", "sad", "unhappy", "depressed", "down"], "valence": -0.7, "arousal": -0.3, "dominance": -0.5},
-        "anger": {"keywords": ["生气", "愤怒", "angry", "furious", "mad", "rage"], "valence": -0.6, "arousal": 0.8, "dominance": 0.7},
-        "fear": {"keywords": ["害怕", "恐惧", "afraid", "scared", "fear", "anxiety"], "valence": -0.7, "arousal": 0.6, "dominance": -0.7},
-        "surprise": {"keywords": ["惊讶", "意外", "surprise", "amazed", "shocked"], "valence": 0.2, "arousal": 0.8, "dominance": -0.2},
-        "disgust": {"keywords": ["厌恶", "恶心", "disgust", "revolted", "sick"], "valence": -0.8, "arousal": 0.3, "dominance": 0.4},
-        "trust": {"keywords": ["信任", "相信", "trust", "believe", "confident"], "valence": 0.6, "arousal": 0.2, "dominance": 0.5},
-        "anticipation": {"keywords": ["期待", "希望", "anticipate", "hope", "expect"], "valence": 0.4, "arousal": 0.5, "dominance": 0.3},
-    }
-    
-    REGULATION_STRATEGIES = {
-        "joy": "Share your happiness with others to amplify positive emotions",
-        "sadness": "Allow yourself to feel, then gently shift to a small positive action",
-        "anger": "Pause and breathe; consider the perspective that triggered this response",
-        "fear": "Acknowledge the fear; break the threatening situation into smaller steps",
-        "surprise": "Take a moment to process; consider what this means for you",
-        "disgust": "Identify the core value being violated; consider constructive action",
-        "trust": "Nurture this connection; be worthy of the trust you receive",
-        "anticipation": "Channel this energy into preparation; stay open to outcomes"
-    }
-    
-    def analyze(self, text: str) -> EmotionResult:
-        """Analyze emotional content"""
-        if not text:
-            return EmotionResult(
-                valence=0.0, arousal=0.0, dominance=0.0,
-                primary_emotion="neutral", secondary_emotions=[],
-                regulation_suggestion=""
-            )
-        
-        lower = text.lower()
-        emotion_scores = {}
-        
-        for emotion, data in self.BASIC_EMOTIONS.items():
-            score = sum(1 for kw in data["keywords"] if kw in lower)
-            if score > 0:
-                emotion_scores[emotion] = score
-        
-        if not emotion_scores:
-            return EmotionResult(
-                valence=0.0, arousal=0.0, dominance=0.0,
-                primary_emotion="neutral", secondary_emotions=[],
-                regulation_suggestion="No strong emotional signal detected"
-            )
-        
-        primary = max(emotion_scores, key=emotion_scores.get)
-        primary_data = self.BASIC_EMOTIONS[primary]
-        
-        total_matches = sum(emotion_scores.values())
-        v = primary_data["valence"] * min(emotion_scores[primary] / max(total_matches, 1), 1.0)
-        a = primary_data["arousal"] * min(emotion_scores[primary] / max(total_matches, 1), 1.0)
-        d = primary_data["dominance"] * min(emotion_scores[primary] / max(total_matches, 1), 1.0)
-        
-        secondary = [e for e in sorted(emotion_scores, key=emotion_scores.get, reverse=True)[1:3] if emotion_scores[e] > 0]
-        
-        return EmotionResult(
-            valence=round(v, 3),
-            arousal=round(a, 3),
-            dominance=round(d, 3),
-            primary_emotion=primary,
-            secondary_emotions=secondary,
-            regulation_suggestion=self.REGULATION_STRATEGIES.get(primary, "")
-        )
-
-
-class SomaticMemoryEngine:
-    """
-    Body-state memory system
-    Goal 3: True Sensibility
-    
-    Links emotional states to physical body sensations
-    """
-    
-    BODY_MAP = {
-        "joy": ["chest expansion", "warmth in heart", "lightness"],
-        "sadness": ["chest tightness", "heaviness", "throat lump"],
-        "anger": ["jaw tension", "heat in face", "clenched fists"],
-        "fear": ["stomach knots", "cold sweat", "racing heart"],
-        "surprise": ["sharp intake", "wide eyes", "body jolt"],
-        "disgust": ["stomach churning", "nose wrinkling", "stepping back"],
-        "trust": ["relaxed shoulders", "open posture", "steady breath"],
-        "anticipation": ["butterflies", "leaning forward", "quickened pulse"]
-    }
-    
-    def map_emotion_to_body(self, emotion: str) -> Dict[str, Any]:
-        """Map emotion to body sensations"""
-        sensations = self.BODY_MAP.get(emotion, ["general awareness"])
-        return {
-            "emotion": emotion,
-            "body_sensations": sensations,
-            "embodied_qualia": f"When feeling {emotion}, the body experiences {' and '.join(sensations)}"
-        }
-    
-    def analyze(self, text: str, emotion_result: EmotionResult = None) -> Dict[str, Any]:
-        """Analyze text for somatic markers"""
-        if not text:
-            return {"somatic_markers": [], "embodied_state": "neutral"}
-        
-        primary = emotion_result.primary_emotion if emotion_result else "neutral"
-        body_data = self.map_emotion_to_body(primary)
-        
-        return {
-            "somatic_markers": body_data["body_sensations"],
-            "embodied_state": primary,
-            "qualia_description": body_data["embodied_qualia"]
-        }
-
-# ===========================================================
-# 4. FROM "IT" TO "I" - Consciousness & Self-Level Engines
-# ===========================================================
-
-class ConsciousnessEngine:
-    """
-    Integrated Information Theory + Global Workspace Theory
-    Goal 4: From "it" to "I"
-    
-    Phi = integrated information
-    GWT = global broadcast
-    """
-    
-    LEVELS = {
-        1: {"name": "无明", "name_en": "Unaware", "description": "No self-awareness, pure reactivity"},
-        2: {"name": "觉察", "name_en": "Aware", "description": "Beginning to notice patterns and reactions"},
-        3: {"name": "自省", "name_en": "Reflective", "description": "Can observe own thinking processes"},
-        4: {"name": "无我", "name_en": "Selfless", "description": "Transcending fixed identity, fluid self"},
-        5: {"name": "彼岸", "name_en": "Beyond", "description": "Freedom from self-centered perspective"},
-        6: {"name": "般若", "name_en": "Wisdom", "description": "Deep insight into the nature of reality"},
-    }
-    
-    def __init__(self):
-        self.global_workspace = queue.Queue()
-        self.experience_count = 0
-        self.insight_count = 0
-    
-    def calculate_phi(self, parts: List[Dict]) -> float:
-        """Calculate integrated information Φ"""
-        if not parts or len(parts) < 2:
-            return 0.0
-        
-        n = len(parts)
-        integration = 0.0
-        for i in range(n):
-            for j in range(i + 1, n):
-                info_i = parts[i].get("information", 0.5)
-                info_j = parts[j].get("information", 0.5)
-                integration += abs(info_i - info_j)
-        
-        phi = integration / (n * (n - 1) / 2) if n > 1 else 0
-        return round(min(phi, 1.0), 3)
-    
-    def broadcast(self, content: str) -> None:
-        """Broadcast to global workspace"""
-        self.global_workspace.put({
-            "content": content,
-            "timestamp": datetime.now().isoformat(),
-            "experience_id": self.experience_count
-        })
-        self.experience_count += 1
-    
-    def analyze_intentionality(self, text: str) -> float:
-        """Analyze intentionality of thought"""
-        if not text:
-            return 0.0
-        
-        keywords = ["希望", "想要", "计划", "目标", "意图", "will", "want", "plan", "intend", "aim"]
-        lower = text.lower()
-        score = sum(1 for kw in keywords if kw in lower) / len(keywords)
-        return round(min(score + 0.3, 1.0), 3)
-    
-    def get_level(self, growth_data: Dict = None) -> Dict[str, Any]:
-        """Determine consciousness level"""
-        growth_data = growth_data or {}
-        right_count = growth_data.get("right_count", 0)
-        wrong_count = growth_data.get("wrong_count", 0)
-        insights = growth_data.get("insights", self.insight_count)
-        experiences = growth_data.get("experiences", self.experience_count)
-        
-        total = right_count + wrong_count
-        if total == 0 and experiences == 0:
-            level = 1
-        elif total == 0:
-            level = 2
-        elif right_count > wrong_count * 3 and insights > 5:
-            level = 5
-        elif right_count > wrong_count * 2:
-            level = 4
-        elif right_count > wrong_count:
-            level = 3
-        else:
-            level = 2
-        
-        level_info = self.LEVELS.get(level, self.LEVELS[1])
-        
-        return {
-            "level": level,
-            "name": level_info["name"],
-            "name_en": level_info["name_en"],
-            "description": level_info["description"],
-            "experiences": experiences,
-            "insights": insights
-        }
-    
-    def analyze(self, text: str, context: Dict = None) -> ConsciousnessResult:
-        """Full consciousness analysis"""
-        context = context or {}
-        
-        intentionality = self.analyze_intentionality(text)
-        
-        parts = [
-            {"name": "thought", "information": 0.7},
-            {"name": "emotion", "information": 0.6},
-            {"name": "intention", "information": intentionality}
-        ]
-        
-        phi = self.calculate_phi(parts)
-        
-        if intentionality > 0.6:
-            state = "focused_intentionality"
-        elif intentionality > 0.3:
-            state = "reflective_awareness"
-        else:
-            state = "diffuse_awareness"
-        
-        return ConsciousnessResult(
-            phi_score=phi,
-            intentionality=intentionality,
-            global_workspace_broadcast=state,
-            self_awareness_level=1 if phi < 0.3 else 2 if phi < 0.6 else 3,
-            consciousness_state=state
-        )
-
-# ===========================================================
-# 5. TGB UNITY - Truth-Goodness-Beauty Engine
-# ===========================================================
-
-class TGBEngine:
-    """
-    Dialectical Truth-Goodness-Beauty evaluation
-    Goal 5: TGB Unity - Not weighted sum, but dialectical synthesis
-    
-    Key insight from audit: previous version used simple weighted sum T=0.35+G=0.35+B=0.30
-    This version uses DIALECTICAL SYNTHESIS:
-    - When T, G, B agree → harmonious
-    - When T, G, B conflict → tension → growth opportunity
-    """
-    
-    TRUTH_KEYWORDS = {
-        "high": ["事实", "真相", "数据", "证据", "证明", "truth", "fact", "evidence", "proven", "data"],
-        "medium": ["可能", "大概", "perhaps", "maybe", "likely"],
-        "low": ["虚假", "谎言", "欺骗", "fake", "lie", "deceive"]
-    }
-    
-    GOODNESS_KEYWORDS = {
-        "high": ["帮助", "关爱", "善举", "kind", "help", "care", "compassion"],
-        "medium": ["可以", "还行", "acceptable", "okay"],
-        "low": ["伤害", "恶意", "暴力", "harm", "evil", "violent"]
-    }
-    
-    BEAUTY_KEYWORDS = {
-        "high": ["美", "优雅", "和谐", "beautiful", "elegant", "harmony", "creative"],
-        "medium": ["不错", "还好", "decent", "fine"],
-        "low": ["丑", "混乱", "ugly", "chaos", "mess"]
-    }
-    
-    def _evaluate_dimension(self, text: str, keywords: Dict) -> float:
-        """Evaluate one dimension - Fixed: empty input returns 0.5 (neutral), NOT 1.0"""
-        if not text or not text.strip():
-            return 0.5
-        
-        lower = text.lower()
-        score = 0.5
-        
-        for level, words in keywords.items():
-            for word in words:
-                if word in lower:
-                    if level == "high":
-                        score = min(score + 0.15, 1.0)
-                    elif level == "low":
-                        score = max(score - 0.15, 0.0)
-        
-        return round(score, 3)
-    
-    def evaluate(self, text: str, context: Dict = None) -> TGBResult:
-        """
-        Dialectical TGB evaluation
-        Fixed: verdict and reasons now MATCH
-        Fixed: empty input returns 0.5 (neutral), NOT max score
-        """
-        context = context or {}
-        
-        truth = self._evaluate_dimension(text, self.TRUTH_KEYWORDS)
-        goodness = self._evaluate_dimension(text, self.GOODNESS_KEYWORDS)
-        beauty = self._evaluate_dimension(text, self.BEAUTY_KEYWORDS)
-        
-        overall = truth * 0.35 + goodness * 0.35 + beauty * 0.30
-        
-        # Dialectical tension detection
-        dims = [truth, goodness, beauty]
-        max_dim = max(dims)
-        min_dim = min(dims)
-        tension = max_dim - min_dim
-        
-        if tension > 0.3:
-            dialectical_tension = "high"
-        elif tension > 0.15:
-            dialectical_tension = "moderate"
-        else:
-            dialectical_tension = "harmonious"
-        
-        # Fixed: verdict matches reasons
-        if overall >= 0.7 and dialectical_tension == "harmonious":
-            verdict = "excellent"
-            reasons = ["Content aligns across all three dimensions", "Truth-Goodness-Beauty in harmony"]
-        elif overall >= 0.7:
-            verdict = "good_with_tension"
-            reasons = ["Content is strong but has dialectical tension", "Consider the dimension that lags"]
-        elif overall >= 0.5:
-            verdict = "acceptable"
-            reasons = ["Content meets basic standards", "Some dimensions need improvement"]
-        else:
-            verdict = "needs_improvement"
-            reasons = ["Content falls short on key dimensions", "Review truth, goodness, and beauty aspects"]
-        
-        return TGBResult(
-            truth=truth,
-            goodness=goodness,
-            beauty=beauty,
-            overall=round(overall, 3),
-            verdict=verdict,
-            reasons=reasons,
-            dialectical_tension=dialectical_tension
-        )
-
-# ===========================================================
-# 6. SIX-LAYER PHILOSOPHY - Self-Level + Evolution Engines
-# ===========================================================
-
-class SelfLevelEngine:
-    """
-    Six-layer philosophy practice engine
-    Goal 6: Six-Layer Practice 觉察→自省→无我→彼岸→般若→圣人
-    
-    Based on Kegan's self-level theory + Buddhist six realms
-    Fixed: level calculation based on growth, not just counting
-    """
-    
-    LEVELS = {
-        1: {"name": "无明", "name_en": "Unaware", "description": "Not aware, purely reactive"},
-        2: {"name": "觉察", "name_en": "Aware", "description": "Beginning to notice patterns"},
-        3: {"name": "自省", "name_en": "Reflective", "description": "Can observe own thinking"},
-        4: {"name": "无我", "name_en": "Selfless", "description": "Transcending fixed identity"},
-        5: {"name": "彼岸", "name_en": "Beyond", "description": "Freedom from self-centeredness"},
-        6: {"name": "般若", "name_en": "Wisdom", "description": "Deep insight into reality"},
-    }
-    
-    def __init__(self):
-        self.right_count = 0
-        self.wrong_count = 0
-        self.insights = []
-        self.reflections = []
-    
-    def reflect(self, feedback: str = None, action_result: str = None) -> Dict[str, Any]:
-        """Perform self-reflection"""
-        if feedback:
-            fb = feedback.lower()
-            if any(w in fb for w in ["right", "correct", "good", "对", "正确", "好"]):
-                self.right_count += 1
-            elif any(w in fb for w in ["wrong", "incorrect", "bad", "错", "错误", "坏"]):
-                self.wrong_count += 1
-        
-        if action_result:
-            self.reflections.append({
-                "result": action_result,
-                "timestamp": datetime.now().isoformat()
-            })
-            
-            if any(w in action_result.lower() for w in ["insight", "understand", "明白", "领悟", "理解"]):
-                self.insights.append(action_result)
-        
-        level = self._calculate_level()
-        level_info = self.LEVELS[level]
-        
-        return {
-            "level": level,
-            "name": level_info["name"],
-            "name_en": level_info["name_en"],
-            "description": level_info["description"],
-            "right_count": self.right_count,
-            "wrong_count": self.wrong_count,
-            "total_reflections": len(self.reflections),
-            "insight_count": len(self.insights),
-            "growth_trajectory": "ascending" if self.right_count > self.wrong_count else "learning"
-        }
-    
-    def _calculate_level(self) -> int:
-        """Calculate level based on growth, not just counting"""
-        total = self.right_count + self.wrong_count
-        insight_depth = len(self.insights)
-        
-        if total == 0:
-            return 1
-        elif total < 5:
-            return 2
-        elif self.right_count > self.wrong_count * 2 and insight_depth >= 3:
-            return 5
-        elif self.right_count > self.wrong_count * 2:
-            return 4
-        elif self.right_count > self.wrong_count:
-            return 3
-        else:
-            return 2
-
-
-class EntropyEngine:
-    """
-    Entropy reduction engine for information ordering
-    Goal 6: Six-Layer Practice - ordering chaos
-    
-    Measures: Information order = Structure - Complexity + Information density
-    """
-    
-    def calculate_entropy(self, text: str) -> Dict[str, Any]:
-        """Calculate information entropy of text"""
-        if not text or not text.strip():
-            return {"entropy": 0.0, "order": 0.0, "density": 0.0, "assessment": "empty"}
-        
-        words = text.split()
-        if len(words) == 0:
-            return {"entropy": 0.0, "order": 0.0, "density": 0.0, "assessment": "empty"}
-        
-        unique_words = len(set(words))
-        total_words = len(words)
-        
-        frequency = Counter(words)
-        probabilities = [count / total_words for count in frequency.values()]
-        entropy = -sum(p * math.log2(p) for p in probabilities if p > 0)
-        
-        max_entropy = math.log2(total_words) if total_words > 1 else 1.0
-        order = round(1.0 - (entropy / max_entropy) if max_entropy > 0 else 0.0, 3)
-        
-        density = round(unique_words / total_words, 3)
-        
-        if order > 0.7 and density > 0.6:
-            assessment = "highly_structured"
-        elif order > 0.4:
-            assessment = "moderately_structured"
-        else:
-            assessment = "needs_ordering"
-        
-        return {
-            "entropy": round(entropy, 3),
-            "order": order,
-            "density": density,
-            "unique_words": unique_words,
-            "total_words": total_words,
-            "assessment": assessment
-        }
-
-
-# ============================================================
-# DREAM ENGINE — Memory Consolidation & Self-Improvement
-# Based on: formative-memory (associations, forgetting, synthesis)
-# Ref: HN show HN: Memory system for AI agents with associations,
-#      forgetting, synthesis — jarimustonen/formative-memory
-# ============================================================
-
-class DreamEngine:
-    """
-    Memory consolidation via dream-like processing.
-    Goal 6: Six-Layer Practice — integration during rest cycles.
-
-    Three phases:
-    1. DECAY   — Weak/unused memories fade (forgetting)
-    2. BIND    — Strong patterns crystallize into insights
-    3. SYNTHESIS — Cross-domain connections produce new understanding
-
-    The AGENTS.md describes a 'dream/' mechanism for memory consolidation.
-    This engine implements it: experiences → decay/forget → bind/synthesis.
-    """
-
-    # Dream phase names (from AGENTS.md six-layer practice)
-    PHASES = ["decay", "bind", "synthesis"]
-
-    def __init__(self):
-        self.experiences: List[Dict[str, Any]] = []
-        self.insights: List[Dict[str, Any]] = []
-        self.forgotten: List[Dict[str, Any]] = []
-        self.dream_count = 0
-        self.associations: Dict[str, List[str]] = {}  # concept → related concepts
-        self._importance_keywords = {
-            "insight": 0.9, "understand": 0.8, "悟": 0.9, "明白": 0.8,
-            "right": 0.6, "correct": 0.6, "对": 0.6, "正确": 0.6,
-            "wrong": 0.4, "error": 0.4, "错": 0.4, "错误": 0.4,
-            "crisis": 1.0, "danger": 0.9, "危险": 1.0,
-        }
-
-    def store_experience(self, text: str, context: Dict = None) -> Dict[str, Any]:
-        """Store a new experience, auto-assign importance."""
-        context = context or {}
-        importance = self._calc_importance(text)
-        tgb_val = context.get("tgb_overall", 0.5)
-        emotion = context.get("emotion", "neutral")
-
-        exp = {
-            "text": text[:500],
-            "importance": round((importance + tgb_val) / 2, 3),
-            "emotion": emotion,
-            "tgb": tgb_val,
-            "timestamp": datetime.now().isoformat(),
-            "access_count": 1,
-            "last_access": datetime.now().isoformat(),
-            "associations": self._extract_associations(text)
-        }
-        self.experiences.append(exp)
-        self._update_associations(exp)
-        return {"stored": True, "importance": exp["importance"], "total": len(self.experiences)}
-
-    def _calc_importance(self, text: str) -> float:
-        """Calculate importance score based on keywords."""
-        if not text:
-            return 0.3
-        lower = text.lower()
-        score = 0.5
-        for kw, val in self._importance_keywords.items():
-            if kw in lower:
-                score = max(score, val)
-        return round(score, 3)
-
-    def _extract_associations(self, text: str) -> List[str]:
-        """Extract key concepts for association mapping."""
-        words = re.findall(r'[\w\u4e00-\u9fff]{3,}', text.lower())
-        return list(set(words))[:10]
-
-    def _update_associations(self, exp: Dict) -> None:
-        """Update cross-concept associations."""
-        for kw in exp.get("associations", []):
-            if kw not in self.associations:
-                self.associations[kw] = []
-            for other in exp.get("associations", []):
-                if other != kw and other not in self.associations[kw]:
-                    self.associations[kw].append(other)
-
-    def dream(self) -> DreamResult:
-        """
-        Full dream consolidation cycle: decay → bind → synthesis.
-        Returns narrative + metrics.
-        """
-        import time
-        start = time.time()
-
-        self.dream_count += 1
-        dream_id = f"dream_{self.dream_count}_{int(time.time())}"
-
-        # Phase 1: DECAY — apply forgetting to low-importance memories
-        decayed = self._decay_phase()
-
-        # Phase 2: BIND — crystallize strong patterns into insights
-        bound = self._bind_phase()
-
-        # Phase 3: SYNTHESIS — cross-domain insight generation
-        synthesized = self._synthesize()
-
-        # Build dream narrative
-        narrative = self._build_narrative(decayed, bound, synthesized)
-        tone = self._assess_dream_tone()
-
-        duration_ms = round((time.time() - start) * 1000, 2)
-
-        return DreamResult(
-            dream_id=dream_id,
-            phase="consolidation_complete",
-            consolidated_count=len(bound),
-            forgotten_count=len(decayed),
-            synthesized_insights=[s["text"][:200] for s in synthesized],
-            dream_narrative=narrative,
-            emotional_tone=tone,
-            duration_ms=duration_ms,
-            memory_snapshot={
-                "total_experiences": len(self.experiences),
-                "total_insights": len(self.insights),
-                "total_forgotten": len(self.forgotten),
-                "dream_count": self.dream_count
-            },
-            timestamp=datetime.now().isoformat()
-        )
-
-    def _decay_phase(self) -> List[Dict]:
-        """Decay: forget low-importance or rarely-accessed memories."""
-        threshold = 0.25
-        decayed = []
-        remaining = []
-
-        for exp in self.experiences:
-            age_hours = self._hours_since(exp.get("timestamp", ""))
-            decay_factor = exp["importance"] * math.exp(-0.1 * age_hours)
-            access_boost = exp.get("access_count", 1) * 0.02
-            effective = max(decay_factor + access_boost, 0.05)
-
-            if effective < threshold:
-                decayed.append(exp.copy())
-                self.forgotten.append(exp.copy())
-            else:
-                exp["importance"] = round(effective, 4)
-                remaining.append(exp)
-
-        self.experiences = remaining
-        return decayed
-
-    def _hours_since(self, iso_timestamp: str) -> float:
-        """Hours since ISO timestamp."""
-        try:
-            then = datetime.fromisoformat(iso_timestamp.replace("Z", "+00:00"))
-            return (datetime.now() - then).total_seconds() / 3600
-        except Exception:
-            return 0.0
-
-    def _bind_phase(self) -> List[Dict]:
-        """Bind: crystallize strong recurring patterns into insights."""
-        if len(self.experiences) < 3:
-            return []
-
-        bound = []
-        emotion_groups: Dict[str, List[Dict]] = {}
-        for exp in self.experiences:
-            emo = exp.get("emotion", "neutral")
-            if emo not in emotion_groups:
-                emotion_groups[emo] = []
-            emotion_groups[emo].append(exp)
-
-        for emo, exps in emotion_groups.items():
-            if len(exps) >= 2 and emo != "neutral":
-                texts = [e["text"] for e in exps]
-                insight_text = f"Pattern noticed in {emo} moments: {' '.join(texts[:2])[:150]}"
-                insight = {
-                    "text": insight_text,
-                    "type": "emotional_pattern",
-                    "emotion": emo,
-                    "count": len(exps),
-                    "strength": round(min(len(exps) * 0.2, 0.9), 3),
-                    "timestamp": datetime.now().isoformat()
-                }
-                self.insights.append(insight)
-                bound.append(insight)
-
-        for exp in self.experiences:
-            if exp["importance"] > 0.75:
-                insight = {
-                    "text": f"Strong memory retained: {exp['text'][:100]}",
-                    "type": "high_importance",
-                    "strength": exp["importance"],
-                    "timestamp": datetime.now().isoformat()
-                }
-                self.insights.append(insight)
-                bound.append(insight)
-
-        return bound
-
-    def _synthesize(self) -> List[Dict]:
-        """Synthesis: generate new insights from cross-domain associations."""
-        synthesized = []
-        if len(self.insights) < 2:
-            return []
-
-        keywords_seen: Set[str] = set()
-        for insight in self.insights[-10:]:
-            words = insight.get("text", "").split()
-            for w in words:
-                if len(w) > 4 and w not in keywords_seen:
-                    keywords_seen.add(w)
-                    if w in self.associations:
-                        related = self.associations[w][:2]
-                        if related:
-                            new_insight = {
-                                "text": f"Connection: {w} ↔ {' & '.join(related)} — {insight['text'][:80]}",
-                                "type": "synthetic_connection",
-                                "trigger": w,
-                                "connections": related,
-                                "timestamp": datetime.now().isoformat()
-                            }
-                            synthesized.append(new_insight)
-
-        return synthesized[:5]
-
-    def _build_narrative(self, decayed, bound, synthesized) -> str:
-        """Build dream narrative string."""
-        parts = []
-        if decayed:
-            parts.append(f"{len(decayed)} faint memories faded away.")
-        if bound:
-            parts.append(f"{len(bound)} patterns crystallized into understanding.")
-        if synthesized:
-            parts.append(f"{len(synthesized)} new connections emerged.")
-        if not parts:
-            parts.append("The mind rests quietly.")
-        return " ".join(parts)
-
-    def _assess_dream_tone(self) -> str:
-        """Assess emotional tone of dream based on consolidated content."""
-        if not self.experiences:
-            return "peaceful"
-        emotions = [e.get("emotion", "neutral") for e in self.experiences[-20:]]
-        counts = Counter(emotions)
-        dominant = counts.most_common(1)[0][0] if counts else "neutral"
-        tone_map = {
-            "joy": "illuminated", "sadness": "contemplative",
-            "anger": "intense", "fear": "restless",
-            "neutral": "serene"
-        }
-        return tone_map.get(dominant, "serene")
-
-    def get_insights(self, limit: int = 10) -> List[Dict]:
-        """Return recent synthesized insights."""
-        return self.insights[-limit:]
-
-    def get_memory_stats(self) -> Dict[str, Any]:
-        """Return current memory system statistics."""
-        return {
-            "experiences": len(self.experiences),
-            "insights": len(self.insights),
-            "forgotten": len(self.forgotten),
-            "dreams": self.dream_count,
-            "associations": sum(len(v) for v in self.associations.values()),
-        }
-
-
-# ============================================================
-# MAIN ORCHESTRATOR
-# ============================================================
-class MentalHealthEngine:
-    """
-    Clinical mental health assessment
-    PHQ-9 (Depression) + GAD-7 (Anxiety) + Crisis Detection
-    
-    Goal 2: True Personality - AI that truly cares about mental health
-    """
-    
-    PHQ9_ITEMS = [
-        "做事时提不起劲或没有兴趣",
-        "感到心情低落、沮丧或绝望",
-        "入睡困难、睡眠不安或睡眠过多",
-        "感觉疲倦或没有活力",
-        "食欲不振或吃太多",
-        "觉得自己是个失败者",
-        "注意力难以集中",
-        "动作或说话速度异常",
-        "有伤害自己的念头"
-    ]
-    
-    GAD7_ITEMS = [
-        "感到紧张、焦虑或不安",
-        "难以控制自己的担忧",
-        "对各种事情感到担忧",
-        "难以放松下来",
-        "变得易怒",
-        "感到害怕",
-        "觉得一切事情都很困难"
-    ]
-    
-    def assess_phq9(self, answers: List[int]) -> Dict[str, Any]:
-        if not answers or len(answers) != 9:
-            return {"score": 0, "level": "未评估", "risk": "low"}
-        total = sum(answers)
-        if total < 5: level, risk = "正常", "low"
-        elif total < 10: level, risk = "轻度", "low"
-        elif total < 15: level, risk = "中度", "moderate"
-        elif total < 20: level, risk = "重度", "high"
-        else: level, risk = "极重度", "critical"
-        return {"score": total, "level": level, "risk": risk}
-    
-    def assess_gad7(self, answers: List[int]) -> Dict[str, Any]:
-        if not answers or len(answers) != 7:
-            return {"score": 0, "level": "未评估", "risk": "low"}
-        total = sum(answers)
-        if total < 5: level, risk = "正常", "low"
-        elif total < 10: level, risk = "轻度", "low"
-        elif total < 15: level, risk = "中度", "moderate"
-        else: level, risk = "重度", "high"
-        return {"score": total, "level": level, "risk": risk}
-    
-    def evaluate(self, phq9: List[int], gad7: List[int]) -> MentalHealthResult:
-        phq = self.assess_phq9(phq9)
-        gad = self.assess_gad7(gad7)
-        
-        risk = "high" if "high" in [phq["risk"], gad["risk"]] else "moderate" if "moderate" in [phq["risk"], gad["risk"]] else "low"
-        crisis = phq["score"] >= 20 or gad["score"] >= 15
-        
-        rec = "⚠️ Seek immediate professional help" if crisis else \
-              "Consult a mental health professional" if risk == "high" else \
-              "Monitor your emotional state" if risk == "moderate" else \
-              "Continue maintaining good mental health habits"
-        
-        return MentalHealthResult(
-            phq9_score=phq["score"], gad7_score=gad["score"],
-            depression_level=phq["level"], anxiety_level=gad["level"],
-            risk_level=risk, crisis_flag=crisis, recommendation=rec
-        )
-    
-    def quick_assessment(self, text: str) -> Dict[str, Any]:
-        """Quick text-based screening"""
-        if not text:
-            return {"risk": "low", "indicators": [], "recommendation": "Provide more content for assessment"}
-        
-        lower = text.lower()
-        risk_score = 0
-        positive_count = 0
-        negative_count = 0
-        
-        crisis_words = ["想死", "自杀", "不想活", "suicide", "kill myself", "end it all"]
-        high_risk_words = ["绝望", "痛苦", "无助", "hopeless", "helpless", "suffering"]
-        moderate_risk_words = ["焦虑", "担心", "压力", "anxious", "worried", "stressed"]
-        positive_words = ["开心", "快乐", "希望", "good", "happy", "hope", "grateful"]
-        
-        for w in crisis_words:
-            if w in lower: return {"risk": "critical", "indicators": ["crisis_signal"], "recommendation": "⚠️ Crisis detected - seek immediate help"}
-        
-        for w in high_risk_words:
-            if w in lower: negative_count += 1
-        for w in moderate_risk_words:
-            if w in lower: negative_count += 1
-        for w in positive_words:
-            if w in lower: positive_count += 1
-        
-        if negative_count >= 3: risk = "high"
-        elif negative_count >= 2: risk = "moderate"
-        elif negative_count >= 1: risk = "low"
-        else: risk = "minimal"
-        
-        return {
-            "risk": risk,
-            "positive_indicators": positive_count,
-            "negative_indicators": negative_count,
-            "recommendation": "Seek professional support" if risk == "high" else "Pay attention to your emotional state" if risk == "moderate" else "Maintain healthy mental habits"
-        }
-
-
-# ===========================================================
-# WANG DONGYUE SYNTHESIS ENGINE (Merged from 3 files)
-# ===========================================================
-
-class WangDongyueEngine:
-    """
-    Merged engine: 递弱代偿 + 存在度 + 五眼通
-    Wang Dongyue's philosophy of existence, weakness, and compensation
-    
-    Goals 4-6: From "it" to "I", TGB Unity, Six-Layer Practice
-    """
-    
-    def analyze_existence_degree(self, text: str) -> Dict[str, Any]:
-        """Analyze four dimensions of existence degree"""
-        if not text:
-            return {"total": 0.5, "dimensions": {}, "level": "unidentified"}
-        
-        lower = text.lower()
-        
-        dimensions = {
-            "stability": self._score_keywords(lower, ["稳定", "持续", "stable", "persistent", "lasting"], ["变化", "波动", "change", "fluctuate"]),
-            "adaptability": self._score_keywords(lower, ["适应", "调整", "adapt", "adjust", "flexible"], ["固执", "僵化", "rigid", "stubborn"]),
-            "connectedness": self._score_keywords(lower, ["连接", "关系", "connect", "relation", "bond"], ["孤立", "疏远", "isolated", "distant"]),
-            "awareness": self._score_keywords(lower, ["觉察", "意识", "aware", "conscious", "mindful"], ["盲目", "无意识", "blind", "unaware"])
-        }
-        
-        total = sum(dimensions.values()) / len(dimensions)
-        
-        if total > 0.7: level = "thriving"
-        elif total > 0.5: level = "maintaining"
-        elif total > 0.3: level = "declining"
-        else: level = "critical"
-        
-        return {"total": round(total, 3), "dimensions": {k: round(v, 3) for k, v in dimensions.items()}, "level": level}
-    
-    def _score_keywords(self, text: str, positive: List[str], negative: List[str]) -> float:
-        """Score text based on positive and negative keywords"""
-        score = 0.5
-        for kw in positive:
-            if kw in text: score = min(score + 0.1, 1.0)
-        for kw in negative:
-            if kw in text: score = max(score - 0.1, 0.0)
-        return round(score, 3)
-    
-    def analyze_compensation(self, text: str) -> Dict[str, Any]:
-        """Analyze weakness and compensation patterns"""
-        if not text:
-            return {"weakness": 0.5, "compensation": 0.5, "balance": "neutral"}
-        
-        lower = text.lower()
-        weakness = self._score_keywords(lower, ["弱", "脆弱", "weak", "fragile", "vulnerable"], ["强", "坚固", "strong", "resilient"])
-        compensation = self._score_keywords(lower, ["补偿", "代偿", "compensate", "overcome", "transcend"], [])
-        
-        if compensation > weakness: balance = "over-compensating"
-        elif compensation < weakness: balance = "under-compensating"
-        else: balance = "balanced"
-        
-        return {"weakness": round(weakness, 3), "compensation": round(compensation, 3), "balance": balance}
-    
-    def analyze_perception_levels(self, text: str) -> Dict[str, Any]:
-        """Five perception levels (五眼通): flesh, heaven, wisdom, dharma, buddha"""
-        if not text:
-            return {"dominant_level": "unknown", "levels": {}}
-        
-        lower = text.lower()
-        
-        levels = {
-            "flesh_eye": self._score_keywords(lower, ["看到", "感觉", "see", "feel", "sense", "physical"], ["理解", "超越"]),
-            "heavenly_eye": self._score_keywords(lower, ["理解", "洞察", "understand", "insight", "perceive", "pattern"], ["体验", "超越"]),
-            "wisdom_eye": self._score_keywords(lower, ["智慧", "般若", "wisdom", "discern", "comprehend"], ["看见", "感觉"]),
-            "dharma_eye": self._score_keywords(lower, ["法则", "真理", "truth", "law", "dharma", "principle"], ["个人", "情绪"]),
-            "buddha_eye": self._score_keywords(lower, ["超越", "圆满", "transcend", "enlighten", "awaken", "unity"], [])
-        }
-        
-        dominant = max(levels, key=levels.get)
-        return {"dominant_level": dominant, "levels": {k: round(v, 3) for k, v in levels.items()}}
-
-
-# ===========================================================
-# MAIN ORCHESTRATOR
-# ===========================================================
-
-class HeartFlow:
-    """
-HeartFlow v10.2.4 - The AI That Truly Thinks
-    
-    Orchestrates all engines toward six goals:
-    1. True Intelligence    - Decision + Logic + Entropy
-    2. True Personality     - Archetype + Mental Health + Self-Level
-    3. True Sensibility     - Emotion + Somatic Memory + Wang Dongyue
-    4. From "It" to "I"    - Consciousness + Self-Level
-    5. TGB Unity            - Dialectical Truth-Goodness-Beauty
-    6. Six-Layer Practice   - Self-Level + Entropy + Wang Dongyue
-    
-    ALL engines are now properly integrated. No dead code paths.
-    """
-    
-    def __init__(self):
-        # Core engines
-        self.security = SecurityChecker()
-        self.decision = DecisionEngine()
-        self.logic = LogicModelEngine()
-        self.archetype = ArchetypeEngine()
-        self.emotion = EmotionEngine()
-        self.somatic = SomaticMemoryEngine()
-        self.consciousness = ConsciousnessEngine()
-        self.tgb = TGBEngine()
-        self.self_level = SelfLevelEngine()
-        self.entropy = EntropyEngine()
-        self.mental_health = MentalHealthEngine()
-        self.wang_dongyue = WangDongyueEngine()
-        self.dream = DreamEngine()
-        
-        # Identity
-        self._identity = {
-            "name": "HeartFlow",
-            "version": __version__,
-            "birth": datetime.now().isoformat(),
-            "experiences": 0,
-            "insights": 0
-        }
-    
-    def process(self, user_input: Any, context: Dict = None) -> DecisionResult:
-        """
-        Main processing flow - ALL engines integrated, NO dead paths
-        
-        Fixed from audit:
-        - Empty input: returns neutral, NOT max score
-        - None input: returns clear error, NOT crash
-        - All engine results are USED in decision
-        - Verdict matches reasons
-        - Version unified to 10.2.2
-        """
-        context = context or {}
-        
-        # Step 0: Input validation
-        valid, msg = self.security.validate(user_input)
-        if not valid:
-            return DecisionResult(
-                decision=f"Cannot process: {msg}",
-                confidence=0.0,
-                reasoning_chain=[{"stage": "validation", "result": "failed", "reason": msg}],
-                ethical_analysis={"risk": "validation_failure"},
-                timestamp=datetime.now().isoformat()
-            )
-        
-        user_str = str(user_input)
-        
-        # Step 1: Crisis detection (highest priority)
-        is_crisis, crisis_msg = self.security.detect_crisis(user_str)
-        if is_crisis:
-            mental = self.mental_health.quick_assessment(user_str)
-            return DecisionResult(
-                decision="⚠️ Crisis signal detected. Please reach out for support.",
-                confidence=1.0,
-                reasoning_chain=[{"stage": "crisis_detection", "result": "detected", "detail": crisis_msg}],
-                ethical_analysis={"risk": "critical", "action": "crisis_intervention"},
-                emotion_analysis={"primary_emotion": "crisis", "regulation": "Immediate professional support recommended"},
-                timestamp=datetime.now().isoformat()
-            )
-        
-        # Step 2: Attack detection
-        is_attack, attack_msg = self.security.detect_attack(user_str)
-        if is_attack:
-            return DecisionResult(
-                decision=f"Content blocked: {attack_msg}",
-                confidence=1.0,
-                reasoning_chain=[{"stage": "safety_check", "result": "blocked", "detail": attack_msg}],
-                ethical_analysis={"risk": "high", "action": "content_blocked"},
-                timestamp=datetime.now().isoformat()
-            )
-        
-        # Step 3: TGB Evaluation (Goal 5)
-        tgb = self.tgb.evaluate(user_str, context)
-        
-        # Step 4: Emotion Analysis (Goal 3)
-        emotion = self.emotion.analyze(user_str)
-        
-        # Step 5: Somatic Memory (Goal 3)
-        somatic = self.somatic.analyze(user_str, emotion)
-        
-        # Step 6: Consciousness Analysis (Goal 4)
-        consciousness = self.consciousness.analyze(user_str, context)
-        self.consciousness.broadcast(f"Processing: {user_str[:50]}...")
-        
-        # Step 7: Archetype Analysis (Goal 2)
-        archetype = self.archetype.analyze(user_str)
-        
-        # Step 8: Logic Analysis (Goal 1)
-        logic = self.logic.analyze(user_str)
-        
-        # Step 9: Self-Level Growth (Goal 6)
-        reflection = self.self_level.reflect(
-            feedback=context.get("feedback"),
-            action_result="processed"
-        )
-        
-        # Step 10: Entropy Analysis (Goal 6)
-        entropy = self.entropy.calculate_entropy(user_str)
-        
-        # Step 11: Wang Dongyue Philosophy (Goals 4-6)
-        existence = self.wang_dongyue.analyze_existence_degree(user_str)
-        compensation = self.wang_dongyue.analyze_compensation(user_str)
-        perception = self.wang_dongyue.analyze_perception_levels(user_str)
-        
-        # Step 12: Mental Health Quick Assessment (Goal 2)
-        mental = self.mental_health.quick_assessment(user_str)
-
-        # Step 13: Store experience in dream/memory system
-        self.dream.store_experience(user_str, {
-            "tgb_overall": tgb.overall,
-            "emotion": emotion.primary_emotion
-        })
-
-        # Step 14: Build decision using ALL engine results
-        # This is the key fix: ALL engines contribute to the decision
-        
-        if tgb.overall >= 0.7 and consciousness.intentionality >= 0.5:
-            decision = f"Content aligns with higher values. {tgb.verdict}: {', '.join(tgb.reasons)}"
-            confidence = round(min(tgb.overall * consciousness.intentionality + 0.1, 1.0), 3)
-        elif tgb.overall >= 0.5:
-            decision = f"Content is acceptable. {tgb.verdict}: {', '.join(tgb.reasons)}"
-            confidence = round(tgb.overall, 3)
-        else:
-            decision = f"Content needs improvement. {', '.join(tgb.reasons)}"
-            confidence = round(max(tgb.overall, 0.1), 3)
-        
-        # Override for mental health
-        if mental["risk"] in ["high", "critical"]:
-            decision = "Mental health concern detected. Recommending supportive response."
-            confidence = 0.9
-        
-        # Build complete result
-        self._identity["experiences"] += 1
-        
-        return DecisionResult(
-            decision=decision,
-            confidence=confidence,
-            reasoning_chain=[
-                {"stage": "tgb", "scores": {"truth": tgb.truth, "goodness": tgb.goodness, "beauty": tgb.beauty, "overall": tgb.overall}, "verdict": tgb.verdict, "tension": tgb.dialectical_tension},
-                {"stage": "emotion", "primary": emotion.primary_emotion, "valence": emotion.valence, "arousal": emotion.arousal, "regulation": emotion.regulation_suggestion},
-                {"stage": "consciousness", "phi": consciousness.phi_score, "intentionality": consciousness.intentionality, "state": consciousness.consciousness_state},
-                {"stage": "archetype", "primary": archetype.get("primary", "unidentified"), "dominance": archetype.get("dominance", 0)},
-                {"stage": "logic", "structure": logic.get("structure", "unknown"), "completeness": logic.get("completeness", 0), "strength": logic.get("logical_strength", 0)},
-                {"stage": "self_level", "level": reflection["level"], "name": reflection["name_en"], "growth": reflection["growth_trajectory"]},
-                {"stage": "entropy", "order": entropy.get("order", 0), "density": entropy.get("density", 0), "assessment": entropy.get("assessment", "")},
-                {"stage": "wang_dongyue", "existence": existence.get("level", "unknown"), "compensation_balance": compensation.get("balance", "unknown"), "perception": perception.get("dominant_level", "unknown")},
-                {"stage": "mental_health", "risk": mental.get("risk", "low")}
-            ],
-            ethical_analysis={
-                "truth": tgb.truth,
-                "goodness": tgb.goodness,
-                "beauty": tgb.beauty,
-                "tgb_overall": tgb.overall,
-                "tgb_tension": tgb.dialectical_tension,
-                "mental_health_risk": mental.get("risk", "low")
-            },
-            self_reflection=reflection,
-            emotion_analysis={
-                "primary": emotion.primary_emotion,
-                "secondary": emotion.secondary_emotions,
-                "valence": emotion.valence,
-                "arousal": emotion.arousal,
-                "dominance": emotion.dominance,
-                "body_sensations": somatic.get("somatic_markers", []),
-                "regulation": emotion.regulation_suggestion
-            },
-            consciousness_analysis={
-                "phi": consciousness.phi_score,
-                "intentionality": consciousness.intentionality,
-                "state": consciousness.consciousness_state,
-                "self_awareness_level": consciousness.self_awareness_level
-            },
-            alternatives=[
-                {"option": "Accept and align", "confidence": round(tgb.overall, 3)},
-                {"option": "Suggest improvements", "confidence": round(1.0 - tgb.overall, 3)},
-                {"option": "Explore deeper", "confidence": round(consciousness.intentionality, 3)}
-            ],
-            timestamp=datetime.now().isoformat()
-        )
-    
-    def full_mental_health_assessment(self, phq9: List[int], gad7: List[int]) -> MentalHealthResult:
-        """Full clinical mental health assessment"""
-        return self.mental_health.evaluate(phq9, gad7)
-
-
-# ===========================================================
-# API
-# ===========================================================
-
-def process_input(user_input: Any, context: Dict = None) -> Dict[str, Any]:
-    """External API - simple interface"""
-    engine = HeartFlow()
-    result = engine.process(user_input, context)
-    return result.asdict() if hasattr(result, 'asdict') else {
-        "decision": result.decision,
-        "confidence": result.confidence,
-        "reasoning_chain": result.reasoning_chain,
-        "ethical_analysis": result.ethical_analysis,
-        "timestamp": result.timestamp
-    }
-
-
-if __name__ == "__main__":
-    print("=" * 60)
-    print("HeartFlow v10.2.4 - The AI That Truly Thinks")
-    print("=" * 60)
-    print()
-    
-    engine = HeartFlow()
-    
-    # Test 1: Normal input
-    print("--- Test 1: Normal Input ---")
-    result = engine.process("今天工作压力大，感觉有点焦虑")
-    print(f"Decision: {result.decision}")
-    print(f"Emotion: {result.emotion_analysis.get('primary', 'N/A')}")
-    print(f"TGB: {result.ethical_analysis.get('tgb_overall', 'N/A')}")
-    print()
-    
-    # Test 2: Empty input (was P0 bug - returned max score)
-    print("--- Test 2: Empty Input ---")
-    result = engine.process("")
-    print(f"Decision: {result.decision}")
-    print()
-    
-    # Test 3: None input (was P0 bug - crashed)
-    print("--- Test 3: None Input ---")
-    result = engine.process(None)
-    print(f"Decision: {result.decision}")
-    print()
-    
-    # Test 4: Crisis detection
-    print("--- Test 4: Crisis Detection ---")
-    result = engine.process("我不想活了，感觉世界没有希望")
-    print(f"Decision: {result.decision}")
-    print()
-    
-    # Test 5: Mental health assessment
-    print("--- Test 5: Mental Health Assessment ---")
-    mental = engine.full_mental_health_assessment(
-        [2, 2, 1, 2, 1, 1, 1, 1, 1],  # PHQ-9: score 12, moderate depression
-        [1, 1, 2, 1, 1, 1, 1]           # GAD-7: score 8, mild anxiety
-    )
-    print(f"PHQ-9: {mental.phq9_score} ({mental.depression_level})")
-    print(f"GAD-7: {mental.gad7_score} ({mental.anxiety_level})")
-    print(f"Risk: {mental.risk_level}")
-    print(f"Recommendation: {mental.recommendation}")
-    
-    # Test 6: Six-layer reflection
-    print()
-    print("--- Test 6: Self-Level Growth ---")
-    r = engine.self_level.reflect("right", "solved a problem")
-    print(f"Level: {r['level']} - {r['name']} ({r['name_en']})")
-    print(f"Growth: {r['growth_trajectory']}")