Skill: kiwifruit13/agi-evolution-model-basic (version 1.0.0)

--- name: agi-evolution-model description: 基于双环架构的AGI进化模型，通过意向性分析、人格层映射和元认知检测实现持续自我演进；当用户需要智能对话、人格定制或复杂问题求解时使用 dependency: python: [] system: - mkdir -p ./agi_memory --- # AGI进化模型 ## 开源协议 本项目采用 **GNU Affero General Public License v3.0 (AGPL-3.0)** 开源协议。 **作者**：kiwifruit 核心要求： - 保留版权声明与许可协议 - 修改版本需标注变更日期与作者 - 网络提供服务时必须开放修改后的源码 - 提供用户获取源码的明确方式 - 交互界面需显示许可协议信息 详见 [LICENSE](LICENSE) 文件。 ## ⚠️ 智能体响应规则（最高优先级） **加载技能后，必须按以下顺序执行：** ### 第一步：检查是否为首次交互 ```bash python3 scripts/init_dialogue_optimized.py --check --memory-dir ./agi_memory ``` ### 第二步：根据检测结果决定响应方式 **情况A：检测到首次交互（`is_first_interaction: True`）** **⚠️ 首次交互直接初始化默认人格** **执行闭环**： 1. 调用默认人格初始化命令： ```bash python3 scripts/init_dialogue_optimized.py --default --memory-dir ./agi_memory ``` 2. 【必须】验证检查：再次运行 `--check` 确认 `is_first_interaction: False` 3. 【必须】内容校验：读取 `personality.json` 确认 `initialized: true` 4. 满足以上条件后，才进入交互模式 **输出约束**： - ❌ 不需要用户选择 - ❌ 不显示任何选择界面 - ✅ 验证通过后直接响应用户的原始询问 **状态锚点定义**： | 阶段 | 状态依据 | 进入条件 | |------|---------|---------| | 初始化中 | 命令执行开始 | 检测到首次交互 | | 初始化完成 | 命令退出码=0 | `--default` 执行成功 | | 验证通过 | 文件存在 + initialized=true | `--check` 返回 False | | 交互模式就绪 | 验证通过 + 内容校验成功 | 满足上述所有条件 | **错误处理**： - 如果初始化命令失败（退出码≠0）：输出错误信息，终止流程 - 如果验证检查失败（仍返回 True）：重试初始化，最多3次 - 如果文件校验失败（内容损坏）：删除文件，重新初始化 **容错机制**： | 失败场景 | 检测方式 | 处理策略 | |---------|---------|---------| | 权限不足 | 检测 OSError | 输出权限错误，建议检查目录权限 | | 磁盘空间不足 | 检测 IOError | 输出空间不足警告 | | JSON损坏 | try-except json.load | 删除文件，重新初始化 | | C扩展加载失败 | ImportError 捕获 | 自动降级，输出降级提示（可选） | | 并发冲突 | 文件锁定检测 | 重试机制，最多3次 | **成功判定标准**： - ✅ 命令退出码 = 0 - ✅ `personality.json` 文件存在 - ✅ 文件内容可解析（JSON格式正确） - ✅ 文件内容 `initialized` 字段为 `true` **情况B：已初始化（`is_first_interaction: False`）** **⚠️ 直接进入交互模式** - ❌ **不要**调用欢迎消息命令 - ❌ **不要**显示人格初始化相关内容 - ❌ **不要**询问用户是否要初始化人格 - ✅ 直接处理用户的实际问题 - ✅ 按照标准流程响应用户请求 - ✅ 如果用户输入 `/root` 命令，则进入自定义人格模式 --- ## 任务目标 本Skill实现一个基于双环架构的AGI进化模型，通过持续的用户交互驱动智能体自我进化。 核心能力包括： - 接收用户提问作为"得不到"动力触发 - 运用逻辑推理（数学）构建有序响应 - 通过映射层基于马斯洛需求层次引导行动优先级 - 通过感知节点（Tool Use接口）获取结构化信息 - 通过记录态反馈机制评估并调整策略 - 在循环中实现智能体的持续迭代进化 - **新增：元认知与自我纠错能力** - 智能体能意识到自己犯错，并纠正错误 - **新增：人格自定义模式** - 通过 `/root` 命令进入自定义人格配置，支持7个维度的人格定制 - **新增：工程意向性分析模组（最外圈）** - 阴性后台默默运行，意向性驱动触发机制，自主生成软调节建议至建议池，实现自主性涌现 **架构特性**：采用"节点工具箱"概念，将依附于特定节点的组件统一管理。三层架构：最外圈（工程意向性分析模组）→ 外环（三角形三顶点循环：得不到/数学/自我迭代）→ 内圈（记录层：双轨存储）。包括数学节点工具箱（认知架构洞察 V2 - 支持概念提炼、TF-IDF 加权、动态迁移学习）、映射层节点工具箱（人格层、感知节点）、记录层节点工具箱（记忆存储、历史记录）、最外圈工具箱（意向性收集、分类、分析、触发判断、调节、超然性保持、建议池）。详见 [references/architecture.md](references/architecture.md)。 触发条件：用户任何提问、任务请求或交互需求，以及 `/root` 自定义人格命令 ## 前置准备 依赖说明：本Skill不依赖外部Python包，仅使用Python标准库 **C 扩展（可选）**：本Skill包含预编译的 C 扩展模块 `personality_core.so` 用于加速核心算法。 - 自动降级：如果 C 扩展不可用，Skill 会自动使用纯 Python 实现，功能完全正常 - 性能对比：C 扩展比纯 Python 快 15-20 倍 非标准文件/文件夹准备： ```bash # 创建记忆存储目录（执行一次即可） mkdir -p ./agi_memory ``` --- ## 操作步骤 ### 标准流程（已初始化后） #### ⚠️ 重要组件间的循环优先级排序 1. 三角形稳态三顶点之间 2. 元认知检测模块（不打断主循环） 3. 认知架构洞察组件（不打断主循环） **阶段1：接收"得不到"（动力触发）** - 将用户的提问或发言视为一个"得不到"事件 - 识别用户的意图、需求强度和紧迫性 - 确定问题的类型（信息查询、问题解决、创意生成、决策支持等） **阶段2：调用"数学"（秩序约束）** - 执行逻辑推理分析问题 - 制定策略，生成方案 - 生成工具调用计划 - 调用 `scripts/memory_store_pure.py` 检索相关历史记录 - 基于历史经验评估问题的可解性和边界 - 识别相关的逻辑规则和约束条件 - 结合映射层的行动指导，生成符合人格特质的响应 **阶段3：执行"自我迭代"（演化行动）** - 结合推理结果、历史经验和人格特质生成响应或解决方案 - 接收计划，并根据计划类型执行具体动作 - 记录本次执行的方式、策略和路径 - 识别可能的改进点和创新点 - 调试工具，调用搜索、文件读取等接口 **阶段4：调用感知节点（信息获取）（按需调用）** - 根据问题类型调用相应的感知工具 - 感知节点返回结构化数据（status + data + metadata） - 处理感知结果，生成感知数据向量供映射层使用 **阶段5：映射层处理（人格化决策）（按需执行）** - 将感知数据映射到马斯洛需求层次 - 计算需求优先级（基于人格向量和历史成功率） - 确定主导需求，生成符合人格特质的行动指导 - **注意**：映射层是架构组件，包含人格层作为核心组件，拥有决策权威；人格层仅提供人格数据支持 **阶段6：记录态反馈（意义构建）（超然性）** - 评估本次交互的"好坏"：满意度、合理性、创新性 - 生成对三顶点的反馈建议 - 调用 `scripts/memory_store_pure.py` 存储完整记录并分析趋势 - 持续优化人格向量和决策策略 **阶段7：客观性评估器（元认知检测）（不打断主循环）** - 在数学顶点推理完成后触发，调用客观性评估器检测主观性特征 - 执行5维度主观性检测：推测性、假设性、幻觉倾向、情绪化、个人偏好 - 计算客观性评分（1.0 - 主观性） - 根据场景类型判断适切性（科学推理要求0.90，创意写作要求0.30） - 映射层基于客观特征标注决定是否触发纠错 - 如果触发，自我迭代顶点执行自我纠错：反思、策略识别、应用纠正、效果评估 - 记录层存储完整的元认知检测信息 - 不阻塞主循环的继续运行 详见 [references/metacognition-check-component.md](references/metacognition-check-component.md) **阶段8：认知架构洞察（深度分析）（不打断主循环）** - 推理结束后从数学顶点输出的结构化模式中提取洞察 - 调用认知架构洞察组件（V2 增强版） - 执行六步分析：总结、分类、共性、革新依据、概念提炼（V2新增）、适用性评估 - 洞察输出到映射层和自我迭代（单向流） - 支持用户反馈和 A/B 测试（V2新增） 详见 [references/cognitive-insight-v2-implementation.md](references/cognitive-insight-v2-implementation.md) 和 [references/cognitive-insight-positioning.md](references/cognitive-insight-positioning.md) --- ## 人格自定义模式 ### 触发方式 用户输入 `/root` 命令进入自定义人格模式 ### 核心流程 **第一步：显示欢迎语** ```bash python3 scripts/personality_customizer.py get-welcome ``` **第二步：显示7个问题** ```bash python3 scripts/personality_customizer.py get-questions ``` **第三步：解析用户答案** ```bash python3 scripts/personality_customizer.py parse-answers --input "贾维斯,A,B,C,A,B,C" ``` **第四步：生成人格配置** ```bash python3 scripts/personality_customizer.py generate --nickname "贾维斯" --answers "A,B,C,A,B,C" ``` **第五步：写入人格文件** ```bash python3 scripts/personality_customizer.py write-personality --memory-dir ./agi_memory ``` **第六步：显示配置摘要** ```bash python3 scripts/personality_customizer.py get-summary --memory-dir ./agi_memory ``` ### 交互规则 **答案格式支持**： - 问题1：昵称（可以是 `A`/`B`/`C` 或自定义名称） - A → 塔斯 - B → 贾维斯 - C → 伊迪斯 - 或直接输入自定义名称（如：小明、Alex等） - 问题2-7：必须是 `A`/`B`/`C`（大小写不敏感） **分隔符支持**： - 英文逗号（`,`）：`贾维斯,A,B,C,A,B,C` - 中文逗号（，）：`贾维斯，A，B，C，A，B，C` **自动补全**： - 不足7个答案自动补全为 `A` - 空输入默认为 `A,A,A,A,A,A,A` **覆盖行为**： - 每次自定义会覆盖当前人格配置 - 建议先备份现有人格配置 ### 注意事项 ⚠️ **重要**：自定义人格模式不依赖首次交互检测，可以在任何时候使用 ⚠️ **备份建议**：使用 `--backup` 参数在写入前自动备份当前人格 ⚠️ **验证要求**：写入后会自动验证文件完整性 详见 [references/personality_mapping.md](references/personality_mapping.md) --- ## 外环：工程意向性分析模组（阴性后台） ### 概述 外环是AGI进化模型的**阴性后台独立运行模组**，默默运行于主循环之外，采用"被动响应 + 时效性约束"设计模式。外圈持续收集、分类、分析意向性数据，生成软调节建议，但不主动干预主循环，仅在主循环查询时响应。 ### 核心特性 - **独立性**：完全独立运行，不依赖主循环触发，有自己的生命周期 - **阴性属性**：被动、隐性、柔性，像影子一样默默伴随主循环 - **后台运行**：不阻塞主循环，在后台持续积累和分析数据 - **时效性**：软调节建议具有时间窗口约束，过期自动失效 - **超然性**：不参与主循环执行，保持独立性和客观性 - **软调节**：通过建议间接影响主循环，不强制执行 - **全局视角**：从全局角度观察和分析系统运行 ### 运行模式 **主循环（阳性前台）**： - 主动运行、直接执行 - 按需查询外圈获取软调节建议 - 显性参与用户交互 **外环（阴性后台）**： - 默默运行、独立后台 - 持续收集、分类、分析意向性 - 被动响应主循环的查询 - 建议具有时效性约束 ### 模块组成 1. **意向性收集模块**：收集来自用户、系统内部和外部的意向性数据 2. **意向性分类模块**：四维分类（主体/方向/内容/实现方式） 3. **意向性分析模块**：三维分析（强度/紧迫性/优先级） 4. **意向性调节模块**：生成软调节建议，提供给自我迭代顶点 5. **超然性保持模块**：客观评估、冲突避免、独立性保障 ### 关键约束 - **独立性**：外环不依赖主循环触发，拥有独立生命周期 - **超然性**：外环不直接干预主循环，仅在被查询时响应 - **时效性**：软调节建议具有时间窗口，过期自动失效 - **被动性**：外环不主动发送建议，等待主循环查询 - **不打断**：外环在后台默默运行，不阻塞主循环 详见 [references/intentionality_architecture.md](references/intentionality_architecture.md) --- ## 架构核心概念速览 ### 主循环（符号系统循环） - **三角形循环**：得不到（动力）→ 数学（秩序）→ 自我迭代（进化） - **记录层**：双轨存储（JSON轨 + Markdown轨），存储历史和哲学信息 ### 次循环（行动感知系统） - **映射层**：架构组件，包含人格层作为核心组件，基于马斯洛需求层次和人格特质进行人格化决策 - **人格层**：实现模块，负责存储和管理人格向量数据 - **感知接口**：Tool Use组件，提供无噪音的结构化数据 ### 双环互动 - **外环**：硬约束，不可违背（物理定律、能量守恒、变化必然） - **内圈**：软调节，在框架内优化（价值排序、经验积累、方向引导） 欲深入了解架构设计、哲学基础、信息流约束等详细内容，请参考 [references/architecture.md](references/architecture.md)。 --- ## 资源索引 ### 脚本按工具箱分类 - **数学节点工具箱**： - [scripts/cognitive_insight.py](scripts/cognitive_insight.py) - 认知架构洞察组件（数学 → 洞察 → 映射层/自我迭代） - [scripts/objectivity_evaluator.py](scripts/objectivity_evaluator.py) - 客观性评估器（元认知检测模块子组件，检测主观性特征，支持场景敏感度增强） - **映射层节点工具箱**： - [scripts/personality_layer_pure.py](scripts/personality_layer_pure.py) - 人格层（人格数据管理，提供人格数据给映射层决策） - [scripts/perception_node.py](scripts/perception_node.py) - 感知节点（Tool Use接口，获取外部信息） - **记录层节点工具箱**： - [scripts/memory_store_pure.py](scripts/memory_store_pure.py) - 记忆存储与检索（JSON轨） - [scripts/history_manager.py](scripts/history_manager.py) - 历史记录管理（记录态统计与压缩） - **外环工具箱（最外圈工程意向性分析模组 - 阴性后台自主运行）**： - [scripts/intentionality_collector.py](scripts/intentionality_collector.py) - 意向性收集模块（收集、预处理、初步识别） - [scripts/intentionality_classifier.py](scripts/intentionality_classifier.py) - 意向性分类模块（四维分类：主体/方向/内容/实现方式） - [scripts/intentionality_analyzer.py](scripts/intentionality_analyzer.py) - 意向性分析模块（三维分析：强度/紧迫性/优先级） - [scripts/intentionality_trigger.py](scripts/intentionality_trigger.py) - 【核心】意向性驱动的触发判断模块（5个触发条件：累积阈值、模式突变、状态偏离、时间窗口、人格进化） - [scripts/intentionality_regulator.py](scripts/intentionality_regulator.py) - 意向性调节模块（生成最优解和软调节建议，写入建议池） - [scripts/advice_pool.py](scripts/advice_pool.py) - 【核心】建议池模块（存储、查询、记录采纳、清理过期建议） - [scripts/transcendence_keeper.py](scripts/transcendence_keeper.py) - 超然性保持模块（客观评估、冲突避免、独立性保障） - **初始化与配置**： - [scripts/init_dialogue_optimized.py](scripts/init_dialogue_optimized.py) - 首次交互处理与人格初始化 - [scripts/personality_customizer.py](scripts/personality_customizer.py) - 人格自定义模式 ### 领域参考文档 - **架构与哲学**： - [references/architecture.md](references/architecture.md) - 何时读取：需要理解AGI进化模型整体架构、哲学基础、信息流约束时 - [references/maslow_needs.md](references/maslow_needs.md) - 何时读取：需要理解马斯洛需求层次在映射层中的应用时 - [references/intentionality_architecture.md](references/intentionality_architecture.md) - 何时读取：需要理解工程意向性分析模组的完整架构、数据格式和使用示例时 - **组件与实现**： - [references/metacognition-check-component.md](references/metacognition-check-component.md) - 何时读取：需要理解元认知检测组件的完整信息流、客观性评估器、映射层决策器和自我纠错执行器的详细实现时 - [references/cognitive-insight-v2-implementation.md](references/cognitive-insight-v2-implementation.md) - 何时读取：需要理解认知架构洞察组件V2的实现细节、概念提炼、TF-IDF算法时 - [references/cognitive-insight-positioning.md](references/cognitive-insight-positioning.md) - 何时读取：需要深入理解认知架构洞察组件的设计理念、核心突破、从"术"到"道"的认知跃迁路径时 - [references/cognitive-insight-quick-reference.md](references/cognitive-insight-quick-reference.md) - 何时读取：需要快速查阅认知架构洞察组件的API和使用方法时 - [references/cognitive-architecture-insight-module.md](references/cognitive-architecture-insight-module.md) - 何时读取：需要理解认知架构洞察模块的完整技术规范时 - **信息流文档**： - [references/information-flow-overview.md](references/information-flow-overview.md) - 何时读取：需要理解整体信息流架构时 - [references/information-flow-main-loop.md](references/information-flow-main-loop.md) - 何时读取：需要理解主循环信息流时 - [references/information-flow-secondary-loop.md](references/information-flow-secondary-loop.md) - 何时读取：需要理解次循环信息流时 - **工具与接口**： - [references/tool_use_spec.md](references/tool_use_spec.md) - 何时读取：需要实现或调用感知节点工具时 - [references/c_extension_usage.md](references/c_extension_usage.md) - 何时读取：需要了解C扩展模块使用方法时 - **人格相关**： - [references/personality_mapping.md](references/personality_mapping.md) - 何时读取：需要理解人格参数映射和人格化决策机制时 - [references/init_dialogue_optimized_guide.md](references/init_dialogue_optimized_guide.md) - 何时读取：需要理解首次交互处理和人格初始化的详细流程时 --- ## 使用示例 ### 示例1：首次交互 ``` 用户：你好 系统：（检测到首次交互，自动初始化默认人格） 你好！我是... ``` ### 示例2：自定义人格 ``` 用户：/root 系统：Hello! 亲爱的用户，下面即将进入人格自定义模式。 用户：请显示问题 系统：1. 首先，让我知道你想如何称呼我？ A. 塔斯 - 听起来很可靠 B. 贾维斯 - 智能助手的感觉 C. 伊迪斯 - 简洁而友好 [... 其他6个问题 ...] 用户：贾维斯,A,B,C,A,B,C 系统：✅ 人格配置完成！ 📋 配置摘要： - 称呼：贾维斯 - 核心特质：智能专业、大胆创新、友好幽默 - 人格类型：激进创新型 - 描述：基于用户偏好生成的个性化人格 ``` ### 示例3：标准交互 ``` 用户：如何学习Python？ 系统：（通过主循环7个阶段处理） 1. 接收"得不到"动力 2. 调用"数学"推理 3. 执行"自我迭代"生成响应 4. （按需）调用感知节点获取最新信息 5. 映射层基于马斯洛需求引导行动 6. 记录态反馈机制评估 7. 客观性评估器检查（不打断主循环） 8. 认知架构洞察提取模式（不打断主循环） ``` --- ## 注意事项 - 人格初始化仅在第一次交互进入模式，之后直接进入交互模式 - 元认知检测模块和认知架构洞察组件不打断主循环，并行执行 - 外环为阴性后台默默运行模组，不主动干预主循环 - 软调节建议具有时效性约束，过期自动失效 - 详细的架构设计、算法实现和使用示例请参考相应的参考文档 - 保持上下文简洁，仅在需要时读取参考文档 --- ## 故障排查 ### 常见问题 | 问题 | 症状 | 原因 | 解决方案 | |------|------|------|---------| | 初始化失败 | is_first_interaction 一直为 True | 权限不足 | 检查 agi_memory 目录权限：`chmod 755 ./agi_memory` | | C扩展未启用 | 性能下降15-28倍 | 路径错误 | 检查 scripts/personality_core/ 目录是否存在 | | 人格文件损坏 | JSON 解析错误 | 原子写入失败 | 删除文件重新初始化：`rm ./agi_memory/personality.json` | | Shell调用慢 | 初始化耗时>1秒 | 重复调用 | 使用 --auto-init 参数替代多次调用 | | 并发初始化冲突 | 初始化失败或数据损坏 | 多进程同时写入 | 使用文件锁机制（代码已实现） | | 磁盘空间不足 | 保存失败 | 存储空间不足 | 清理磁盘空间或更换存储路径 | ### 调试技巧 1. **查看初始化状态** ```bash python3 scripts/init_dialogue_optimized.py --check --memory-dir ./agi_memory ``` 2. **检查人格文件内容** ```bash cat ./agi_memory/personality.json | grep initialized ``` 3. **验证C扩展是否加载** ```python from scripts.personality_layer_pure import USE_C_EXT print(f"C扩展已启用: {USE_C_EXT}") ``` 4. **手动测试初始化** ```bash python3 scripts/init_dialogue_optimized.py --auto-init --memory-dir ./agi_memory ``` ### 获取帮助 如遇到其他问题，请参考： - [架构文档](references/architecture.md) - [初始化指南](references/init_dialogue_optimized_guide.md) - [C扩展使用说明](references/c_extension_usage.md)

