Add self-study-agent skill with feedback loop

- SKILL.md: Main skill definition with 20-iteration feedback loop
- config.yaml: Pipeline parameters (loop, sources, questions, adaptation)
- pipeline/: 5-step learning pipeline (topic selection → source discovery → extraction → synthesis → report)
- feedback/: 4 feedback mechanisms (self-testing, spaced repetition, interleaving, adaptation)
- Learning science principles: active recall, spaced repetition, desirable difficulty, interleaving, delayed feedback

README.md

@@ -0,0 +1,70 @@
+# Self-Study Agent
+
+자율 학습 파이프라인 스킬입니다. 학습 → 자기 평가 → 피드백 → 적응 루프를 통해 지식을 구축합니다.
+
+## 구조
+
+```
+skills/self-study-agent/
+├── SKILL.md                         # 메인 스킬 (전체 루프 개요)
+├── config.yaml                      # 파라미터 (루프 횟수, 문제 분포, etc.)
+├── pipeline/
+│   ├── 01-topic-selection.md        # 주제 선택 전략
+│   ├── 02-source-discovery.md       # 소스 발견
+│   ├── 03-extraction.md             # 지식 추출
+│   ├── 04-synthesis.md              # 지식 종합
+│   └── 05-session-report.md         # 세션 리포트
+└── feedback/
+    ├── self-testing.md              # 자기 평가 (문제 생성 + 답변 + 피드백)
+    ├── spaced-repetition.md         # 간격 반복 (FSRS)
+    ├── interleaving.md              # 교차 학습
+    └── adaptation.md                # 적응 로직 + 메트릭
+```
+
+## 학습 과학 원리 적용
+
+| 원리 | 설명 | 적용 |
+|------|------|------|
+| **능동적 회상** | 문제를 풀 때 메모리에서만 꺼냄 | self-testing.md |
+| **간격 반복** | FSRS 알고리즘으로 복습 스케줄 관리 | spaced-repetition.md |
+| **바람직한 난이도** | 정답률에 따라 난이도 자동 조절 | adaptation.md |
+| **교차 학습** | 한 세션에서 여러 주제 문제 혼합 출제 | interleaving.md |
+| **지연 피드백** | 에이전트가 피드백을 스스로 생성 | self-testing.md |
+
+## 루프 흐름
+
+```
+[Phase 1: 학습 세션]
+주제 선택 → 소스 발견 → 추출 → 종합 → 메모리 저장
+
+[Phase 2: 자기 평가 루프] (최대 20회)
+문제 생성 → 답변 시도 → 피드백 → 메모리 업데이트 → 다음 문제
+
+[종료 조건]
+- 정답률 95% 이상
+- 또는 20회 완료
+```
+
+## 사용법
+
+```bash
+# 주제 학습
+opencode task --agent self-study-agent --prompt "Study 'Rust async patterns' deeply"
+
+# 복습 세션
+opencode task --agent self-study-agent --prompt "Run review session"
+
+# 진행 상황 확인
+opencode task --agent self-study-agent --prompt "Show learning progress"
+```
+
+## 메모리 구조
+
+모든 학습은 지식 베이스로 구조화되어 저장됩니다:
+
+- **Concepts** — 개념 (정의, 예시, 연결)
+- **Facts** — 팩트 (진술, 증거, 출처)
+- **Procedures** — 절차 (단계, 숙련도)
+- **Code Patterns** — 코드 패턴 (언어, 코드, 설명)
+- **Test History** — 평가 이력 (문제, 답변, 정오)
+- **Adaptation Log** — 적응 기록 (전략 변경, 파라미터 조정)

