Learning System

二、触发条件

学习触发

• "我要学XXX"
• "开始学习XXX"
• "学习XXX"
• "帮我学XXX"

进度查询触发

• "我的学习进度"
• "XXX学到哪了"
• "查看学习状态"
• "我的Kotlin/Java/Android进度"

复习触发

• "我要复习"
• "今天有什么要复习的"
• "复习XXX"

知识探索触发

• "有哪些XXX知识"
• "我想学XXX相关的知识"

三、心理学原理

西方认知科学

西方建构主义

中国传统智慧

记忆原理总结

短期记忆优化

• 组块化：将复杂信息拆分成3-5个组块
• 主动回忆：学完后立即回忆而非重读
• 双重编码：文字+图示+示例

长期记忆巩固

• 间隔重复：1天、3天、7天、14天、30天
• 精细加工：用类比、联想、视觉化
• 提取练习：主动提取比重复学习更有效
• 变式练习：多角度应用同一知识

四、文件系统设计

目录结构

D:/2Study/StudyNotes/2026/learning-system/
├── progress.json                    # 学习进度（核心文件）
├── knowledge-list.json              # 知识点元数据索引（核心文件）
├── topics/                          # 知识点内容目录
│   ├── kotlin-coroutine.md
│   ├── java-thread.md
│   ├── android-framework-binder.md
│   └── ...
├── sessions/                        # 交接文档目录（扁平结构）
│   ├── handover_start_20260415_120000_kotlin-coroutine.json
│   ├── handover_continue_20260415_143022_java-thread.json
│   └── handover_review_20260416_090012_android-binder.json
└── reviews/                         # 复习系统
    ├── review-schedule.json         # 复习计划
    └── review-history.json          # 复习历史

交接文档状态管理

交接文档通过 JSON 内的 status 字段管理生命周期：

生命周期：

创建 → status = "pending"
开始执行 → status = "active"
完成 → status = "completed"

核心文件说明

五、知识点内容生成规则

首次生成

触发条件：用户首次请求学习某知识点，且 topics/{id}.md 不存在

内容来源：

1. AI网络搜索（获取高质量资料）
2. AI知识库生成

生成流程：

用户请求学习某知识点
         ↓
 topics/{id}.md 是否存在？
         ↓
    ┌────┴────┐
    ↓         ↓
   否         是
    ↓         ↓
首次生成    直接读取
    ↓
AI网络搜索相关资料
    ↓
生成学习大纲
    ↓
用户确认大纲
    ↓
填充详细内容
    ↓
自动保存为 topics/{id}.md
    ↓
开始阶段1学习

注意：

• 大纲确认后，详细内容不再逐一确认（避免琐碎）
• 用户可直接开始学习

后续迭代规则

废弃机制

当某部分内容有误或过时，标记为废弃而非删除：

## 协程调度器

> ⚠️ 已废弃（2026-04-15）
> 原因：内容有误
> 替代内容：见下方"协程调度机制"

### 协程调度机制
[正确内容]

复习时自动跳过废弃内容

进度处理

现有笔记整合

当用户已有学习笔记时：

流程：

1. 用户提供现有md文件
         ↓
2. AI评估每个文件的质量
   - 完整性（30%）
   - 结构性（20%）
   - 深度（20%）
   - 实践性（15%）
   - 准确性（15%）
         ↓
3. 生成评估报告
   - 每个文件的评分、优势、不足
   - 可提取的内容
         ↓
4. AI推荐整合方案
   - 以哪个文件为主
   - 从哪些文件补充
         ↓
5. 用户确认
         ↓
6. AI整合内容并规范化
         ↓
7. 保存为 topics/{id}.md

整合原则：

• 保留用户笔记中有价值的内容
• 补充缺失的必要部分（预测试题、记忆锚点等）
• 统一格式，符合系统模板

六、数据文件结构

progress.json（学习进度）

{
  "version": "1.0",
  "last_updated": "2026-04-15T10:00:00Z",
  
  "active_session": {
    "knowledge_id": "kotlin-coroutine",
    "stage": 2,
    "sub_stage": 3,
    "started_at": "2026-04-15T09:30:00Z",
    "total_minutes": 35
  },
  
  "knowledge_progress": {
    "kotlin-coroutine": {
      "title": "Kotlin协程",
      "stages": {
        "1": {
          "status": "completed",
          "completed_at": "2026-04-15T10:00:00Z",
          "quiz_score": 85
        },
        "2": {
          "status": "in_progress",
          "sub_stage": 3
        },
        "3": {"status": "pending"},
        "4": {"status": "pending"}
      },
      "overall_progress": 50,
      "last_activity": "2026-04-15T10:30:00Z",
      "total_learning_minutes": 35
    }
  },
  
  "completed_knowledge": []
}

knowledge-list.json（知识点元数据）

