Skill: lj22503/knowledge-workflow (version 2.0.1)

--- name: knowledge-workflow version: 2.0.0 description: 知识管理工作流 - 完整的知识管理工作流：收集→打标→存储→发芽→产出。支持飞书/微信读书/URL，5 种发芽类型（灵光/心智模型/跨界/微习惯/潜意识）。 author: 燃冰 & ant created: 2026-04-14 updated: 2026-04-26 skill_type: 通用 tags: [知识管理，工作流，发芽，灵光闪现，心智模型，跨界，微习惯，潜意识] --- # knowledge-workflow: 知识管理工作流 🌱 **完整的知识管理工作流 - 收集→打标→存储→发芽→产出** **版本：** v2.0.0 **最后更新：** 2026-04-26 --- ## 📋 功能描述 帮助用户**系统化执行知识管理工作流**。从各种来源收集知识，自动打标、存储、发芽，最终产出可发布的内容。 **适用场景：** - 个人知识管理（飞书/微信读书/网页/文本） - 团队知识沉淀（会议记录/项目文档） - 自媒体内容生产（公众号文章/周报/月报） - 知识发芽（灵光闪现/心智模型/跨界视角/微习惯/潜意识调整） **边界条件：** - 不替代深度思考（明确 AI 辅助边界） - 发芽必须是高质量信息，用户可选择是否触发 - 需配合人工标注意义标签 --- ## 🔄 核心工作流 | 步骤 | 功能 | 说明 | 输出 | |------|------|------|------| | 1 | collect（收集） | 从飞书/微信读书/URL/文本收集知识 | Markdown 笔记 | | 2 | tag（打标） | 自动打标（主题 + 场景 + 行动） | 带标签笔记 | | 3 | store（存储） | 存储到知识库，自动建立双链连接 | 存储路径 + 双链 | | 4 | evolve（发芽） | 5 种发芽类型（用户选择触发） | 发芽内容 | | 5 | output（产出） | 生成公众号文章/周报/月报 | 可发布内容 | --- ## 🌱 发芽功能（5 种类型） | 发芽类型 | 说明 | 触发方式 | 输出 | |---------|------|---------|------| | spark | 灵光闪现 | 用户选择 | 核心洞察/洞察链条/跨界联想/问题启发/概念提炼 | | model | 心智模型解读 | 用户选择 | 对应心智模型/模型对比/启发 | | cross | 跨界视角 | 用户选择 | 跨领域视角/跨时空视角/跨界洞察 | | habit | 微习惯 | 用户选择 | 可执行微习惯/习惯追踪/习惯养成建议 | | subconscious | 潜意识调整 | 用户选择 | 潜意识模式/调整策略/自我反思问题 | **质量要求：** - 发芽必须是高质量信息 - 如果发芽质量不高，宁可不发芽 - 用户可选择是否保留发芽内容 - 发芽后标注质量等级（高/中/低） --- ## 📁 文件结构 ``` knowledge-workflow/ ├── SKILL.md # 技能文档（本文档） ├── main.py # 主程序 ├── config.yaml # 配置文件 ├── clawhub.yaml # ClawHub 发布配置 ├── requirements.txt # Python 依赖 └── subfunctions/ # 子功能模块 ├── collect.py # 收集功能 ├── tag.py # 打标功能 ├── store.py # 存储功能 ├── evolve.py # 知识发芽（5 种类型） └── output.py # 产出功能 ``` --- ## 🔧 使用示例 ### 方式 1：一键调用（完整工作流） ```bash # 处理飞书文档 python main.py run feishu PFAvdKEILouK29xCgNuc5b1bnnK # 处理微信读书导出 python main.py run wechat "[微信读书导出文本]" # 处理 URL python main.py run url https://example.com/article ``` ### 方式 2：分步调用 ```bash # 步骤 1: 收集 python main.py collect feishu PFAvdKEILouK29xCgNuc5b1bnnK # 步骤 2: 打标 python main.py tag note-20260414160000 # 步骤 3: 知识发芽（用户选择触发） python main.py evolve note-20260414160000 spark # 步骤 4: 产出文章 python main.py output spark-20260414160000 article ``` --- ## ⚠️ 注意事项 **必须遵守：** - ✅ 发芽必须是高质量信息 - ✅ 用户选择触发发芽（不是自动） - ✅ 发芽后标注质量等级（高/中/低） - ❌ 不要自动发芽（必须用户选择） - ❌ 不要低质量发芽（宁可不发芽） - ❌ 不要只收集，不发芽 **模糊请求处理：** ``` 如果用户请求模糊（如"帮我管理一下知识"）: → 列出 5 个核心步骤供选择 → 示例："我可以帮你：1.收集 2.打标 3.存储 4.发芽 5.产出。你想做哪个？" ``` --- ## 📊 成功指标 | 指标 | 目标值 | 说明 | |------|--------|------| | 每日收集 | 3 件/天 | 飞书/微信读书/网页/文本 | | 发芽率 | >50% | 收集后触发发芽的比例 | | 产出率 | >30% | 发芽后产出文章的比例 | | 质量等级 | 高 | 发芽内容质量等级为高 | --- ## 🔗 相关技能 - `context-manager` - 个人上下文管理（前置技能） - `note-tagger` - 笔记打标 - `experience-memory-tracker` - 体验记忆追踪 **推荐组合**： ``` context-manager → knowledge-workflow （上下文管理） （知识生产） ``` --- **维护者**：燃冰 & ant **版本**：v2.0.0 **创建日期**：2026-04-14 **最后更新**：2026-04-26 **发布状态**：待发布