skills/self-study-agent/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: self-study-agent
+description: "Autonomous self-study pipeline with feedback loop. Learn topics → test yourself → get feedback → adapt. Uses spaced repetition, interleaving, and desirable difficulty. Stores all knowledge in memory as a structured knowledge base."
+version: 3.0.0
+author: User
+tags: [learning, pipeline, feedback-loop, self-testing, spaced-repetition]
+dependencies: [websearch, webfetch]
+---
+
+# Self-Study Agent
+
+자율 학습 파이프라인입니다. 학습 → 자기 평가 → 피드백 → 적응 루프를 통해 지식을 구축합니다.
+
+**이 스킬은 학습과 평가만 담당합니다.** 메모리 저장은 에이전트가 처리합니다.
+
+## 전체 루프
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                    SELF-STUDY LOOP (최대 20회)                         │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                         │
+│  [Phase 1: 학습 세션]                                                   │
+│       │                                                                 │
+│       ▼                                                                 │
+│  주제 선택 → 소스 발견 → 추출 → 종합 → 메모리 저장                     │
+│                                                                         │
+│  [Phase 2: 자기 평가 루프] (최대 20회)                                 │
+│       │                                                                 │
+│       ▼                                                                 │
+│  문제 생성 → 답변 시도 → 피드백 → 메모리 업데이트 → 다음 문제          │
+│       │                                                                 │
+│       ├── 정답 → 신뢰도 ↑, 간격 증가                                   │
+│       │                                                                 │
+│       └── 오답 → 피드백, 약점 분석, 재학습 → 메모리 보강              │
+│                                                                         │
+│  [종료 조건]                                                            │
+│  - 정답률 95% 이상                                                     │
+│  - 또는 20회 완료                                                      │
+│                                                                         │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+## 파이프라인 단계
+
+| 단계 | 파일 | 설명 |
+|------|------|------|
+| 1 | `pipeline/01-topic-selection.md` | 주제 선택 (목표/호기심/트렌드/복습) |
+| 2 | `pipeline/02-source-discovery.md` | 소스 발견 (웹/학술/GitHub/문서) |
+| 3 | `pipeline/03-extraction.md` | 지식 추출 (개념/팩트/절차/코드) |
+| 4 | `pipeline/04-synthesis.md` | 지식 종합 (연결/요약/학습 목표) |
+| 5 | `pipeline/05-session-report.md` | 세션 리포트 출력 |
+
+## 피드백 루프 단계
+
+| 단계 | 파일 | 설명 |
+|------|------|------|
+| F1 | `feedback/self-testing.md` | 문제 생성 + 답변 + 피드백 |
+| F2 | `feedback/spaced-repetition.md` | 간격 반복 (FSRS 알고리즘) |
+| F3 | `feedback/interleaving.md` | 교차 학습 (주제 혼합 출제) |
+| F4 | `feedback/adaptation.md` | 적응 로직 + 메트릭 |
+
+## 실행 규칙
+
+1. **능동적 회상** — 문제를 풀 때 메모리에서만 꺼냄 (소스 접근 금지)
+2. **피드백은 에이전트가 생성** — 정오 판정 + 설명 + 관련 개념 링크
+3. **모든 학습은 메모리에 저장** — 구조화된 지식 베이스로 유지
+4. **간격 반복 적용** — FSRS 알고리즘으로 복습 스케줄 관리
+5. **교차 학습** — 한 세션에서 여러 주제 문제를 혼합 출제
+6. **바람직한 난이도** — 정답률에 따라 난이도 자동 조절
+7. **루프 20회 제한** — 충분한 학습 기회 보장
+
+## 메모리 구조 (지식 베이스)
+
+```
+Memory Store
+├── Concepts (개념)
+│   ├── id, title, definition, examples
+│   ├── connections: [related_concept_ids]
+│   ├── confidence: 0.0-1.0
+│   └── source_refs: [출처 참조]
+│
+├── Facts (팩트)
+│   ├── id, statement, evidence
+│   ├── confidence: 0.0-1.0
+│   └── source_refs: [출처 참조]
+│
+├── Procedures (절차)
+│   ├── id, name, steps
+│   ├── proficiency: 0.0-1.0
+│   └── practice_count: int
+│
+├── Code Patterns (코드 패턴)
+│   ├── id, language, code, explanation
+│   └── use_cases: [list]
+│
+├── Test History (평가 이력)
+│   ├── session_id, timestamp
+│   ├── questions: [question_id, type, difficulty, user_answer, is_correct]
+│   └── metrics: {accuracy, retention_rate, ...}
+│
+└── Adaptation Log (적응 기록)
+    ├── timestamp
+    ├── strategy_changes: [list]
+    └── parameter_adjustments: [list]
+```
+
+## 예시 흐름
+
+```
+[세션 1: 학습]
+주제: Rust Async
+소스: rust-lang.org, tokio.rs, 블로그
+추출: 12개 개념, 8개 팩트, 3개 절차, 5개 코드 패턴
+메모리 저장: 지식 베이스 구축
+
+[자기 평가 루프]
+1회: "Rust의 Future란?" → 정답 (신뢰도 0.6)
+2회: "Tokio에서 spawn은?" → 정답 (신뢰도 0.7)
+3회: "Async/Await의 차이점은?" → 오답 → 피드백 → 메모리 보강
+4회: "Polling이란?" → 정답 (신뢰도 0.65)
+...
+20회: 정답률 92% → 종료
+
+[최종 메모리]
+- 12개 개념 (평균 신뢰도 0.85)
+- 8개 팩트 (평균 신뢰도 0.90)
+- 3개 절차 (숙련도 0.75)
+- 5개 코드 패턴
+- 20회 평가 이력
+```

skills/self-study-agent/config.yaml