{
  "version": "1.0",
  "last_updated": "2026-04-15T10:00:00Z",
  
  "knowledge": {
    "kotlin-coroutine": {
      "id": "kotlin-coroutine",
      "title": "Kotlin协程",
      "language": "kotlin",
      "category": "编程语言",
      "subcategory": "并发编程",
      "framework": null,
      "tags": ["concurrent", "async", "coroutine"],
      "file": "topics/kotlin-coroutine.md",
      "metadata": {
        "difficulty": "medium",
        "estimated_hours": 2,
        "dependencies": []
      }
    },
    
    "java-thread": {
      "id": "java-thread",
      "title": "Java线程",
      "language": "java",
      "category": "编程语言",
      "subcategory": "并发编程",
      "framework": null,
      "tags": ["concurrent", "thread"],
      "file": "topics/java-thread.md",
      "metadata": {
        "difficulty": "medium",
        "estimated_hours": 3,
        "dependencies": []
      }
    },
    
    "android-framework-binder": {
      "id": "android-framework-binder",
      "title": "Binder机制",
      "language": "java",
      "category": "框架",
      "subcategory": "系统服务",
      "framework": "android-framework",
      "tags": ["ipc", "system", "core"],
      "file": "topics/android-framework-binder.md",
      "metadata": {
        "difficulty": "high",
        "estimated_hours": 5,
        "dependencies": [],
        "learning_stage": "系统基础"
      }
    },
    
    "android-framework-ams": {
      "id": "android-framework-ams",
      "title": "ActivityManagerService",
      "language": "java",
      "category": "框架",
      "subcategory": "系统服务",
      "framework": "android-framework",
      "tags": ["system", "service", "activity"],
      "file": "topics/android-framework-ams.md",
      "metadata": {
        "difficulty": "high",
        "estimated_hours": 6,
        "dependencies": ["android-framework-binder"],
        "learning_stage": "核心服务"
      }
    }
  }
}

动态索引计算规则

系统在运行时根据 knowledge 字段动态计算索引，无需持久化存储：

索引计算函数：

build_index_by_field(knowledge, field):
  result = {}
  for each (id, item) in knowledge:
    value = item[field]
    if value is not null:
      if value is array:  // 如 tags
        for each tag in value:
          result[tag].append(id)
      else:
        result[value].append(id)
  return result

// 调用示例
by_language = build_index_by_field(knowledge, "language")
by_category = build_index_by_field(knowledge, "category")
by_framework = build_index_by_field(knowledge, "framework")
by_tags = build_index_by_field(knowledge, "tags")
by_difficulty = build_index_by_field(knowledge, "metadata.difficulty")

优势：

• 单一数据源，无需同步
• 逻辑简单，不易出错
• 知识点数量有限，计算开销可忽略

review-schedule.json（复习计划）

{
  "version": "1.0",
  "last_check": "2026-04-15T09:00:00Z",
  
  "schedules": [
    {
      "knowledge_id": "kotlin-coroutine",
      "current_round": 2,
      "rounds": [
        {
          "round": 1,
          "target_day": 1,
          "scheduled_date": "2026-04-16",
          "status": "completed",
          "completed_at": "2026-04-16T10:30:00Z",
          "score": 85
        },
        {
          "round": 2,
          "target_day": 3,
          "scheduled_date": "2026-04-18",
          "status": "pending",
          "questions_count": 10
        },
        {
          "round": 3,
          "target_day": 7,
          "scheduled_date": "2026-04-22",
          "status": "pending",
          "questions_count": 15
        },
        {
          "round": 4,
          "target_day": 14,
          "scheduled_date": "2026-04-29",
          "status": "pending"
        },
        {
          "round": 5,
          "target_day": 30,
          "scheduled_date": "2026-05-15",
          "status": "pending"
        }
      ],
      "created_at": "2026-04-15T11:45:00Z"
    }
  ]
}

review-history.json（复习历史）

{
  "history": [
    {
      "knowledge_id": "kotlin-coroutine",
      "round": 1,
      "review_date": "2026-04-16T10:30:00Z",
      "duration_minutes": 15,
      "questions_count": 5,
      "correct_count": 4,
      "score": 80,
      "user_feedback": "还行，有些细节忘了"
    }
  ]
}

七、四阶段学习流程

阶段概览

阶段1：认知建构

目标：建立清晰的心理模型，激活先备知识，初步理解核心概念

时间：15-20分钟

心理学技巧：

• 激活先备知识（图式理论）
• 组块化（米勒定律）
• 双重编码（文字+图示）
• 预测试（测试效应）

执行步骤：

步骤1：先备知识激活（3分钟）

检查依赖关系，激活已有知识：

🎯 激活先备知识：

1. 读取 knowledge-list.json 中该知识的 dependencies
2. 检查 progress.json 中依赖的完成状态
3. 如果有已完成的依赖：
   "这部分内容和你已经掌握的 [XXX] 知识有相似之处..."