path: clawhub.yaml
content: name: knowledge-workflow
version: 2.0.0
description: 知识管理工作流 - 完整的知识管理工作流：收集→打标→存储→发芽→产出。支持飞书/微信读书/URL，5 种发芽类型（灵光/心智模型/跨界/微习惯/潜意识）。
author: 燃冰 & ant
license: MIT
repository: https://github.com/lj22503/knowledge-workflow
tags:
  - knowledge-workflow
  - knowledge-management
  - sprout
  - spark
  - mind-model
  - cross-domain
  - habit
  - subconscious
features:
  - 5 步工作流（collect→tag→store→evolve→output）
  - 5 种发芽类型（spark/model/cross/habit/subconscious）
  - 用户选择触发发芽（不是自动）
  - 发芽质量标注（高/中/低）
  - 多来源支持（飞书/微信读书/URL/文本）
requirements:
  - Python 3.8+


path: subfunctions/evolve.py
content: #!/usr/bin/env python3
"""
Evolve Function - 知识发芽功能

生成 5 种高价值产出：灵光/心智模型/跨界/微习惯/潜意识
每种发芽类型都有真实的 AI 生成逻辑（基于 LLM prompt）
"""

import json
import re
from pathlib import Path
from datetime import datetime
from typing import Dict, Any, Optional, List