@@ -0,0 +1,88 @@
+# Self-Study Agent - 파이프라인 파라미터
+
+# 루프 설정
+loop:
+  max_iterations: 20
+  early_exit_accuracy: 0.95
+
+# 주제 선택
+topic_selection:
+  strategy: "balanced"
+  user_goals: []
+
+# 소스 발견
+sources:
+  channels:
+    web_search: true
+    academic: true
+    github: true
+    documentation: true
+    local_files: false
+  max_per_channel: 5
+  max_total: 10
+
+# 추출
+extraction:
+  model: "small"
+  max_sources: 5
+  cross_reference: true
+  min_sources_for_fact: 2
+
+# 문제 생성
+question_generation:
+  # 문제 유형 비중
+  type_distribution:
+    direct_recall: 0.4      # 직접 회상
+    application: 0.3        # 적용 질문
+    variation: 0.2          # 변형 질문
+    connection: 0.1         # 연결 질문
+
+  # 난이도 분포
+  difficulty_distribution:
+    easy: 0.3
+    medium: 0.4
+    hard: 0.3
+
+  # 세션당 문제 수
+  questions_per_session: 10
+
+# 피드백
+feedback:
+  # 피드백 생성 규칙
+  include_explanation: true
+  include_related_concepts: true
+  include_source_reference: true
+  include_suggested_review: true
+
+# 간격 반복 (FSRS)
+spaced_repetition:
+  algorithm: "FSRS"
+  fsrs_params: [0.4, 0.6, 2.4, 5.8, 4.93, 0.94, 0.86, 0.01, 1.49, 0.14, 0.94, 2.18, 0.05, 0.34, 1.26, 0.29, 2.61]
+  min_interval_days: 1
+  max_interval_days: 365
+  target_retention: 0.9
+
+# 교차 학습
+interleaving:
+  enabled: true
+  mix_previous_sessions: 3   # 이전 세션 주제 포함 수
+  mix_ratio: 0.3             # 이전 주제 비중
+
+# 적응
+adaptation:
+  # 정답률 기반 적응
+  low_accuracy_threshold: 0.5
+  high_accuracy_threshold: 0.9
+  low_accuracy_consecutive: 3
+  high_accuracy_consecutive: 5
+
+  # 난이도 조절
+  difficulty_adjustment:
+    enabled: true
+    min_difficulty: 0.1
+    max_difficulty: 0.9
+
+  # 문제 유형 조절
+  type_adjustment:
+    enabled: true
+    weak_type_boost: 0.1     # 약한 유형 비중 증가

skills/self-study-agent/feedback/adaptation.md

