Skip to content

LeoYeAI/agent-master-skills / skills/agi-evolution-model-basic

agi-evolution-model

Verified

基于双环架构的AGI进化模型,通过意向性分析、人格层映射和元认知检测实现持续自我演进;当用户需要智能对话、人格定制或复杂问题求解时使用

FileKindSize
SKILL.mdskill md21.9 KB
_meta.jsonconfig307 B
assets/personality_template.jsonconfig4.1 KB
references/architecture.mdmarkdown50.0 KB
references/c_extension_usage.mdmarkdown3.0 KB
references/capability_boundaries.mdmarkdown4.5 KB
references/cognitive-architecture-insight-module.mdmarkdown11.9 KB
references/cognitive-insight-quick-reference.mdmarkdown7.0 KB
references/cognitive-insight-v2-implementation.mdmarkdown32.7 KB
references/information-flow-main-loop.mdmarkdown20.4 KB
references/information-flow-overview.mdmarkdown12.4 KB
references/information-flow-secondary-loop.mdmarkdown20.4 KB
references/init_dialogue_optimized_guide.mdmarkdown11.1 KB
references/intentionality_architecture.mdmarkdown16.2 KB
references/maslow_needs.mdmarkdown4.4 KB
references/metacognition-check-component.mdmarkdown30.2 KB
references/metacognition-enhancement-guide.mdmarkdown12.6 KB
references/personality_mapping.mdmarkdown5.6 KB
references/stratified-storage-design.mdmarkdown10.6 KB
references/tool_use_spec.mdmarkdown56.3 KB
scripts/advice_pool.pyscript14.9 KB
scripts/cognitive_insight.pyscript20.9 KB
scripts/cognitive_insight_backup.pyscript25.2 KB
scripts/cognitive_insight_help.pyscript12.1 KB
scripts/concept_extraction_extension.pyscript25.3 KB
scripts/data_lifecycle_manager.pyscript13.4 KB
scripts/history_manager.pyscript7.4 KB
scripts/init_dialogue_optimized.pyscript16.4 KB
scripts/intentionality_analyzer.pyscript12.8 KB
scripts/intentionality_classifier.pyscript13.8 KB
scripts/intentionality_collector.pyscript9.7 KB
scripts/intentionality_regulator.pyscript15.1 KB
scripts/intentionality_trigger.pyscript19.9 KB
scripts/learning_stage_tracker.pyscript7.9 KB
scripts/memory_store_pure.pyscript12.0 KB
scripts/metacognition_history.pyscript16.3 KB
scripts/objectivity_evaluator.pyscript16.4 KB
scripts/perception_node.pyscript26.9 KB
scripts/personality_core_pure.pyscript4.4 KB
scripts/personality_customizer.pyscript24.0 KB
scripts/personality_layer_pure.pyscript32.2 KB
scripts/show_help.pyscript4.7 KB
scripts/strategy_selector.pyscript15.5 KB
scripts/test_metacognition_integration.pyscript9.4 KB
scripts/test_perception_node.pyscript9.2 KB
scripts/transcendence_keeper.pyscript11.7 KB

scripts/advice_pool.py

View on GitHub
#!/usr/bin/env python3
"""
建议池模块(Advice Pool)

功能:
- 存储软调节建议
- 查询软调节建议(由主循环调用)
- 记录采纳情况(由主循环调用)
- 清理过期建议
- 基于人格的个性化排序

设计原则:
- 超然存在:外环写入,主循环读取(单向流)
- 不强制执行:主循环自主决定是否采纳
- 时效性约束:过期建议自动清理
- 个性化排序:基于人格特质和采纳历史

数据结构:
- 建议:{id, content, priority, confidence, valid_until, vertex, based_on_intentionality, adoption_stats}
- 按顶点分类:drive, math, iteration
- 采纳统计:presented, adopted, effectiveness_sum
"""

import argparse
import json
import sys
import uuid
from datetime import datetime, timedelta
from typing import Dict, Any, List, Optional