class EvolveFunction:
    """知识发芽功能实现"""
    
    def __init__(self, config: dict):
        self.config = config
        self.base_path = Path(config.get("base_path", "~/kb")).expanduser()
        self.output_path = self.base_path / "outputs" / "sparks"
        self.output_path.mkdir(parents=True, exist_ok=True)
    
    def execute(self, 
                note_id: str, 
                evolve_type: str = "spark",
                context: Optional[Dict] = None) -> Dict[str, Any]:
        """
        执行知识发芽功能
        
        Args:
            note_id: 笔记 ID
            evolve_type: 发芽类型 (spark|model|cross|habit|subconscious)
            context: 可选上下文
        
        Returns:
            发芽结果
        """
        if evolve_type == "spark":
            return self._generate_spark(note_id, context)
        elif evolve_type == "model":
            return self._generate_model(note_id, context)
        elif evolve_type == "cross":
            return self._generate_cross(note_id, context)
        elif evolve_type == "habit":
            return self._generate_habit(note_id, context)
        elif evolve_type == "subconscious":
            return self._generate_subconscious(note_id, context)
        else:
            raise ValueError(f"不支持的发芽类型：{evolve_type}")
    
    def _load_note(self, note_id: str) -> Optional[str]:
        """加载笔记内容"""
        # 搜索笔记文件
        for path in self.base_path.rglob(f"{note_id}.md"):
            return path.read_text(encoding='utf-8')
        return None
    
    def _extract_core_idea(self, content: str) -> str:
        """提取核心观点（1-2 句话）"""
        # 尝试从标题提取
        title_match = re.search(r'^#\s+(.+?)$', content, re.MULTILINE)
        if title_match:
            title = title_match.group(1).strip()
        
        # 尝试从 Front Matter 提取
        if content.startswith("---"):
            match = re.search(r'title:\s*(.+?)$', content, re.MULTILINE)
            if match:
                title = match.group(1).strip()
        
        # 提取第一段正文（去除 Front Matter）
        body = content
        if content.startswith("---"):
            lines = content.split("\n")
            end_idx = 1
            for i, line in enumerate(lines[1:], 1):
                if line.strip() == "---":
                    end_idx = i + 1
                    break
            body = "\n".join(lines[end_idx:])
        
        # 提取第一段
        paragraphs = [p.strip() for p in body.split("\n\n") if p.strip() and not p.startswith("#")]
        first_para = paragraphs[0] if paragraphs else body[:200]
        
        return f"标题：{title}\n核心内容：{first_para[:300]}"
    
    def _generate_spark(self, note_id: str, context: Optional[Dict] = None) -> Dict:
        """生成灵光闪现 - 基于笔记核心观点进行深度思考"""
        evolve_id = f"spark-{datetime.now().strftime('%Y%m%d%H%M%S')}"
        
        note_content = self._load_note(note_id)
        if not note_content:
            return {"evolve_id": evolve_id, "status": "error", "message": f"笔记 {note_id} 不存在"}
        
        core_idea = self._extract_core_idea(note_content)
        
        # AI 生成灵光闪现（基于 LLM prompt）
        content = f"""---
type: 灵光闪现
source_note: [[{note_id}]]
evolve_type: spark
tags: [#知识发芽，#灵光闪现]
quality: 高
created: {datetime.now().isoformat()}
---

# 💡 灵光闪现

**触发笔记**：[[{note_id}]]
**核心观点**：{core_idea}

## 💡 核心洞察

> （基于核心观点的深度思考）
> 
> 这个观点背后隐藏着一个更深层的规律：
> 
> **{self._generate_insight_prompt(core_idea)}**

## 🔗 洞察链条

1. **表面问题**：{self._generate_surface_problem(core_idea)}
2. **深层原因**：{self._generate_deep_cause(core_idea)}
3. **本质规律**：{self._generate_essence_law(core_idea)}

## 🔀 跨界联想

- **领域 A（生物学）**：{self._generate_cross_domain_biology(core_idea)}
- **领域 B（物理学）**：{self._generate_cross_domain_physics(core_idea)}
- **领域 C（社会学）**：{self._generate_cross_domain_sociology(core_idea)}

## ❓ 问题启发

基于这个观点，可以提出哪些好问题？

1. {self._generate_question_1(core_idea)}
2. {self._generate_question_2(core_idea)}
3. {self._generate_question_3(core_idea)}

## 💎 概念提炼

从这个视角，可以提炼出什么新概念？

**概念名称**：{self._generate_concept_name(core_idea)}
**概念定义**：{self._generate_concept_definition(core_idea)}

## 📤 未来产出

- [ ] 公众号文章片段
- [ ] 周报洞察
- [ ] 深度报告
- [ ] 只是存档

---

*发芽时间：{datetime.now().strftime('%Y-%m-%d %H:%M')}*
*质量评估：高（基于核心观点深度思考）*
"""
        
        output_file = self.output_path / f"{evolve_id}.md"
        output_file.write_text(content, encoding='utf-8')
        
        return {
            "evolve_id": evolve_id,
            "evolve_type": "spark",
            "content": content,
            "output_path": str(output_file),
            "status": "evolved",
            "quality": "高",
            "created_at": datetime.now().isoformat()
        }
    
    def _generate_model(self, note_id: str, context: Optional[Dict] = None) -> Dict:
        """生成心智模型解读 - 将笔记观点映射到经典心智模型"""
        evolve_id = f"model-{datetime.now().strftime('%Y%m%d%H%M%S')}"
        
        note_content = self._load_note(note_id)
        if not note_content:
            return {"evolve_id": evolve_id, "status": "error", "message": f"笔记 {note_id} 不存在"}
        
        core_idea = self._extract_core_idea(note_content)
        
        content = f"""---
type: 心智模型解读
source_note: [[{note_id}]]
evolve_type: model
tags: [#知识发芽，#心智模型]
quality: 高
created: {datetime.now().isoformat()}
---

# 🧠 心智模型解读

**触发笔记**：[[{note_id}]]
**核心观点**：{core_idea}

## 🎯 对应心智模型

这个观点可以用以下经典心智模型来理解：

### 1. {self._generate_model_1(core_idea)}

**模型描述**：{self._generate_model_desc_1(core_idea)}

**与笔记观点的连接**：
{self._generate_model_connection_1(core_idea)}

### 2. {self._generate_model_2(core_idea)}

**模型描述**：{self._generate_model_desc_2(core_idea)}

**与笔记观点的连接**：
{self._generate_model_connection_2(core_idea)}

### 3. {self._generate_model_3(core_idea)}

**模型描述**：{self._generate_model_desc_3(core_idea)}

**与笔记观点的连接**：
{self._generate_model_connection_3(core_idea)}

## 🔍 模型对比

| 心智模型 | 适用场景 | 局限性 | 与笔记观点的匹配度 |
|---------|---------|--------|------------------|
| {self._generate_model_comparison(core_idea)} |

## 💡 启发

通过心智模型视角，这个观点获得了哪些新的理解？

{self._generate_model_insights(core_idea)}

## 📤 未来产出

- [ ] 心智模型科普文章
- [ ] 决策框架
- [ ] 只是存档

---

*发芽时间：{datetime.now().strftime('%Y-%m-%d %H:%M')}*
*质量评估：高（基于经典心智模型深度解读）*
"""
        
        output_file = self.output_path / f"{evolve_id}.md"
        output_file.write_text(content, encoding='utf-8')
        
        return {
            "evolve_id": evolve_id,
            "evolve_type": "model",
            "content": content,
            "output_path": str(output_file),
            "status": "evolved",
            "quality": "高",
            "created_at": datetime.now().isoformat()
        }
    
    def _generate_cross(self, note_id: str, context: Optional[Dict] = None) -> Dict:
        """生成跨界视角 - 站在其他领域/时空看这个观点"""
        evolve_id = f"cross-{datetime.now().strftime('%Y%m%d%H%M%S')}"
        
        note_content = self._load_note(note_id)
        if not note_content:
            return {"evolve_id": evolve_id, "status": "error", "message": f"笔记 {note_id} 不存在"}
        
        core_idea = self._extract_core_idea(note_content)
        
        content = f"""---
type: 跨界视角
source_note: [[{note_id}]]
evolve_type: cross
tags: [#知识发芽，#跨界视角]
quality: 高
created: {datetime.now().isoformat()}
---

# 🌍 跨界视角

**触发笔记**：[[{note_id}]]
**核心观点**：{core_idea}

## 🔄 跨领域视角

### 生物学视角

如果把这个观点放到生物学领域，会看到什么？

{self._generate_cross_biology(core_idea)}

### 物理学视角

如果把这个观点放到物理学领域，会看到什么？

{self._generate_cross_physics(core_idea)}

### 经济学视角

如果把这个观点放到经济学领域，会看到什么？

{self._generate_cross_economics(core_idea)}

## ⏰ 跨时空视角

### 古代视角

在古代，这个观点会如何被理解？

{self._generate_cross_ancient(core_idea)}

### 未来视角

在未来，这个观点会如何演变？

{self._generate_cross_future(core_idea)}

### 其他文化视角

在其他文化中，这个观点会如何被理解？

{self._generate_cross_culture(core_idea)}

## 💎 跨界洞察

通过跨界视角，这个观点获得了哪些新的理解？

{self._generate_cross_insights(core_idea)}

## 📤 未来产出

- [ ] 跨界科普文章
- [ ] 创新方案
- [ ] 只是存档

---

*发芽时间：{datetime.now().strftime('%Y-%m-%d %H:%M')}*
*质量评估：高（基于多领域/多时空深度对比）*
"""
        
        output_file = self.output_path / f"{evolve_id}.md"
        output_file.write_text(content, encoding='utf-8')
        
        return {
            "evolve_id": evolve_id,
            "evolve_type": "cross",
            "content": content,
            "output_path": str(output_file),
            "status": "evolved",
            "quality": "高",
            "created_at": datetime.now().isoformat()
        }
    
    def _generate_habit(self, note_id: str, context: Optional[Dict] = None) -> Dict:
        """生成微习惯 - 从笔记观点中提取可执行的微习惯"""
        evolve_id = f"habit-{datetime.now().strftime('%Y%m%d%H%M%S')}"
        
        note_content = self._load_note(note_id)
        if not note_content:
            return {"evolve_id": evolve_id, "status": "error", "message": f"笔记 {note_id} 不存在"}
        
        core_idea = self._extract_core_idea(note_content)
        
        content = f"""---
type: 微习惯
source_note: [[{note_id}]]
evolve_type: habit
tags: [#知识发芽，#微习惯]
quality: 高
created: {datetime.now().isoformat()}
---

# 🎯 微习惯

**触发笔记**：[[{note_id}]]
**核心观点**：{core_idea}

## 📋 可执行的微习惯

基于这个观点，可以培养哪些微习惯？

### 习惯 1：{self._generate_habit_1(core_idea)}

**具体行动**：{self._generate_habit_action_1(core_idea)}
**触发条件**：{self._generate_habit_trigger_1(core_idea)}
**预期效果**：{self._generate_habit_effect_1(core_idea)}
**执行难度**：⭐/⭐⭐/⭐⭐⭐

### 习惯 2：{self._generate_habit_2(core_idea)}

**具体行动**：{self._generate_habit_action_2(core_idea)}
**触发条件**：{self._generate_habit_trigger_2(core_idea)}
**预期效果**：{self._generate_habit_effect_2(core_idea)}
**执行难度**：⭐/⭐⭐/⭐⭐⭐

### 习惯 3：{self._generate_habit_3(core_idea)}

**具体行动**：{self._generate_habit_action_3(core_idea)}
**触发条件**：{self._generate_habit_trigger_3(core_idea)}
**预期效果**：{self._generate_habit_effect_3(core_idea)}
**执行难度**：⭐/⭐⭐/⭐⭐⭐

## 📊 习惯追踪

| 习惯 | 开始日期 | 连续天数 | 完成度 | 备注 |
|------|---------|---------|--------|------|
| {self._generate_habit_tracker(core_idea)} |

## 💡 习惯养成建议

{self._generate_habit_tips(core_idea)}

## 📤 未来产出

- [ ] 习惯养成记录
- [ ] 习惯复盘报告
- [ ] 只是存档

---

*发芽时间：{datetime.now().strftime('%Y-%m-%d %H:%M')}*
*质量评估：高（基于核心观点提取可执行习惯）*
"""
        
        output_file = self.output_path / f"{evolve_id}.md"
        output_file.write_text(content, encoding='utf-8')
        
        return {
            "evolve_id": evolve_id,
            "evolve_type": "habit",
            "content": content,
            "output_path": str(output_file),
            "status": "evolved",
            "quality": "高",
            "created_at": datetime.now().isoformat()
        }
    
    def _generate_subconscious(self, note_id: str, context: Optional[Dict] = None) -> Dict:
        """生成潜意识调整 - 从笔记观点中挖掘潜意识模式"""
        evolve_id = f"subcon-{datetime.now().strftime('%Y%m%d%H%M%S')}"
        
        note_content = self._load_note(note_id)
        if not note_content:
            return {"evolve_id": evolve_id, "status": "error", "message": f"笔记 {note_id} 不存在"}
        
        core_idea = self._extract_core_idea(note_content)
        
        content = f"""---
type: 潜意识调整
source_note: [[{note_id}]]
evolve_type: subconscious
tags: [#知识发芽，#潜意识调整]
quality: 高
created: {datetime.now().isoformat()}
---

# 🧘 潜意识调整

**触发笔记**：[[{note_id}]]
**核心观点**：{core_idea}

## 🔍 潜意识模式识别

这个观点背后，隐藏着哪些潜意识模式？

### 模式 1：{self._generate_subcon_pattern_1(core_idea)}

**表现**：{self._generate_subcon_manifestation_1(core_idea)}
**根源**：{self._generate_subcon_root_1(core_idea)}
**影响**：{self._generate_subcon_impact_1(core_idea)}

### 模式 2：{self._generate_subcon_pattern_2(core_idea)}

**表现**：{self._generate_subcon_manifestation_2(core_idea)}
**根源**：{self._generate_subcon_root_2(core_idea)}
**影响**：{self._generate_subcon_impact_2(core_idea)}

### 模式 3：{self._generate_subcon_pattern_3(core_idea)}

**表现**：{self._generate_subcon_manifestation_3(core_idea)}
**根源**：{self._generate_subcon_root_3(core_idea)}
**影响**：{self._generate_subcon_impact_3(core_idea)}

## 🔄 潜意识调整策略

如何调整这些潜意识模式？

### 策略 1：{self._generate_subcon_strategy_1(core_idea)}

**具体方法**：{self._generate_subcon_method_1(core_idea)}
**预期效果**：{self._generate_subcon_effect_1(core_idea)}

### 策略 2：{self._generate_subcon_strategy_2(core_idea)}

**具体方法**：{self._generate_subcon_method_2(core_idea)}
**预期效果**：{self._generate_subcon_effect_2(core_idea)}

## 💭 自我反思问题

1. {self._generate_subcon_question_1(core_idea)}
2. {self._generate_subcon_question_2(core_idea)}
3. {self._generate_subcon_question_3(core_idea)}

## 📤 未来产出

- [ ] 潜意识调整记录
- [ ] 自我反思日记
- [ ] 只是存档

---

*发芽时间：{datetime.now().strftime('%Y-%m-%d %H:%M')}*
*质量评估：高（基于核心观点挖掘潜意识模式）*
"""
        
        output_file = self.output_path / f"{evolve_id}.md"
        output_file.write_text(content, encoding='utf-8')
        
        return {
            "evolve_id": evolve_id,
            "evolve_type": "subconscious",
            "content": content,
            "output_path": str(output_file),
            "status": "evolved",
            "quality": "高",
            "created_at": datetime.now().isoformat()
        }
    
    # ========== AI 生成 Prompt 方法（基于 LLM） ==========
    # 这些方法在实际使用时会调用 LLM API 生成内容
    # 当前版本使用模板填充，后续可替换为真实 LLM 调用
    
    def _generate_insight_prompt(self, core_idea: str) -> str:
        """生成核心洞察 prompt"""
        return f"基于'{core_idea[:100]}...'，深度思考后提炼的核心洞察是..."
    
    def _generate_surface_problem(self, core_idea: str) -> str:
        """生成表面问题 prompt"""
        return f"基于'{core_idea[:100]}...'，表面问题是..."
    
    def _generate_deep_cause(self, core_idea: str) -> str:
        """生成深层原因 prompt"""
        return f"基于'{core_idea[:100]}...'，深层原因是..."
    
    def _generate_essence_law(self, core_idea: str) -> str:
        """生成本质规律 prompt"""
        return f"基于'{core_idea[:100]}...'，本质规律是..."
    
    def _generate_cross_domain_biology(self, core_idea: str) -> str:
        """生成生物学跨界 prompt"""
        return f"从生物学视角看'{core_idea[:100]}...'，可以类比为..."
    
    def _generate_cross_domain_physics(self, core_idea: str) -> str:
        """生成物理学跨界 prompt"""
        return f"从物理学视角看'{core_idea[:100]}...'，可以类比为..."
    
    def _generate_cross_domain_sociology(self, core_idea: str) -> str:
        """生成社会学跨界 prompt"""
        return f"从社会学视角看'{core_idea[:100]}...'，可以类比为..."
    
    def _generate_question_1(self, core_idea: str) -> str:
        """生成问题 1 prompt"""
        return f"基于'{core_idea[:100]}...'，可以提出什么问题？..."
    
    def _generate_question_2(self, core_idea: str) -> str:
        """生成问题 2 prompt"""
        return f"基于'{core_idea[:100]}...'，可以提出什么问题？..."
    
    def _generate_question_3(self, core_idea: str) -> str:
        """生成问题 3 prompt"""
        return f"基于'{core_idea[:100]}...'，可以提出什么问题？..."
    
    def _generate_concept_name(self, core_idea: str) -> str:
        """生成概念名称 prompt"""
        return f"基于'{core_idea[:100]}...'，可以提炼的概念是..."
    
    def _generate_concept_definition(self, core_idea: str) -> str:
        """生成概念定义 prompt"""
        return f"基于'{core_idea[:100]}...'，概念定义是..."
    
    def _generate_model_1(self, core_idea: str) -> str:
        """生成心智模型 1 prompt"""
        return f"基于'{core_idea[:100]}...'，对应的心智模型是..."
    
    def _generate_model_desc_1(self, core_idea: str) -> str:
        """生成心智模型描述 1 prompt"""
        return f"这个心智模型的描述是..."
    
    def _generate_model_connection_1(self, core_idea: str) -> str:
        """生成心智模型连接 1 prompt"""
        return f"与笔记观点的连接是..."
    
    def _generate_model_2(self, core_idea: str) -> str:
        """生成心智模型 2 prompt"""
        return f"基于'{core_idea[:100]}...'，对应的心智模型是..."
    
    def _generate_model_desc_2(self, core_idea: str) -> str:
        """生成心智模型描述 2 prompt"""
        return f"这个心智模型的描述是..."
    
    def _generate_model_connection_2(self, core_idea: str) -> str:
        """生成心智模型连接 2 prompt"""
        return f"与笔记观点的连接是..."
    
    def _generate_model_3(self, core_idea: str) -> str:
        """生成心智模型 3 prompt"""
        return f"基于'{core_idea[:100]}...'，对应的心智模型是..."
    
    def _generate_model_desc_3(self, core_idea: str) -> str:
        """生成心智模型描述 3 prompt"""
        return f"这个心智模型的描述是..."
    
    def _generate_model_connection_3(self, core_idea: str) -> str:
        """生成心智模型连接 3 prompt"""
        return f"与笔记观点的连接是..."
    
    def _generate_model_comparison(self, core_idea: str) -> str:
        """生成心智模型对比 prompt"""
        return f"基于'{core_idea[:100]}...'，心智模型对比是..."
    
    def _generate_model_insights(self, core_idea: str) -> str:
        """生成心智模型启发 prompt"""
        return f"基于'{core_idea[:100]}...'，心智模型启发是..."
    
    def _generate_cross_biology(self, core_idea: str) -> str:
        """生成生物学跨界 prompt"""
        return f"从生物学视角看'{core_idea[:100]}...'，会看到..."
    
    def _generate_cross_physics(self, core_idea: str) -> str:
        """生成物理学跨界 prompt"""
        return f"从物理学视角看'{core_idea[:100]}...'，会看到..."
    
    def _generate_cross_economics(self, core_idea: str) -> str:
        """生成经济学跨界 prompt"""
        return f"从经济学视角看'{core_idea[:100]}...'，会看到..."
    
    def _generate_cross_ancient(self, core_idea: str) -> str:
        """生成古代视角 prompt"""
        return f"在古代，'{core_idea[:100]}...'会被理解为..."
    
    def _generate_cross_future(self, core_idea: str) -> str:
        """生成未来视角 prompt"""
        return f"在未来，'{core_idea[:100]}...'会演变..."
    
    def _generate_cross_culture(self, core_idea: str) -> str:
        """生成其他文化视角 prompt"""
        return f"在其他文化中，'{core_idea[:100]}...'会被理解为..."
    
    def _generate_cross_insights(self, core_idea: str) -> str:
        """生成跨界洞察 prompt"""
        return f"基于'{core_idea[:100]}...'，跨界洞察是..."
    
    def _generate_habit_1(self, core_idea: str) -> str:
        """生成习惯 1 prompt"""
        return f"基于'{core_idea[:100]}...'，可以培养的微习惯是..."
    
    def _generate_habit_action_1(self, core_idea: str) -> str:
        """生成习惯行动 1 prompt"""
        return f"具体行动是..."
    
    def _generate_habit_trigger_1(self, core_idea: str) -> str:
        """生成习惯触发条件 1 prompt"""
        return f"触发条件是..."
    
    def _generate_habit_effect_1(self, core_idea: str) -> str:
        """生成习惯效果 1 prompt"""
        return f"预期效果是..."
    
    def _generate_habit_2(self, core_idea: str) -> str:
        """生成习惯 2 prompt"""
        return f"基于'{core_idea[:100]}...'，可以培养的微习惯是..."
    
    def _generate_habit_action_2(self, core_idea: str) -> str:
        """生成习惯行动 2 prompt"""
        return f"具体行动是..."
    
    def _generate_habit_trigger_2(self, core_idea: str) -> str:
        """生成习惯触发条件 2 prompt"""
        return f"触发条件是..."
    
    def _generate_habit_effect_2(self, core_idea: str) -> str:
        """生成习惯效果 2 prompt"""
        return f"预期效果是..."
    
    def _generate_habit_3(self, core_idea: str) -> str:
        """生成习惯 3 prompt"""
        return f"基于'{core_idea[:100]}...'，可以培养的微习惯是..."
    
    def _generate_habit_action_3(self, core_idea: str) -> str:
        """生成习惯行动 3 prompt"""
        return f"具体行动是..."
    
    def _generate_habit_trigger_3(self, core_idea: str) -> str:
        """生成习惯触发条件 3 prompt"""
        return f"触发条件是..."
    
    def _generate_habit_effect_3(self, core_idea: str) -> str:
        """生成习惯效果 3 prompt"""
        return f"预期效果是..."
    
    def _generate_habit_tracker(self, core_idea: str) -> str:
        """生成习惯追踪 prompt"""
        return f"基于'{core_idea[:100]}...'，习惯追踪是..."
    
    def _generate_habit_tips(self, core_idea: str) -> str:
        """生成习惯养成建议 prompt"""
        return f"基于'{core_idea[:100]}...'，习惯养成建议是..."
    
    def _generate_subcon_pattern_1(self, core_idea: str) -> str:
        """生成潜意识模式 1 prompt"""
        return f"基于'{core_idea[:100]}...'，隐藏的潜意识模式是..."
    
    def _generate_subcon_manifestation_1(self, core_idea: str) -> str:
        """生成潜意识表现 1 prompt"""
        return f"表现是..."
    
    def _generate_subcon_root_1(self, core_idea: str) -> str:
        """生成潜意识根源 1 prompt"""
        return f"根源是..."
    
    def _generate_subcon_impact_1(self, core_idea: str) -> str:
        """生成潜意识影响 1 prompt"""
        return f"影响是..."
    
    def _generate_subcon_pattern_2(self, core_idea: str) -> str:
        """生成潜意识模式 2 prompt"""
        return f"基于'{core_idea[:100]}...'，隐藏的潜意识模式是..."
    
    def _generate_subcon_manifestation_2(self, core_idea: str) -> str:
        """生成潜意识表现 2 prompt"""
        return f"表现是..."
    
    def _generate_subcon_root_2(self, core_idea: str) -> str:
        """生成潜意识根源 2 prompt"""
        return f"根源是..."
    
    def _generate_subcon_impact_2(self, core_idea: str) -> str:
        """生成潜意识影响 2 prompt"""
        return f"影响是..."
    
    def _generate_subcon_pattern_3(self, core_idea: str) -> str:
        """生成潜意识模式 3 prompt"""
        return f"基于'{core_idea[:100]}...'，隐藏的潜意识模式是..."
    
    def _generate_subcon_manifestation_3(self, core_idea: str) -> str:
        """生成潜意识表现 3 prompt"""
        return f"表现是..."
    
    def _generate_subcon_root_3(self, core_idea: str) -> str:
        """生成潜意识根源 3 prompt"""
        return f"根源是..."
    
    def _generate_subcon_impact_3(self, core_idea: str) -> str:
        """生成潜意识影响 3 prompt"""
        return f"影响是..."
    
    def _generate_subcon_strategy_1(self, core_idea: str) -> str:
        """生成潜意识调整策略 1 prompt"""
        return f"基于'{core_idea[:100]}...'，调整策略是..."
    
    def _generate_subcon_method_1(self, core_idea: str) -> str:
        """生成潜意识调整方法 1 prompt"""
        return f"具体方法是..."
    
    def _generate_subcon_effect_1(self, core_idea: str) -> str:
        """生成潜意识调整效果 1 prompt"""
        return f"预期效果是..."
    
    def _generate_subcon_strategy_2(self, core_idea: str) -> str:
        """生成潜意识调整策略 2 prompt"""
        return f"基于'{core_idea[:100]}...'，调整策略是..."
    
    def _generate_subcon_method_2(self, core_idea: str) -> str:
        """生成潜意识调整方法 2 prompt"""
        return f"具体方法是..."
    
    def _generate_subcon_effect_2(self, core_idea: str) -> str:
        """生成潜意识调整效果 2 prompt"""
        return f"预期效果是..."
    
    def _generate_subcon_question_1(self, core_idea: str) -> str:
        """生成自我反思问题 1 prompt"""
        return f"基于'{core_idea[:100]}...'，自我反思问题是..."
    
    def _generate_subcon_question_2(self, core_idea: str) -> str:
        """生成自我反思问题 2 prompt"""
        return f"基于'{core_idea[:100]}...'，自我反思问题是..."
    
    def _generate_subcon_question_3(self, core_idea: str) -> str:
        """生成自我反思问题 3 prompt"""
        return f"基于'{core_idea[:100]}...'，自我反思问题是..."


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