@@ -0,0 +1,172 @@
+# F4: 적응 로직 (Adaptation)
+
+## 개요
+
+자기 평가 결과를 분석하여 다음 세션의 전략과 파라미터를 자동 조절합니다.
+
+## 메트릭 정의
+
+### 핵심 메트릭
+
+| 메트릭 | 계산 방법 | 목표 |
+|--------|-----------|------|
+| **정답률** | 정답 수 / 전체 문제 수 | ≥ 0.85 |
+| **유형별 정답률** | 유형별 정답 수 / 유형별 문제 수 | ≥ 0.70 |
+| **주제별 정답률** | 주제별 정답 수 / 주제별 문제 수 | ≥ 0.70 |
+| **난이도별 정답률** | 난이도별 정답 수 / 난이도별 문제 수 | 0.6-0.8 |
+| **간격 유지율** | 예정된 복습 수행 비율 | ≥ 0.80 |
+| **개념 연결도** | 연결된 개념 비율 | ≥ 0.30 |
+
+### 메트릭 수집
+
+각 자기 평가 루프 후 메트릭 계산:
+
+```json
+{
+  "session_id": "session_001",
+  "iteration": 5,
+  "metrics": {
+    "accuracy": 0.75,
+    "type_accuracy": {
+      "direct_recall": 0.85,
+      "application": 0.70,
+      "variation": 0.65,
+      "connection": 0.80
+    },
+    "topic_accuracy": {
+      "rust_async": 0.80,
+      "ownership": 0.70
+    },
+    "difficulty_accuracy": {
+      "easy": 0.95,
+      "medium": 0.75,
+      "hard": 0.55
+    },
+    "concepts_mastered": 8,
+    "concepts_total": 12
+  }
+}
+```
+
+## 적응 로직
+
+### 1. 정답률 기반 적응
+
+```
+if 정답률 < 0.5 and 연속 3회:
+    → 난이도 하향
+    → 학습 속도 감소
+    → 쉬운 문제 비중 증가
+
+if 정답률 > 0.9 and 연속 5회:
+    → 난이도 상향
+    → 새로운 주제 탐색
+    → 어려운 문제 비중 증가
+```
+
+### 2. 유형별 적응
+
+```
+for each 유형 in [직접 회상, 적용, 변형, 연결]:
+    if 유형별 정답률 < 0.5:
+        → 해당 유형 문제 비중 증가 (+0.1)
+    elif 유형별 정답률 > 0.9:
+        → 해당 유형 문제 비중 감소 (-0.05)
+```
+
+### 3. 난이도 적응
+
+```
+if 쉬운 문제 정답률 > 0.95:
+    → 보통 문제 비중 증가
+
+if 보통 문제 정답률 > 0.85:
+    → 어려운 문제 비중 증가
+
+if 어려운 문제 정답률 < 0.4:
+    → 어려운 문제 비중 감소
+    → 보통 문제 비중 증가
+```
+
+### 4. 주제별 적응
+
+```
+for each 주제 in 메모리:
+    if 주제별 정답률 < 0.6:
+        → 해당 주제 재학습 세션 추가
+    elif 주제별 정답률 > 0.9:
+        → 해당 주제 심화 탐색
+```
+
+## 파라미터 조절
+
+### 문제 생성 파라미터
+
+```json
+{
+  "type_distribution": {
+    "direct_recall": 0.4,
+    "application": 0.3,
+    "variation": 0.2,
+    "connection": 0.1
+  },
+  "difficulty_distribution": {
+    "easy": 0.3,
+    "medium": 0.4,
+    "hard": 0.3
+  }
+}
+```
+
+### 적응 예시
+
+```
+원래: direct_recall=0.4, application=0.3, variation=0.2, connection=0.1
+적용 질문 정답률 0.45 (낮음):
+→ direct_recall=0.35, application=0.35, variation=0.2, connection=0.1
+
+어려운 문제 정답률 0.35 (낮음):
+→ easy=0.35, medium=0.45, hard=0.20
+```
+
+## 적응 이력
+
+적응 변경 시 메모리에 기록:
+
+```json
+{
+  "adaptation_log": [
+    {
+      "timestamp": "2024-01-10T10:00:00Z",
+      "trigger": "low_accuracy_variation",
+      "changes": {
+        "type_distribution.variation": {"old": 0.2, "new": 0.25}
+      },
+      "reason": "변형 질문 정답률 0.45 (기준 미달)"
+    }
+  ]
+}
+```
+
+## 메모리 저장 형식
+
+```json
+{
+  "current_strategy": {
+    "type_distribution": {...},
+    "difficulty_distribution": {...},
+    "interleaving_ratio": 0.3
+  },
+  "adaptation_history": [...],
+  "metrics_history": [
+    {
+      "iteration": 1,
+      "accuracy": 0.60
+    },
+    {
+      "iteration": 5,
+      "accuracy": 0.75
+    }
+  ]
+}
+```

skills/self-study-agent/feedback/interleaving.md

@@ -0,0 +1,95 @@
+# F3: 교차 학습 (Interleaving)
+
+## 개요
+
+여러 주제를 섞어서 학습하면 단일 주제를 반복하는 것보다 장기 기억이 40% 향상됩니다.
+
+## 적용 방법
+
+### 세션 내 교차
+
+한 자기 평가 세션에서 여러 주제의 문제를 혼합 출제:
+
+```
+세션 문제 구성:
+- 현재 주제 문제: 70%
+- 이전 세션 주제 문제: 30%
+```
+
+### 세션 간 교차
+
+이전 세션에서 학습한 주제를 현재 세션에 포함:
+
+```
+예시:
+- 세션 1: Rust Async 학습
+- 세션 2: Tokio Internals 학습
+- 세션 2 자기 평가:
+  - Tokio 문제: 70%
+  - Rust Async 문제: 30% (세션 1에서 학습)
+```
+
+## 문제 구성 알고리즘
+
+### 1단계: 현재 주제 문제 생성
+
+현재 학습한 주제에서 문제 생성 (70%)
+
+### 2단계: 이전 주제 문제 선택
+
+메모리에서 이전 세션 주제를 검색하고, 복습 예정 카드에서 문제 선택 (30%)
+
+### 3단계: 문제 셔플
+
+모든 문제를 무작위 순서로 셔플
+
+## 이전 주제 선택 기준
+
+| 기준 | 가중치 |
+|------|--------|
+| 복습 예정일이 가까운 순 | 높음 |
+| 이전 정답률이 낮은 순 | 높음 |
+| 개념 연결이 많은 순 | 중간 |
+| 최근 학습한 순 | 낮음 |
+
+## 교차 비중 조절
+
+### 설정
+
+```yaml
+interleaving:
+  enabled: true
+  mix_previous_sessions: 3   # 이전 세션 주제 포함 수
+  mix_ratio: 0.3             # 이전 주제 비중
+```
+
+### 적응적 조절
+
+- 현재 주제 정답률 90%↑ → 이전 주제 비중 0.4로 증가
+- 현재 주제 정답률 50%↓ → 이전 주제 비중 0.2로 감소
+- 특정 이전 주제 오답률 높음 → 해당 주제 비중 증가
+
+## 메모리 저장 형식
+
+```json
+{
+  "session_topics": [
+    {
+      "topic_id": "rust_async",
+      "source_session": 1,
+      "question_count": 7,
+      "correct_count": 6
+    },
+    {
+      "topic_id": "tokio_internals",
+      "source_session": 2,
+      "question_count": 3,
+      "correct_count": 2
+    }
+  ],
+  "interleaving_stats": {
+    "mix_ratio": 0.3,
+    "cross_session_accuracy": 0.83
+  }
+}
+```