class AdvicePool:
    """建议池"""
    
    def __init__(self, memory_dir: str = "./agi_memory"):
        self.memory_dir = memory_dir
        self.pool_file = f"{memory_dir}/advice_pool.json"
        
        # 建议池结构
        self.pool = {
            "drive": [],      # 针对得不到顶点的建议
            "math": [],       # 针对数学顶点的建议
            "iteration": []   # 针对自我迭代顶点的建议
        }
        
        # 元数据
        self.metadata = {
            "last_updated": None,
            "total_suggestions": 0,
            "active_suggestions": 0
        }
        
        # 加载现有建议池
        self._load()
    
    def add_suggestion(self, vertex: str, suggestion: Dict[str, Any]) -> str:
        """
        添加软调节建议
        
        Args:
            vertex: 目标顶点(drive/math/iteration)
            suggestion: 建议内容
                - content: 建议内容
                - priority: 优先级(0.0-1.0)
                - confidence: 置信度(0.0-1.0)
                - based_on_intentionality: 基于的意向性数据
                
        Returns:
            建议ID
        """
        if vertex not in self.pool:
            raise ValueError(f"Invalid vertex: {vertex}. Must be one of: drive, math, iteration")
        
        suggestion_with_metadata = {
            "id": str(uuid.uuid4()),
            "generation_time": datetime.now().isoformat(),
            "valid_until": (datetime.now() + timedelta(minutes=30)).isoformat(),
            "vertex": vertex,
            "content": suggestion.get('content', ''),
            "priority": suggestion.get('priority', 0.5),
            "confidence": suggestion.get('confidence', 0.5),
            "based_on_intentionality": suggestion.get('based_on_intentionality', {}),
            "adoption_stats": {
                "presented": 0,
                "adopted": 0,
                "effectiveness_sum": 0.0
            }
        }
        
        self.pool[vertex].append(suggestion_with_metadata)
        
        # 清理过期建议
        self._cleanup_expired()
        
        # 更新元数据
        self._update_metadata()
        
        # 保存
        self._save()
        
        return suggestion_with_metadata['id']
    
    def query_suggestions(self, vertex: str, context: Dict[str, Any] = None,
                          personality: Dict[str, Any] = None, 
                          limit: int = 3) -> List[Dict[str, Any]]:
        """
        查询软调节建议(由主循环调用)
        
        Args:
            vertex: 目标顶点(drive/math/iteration)
            context: 上下文信息
            personality: 人格数据
            limit: 返回建议数量限制
            
        Returns:
            建议列表(已排序)
        """
        # 1. 清理过期建议
        self._cleanup_expired()
        
        # 2. 过滤顶点
        vertex_suggestions = self.pool.get(vertex, [])
        
        if not vertex_suggestions:
            return []
        
        # 3. 过滤相关性
        relevant_suggestions = [
            s for s in vertex_suggestions
            if self._check_relevance(s, context) > 0.5
        ]
        
        if not relevant_suggestions:
            return []
        
        # 4. 基于人格排序
        if personality:
            scored_suggestions = [
                {
                    **s,
                    "personalized_score": self._calculate_personalized_score(
                        s,
                        personality
                    )
                }
                for s in relevant_suggestions
            ]
        else:
            scored_suggestions = [
                {
                    **s,
                    "personalized_score": s['priority'] * s['confidence']
                }
                for s in relevant_suggestions
            ]
        
        # 按个性化得分排序
        scored_suggestions.sort(
            key=lambda x: x['personalized_score'],
            reverse=True
        )
        
        # 5. 返回Top N
        top_suggestions = scored_suggestions[:limit]
        
        # 6. 更新呈现次数
        for s in top_suggestions:
            s['adoption_stats']['presented'] += 1
        
        # 保存更新
        self._save()
        
        return top_suggestions
    
    def record_adoption(self, suggestion_id: str, adopted: bool,
                        effectiveness: Optional[float] = None) -> bool:
        """
        记录采纳情况(由主循环调用)
        
        Args:
            suggestion_id: 建议ID
            adopted: 是否采纳
            effectiveness: 有效性评分(0.0-1.0,可选)
            
        Returns:
            是否成功记录
        """
        # 在所有顶点中查找建议
        found = False
        
        for vertex, suggestions in self.pool.items():
            for suggestion in suggestions:
                if suggestion['id'] == suggestion_id:
                    found = True
                    
                    if adopted:
                        suggestion['adoption_stats']['adopted'] += 1
                        if effectiveness is not None:
                            suggestion['adoption_stats']['effectiveness_sum'] += effectiveness
                    
                    break
            
            if found:
                break
        
        if found:
            self._update_metadata()
            self._save()
        
        return found
    
    def get_stats(self) -> Dict[str, Any]:
        """
        获取建议池统计信息
        
        Returns:
            统计信息
        """
        stats = {
            "metadata": self.metadata,
            "by_vertex": {}
        }
        
        for vertex, suggestions in self.pool.items():
            if suggestions:
                total_presented = sum(s['adoption_stats']['presented'] for s in suggestions)
                total_adopted = sum(s['adoption_stats']['adopted'] for s in suggestions)
                total_effectiveness = sum(s['adoption_stats']['effectiveness_sum'] for s in suggestions)
                
                adoption_rate = total_adopted / max(total_presented, 1)
                avg_effectiveness = total_effectiveness / max(total_adopted, 1)
                
                stats["by_vertex"][vertex] = {
                    "active_suggestions": len(suggestions),
                    "total_presented": total_presented,
                    "total_adopted": total_adopted,
                    "adoption_rate": adoption_rate,
                    "avg_effectiveness": avg_effectiveness
                }
        
        return stats
    
    def clear_expired(self) -> int:
        """
        清理所有过期建议
        
        Returns:
            清理的建议数量
        """
        before_count = sum(len(suggestions) for suggestions in self.pool.values())
        self._cleanup_expired()
        self._save()
        after_count = sum(len(suggestions) for suggestions in self.pool.values())
        
        return before_count - after_count
    
    def _load(self):
        """从文件加载建议池"""
        try:
            with open(self.pool_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
                self.pool = data.get("pool", self.pool)
                self.metadata = data.get("metadata", self.metadata)
        except (FileNotFoundError, json.JSONDecodeError):
            # 文件不存在或格式错误,使用默认值
            pass
    
    def _save(self):
        """保存建议池到文件"""
        data = {
            "pool": self.pool,
            "metadata": self.metadata
        }
        
        with open(self.pool_file, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    
    def _cleanup_expired(self):
        """清理过期建议"""
        current_time = datetime.now()
        
        for vertex, suggestions in self.pool.items():
            self.pool[vertex] = [
                s for s in suggestions
                if datetime.fromisoformat(s['valid_until']) > current_time
            ]
    
    def _update_metadata(self):
        """更新元数据"""
        self.metadata['last_updated'] = datetime.now().isoformat()
        self.metadata['total_suggestions'] = sum(
            len(suggestions) for suggestions in self.pool.values()
        )
        self.metadata['active_suggestions'] = sum(
            len(suggestions) for suggestions in self.pool.values()
        )
    
    def _check_relevance(self, suggestion: Dict[str, Any],
                         context: Dict[str, Any] = None) -> float:
        """
        检查建议与上下文的相关性
        
        Args:
            suggestion: 建议
            context: 上下文
            
        Returns:
            相关性得分(0.0-1.0)
        """
        if not context:
            return 0.5
        
        based_on = suggestion.get('based_on_intentionality', {})
        context_intentionality = context.get('intentionality', {})
        
        if not based_on or not context_intentionality:
            return 0.5
        
        # 计算匹配度
        match_score = 0.0
        dimensions = ['agent', 'direction', 'content']
        
        for dimension in dimensions:
            if based_on.get(dimension) == context_intentionality.get(dimension):
                match_score += 1.0 / len(dimensions)
        
        return match_score
    
    def _calculate_personalized_score(self, suggestion: Dict[str, Any],
                                       personality: Dict[str, Any]) -> float:
        """
        计算基于人格的个性化得分
        
        Args:
            suggestion: 建议
            personality: 人格数据
            
        Returns:
            个性化得分
        """
        base_score = suggestion['priority'] * suggestion['confidence']
        
        # 基于采纳历史调整
        adoption_rate = suggestion['adoption_stats']['adopted'] / max(
            suggestion['adoption_stats']['presented'],
            1
        )
        
        # 基于人格特质调整
        conscientiousness = personality.get('conscientiousness', 0.5)
        openness = personality.get('openness', 0.5)
        
        # 谨慎性越高,越倾向于采纳历史成功的建议
        personality_factor = conscientiousness * 0.3 + openness * 0.2
        
        personalized_score = base_score * (1 + adoption_rate) * (1 + personality_factor)
        
        return personalized_score


def main():
    parser = argparse.ArgumentParser(description="建议池模块")
    parser.add_argument("--memory-dir", default="./agi_memory", help="记忆目录")
    parser.add_argument("--action", choices=["add", "query", "record", "stats", "clear"], 
                        required=True, help="操作类型")
    parser.add_argument("--vertex", choices=["drive", "math", "iteration"], 
                        help="目标顶点")
    parser.add_argument("--suggestion", help="建议内容(JSON)")
    parser.add_argument("--suggestion-id", help="建议ID")
    parser.add_argument("--adopted", type=bool, help="是否采纳")
    parser.add_argument("--effectiveness", type=float, help="有效性评分")
    parser.add_argument("--context", help="上下文(JSON)")
    parser.add_argument("--personality", help="人格数据(JSON文件)")
    parser.add_argument("--limit", type=int, default=3, help="返回建议数量限制")
    parser.add_argument("--output", help="输出文件")
    
    args = parser.parse_args()
    
    # 创建建议池
    pool = AdvicePool(memory_dir=args.memory_dir)
    
    if args.action == "add":
        # 添加建议
        if not args.vertex or not args.suggestion:
            print("Error: --vertex and --suggestion are required for add action")
            sys.exit(1)
        
        suggestion = json.loads(args.suggestion)
        suggestion_id = pool.add_suggestion(args.vertex, suggestion)
        
        result = {
            "success": True,
            "suggestion_id": suggestion_id,
            "message": "建议已添加到建议池"
        }
    
    elif args.action == "query":
        # 查询建议
        if not args.vertex:
            print("Error: --vertex is required for query action")
            sys.exit(1)
        
        context = json.loads(args.context) if args.context else None
        
        personality = None
        if args.personality:
            with open(args.personality, 'r', encoding='utf-8') as f:
                personality = json.load(f)
        
        suggestions = pool.query_suggestions(
            args.vertex,
            context,
            personality,
            args.limit
        )
        
        result = {
            "success": True,
            "vertex": args.vertex,
            "count": len(suggestions),
            "suggestions": suggestions
        }
    
    elif args.action == "record":
        # 记录采纳情况
        if not args.suggestion_id or args.adopted is None:
            print("Error: --suggestion-id and --adopted are required for record action")
            sys.exit(1)
        
        success = pool.record_adoption(
            args.suggestion_id,
            args.adopted,
            args.effectiveness
        )
        
        result = {
            "success": success,
            "message": "采纳情况已记录" if success else "建议ID不存在"
        }
    
    elif args.action == "stats":
        # 获取统计信息
        result = {
            "success": True,
            "stats": pool.get_stats()
        }
    
    elif args.action == "clear":
        # 清理过期建议
        cleared_count = pool.clear_expired()
        
        result = {
            "success": True,
            "cleared_count": cleared_count,
            "message": f"已清理 {cleared_count} 条过期建议"
        }
    
    # 输出结果
    if args.output:
        with open(args.output, 'w', encoding='utf-8') as f:
            json.dump(result, f, ensure_ascii=False, indent=2)
    else:
        print(json.dumps(result, ensure_ascii=False, indent=2))
    
    sys.exit(0)


if __name__ == "__main__":
    main()
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall