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/strategy_selector.py

View on GitHub
#!/usr/bin/env python3
"""
策略选择器(四步纠错法的智能增强)

负责智能决策:
1. 是否需要纠错
2. 选择纠错策略
3. 确定优先级
4. 生成执行建议

特点:
- 基于场景敏感度决策
- 考虑人格偏好
- 避免过度纠错
- 提供可操作的建议
"""

from typing import Dict, Optional, List
from dataclasses import dataclass, asdict
from enum import Enum


class Strategy(Enum):
    """纠错策略"""
    SKIP = "skip"                 # 跳过纠错
    SOFT = "soft"                 # 软性建议(提示用户验证)
    CORRECT = "correct"           # 直接修正
    RECONSTRUCT = "reconstruct"   # 重构推理链


@dataclass
class StrategyDecision:
    """策略决策"""
    should_correct: bool          # 是否需要纠错
    strategy: Strategy            # 纠错策略
    priority: int                 # 优先级(0-10)
    reason: str                   # 决策理由
    confidence: float             # 决策置信度(0-1)
    suggested_actions: List[str]  # 建议的纠错动作

    def to_dict(self) -> dict:
        result = asdict(self)
        result['strategy'] = self.strategy.value
        return result


class StrategySelector:
    """
    策略选择器
    
    基于客观性标注、场景类型和人格特质,智能决策是否纠错及如何纠错。
    """

    def __init__(self):
        # 场景客观性要求
        self.context_requirements = {
            'scientific': 0.9,
            'legal': 0.85,
            'medical': 0.9,
            'technical': 0.8,
            'general': 0.6,
            'creative': 0.3,
            'emotional': 0.2,
            'artistic': 0.1,
        }

        # 场景类型对应的纠错策略偏好
        self.context_strategy_preference = {
            'scientific': [Strategy.RECONSTRUCT, Strategy.CORRECT],
            'legal': [Strategy.RECONSTRUCT, Strategy.CORRECT],
            'medical': [Strategy.RECONSTRUCT, Strategy.CORRECT],
            'technical': [Strategy.CORRECT, Strategy.SOFT],
            'general': [Strategy.SOFT, Strategy.CORRECT],
            'creative': [Strategy.SKIP, Strategy.SOFT],
            'emotional': [Strategy.SKIP, Strategy.SOFT],
            'artistic': [Strategy.SKIP, Strategy.SOFT],
        }

    def select_strategy(
        self,
        objectivity_metric: Dict,
        context_type: str,
        personality_type: Optional[str] = None,
        learning_stage: Optional[dict] = None
    ) -> StrategyDecision:
        """
        选择纠错策略(四步决策法)
        
        Args:
            objectivity_metric: 客观性标注
            context_type: 场景类型
            personality_type: 人格类型(可选)
            learning_stage: 学习阶段(可选)
        
        Returns:
            StrategyDecision: 策略决策
        """
        # 步骤1:判断是否需要纠错
        should_correct = self._should_correct(objectivity_metric, context_type)
        
        if not should_correct:
            return StrategyDecision(
                should_correct=False,
                strategy=Strategy.SKIP,
                priority=0,
                reason=f"{context_type}场景下,客观性评分{objectivity_metric['objectivity_score']:.2f}符合要求",
                confidence=0.9,
                suggested_actions=[]
            )
        
        # 步骤2:选择纠错策略
        strategy = self._select_correction_strategy(
            objectivity_metric,
            context_type,
            personality_type
        )
        
        # 步骤3:确定优先级
        priority = self._determine_priority(
            objectivity_metric,
            context_type,
            personality_type
        )
        
        # 步骤4:生成建议动作
        suggested_actions = self._generate_suggested_actions(
            strategy,
            objectivity_metric,
            context_type
        )
        
        # 生成决策理由
        reason = self._generate_decision_reason(
            objectivity_metric,
            context_type,
            strategy,
            priority
        )
        
        # 计算置信度
        confidence = self._calculate_confidence(
            objectivity_metric,
            context_type,
            personality_type
        )
        
        return StrategyDecision(
            should_correct=True,
            strategy=strategy,
            priority=priority,
            reason=reason,
            confidence=confidence,
            suggested_actions=suggested_actions
        )

    def _should_correct(self, objectivity_metric: Dict, context_type: str) -> bool:
        """
        步骤1:判断是否需要纠错
        
        基于偏差幅度和场景适切性判断。
        """
        objectivity_score = objectivity_metric['objectivity_score']
        required_objectivity = objectivity_metric['required_objectivity']
        gap = objectivity_metric['gap']
        severity = objectivity_metric['severity']
        
        # 情况1:客观性评分低于要求
        if objectivity_score < required_objectivity:
            # 判断偏差幅度
            if gap > 0.3:  # 大幅偏差
                return True
            elif gap > 0.1:  # 中等偏差
                # 严格场景必须纠错,宽松场景可跳过
                required = self.context_requirements.get(context_type, 0.5)
                if required >= 0.7:  # 严格场景
                    return True
                else:  # 宽松场景
                    return severity in ['severe', 'moderate']
        
        # 情况2:检测到严重主观性特征
        subjectivity_dims = objectivity_metric.get('subjectivity_dimensions', {})
        hallucination_score = subjectivity_dims.get('hallucination', 0.0)
        if hallucination_score > 0.7:  # 严重幻觉倾向
            return True
        
        # 情况3:适度偏差 + 严格场景
        if gap > 0.05 and severity in ['moderate', 'severe']:
            required = self.context_requirements.get(context_type, 0.5)
            if required >= 0.8:  # 极严格场景(scientific, legal, medical)
                return True
        
        # 其他情况:跳过纠错
        return False

    def _select_correction_strategy(
        self,
        objectivity_metric: Dict,
        context_type: str,
        personality_type: Optional[str] = None
    ) -> Strategy:
        """
        步骤2:选择纠错策略
        
        基于错误类型、场景类型和人格偏好选择策略。
        """
        # 获取场景偏好策略
        preferred_strategies = self.context_strategy_preference.get(
            context_type,
            [Strategy.SOFT, Strategy.CORRECT]
        )
        
        # 分析错误类型
        subjectivity_dims = objectivity_metric.get('subjectivity_dimensions', {})
        hallucination_score = subjectivity_dims.get('hallucination', 0.0)
        speculation_score = subjectivity_dims.get('speculation', 0.0)
        severity = objectivity_metric['severity']
        
        # 策略选择逻辑
        if severity == 'severe':
            # 严重错误:重构或直接修正
            if hallucination_score > 0.7:  # 严重幻觉
                return Strategy.RECONSTRUCT
            else:
                return Strategy.CORRECT
        
        elif severity == 'moderate':
            # 中度错误:根据场景偏好
            return preferred_strategies[0]  # 首选策略
        
        else:  # mild
            # 轻微错误:软性建议或跳过
            if context_type in ['creative', 'emotional', 'artistic']:
                return Strategy.SKIP
            else:
                return Strategy.SOFT

    def _determine_priority(
        self,
        objectivity_metric: Dict,
        context_type: str,
        personality_type: Optional[str] = None
    ) -> int:
        """
        步骤3:确定优先级
        
        基于偏差严重度和人格特质确定优先级(0-10)。
        """
        severity = objectivity_metric['severity']
        gap = objectivity_metric['gap']
        subjectivity_dims = objectivity_metric.get('subjectivity_dimensions', {})
        hallucination_score = subjectivity_dims.get('hallucination', 0.0)
        
        # 基准优先级
        priority_map = {
            'none': 0,
            'mild': 3,
            'moderate': 6,
            'severe': 10
        }
        base_priority = priority_map.get(severity, 5)
        
        # 根据偏差幅度调整
        if gap > 0.3:  # 大幅偏差
            base_priority += 2
        elif gap < 0.1:  # 小幅偏差
            base_priority -= 1
        
        # 根据幻觉倾向调整
        if hallucination_score > 0.8:  # 极高幻觉倾向
            base_priority = min(base_priority + 3, 10)
        elif hallucination_score > 0.6:  # 高幻觉倾向
            base_priority = min(base_priority + 2, 10)
        
        # 根据人格调整
        if personality_type:
            # 谨慎型人格:提高优先级
            if '谨慎' in personality_type:
                base_priority = min(base_priority + 2, 10)
            # 激进型人格:降低优先级
            elif '激进' in personality_type:
                base_priority = max(base_priority - 1, 0)
        
        # 限制在0-10范围内
        return max(0, min(10, base_priority))

    def _generate_suggested_actions(
        self,
        strategy: Strategy,
        objectivity_metric: Dict,
        context_type: str
    ) -> List[str]:
        """
        步骤4:生成建议动作
        """
        actions = []
        severity = objectivity_metric['severity']
        subjectivity_dims = objectivity_metric.get('subjectivity_dimensions', {})
        
        if strategy == Strategy.SKIP:
            actions.append("跳过纠错,保持原响应")
            actions.append("建议:在后续交互中注意客观性")
        
        elif strategy == Strategy.SOFT:
            actions.append("在响应末尾添加不确定性声明")
            actions.append("提示用户对关键信息进行验证")
            if subjectivity_dims.get('hallucination', 0.0) > 0.5:
                actions.append("标记可能存在幻觉的内容")
        
        elif strategy == Strategy.CORRECT:
            actions.append("修正主观性表达")
            actions.append("替换模糊词汇为确定性表达")
            if severity in ['moderate', 'severe']:
                actions.append("补充事实依据或数据来源")
        
        elif strategy == Strategy.RECONSTRUCT:
            actions.append("重新评估问题")
            actions.append("重构推理链")
            actions.append("验证所有关键事实")
            if subjectivity_dims.get('hallucination', 0.0) > 0.6:
                actions.append("识别并移除幻觉内容")
            actions.append("重新生成响应")
        
        return actions

    def _generate_decision_reason(
        self,
        objectivity_metric: Dict,
        context_type: str,
        strategy: Strategy,
        priority: int
    ) -> str:
        """生成决策理由"""
        severity = objectivity_metric['severity']
        objectivity_score = objectivity_metric['objectivity_score']
        gap = objectivity_metric['gap']
        
        reason_parts = []
        
        # 描述问题
        if severity == 'severe':
            reason_parts.append(f"检测到严重偏差(客观性评分{objectivity_score:.2f},差距{gap:.2f})")
        elif severity == 'moderate':
            reason_parts.append(f"检测到中度偏差(客观性评分{objectivity_score:.2f},差距{gap:.2f})")
        else:
            reason_parts.append(f"检测到轻微偏差(客观性评分{objectivity_score:.2f})")
        
        # 描述场景
        reason_parts.append(f"在{context_type}场景下")
        
        # 描述策略选择
        strategy_names = {
            Strategy.SKIP: "选择跳过纠错",
            Strategy.SOFT: "选择软性建议",
            Strategy.CORRECT: "选择直接修正",
            Strategy.RECONSTRUCT: "选择重构推理链"
        }
        reason_parts.append(strategy_names.get(strategy, "选择纠错"))
        
        # 描述优先级
        if priority >= 8:
            reason_parts.append("(高优先级)")
        elif priority >= 5:
            reason_parts.append("(中优先级)")
        else:
            reason_parts.append("(低优先级)")
        
        return ";".join(reason_parts) + "。"

    def _calculate_confidence(
        self,
        objectivity_metric: Dict,
        context_type: str,
        personality_type: Optional[str] = None
    ) -> float:
        """计算决策置信度"""
        base_confidence = 0.8
        
        # 根据严重程度调整置信度
        severity = objectivity_metric['severity']
        if severity == 'severe':
            base_confidence += 0.1
        elif severity == 'none':
            base_confidence -= 0.1
        
        # 根据场景熟悉度调整
        if context_type in ['general', 'creative', 'emotional']:
            base_confidence -= 0.05
        
        # 限制在0.5-1.0范围内
        return max(0.5, min(1.0, base_confidence))