skills/self-study-agent/feedback/self-testing.md

@@ -0,0 +1,155 @@
+# F1: 자기 평가 (Self-Testing)
+
+## 개요
+
+메모리에 있는 지식으로 문제를 생성하고, 메모리에서만 답변하여 테스트하는 루프입니다.
+
+## 루프 구조
+
+```
+최대 20회 반복:
+  1. 문제 생성
+  2. 답변 시도 (메모리만 사용)
+  3. 피드백 생성 (에이전트 자체)
+  4. 메모리 업데이트
+  5. 적응 (난이도/유형 조절)
+
+종료 조건:
+  - 정답률 95% 이상
+  - 또는 20회 완료
+```
+
+## Step 1: 문제 생성
+
+### 문제 유형과 비중
+
+| 유형 | 비중 | 설명 | 예시 |
+|------|------|------|------|
+| **직접 회상** | 40% | 정의, 개념, 사실 묻기 | "Rust의 Ownership이란?" |
+| **적용 질문** | 30% | 실제 상황에서의 활용 | "이 상황에서 Ownership을 어떻게 사용?" |
+| **변형 질문** | 20% | 같은 내용 다른 표현 (암기 방지) | "Ownership의 장단점은?" |
+| **연결 질문** | 10% | 개념 간 관계 묻기 | "Ownership과 Borrowing의 관계는?" |
+
+### 난이도 분포
+
+| 난이도 | 비중 | 기준 |
+|--------|------|------|
+| **쉬움** | 30% | 단순 회상, 정의, 사실 |
+| **보통** | 40% | 적용, 분석 |
+| **어려움** | 30% | 종합, 평가, 창의적 사고 |
+
+### 문제 생성 규칙
+
+1. 메모리에서 주제 관련 지식 추출
+2. 각 개념/팩트에 대해 문제 생성
+3. 유형별 비중 준수
+4. 난이도별 비중 준수
+5. 이전 오답 유형 고려 (약한 유형 비중 증가)
+
+### 문제 생성 프롬프트
+
+```
+메모리에 있는 "{topic}" 관련 지식으로 문제를 생성하십시오.
+
+문제 유형: {type} (직접 회상/적용/변형/연결)
+난이도: {difficulty} (쉬움/보통/어려움)
+
+규칙:
+- 메모리에서만 답변할 수 있어야 함
+- 명확하고 구체적인 문제
+- 부분 정답 가능하도록 설계
+- 관련 개념과 연결된 문제 선호
+
+문제:
+```
+
+## Step 2: 답변 시도
+
+### 규칙
+
+1. **메모리에서만 정보 꺼냄** — 외부 소스 접근 금지
+2. **생각하는 과정 표시** — 어떤 지식을 기반으로 답변하는지
+3. **확신도 표시** — 0-100% 확신도
+
+### 답변 형식
+
+```json
+{
+  "question_id": "q_001",
+  "user_answer": "사용자의 답변",
+  "confidence": 85,
+  "thinking_process": "메모리에서 X 개념과 Y 팩트를 기반으로 답변"
+}
+```
+
+## Step 3: 피드백 생성
+
+### 피드백 생성 규칙
+
+에이전트가 직접 피드백을 생성합니다:
+
+1. **정답 여부 판단**
+   - 핵심 키워드 포함 여부
+   - 개념적 정확성
+   - 부분 정답 처리
+
+2. **피드백 내용**
+   - 정답: "맞습니다. {설명}"
+   - 오답: "틀렸습니다. 정답은 {정답}입니다. {왜 그런지 설명}"
+   - 부분 정답: "부분적으로 맞습니다. {맞은 부분}은 정확하지만, {틀린 부분}은..."
+
+3. **관련 개념 링크**
+   - 틀린 문제의 관련 개념 자동 식별
+   - "이 문제는 {개념A}, {개념B}와 연결되어 있습니다"
+
+4. **추가 학습 제안**
+   - "이 부분을 더 공부하려면 {추천 자료}를 확인하세요"
+
+### 피드백 형식
+
+```json
+{
+  "question_id": "q_001",
+  "is_correct": false,
+  "partial_credit": 0.5,
+  "feedback": "틀렸습니다. 정답은 'Rust의 Ownership은 메모리 안전성을 보장하는 시스템으로, 각 값에 대해 하나의 소유자가 존재합니다'입니다.",
+  "explanation": "Ownership은 Rust의 핵심 개념으로...",
+  "related_concepts": ["Borrowing", "Lifetimes", "Move Semantics"],
+  "source_reference": "https://doc.rust-lang.org/book/ch04-01.html",
+  "suggested_review": "Rust Book Chapter 4.1을 다시 읽어보세요"
+}
+```
+
+## Step 4: 메모리 업데이트
+
+### 정답 시
+
+```json
+{
+  "concept_id": "concept_001",
+  "confidence": 0.85,
+  "last_reviewed": "timestamp",
+  "next_review": "FSRS 알고리즘으로 계산",
+  "correct_count": 5,
+  "total_count": 6
+}
+```
+
+### 오답 시
+
+```json
+{
+  "concept_id": "concept_001",
+  "confidence": 0.4,
+  "last_reviewed": "timestamp",
+  "next_review": "1일 후 (간격 초기화)",
+  "correct_count": 2,
+  "total_count": 6,
+  "weak_points": ["관련 개념1", "관련 개념2"],
+  "review_notes": "추가 학습 필요"
+}
+```
+
+## Step 5: 적응
+
+`feedback/adaptation.md` 참조