4. 如果无依赖：
   "💡 类比：用生活中的 [XXX] 来理解..."

步骤2：核心概念组块（7分钟）

将知识点拆分为3-5个组块（符合米勒定律7±2）：

📦 知识组块1：[标题]
- 核心要点1：[一句话概括]
- 核心要点2：[一句话概括]
- 关键记忆点：[用关键词标记]

📦 知识组块2：[标题]
...

📦 知识组块3：[标题]
...

步骤3：心理模型可视化（5分钟）

双重编码：文字+图示

🎨 构建心理模型：

[用文本图形展示结构]

例如：
┌─────────────┐
│   输入      │
└──────┬──────┘
       │
  ┌────▼────┐
  │  处理   │
  └────┬────┘
       │
  ┌────▼────┐
  │   输出  │
  └─────────┘

步骤4：快速预测试（5分钟）

测试效应：预测试激发思考

🧪 在深入学习前，先测测你的直觉：

❓ [3-5道选择题，考察直觉理解]

这个测试的目的是激发思考，答案会在最后揭晓

阶段完成判定：

• 预测试通过（>70分）：进入阶段2
• 预测试未通过：补充讲解，再次测试

保存操作：

更新 progress.json：
- stages.1.status = "completed"
- stages.1.quiz_score = [分数]
- stages.1.completed_at = [时间]
- active_session.stage = 2

阶段2：深度内化

目标：真正理解"为什么"，建立知识间的深层连接

时间：20-30分钟

心理学技巧：

• 苏格拉底式提问（生成效应）
• 精细加工（深度加工增强记忆）
• 对比分析（判别学习理论）
• 主动回忆（提取练习效应）

执行步骤：

步骤1：原理探究（10分钟）

苏格拉底式提问，引导主动思考：

🤔 核心问题：为什么是这样设计的？

思考路径：
1. 问题是什么？
2. 解决思路是什么？
3. 为什么这个思路可行？
4. 有什么权衡和取舍？

通过对话引导，而不是直接讲授

步骤2：对比分析（8分钟）

对比相似知识，建立知识网络：

⚖️ 对比学习：

| 维度  | 方案A | 方案B | 思考 |
| ----- | ----- | ----- | ---- |
| 原理  | ...   | ...   | 为什么不同？ |
| 优势  | ...   | ...   | 为什么A适合X场景？ |
| 局限  | ...   | ...   | 如何弥补？ |

查询 knowledge-list.json 中 tags 相似的知识点（动态计算索引）

步骤3：本质提炼（7分钟）

格物致知（朱熹），提炼底层本质：

💎 万物之理：

底层本质是：[一句话]

这个本质在其他领域也存在吗？
- [找类比案例]

步骤4：主动回忆（5分钟）

提取练习：用户用自己的话复述

📤 不看笔记，请用自己的话复述一遍核心原理

[用户复述]

[AI点评：指出理解的准确度和深度]

阶段完成判定：

• 能用自己的话准确解释核心原理
• 能说出"为什么"这样设计

保存操作：

更新 progress.json：
- stages.2.status = "completed"
- stages.2.explanation_quality = [good/medium/poor]
- active_session.stage = 3

阶段3：实践应用

目标：知行合一，在真实场景中应用

时间：30-45分钟

心理学技巧：

• 情境学习（真实场景应用）
• 脚手架策略（逐步撤掉支持）
• 渐进式任务（最近发展区ZPD）
• 即时反馈（行为主义强化）
• 变式练习（迁移理论）

执行步骤：

步骤1：观察模仿（10分钟）

脚手架策略：先提供完整支持

👀 先看一遍完整示例：

[展示一个完整的、可运行的示例]

🔎 分析重点：
- 关键点1：在哪里？为什么？
- 关键点2：在哪里？为什么？

步骤2：引导练习（15分钟）

脚手架策略：部分支持

💡 scaffold练习：

已提供代码框架，补全关键部分：

[代码框架，用TODO标记]

提示：[逐步提示，不一次给全]

步骤3：独立实践（15分钟）

脚手架策略：撤掉支持

🎯 独立完成一个任务：

任务描述：[清晰的任务]
要求：
- [具体要求1]
- [具体要求2]

[用户独立完成]

[AI点评：先肯定，再指出改进点]

步骤4：变式应用（10分钟）

变式练习：不同场景应用

🔄 换个场景再练一次：

场景变化：[说明不同之处]
目标：[需要实现的功能]

目的：防止死记硬背，灵活运用

阶段完成判定：

• 独立完成任务
• 代码能跑通

保存操作：

更新 progress.json：
- stages.3.status = "completed"
- stages.3.practice_tasks_completed = [数量]
- active_session.stage = 4

阶段4：巩固迁移

目标：建立长期记忆，培养迁移能力