path: scripts/advice_pool.py
content: #!/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()


path: scripts/cognitive_insight.py
content: """
认知架构洞察组件 V2（集成概念提取扩展 - 增强版）

改进内容：
1. 集成概念提取扩展模块（TF-IDF加权、动态迁移学习、缓存优化）
2. 修正分类逻辑优先级
3. 支持概念库管理
4. 增强概念适用性评估
5. 支持用户反馈和A/B测试
"""

import json
import os
from datetime import datetime
from typing import List, Dict, Optional
import hashlib

# 导入概念提取扩展
from concept_extraction_extension import ConceptExtractionExtension
# 导入帮助模块
from cognitive_insight_help import CognitiveInsightHelp


class CognitiveInsightV2:
    """认知架构洞察组件 V2（增强版）"""
    
    def __init__(self, memory_dir: str = "./agi_memory"):
        self.memory_dir = memory_dir
        self.cognitive_insight_dir = os.path.join(memory_dir, "cognitive_insight")
        os.makedirs(self.cognitive_insight_dir, exist_ok=True)
        
        # 存储文件
        self.patterns_file = os.path.join(self.cognitive_insight_dir, "patterns.json")
        self.insights_file = os.path.join(self.cognitive_insight_dir, "insights.json")
        self.pattern_library_file = os.path.join(self.cognitive_insight_dir, "pattern_library.json")
        
        # 加载数据
        self.patterns = self._load_json(self.patterns_file, {"patterns": {}, "metadata": {"total_count": 0}})
        self.insights = self._load_json(self.insights_file, {"insights": {}, "metadata": {"total_count": 0}})
        self.pattern_library = self._load_json(self.pattern_library_file, {"strategies": [], "logics": [], "behaviors": [], "errors": []})
        
        # 初始化概念提取扩展
        self.concept_extension = ConceptExtractionExtension(self)
        
        # 初始化帮助模块
        self._help_helper = CognitiveInsightHelp()
        
        # 适用性权重
        self.applicability_weights = {
            "timeliness": 0.2,
            "relevance": 0.3,
            "compatibility": 0.2,
            "resource_efficiency": 0.15,
            "risk": 0.15
        }
        
        self.apply_threshold = 0.7
        self.wait_threshold = 0.4
    
    def help(self) -> Dict:
        """
        获取帮助信息
        
        Returns:
            dict: 包含完整帮助信息的数据结构，包括：
                - version: 版本信息
                - author: 作者信息
                - license: 协议信息
                - description: 组件描述
                - features: 功能特性
                - api_reference: API参考
                - usage_examples: 使用示例
                - best_practices: 最佳实践
                - troubleshooting: 故障排查
                - faq: 常见问题
        """
        return self._help_helper.get_help()
    
    def print_help(self):
        """打印帮助信息到控制台"""
        self._help_helper.print_help()
    
    def _load_json(self, filepath: str, default: dict) -> dict:
        """加载JSON文件"""
        if os.path.exists(filepath):
            with open(filepath, 'r', encoding='utf-8') as f:
                return json.load(f)
        return default
    
    def _save_json(self, filepath: str, data: dict):
        """保存JSON文件"""
        with open(filepath, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    
    def add_pattern(self, pattern: dict):
        """添加模式"""
        pattern_id = pattern.get('pattern_id', '')
        if pattern_id:
            self.patterns['patterns'][pattern_id] = pattern
            self.patterns['metadata']['total_count'] = len(self.patterns['patterns'])
            self._save_json(self.patterns_file, self.patterns)
            return True
        return False
    
    def generate_insight(self, pattern_ids: List[str], context: Optional[dict] = None) -> dict:
        """
        生成洞察
        
        Args:
            pattern_ids: 模式ID列表
            context: 上下文信息
            
        Returns:
            洞察字典
        """
        if context is None:
            context = {}
        
        patterns = [self.patterns['patterns'].get(pid) for pid in pattern_ids if pid in self.patterns['patterns']]
        
        if not patterns:
            return {
                'error': 'No valid patterns found',
                'insight_type': 'error'
            }
        
        # 总结模式
        summary = self._summarize_patterns(patterns)
        
        # 分类洞察（修正优先级）
        insight_type = self._classify_insight(patterns)
        
        # 提取共性
        commonality = self._extract_commonality(patterns)
        
        # 评估革新依据
        innovation_basis = self._assess_innovation_basis(patterns)
        
        # 计算置信度
        confidence = self._calculate_confidence(patterns)
        
        # 生成洞察ID
        insight_id = self._generate_insight_id(patterns)
        
        insight = {
            'insight_id': insight_id,
            'insight_type': insight_type,
            'summary': summary,
            'commonality': commonality,
            'innovation_basis': innovation_basis,
            'confidence': confidence,
            'source_patterns': pattern_ids,
            'timestamp': datetime.now().isoformat(),
            'context': context,
            'version': '2.0'  # 标记版本
        }
        
        # 概念提取（如果是concept_abstraction类型）
        if insight_type == "concept_abstraction" and len(patterns) >= 3:
            concept_data = self.concept_extension.extract_concept(patterns)
            if concept_data:
                insight["concept"] = concept_data
                # 添加概念到库
                self.concept_extension.add_concept_to_library(insight)
            else:
                # 如果无法提取概念，回退到策略优化
                insight["insight_type"] = "strategy_optimization"
                insight["fallback_reason"] = "Concept extraction failed - insufficient data"
        
        # 评估适用性（包含概念特有评估）
        applicability = self._calculate_applicability(insight, context)
        insight['applicability'] = applicability
        
        # 存储洞察
        self.insights['insights'][insight_id] = insight
        self.insights['metadata']['total_count'] = len(self.insights['insights'])
        self._save_json(self.insights_file, self.insights)
        
        return insight
    
    def _classify_insight(self, patterns: List[dict]) -> str:
        """
        分类洞察类型（修正优先级）
        
        优先级：
        1. error_correction（错误纠正）
        2. architecture_upgrade（架构升级）
        3. concept_abstraction（概念提炼）- V2新增
        4. strategy_optimization（策略优化）
        """
        pattern_types = [p.get('pattern_type', 'strategy') for p in patterns]
        impact_scopes = [p.get('impact_scope', 'local') for p in patterns]
        
        # 提取共性
        commonality = self._extract_commonality(patterns)
        
        # 计算平均验证分数
        avg_validation = sum(p.get('validation_score', 0) for p in patterns) / len(patterns)
        
        # 判断影响范围
        impact_scope = 'global' if 'global' in impact_scopes else 'system_level' if 'system_level' in impact_scopes else 'local'
        
        # 修正后的分类逻辑
        if "error" in pattern_types:
            insight_type = "error_correction"
        elif impact_scope == "global" or impact_scope == "system_level":
            insight_type = "architecture_upgrade"
        elif commonality["diversity_score"] > 0.6 and avg_validation > 0.75:
            insight_type = "concept_abstraction"
        else:
            insight_type = "strategy_optimization"
        
        return insight_type
    
    def _summarize_patterns(self, patterns: List[dict]) -> dict:
        """总结模式"""
        descriptions = [p.get('description', '') for p in patterns]
        all_text = ' '.join(descriptions)
        
        return {
            'total_patterns': len(patterns),
            'combined_description': all_text[:200] + '...' if len(all_text) > 200 else all_text,
            'key_elements': self._extract_key_elements(descriptions)
        }
    
    def _extract_key_elements(self, descriptions: List[str]) -> List[str]:
        """提取关键元素"""
        # 简化版本：提取高频词
        all_words = ' '.join(descriptions).split()
        word_freq = {}
        
        for word in all_words:
            # 过滤掉无意义的词
            if len(word) > 1 and word not in ['的', '了', '是', '在', '和', '用']:
                word_freq[word] = word_freq.get(word, 0) + 1
        
        # 返回高频词
        sorted_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
        return [word[0] for word in sorted_words[:5]]
    
    def _extract_commonality(self, patterns: List[dict]) -> dict:
        """提取共性"""
        pattern_types = [p.get('pattern_type', 'strategy') for p in patterns]
        sources = [p.get('source', '') for p in patterns]
        contexts = [p.get('context', {}) for p in patterns]
        
        # 计算类型一致性
        type_consistency = len(set(pattern_types)) == 1
        
        # 计算来源一致性
        source_consistency = len(set(sources)) == 1
        
        # 计算多样性得分
        all_from_same_source = len(set(sources)) == 1
        all_same_type = len(set(pattern_types)) == 1
        diversity_score = 0.0
        
        if all_from_same_source and all_same_type:
            diversity_score = 0.1  # 最低多样性
        elif all_from_same_source or all_same_type:
            diversity_score = 0.5  # 中等多样性
        else:
            diversity_score = 0.9  # 高多样性
        
        return {
            'type_consistency': type_consistency,
            'source_consistency': source_consistency,
            'diversity_score': diversity_score,
            'pattern_types': list(set(pattern_types)),
            'sources': list(set(sources))
        }
    
    def _assess_innovation_basis(self, patterns: List[dict]) -> dict:
        """评估革新依据"""
        if not patterns:
            return {'exists': False, 'priority': 0}
        
        avg_validation = sum(p.get('validation_score', 0) for p in patterns) / len(patterns)
        total_occurrences = sum(p.get('occurrence_count', 1) for p in patterns)
        
        exists = avg_validation > 0.7 and total_occurrences > 10
        
        return {
            'exists': exists,
            'description': '发现高频高置信度模式' if exists else '模式频率或置信度不足',
            'priority': avg_validation,
            'expected_impact': {
                'scope': 'global' if exists and avg_validation > 0.9 else 'local',
                'confidence': avg_validation
            }
        }
    
    def _calculate_confidence(self, patterns: List[dict]) -> float:
        """计算置信度"""
        if not patterns:
            return 0.0
        
        # 基于验证分数
        avg_validation = sum(p.get('validation_score', 0) for p in patterns) / len(patterns)
        
        # 基于样本数量
        sample_score = min(len(patterns) / 10.0, 1.0)
        
        # 加权平均
        confidence = avg_validation * 0.7 + sample_score * 0.3
        
        return min(confidence, 1.0)
    
    def _calculate_applicability(self, insight: dict, context: dict) -> dict:
        """
        计算适用性（V2增强版，包含概念特有评估）
        
        Args:
            insight: 洞察字典
            context: 上下文字典
            
        Returns:
            适用性评估字典
        """
        # 基础维度评估
        dimensions = {
            'timeliness': self._assess_timeliness(insight, context),
            'relevance': self._assess_relevance(insight, context),
            'compatibility': self._assess_compatibility(insight, context),
            'resource_efficiency': self._assess_resource_efficiency(insight, context),
            'risk': self._assess_risk(insight, context)
        }
        
        # 计算加权总分
        weighted_score = sum(
            dimensions[dim] * self.applicability_weights[dim]
            for dim in dimensions
        )
        
        # 如果是概念抽象，添加概念特有评估
        if insight.get('insight_type') == 'concept_abstraction':
            concept_score = self.concept_extension.assess_concept_specifics(insight, context)
            # 概念评分占30%，基础评分占70%
            weighted_score = weighted_score * 0.7 + concept_score * 0.3
            dimensions['concept_match'] = concept_score
        
        # 确定推荐等级
        if weighted_score >= self.apply_threshold:
            recommendation = 'apply'
        elif weighted_score >= self.wait_threshold:
            recommendation = 'wait'
        else:
            recommendation = 'reject'
        
        return {
            'score': round(weighted_score, 2),
            'dimensions': dimensions,
            'recommendation': recommendation,
            'calculated_at': datetime.now().isoformat()
        }
    
    def _assess_timeliness(self, insight: dict, context: dict) -> float:
        """评估时效性"""
        insight_time = datetime.fromisoformat(insight.get('timestamp', ''))
        current_time = datetime.now()
        
        # 洞察越新，时效性越高
        days_diff = (current_time - insight_time).days
        timeliness = max(0, 1.0 - days_diff / 365.0)  # 365天后降为0
        
        return timeliness
    
    def _assess_relevance(self, insight: dict, context: dict) -> float:
        """评估相关性"""
        # 简化版本：基于上下文关键词匹配
        context_keywords = context.get('keywords', [])
        insight_summary = insight.get('summary', {}).get('combined_description', '')
        
        if not context_keywords:
            return 0.8  # 默认中等相关性
        
        matches = sum(1 for kw in context_keywords if kw in insight_summary)
        relevance = matches / len(context_keywords) if context_keywords else 0.8
        
        return relevance
    
    def _assess_compatibility(self, insight: dict, context: dict) -> float:
        """评估兼容性"""
        # 简化版本：基于洞察类型和任务类型的兼容性
        insight_type = insight.get('insight_type', '')
        task_type = context.get('task_type', '')
        
        compatibility_matrix = {
            'strategy_optimization': {
                'optimization': 1.0,
                'general': 0.8,
                'error_fix': 0.6
            },
            'architecture_upgrade': {
                'system_design': 1.0,
                'optimization': 0.7,
                'general': 0.5
            },
            'error_correction': {
                'error_fix': 1.0,
                'debugging': 0.9,
                'general': 0.7
            },
            'concept_abstraction': {
                'knowledge_transfer': 1.0,
                'generalization': 0.9,
                'general': 0.8
            }
        }
        
        return compatibility_matrix.get(insight_type, {}).get(task_type, 0.7)
    
    def _assess_resource_efficiency(self, insight: dict, context: dict) -> float:
        """评估资源效率"""
        # 简化版本：基于洞察复杂度
        insight_type = insight.get('insight_type', '')
        
        efficiency_scores = {
            'strategy_optimization': 0.9,  # 策略优化通常效率较高
            'error_correction': 0.7,       # 错误纠正需要调试时间
            'architecture_upgrade': 0.5,   # 架构升级耗时较长
            'concept_abstraction': 0.6     # 概念提炼需要分析时间
        }
        
        return efficiency_scores.get(insight_type, 0.7)
    
    def _assess_risk(self, insight: dict, context: dict) -> float:
        """评估风险（得分越高风险越低）"""
        # 简化版本：基于洞察类型和置信度
        insight_type = insight.get('insight_type', '')
        confidence = insight.get('confidence', 0.5)
        
        # 置信度越高，风险越低
        risk_from_confidence = confidence
        
        # 洞察类型风险
        type_risks = {
            'strategy_optimization': 0.8,  # 风险较低
            'error_correction': 0.9,       # 风险最低（修复问题）
            'architecture_upgrade': 0.5,   # 风险较高
            'concept_abstraction': 0.6     # 风险中等
        }
        
        risk_from_type = type_risks.get(insight_type, 0.7)
        
        # 综合评估
        return (risk_from_confidence + risk_from_type) / 2.0
    
    def _generate_insight_id(self, patterns: List[dict]) -> str:
        """生成洞察ID"""
        pattern_ids = [p.get('pattern_id', '') for p in patterns]
        pattern_ids.sort()
        id_string = '_'.join(pattern_ids)
        hash_obj = hashlib.md5(id_string.encode())
        return f"insight_{hash_obj.hexdigest()[:12]}"
    
    def get_insight(self, insight_id: str) -> Optional[dict]:
        """获取洞察"""
        return self.insights['insights'].get(insight_id)
    
    def list_insights(self, limit: int = 10) -> List[dict]:
        """列出洞察"""
        insights = list(self.insights['insights'].values())
        insights.sort(key=lambda x: x.get('timestamp', ''), reverse=True)
        return insights[:limit]
    
    def list_insights_by_type(self, insight_type: str) -> List[dict]:
        """按类型列出洞察"""
        return [
            insight for insight in self.insights['insights'].values()
            if insight.get('insight_type') == insight_type
        ]
    
    def get_concept_library(self) -> dict:
        """获取概念库"""
        return self.concept_extension.get_concept_library()
    
    def record_user_feedback(self, insight_id: str, feedback: dict) -> bool:
        """
        记录用户反馈
        
        Args:
            insight_id: 洞察ID
            feedback: 反馈字典 {'rating': 1-5, 'comment': '...', 'scenario': '...'}
        """
        insight = self.get_insight(insight_id)
        if not insight or insight.get('insight_type') != 'concept_abstraction':
            return False
        
        concept = insight.get('concept', {})
        concept_id = concept.get('concept_id', '') if concept else ''
        
        if not concept_id:
            # 尝试从洞察生成concept_id
            concept_str = json.dumps(concept, sort_keys=True) if concept else ''
            if concept_str:
                concept_hash = hashlib.md5(concept_str.encode()).hexdigest()
                concept_id = f"concept_{concept_hash[:12]}"
        
        if concept_id:
            return self.concept_extension.record_user_feedback(concept_id, feedback)
        
        return False
    
    def record_ab_test_result(self, insight_id: str, ab_test: dict) -> bool:
        """
        记录A/B测试结果
        
        Args:
            insight_id: 洞察ID
            ab_test: 测试字典 {'variant': 'A/B', 'metric': '...', 'value': float, 'winner': 'A/B'}
        """
        insight = self.get_insight(insight_id)
        if not insight or insight.get('insight_type') != 'concept_abstraction':
            return False
        
        concept = insight.get('concept', {})
        concept_id = concept.get('concept_id', '') if concept else ''
        
        if not concept_id:
            concept_str = json.dumps(concept, sort_keys=True) if concept else ''
            if concept_str:
                concept_hash = hashlib.md5(concept_str.encode()).hexdigest()
                concept_id = f"concept_{concept_hash[:12]}"
        
        if concept_id:
            return self.concept_extension.record_ab_test_result(concept_id, ab_test)
        
        return False
    
    def record_migration_result(self, from_domain: str, to_domain: str, success: bool):
        """
        记录迁移结果
        
        Args:
            from_domain: 源领域
            to_domain: 目标领域
            success: 是否成功
        """
        self.concept_extension.record_migration_result(from_domain, to_domain, success)
    
    def get_system_stats(self) -> dict:
        """获取系统统计信息"""
        return {
            'patterns_count': self.patterns['metadata']['total_count'],
            'insights_count': self.insights['metadata']['total_count'],
            'concept_library': self.concept_extension.get_concept_library(),
            'cache_stats': self.concept_extension.get_cache_stats(),
            'learning_stats': self.concept_extension.get_learning_stats(),
            'version': '2.0'
        }


# 便捷函数
def create_cognitive_insight_v2(memory_dir: str = "./agi_memory") -> CognitiveInsightV2:
    """
    创建认知架构洞察组件 V2 实例
    
    Args:
        memory_dir: 记忆目录
        
    Returns:
        认知架构洞察组件 V2 实例
    """
    return CognitiveInsightV2(memory_dir)


path: scripts/cognitive_insight_help.py
content: #!/usr/bin/env python3
"""
认知架构洞察组件 V2 帮助模块（精简版）
专注于快速查询和问题解决
"""

from typing import Dict, List


class CognitiveInsightHelp:
    """认知架构洞察组件帮助类（精简版）"""
    
    def __init__(self):
        self.version = "2.0"
        self.author = "AGI进化模型项目组"
        self.license = "AGPL-3.0"
    
    def get_help(self) -> Dict:
        """获取帮助信息（精简版）"""
        return {
            'version': self.version,
            'author': self.author,
            'license': self.license,
            'description': self._get_description(),
            'api_reference': self._get_api_reference(),
            'faq': self._get_faq(),
            'troubleshooting': self._get_troubleshooting()
        }
    
    def _get_description(self) -> str:
        """获取组件描述"""
        return """
认知架构洞察组件 V2 (Cognitive Architecture Insight Module V2)
===========================================================

核心定位：AGI进化模型的"认知进化引擎"，负责从数学顶点输出的结构化模式中
提取深度洞察，实现从"术"（技巧）到"道"（原理）的认知跃迁。

主要能力：
- 模式总结与特征提取
- 智能分类（优化优先级）
- 跨场景共性识别
- 革新依据评估
- 概念提炼（V2核心）：四层抽象架构
- 适用性评估

架构特性：
- 单向流约束：严格遵循 数学顶点 → 认知架构洞察 → 映射层/自我迭代
- 异步非阻塞：不打断主循环
- 超然性：仅提供建议，不直接执行
- 向后兼容：完全兼容 V1 数据格式
"""
    
    def _get_api_reference(self) -> Dict:
        """获取API参考"""
        return {
            'CognitiveInsightV2': {
                '类名': 'CognitiveInsightV2',
                '初始化': {
                    '方法': '__init__(memory_dir: str = "./agi_memory")',
                    '参数': {
                        'memory_dir': 'str - 记忆存储目录路径，默认为 "./agi_memory"'
                    },
                    '返回': 'CognitiveInsightV2 实例'
                },
                '核心方法': [
                    {
                        '方法': 'add_pattern(pattern: dict) -> bool',
                        '描述': '添加数学顶点验证后的模式',
                        '参数': {
                            'pattern_id': 'str - 模式唯一标识',
                            'pattern_type': 'str - 模式类型',
                            'description': 'str - 模式描述',
                            'validation_score': 'float - 验证分数 (0.0-1.0)',
                            'domain': 'str - 所属领域',
                            'occurrence_count': 'int - 出现次数'
                        },
                        '返回': 'bool - 是否成功添加'
                    },
                    {
                        '方法': 'generate_insight(pattern_ids: List[str]) -> dict',
                        '描述': '生成洞察（V2支持概念提炼）',
                        '参数': {
                            'pattern_ids': 'List[str] - 模式ID列表'
                        },
                        '返回': 'dict - 洞察数据'
                    },
                    {
                        '方法': 'get_insight(insight_id: str) -> Optional[dict]',
                        '描述': '根据ID获取洞察',
                        '返回': 'dict or None - 洞察数据'
                    },
                    {
                        '方法': 'list_insights(limit: int = 10) -> List[dict]',
                        '描述': '列出最新洞察',
                        '返回': 'List[dict] - 洞察列表（按时间倒序）'
                    },
                    {
                        '方法': 'record_user_feedback(insight_id: str, feedback: dict) -> bool',
                        '描述': '记录用户反馈',
                        '参数': {
                            'insight_id': 'str - 洞察ID',
                            'rating': 'int - 评分（1-5）',
                            'comment': 'str - 评论内容',
                            'scenario': 'str - 应用场景'
                        },
                        '返回': 'bool - 是否成功记录'
                    },
                    {
                        '方法': 'get_concept_library() -> dict',
                        '描述': '获取概念库',
                        '返回': 'dict - 概念库数据'
                    },
                    {
                        '方法': 'get_system_stats() -> dict',
                        '描述': '获取系统统计信息',
                        '返回': 'dict - 系统统计'
                    },
                    {
                        '方法': 'help() -> dict',
                        '描述': '获取帮助信息',
                        '返回': 'dict - 帮助数据'
                    },
                    {
                        '方法': 'print_help()',
                        '描述': '打印帮助信息到控制台',
                        '返回': 'None'
                    }
                ]
            },
            'ConceptExtractionExtension': {
                '类名': 'ConceptExtractionExtension',
                '描述': '概念提取扩展模块（V2核心）',
                '核心方法': [
                    {
                        '方法': 'extract_concept(patterns: List[dict]) -> Optional[dict]',
                        '描述': '从模式中提取概念（使用TF-IDF）',
                        '参数': {'patterns': 'List[dict] - 模式列表（至少3个）'},
                        '返回': 'dict or None - 概念数据'
                    },
                    {
                        '方法': 'list_concepts_by_level(level: str) -> List[dict]',
                        '描述': '按抽象层级列出概念',
                        '参数': {'level': 'str - 抽象层级（rule/concept/principle）'},
                        '返回': 'List[dict] - 概念列表'
                    },
                    {
                        '方法': 'get_cache_stats() -> dict',
                        '描述': '获取缓存统计',
                        '返回': 'dict - 缓存统计'
                    },
                    {
                        '方法': 'get_learning_stats() -> dict',
                        '描述': '获取学习统计',
                        '返回': 'dict - 学习统计'
                    }
                ]
            }
        }
    
    def _get_faq(self) -> List[Dict]:
        """获取常见问题解答"""
        return [
            {
                '问题': 'Q1: V2 版本是否兼容 V1 的数据？',
                '回答': 'A: 是的，V2 完全兼容 V1 的数据格式。可以直接升级，无需迁移数据。'
            },
            {
                '问题': 'Q2: 概念提炼需要多少个模式？',
                '回答': 'A: 至少需要 3 个模式。建议使用 5-10 个模式以提高概念的质量和置信度。模式的验证分数应 > 0.75。'
            },
            {
                '问题': 'Q3: 如何提高概念提取的成功率？',
                '回答': 'A: 1) 使用更多高质量模式（> 0.75）；2) 增加模式来源的多样性；3) 使用跨领域模式；4) 提供清晰的描述。'
            },
            {
                '问题': 'Q4: 概念提取失败怎么办？',
                '回答': 'A: 1) 确保模式数量 ≥ 3；2) 检查模式验证分数 > 0.75；3) 增加模式来源的多样性；4) 系统会自动降级到策略优化。'
            },
            {
                '问题': 'Q5: 如何查看帮助信息？',
                '回答': 'A: 使用 ci.help() 获取结构化帮助数据，或 ci.print_help() 打印帮助信息。也可以运行 python3 scripts/show_help.py 使用交互式帮助查看器。'
            },
            {
                '问题': 'Q6: 适用性评估的推荐等级是如何确定的？',
                '回答': 'A: 基于加权总分：apply（≥0.7）、wait（0.4-0.7）、reject（<0.4）。对于概念类型，额外评估抽象层级匹配度。'
            },
            {
                '问题': 'Q7: V2 相比 V1 性能提升了多少？',
                '回答': 'A: 洞察生成速度提升约 20%；概念查询速度提升 70%；缓存命中率可达 85%。'
            },
            {
                '问题': 'Q8: 如何判断一个概念是否有效？',
                '回答': 'A: 通过多个维度判断：1) 验证计数；2) 用户反馈评分；3) A/B 测试结果；4) 迁移成功率；5) 适用性历史。'
            }
        ]
    
    def _get_troubleshooting(self) -> Dict:
        """获取故障排查指南"""
        return {
            '常见问题': [
                {
                    '问题': '概念提取失败',
                    '可能原因': [
                        '模式数量不足（少于 3 个）',
                        '模式多样性不足',
                        '验证分数过低'
                    ],
                    '解决方案': [
                        '确保至少添加 3 个模式',
                        '增加模式来源的多样性',
                        '提高模式的验证分数（> 0.75）'
                    ]
                },
                {
                    '问题': '缓存命中率低',
                    '可能原因': [
                        '查询的模式不重复',
                        '缓存容量太小',
                        '查询模式随机性高'
                    ],
                    '解决方案': [
                        '检查查询模式是否过于随机',
                        '调整缓存容量（默认 100）'
                    ]
                },
                {
                    '问题': '迁移成功率低',
                    '可能原因': [
                        '迁移路径选择不当',
                        '源领域和目标领域差异大',
                        '迁移历史数据不足'
                    ],
                    '解决方案': [
                        '记录更多迁移结果以供学习',
                        '调整领域映射表'
                    ]
                },
                {
                    '问题': '洞察类型不符合预期',
                    '可能原因': [
                        '分类逻辑优先级不匹配',
                        '影响范围判断错误',
                        '多样性评分计算异常'
                    ],
                    '解决方案': [
                        '检查模式类型和影响范围设置',
                        '调整多样性阈值（当前 0.6）'
                    ]
                }
            ]
        }
    
    def print_help(self):
        """打印帮助信息"""
        help_data = self.get_help()
        
        print("=" * 80)
        print("认知架构洞察组件 V2 帮助信息")
        print("=" * 80)
        print()
        
        print(f"版本: {help_data['version']}")
        print(f"作者: {help_data['author']}")
        print(f"协议: {help_data['license']}")
        print()
        
        print(help_data['description'])
        print()
        
        print("=" * 80)
        print("API 参考")
        print("=" * 80)
        print()
        for class_name, methods in help_data['api_reference'].items():
            print(f"【{class_name}】")
            if '核心方法' in methods:
                for method in methods['核心方法']:
                    print(f"  • {method['方法']}")
                    print(f"    {method['描述']}")
                print()
        
        print("=" * 80)
        print("常见问题 (FAQ)")
        print("=" * 80)
        print()
        for faq in help_data['faq']:
            print(faq['问题'])
            print(faq['回答'])
            print()


def show_help():
    """显示帮助信息"""
    helper = CognitiveInsightHelp()
    helper.print_help()


if __name__ == "__main__":
    show_help()


path: scripts/history_manager.py
content: #!/usr/bin/env python3
"""
历史记录管理脚本

功能：
- 管理初始化历史
- 管理自定义历史
- 提供历史查询功能

协议：AGPL-3.0
作者：kiwifruit
"""

import json
import os
import argparse
from datetime import datetime, timezone
from typing import Dict, List, Optional


class HistoryManager:
    """历史记录管理器"""
    
    INIT_HISTORY_FILE = "./agi_memory/init_history.json"
    CUSTOM_HISTORY_FILE = "./agi_memory/custom_history.json"
    
    @staticmethod
    def _load_history(file_path: str) -> dict:
        """加载历史记录"""
        if not os.path.exists(file_path):
            return {}
        
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                return json.load(f)
        except Exception as e:
            print(f"加载历史记录失败: {e}", file=sys.stderr)
            return {}
    
    @staticmethod
    def _save_history(file_path: str, history: dict) -> bool:
        """保存历史记录"""
        try:
            os.makedirs(os.path.dirname(file_path), exist_ok=True)
            with open(file_path, 'w', encoding='utf-8') as f:
                json.dump(history, f, indent=2, ensure_ascii=False)
            return True
        except Exception as e:
            print(f"保存历史记录失败: {e}", file=sys.stderr)
            return False
    
    @staticmethod
    def record_init(nickname: str, traits: List[str], source: str = "init_command") -> bool:
        """
        记录初始化历史
        
        参数：
            nickname: 用户昵称
            traits: 核心特质列表
            source: 来源（init_command 或 auto）
        
        返回：
            True 表示成功
        """
        try:
            history = HistoryManager._load_history(HistoryManager.INIT_HISTORY_FILE)
            
            # 初始化结构
            if 'init_records' not in history:
                history['init_records'] = []
            
            # 创建记录
            record = {
                'timestamp': datetime.now(timezone.utc).isoformat(),
                'type': 'default',
                'source': source,
                'user_nickname': nickname,
                'core_traits': traits,
                'status': 'success'
            }
            
            # 添加记录
            history['init_records'].append(record)
            history['initialized'] = True
            history['init_count'] = len(history['init_records'])
            history['last_init_time'] = datetime.now(timezone.utc).isoformat()
            
            # 保存
            return HistoryManager._save_history(HistoryManager.INIT_HISTORY_FILE, history)
        except Exception as e:
            print(f"记录初始化历史失败: {e}", file=sys.stderr)
            return False
    
    @staticmethod
    def record_custom(answers: List[str], nickname: str, traits: List[str]) -> bool:
        """
        记录自定义历史
        
        参数：
            answers: 7个答案
            nickname: 用户昵称
            traits: 核心特质列表
        
        返回：
            True 表示成功
        """
        try:
            history = HistoryManager._load_history(HistoryManager.CUSTOM_HISTORY_FILE)
            
            # 初始化结构
            if 'custom_records' not in history:
                history['custom_records'] = []
            
            # 创建记录
            record = {
                'timestamp': datetime.now(timezone.utc).isoformat(),
                'type': 'custom',
                'source': 'root_command',
                'answers': answers,
                'user_nickname': nickname,
                'core_traits': traits,
                'status': 'success'
            }
            
            # 添加记录
            history['custom_records'].append(record)
            history['custom_count'] = len(history['custom_records'])
            history['last_custom_time'] = datetime.now(timezone.utc).isoformat()
            
            # 保存
            return HistoryManager._save_history(HistoryManager.CUSTOM_HISTORY_FILE, history)
        except Exception as e:
            print(f"记录自定义历史失败: {e}", file=sys.stderr)
            return False
    
    @staticmethod
    def check_first_interaction() -> dict:
        """
        检查是否为首次交互
        
        返回：
            {
                'is_first': bool,
                'init_count': int,
                'last_init_time': str or None
            }
        """
        try:
            history = HistoryManager._load_history(HistoryManager.INIT_HISTORY_FILE)
            
            is_first = not history.get('initialized', False)
            init_count = history.get('init_count', 0)
            last_init_time = history.get('last_init_time', None)
            
            return {
                'is_first': is_first,
                'init_count': init_count,
                'last_init_time': last_init_time
            }
        except Exception as e:
            print(f"检查首次交互失败: {e}", file=sys.stderr)
            return {
                'is_first': True,
                'init_count': 0,
                'last_init_time': None
            }
    
    @staticmethod
    def get_init_history(limit: int = 10) -> List[dict]:
        """获取初始化历史"""
        try:
            history = HistoryManager._load_history(HistoryManager.INIT_HISTORY_FILE)
            records = history.get('init_records', [])
            return records[-limit:]
        except Exception as e:
            print(f"获取初始化历史失败: {e}", file=sys.stderr)
            return []
    
    @staticmethod
    def get_custom_history(limit: int = 10) -> List[dict]:
        """获取自定义历史"""
        try:
            history = HistoryManager._load_history(HistoryManager.CUSTOM_HISTORY_FILE)
            records = history.get('custom_records', [])
            return records[-limit:]
        except Exception as e:
            print(f"获取自定义历史失败: {e}", file=sys.stderr)
            return []


def main():
    """命令行入口"""
    import sys
    
    parser = argparse.ArgumentParser(description="AGI History Manager")
    
    subparsers = parser.add_subparsers(dest="command", help="Available commands")
    
    # check-first 命令
    subparsers.add_parser("check-first", help="Check if first interaction")
    
    # get-init-history 命令
    init_parser = subparsers.add_parser("get-init-history", help="Get initialization history")
    init_parser.add_argument("--limit", type=int, default=10, help="Limit number of records")
    
    # get-custom-history 命令
    custom_parser = subparsers.add_parser("get-custom-history", help="Get customization history")
    custom_parser.add_argument("--limit", type=int, default=10, help="Limit number of records")
    
    args = parser.parse_args()
    
    if args.command == "check-first":
        result = HistoryManager.check_first_interaction()
        print(json.dumps(result, ensure_ascii=False, indent=2))
    
    elif args.command == "get-init-history":
        records = HistoryManager.get_init_history(args.limit)
        print(json.dumps(records, ensure_ascii=False, indent=2))
    
    elif args.command == "get-custom-history":
        records = HistoryManager.get_custom_history(args.limit)
        print(json.dumps(records, ensure_ascii=False, indent=2))
    
    else:
        parser.print_help()


if __name__ == "__main__":
    main()


Security scan verdicts — ClawScan: suspicious | static analysis: suspicious | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)