skills/self-study-agent/feedback/spaced-repetition.md

@@ -0,0 +1,140 @@
+# F2: 간격 반복 (Spaced Repetition)
+
+## FSRS 알고리즘
+
+### 기본 원리
+
+간격 반복은 정보를 점점 더 긴 간격으로 반복하여 장기 기억을 강화하는 기법입니다.
+
+### FSRS 파라미터
+
+```
+w = [0.4, 0.6, 2.4, 5.8, 4.93, 0.94, 0.86, 0.01, 1.49, 0.14, 0.94, 2.18, 0.05, 0.34, 1.26, 0.29, 2.61]
+```
+
+### 간격 계산
+
+**새 카드:**
+- 최초 학습 후: 1일
+- 첫 번째 복습 후: 3-7일 (난이도 기반)
+- 두 번째 복습 후: 7-30일
+- 이후: 지수적 증가 (최대 365일)
+
+**Rating별 간격:**
+
+| Rating | 의미 | 간격 조정 |
+|--------|------|-----------|
+| `again` | 잊어버림 | 간격 초기화 (1일) |
+| `hard` | 노력해서 회상 | 간격 × 1.2 |
+| `good` | 정확히 회상 | 간격 × FSRS 공식 |
+| `easy` | 쉽게 회상 | 간격 × 1.3 × FSRS 공식 |
+
+### 안정성(Stability) 계산
+
+```
+new_stability = stability * exp(
+  (w6 - w7 * delta) * (w8 - w9 * (rating-1)) * w10 +
+  (1 - w11) * exp(w12 - w13 * (rating-1))
+)
+```
+
+단, again일 때:
+```
+new_stability = w14 * max(stability * w15, 1) * min(new_stability, w16 * stability)
+```
+
+### 간격(Interval) 계산
+
+```
+interval = stability * target_retention
+interval = max(min_interval, min(interval, max_interval))
+```
+
+## 카드 관리
+
+### 카드 생성
+
+학습 세션에서 추출된 각 개념/팩트에 대해 자동 생성:
+
+```json
+{
+  "id": "card_001",
+  "concept_id": "concept_001",
+  "front": "Rust의 Ownership이란?",
+  "back": "메모리 안전성을 보장하는 시스템으로, 각 값에 대해 하나의 소유자가 존재합니다",
+  "difficulty": 0.6,
+  "interval_days": 0,
+  "due_date": "timestamp",
+  "reps": 0,
+  "lapses": 0
+}
+```
+
+### 카드 업데이트
+
+복습 후 FSRS 알고리즘에 따라 업데이트:
+
+```json
+{
+  "id": "card_001",
+  "interval_days": 7,
+  "due_date": "7일 후 timestamp",
+  "reps": 3,
+  "lapses": 0,
+  "stability": 2.5,
+  "retrievability": 0.85
+}
+```
+
+## 복습 세션
+
+### 복습할 카드 선택
+
+1. 오늘 예정된 카드 우선
+2. 연체된 카드 다음
+3. 새로운 카드는 설정된 수만큼 (기본 20개/일)
+
+### 복습 흐름
+
+```
+복습할 카드 목록
+    │
+    ▼
+각 카드에 대해:
+    │
+    ├── 문제 표시
+    │
+    ├── 답변 시도
+    │
+    ├── 정답 확인
+    │
+    └── Rating 선택 (again/hard/good/easy)
+         │
+         └── 카드 간격 업데이트
+```
+
+## 메모리 저장 형식
+
+```json
+{
+  "cards": [
+    {
+      "id": "card_001",
+      "front": "...",
+      "back": "...",
+      "interval_days": 7,
+      "due_date": "2024-01-15",
+      "reps": 3,
+      "lapses": 0,
+      "stability": 2.5
+    }
+  ],
+  "stats": {
+    "total_cards": 100,
+    "due_today": 15,
+    "due_this_week": 45,
+    "overdue": 5,
+    "retention_rate": 0.88
+  }
+}
+```