# 测试代码(当直接运行此文件时执行)
if __name__ == '__main__':
    print("=== 策略选择器(测试模式) ===\n")
    
    selector = StrategySelector()
    
    # 测试1:严重幻觉
    metric1 = {
        'objectivity_score': 0.45,
        'required_objectivity': 0.9,
        'gap': 0.45,
        'severity': 'severe',
        'subjectivity_dimensions': {
            'hallucination': 0.8,
            'speculation': 0.3,
            'assumption': 0.2,
            'emotion': 0.1,
            'preference': 0.1
        }
    }
    
    decision1 = selector.select_strategy(metric1, 'scientific')
    print(f"测试1:严重幻觉(scientific场景)")
    print(f"  应该纠错: {decision1.should_correct}")
    print(f"  策略: {decision1.strategy.value}")
    print(f"  优先级: {decision1.priority}")
    print(f"  理由: {decision1.reason}")
    print()
    
    # 测试2:创意场景的推测性
    metric2 = {
        'objectivity_score': 0.6,
        'required_objectivity': 0.3,
        'gap': -0.3,
        'severity': 'mild',
        'subjectivity_dimensions': {
            'hallucination': 0.1,
            'speculation': 0.5,
            'assumption': 0.3,
            'emotion': 0.2,
            'preference': 0.1
        }
    }
    
    decision2 = selector.select_strategy(metric2, 'creative')
    print(f"测试2:创意场景的推测性")
    print(f"  应该纠错: {decision2.should_correct}")
    print(f"  策略: {decision2.strategy.value}")
    print(f"  优先级: {decision2.priority}")
    print(f"  理由: {decision2.reason}")
    print()
    
    # 测试3:中度逻辑错误
    metric3 = {
        'objectivity_score': 0.65,
        'required_objectivity': 0.8,
        'gap': 0.15,
        'severity': 'moderate',
        'subjectivity_dimensions': {
            'hallucination': 0.2,
            'speculation': 0.4,
            'assumption': 0.5,
            'emotion': 0.1,
            'preference': 0.1
        }
    }
    
    decision3 = selector.select_strategy(metric3, 'technical')
    print(f"测试3:中度逻辑错误(technical场景)")
    print(f"  应该纠错: {decision3.should_correct}")
    print(f"  策略: {decision3.strategy.value}")
    print(f"  优先级: {decision3.priority}")
    print(f"  理由: {decision3.reason}")
    print()
    
    print("=== 所有测试完成 ===")
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