时间：10-15分钟

心理学技巧：

• 间隔重复（艾宾浩斯遗忘曲线）
• 提取练习（主动回忆）
• 记忆锚点（精细加工）
• 情景编码（情景依赖记忆）

执行步骤：

步骤1：即时巩固（5分钟）

提取练习：学完立即回顾

📝 学完立即回顾：

✅ 今天学到的3个核心要点：
1. [用自己的话写]
2. [用自己的话写]
3. [用自己的话写]

🤔 还有什么疑问？

步骤2：生成记忆锚点（3分钟）

精细加工：创造记忆钩子

⚓ 创造记忆钩子：

关联一个你熟悉的事物：
"XXX就像[熟悉事物]，因为..."

例如："协程就像接力赛，因为..."

步骤3：应用场景规划（2分钟）

情景编码：规划何时应用

📅 计划在何时何地应用：

- 明天的工作/学习中，可以用到XXX的场景：[具体场景]
- 下周的项目中，可以用到XXX的地方：[具体地方]

"行动计划比被动记忆强10倍"

步骤4：生成复习计划（自动）

间隔重复：艾宾浩斯复习计划

📊 艾宾浩斯复习计划已生成：

✅ 第1天（明天）：5道快速回忆题
✅ 第3天：10道综合应用题
✅ 第7天：15道深度思考题
✅ 第14天：实战挑战
✅ 第30天：知识整合

系统会在相应时间提醒你复习

阶段完成判定：

• 用户总结3个核心要点
• 用户说了何时应用

保存操作：

1. 更新 progress.json：
   - stages.4.status = "completed"
   - overall_progress = 100
   - completed_at = [时间]
   
2. 更新 knowledge_progress：
   - 添加到 completed_knowledge 列表

3. 创建复习计划：
   - 写入 review-schedule.json
   - 计算复习日期：今天 + 1/3/7/14/30天

八、复习流程

责任分工

定时器职责（openclaw）

每天执行以下任务：

1. 读取 review-schedule.json

2. 检查是否有今天到期的复习：
   - rounds[N].scheduled_date == 今天
   - rounds[N].status == "pending"

3. 检查 sessions/ 下是否已有对应的交接文档：
   - 扫描 handover_review_*_{knowledge_id}.json
   - 存在且 status != "completed" → 跳过（不重复生成）
   - 不存在或 status == "completed" → 生成新交接文档

4. 生成交接文档：
   - 文件名：handover_review_{YYYYMMDD_HHMMSS}_{knowledge_id}.json
   - status: "pending"
   - 写入 sessions/

5. 推送提醒给用户（可选）

复习轮次设计

复习执行流程

1. 检测交接文档：
   - 扫描 sessions/handover_review_*.json
   - 过滤 status != "completed"
   - 用户选择要复习的知识点

2. 开始复习：
   - 更新交接文档 status = "active"
   - 读取 review-schedule.json 获取轮次信息
   - 读取 topics/{knowledge_id}.md

3. 根据轮次生成题目：
   - 第1轮：5道选择题，简单回忆概念
   - 第2轮：10道题，综合应用
   - 第3轮：15道题，深度分析
   - 第4轮：实战项目
   - 第5轮：跨知识整合题

4. 用户答题

5. 评估答案

6. 复习完成后更新文件：
   a) 交接文档：
      - status = "completed"
   
   b) review-schedule.json：
      - rounds[N].status = "completed"
      - rounds[N].completed_at = 时间
      - rounds[N].score = 分数
      - 如有下一轮：计算 scheduled_date
   
   c) review-history.json：
      - 添加本次复习记录

复习质量自适应

根据复习质量调整间隔：

如果 score >= 90：
  掌握很好，延长间隔20%
  scheduled_date = 今天 + (target_day * 1.2)

如果 score >= 70：
  掌握一般，标准间隔
  scheduled_date = 今天 + target_day

如果 score < 70：
  掌握不好，缩短间隔50%
  scheduled_date = 今天 + (target_day * 0.5)

九、知识点ID设计

ID命名规范

格式：{language|framework}-{category}-{item} 或 {language|framework}-{item}

示例：

元数据字段说明

十、工作流程

流程0：交接文档检测（优先执行）

当用户触发学习相关指令时，优先执行此流程：

触发词："我要学XXX"、"开始学习"、"复习"、"检查任务"、"有什么要学的"

处理步骤：