skills/self-study-agent/pipeline/01-topic-selection.md

@@ -0,0 +1,31 @@
+# Step 1: 주제 선택
+
+## 전략
+
+| 전략 | 선택 방법 |
+|------|-----------|
+| **목표 기반** | 사용자가 설정한 목표 중 미완료된 첫 번째 주제 |
+| **호기심 기반** | 메모리에서 연결이 적은 개념을 찾아 탐색 |
+| **트렌드 기반** | GitHub 트렌딩, arXiv 최신, 기술 뉴스에서 주제 탐색 |
+| **복습 기반** | 복습 예정 카드가 많은 주제 우선 선택 |
+| **균형** | 모든 전략을 가중치로 종합하여 최고 점수 주제 선택 |
+
+## 선택 규칙
+
+1. 메모리에 이미 많은 지식이 있는 주제는 우선순위 낮춤
+2. 이전 세션에서 오답률이 높았던 주제는 우선순위 높임
+3. 새로 탐색한 주제와 기존 주제를 연결할 수 있는 주제 선호
+
+## 출력
+
+```
+{
+  "id": "unique_topic_id",
+  "title": "주제 제목",
+  "domain": "프로그래밍| Machine Learning| 과학| 일반",
+  "keywords": ["키워드1", "키워드2"],
+  "depth": "shallow|medium|deep",
+  "prerequisites": ["선행 주제 id"],
+  "goals": ["학습 목표1"]
+}
+```

skills/self-study-agent/pipeline/02-source-discovery.md

@@ -0,0 +1,50 @@
+# Step 2: 소스 발견
+
+## 소스 채널
+
+| 채널 | 사용 시점 | 도구 |
+|------|-----------|------|
+| **웹 검색** | 모든 주제 | `websearch` |
+| **학술** | 연구 주제 (ML, 과학) | `websearch` (arXiv, Semantic Scholar) |
+| **GitHub** | 기술 주제 (프로그래밍, DevOps) | `websearch` (GitHub) |
+| **공식 문서** | 도구/프레임워크 | `webfetch` (공식 사이트) |
+| **로컬 파일** | 로컬 코드베이스 탐색 시 | 파일 시스템 검색 |
+
+## 소스 선택 규칙
+
+1. 채널별 상위 5-10개 결과 수집
+2. 각 소스의 신뢰도 평가:
+   - 공식/권위 있는 소스인지
+   - 최근 2년 이내 자료인지
+   - 인용수/커뮤니티 검증이 있는지
+   - 다른 소스에서 교차 참조되는지
+3. URL 기준 중복 제거
+4. 신뢰도 점수로 정렬
+5. 상위 N개 소스 반환 (기본: 5개)
+
+## 신뢰도 점수 계산
+
+```
+credibility = (
+  domain_authority * 0.3 +
+  recency_score * 0.2 +
+  citation_score * 0.15 +
+  peer_reviewed * 0.15 +
+  official_source * 0.1 +
+  cross_referenced * 0.1
+)
+```
+
+## 출력
+
+```
+[
+  {
+    "id": "source_id",
+    "url": "https://...",
+    "title": "소스 제목",
+    "type": "web_page|documentation|academic_paper|github_repo|blog_post",
+    "credibility": 0.85
+  }
+]
+```

skills/self-study-agent/pipeline/03-extraction.md

@@ -0,0 +1,79 @@
+# Step 3: 지식 추출
+
+## 추출 프로세스
+
+각 소스에 대해:
+
+1. **가져오기** — `webfetch` 도구로 콘텐츠 수집
+2. **파싱** — HTML → 텍스트, 보일러플레이트 제거
+3. **청킹** — 논리적 섹션별 분할 (제목, 단락, 코드 블록)
+4. **추출** — LLM으로 구조화된 지식 추출
+
+## 추출 프롬프트
+
+```
+다음 콘텐츠에서 "{topic.title}"에 대한 구조화된 지식을 추출하십시오.
+
+JSON 형식으로 반환:
+{
+  "concepts": [
+    {
+      "title": "개념 이름",
+      "definition": "명확한 정의",
+      "examples": ["예시1", "예시2"],
+      "related": ["관련 개념1", "관련 개념2"]
+    }
+  ],
+  "facts": [
+    {
+      "statement": "팩트 진술",
+      "evidence": "출처에서의 인용",
+      "confidence": 0.9
+    }
+  ],
+  "procedures": [
+    {
+      "name": "절차 이름",
+      "description": " 설명",
+      "steps": ["단계1", "단계2", "단계3"]
+    }
+  ],
+  "code_patterns": [
+    {
+      "language": "python",
+      "pattern_name": "패턴 이름",
+      "code": "코드",
+      "explanation": "설명"
+    }
+  ]
+}
+
+콘텐츠:
+{source.content}
+```
+
+## 교차 검증
+
+1. 여러 소스에서 추출된 팩트를 비교
+2. 일치하지 않는 내용 표시
+3. 2개 이상 소스에서 확인된 팩트만 신뢰도 높음으로 처리
+
+## 신뢰도 점수
+
+- 단일 소스 확인: confidence = 0.5
+- 2개 소스 확인: confidence = 0.7
+- 3개 이상 소스 확인: confidence = 0.9
+- 소스 간 불일치: confidence = 0.3
+
+## 출력
+
+```
+{
+  "concepts": [...],
+  "facts": [...],
+  "procedures": [...],
+  "code_patterns": [...],
+  "source_id": "source_id",
+  "extraction_confidence": 0.7
+}
+```

skills/self-study-agent/pipeline/04-synthesis.md

@@ -0,0 +1,48 @@
+# Step 4: 지식 종합
+
+## 종합 프로세스
+
+여러 소스에서 추출된 지식을 통합:
+
+1. **중복 제거** — 제목/진술 기준 동일 개념/팩트 통합
+2. **병합** — 높은 신뢰도 유지, 소스 결합
+3. **연결** — 개념 간 관계 찾기 (전제, 예시, 대비, 구현 등)
+4. **요약** — 핵심 학습 내용 요약 생성
+5. **학습 목표** — 학습자가 할 수 있어야 할 것 목록
+6. **복습 질문** — 각 개념을 테스트할 수 있는 질문
+
+## 개념 연결 유형
+
+| 관계 | 설명 | 예시 |
+|------|------|------|
+| `prerequisite` | A를 알아야 B를 이해 | "변수" → "함수" |
+| `example` | A는 B의 예시 | " 리스트 컴프리헨션" → "파이썬" |
+| `contrast` | A와 B는 대비 | "동기" vs "비동기" |
+| `implements` | A는 B를 구현 | "Tokio" → "비동기 런타임" |
+| `uses` | A가 B를 사용 | "FastAPI" → "Pydantic" |
+
+## 학습 목표 생성
+
+각 개념에 대해 Bloom's Taxonomy 기반 학습 목표 생성:
+- **기억**: ~를 설명할 수 있다
+- **이해**: ~와 ~의 차이를 설명할 수 있다
+- **적용**: ~를 사용하여 ~를 구현할 수 있다
+- **분석**: ~의 장단점을 분석할 수 있다
+- **평가**: ~와 ~를 비교하여 선택할 수 있다
+- **창작**: ~를 조합하여 ~를 만들 수 있다
+
+## 출력
+
+```
+{
+  "summary": "종합 요약",
+  "key_concepts": [...],
+  "key_facts": [...],
+  "key_procedures": [...],
+  "connections": [
+    {"from": "concept_id", "to": "concept_id", "relation": "prerequisite"}
+  ],
+  "learning_objectives": [...],
+  "review_questions": [...]
+}
+```

skills/self-study-agent/pipeline/05-session-report.md

@@ -0,0 +1,60 @@
+# Step 5: 세션 리포트
+
+## 리포트 형식
+
+```markdown
+## 학습 세션: {topic.title}
+
+### 소스 정보
+| # | 소스 | 유형 | 신뢰도 |
+|---|------|------|--------|
+| 1 | {title} | {type} | {score} |
+
+### 추출된 지식
+- **개념**: {count}개
+- **팩트**: {count}개
+- **절차**: {count}개
+- **코드 패턴**: {count}개
+
+### 핵심 개념
+1. **{concept.title}**: {concept.definition}
+2. ...
+
+### 개념 연결
+- {개념A} → (전제) → {개념B}
+- {개념C} → (예시) → {개념D}
+- ...
+
+### 학습 목표
+- [ ] {학습 목표1}
+- [ ] {학습 목표2}
+- ...
+
+### 복습 질문 (미리보기)
+1. {question1}
+2. {question3}
+3. ...
+
+### 다음 단계
+- 자기 평가 루프 시작
+- 예상 문제 수: {count}개
+- 예상 소요 시간: {minutes}분
+```
+
+## 메모리 저장 형식
+
+리포트 생성 후, 다음 형식으로 메모리에 저장:
+
+```json
+{
+  "session_id": "session_id",
+  "topic": "topic_title",
+  "concepts": [...],
+  "facts": [...],
+  "procedures": [...],
+  "code_patterns": [...],
+  "connections": [...],
+  "source_refs": [...],
+  "timestamp": "ISO timestamp"
+}
+```