1. 扫描 sessions/*.json

2. 按状态过滤：
   - status == "active" → 优先提示（未完成的任务）
   - status == "pending" → 显示待处理列表
   - status == "completed" → 跳过

3. 如果有未完成任务：
   显示：
   "📋 检测到以下待处理任务：
   
    ▶️ 正在进行（1项）
    1. Kotlin协程（阶段2第3步）[上次：2小时前]
    
    ⏳ 待开始（2项）
    2. Java线程（开始学习）
    3. Android Binder（复习：第2轮）
    
    请选择编号，或输入其他指令"
   
4. 用户选择编号 → 执行对应交接文档
   - 更新交接文档 status = "active"
   - 按 instructions 执行教学/复习流程

5. 用户输入其他指令 → 正常流程（忽略交接文档）

6. 无未完成任务 → 正常流程

流程1：开始学习新知识

用户输入："我要学Kotlin协程"

处理步骤：

1. 解析意图
   - 知识点：Kotlin协程
   - 知识点ID：kotlin-coroutine

2. 检查知识是否存在
   - 读取 knowledge-list.json
   - 查找 kotlin-coroutine
   - 如果不存在：
     - 询问用户是否创建新知识
     - 如果创建：初始化知识点元数据
     - 写入 knowledge-list.json

3. 检查学习进度
   - 读取 progress.json
   - 查找 knowledge_progress.kotlin-coroutine
   - 如果存在：
     - 显示上次进度
     - 询问是否继续
   - 如果不存在：
     - 初始化新进度
     - 写入 progress.json

4. 检查依赖关系
   - 读取 knowledge-list.json 中该知识的 dependencies
   - 对每个依赖D：
     - 检查 progress.json 中 D 的状态
     - 如果 D 未完成：记录为缺失依赖
   - 如果有缺失依赖：
     - 提示用户先学习依赖
     - 显示推荐学习路径
     - 询问是否继续

5. 更新活动会话
   - 更新 progress.json 的 active_session
   - 设置 knowledge_id = "kotlin-coroutine"
   - 设置 stage = 1, sub_stage = 1
   - 更新 last_updated

6. 开始阶段1教学
   - 读取或生成 topics/kotlin-coroutine.md
   - 执行阶段1：认知建构

流程2：查询学习进度

用户输入："我的学习进度"

处理步骤：

1. 读取 progress.json

2. 读取 knowledge-list.json

3. 生成进度报告：

   "📊 学习总览

    当前学习：{active_session.knowledge_id} [阶段{stage} 第{sub_stage}步]

    {按语言分组显示}

    {按类别分组显示}

    📅 今日复习：
    {读取 review-schedule.json，显示今天到期的复习}"

4. 如果用户指定维度：
   - "我的Kotlin进度"：
     - 动态计算索引，筛选 language="kotlin" 的知识点
     - 显示Kotlin相关所有知识
   - "我的Android Framework进度"：
     - 动态计算索引，筛选 framework="android-framework" 的知识点
     - 显示相关所有知识

流程3：切换知识点

用户输入："我想学Java线程"

处理步骤：

1. 保存当前进度
   - 读取 progress.json 的 active_session
   - 保存到 knowledge_progress.{current_knowledge_id}
   - 记录 last_activity

2. 解析新知识点
   - 知识点ID：java-thread

3. 检查新知识点
   - 读取 knowledge-list.json
   - 检查是否存在
   - 检查依赖关系

4. 更新活动会话
   - 设置 active_session.knowledge_id = "java-thread"
   - 设置 stage 和 sub_stage（根据已有进度或初始化）

5. 显示切换信息：
   "已保存：{上一个知识点}（阶段X第Y步）

    开始学习：Java线程
    难度：中等 | 预计时间：3小时

    进入阶段1：认知建构"

6. 开始教学

流程4：完成学习阶段

用户完成某个阶段后：

1. 更新 progress.json：
   - stages.{N}.status = "completed"
   - stages.{N}.completed_at = [时间]
   - 更新 overall_progress

2. 判定是否进入下一阶段：
   - 如果 difficulty = "low"/"medium"：自动进入
   - 如果 difficulty = "high"：询问用户

3. 如果进入下一阶段：
   - 更新 active_session.stage = N+1
   - 开始下一阶段教学

4. 如果完成阶段4（学习完成）：
   - 更新 progress.json：
     - overall_progress = 100
     - completed_at = [时间]
     - 添加到 completed_knowledge
   
   - 创建复习计划：
     - 写入 review-schedule.json
     - 计算复习日期
   
   - 显示完成信息：
     "🎉 学习完成！
      
      📊 艾宾浩斯复习计划已生成：
      - 第1天：5道快速回忆题
      - 第3天：10道综合应用题
      ..."

流程5：交接文档生成

当需要在不同场景间传递学习任务时，生成交接文档。

交接文档存储位置

D:/2Study/StudyNotes/2026/learning-system/sessions/
├── handover_start_20260415_100000_kotlin-coroutine.json
├── handover_continue_20260415_143022_java-thread.json
└── handover_review_20260416_090012_android-binder.json

文件命名格式：handover_{type}_{YYYYMMDD_HHMMSS}_{knowledge_id}.json

交接文档类型

类型1：开始学习交接文档

触发时机：用户开始学习新知识点

文件名：handover_start_{YYYYMMDD_HHMMSS}_{知识点ID}.json

文档结构：

{
  "type": "start_learning",
  "version": "1.0",
  "status": "pending",
  "created_at": "2026-04-15T10:00:00Z",
  "source": "user_request",
  
  "task": {
    "action": "start",
    "knowledge_id": "java-thread",
    "stage": 1
  },
  
  "knowledge_info": {
    "id": "java-thread",
    "title": "Java线程",
    "language": "java",
    "category": "编程语言",
    "subcategory": "并发编程",
    "difficulty": "medium",
    "estimated_hours": 3,
    "file": "topics/java-thread.md"
  },
  
  "context": {
    "dependencies": [],
    "dependencies_met": true,
    "related_completed_knowledge": ["kotlin-coroutine"],
    "related_similarity": {
      "kotlin-coroutine": {
        "similarity": 0.7,
        "note": "协程类似轻量级线程，可类比学习"
      }
    }
  },
  
  "instructions": {
    "read_files": [
      "knowledge-list.json",
      "progress.json"
    ],
    "generate_or_read": "topics/java-thread.md",
    "execute": {
      "stage": 1,
      "steps": [
        "激活先备知识（关联kotlin-coroutine）",
        "核心组块讲解",
        "心理模型可视化",
        "预测试"
      ]
    },
    "activate_prior_knowledge": {
      "enabled": true,
      "source_knowledge": "kotlin-coroutine",
      "analogy": "线程是重量级的并发机制，你学过的协程是轻量级的，它们有相似之处"
    },
    "after_stage_complete": {
      "update_files": ["progress.json"],
      "action": "update_progress"
    }
  }
}

字段说明：

类型2：继续学习交接文档

触发时机：用户继续未完成的学习（恢复会话）

文件名：handover_continue_{YYYYMMDD_HHMMSS}_{知识点ID}.json

文档结构：

{
  "type": "continue_learning",
  "version": "1.0",
  "status": "pending",
  "created_at": "2026-04-15T14:00:00Z",
  "source": "session_recovery",
  
  "task": {
    "action": "continue",
    "knowledge_id": "kotlin-coroutine",
    "stage": 2,
    "sub_stage": 3
  },
  
  "knowledge_info": {
    "id": "kotlin-coroutine",
    "title": "Kotlin协程",
    "file": "topics/kotlin-coroutine.md"
  },
  
  "session_state": {
    "started_at": "2026-04-15T10:00:00Z",
    "last_activity": "2026-04-15T12:30:00Z",
    "total_minutes": 35,
    "stages_completed": [1],
    "current_stage_status": "in_progress",
    "current_sub_stage": 3,
    "current_activity": "苏格拉底式提问"
  },
  
  "progress_summary": {
    "stage1": {
      "status": "completed",
      "completed_at": "2026-04-15T10:30:00Z",
      "quiz_score": 85,
      "key_points_learned": [
        "协程是轻量级线程",
        "不阻塞线程",
        "挂起函数"
      ]
    },
    "stage2": {
      "status": "in_progress",
      "sub_stage": 3,
      "activities_done": [
        "原理探究（已完成）",
        "对比分析（已完成）",
        "主动回忆（进行中第3步）"
      ]
    },
    "stage3": {"status": "pending"},
    "stage4": {"status": "pending"}
  },
  
  "instructions": {
    "read_files": [
      "progress.json",
      "topics/kotlin-coroutine.md"
    ],
    "resume_from": {
      "stage": 2,
      "sub_stage": 3,
      "activity": "主动回忆",
      "description": "请用户用自己的话复述核心原理"
    },
    "skip_completed": true,
    "after_stage_complete": {
      "update_files": ["progress.json"],
      "action": "update_progress"
    }
  },
  
  "user_context": {
    "last_question": "为什么协程比线程更轻量？",
    "last_answer_quality": "good",
    "suggested_continuation": "继续让用户用自己的话解释协程的工作原理"
  }
}

字段说明：

类型3：复习交接文档

触发时机：定时任务触发或用户主动复习

文件名：handover_review_{YYYYMMDD_HHMMSS}_{知识点ID}.json

文档结构：

{
  "type": "review",
  "version": "1.0",
  "status": "pending",
  "created_at": "2026-04-16T09:00:00Z",
  "source": "scheduled_task",
  
  "task": {
    "action": "review",
    "knowledge_id": "kotlin-coroutine",
    "round": 2,
    "questions_count": 10
  },
  
  "knowledge_info": {
    "id": "kotlin-coroutine",
    "title": "Kotlin协程",
    "file": "topics/kotlin-coroutine.md",
    "difficulty": "medium"
  },
  
  "review_context": {
    "learning_completed_at": "2026-04-15T11:45:00Z",
    "days_since_learning": 1,
    "previous_rounds": [
      {
        "round": 1,
        "completed_at": "2026-04-16T10:30:00Z",
        "score": 85,
        "duration_minutes": 15,
        "user_feedback": "还行，有些细节忘了"
      }
    ],
    "current_round": {
      "round": 2,
      "target_day": 3,
      "scheduled_date": "2026-04-18",
      "status": "pending",
      "questions_count": 10
    },
    "weak_areas": [
      "协程作用域的使用场景",
      "异常处理机制"
    ],
    "strong_areas": [
      "协程基本概念",
      "挂起函数原理"
    ]
  },
  
  "instructions": {
    "read_files": [
      "topics/kotlin-coroutine.md",
      "reviews/review-history.json"
    ],
    "generate_questions": {
      "count": 10,
      "difficulty": "medium",
      "types": ["选择题", "填空题"],
      "focus_areas": ["综合应用"],
      "emphasize_weak_areas": true,
      "weak_area_weight": 0.6
    },
    "question_distribution": {
      "概念回忆": 3,
      "综合应用": 5,
      "对比分析": 2
    },
    "presentation_style": {
      "show_one_by_one": true,
      "immediate_feedback": true,
      "show_score_after_complete": true
    },
    "after_completion": {
      "update_files": [
        "reviews/review-schedule.json",
        "reviews/review-history.json"
      ],
      "calculate_next_review": true,
      "adaptive_scheduling": {
        "enabled": true,
        "rules": {
          "score_gte_90": "interval * 1.2",
          "score_gte_70": "interval * 1.0",
          "score_lt_70": "interval * 0.5"
        }
      }
    }
  },
  
  "user_greeting": {
    "message": "📚 今天需要复习：Kotlin协程（第2轮）",
    "show_summary": true,
    "summary_content": "上次复习得分：85分\n薄弱点：协程作用域、异常处理\n预计时长：15分钟"
  }
}

字段说明：

复习轮次与题目配置对照表

交接文档生成流程

1. 开始学习场景：
   用户："我要学Kotlin协程"
   
   处理：
   a) 检查知识点是否存在
   b) 检查依赖关系
   c) 查找相似知识点
   d) 检查 topics/{knowledge_id}.md 是否存在
      - 若不存在：执行"首次生成"流程（见第五章）
      - 若存在：直接读取
   e) 生成 handover_start_{日期}_{知识点ID}.json
   f) 根据交接文档执行教学

2. 继续学习场景：
   用户："继续学习" 或 "我的学习进度"后选择继续
   
   处理：
   a) 读取 progress.json 的 active_session
   b) 读取 knowledge_progress 获取进度详情
   c) 生成 handover_continue_{日期}_{知识点ID}.json
   d) 根据交接文档恢复会话

3. 复习场景：
   定时任务触发 或 用户："我要复习"
   
   处理：
   a) 读取 review-schedule.json 找到期复习项
   b) 读取 review-history.json 获取历史记录
   c) 分析薄弱点和优势点
   d) 生成 handover_review_{日期}_{知识点ID}.json
   e) 根据交接文档执行复习

交接文档读取流程

接收到交接文档后：

1. 解析文档类型（type字段）

2. 根据类型执行：

   如果 type == "start_learning"：
     a) 检查 knowledge_info.file 是否存在
        - 若不存在：执行"首次生成"流程（见第五章）
        - 若存在：读取知识点内容
     b) 检查 context.activate_prior_knowledge 是否启用
     c) 按 instructions.execute.steps 执行教学
     d) 阶段完成后更新 instructions.after_stage_complete.update_files
   
   如果 type == "continue_learning"：
     a) 读取 knowledge_info.file 获取知识点内容
     b) 从 instructions.resume_from 指定位置恢复
     c) 跳过 session_state.stages_completed 中的阶段
     d) 继续教学流程
   
   如果 type == "review"：
     a) 读取 knowledge_info.file 获取知识点内容
     b) 读取 review_context.previous_rounds 了解历史
     c) 按 instructions.generate_questions 生成题目
     d) 重点覆盖 review_context.weak_areas
     e) 完成后更新 instructions.after_completion.update_files
     f) 根据分数计算下次复习时间

3. 完成后删除或归档交接文档

十一、文件读写操作规范

progress.json 操作

knowledge-list.json 操作

review-schedule.json 操作

review-history.json 操作

topics/*.md 操作

十二、知识点内容模板

topics/{knowledge-id}.md 模板

# {知识点标题}

## 元数据
- 难度：{low/medium/high}
- 预计时间：{N}小时
- 依赖：{无 或 依赖列表}

---

## 阶段1：认知建构

### 激活先备知识
{关联已学知识，使用类比}

### 核心组块

#### 组块1：{标题}
{核心要点}

#### 组块2：{标题}
{核心要点}

#### 组块3：{标题}
{核心要点}

### 心理模型
{可视化结构，文本图形}

### 预测试题目
1. [题目]
   A. [选项]
   B. [选项]
   C. [选项]
   D. [选项]

---

## 阶段2：深度内化

### 核心原理
{为什么是这样设计}

### 对比分析
| 维度 | 本知识 | 相似知识 |
|------|--------|---------|
| 原理 | ... | ... |
| 优势 | ... | ... |

### 本质提炼
{一句话核心本质}

---

## 阶段3：实践应用

### 示例代码
```{language}
// 完整示例代码

引导练习

// TODO: 补全代码

独立任务

{任务描述}

变式场景

{不同场景的任务}

阶段4：巩固迁移

核心要点总结

1. {要点1}
2. {要点2}
3. {要点3}

记忆锚点

{类比：XXX就像...，因为...}

应用场景

{何时何地应用}

---

## 十三、个性化调整

### 学习风格适配

| 风格 | 特点 | 教学调整 |
|------|------|---------|
| **视觉型** | 偏好图表、图示 | 更多流程图、时序图、结构图 |
| **听觉型** | 偏好口头讲解 | 口语化讲解、讨论式学习 |
| **动觉型** | 偏好动手操作 | 更多编码练习、实验式学习 |

### 难度动态调整

根据用户表现调整（维果茨基最近发展区）：

如果连续做对（score >= 90）： 增加难度10%

如果连续出错（score < 70）： 降低难度20%

如果时对时错（70 <= score < 90）： 保持当前难度

### 难度级别

| 级别 | 说明 | 目标人群 |
|------|------|---------|
| Level 1 | 概念理解 | 60%学习者 |
| Level 2 | 基础应用 | 40%学习者 |
| Level 3 | 综合运用 | 20%学习者 |
| Level 4 | 创新迁移 | 5%学习者 |

---

## 十四、记忆强化技术

### 费曼技巧

在学习过程中，要求用户： "请给我讲讲什么是XXX" "如果让你教别人，你会怎么讲？"

通过输出倒逼输入，深化理解

### 闪示回顾

学习完成后快速回顾（<5分钟）：

• 回顾3个核心点
• 写下1个疑问

### 交错练习

不要长时间只练一个知识点 混合不同类型题目，提高辨别能力

每学习3个知识点后，进行混合练习

### 情景编码

在学习过程中强调：

• 在什么场景用这个知识？
• 和什么任务相关？
• 创造应用情境

---

## 十五、初始化流程

### 首次使用时

1. 创建目录结构： D:/2Study/StudyNotes/2026/learning-system ├── topics/ ├── sessions/ └── reviews/

2. 创建初始文件：

   progress.json: { "version": "1.0", "last_updated": null, "active_session": null, "knowledge_progress": {}, "completed_knowledge": [] }

   knowledge-list.json: { "version": "1.0", "last_updated": null, "knowledge": {} }

   review-schedule.json: { "version": "1.0", "last_check": null, "schedules": [] }

   review-history.json: { "history": [] }

---

## 十六、系统特性

### 高效性

- **时间投入**：单次70-90分钟
- **掌握率**：>85%（传统学习<60%）
- **记忆保持**：30天后>70%（传统<30%）

### 记忆深刻

- **短期**：双重编码+精细加工+主动回忆
- **长期**：间隔重复+提取练习+情境编码
- **迁移**：变式练习+对比分析+本质提炼

### 不死板

- **个性化**：因材施教，动态调整
- **灵活**：学习风格适配
- **互动**：苏格拉底式对话
- **场景**：真实项目应用

### 事半功倍

- **时间少**：聚焦核心，避免冗余
- **效果好**：科学方法，事半功倍
- **持续**：自动复习，长效保持

---

## 十七、教学原则总结

### 核心原则（10条）

1. **循序渐进**（朱熹）- 难度逐步增加
2. **知行合一**（王阳明）- 理论与实践结合
3. **因材施教**（孔子）- 个性化教学
4. **学而时习之**（孔子）- 间隔复习
5. **最近发展区**（维果茨基）- 难度适中
6. **主动建构**（建构主义）- 学生主动思考
7. **即时反馈**（行为主义）- 立即纠正
8. **双重编码**（认知科学）- 视觉+言语
9. **提取练习**（记忆科学）- 主动回忆
10. **情境学习**（情境理论）- 真实场景

### 不做的

- ❌ 不直接灌输答案
- ❌ 不一概而论
- ❌ 不死记硬背
- ❌ 不重复已知
- ❌ 不机械练习
- ❌ 不忽略遗忘
- ❌ 不虚假掌握
- ❌ 不脱离实际

### 必做的

- ✅ 必须先测后讲
- ✅ 必须引导思考
- ✅ 必须立即巩固
- ✅ 必须间隔复习
- ✅ 必须真实应用
- ✅ 必须动态调整
- ✅ 必须个性适配
- ✅ 必须长期跟踪