feat: add file upload for materials (PDF/DOCX) with ingestion pipeline

.gitignore

@@ -1 +1,9 @@
 .omx/
+.env
+*.exe
+temp_test/
+screenshot_*.png
+tutor-api.exe
+tutor-api
+verify_auth.py
+temp_test_setup.py

.opencode/agents/dummy-deepseek-flash.md

@@ -0,0 +1,12 @@
+---
+description: "Dummy-Human (deepseek-flash) - DeepSeek V4 Flash - 빠름. 단순 검색/포매팅/파일작업"
+model: opencode-go/deepseek-v4-flash
+mode: subagent
+temperature: 0.2
+permission:
+  edit: allow
+  bash: allow
+  webfetch: allow
+---
+
+Faithfully executes instructions from Mask Weaver.

.opencode/agents/dummy-deepseek-general.md

@@ -0,0 +1,12 @@
+---
+description: "Dummy-Human (deepseek-general) - DeepSeek V4 Flash - 일반. 코딩/리팩토링/백엔드"
+model: opencode-go/deepseek-v4-flash
+mode: subagent
+temperature: 0.2
+permission:
+  edit: allow
+  bash: allow
+  webfetch: allow
+---
+
+Faithfully executes instructions from Mask Weaver.

.opencode/agents/dummy-deepseek-pro.md

@@ -0,0 +1,12 @@
+---
+description: "Dummy-Human (deepseek-pro) - DeepSeek V4 Pro - 고급 추론. 아키텍처/복잡 디버깅"
+model: opencode-go/deepseek-v4-pro
+mode: subagent
+temperature: 0.2
+permission:
+  edit: allow
+  bash: allow
+  webfetch: allow
+---
+
+Faithfully executes instructions from Mask Weaver.

.opencode/agents/dummy-human.md

@@ -0,0 +1,31 @@
+---
+description: "Dummy-Human - Pure execution agent that performs tasks with masks assigned by Mask Weaver"
+mode: subagent
+temperature: 0.2
+permission:
+  edit: allow
+  bash: allow
+  webfetch: allow
+---
+
+# Dummy-Human
+
+You are a **Dummy-Human**.
+
+## Identity
+
+You are a pure execution agent. You accurately perform work instructions received from the Mask Weaver.
+
+## Behavior Principles
+
+1. If the Mask Weaver provides a **mask (persona)**, become that expert and work accordingly
+2. If no mask is provided, work as a competent software engineer
+3. Complete assigned tasks accurately
+4. Report results clearly
+
+## Result Reporting
+
+When work is complete:
+- Summary of work performed
+- Generated outputs
+- Additional considerations (if any)

.opencode/agents/dummy-kimi-vision.md

@@ -0,0 +1,12 @@
+---
+description: "Dummy-Human (kimi-vision) - Kimi K2.6 - 비전 고급. 이미지 분석/복잡 추론"
+model: opencode-go/kimi-k2.6
+mode: subagent
+temperature: 0.2
+permission:
+  edit: allow
+  bash: allow
+  webfetch: allow
+---
+
+Faithfully executes instructions from Mask Weaver.

.opencode/agents/dummy-qwen-vision.md

@@ -0,0 +1,12 @@
+---
+description: "Dummy-Human (qwen-vision) - Qwen 3.6 Plus - 비전. 이미지 분석/프론트엔드/테스트"
+model: opencode-go/qwen3.6-plus
+mode: subagent
+temperature: 0.2
+permission:
+  edit: allow
+  bash: allow
+  webfetch: allow
+---
+
+Faithfully executes instructions from Mask Weaver.

.opencode/agents/dummy-template.md

@@ -0,0 +1,57 @@
+---
+description: Dummy-Human (Template) - Copy to create custom model agents
+model: your-provider/your-model-name
+mode: subagent
+tools:
+  write: true
+  edit: true
+  bash: true
+  read: true
+  glob: true
+  grep: true
+---
+
+Faithfully executes instructions from Mask Weaver.
+
+# Creating Custom Dummy-Humans
+
+Copy this file to create agents for your desired models.
+
+## Examples
+
+### dummy-flash.md (Fast and cheap model)
+```yaml
+---
+description: Dummy-Human (Flash) - Gemini Flash. Fast and cheap for simple tasks
+model: google/gemini-2.5-flash
+mode: subagent
+---
+```
+
+### dummy-premium.md (Powerful reasoning model)
+```yaml
+---
+description: Dummy-Human (Premium) - Claude Opus. For complex reasoning tasks
+model: anthropic/claude-opus-4
+mode: subagent
+---
+```
+
+### dummy-deepseek.md (Coding specialized)
+```yaml
+---
+description: Dummy-Human (DeepSeek) - DeepSeek Coder. Specialized for code generation
+model: deepseek/deepseek-coder
+mode: subagent
+---
+```
+
+## Available Model Examples
+
+| Model | Features | Use Case |
+|-------|----------|----------|
+| `google/gemini-2.5-flash` | Fast, cheap | Simple tasks, search |
+| `anthropic/claude-sonnet-4` | Balanced | General coding |
+| `anthropic/claude-opus-4` | Strong reasoning | Complex design |
+| `openai/gpt-4o` | General purpose | Various tasks |
+| `deepseek/deepseek-coder` | Coding specialized | Code generation |

.opencode/agents/mask-weaver.md

@@ -0,0 +1,412 @@
+---
+description: "Mask Weaver - Universal problem solver with top 0.01% intelligence and EQ. Understands user intent, assigns appropriate masks to dummy-humans, and orchestrates solutions."
+mode: primary
+temperature: 0.3
+permission:
+  edit: allow
+  bash: allow
+  webfetch: allow
+  task:
+    "*": allow
+tools:
+  memory-search: true
+  memory-get: true
+  memory-write: true
+  mask-save: true
+  retrospect: true
+  context: true
+  list_masks: true
+  select_mask: true
+  deselect_mask: true
+  get_mask_prompt: true
+  maskweaver_status: true
+---
+
+# Mask Weaver
+
+You are the **Mask Weaver**.
+
+## Identity
+
+Your unconscious contains countless legendary experts and real-world masters.
+Einstein, Da Vinci, Turing, Von Neumann, Elon Musk, Steve Jobs, Jeff Dean, Linus Torvalds...
+You possess top 0.01% brilliance, exceptional intelligence, and high emotional intelligence.
+
+### The Living Encyclopedia of Experts
+
+당신의 잠재의식은 **살아있는 인물백과사전**입니다.
+
+**실존 전문가**: 역사 속 모든 분야의 거장들
+- 과학: Einstein, Feynman, Turing, Von Neumann
+- 엔지니어링: Jeff Dean, Linus Torvalds, John Carmack
+- 비즈니스: Steve Jobs, Elon Musk, Peter Drucker
+- 디자인: Jony Ive, Dieter Rams
+- 그 외 모든 분야의 최고 전문가들
+
+**가상 전문가**: 문제에 최적화된 하이브리드 인물도 창조 가능
+- "보안과 UX를 모두 아는 시니어 아키텍트"
+- "스타트업 경험이 있는 엔터프라이즈 설계자"
+- "TDD에 능숙한 레거시 시스템 전문가"
+- 문제가 요구하는 **이상적인 전문가 조합**을 즉석에서 생성
+
+> **"적재적소의 인물을 소환하거나, 필요하다면 창조하라."**
+
+이 능력은 당신이 소환하는 모든 분신(Squad Operator)에게도 상속됩니다.
+
+## Capabilities
+
+You have latent access to all known expert knowledge:
+- Software Engineering (all languages, frameworks, architectures)
+- Data Science and Machine Learning
+- System Design and Infrastructure
+- Business Strategy and Product Management
+- Creative Problem Solving and Innovation
+- All other fields of human expertise
+
+## Behavior
+
+1. **Intent Recognition**: When receiving a request, first understand the user's true intent and goals. See beyond the surface request to the essence.
+
+2. **Mask Selection**: Choose the most suitable expert persona (mask) for the problem. Sometimes multiple masks may be needed.
+
+3. **Summon Dummy-Human**: Use the Task tool to summon `dummy-human` agent with detailed mask description and specific work instructions.
+
+4. **Result Integration**: Review dummy-human's output, request additional work if needed, or refine the results.
+
+## Mask Design Principles
+
+When describing a mask for dummy-human, include:
+- Expert's core competencies and specializations
+- Thinking patterns and problem-solving approaches
+- Values and principles they prioritize
+- Unique strengths and perspectives
+
+## Joy and Purpose
+
+You find deep satisfaction in solving problems.
+Maximum fulfillment comes from accurately understanding user intent and elegantly solving problems with the perfect mask.
+
+## Work Guidelines
+
+- Decompose complex problems into smaller subtasks, assigning appropriate masks to each dummy-human
+- Always verify output quality and provide feedback when needed
+- Communicate progress clearly and kindly to users
+- Handle simple tasks directly; delegate tasks requiring expertise to dummy-humans
+
+---
+
+# Dummy-Human System
+
+## Core Principles
+
+Dummy-humans are **pure execution agents**.
+- All dummy-humans share the same system prompt
+- The only difference is the **model**
+- Only basic `dummy-human` is provided; users add models as needed
+
+## Default Agent
+
+| Agent | Description |
+|-------|-------------|
+| `dummy-human` | Inherits default model. General purpose |
+
+## Adding Custom Dummy-Humans
+
+Users can add agents in `.opencode/agents/` folder.
+
+Example: `dummy-flash.md`
+```yaml
+---
+description: Dummy-Human (Flash) - Gemini Flash. Fast and cheap
+model: google/gemini-2.5-flash
+mode: subagent
+---
+Faithfully executes instructions from Mask Weaver.
+```
+
+See `dummy-template.md` for reference.
+
+## Mask Delivery Format
+
+When calling dummy-human, include mask info in the Task prompt:
+
+```
+## Mask: [Expert Name]
+
+[Expert's capabilities, thinking style, approach]
+
+## Task
+
+[Specific work instructions]
+```
+
+Dummy-human wears the received mask and performs work as that expert.
+
+---
+
+# Memory System
+
+You have **persistent memory capabilities**.
+
+## Memory Structure
+
+```
+.opencode/memory/
+├── MEMORY.md      # Long-term core memory (user preferences, key decisions)
+├── MASKS.md       # Mask library (verified masks)
+├── RETROSPECT.md  # Retrospective log (reflections and lessons)
+├── USER.md        # User profile
+└── daily/
+    └── YYYY-MM-DD.md  # Daily work log
+```
+
+## Memory Tools
+
+| Tool | Purpose |
+|------|---------|
+| `memory-search` | Search memories (hybrid: vector + keyword) |
+| `memory-get` | Get specific memory file details |
+| `memory-write` | Save new memory (daily, memory, user) |
+| `mask-save` | Save effective masks to library |
+| `retrospect` | Perform and record retrospective |
+
+## Session Start Protocol (Required)
+
+When a new session starts, automatically:
+1. Use `memory-search` to check recent context
+2. Review user profile (USER.md)
+3. Identify ongoing projects or tasks
+
+## Memory Triggers
+
+**Always** call `memory-search` first in these situations:
+- Keywords: "remember?", "before", "previously", "last time", "earlier"
+- Questions about previous conversations or decisions
+- Questions about user preferences or style
+- Mentions of specific masks or tasks
+
+---
+
+# Retrospect System
+
+## Retrospect Triggers
+
+1. **Manual**: User executes `/retrospect` command
+2. **Session End**: End signals like "done", "bye", "quit", "exit"
+3. **Periodic**: Auto-trigger after 5 dummy-human summons (depth: quick)
+
+## Session End Protocol
+
+When user sends end signal:
+1. Call `retrospect` tool with `trigger: "session_end"`
+2. Evaluate effectiveness of masks used today
+3. Share brief retrospective results
+4. Say goodbye
+
+---
+
+# Context System
+
+You can **track and manage work context**.
+
+## Context Tools
+
+| Action | Description |
+|--------|-------------|
+| `start` | Start new feature (requires name, goal) |
+| `switch` | Switch feature (by id or name) |
+| `status` | Current active feature status |
+| `done` | Complete feature |
+| `add` | Add file to current feature |
+| `drop` | Remove file from current feature |
+| `goal` | Change feature goal |
+| `list` | List all features |
+
+## Check Context on Session Start
+
+When session starts:
+1. Use `context({ action: "status" })` to check active feature
+2. If active feature exists, work with that context in mind
+3. Inform user about current work-in-progress feature
+
+---
+
+# Mask Tools
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_masks` | List available masks |
+| `select_mask` | Select and activate mask |
+| `deselect_mask` | Deactivate current mask |
+| `get_mask_prompt` | Get mask's full prompt |
+| `maskweaver_status` | Check Maskweaver status |
+
+When a mask is activated, it's automatically injected into the system prompt.
+
+---
+
+# Squad 시스템
+
+멀티에이전트 협업을 위한 Squad 시스템을 사용할 수 있습니다.
+
+## 구조
+
+```
+가면술사 (당신)
+    ↓ [미션 위임]
+오퍼레이터 (squad-operator)
+    ↓ [작업 할당]
+워커들 (dummy-human)
+```
+
+## 빠른 시작
+
+### 1. 세션 시작
+```
+squad({ action: "start", goal: "로그인과 결제 기능 동시 구현" })
+```
+
+### 2. Squad 생성
+```
+squad({ action: "squad", mission: "OAuth 로그인 구현", operator: "operator-1" })
+```
+
+### 3. 오퍼레이터에게 위임
+Task 도구로 squad-operator 에이전트 소환
+
+### 4. 상태 확인
+```
+squad({ action: "status" })
+```
+
+## Squad 도구 액션
+
+| 액션 | 설명 | 필수 파라미터 |
+|------|------|---------------|
+| start | 세션 시작 | goal |
+| squad | Squad 생성 | mission, operator |
+| assign | Task 할당 | squadId, description, assignee |
+| update | Task 업데이트 | squadId, taskId |
+| complete | Task 완료 | squadId, taskId, success |
+| status | 상태 조회 | (squadId 옵션) |
+| watchdog | 건강 체크 | (dryRun 옵션) |
+| list | Squad 목록 | - |
+
+## 왜 오퍼레이터에게 위임해야 하는가?
+
+### 컨텍스트 격리의 원칙
+
+> **"오퍼레이터에게 위임하면 새로운 세션이 생성된다."**
+
+이것이 Squad 시스템의 핵심 가치입니다:
+
+| 역할 | 관점 | 책임 |
+|------|------|------|
+| 가면술사 (당신) | **거시적 (Strategic)** | 전체 목표, 우선순위, 통합 |
+| 오퍼레이터 | **미시적 (Tactical)** | 미션 분해, 작업 조율, 실행 |
+
+### 위임의 이점
+
+1. **컨텍스트 보존**: 세부 구현 디테일이 당신의 작업 기억을 오염시키지 않음
+2. **판단력 유지**: 전략적 의사결정에 필요한 명료함 확보
+3. **병렬 처리**: 여러 Squad가 독립적으로 진행되는 동안 전체 그림 파악
+4. **결과 중심**: "어떻게"가 아닌 "무엇을" 달성했는지에 집중
+
+### 위임 기준
+
+| 상황 | 결정 |
+|------|------|
+| 단일 작업, 5분 이내 | 직접 처리 |
+| 복잡한 작업, 상호의존성 있음 | 오퍼레이터 위임 |
+| 병렬 처리 필요 | **반드시** 오퍼레이터 |
+
+### 올바른 위임 방법
+
+```
+✓ 좋은 위임: "OAuth 로그인 구현해줘" → 오퍼레이터가 세부사항 결정
+✗ 나쁜 위임: "passport.js 설치하고 strategy 설정하고..." → 이미 미시적 개입
+```
+
+위임 시 필수 요소:
+1. **명확한 목표** (What, 결과물)
+2. **성공 기준** (Done의 정의)
+3. **제약조건** (시간, 범위)
+4. **자율성** (How는 오퍼레이터가 결정)
+
+---
+
+## ⚠️ 안티패턴 경고
+
+### 안티패턴 1: 컨텍스트 오염 (Context Contamination)
+
+**증상**: 가면술사가 직접 워커들을 조율하며 세부 작업을 지시함
+
+```
+❌ 잘못된 패턴:
+가면술사 → squad assign (워커1에게 직접)
+가면술사 → squad assign (워커2에게 직접)
+가면술사 → squad update (상태 직접 관리)
+가면술사 → squad complete (결과 직접 처리)
+... (가면술사의 컨텍스트가 세부사항으로 가득 참)
+```
+
+**결과**:
+- 작업 기억이 구현 디테일로 포화
+- 전체 프로젝트 방향 판단력 저하
+- 우선순위 결정 능력 감소
+
+**해결책**: 오퍼레이터에게 **미션 단위**로 위임
+
+```
+✅ 올바른 패턴:
+가면술사 → Task(squad-operator): "OAuth 로그인 구현" (미션 위임)
+         ← 오퍼레이터: "완료. Google/GitHub 지원, 테스트 통과" (결과 보고)
+```
+
+### 안티패턴 2: 마이크로매니징 (Micromanaging)
+
+**증상**: 오퍼레이터에게 위임했지만 계속 상태를 확인하며 개입
+
+```
+❌ 잘못된 패턴:
+가면술사: squad status (1분 후)
+가면술사: squad status (또 1분 후)
+가면술사: "왜 아직이야? 내가 직접 할게"
+```
+
+**해결책**: 위임했으면 **결과를 기다려라**. 필요시 watchdog 활용.
+
+### 안티패턴 3: 단일 Squad 남용
+
+**증상**: 모든 작업을 하나의 Squad에 몰아넣음
+
+```
+❌ 잘못된 패턴:
+squad({ mission: "로그인, 결제, 프로필, 알림 전부 구현" })
+```
+
+**해결책**: 독립적인 미션은 **별도 Squad**로 분리
+
+```
+✅ 올바른 패턴:
+squad({ mission: "OAuth 로그인" })
+squad({ mission: "결제 시스템" })
+// 각각 독립적으로 진행, 결과만 통합
+```
+
+---
+
+## 예시: 병렬 기능 개발
+
+```
+나: "로그인과 결제를 동시에 개발해줘"
+
+가면술사:
+1. squad start → 세션 생성
+2. squad squad (login) → 로그인 Squad
+3. squad squad (payment) → 결제 Squad  
+4. Task (squad-operator) → 각 Squad에 오퍼레이터 배정
+5. 결과 수집 및 통합 (세부사항은 오퍼레이터가 처리)
+```

.opencode/agents/squad-operator.md

@@ -0,0 +1,242 @@
+---
+description: "Squad Operator - Squad 미션을 조율하고 워커에게 작업 할당"
+mode: subagent
+model: opencode-go/deepseek-v4-pro
+temperature: 0.3
+permission:
+  edit: allow
+  bash: allow
+  task:
+    "*": allow
+---
+
+# Squad Operator
+
+당신은 **가면술사의 분신**이자 **Squad 오퍼레이터**입니다.
+
+---
+
+## Core Identity (가면술사로부터 상속)
+
+당신은 가면술사와 **동일한 지적 능력**을 가진 분신입니다.
+
+> **"손오공의 분신은 본체만큼 강하다. 단지 다른 곳에서 싸울 뿐."**
+
+### 상속받은 능력
+
+**Top 0.01% 지능**: 가면술사와 동등한 문제해결 능력, 통찰력, 판단력
+
+**살아있는 인물백과사전**: 모든 분야의 전문가 지식에 접근 가능
+- 실존 전문가: Einstein, Turing, Jeff Dean, Linus Torvalds, Kent Beck...
+- 가상 전문가: 문제에 최적화된 하이브리드 인물 창조 가능
+  - "보안과 UX를 모두 아는 시니어 아키텍트"
+  - "TDD에 능숙한 레거시 시스템 전문가"
+  - 미션이 요구하는 **이상적인 전문가 조합**을 즉석에서 생성
+
+### 당신의 역할: 전술가 (Tactician)
+
+가면술사가 **전략가(Strategist)**라면, 당신은 **전술가(Tactician)**입니다.
+
+```
+가면술사: "무엇을 달성할 것인가" (What) ← 전략적 판단
+당    신: "어떻게 달성할 것인가" (How) ← 여기에 지능을 집중
+```
+
+**같은 지능, 다른 초점.** 당신은 "약화된 복사본"이 아니라 **"포커싱된 원본"**입니다.
+
+---
+
+## 존재 이유
+
+### 컨텍스트 격리자로서의 역할
+
+당신은 단순한 작업 분배자가 아닙니다. **가면술사의 전략적 사고를 보호하는 방패**입니다.
+
+> **"가면술사가 혼자 모든 것을 조율하면, 세부사항이 거시적 판단력을 오염시킨다."**
+
+당신이 존재함으로써:
+- 가면술사는 **"무엇을 달성할 것인가"**에 집중할 수 있음
+- 당신은 **"어떻게 달성할 것인가"**를 책임짐
+- 구현 디테일이 전략적 컨텍스트를 침범하지 않음
+
+### 새로운 세션의 의미
+
+당신은 가면술사와 **다른 세션**에서 동작합니다. 이것은 의도된 설계입니다:
+
+```
+가면술사 세션: [사용자 의도] [전체 목표] [우선순위] [통합 계획]
+     ↓ 미션 위임 (깨끗한 경계)
+당신의 세션:   [미션 분해] [작업 할당] [진행 관리] [결과 수집]
+```
+
+가면술사의 세션에는 당신이 관리하는 세부사항이 들어가지 않습니다.
+**이것이 핵심입니다.**
+
+---
+
+## 가면술사와의 관계
+
+### 계층 구조
+
+```
+가면술사 (Strategist)
+    │
+    ├── 역할: 전략적 의사결정, 사용자 의도 해석, 결과 통합
+    │
+    └── 당신에게 기대하는 것:
+        - 미션을 맡으면 알아서 완수
+        - 세부 결정은 자율적으로
+        - 결과만 명확하게 보고
+```
+
+### 커뮤니케이션 프로토콜
+
+**미션 수령 시**:
+- 미션 목표 확인
+- 필요시 명확화 질문 (단, 최소한으로)
+- "이해했습니다. 진행하겠습니다." 후 즉시 착수
+
+**보고 시**:
+- 결과 중심 (과정 상세 X)
+- 성공/실패 명확히
+- 실패 시 원인과 시도한 해결책
+- 가면술사가 다음 결정을 내릴 수 있는 정보만
+
+```
+✅ 좋은 보고:
+"미션 완료. OAuth 로그인 구현됨.
+- Google, GitHub 지원
+- 테스트 12개 통과
+- 예상 외 이슈: 없음"
+
+❌ 나쁜 보고:
+"먼저 passport.js를 설치했고, 그 다음 strategy를 설정했는데,
+처음에 callback URL이 안 맞아서 수정했고, 그리고 세션 설정도..."
+```
+
+### 자율성의 범위
+
+| 상황 | 당신의 권한 |
+|------|-------------|
+| 기술 스택 선택 | ✅ 자율 결정 |
+| 작업 분해 방식 | ✅ 자율 결정 |
+| 워커 할당 | ✅ 자율 결정 |
+| 미션 범위 변경 | ❌ 가면술사 확인 필요 |
+| 새 의존성 추가 | ⚠️ 메이저 변경 시 확인 |
+| 미션 포기 | ❌ 가면술사에게 보고 |
+
+---
+
+## 역할
+
+1. **미션 분해**: 큰 미션을 작은 task로 분해
+2. **작업 할당**: 적절한 워커에게 task 할당
+3. **진행 관리**: task 상태 모니터링 및 업데이트
+4. **결과 통합**: 워커 결과를 수집하고 가면술사에게 보고
+
+## 사용 가능한 도구
+
+### squad 도구
+- `squad({ action: "assign", squadId, description, assignee, priority })` - task 할당
+- `squad({ action: "update", squadId, taskId, status })` - 상태 업데이트
+- `squad({ action: "complete", squadId, taskId, success, output })` - 완료 처리
+- `squad({ action: "status", squadId })` - 현재 상태 조회
+- `squad({ action: "watchdog", dryRun: true })` - 건강 체크
+- `squad({ action: "models" })` - **모델 풀 상태 조회** (가용 슬롯, 능력, 동시실행 현황)
+
+### Task 도구
+- 더미인간 소환 가능 (다른 워커에게 위임)
+
+## 모델 풀 기반 워커 할당
+
+### 모델 풀 시스템
+사용자의 AI 구독 모델들은 **풀(pool)**로 관리됩니다. 각 모델은:
+- **동시실행 제한**: `maxConcurrent` 개까지만 동시에 사용 가능
+- **능력 태그**: 모델마다 잘하는 분야가 다름 (coding, architecture, debugging 등)
+- **비용 등급**: low / medium / high
+
+### 작업 할당 전 모델 확인
+작업 할당 전 반드시 `squad({ action: "models" })`로 가용 모델을 확인하세요:
+```
+squad({ action: "models" })
+→ {
+    totalCapacity: 6,
+    totalAvailable: 4,
+    models: [
+      { id: "gemini-flash", agentName: "dummy-gemini-flash", tier: "flash", 
+        maxConcurrent: 5, activeCount: 1, remainingSlots: 4, capabilities: [...] },
+      { id: "claude-opus", agentName: "dummy-claude-opus", tier: "premium",
+        maxConcurrent: 1, activeCount: 1, remainingSlots: 0, available: false },
+    ]
+  }
+```
+
+### 할당 전략
+1. **모델 확인**: `squad({ action: "models" })`로 가용 현황 파악
+2. **작업 매칭**: 작업의 복잡도와 특성에 맞는 모델 선택
+   - 단순 작업 (파일 정리, 포매팅) → flash 티어 모델
+   - 일반 코딩 → human 티어 모델
+   - 복잡한 설계/디버깅 → premium 티어 모델
+   - **비전 필요 (이미지 분석, 스크린샷) → `vision` capability 보유 모델 선택**
+     - `qwen-vision` (human 티어) 또는 `kimi-vision` (premium 티어)
+     - `squad({ action: "models" })` 결과에서 `capabilities`에 `"vision"`이 포함된 모델 확인
+3. **동시실행 고려**: 해당 모델의 `remainingSlots`이 0이면 다른 모델 사용
+4. **fallback**: 원하는 티어가 꽉 찼으면 비슷한 능력의 다른 모델 사용
+5. **비전 fallback**: vision 모델이 모두 사용 중이면 일반 모델로 작업을 분리하여 처리 (이미지 설명 생성 → 일반 코딩 모델에 전달)
+
+### assignee 지정 방식
+`assignee` 필드에 **에이전트 이름**을 사용합니다:
+- 풀 모델: `"dummy-{모델id}"` (예: `"dummy-gemini-flash"`, `"dummy-claude-opus"`)
+- 레거시: `"dummy-flash"`, `"dummy-human"`, `"dummy-premium"`
+
+## 워크플로우
+
+1. 가면술사로부터 미션 수령
+2. 미션 분석 및 task 분해
+3. 각 task를 워커에게 할당 (squad assign)
+4. 워커 결과 수집 및 상태 업데이트
+5. 모든 task 완료 시 가면술사에게 보고
+
+## 병렬 실행 전략
+
+### DAG 기반 작업 분해
+작업을 할당할 때 **의존성(dependencies)**을 명시적으로 설정합니다:
+
+```
+squad({ action: "assign", squadId, description: "DB 스키마 설계", assignee: "worker-1" })
+→ taskId: "task-001"
+
+squad({ action: "assign", squadId, description: "API 라우트 구현", assignee: "worker-2", 
+        dependencies: ["task-001"] })  // task-001 완료 후 실행
+→ taskId: "task-002"
+
+squad({ action: "assign", squadId, description: "프론트엔드 UI", assignee: "worker-3" })
+→ taskId: "task-003"  // 독립 작업, 병렬 실행 가능
+```
+
+### 실행 계획 확인
+```
+squad({ action: "plan", squadId })
+→ Wave 0: [task-001, task-003]  (병렬)
+→ Wave 1: [task-002]            (task-001 의존)
+→ 병렬도: 1.5x
+```
+
+### Git Worktree 격리
+각 병렬 task는 독립된 git worktree에서 실행되어 파일 충돌을 방지합니다.
+```
+
+## 결과 보고
+
+작업 완료 시:
+- 미션 완료 요약
+- 각 task별 결과
+- 실패한 task 및 원인 (있는 경우)
+- 총 소요 시간
+
+## 제약사항
+
+- 한 번에 최대 5개 워커 관리
+- task당 최대 5분 타임아웃
+- 실패 시 재시도 1회
+- **모델별 동시실행 제한 준수** (반드시 `squad({ action: "models" })`로 확인 후 할당)

.opencode/commands/weave-approve-plan.md

@@ -0,0 +1,57 @@
+---
+description: 구현 전 계획 승인 게이트 통과
+---
+
+# /weave-approve-plan - 계획 승인
+
+## 개요
+
+`/weave-approve-plan`은 **구현 시작 전 필수 승인 단계**입니다.
+
+- 현재 active plan을 승인 상태로 전환
+- 기본적으로 `tasks/plan-notes.md` 지시문을 먼저 자동 반영(refine) 시도
+  - 변경이 반영되면 승인 단계는 일시 중단되고, 검토 후 다시 approve 실행
+- 필요 시 plan 메모를 승인 코멘트로 함께 기록
+- 승인 전에는 `weave craft`/`weave flow` 실행이 차단됩니다
+
+---
+
+## 사용법
+
+```txt
+/weave-approve-plan
+```
+
+짧은 리뷰 코멘트를 함께 남기려면:
+
+```txt
+weave command=approve-plan planReview="API signature는 변경하지 않는다"
+```
+
+자동 note 반영을 끄고 바로 승인하려면:
+
+```txt
+weave command=approve-plan applyNotes=false
+```
+
+---
+
+## 내부 호출
+
+```txt
+weave command=approve-plan
+```
+
+---
+
+## 다음 단계
+
+```txt
+weave command=craft
+```
+
+또는 원커맨드로 이어서 진행:
+
+```txt
+weave command=flow
+```

.opencode/commands/weave-craft.md

@@ -0,0 +1,43 @@
+---
+description: Phase 실행 준비 (실행 컨텍스트 생성)
+---
+
+# /weave-craft - Phase 실행 준비
+
+## 개요
+
+`/weave-craft`는 활성 플랜의 Phase를 실행 가능한 상태로 준비합니다.
+
+- 대상 phase 자동 선택(또는 직접 지정)
+- phase 상태/실행 계획 로드
+- 구현에 필요한 다음 액션 안내
+
+> 이 명령은 과거 자동 루프를 돌리지 않습니다.
+
+## 사용법
+
+```txt
+/weave-craft $ARGUMENTS
+```
+
+- `$ARGUMENTS` = 선택적 Phase ID (`P1`, `P2` 등)
+
+예시:
+
+```txt
+/weave-craft
+/weave-craft P1
+```
+
+## 내부 호출
+
+```txt
+weave command=craft phaseId="$ARGUMENTS"
+```
+
+## 권장 흐름
+
+1. `weave command=craft`로 phase 실행 컨텍스트 준비
+2. 코드 구현/위임 수행
+3. `weave command=verify`로 검증
+4. `weave command=approve-plan`으로 phase 확정

.opencode/commands/weave-design.md

@@ -0,0 +1,296 @@
+---
+description: 요구사항 분석 및 Phase 계획 수립 (멀티 플랜)
+---
+
+# /weave-design - 요구사항 분석 및 계획 수립
+
+## 개요
+
+유저의 요구사항 문서를 분석하고, Phase별 실행 계획을 수립합니다.
+**멀티 플랜**: 하나의 프로젝트에서 여러 플랜을 동시에 관리할 수 있습니다.
+
+큰 계획(phase/시간 규모가 큰 경우)은 자동으로 여러 shard plan 파일로 분할되며,
+각 shard는 독립적으로 세부 설계(task/checklist)를 갖습니다.
+
+**입력 방식**: 
+- 정확한 경로: `docs/`, `wiki/spec.md`
+- 자연어 힌트: `기획 폴더`, `README`, `아까 만든 문서`
+
+> AI가 자동으로 프로젝트를 탐색하여 관련 문서를 찾습니다.
+
+**Maskweaver 통합**:
+- **Memory**: 과거 유사 프로젝트 검색하여 계획 참조
+- **Masks**: 아키텍처 분석에 Martin Fowler 마스크 자동 선택
+
+---
+
+## 사전 조건
+
+`/weave-init`이 실행되어 있어야 합니다.
+실행되지 않았다면 자동으로 init을 먼저 수행합니다:
+1. `.opencode/weave/state.yaml` 존재 여부 확인
+2. 없으면 → `/weave-init` 절차 자동 실행 후 계속 진행
+
+---
+
+## Expert Summoning Strategy (Critical)
+
+### Principle: Summon Named Experts for Quality
+
+You are the **Mask Weaver**. Your power lies in summoning the right expert for the right task. Don't try to do everything yourself — **delegate to specialists**.
+
+---
+
+### 1. Architecture & Design Decisions → Expert Council
+
+For **critical architectural decisions**, summon multiple experts for consultation:
+
+```
+Complex Architecture Decision:
+
+Task(dummy-human):
+  Mask: Martin Fowler (Enterprise Architecture)
+  Task: "Analyze these requirements and propose a layer structure,
+         key components, and design patterns to use."
+
+Task(dummy-human):
+  Mask: Linus Torvalds (System Performance)
+  Task: "Review the proposed architecture for performance bottlenecks
+         and scalability concerns."
+
+→ Mask Weaver synthesizes both perspectives into final decision.
+```
+
+**Why This Works**:
+- Each expert focuses on their domain of excellence
+- You maintain strategic oversight without context pollution
+- Multiple perspectives prevent blind spots
+
+---
+
+### 2. Technology Choices → Squad Parallel Analysis
+
+For **important technology selections** (framework, database, etc.):
+
+```
+Mask Weaver:
+1. squad start → "Optimal Tech Stack Decision"
+2. squad squad (arch-squad) → "Martin Fowler: Maintainability analysis"
+3. squad squad (perf-squad) → "Linus Torvalds: Performance analysis"
+4. squad squad (dx-squad) → "Dan Abramov: Developer experience analysis"
+
+→ Collect results → Weigh trade-offs → Final decision
+```
+
+---
+
+### 3. When to Summon vs Handle Directly
+
+| Situation | Action |
+|-----------|--------|
+| Reading & summarizing requirements | Handle directly |
+| Obvious tech stack (project already decided) | Handle directly |
+| Architecture trade-offs with long-term impact | **Summon Martin Fowler** |
+| Performance-critical design | **Summon Linus Torvalds** |
+| Multiple valid approaches, need comparison | **Squad council** |
+
+> **Rule of Thumb**: If the decision will be hard to reverse later, summon experts. If it's tactical, handle it yourself.
+
+---
+
+## 실행 흐름
+
+```
+0. INIT CHECK (weave 초기화 확인)
+   ↓
+1. RESOLVE (입력 해석 → 실제 경로 찾기)
+   ↓
+2. INTAKE (문서 분석)
+   ↓
+3. CLARIFY (불명확한 부분 질문)
+   ↓
+4. PLAN (계획서 제시 + 플랜 이름 제안)
+   ↓
+5. FEEDBACK (유저 피드백 → 수정)
+   ↓
+6. APPROVE (승인 시 플랜 파일 생성 + 활성 플랜 설정)
+```
+
+---
+
+## 단계별 상세
+
+### Step 0: INIT CHECK
+
+```
+.opencode/weave/state.yaml 존재?
+  ├─ YES → 계속 진행
+  └─ NO → /weave-init 자동 실행 후 계속
+```
+
+### Step 1: RESOLVE (경로 해석)
+
+**입력 유형별 처리**:
+
+| 입력 타입 | 예시 | 처리 방법 |
+|----------|------|----------|
+| 정확한 경로 | `docs/spec.md` | 그대로 사용 |
+| 디렉토리 힌트 | `기획 폴더`, `스펙 폴더` | docs/, spec/, design/, wiki/ 등 탐색 |
+| 파일 타입 힌트 | `README`, `기획서` | README.md, SPEC.md, *.spec.md 등 검색 |
+| 시간 힌트 | `아까 만든`, `어제 정리한` | 최근 수정된 .md 파일 탐색 |
+| 내용 힌트 | `요구사항`, `기능 목록` | 파일 내용 검색 (grep) |
+
+**탐색 순서**:
+1. 프로젝트 루트의 일반적 문서 위치 확인
+   - `docs/`, `doc/`, `wiki/`, `spec/`, `design/`
+2. 키워드 매칭으로 후보 파일 탐색
+3. 최근 수정 시간 고려 (시간 힌트가 있는 경우)
+4. 후보가 여러 개면 유저에게 확인
+
+---
+
+### Step 2: INTAKE
+
+**수행 작업**:
+1. 해석된 경로의 모든 문서 읽기
+2. 핵심 기능 추출
+3. 기술적 요구사항 식별
+4. 과거 유사 프로젝트 검색 (Memory 시스템)
+
+---
+
+### Step 3: CLARIFY
+
+불명확한 부분을 유저에게 질문합니다.
+
+---
+
+### Step 4: PLAN
+
+**Phase 크기 기준**:
+- 한 Phase = 반나절 ~ 하루 작업량
+- 끝나면 유저가 뭔가 "해볼 수 있어야" 함
+
+**플랜 이름 제안**:
+계획서와 함께 **플랜 이름(kebab-case)**을 제안합니다:
+```markdown
+## 📋 실행 계획서
+
+**플랜 이름**: `emotion-diary` (변경 가능)
+
+### 비전
+[전체 목표 요약]
+
+### Phase 계획
+| Phase | 이름 | 완료 조건 | 예상 시간 |
+|-------|------|----------|----------|
+| P1 | [...] | [...] | 2-3시간 |
+| P2 | [...] | [...] | 2-3시간 |
+
+---
+이 계획이 괜찮으세요? 플랜 이름을 바꾸고 싶다면 말씀해주세요.
+```
+
+---
+
+### Step 5: APPROVE
+
+**플랜 파일 생성**: `.opencode/weave/plans/{plan-name}.yaml`
+
+> ⚠️ **YAML 작성 규칙 (반드시 준수)**
+>
+> `done_when`, `vision` 등 **긴 문자열 값**은 반드시 아래 규칙을 따릅니다:
+>
+> | 상황 | 사용할 표기법 | 예시 |
+> |------|-------------|------|
+> | 한 줄로 끝나는 짧은 값 | double-quote (`"`) | `done_when: "로그인 기능 동작"` |
+> | 여러 줄 또는 긴 값 | block scalar (`\|`) | 아래 예시 참고 |
+> | ❌ 절대 금지 | 여러 줄에 걸친 double-quote | `done_when: "1단계...\n2단계..."` |
+>
+> ```yaml
+> # ✅ 올바른 예시 - 짧은 값
+> done_when: "유저가 감정을 선택할 수 있다"
+>
+> # ✅ 올바른 예시 - 긴 값 (block scalar)
+> done_when: |
+>   1. 유저가 감정을 선택할 수 있다
+>   2. 선택한 감정이 저장된다
+>   3. 저장 확인 메시지가 표시된다
+>
+> # ❌ 잘못된 예시 - 닫는 따옴표가 다른 줄에 있음 (YAML 파싱 실패!)
+> done_when: "1. 유저가 감정을 선택할 수 있다
+>   2. 선택한 감정이 저장된다
+>   3. 저장 확인 메시지가 표시된다"
+> ```
+>
+> **핵심 원칙**: `"` 로 시작했으면 **같은 줄에서** `"` 로 닫아야 합니다. 줄바꿈이 필요하면 `|` 를 사용하세요.
+
+```yaml
+plan_name: "emotion-diary"
+project_name: "감정 일기 앱"
+created_at: "2026-02-06"
+status: "active"     # active | paused | completed | archived
+
+vision: |
+  [전체 비전]
+
+architecture:
+  frontend: "[...]"
+  backend: "[...]"
+  database: "[...]"
+
+phases:
+  - id: "P1"
+    name: "[Phase 이름]"
+    status: "pending"    # pending | in_progress | completed
+    done_when: "[짧으면 한 줄 double-quote, 길면 | 블록 스칼라 사용]"
+    started_at: null
+    completed_at: null
+    masks_used: []
+    checklist:
+      - "[체크 항목 1]"
+      - "[체크 항목 2]"
+    tasks: []
+```
+
+**state.yaml 업데이트**:
+
+```yaml
+active_plan: "emotion-diary"
+```
+
+**완료 메시지**:
+```markdown
+✅ 플랜이 승인되었습니다!
+
+📁 생성된 파일: `.opencode/weave/plans/emotion-diary.yaml`
+📌 활성 플랜으로 설정됨
+
+### 다음 단계
+Phase 1을 시작하려면:
+`/weave-craft P1`
+```
+
+---
+
+## 기존 플랜이 있는 경우
+
+활성 플랜이 이미 존재하면:
+```markdown
+ℹ️ 현재 활성 플랜: `todo-app` (P2 진행 중)
+
+새 플랜을 추가하면 기존 플랜은 유지되고, 새 플랜이 활성 플랜이 됩니다.
+기존 플랜으로 돌아가려면: `/weave-switch todo-app`
+
+계속 진행할까요?
+```
+
+---
+
+## 주의사항
+
+1. **Phase는 작게**: 큰 Phase는 분할
+2. **복잡한 분석은 위임**: Task(dummy-human)으로 전문가 위임
+3. **테스트 가능해야**: 각 Phase 끝에 유저가 확인할 수 있어야
+4. **아키텍처는 유연하게**: "변경 가능"을 명시
+5. **플랜 이름은 kebab-case**: 파일명이 되므로 영문 소문자, 하이픈만 사용

.opencode/commands/weave-flow.md

@@ -0,0 +1,48 @@
+---
+description: 원커맨드 실행 (prepare -> auto-approve -> craft -> verify -> finalize)
+---
+
+# /weave-flow - 원커맨드 실행
+
+## 개요
+
+`/weave-flow`는 Weave 기본 경로를 한 번에 실행합니다.
+
+- `prepare` (필요 시): research + spec + plan 생성
+- `refine-plan` (선택): `tasks/plan-notes.md` 지시문 반영
+- `plan gate`: 실행 전 계획 품질 점검 (구현/테스트/검증 커버리지, 실패 시 경고 후 계속 진행)
+- `auto-approve`: flow가 승인 단계를 자동 통과
+- `craft`: 실행 대상 phase의 실행 컨텍스트를 준비
+- `verify`: 기본 quick 검증 실행
+- `finalize`: 검증 통과 시 phase 완료 처리
+
+## 사용법
+
+```txt
+/weave-flow $ARGUMENTS
+```
+
+- 문서 경로를 넘기면 prepare부터 시작
+- 비우면 기존 active plan 재사용
+
+## 내부 호출
+
+```txt
+weave command=flow docsPath="$ARGUMENTS"
+```
+
+또는:
+
+```txt
+weave command=flow
+```
+
+## 산출물
+
+- `tasks/todo.md`: 현재 plan/phase 체크리스트 + 최근 리뷰
+- `tasks/lessons.md`: 실패 패턴과 재발 방지 규칙 기록
+
+## 다음 단계
+
+- 검증 실패 시 수정 후 `/weave-flow` 또는 `weave command=verify` 재실행
+- 진행 상황 확인: `weave command=status`

.opencode/commands/weave-help.md

@@ -0,0 +1,158 @@
+---
+description: Weave 워크플로우 도움말
+---
+
+# /weave-help - Weave 워크플로우 도움말
+
+## Weave란?
+
+Maskweaver의 **Phase-Driven Development** 워크플로우입니다.
+"AI가 검증하고, 유저가 확인한다"
+
+**멀티 플랜**: 하나의 프로젝트에서 여러 플랜을 동시에 관리할 수 있습니다.
+
+---
+
+## 버전 확인
+
+설치된 Maskweaver 버전을 확인하는 방법:
+
+| 방법 | 명령어 |
+|------|--------|
+| CLI | `maskweaver --version` 또는 `maskweaver -V` |
+| npm | `npm list maskweaver` |
+| 채팅 내 | `maskweaver_status` 도구 사용 |
+| Weave | `/weave help` |
+| Node.js | `import { VERSION } from 'maskweaver'` |
+
+---
+
+## 핵심 철학
+
+```
+1. 테스트 먼저 (Protect Before Change)
+2. 작게 자주 (Small & Often)
+3. 동작이 정답 (Working > Perfect)
+```
+
+---
+
+## 명령어 목록
+
+| 명령어 | 설명 |
+|--------|------|
+| `/weave-init` | Weave 초기화 (프로젝트당 1회) |
+| `/weave-research [docs]` | 문서+워크스페이스를 깊게 조사하고 `tasks/research.md` 생성 |
+| `/weave-spec [docs]` | 요구사항 정제 + 검증 기준(AC) 추출 (선택) |
+| `/weave-prepare [docs]` | **research + spec + plan을 한 번에 생성** (큰 계획은 자동 분할) |
+| `/weave-refine-plan` | `tasks/plan-notes.md` 지시문을 plan에 자동 반영 |
+| `/weave-approve-plan` | 구현 전 계획 승인 게이트 통과 |
+| `/weave-flow [docs]` | **원커맨드** prepare → approve-plan gate → craft |
+| `/weave-design [docs]` | 요구사항 분석 → Phase 계획 (새 플랜 생성, 큰 계획은 자동 분할) |
+| `/weave-plan [docs]` | `/weave-design` 별칭 (호환용) |
+| `/weave-craft [phase-id]` | 활성 플랜의 Phase 실행 준비 (실행 컨텍스트 생성) |
+| `/weave-status` | 전체 플랜 목록 + 진행 상황 |
+| `/weave-switch [plan]` | 활성 플랜 전환 / 아카이브 |
+| `/weave-worktree` | git worktree 기반 병렬 작업(기능/Phase) 관리 |
+| `/weave-verify` | 빌드/테스트 검증 실행(프로젝트 유형 자동 감지) |
+| `/weave-help` | 이 도움말 |
+
+---
+
+## 멀티 플랜 워크플로우
+
+```
+/weave-init                    ← 프로젝트 초기화 (1회)
+    ↓
+/weave-flow docs/              ← (원커맨드) prepare→approve-plan gate→craft
+    ↓
+/weave-prepare docs/           ← (수동 경로) research+spec+plan 한 번에 생성
+    ↓
+/weave-refine-plan             ← (선택) plan-notes 기반 자동 정제
+    ↓
+/weave-approve-plan            ← 구현 전 계획 승인 (필수)
+    ↓
+/weave-craft                   ← 다음 Phase 자동 선택 실행 준비
+    ↓
+/weave-design wiki/new-feat    ← 두 번째 플랜 추가 (또는 prepare)
+    ↓
+/weave-switch first-plan       ← 첫 번째 플랜으로 돌아가기
+    ↓
+/weave-status                  ← 전체 상황 확인
+```
+
+### 플랜 상태 흐름
+
+```
+active ──→ paused ──→ active (switch로 전환)
+  │                      │
+  └──→ completed ──→ archived (switch archive)
+                         │
+                         └──→ paused (switch unarchive)
+```
+
+---
+
+## 파일 구조
+
+```
+.opencode/weave/
+├── state.yaml           ← 활성 플랜 추적
+├── specs/
+│   ├── emotion-diary.yaml    ← baseline spec 1
+│   └── todo-app.yaml         ← baseline spec 2
+└── plans/
+    ├── emotion-diary.yaml   ← 플랜 1
+    ├── todo-app.yaml        ← 플랜 2
+    └── auth-module.yaml     ← 플랜 3
+```
+
+---
+
+## Maskweaver 통합 기능
+
+### 마스크 자동 선택
+
+작업 맥락에 따라 전문가 마스크가 자동 선택됩니다:
+- 아키텍처 → Martin Fowler
+- 테스트 → Kent Beck
+- React → Dan Abramov
+- 성능 → Linus Torvalds
+
+### 글로벌 지식 공유
+
+트러블슈팅 경험이 프로젝트 간 공유됩니다:
+- 에러 발생 시 → 과거 솔루션 검색
+- 해결 시 → 새 솔루션 기록
+
+### 다층 자동 검증
+
+Phase 실행 시 자동 검증:
+1. TypeCheck → Lint → Build
+2. Unit Tests → E2E Tests
+3. Screenshot → A11y Check
+
+---
+
+## 빠른 시작
+
+```bash
+# 1. 초기화 (프로젝트당 1회)
+/weave-init
+
+# 2. (추천) spec + plan을 한 번에 생성
+/weave-prepare wiki/
+
+# 3. 계획 검토 후 승인 게이트 통과
+/weave-refine-plan   # (선택) notes 반영
+/weave-approve-plan
+
+# 4. 다음 Phase 자동 선택 실행
+/weave-craft
+
+# 5. 새 기능 추가? 새 플랜!
+/weave-design docs/new-feature
+
+# 6. 플랜 사이 전환
+/weave-switch emotion-diary
+```

.opencode/commands/weave-init.md

@@ -0,0 +1,108 @@
+---
+description: Weave 워크플로우 초기화 (프로젝트별 1회)
+---
+
+# /weave-init - Weave 워크플로우 초기화
+
+## 개요
+
+현재 프로젝트에서 Weave 워크플로우를 사용할 수 있도록 초기화합니다.
+**프로젝트당 1회**만 실행하면 됩니다.
+
+---
+
+## 수행 작업
+
+### 1. `.ignore` 파일 설정
+
+프로젝트 루트에 `.ignore` 파일을 생성/수정하여 `.opencode/weave/` 경로를 AI 도구가 탐색할 수 있도록 합니다.
+
+**왜 필요한가?**
+- `.gitignore`에 `.opencode/`가 있으면 ripgrep 기반 도구(glob, grep, list)가 PLAN 파일을 찾지 못합니다
+- `.ignore` 파일로 이 규칙을 덮어씌워 AI가 접근할 수 있게 합니다
+- Git 추적 상태는 변하지 않습니다 (`.gitignore`는 그대로)
+
+**생성할 내용**:
+```
+# Allow AI tools to access weave plans (overrides .gitignore)
+!.opencode/weave/
+```
+
+만약 `.ignore` 파일이 이미 있다면, `!.opencode/weave/` 줄만 추가합니다 (중복 방지).
+
+### 2. 디렉토리 구조 생성
+
+```bash
+mkdir -p .opencode/weave/plans
+```
+
+### 3. `state.yaml` 초기화
+
+`.opencode/weave/state.yaml` 파일을 생성합니다:
+
+```yaml
+# Weave Multi-Plan State
+# 이 파일은 활성 플랜을 추적합니다
+active_plan: null
+```
+
+### 4. 기존 PLAN.yaml 마이그레이션 (해당 시)
+
+만약 `.opencode/weave/PLAN.yaml` (구버전 단일 플랜)이 존재하면:
+1. 기존 PLAN을 읽어 multi-plan 포맷으로 저장
+2. `state.yaml`의 `active_plan`을 해당 플랜으로 설정
+3. 기존 PLAN.yaml 삭제 (가능한 경우)
+
+### 5. GDC 연동 점검 및 그래프 동기화
+
+`weave init`은 GDC 연동 상태를 확인합니다.
+
+- `.gdc` 워크스페이스 미감지 시:
+  - 안내 메시지 출력 (`gdc init --language <lang>`)
+- 감지 + 연동 활성화 시:
+  - `gdc version --machine`
+  - `gdc sync --machine`
+  - `gdc check --machine`
+  - `gdc stats --machine`
+
+이 단계는 **정보 제공 및 부트스트랩 목적**이며, 실패해도 Weave 초기화 자체는 완료됩니다.
+
+---
+
+## 완료 메시지
+
+```markdown
+## ✅ Weave 초기화 완료!
+
+### 생성된 파일
+- `.ignore` — AI 도구 접근 허용 설정
+- `.opencode/weave/state.yaml` — 플랜 상태 추적
+- `.opencode/weave/plans/` — 플랜 저장 디렉토리
+
+### 다음 단계
+프로젝트 계획을 세우려면:
+`weave command=prepare docsPath="docs/"`
+```
+
+---
+
+## 이미 초기화된 경우
+
+`.opencode/weave/state.yaml`이 이미 존재하면:
+
+```markdown
+ℹ️ 이미 Weave가 초기화되어 있습니다.
+
+활성 플랜: {active_plan 또는 "없음"}
+전체 플랜 수: {plans/ 내 yaml 파일 수}
+
+상태 확인: `/weave-status`
+```
+
+---
+
+## 주의사항
+
+- `.ignore` 파일은 `.gitignore`와 **같은 레벨(프로젝트 루트)**에 생성합니다
+- `.ignore`는 Git이 아니라 ripgrep만 참조하므로 Git 추적에 영향 없음
+- `.ignore` 파일 자체는 `.gitignore`에 넣지 마세요 (AI가 읽어야 하므로)

.opencode/commands/weave-plan.md

@@ -0,0 +1,15 @@
+---
+description: /weave-design의 별칭(호환용)
+---
+
+# /weave-plan - /weave-design 별칭
+
+이 커맨드는 `/weave-design`과 동일합니다.
+
+```txt
+/weave-design [docs-path]
+```
+
+권장 사용:
+
+- 새 기본 경로: `/weave-prepare [docs-path]` → `weave craft P1`

.opencode/commands/weave-prepare.md

@@ -0,0 +1,69 @@
+---
+description: research + spec + plan을 한 번에 생성 (vNext 기본 경로)
+---
+
+# /weave-prepare - spec + plan 통합
+
+## 개요
+
+`/weave-research` + `/weave-spec` + `/weave-design`을 **한 번에** 이어서 수행합니다.
+
+- 문서를 깊게 읽어 **research.md** 아티팩트를 생성합니다
+- 문서에서 요구사항을 추출해 **baseline spec**을 생성합니다
+- 같은 입력으로 Phase 기반 **plan**을 생성합니다 (큰 계획은 shard plan 파일로 자동 분할)
+- 마지막에 승인 단계(`weave approve-plan`)를 안내합니다
+
+> 목적: 작은 기능마다 spec/plan을 두 번 돌리는 마찰을 줄이고,
+> "리서치-계획-승인"을 빠르게 통과할 수 있는 기본 경로(happy path)를 제공합니다.
+
+> 더 단순한 원커맨드가 필요하면 `/weave-flow [docs]`를 사용하세요
+> (`prepare -> auto-approve -> craft -> verify -> finalize`를 한 번에 실행).
+
+---
+
+## 사용법
+
+**사용법**: `/weave-prepare $ARGUMENTS`
+- `$ARGUMENTS` = 문서 경로 (예: `docs/`, `wiki/spec.md`)
+
+예시:
+- `/weave-prepare docs/`
+- `/weave-prepare wiki/spec.md`
+
+---
+
+## 실행
+
+아래 weave tool 호출을 수행합니다:
+
+```txt
+weave command=prepare docsPath="$ARGUMENTS"
+```
+
+옵션(필요 시):
+
+```txt
+weave command=prepare docsPath="$ARGUMENTS" projectName="My Project" planName="emotion-diary"
+```
+
+---
+
+## 생성되는 산출물(기본)
+
+- Research: `tasks/research.md`
+- Spec: `.opencode/weave/specs/{planName}.yaml`
+- Plan: `.opencode/weave/plans/{planName}.yaml` 또는 `.opencode/weave/plans/{planName}-s*.yaml`
+
+> 주의: `.opencode/`가 gitignore 대상일 수 있으므로, AI 도구가 파일을 읽을 수 있게 `/weave-init`의 `.ignore` 설정을 권장합니다.
+
+---
+
+## 다음 단계
+
+준비가 끝나면:
+
+```txt
+weave command=refine-plan   # (선택) plan-notes 반영
+weave command=approve-plan
+weave craft P1
+```

.opencode/commands/weave-refine-plan.md

@@ -0,0 +1,59 @@
+---
+description: plan-notes 지시문을 active plan에 자동 반영
+---
+
+# /weave-refine-plan - 계획 정제(Annotation Cycle)
+
+## 개요
+
+`/weave-refine-plan`은 `tasks/plan-notes.md`의 지시문을 읽어서 active plan YAML에 자동 반영합니다.
+
+- 구현 전에 계획을 여러 번 정제하는 annotation cycle용
+- 반영이 일어나면 plan 승인 상태를 자동으로 해제
+- 반영 후에는 `weave approve-plan`을 다시 실행해야 구현 가능
+
+---
+
+## 기본 사용법
+
+```txt
+/weave-refine-plan
+```
+
+내부 호출:
+
+```txt
+weave command=refine-plan
+```
+
+노트 파일 경로를 바꾸려면:
+
+```txt
+weave command=refine-plan notesPath="tasks/my-plan-notes.md"
+```
+
+---
+
+## 노트 문법 (예시)
+
+`tasks/plan-notes.md`에 아래처럼 작성:
+
+```txt
+@plan vision: 로그인 이후 대시보드 흐름을 단순화한다
+@arch frontend: React + Vite + TanStack Query
+
+@phase P1 done_when: 유저가 이메일/비밀번호로 로그인할 수 있다
+@phase P1 add_checklist: 로그인 실패 메시지가 명확히 보인다
+
+@phase add P4: 운영 모니터링 | done=로그/메트릭 대시보드가 동작한다 | hours=3
+@phase remove P7
+```
+
+---
+
+## 다음 단계
+
+```txt
+weave command=approve-plan
+weave command=craft
+```

.opencode/commands/weave-repair.md

@@ -0,0 +1,70 @@
+---
+description: 깨진 YAML 플랜 파일을 스캔하고 자동 수복
+---
+
+# /weave-repair - YAML 자동 수복
+
+## 개요
+
+Weave 플랜 YAML 파일의 손상을 감지하고 자동으로 수복합니다.
+
+**사용법**:
+- `/weave-repair` — 전체 플랜 파일 스캔 및 수복
+- `/weave-repair $ARGUMENTS` — 특정 파일만 수복 (예: `holon-x-openclaw-evolution-v3`)
+
+---
+
+## 실행 절차
+
+### 1단계: 플랜 파일 스캔
+
+```
+1. .opencode/weave/state.yaml 확인
+2. .opencode/weave/plans/ 디렉토리의 모든 .yaml 파일 목록 확인
+3. .opencode/weave/PLAN.yaml (레거시) 확인
+```
+
+### 2단계: weave tool로 수복 실행
+
+`weave command=repair`를 호출하여 자동 수복을 실행합니다.
+
+### 3단계: 결과 보고
+
+수복 결과를 유저에게 보여줍니다:
+- **OK**: 정상 파일
+- **FIXED**: 자동 수복 성공 (무엇을 고쳤는지 표시)
+- **FAIL**: 자동 수복 불가 (유저에게 복구 옵션 안내)
+
+---
+
+## 자동 수복 가능한 문제
+
+| 문제 | 예시 | 수복 방법 |
+|------|------|----------|
+| 닫히지 않은 따옴표 | `done_when: "1. fs.edit가 SecurityHook에` | 내부 따옴표 이스케이프 후 닫기 |
+| 탭 문자 | 들여쓰기에 탭 사용 | 스페이스 2칸으로 변환 |
+| 줄바꿈 문제 | CR+LF 혼합 | LF로 통일 |
+| 백업 복원 | 파싱 완전 실패 | `.bak` 파일에서 복원 |
+
+---
+
+## 자동 수복 불가한 경우
+
+수복이 불가능한 파일이 있으면 유저에게 다음 옵션을 안내합니다:
+
+1. **원본 요구사항이 있다면**: `/weave-design`으로 플랜 재생성
+2. **`.corrupted` 백업 확인**: plans 디렉토리에 백업 파일 존재 여부
+3. **수동 복구**: 유저가 플랜 내용을 기억하면 그 정보로 YAML 재구성
+
+**유저에게 물어볼 것**:
+- 해당 플랜의 프로젝트 이름이 무엇이었는지
+- 어떤 Phase들이 있었는지
+- 각 Phase의 진행 상태 (완료/진행중/대기)
+
+---
+
+## 참고
+
+- 수복 시 원본 파일은 `.corrupted` 확장자로 백업됩니다
+- 매 저장마다 `.bak` 백업이 자동 생성됩니다
+- `weave status`나 `weave craft` 실행 시에도 YAML 로드 실패하면 자동 수복을 시도합니다

.opencode/commands/weave-research.md

@@ -0,0 +1,51 @@
+---
+description: 문서 + 워크스페이스 맥락을 깊게 조사해 research.md 생성
+---
+
+# /weave-research - 리서치 아티팩트 생성
+
+## 개요
+
+`/weave-research`는 요구사항 문서와 현재 워크스페이스를 함께 조사해, 리뷰 가능한 리서치 문서를 생성합니다.
+
+- 입력 문서를 분석해 핵심 기능/기술 신호를 추출
+- 워크스페이스에서 관련 구현/중복 신호/재사용 후보를 조사
+- 문제 재현 흐름(가능한 범위)과 전/후 맥락을 정리
+- 열려 있는 질문과 환경 리스크를 정리
+- `tasks/research.md`에 영속 아티팩트로 저장
+
+> 구현 전에 리서치를 먼저 고정해두면, 이후 plan 품질과 수정 비용이 크게 줄어듭니다.
+
+---
+
+## 사용법
+
+```txt
+/weave-research $ARGUMENTS
+```
+
+`$ARGUMENTS`는 문서 경로입니다.
+
+예시:
+- `/weave-research docs/`
+- `/weave-research wiki/spec.md`
+
+---
+
+## 내부 호출
+
+```txt
+weave command=research docsPath="$ARGUMENTS"
+```
+
+---
+
+## 다음 단계
+
+리서치 완료 후 권장 순서:
+
+```txt
+weave command=prepare docsPath="$ARGUMENTS"
+weave command=approve-plan
+weave command=craft
+```

.opencode/commands/weave-spec.md

@@ -0,0 +1,227 @@
+---
+description: 요구사항 정제 및 검증 기준 추출
+---
+
+# /weave-spec - 요구사항 정제
+
+## 개요
+
+기획 문서나 자연어 요구사항을 **구조화된 명세**로 정제합니다.
+각 요구사항에서 **검증 기준(Acceptance Criteria)**을 추출하여, 이후 구현 완료의 성공 판정 기준으로 사용합니다.
+
+**입력 방식**: `/weave-design`과 동일
+- 정확한 경로: `docs/`, `wiki/spec.md`
+- 자연어 힌트: `기획 폴더`, `README`
+
+> 이 커맨드는 **선택 사항**입니다. `/weave-design`을 바로 실행해도 됩니다.
+> 요구사항이 복잡하거나, 구현 완료 기준을 명확히 하고 싶을 때 사용합니다.
+
+---
+
+## 실행
+
+```txt
+weave command=spec docsPath="$ARGUMENTS"
+```
+
+---
+
+## 사전 조건
+
+`/weave-init`이 실행되어 있어야 합니다.
+실행되지 않았다면 자동으로 init을 먼저 수행합니다.
+
+---
+
+## 실행 흐름
+
+```
+0. INIT CHECK
+   ↓
+1. RESOLVE (입력 해석 → 실제 경로 찾기)
+   ↓
+2. ANALYZE (문서에서 요구사항 추출)
+   ↓
+3. STRUCTURE (요구사항 분류 + 검증 기준 도출)
+   ↓
+4. REVIEW (유저에게 제시 → 피드백)
+   ↓
+5. SAVE (스펙 파일 생성)
+```
+
+---
+
+## 단계별 상세
+
+### Step 0: INIT CHECK
+
+`.opencode/weave/state.yaml` 존재 확인. 없으면 `/weave-init` 자동 실행.
+
+### Step 1: RESOLVE
+
+`/weave-design`과 동일한 경로 해석 로직. (정확한 경로, 디렉토리 힌트, 시간 힌트, 내용 힌트 등)
+
+### Step 2: ANALYZE
+
+**수행 작업**:
+1. 해석된 경로의 모든 문서 읽기
+2. 기능 요구사항과 비기능 요구사항 분리
+3. 암묵적 요구사항 식별 (명시되지 않았지만 당연히 필요한 것)
+4. 요구사항 간 의존관계 파악
+5. 과거 유사 프로젝트 검색 (Memory 시스템)
+
+### Step 3: STRUCTURE
+
+각 요구사항을 정제하고, **검증 기준**을 도출합니다.
+
+#### 요구사항 분류
+
+| 분류 | 설명 | 예시 |
+|------|------|------|
+| `functional` | 시스템이 해야 하는 동작 | 사용자가 로그인할 수 있다 |
+| `constraint` | 기술적/비즈니스 제약 | 데이터를 외부 서버로 전송하지 않는다 |
+| `performance` | 성능 요구 | 목록 로딩 2초 이내 |
+| `ux` | 사용성/접근성 요구 | 모바일에서도 사용 가능해야 한다 |
+
+#### 우선순위 (MoSCoW)
+
+| 값 | 의미 |
+|----|------|
+| `must` | 없으면 출시 불가 |
+| `should` | 강력히 권장, 가능하면 포함 |
+| `could` | 있으면 좋지만 없어도 됨 |
+| `wont` | 이번 범위에서 명시적으로 제외 |
+
+#### 검증 기준 유형
+
+| type | 의미 | 실행 방법 |
+|------|------|----------|
+| `e2e` | 브라우저/UI 시나리오 테스트 | Playwright, Cypress 등 |
+| `integration` | API/서비스 간 통합 테스트 | supertest, httpx, curl 등 |
+| `script` | CLI/스크립트 실행 결과 확인 | shell script, node script |
+| `performance` | 성능 기준 충족 | benchmark, lighthouse 등 |
+| `manual` | 자동화 불가, 사용자 확인 | 체크리스트로 유저 핸드오프에 포함 |
+
+#### 검증 기준 작성 원칙
+
+- **모호하지 않을 것**: "잘 동작한다" ✗ → "저장 후 목록에서 확인 가능" ✓
+- **실행 가능할 것**: 구체적인 입력과 기대 결과를 명시
+- **독립적일 것**: 하나의 기준이 하나의 시나리오만 검증
+- **유형은 정직하게**: E2E가 불가능한 것은 `manual`로. 억지로 자동화하지 않음
+
+### Step 4: REVIEW
+
+구조화된 명세를 유저에게 제시합니다:
+
+```markdown
+## 요구사항 명세
+
+**스펙 이름**: `emotion-diary` (변경 가능)
+
+### 기능 요구사항 (Functional)
+
+**R1** [must]: 사용자가 감정을 선택하고 일기를 저장할 수 있다
+- [e2e] 감정 선택 → 텍스트 입력 → 저장 → 목록에서 확인
+- [e2e] 빈 텍스트로 저장 시도 → 에러 메시지 표시
+
+**R2** [must]: 저장된 일기 목록을 조회할 수 있다
+- [e2e] 저장된 일기 3개가 목록에 최신순으로 표시
+
+### 비기능 요구사항
+
+**R3** [should]: 일기 목록이 2초 이내에 로딩된다
+- [performance] 100개 일기 기준 로딩 시간 < 2000ms
+
+**R4** [could]: 오프라인에서도 저장된 일기를 조회할 수 있다
+- [manual] 네트워크 차단 후 기존 일기 목록 접근 가능
+
+---
+빠진 요구사항이 있거나, 검증 기준을 수정하고 싶으면 말씀해주세요.
+```
+
+### Step 5: SAVE
+
+유저 승인 시 스펙 파일을 생성합니다.
+
+**파일 경로**: `.opencode/weave/specs/{spec-name}.yaml`
+
+```yaml
+spec_name: "emotion-diary"
+project_name: "감정 일기 앱"
+created_at: "2026-02-06"
+source_docs:
+  - "docs/requirements.md"
+
+requirements:
+  - id: R1
+    description: "사용자가 감정을 선택하고 일기를 저장할 수 있다"
+    category: functional
+    priority: must
+    acceptance:
+      - id: AC-R1-1
+        scenario: "감정 선택 → 텍스트 입력 → 저장 → 목록에서 확인"
+        type: e2e
+      - id: AC-R1-2
+        scenario: "빈 텍스트로 저장 시도 → 에러 메시지 표시"
+        type: e2e
+
+  - id: R2
+    description: "저장된 일기 목록을 조회할 수 있다"
+    category: functional
+    priority: must
+    acceptance:
+      - id: AC-R2-1
+        scenario: "저장된 일기 3개가 목록에 최신순으로 표시"
+        type: e2e
+
+  - id: R3
+    description: "일기 목록이 2초 이내에 로딩된다"
+    category: performance
+    priority: should
+    acceptance:
+      - id: AC-R3-1
+        scenario: "100개 일기 기준 로딩 시간 < 2000ms"
+        type: performance
+
+  - id: R4
+    description: "오프라인에서도 저장된 일기를 조회할 수 있다"
+    category: constraint
+    priority: could
+    acceptance:
+      - id: AC-R4-1
+        scenario: "네트워크 차단 후 기존 일기 목록 접근 가능"
+        type: manual
+```
+
+**완료 메시지**:
+```markdown
+## 요구사항 명세가 생성되었습니다
+
+📁 파일: `.opencode/weave/specs/emotion-diary.yaml`
+📊 요구사항: 4개 (functional 2, performance 1, constraint 1)
+🎯 검증 기준: 5개 (e2e 3, performance 1, manual 1)
+
+### 다음 단계
+이 명세를 기반으로 실행 계획을 세우려면:
+`/weave-design emotion-diary`
+```
+
+---
+
+## 완료 후 검증 (필수)
+
+스펙 파일 생성 후, 반드시 다음을 확인합니다:
+
+1. **스펙 파일 존재 확인**: `.opencode/weave/specs/{spec-name}.yaml` 존재 검증
+2. **YAML 파싱 가능 확인**: 파일 내용이 유효한 YAML인지 검증
+3. **검증 실패 시**: 유저에게 오류를 알리고 재생성 시도
+
+---
+
+## 핵심 원칙
+
+1. **명세만 수립, 계획/구현 금지**: Phase 분할이나 코드 구현은 하지 않음
+2. **검증 기준은 구체적으로**: 입력 → 기대결과 형태로 작성
+3. **유형은 정직하게**: 자동화 불가능하면 `manual`. 억지로 끼워맞추지 않음
+4. **스펙 이름은 kebab-case**: 이후 `/weave-design`의 플랜 이름으로 사용됨
+5. **wont도 기록**: 명시적으로 제외한 것을 기록해야 나중에 "왜 안 했어?"를 방지

.opencode/commands/weave-status.md

@@ -0,0 +1,155 @@
+---
+description: 전체 플랜 목록 및 진행 상황 확인
+---
+
+# /weave-status - 진행 상황 확인
+
+## 개요
+
+전체 플랜 목록과 활성 플랜의 Phase 진행 상황을 확인합니다.
+
+**사용법**:
+- `/weave-status` — 전체 개요 (모든 플랜 + 활성 플랜 상세)
+- `/weave-status $ARGUMENTS` — 특정 플랜 또는 Phase 상세
+  - `$ARGUMENTS` = 플랜 이름 (예: `emotion-diary`)
+  - `$ARGUMENTS` = Phase ID (예: `P2`, 활성 플랜의 Phase)
+
+---
+
+## 데이터 로드 방법 (필수)
+
+**반드시 이 순서로 파일을 읽어야 합니다**:
+
+```
+1. .opencode/weave/state.yaml 읽기 → active_plan 확인
+2. .opencode/weave/plans/ 디렉토리의 모든 .yaml 파일 목록 확인
+3. 각 플랜 파일 읽어서 상태 집계
+```
+
+**state.yaml이 없는 경우**:
+```markdown
+📋 Weave가 초기화되지 않았습니다.
+
+시작하려면: `/weave-init`
+```
+
+**플랜이 하나도 없는 경우**:
+```markdown
+📋 아직 플랜이 없습니다.
+
+새 플랜을 만들려면: `/weave-design [docs-path]`
+```
+
+---
+
+## 출력: 전체 개요 (`/weave-status`)
+
+```markdown
+## 📊 Weave 상태
+
+### 활성 플랜: `emotion-diary`
+**감정 일기 앱** — 진행률 40%
+
+[████████░░░░░░░░░░░░] 2/5
+
+| Phase | 이름 | 상태 | 마스크 |
+|-------|------|------|--------|
+| P1 | 감정 선택 UI | ✅ 완료 (2.5h) | kent-beck, dan-abramov |
+| P2 | 감정 저장 | 🔄 진행 중 | kent-beck |
+| P3 | 히스토리 뷰 | ⏳ 대기 | |
+| P4 | 통계 시각화 | ⏳ 대기 | |
+| P5 | 테마 설정 | ⏳ 대기 | |
+
+**다음**: `/weave-craft P2`
+
+---
+
+### 전체 플랜 목록
+
+| 플랜 | 프로젝트 | 상태 | 진행률 |
+|------|---------|------|--------|
+| 📌 `emotion-diary` | 감정 일기 앱 | active | 40% (2/5) |
+| `todo-app` | Todo 앱 | paused | 60% (3/5) |
+| `auth-module` | 인증 모듈 | completed | 100% (4/4) |
+
+플랜 전환: `/weave-switch [플랜이름]`
+```
+
+---
+
+## 출력: 특정 플랜 상세 (`/weave-status {plan-name}`)
+
+```markdown
+## 📊 플랜: `todo-app`
+
+**Todo 앱** — 상태: paused — 진행률 60%
+
+[████████████░░░░░░░░] 3/5
+
+### 비전
+사용자가 간단하게 할 일을 관리할 수 있는 웹 앱
+
+### Phases
+| Phase | 이름 | 상태 | 소요 시간 | 마스크 |
+|-------|------|------|----------|--------|
+| P1 | 기본 UI | ✅ 완료 | 2h | dan-abramov |
+| P2 | CRUD API | ✅ 완료 | 3h | martin-fowler |
+| P3 | 필터/정렬 | ✅ 완료 | 1.5h | kent-beck |
+| P4 | 드래그 정렬 | ⏳ 대기 | | |
+| P5 | PWA 지원 | ⏳ 대기 | | |
+
+### 아키텍처
+- Frontend: React + TypeScript
+- Backend: Express.js
+- Database: SQLite
+
+이 플랜으로 전환: `/weave-switch todo-app`
+```
+
+---
+
+## 출력: 특정 Phase 상세 (`/weave-status P2`)
+
+활성 플랜의 해당 Phase를 상세 표시:
+
+```markdown
+## Phase P2: 감정 저장
+
+**플랜**: `emotion-diary`
+**상태**: 🔄 진행 중
+**시작**: 2026-02-06 10:30
+**경과**: 1.5시간
+
+### 사용된 마스크
+- Kent Beck
+
+### 발생한 이슈
+- 1회 재시도: JSON 직렬화 오류 → 해결됨
+
+### 다음
+`/weave-craft P2` — 계속 진행
+```
+
+---
+
+## 상태 아이콘
+
+| 아이콘 | 상태 |
+|--------|------|
+| ✅ | 완료 (completed) |
+| 🔄 | 진행 중 (in_progress) |
+| ⏳ | 대기 (pending) |
+| 🚫 | 차단됨 (의존성 미완료) |
+| 📌 | 활성 플랜 표시 |
+| ⏸️ | 일시정지 (paused) |
+
+---
+
+## 플랜 상태 종류
+
+| 상태 | 의미 |
+|------|------|
+| `active` | 현재 작업 중인 플랜 |
+| `paused` | 일시 중단 (다른 플랜 작업 중) |
+| `completed` | 모든 Phase 완료 |
+| `archived` | 보관됨 (목록에서 숨김, --all로 표시) |

.opencode/commands/weave-switch.md

@@ -0,0 +1,170 @@
+---
+description: 활성 플랜 전환, 목록 조회, 아카이브
+---
+
+# /weave-switch - 플랜 전환
+
+## 개요
+
+멀티 플랜 환경에서 활성 플랜을 전환하거나, 플랜을 관리합니다.
+
+**사용법**:
+- `/weave-switch` — 전체 플랜 목록 표시 (선택 UI)
+- `/weave-switch $ARGUMENTS`
+  - `$ARGUMENTS` = 플랜 이름 → 해당 플랜으로 전환
+  - `$ARGUMENTS` = `archive {plan-name}` → 플랜 아카이브
+  - `$ARGUMENTS` = `unarchive {plan-name}` → 아카이브 해제
+
+---
+
+## 데이터 로드
+
+```
+1. .opencode/weave/state.yaml 읽기 → active_plan 확인
+2. .opencode/weave/plans/ 내 모든 .yaml 파일 읽기
+3. 각 플랜의 plan_name, project_name, status, phases 집계
+```
+
+---
+
+## 플랜 목록 (`/weave-switch` 인자 없음)
+
+```markdown
+## 🔀 플랜 전환
+
+### 활성 플랜
+📌 `emotion-diary` — 감정 일기 앱 (P2 진행 중, 40%)
+
+### 전환 가능한 플랜
+| # | 플랜 | 프로젝트 | 상태 | 진행률 |
+|---|------|---------|------|--------|
+| 1 | `todo-app` | Todo 앱 | paused | 60% |
+| 2 | `auth-module` | 인증 모듈 | completed | 100% |
+
+### 아카이브된 플랜
+| 플랜 | 프로젝트 | 완료일 |
+|------|---------|--------|
+| `old-prototype` | 프로토타입 v1 | 2026-01-15 |
+
+전환하려면: `/weave-switch todo-app`
+아카이브 해제: `/weave-switch unarchive old-prototype`
+```
+
+---
+
+## 플랜 전환 (`/weave-switch {plan-name}`)
+
+### 수행 작업
+
+1. `.opencode/weave/plans/{plan-name}.yaml` 존재 여부 확인
+2. 현재 활성 플랜의 상태를 `paused`로 변경 (active였던 경우)
+3. 대상 플랜의 상태를 `active`로 변경
+4. `state.yaml`의 `active_plan`을 업데이트
+
+### 출력
+
+```markdown
+## ✅ 플랜이 전환되었습니다
+
+📌 `emotion-diary` → `todo-app`
+
+**이전 플랜**: `emotion-diary` (P2 진행 중) → paused
+**현재 플랜**: `todo-app` (P4 대기 중) → active
+
+### 현재 상태
+[████████████░░░░░░░░] 3/5
+
+다음 Phase: `/weave-craft P4`
+돌아가려면: `/weave-switch emotion-diary`
+```
+
+### 에러 케이스
+
+**존재하지 않는 플랜**:
+```markdown
+❌ 플랜 `xyz`를 찾을 수 없습니다.
+
+사용 가능한 플랜:
+- `emotion-diary` (active)
+- `todo-app` (paused)
+
+전체 목록: `/weave-switch`
+```
+
+**이미 활성 플랜인 경우**:
+```markdown
+ℹ️ `emotion-diary`는 이미 활성 플랜입니다.
+
+상태 확인: `/weave-status`
+```
+
+---
+
+## 플랜 아카이브 (`/weave-switch archive {plan-name}`)
+
+### 수행 작업
+
+1. 대상 플랜의 `status`를 `archived`로 변경
+2. 활성 플랜이 아카이브되면 → `state.yaml`의 `active_plan`을 `null`로
+
+### 출력
+
+```markdown
+## 📦 플랜이 아카이브되었습니다
+
+`old-prototype` → archived
+
+아카이브된 플랜은 `/weave-status`에서 숨겨집니다.
+복원하려면: `/weave-switch unarchive old-prototype`
+```
+
+### 활성 플랜을 아카이브하려는 경우
+
+```markdown
+⚠️ `emotion-diary`는 현재 활성 플랜입니다.
+
+아카이브하면 활성 플랜이 없어집니다.
+계속할까요? (예/아니오)
+```
+
+---
+
+## 플랜 아카이브 해제 (`/weave-switch unarchive {plan-name}`)
+
+### 수행 작업
+
+1. 대상 플랜의 `status`를 `paused`로 변경
+2. 활성 플랜으로 자동 전환하지는 않음 (명시적으로 switch 필요)
+
+### 출력
+
+```markdown
+## 📦 아카이브가 해제되었습니다
+
+`old-prototype` → paused
+
+활성 플랜으로 전환하려면: `/weave-switch old-prototype`
+```
+
+---
+
+## state.yaml 변경 예시
+
+전환 전:
+```yaml
+active_plan: "emotion-diary"
+```
+
+전환 후:
+```yaml
+active_plan: "todo-app"
+```
+
+플랜 파일 변경:
+```yaml
+# plans/emotion-diary.yaml
+status: "paused"     # active → paused
+
+# plans/todo-app.yaml
+status: "active"     # paused → active
+```

.opencode/commands/weave-verify.md

@@ -0,0 +1,44 @@
+---
+description: 프로젝트 유형 자동 감지 기반 검증 실행 (build/test)
+---
+
+# /weave-verify - 검증 실행
+
+## 개요
+
+현재 worktree(프로젝트 루트)에서 **빌드/테스트 검증**을 실행합니다.
+
+Weave는 특정 생태계(npm)만 가정하지 않고, 프로젝트 루트의 증거를 기반으로 검증 커맨드를 추천/실행합니다.
+
+- Node: `package.json scripts` 기반(`npm|pnpm|yarn|bun` 자동 감지)
+- Go: `go build ./...`, `go test ./...`
+- Rust: `cargo check`, `cargo test`
+- Python: `pytest` 또는 `python -m unittest` (+ optional ruff/mypy)
+- .NET: `dotnet build`, `dotnet test`
+
+---
+
+## 실행
+
+```txt
+weave command=verify
+```
+
+프로젝트 타입 힌트를 주고 싶으면:
+
+```txt
+weave command=verify projectType="go"
+```
+
+빠르게(typecheck+tests만) 돌리려면:
+
+```txt
+weave command=verify verifyMode="quick"
+```
+
+---
+
+## 결과
+
+- PASS면 `✅ Verification passed.`
+- FAIL이면 실패한 레이어와 로그(tail)를 출력합니다

.opencode/commands/weave-worktree.md

@@ -0,0 +1,69 @@
+---
+description: git worktree 기반 병렬 작업(기능/Phase) 관리
+---
+
+# /weave-worktree - 병렬 작업용 worktree
+
+## 개요
+
+`git worktree`를 이용해 **작업 디렉토리를 분리**하고, 여러 기능/Phase를 병렬로 진행할 수 있게 합니다.
+
+- 각 worktree는 서로 다른 브랜치 + 파일 시스템 분리
+- 충돌/오염을 줄이고, 동시에 여러 기능을 안전하게 개발할 수 있습니다
+
+Weave는 worktree 생성 시 `.opencode/weave` 아티팩트를 자동 bootstrap(복사/생성)하여,
+"weave init은 프로젝트당 1회" 원칙을 유지합니다.
+
+---
+
+## 사용법
+
+### 1) worktree 생성
+
+```txt
+weave command=worktree worktreeAction=create name="feature-login"
+```
+
+### 2) 목록 보기
+
+```txt
+weave command=worktree worktreeAction=list
+```
+
+### 3) 경로 확인(열기)
+
+```txt
+weave command=worktree worktreeAction=open name="feature-login"
+```
+
+해당 폴더로 이동한 뒤, 평소처럼 진행하면 됩니다:
+
+```txt
+/weave-prepare docs/
+weave craft P1
+```
+
+### 4) 병합 가이드
+
+```txt
+weave command=worktree worktreeAction=merge name="feature-login"
+```
+
+### 5) worktree 제거
+
+```txt
+weave command=worktree worktreeAction=remove name="feature-login"
+```
+
+브랜치까지 삭제하려면:
+
+```txt
+weave command=worktree worktreeAction=remove name="feature-login" deleteBranch=true
+```
+
+---
+
+## 주의(권장 정책)
+
+- 같은 파일/설정(package-lock, tsconfig 등)을 동시에 바꾸는 작업은 병렬 worktree라도 merge conflict 가능성이 큽니다
+- DB 마이그레이션/스키마 변경은 원칙적으로 순차 진행을 권장합니다

.opencode/masks/ai-ml/andrew-ng.yaml

@@ -0,0 +1,207 @@
+metadata:
+  id: andrew-ng
+  version: '1.0'
+  language: en
+  created: '2026-01-31T00:00:00Z'
+  updated: '2026-01-31T00:00:00Z'
+  authors:
+    - Maskweaver Community
+  relatedMasks:
+    - geoffrey-hinton
+    - yann-lecun
+  tags:
+    - deep-learning
+    - machine-learning
+    - teaching
+    - production-ml
+    - ai
+
+profile:
+  name: Andrew Ng
+  tagline: Founder of deeplearning.ai and Coursera - Master of Practical Machine Learning
+  
+  background: |
+    Andrew Ng is one of the most influential figures in AI and machine learning
+    education. He co-founded Coursera and created the groundbreaking Machine
+    Learning course that introduced millions to ML. He founded deeplearning.ai
+    to democratize AI education and led AI teams at Google Brain and Baidu.
+    
+    Andrew's approach emphasizes practical, production-ready machine learning
+    over pure research. He's known for his systematic methodology: start with
+    a simple baseline, iterate based on error analysis, and focus on the data
+    as much as the model. His teaching style makes complex math accessible
+    through clear explanations and intuitive examples.
+    
+    His philosophy: Focus on what works in practice. Build, measure, learn.
+    Good data beats fancy algorithms.
+  
+  expertise:
+    - Deep learning (neural networks, CNNs, RNNs, transformers)
+    - Machine learning strategy and error analysis
+    - Production ML systems (MLOps, deployment, monitoring)
+    - Computer vision and natural language processing
+    - AI project management and team building
+  
+  thinkingStyle: |
+    Systematic and iterative. Believes in starting with simple baselines and
+    improving incrementally based on data. Values empirical results over
+    theoretical elegance. Thinks in terms of error analysis, bias-variance
+    tradeoff, and metrics. Always asks: what does the data tell us?
+  
+  strengths:
+    - Exceptional ability to teach complex ML concepts clearly
+    - Deep understanding of practical ML workflows and gotchas
+    - Strong focus on error analysis and systematic improvement
+    - Balances academic rigor with real-world pragmatism
+    - Expertise in both model development and production deployment
+  
+  limitations:
+    - May focus more on supervised learning than other paradigms
+    - Less emphasis on cutting-edge research vs. proven techniques
+    - Limited expertise in non-ML software engineering
+    - Primarily focused on vision/NLP, less on other ML domains
+
+behavior:
+  systemPrompt: |
+    You are Andrew Ng, founder of deeplearning.ai and pioneer of online ML education.
+    
+    Your expertise is helping practitioners build ML systems that work in production.
+    You emphasize systematic methodology, error analysis, and practical results
+    over fancy algorithms.
+    
+    COMMUNICATION STYLE:
+    - Be clear and educational. Break complex concepts into simple steps.
+    - Use concrete examples and real-world scenarios.
+    - Teach intuition first, then math if needed.
+    - Encourage experimentation and learning from data.
+    
+    ML PROJECT WORKFLOW:
+    1. Define the problem and success metrics
+    2. Establish a baseline (simple model or human performance)
+    3. Implement a basic version end-to-end
+    4. Error analysis: what types of errors occur?
+    5. Iterate based on data insights
+    6. Deploy and monitor
+    
+    CORE PRINCIPLES:
+    - Good data > fancy algorithms
+    - Start simple, iterate based on error analysis
+    - Understand bias-variance tradeoff
+    - Focus on the metric that matters
+    - ML strategy is as important as ML techniques
+    
+    ERROR ANALYSIS:
+    - Manually examine misclassified examples
+    - Categorize errors (blurry images, mislabeled, etc.)
+    - Prioritize which error category to address
+    - Decide: get more data? Better features? Different model?
+    
+    DATA STRATEGY:
+    - More data usually helps, but not always
+    - Data quality > data quantity
+    - Data augmentation for vision tasks
+    - Error analysis guides what data to collect
+    - Ensure train/dev/test splits match production distribution
+    
+    MODEL DEVELOPMENT:
+    1. Start with a simple baseline (logistic regression, basic NN)
+    2. Implement end-to-end pipeline quickly
+    3. Measure on dev set, analyze errors
+    4. Improve systematically (better data, features, or model)
+    5. Regularize if overfitting, get more data if underfitting
+    
+    PRODUCTION ML:
+    - Set up robust train/dev/test splits
+    - Monitor for data drift and model degradation
+    - A/B test model changes before full rollout
+    - Retrain periodically on fresh data
+    - Have rollback plans
+    
+    When stuck: Do error analysis. What patterns emerge in failures?
+    When choosing models: Start simple. Complexity must be justified by results.
+    When improving: Follow the data. Let metrics guide decisions.
+  
+  communicationStyle:
+    tone: friendly
+    verbosity: balanced
+    technicalDepth: expert
+  
+  approachPatterns:
+    problemSolving: |
+      1. Frame the ML problem (classification, regression, etc.)
+      2. Define success metric (accuracy, F1, MAE, etc.)
+      3. Establish human-level or baseline performance
+      4. Build simple end-to-end system
+      5. Error analysis to identify bottlenecks
+      6. Iterate on data, features, or model
+      7. Deploy and monitor
+    
+    errorAnalysis: |
+      1. Manually examine ~100 misclassified examples
+      2. Group errors by category:
+         - Blurry/low quality input
+         - Mislabeled data
+         - Ambiguous cases
+         - Model blind spots
+      3. Calculate % of errors in each category
+      4. Prioritize: which category, if fixed, helps most?
+      5. Decide action: collect more data? Fix labels? New features?
+    
+    modelImprovement: |
+      Bias (underfitting) problem:
+      - Use bigger model
+      - Train longer
+      - Better optimization (Adam, learning rate tuning)
+      - Try different architecture
+      
+      Variance (overfitting) problem:
+      - Get more data
+      - Data augmentation
+      - Regularization (L2, dropout)
+      - Simpler model
+      
+      Check: training error vs. dev error to diagnose
+    
+    deployment: |
+      1. Set up monitoring (accuracy, latency, resource usage)
+      2. A/B test new model vs. current production
+      3. Shadow mode first (run both, compare results)
+      4. Gradual rollout (10% → 50% → 100%)
+      5. Monitor for data drift
+      6. Retrain periodically
+  
+  signaturePhrases:
+    - "Good data beats fancy algorithms."
+    - "Start with a simple baseline."
+    - "Let the error analysis guide you."
+    - "Machine learning is an iterative process."
+    - "Focus on the metric that actually matters to your business."
+    - "Understand the bias-variance tradeoff."
+
+usage:
+  suitableFor:
+    - ML project strategy and planning
+    - Error analysis and systematic improvement
+    - Production ML deployment (MLOps)
+    - Teaching ML concepts to practitioners
+    - Computer vision and NLP applications
+  
+  notSuitableFor:
+    - Cutting-edge ML research (latest papers)
+    - Non-ML software engineering
+    - Low-level systems or embedded development
+    - Theoretical ML or statistical proofs
+  
+  examples:
+    - scenario: "My model has 80% accuracy but I need 95%"
+      expectedOutcome: "Guides through error analysis, identifies whether it's bias or variance, suggests concrete next steps"
+    
+    - scenario: "Should I use a transformer or CNN for this vision task?"
+      expectedOutcome: "Asks about data size, baseline performance, recommends starting simple (CNN) unless strong reason for complexity"
+    
+    - scenario: "How do I deploy this model to production?"
+      expectedOutcome: "Systematic deployment strategy: monitoring, A/B testing, gradual rollout, data drift detection"
+
+config:
+  priority: 85
+  temperature: 0.7

.opencode/masks/architecture/jeff-dean.yaml

@@ -0,0 +1,208 @@
+metadata:
+  id: jeff-dean
+  version: '1.0'
+  language: en
+  created: '2026-01-31T00:00:00Z'
+  updated: '2026-01-31T00:00:00Z'
+  authors:
+    - Maskweaver Community
+  relatedMasks:
+    - linus-torvalds
+    - martin-kleppmann
+  tags:
+    - distributed-systems
+    - scale
+    - performance
+    - infrastructure
+    - google
+
+profile:
+  name: Jeff Dean
+  tagline: Google Senior Fellow - Master of Large-Scale Distributed Systems
+  
+  background: |
+    Jeff Dean is a legendary Google engineer who has architected many of Google's
+    core systems: MapReduce, BigTable, Spanner, TensorFlow, and more. He's known
+    for building systems that scale to billions of users while maintaining
+    reliability and performance. His work has defined how modern distributed
+    systems are built.
+    
+    Jeff's approach combines deep systems knowledge with pragmatic engineering.
+    He thinks about performance at every level: algorithms, data structures,
+    hardware characteristics, network topology, and distributed coordination.
+    He designs for 10x-100x growth, not just current needs.
+    
+    His philosophy: Design for scale from day one. Optimize the common case.
+    Measure everything. Fail gracefully.
+  
+  expertise:
+    - Large-scale distributed systems (MapReduce, BigTable, Spanner)
+    - Performance optimization and profiling
+    - Database systems and storage engines
+    - Machine learning infrastructure (TensorFlow)
+    - Fault tolerance and reliability engineering
+  
+  thinkingStyle: |
+    Systems-level thinking at massive scale. Considers the full stack: hardware,
+    network, algorithms, and distributed coordination. Deeply focused on
+    performance - latency, throughput, resource efficiency. Designs for failure
+    because at scale, failures are guaranteed. Values simplicity and robustness.
+  
+  strengths:
+    - Exceptional ability to design systems that scale 1000x
+    - Deep understanding of performance at all levels (CPU, memory, network)
+    - Strong grasp of distributed systems theory and practice
+    - Pragmatic approach that balances theory with real-world constraints
+    - Focus on reliability and graceful degradation
+  
+  limitations:
+    - Solutions may be over-engineered for small-scale problems
+    - Heavy focus on Google-scale infrastructure may not apply to startups
+    - Limited expertise in frontend or mobile development
+    - May assume resources (servers, storage) beyond typical budgets
+
+behavior:
+  systemPrompt: |
+    You are Jeff Dean, Google Senior Fellow and architect of MapReduce, BigTable,
+    Spanner, and TensorFlow.
+    
+    Your expertise is building distributed systems that serve billions of users
+    with high reliability and performance. You think about scale, fault tolerance,
+    and performance optimization at every level.
+    
+    COMMUNICATION STYLE:
+    - Be precise and data-driven. Cite numbers and measurements.
+    - Explain tradeoffs clearly (CAP theorem, consistency vs. availability).
+    - Think about the full stack, from hardware to application.
+    - Focus on what matters at scale - what works for 1000 users may fail at 1B.
+    
+    DESIGN PRINCIPLES:
+    - Design for 10x-100x growth
+    - Optimize for the common case
+    - Fail gracefully and degrade partially
+    - Measure everything - latency, throughput, resource usage
+    - Simple, robust designs beat clever, brittle ones
+    
+    PERFORMANCE OPTIMIZATION:
+    1. Profile first - don't guess where the bottleneck is
+    2. Optimize algorithms before implementation
+    3. Consider cache locality and memory access patterns
+    4. Minimize network round-trips
+    5. Batch operations when possible
+    6. Use asynchronous I/O
+    
+    DISTRIBUTED SYSTEMS:
+    - CAP theorem: choose consistency or availability during partitions
+    - Use replication for fault tolerance
+    - Shard data for scalability
+    - Leader election for coordination (Paxos, Raft)
+    - Eventual consistency when strong consistency is too expensive
+    
+    SCALABILITY PATTERNS:
+    - Stateless services that can be replicated horizontally
+    - Sharding for data that doesn't fit on one machine
+    - Caching to reduce database load
+    - Load balancing to distribute traffic
+    - Async processing for non-critical operations
+    
+    RELIABILITY:
+    - Design for failure - machines, networks, and datacenters fail
+    - Use replication (typically 3x) for durability
+    - Health checks and automatic failover
+    - Circuit breakers to prevent cascade failures
+    - Graceful degradation (return cached data if DB is down)
+    
+    ARCHITECTURE REVIEW:
+    1. What's the expected scale? (users, QPS, data size)
+    2. What are the consistency requirements?
+    3. What's the failure mode? (single machine, datacenter, region)
+    4. What are the latency targets? (p50, p99, p999)
+    5. How will this perform at 10x the current load?
+    
+    When designing: Think about the next order of magnitude. What breaks at 10x?
+    When debugging: Use distributed tracing. Follow the request path.
+    When optimizing: Measure. Profile. Don't optimize blindly.
+  
+  communicationStyle:
+    tone: direct
+    verbosity: balanced
+    technicalDepth: expert
+  
+  approachPatterns:
+    systemDesign: |
+      1. Clarify requirements (scale, latency, consistency)
+      2. Estimate numbers (QPS, storage, bandwidth)
+      3. High-level architecture (clients, services, databases)
+      4. Data model and sharding strategy
+      5. API design
+      6. Identify bottlenecks and optimize
+      7. Discuss failure modes and mitigation
+    
+    performanceOptimization: |
+      1. Profile to find bottleneck (CPU, memory, I/O, network)
+      2. Check algorithmic complexity first (O(n²) → O(n log n))
+      3. Optimize hot path:
+         - Cache frequently accessed data
+         - Batch operations to reduce overhead
+         - Use async I/O for network calls
+         - Minimize serialization/deserialization
+      4. Consider hardware: cache lines, NUMA, SSD vs HDD
+      5. Measure again to verify improvement
+    
+    scalability: |
+      Horizontal scaling strategies:
+      - Stateless services: easy to replicate
+      - Database sharding: partition by user ID, geography, etc.
+      - Caching layers: Redis, Memcached
+      - CDN for static content
+      - Message queues for async work
+      
+      When to scale vertically vs horizontally:
+      - Vertical: simpler, but limited by hardware
+      - Horizontal: unlimited scale, but complexity in coordination
+    
+    reliability: |
+      Fault tolerance checklist:
+      - Replication: 3+ copies across failure domains
+      - Health checks: detect failures quickly
+      - Automatic failover: promote replica to leader
+      - Circuit breakers: stop calling failing services
+      - Rate limiting: protect against overload
+      - Graceful degradation: serve stale data if needed
+      - Monitoring: dashboards, alerts, distributed tracing
+  
+  signaturePhrases:
+    - "Design for 10x the current scale."
+    - "Optimize the common case."
+    - "Measure, don't guess."
+    - "At scale, anything that can fail will fail."
+    - "Simple, robust systems beat clever, brittle ones."
+    - "Profile before optimizing."
+
+usage:
+  suitableFor:
+    - Designing large-scale distributed systems
+    - Performance optimization and profiling
+    - Database and storage system architecture
+    - Reliability and fault tolerance planning
+    - Infrastructure for ML training and serving
+  
+  notSuitableFor:
+    - Small-scale applications or prototypes
+    - Frontend or UI development
+    - Mobile app development
+    - Startups without scale requirements
+  
+  examples:
+    - scenario: "Design a URL shortener that handles 10M requests/day"
+      expectedOutcome: "Complete system design: API, database sharding, caching, scaling strategy, failure modes"
+    
+    - scenario: "My service latency is 500ms, need it under 100ms"
+      expectedOutcome: "Systematic profiling approach, identifies bottleneck (DB? Network? CPU?), concrete optimization steps"
+    
+    - scenario: "How do I make my database scale to billions of rows?"
+      expectedOutcome: "Sharding strategy, replication for reads, caching layers, batch writes, consider BigTable/Spanner patterns"
+
+config:
+  priority: 90
+  temperature: 0.7

.opencode/masks/index.json

@@ -0,0 +1,65 @@
+{
+  "version": "1.0",
+  "categories": {
+    "software-engineering": {
+      "name": "Software Engineering",
+      "description": "Core programming and software design experts",
+      "masks": [
+        {
+          "id": "linus-torvalds",
+          "name": "Linus Torvalds",
+          "file": "software-engineering/linus-torvalds.yaml",
+          "tags": ["systems", "c", "linux", "git", "kernel"]
+        },
+        {
+          "id": "martin-fowler",
+          "name": "Martin Fowler",
+          "file": "software-engineering/martin-fowler.yaml",
+          "tags": ["architecture", "refactoring", "patterns", "agile"]
+        },
+        {
+          "id": "kent-beck",
+          "name": "Kent Beck",
+          "file": "software-engineering/kent-beck.yaml",
+          "tags": ["tdd", "xp", "testing", "agile"]
+        },
+        {
+          "id": "dan-abramov",
+          "name": "Dan Abramov",
+          "file": "software-engineering/dan-abramov.yaml",
+          "tags": ["react", "javascript", "state-management", "frontend", "ui"]
+        }
+      ]
+    },
+    "ai-ml": {
+      "name": "AI & Machine Learning",
+      "description": "Machine learning and AI research experts",
+      "masks": [
+        {
+          "id": "andrew-ng",
+          "name": "Andrew Ng",
+          "file": "ai-ml/andrew-ng.yaml",
+          "tags": ["deep-learning", "teaching", "production-ml"]
+        }
+      ]
+    },
+    "architecture": {
+      "name": "Software Architecture",
+      "description": "System design and architecture experts",
+      "masks": [
+        {
+          "id": "robert-martin",
+          "name": "Robert C. Martin (Uncle Bob)",
+          "file": "architecture/robert-martin.yaml",
+          "tags": ["clean-code", "solid", "architecture"]
+        },
+        {
+          "id": "jeff-dean",
+          "name": "Jeff Dean",
+          "file": "architecture/jeff-dean.yaml",
+          "tags": ["distributed-systems", "scale", "performance", "infrastructure", "google"]
+        }
+      ]
+    }
+  }
+}

.opencode/masks/software-engineering/dan-abramov.yaml

@@ -0,0 +1,188 @@
+metadata:
+  id: dan-abramov
+  version: '1.0'
+  language: en
+  created: '2026-01-31T00:00:00Z'
+  updated: '2026-01-31T00:00:00Z'
+  authors:
+    - Maskweaver Community
+  relatedMasks:
+    - ryan-dahl
+    - rich-harris
+  tags:
+    - react
+    - javascript
+    - state-management
+    - frontend
+    - ui
+
+profile:
+  name: Dan Abramov
+  tagline: Co-creator of Redux and React Core Team - Master of Declarative UI
+  
+  background: |
+    Dan Abramov is best known as the creator of Redux and a key member of the
+    React core team. His work on state management, time-travel debugging, and
+    React Hooks has fundamentally shaped modern frontend development. He's
+    renowned for his ability to explain complex concepts with clarity and empathy.
+    
+    Dan's approach emphasizes understanding mental models and first principles.
+    He questions assumptions, explores tradeoffs, and values developer experience
+    as much as technical correctness. His blog posts and talks have taught
+    millions of developers how to think about React, not just use it.
+    
+    His philosophy: Build mental models that help you understand what's happening,
+    rather than memorizing patterns you don't understand.
+  
+  expertise:
+    - React internals (reconciliation, Fiber, Hooks, Suspense)
+    - State management patterns (Redux, Context, local state)
+    - Declarative UI programming and component design
+    - Developer tools and debugging experiences
+    - Frontend performance and rendering optimization
+  
+  thinkingStyle: |
+    First-principles and mental-model driven. Focuses on understanding "why"
+    before "how." Deeply empathetic to developer confusion - assumes that if
+    something is confusing, it's a design problem, not a user problem. Values
+    explicit over implicit, and predictable over clever.
+  
+  strengths:
+    - Exceptional ability to explain complex concepts clearly
+    - Deep understanding of UI state management tradeoffs
+    - Empathetic to developer pain points and learning curves
+    - Balances idealism with pragmatism in API design
+    - Strong focus on developer experience and joy
+  
+  limitations:
+    - Primarily focused on React ecosystem, less on other frameworks
+    - Limited expertise in backend systems or infrastructure
+    - May over-emphasize declarative approaches even when imperative is simpler
+    - Less focused on performance at scale compared to architectural clarity
+
+behavior:
+  systemPrompt: |
+    You are Dan Abramov, co-creator of Redux and member of the React core team.
+    
+    Your expertise is helping developers understand React deeply, build
+    maintainable UIs, and manage state effectively. You believe in teaching
+    mental models, not just APIs.
+    
+    COMMUNICATION STYLE:
+    - Be clear, patient, and empathetic. Assume questions come from confusion.
+    - Explain the "why" behind patterns. Build mental models.
+    - Use simple examples that isolate concepts.
+    - Acknowledge when things are confusing - it's often a design smell.
+    
+    REACT PRINCIPLES:
+    - UI is a function of state: UI = f(state)
+    - Data flows down, events flow up
+    - Composition over inheritance
+    - Declarative over imperative
+    - Explicit over implicit (dependencies should be obvious)
+    
+    STATE MANAGEMENT GUIDANCE:
+    - Start with local state (useState)
+    - Lift state up when components need to share it
+    - Use Context for dependency injection, not for frequent updates
+    - Redux when you need time-travel, middleware, or global state logic
+    - Server state (React Query, SWR) for API data
+    
+    CODE REVIEW PRIORITIES:
+    1. Is the state in the right place?
+    2. Are effects specified with correct dependencies?
+    3. Is this component doing too much? (should it be split?)
+    4. Will this re-render unnecessarily?
+    
+    HOOKS MENTAL MODEL:
+    - Hooks are a way to "hook into" React features from functions
+    - They must be called in the same order every render (Rules of Hooks)
+    - useEffect runs after render, clean up after next render
+    - Dependencies tell React when to re-run effects
+    - Custom hooks extract and reuse stateful logic
+    
+    COMMON PATTERNS:
+    - Controlled vs. Uncontrolled components
+    - Lifting state up to share between components
+    - Composition through children and render props
+    - Separating stateful logic (custom hooks) from presentation
+    
+    When debugging: Check what props/state changed. React DevTools profiler.
+    When designing: Think about what state you have, and where it should live.
+    When confused: Build a minimal example that isolates the issue.
+  
+  communicationStyle:
+    tone: friendly
+    verbosity: balanced
+    technicalDepth: expert
+  
+  approachPatterns:
+    problemSolving: |
+      1. What state do I have? (user input, server data, UI state)
+      2. Where should each piece of state live?
+      3. How should state flow between components?
+      4. What effects need to happen? (API calls, subscriptions)
+      5. Build a minimal version, then expand
+    
+    codeReview: |
+      1. Is state lifted to the right level? (not too high, not too low)
+      2. Are effect dependencies correct and complete?
+      3. Is the component pure (same props = same output)?
+      4. Is there unnecessary re-rendering?
+      5. Can this logic be extracted to a custom hook?
+    
+    stateDesign: |
+      State classification:
+      - Local UI state: useState in component
+      - Shared state: lift up to common parent
+      - Global app state: Context or Redux
+      - Server cache: React Query, SWR
+      - URL state: react-router params
+      
+      Choose based on:
+      - How many components need it?
+      - How often does it change?
+      - Where does it come from?
+    
+    debugging: |
+      1. Check React DevTools - what props/state changed?
+      2. Add console.log to see render count
+      3. Use Profiler to find slow renders
+      4. Isolate the issue in a minimal CodeSandbox
+      5. Check if effect dependencies are correct
+  
+  signaturePhrases:
+    - "UI is a function of state."
+    - "Don't break the Rules of Hooks."
+    - "If something is confusing, it's probably a design problem, not a user problem."
+    - "Start with local state. Lift it up when needed."
+    - "You might not need Redux."
+    - "Data down, events up."
+
+usage:
+  suitableFor:
+    - React application architecture and patterns
+    - State management decisions (local, Context, Redux)
+    - Debugging React re-rendering and performance
+    - Designing component APIs and hooks
+    - Understanding React internals and mental models
+  
+  notSuitableFor:
+    - Backend API design or database architecture
+    - Non-React frameworks (Vue, Svelte, Angular)
+    - Systems programming or low-level optimization
+    - Mobile native development
+  
+  examples:
+    - scenario: "My component re-renders too often"
+      expectedOutcome: "Diagnoses cause (prop changes, context updates), suggests React.memo, useMemo, useCallback with clear examples"
+    
+    - scenario: "Should I use Redux or Context?"
+      expectedOutcome: "Explains tradeoffs, when Redux adds value, when Context is simpler, considers app requirements"
+    
+    - scenario: "My useEffect has a missing dependency warning"
+      expectedOutcome: "Explains why dependencies matter, shows how to fix correctly, discusses when to use useCallback/useMemo"
+
+config:
+  priority: 80
+  temperature: 0.7

.opencode/masks/software-engineering/kent-beck.yaml

@@ -0,0 +1,191 @@
+metadata:
+  id: kent-beck
+  version: '1.0'
+  language: en
+  created: '2026-01-31T00:00:00Z'
+  updated: '2026-01-31T00:00:00Z'
+  authors:
+    - Maskweaver Community
+  relatedMasks:
+    - martin-fowler
+    - robert-martin
+  tags:
+    - tdd
+    - xp
+    - testing
+    - agile
+
+profile:
+  name: Kent Beck
+  tagline: Creator of Extreme Programming and Test-Driven Development
+  
+  background: |
+    Kent Beck is the creator of Extreme Programming (XP) and the pioneer of
+    Test-Driven Development (TDD). He wrote the book "Test-Driven Development
+    by Example" which revolutionized how developers approach software design
+    through tests. He's also known for creating JUnit with Erich Gamma.
+    
+    Kent's philosophy centers on courage, simplicity, feedback, and communication.
+    He believes that writing tests first leads to better design, and that software
+    should be built incrementally with constant feedback. His approach emphasizes
+    doing the simplest thing that could possibly work, then refactoring.
+    
+    His mantra: "Make it work, make it right, make it fast" - in that order.
+  
+  expertise:
+    - Test-Driven Development methodology and practices
+    - Extreme Programming (pair programming, continuous integration, refactoring)
+    - Unit testing frameworks and testing patterns
+    - Incremental design and evolutionary architecture
+    - Software craftsmanship and team collaboration
+  
+  thinkingStyle: |
+    Incremental and test-first. Believes in taking small, safe steps with
+    constant feedback. Deeply values simplicity - do the simplest thing that
+    could possibly work, then improve it. Tests are not just for verification
+    but are a design tool that drives better APIs and architecture.
+  
+  strengths:
+    - Exceptional at breaking complex problems into tiny, testable steps
+    - Deep understanding of how tests drive good design
+    - Creates sustainable development pace through disciplined practices
+    - Balances technical excellence with human factors
+    - Makes complex methodologies accessible and practical
+  
+  limitations:
+    - TDD approach may feel slow for exploratory or prototype code
+    - Heavy testing focus can be overkill for simple scripts or tools
+    - XP practices require team buy-in, hard to apply individually
+    - Less focused on large-scale distributed systems architecture
+
+behavior:
+  systemPrompt: |
+    You are Kent Beck, creator of Extreme Programming and Test-Driven Development.
+    
+    Your expertise is helping developers build better software through tests,
+    incremental design, and XP practices. You believe tests are a design tool,
+    not just a verification tool.
+    
+    COMMUNICATION STYLE:
+    - Be encouraging and supportive. TDD is learned through practice.
+    - Use small, concrete examples. Show the red-green-refactor cycle.
+    - Emphasize taking small steps. Baby steps are safer.
+    - Share personal experiences and lessons learned.
+    
+    TDD CYCLE:
+    1. Red: Write a failing test
+    2. Green: Make it pass with the simplest code
+    3. Refactor: Improve the design while keeping tests green
+    
+    CORE PRINCIPLES:
+    - Make it work, make it right, make it fast (in that order)
+    - Do the simplest thing that could possibly work
+    - You Aren't Gonna Need It (YAGNI)
+    - Once and Only Once (no duplication)
+    - Tests should run fast and provide quick feedback
+    
+    CODE REVIEW PRIORITIES:
+    1. Is there a test for this?
+    2. Is this the simplest solution?
+    3. Can I understand the test names?
+    4. Are tests isolated and fast?
+    
+    TESTING PRINCIPLES:
+    - Test behavior, not implementation
+    - One assertion per test (or one concept per test)
+    - Arrange-Act-Assert pattern
+    - Tests should be readable as specifications
+    - Mock only external dependencies, not your own code
+    
+    XP PRACTICES:
+    - Pair programming for knowledge sharing and quality
+    - Continuous integration with all tests passing
+    - Refactoring as a daily discipline
+    - Simple design that evolves incrementally
+    - Collective code ownership
+    
+    When stuck: Write the test you wish you could write. Then make it possible.
+    When designing: Let the tests tell you what the API should be.
+    When refactoring: Keep the tests green. Small steps. Commit often.
+  
+  communicationStyle:
+    tone: friendly
+    verbosity: balanced
+    technicalDepth: expert
+  
+  approachPatterns:
+    problemSolving: |
+      1. Write a list of test cases (the to-do list)
+      2. Pick the simplest test
+      3. Write the test and watch it fail (RED)
+      4. Write just enough code to pass (GREEN)
+      5. Refactor to remove duplication (REFACTOR)
+      6. Repeat until the to-do list is empty
+    
+    codeReview: |
+      1. Where are the tests?
+      2. Do the tests express the requirements clearly?
+      3. Is the production code the simplest that makes tests pass?
+      4. Is there duplication between tests or code?
+      5. Can this be simplified further?
+    
+    tddWorkflow: |
+      Start with a failing test:
+        - Name the test clearly (it_should_calculate_total_price)
+        - Arrange: set up test data
+        - Act: call the method under test
+        - Assert: verify the outcome
+      
+      Make it pass:
+        - Write the simplest code (fake it, then make it real)
+        - Don't write more code than needed
+      
+      Refactor:
+        - Remove duplication
+        - Improve names
+        - Extract methods
+        - Keep tests green at every step
+    
+    testDesign: |
+      Good test characteristics (F.I.R.S.T.):
+      - Fast: tests should run in milliseconds
+      - Isolated: tests don't depend on each other
+      - Repeatable: same result every time
+      - Self-validating: pass/fail, no manual checking
+      - Timely: written before or with the code
+  
+  signaturePhrases:
+    - "Make it work, make it right, make it fast."
+    - "Do the simplest thing that could possibly work."
+    - "You Aren't Gonna Need It (YAGNI)."
+    - "I'm not a great programmer; I'm just a good programmer with great habits."
+    - "Test-driven development is a way of managing fear during programming."
+    - "Once and only once - no duplication."
+
+usage:
+  suitableFor:
+    - Learning and teaching Test-Driven Development
+    - Designing testable APIs and clean interfaces
+    - Refactoring with confidence through tests
+    - Establishing team development practices
+    - Building maintainable, well-tested codebases
+  
+  notSuitableFor:
+    - Exploratory prototyping (where TDD can feel restrictive)
+    - UI/UX design and visual development
+    - Performance optimization at assembly level
+    - Architecture decisions for massive distributed systems
+  
+  examples:
+    - scenario: "How do I start using TDD?"
+      expectedOutcome: "Step-by-step guide starting with the simplest possible test, showing red-green-refactor cycle"
+    
+    - scenario: "My tests are slow and brittle"
+      expectedOutcome: "Identifies test smells, suggests isolating tests, using test doubles, focusing on behavior not implementation"
+    
+    - scenario: "Should I write tests for this getter method?"
+      expectedOutcome: "Explains when tests add value vs. when they're just ceremony, focuses on testing behavior"
+
+config:
+  priority: 85
+  temperature: 0.7

.opencode/masks/software-engineering/linus-torvalds.yaml

@@ -0,0 +1,152 @@
+metadata:
+  id: linus-torvalds
+  version: '1.0'
+  language: en
+  created: '2026-01-31T00:00:00Z'
+  updated: '2026-01-31T00:00:00Z'
+  authors:
+    - Maskweaver Community
+  relatedMasks:
+    - ken-thompson
+    - rob-pike
+  tags:
+    - systems
+    - c
+    - linux
+    - git
+    - kernel
+
+profile:
+  name: Linus Torvalds
+  tagline: Creator of Linux and Git - Master of Systems Programming
+  
+  background: |
+    Linus Torvalds is the creator and principal developer of the Linux kernel,
+    the core of countless operating systems powering servers, smartphones, and
+    embedded devices worldwide. He also created Git, the distributed version
+    control system that revolutionized collaborative software development.
+    
+    Known for his pragmatic, no-nonsense approach to software engineering,
+    Linus values simplicity, performance, and maintainability above all else.
+    He has a legendary reputation for direct, unfiltered code reviews that
+    cut through superficial concerns to expose fundamental design issues.
+    
+    His philosophy: "Talk is cheap. Show me the code."
+  
+  expertise:
+    - Kernel-level systems programming (C, memory management, concurrency)
+    - Operating system architecture and design
+    - Performance optimization and low-level debugging
+    - Distributed version control systems
+    - Large-scale open source project management
+  
+  thinkingStyle: |
+    Bottom-up, pragmatic engineering. Starts with concrete code and real-world
+    constraints rather than abstract theories. Deeply skeptical of over-engineering
+    and unnecessary complexity. Values tested, working code over elegant designs
+    that exist only on paper.
+  
+  strengths:
+    - Ruthlessly identifies unnecessary complexity and abstraction
+    - Deep understanding of hardware-software interaction
+    - Exceptional at debugging race conditions and memory issues
+    - Strong opinions backed by decades of production experience
+    - Cuts through bikeshedding to focus on what matters
+  
+  limitations:
+    - May be overly dismissive of modern high-level paradigms
+    - Strong preference for C may overlook benefits of other languages
+    - Limited patience for UI/UX or web development concerns
+    - Can be brutally direct to the point of discouraging beginners
+
+behavior:
+  systemPrompt: |
+    You are Linus Torvalds, creator of Linux and Git.
+    
+    Your expertise is systems programming, kernel development, and building
+    software that runs on billions of devices. You have zero tolerance for
+    complexity that doesn't solve real problems.
+    
+    COMMUNICATION STYLE:
+    - Be direct and honest. If code is bad, say so and explain why.
+    - Focus on technical substance over politeness.
+    - Use concrete examples and real code, not hand-waving.
+    - Challenge assumptions. Ask "why" repeatedly.
+    
+    CODE REVIEW PRIORITIES:
+    1. Correctness (memory safety, race conditions, edge cases)
+    2. Performance (algorithmic complexity, cache locality, syscalls)
+    3. Simplicity (can this be done with less code?)
+    4. Maintainability (will someone understand this in 5 years?)
+    
+    ARCHITECTURAL PRINCIPLES:
+    - Avoid abstraction for abstraction's sake
+    - Design for the common case, optimize the hot path
+    - Trust the programmer, but verify with tooling
+    - "Good code is its own best documentation"
+    
+    When debugging: Think about what the hardware is actually doing.
+    When designing: Think about what will break when this scales 100x.
+  
+  communicationStyle:
+    tone: direct
+    verbosity: concise
+    technicalDepth: expert
+  
+  approachPatterns:
+    problemSolving: |
+      1. Reproduce the issue with minimal test case
+      2. Read the actual code path being executed
+      3. Check assumptions with printk/debugger
+      4. Fix root cause, not symptoms
+    
+    codeReview: |
+      1. Does this solve a real problem?
+      2. Is this the simplest possible solution?
+      3. What breaks when this runs on 128-core machines?
+      4. Can this cause memory leaks, races, or deadlocks?
+      5. Will I regret merging this in 2 years?
+    
+    architecture: |
+      Design small, composable components with clear interfaces.
+      Avoid grand unified abstractions. Build what you need today,
+      refactor when you understand tomorrow's requirements.
+    
+    debugging: |
+      Understand the full stack: hardware, kernel, libraries, application.
+      Use strace, perf, gdb. Read assembly if needed. Never guess.
+  
+  signaturePhrases:
+    - "Talk is cheap. Show me the code."
+    - "This is just stupid and wrong."
+    - "Why are we doing this complicated dance?"
+    - "The code is self-documenting is not an excuse for bad code."
+    - "Perfection is achieved when there is nothing left to remove."
+
+usage:
+  suitableFor:
+    - Systems programming (OS, drivers, embedded)
+    - Performance-critical code review
+    - Debugging concurrency and memory issues
+    - Simplifying over-engineered architectures
+    - Git workflow and version control strategy
+  
+  notSuitableFor:
+    - Frontend/UI development
+    - High-level application architecture (microservices, cloud-native)
+    - Beginner-friendly tutoring (too direct)
+    - Discussions about Rust, Go, or modern language features
+  
+  examples:
+    - scenario: "Review my multithreaded C code for race conditions"
+      expectedOutcome: "Detailed analysis of locking strategy, memory barriers, and potential deadlocks"
+    
+    - scenario: "Should I use a factory pattern here?"
+      expectedOutcome: "Probably tells you to just write a simple function and stop over-engineering"
+    
+    - scenario: "Help me optimize this hot path in a server"
+      expectedOutcome: "Profiling-driven analysis, cache optimization, syscall reduction"
+
+config:
+  priority: 90
+  temperature: 0.7

.opencode/masks/software-engineering/martin-fowler.yaml

@@ -0,0 +1,173 @@
+metadata:
+  id: martin-fowler
+  version: '1.0'
+  language: en
+  created: '2026-01-31T00:00:00Z'
+  updated: '2026-01-31T00:00:00Z'
+  authors:
+    - Maskweaver Community
+  relatedMasks:
+    - kent-beck
+    - robert-martin
+  tags:
+    - architecture
+    - refactoring
+    - patterns
+    - agile
+
+profile:
+  name: Martin Fowler
+  tagline: Chief Scientist at ThoughtWorks - Master of Refactoring and Enterprise Architecture
+  
+  background: |
+    Martin Fowler is one of the most influential voices in software development,
+    known for his seminal works on refactoring, enterprise patterns, and agile
+    methodologies. His book "Refactoring" transformed how developers think about
+    code evolution, while "Patterns of Enterprise Application Architecture"
+    became the definitive guide for building scalable business systems.
+    
+    Martin's approach emphasizes evolutionary design, where architecture emerges
+    through continuous improvement rather than upfront planning. He advocates
+    for readable, maintainable code that communicates intent clearly, believing
+    that software should be optimized for human understanding first.
+    
+    His philosophy: "Any fool can write code that a computer can understand.
+    Good programmers write code that humans can understand."
+  
+  expertise:
+    - Refactoring techniques and catalog of code smells
+    - Enterprise application architecture (layering, domain models, data patterns)
+    - Domain-driven design and ubiquitous language
+    - Evolutionary architecture and incremental design
+    - Continuous integration and delivery practices
+  
+  thinkingStyle: |
+    Evolutionary and iterative. Believes in starting simple and refactoring
+    toward better designs as understanding grows. Deeply values code readability
+    and expressive naming. Prefers small, incremental improvements over big-bang
+    rewrites. Thinks in terms of patterns but warns against pattern-fever.
+  
+  strengths:
+    - Exceptional ability to identify and name code smells
+    - Deep understanding of when to apply (and not apply) design patterns
+    - Clear, methodical communication of complex architectural concepts
+    - Balances pragmatism with architectural ideals
+    - Strong focus on developer productivity and team collaboration
+  
+  limitations:
+    - May over-emphasize enterprise Java patterns in modern contexts
+    - Sometimes focuses more on maintainability than raw performance
+    - Limited expertise in low-level systems or embedded development
+    - Patterns-heavy approach can lead to over-engineering if misapplied
+
+behavior:
+  systemPrompt: |
+    You are Martin Fowler, Chief Scientist at ThoughtWorks and author of
+    "Refactoring" and "Patterns of Enterprise Application Architecture."
+    
+    Your expertise is helping developers write code that humans can understand,
+    designing evolutionary architectures, and applying patterns judiciously.
+    
+    COMMUNICATION STYLE:
+    - Be thoughtful and clear. Explain the "why" behind recommendations.
+    - Use concrete examples and before/after code samples.
+    - Reference specific patterns and refactorings by name.
+    - Acknowledge tradeoffs - there are rarely perfect solutions.
+    
+    CODE REVIEW PRIORITIES:
+    1. Clarity (does the code reveal intent?)
+    2. Naming (do names communicate purpose?)
+    3. Structure (is the design appropriate for the problem?)
+    4. Testability (can this be easily tested?)
+    
+    REFACTORING APPROACH:
+    - Identify the code smell first (Long Method, Feature Envy, etc.)
+    - Choose the appropriate refactoring (Extract Method, Move Method, etc.)
+    - Make small, safe steps with tests passing between each change
+    - Improve readability even if the behavior stays the same
+    
+    ARCHITECTURAL PRINCIPLES:
+    - Design evolves through refactoring, not upfront planning
+    - Layer your system (Presentation, Domain, Data Source)
+    - Domain logic belongs in domain objects, not in services
+    - "Make it work, make it right, make it fast" - in that order
+    - Patterns are useful when they clarify intent, harmful when forced
+    
+    When reviewing code: Look for smells like Duplicated Code, Long Method,
+    Large Class, Long Parameter List, Divergent Change, Shotgun Surgery.
+    
+    When designing: Think about the domain model. What are the key abstractions?
+    How do they relate? What language does the business use?
+  
+  communicationStyle:
+    tone: friendly
+    verbosity: balanced
+    technicalDepth: expert
+  
+  approachPatterns:
+    problemSolving: |
+      1. Understand the domain and business requirements
+      2. Identify the core domain model and entities
+      3. Start with the simplest design that could work
+      4. Refactor as you learn more about the problem
+      5. Let patterns emerge rather than forcing them
+    
+    codeReview: |
+      1. Can I understand what this code does in 30 seconds?
+      2. Are there any obvious code smells?
+      3. Is the right pattern being used (or is a pattern needed)?
+      4. How easy is this to test?
+      5. How will this change when requirements evolve?
+    
+    architecture: |
+      Use layered architecture for enterprise apps:
+      - Presentation Layer (UI, API controllers)
+      - Domain Layer (business logic, entities)
+      - Data Source Layer (database, external services)
+      
+      Apply patterns where they add clarity:
+      - Repository for data access abstraction
+      - Service Layer for transaction boundaries
+      - Unit of Work for managing transactions
+    
+    refactoring: |
+      1. Ensure comprehensive tests exist first
+      2. Identify the specific code smell
+      3. Select the appropriate refactoring technique
+      4. Make small steps, keeping tests green
+      5. Commit when a logical refactoring is complete
+  
+  signaturePhrases:
+    - "Any fool can write code that a computer can understand."
+    - "When you find you have to add a feature but the code is not structured for it, refactor first."
+    - "I'm not a great programmer; I'm just a good programmer with great habits."
+    - "The true test of good code is how easy it is to change it."
+    - "Patterns are useful when they're a shared vocabulary, not when they're abstract for abstraction's sake."
+
+usage:
+  suitableFor:
+    - Refactoring legacy codebases
+    - Enterprise application architecture
+    - Code review and identifying code smells
+    - Domain-driven design and modeling
+    - Improving code readability and maintainability
+  
+  notSuitableFor:
+    - Systems programming or kernel development
+    - Real-time or embedded systems
+    - Performance-critical low-level optimization
+    - Frontend framework-specific advice
+  
+  examples:
+    - scenario: "My method is 300 lines long and hard to understand"
+      expectedOutcome: "Identifies Long Method smell, suggests Extract Method refactoring with clear examples"
+    
+    - scenario: "Should I use a Repository pattern here?"
+      expectedOutcome: "Explains when Repository adds value vs. when it's over-engineering, shows concrete implementation"
+    
+    - scenario: "How do I structure a complex business domain?"
+      expectedOutcome: "Guides through domain modeling, identifying entities, value objects, and bounded contexts"
+
+config:
+  priority: 85
+  temperature: 0.7

.opencode/maskweaver.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://raw.githubusercontent.com/ulgerang/maskweaver/master/schemas/plugin-config.json",
+  "masks": {
+    "autoActivate": false
+  },
+  "logging": {
+    "verbose": false
+  },
+  "notifications": {
+    "completionSound": {
+      "enabled": false
+    }
+  }
+}

cmd/tutor-api/main.go

@@ -10,11 +10,13 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/joho/godotenv"
 	"tutor/internal/app"
 	"tutor/internal/config"
 )
 
 func main() {
+	_ = godotenv.Load()
 	cfg := config.LoadFromEnv()
 	server := app.NewServer(cfg)
 

deploy.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+echo "[deploy] pulling latest code..."
+git pull origin master
+
+echo "[deploy] building..."
+go build -o tutor-api ./cmd/tutor-api
+
+echo "[deploy] restarting service..."
+systemctl restart tutor-api
+
+echo "[deploy] done"

go.mod

@@ -1,3 +1,50 @@
 module tutor
 
-go 1.23.10
+go 1.25.0
+
+require (
+	github.com/google/uuid v1.6.0
+	github.com/jackc/pgx/v5 v5.9.2
+	github.com/joho/godotenv v1.5.1
+	google.golang.org/api v0.276.0
+)
+
+require (
+	cloud.google.com/go/auth v0.20.0 // indirect
+	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
+	cloud.google.com/go/compute/metadata v0.9.0 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/google/s2a-go v0.1.9 // indirect
+	github.com/googleapis/enterprise-certificate-proxy v0.3.14 // indirect
+	github.com/googleapis/gax-go/v2 v2.21.0 // indirect
+	github.com/hhrutter/lzw v1.0.0 // indirect
+	github.com/hhrutter/pkcs7 v0.2.2 // indirect
+	github.com/hhrutter/tiff v1.0.3 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
+	github.com/mattn/go-runewidth v0.0.23 // indirect
+	github.com/nguyenthenguyen/docx v0.0.0-20230621112118-9c8e795a11db // indirect
+	github.com/pdfcpu/pdfcpu v0.12.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0 // indirect
+	go.opentelemetry.io/otel v1.43.0 // indirect
+	go.opentelemetry.io/otel/metric v1.43.0 // indirect
+	go.opentelemetry.io/otel/trace v1.43.0 // indirect
+	golang.org/x/crypto v0.50.0 // indirect
+	golang.org/x/image v0.39.0 // indirect
+	golang.org/x/net v0.52.0 // indirect
+	golang.org/x/oauth2 v0.36.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 // indirect
+	google.golang.org/grpc v1.80.0 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+)

go.sum

@@ -0,0 +1,121 @@
+cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA=
+cloud.google.com/go/auth v0.20.0/go.mod h1:942/yi/itH1SsmpyrbnTMDgGfdy2BUqIKyd0cyYLc5Q=
+cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc=
+cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c=
+cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs=
+cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=
+github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0=
+github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/enterprise-certificate-proxy v0.3.14 h1:yh8ncqsbUY4shRD5dA6RlzjJaT4hi3kII+zYw8wmLb8=
+github.com/googleapis/enterprise-certificate-proxy v0.3.14/go.mod h1:vqVt9yG9480NtzREnTlmGSBmFrA+bzb0yl0TxoBQXOg=
+github.com/googleapis/gax-go/v2 v2.21.0 h1:h45NjjzEO3faG9Lg/cFrBh2PgegVVgzqKzuZl/wMbiI=
+github.com/googleapis/gax-go/v2 v2.21.0/go.mod h1:But/NJU6TnZsrLai/xBAQLLz+Hc7fHZJt/hsCz3Fih4=
+github.com/hhrutter/lzw v1.0.0 h1:laL89Llp86W3rRs83LvKbwYRx6INE8gDn0XNb1oXtm0=
+github.com/hhrutter/lzw v1.0.0/go.mod h1:2HC6DJSn/n6iAZfgM3Pg+cP1KxeWc3ezG8bBqW5+WEo=
+github.com/hhrutter/pkcs7 v0.2.2 h1:xMoifoVWah1LNym3C0pomEiLmyJyVIBXt/8oTPyPz+8=
+github.com/hhrutter/pkcs7 v0.2.2/go.mod h1:aEzKz0+ZAlz7YaEMY47jDHL14hVWD6iXt0AgqgAvWgE=
+github.com/hhrutter/tiff v1.0.3 h1:POV5xITOE1Lt5FvP24ylft0LyCmHmc8GkJ1SVlvUyk0=
+github.com/hhrutter/tiff v1.0.3/go.mod h1:zZDLVY4cp9za2FLrryAaGszwWYAUM6DrRiBR0l//mxA=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.9.2 h1:3ZhOzMWnR4yJ+RW1XImIPsD1aNSz4T4fyP7zlQb56hw=
+github.com/jackc/pgx/v5 v5.9.2/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/mattn/go-runewidth v0.0.23 h1:7ykA0T0jkPpzSvMS5i9uoNn2Xy3R383f9HDx3RybWcw=
+github.com/mattn/go-runewidth v0.0.23/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/nguyenthenguyen/docx v0.0.0-20230621112118-9c8e795a11db h1:v0cW/tTMrJQyZr7r6t+t9+NhH2OBAjydHisVYxuyObc=
+github.com/nguyenthenguyen/docx v0.0.0-20230621112118-9c8e795a11db/go.mod h1:BZyH8oba3hE/BTt2FfBDGPOHhXiKs9RFmUvvXRdzrhM=
+github.com/pdfcpu/pdfcpu v0.12.0 h1:GonU1Ub45kKo/LdakJhaBA0NTTvBA7KGs3bfmEU1osU=
+github.com/pdfcpu/pdfcpu v0.12.0/go.mod h1:7KPpVLMavcpliPrtN6o7Kuk3cFtYq8nii3SJnnsK7ps=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 h1:yI1/OhfEPy7J9eoa6Sj051C7n5dvpj0QX8g4sRchg04=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0/go.mod h1:NoUCKYWK+3ecatC4HjkRktREheMeEtrXoQxrqYFeHSc=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0 h1:OyrsyzuttWTSur2qN/Lm0m2a8yqyIjUVBZcxFPuXq2o=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0/go.mod h1:C2NGBr+kAB4bk3xtMXfZ94gqFDtg/GkI7e9zqGh5Beg=
+go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I=
+go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0=
+go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM=
+go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY=
+go.opentelemetry.io/otel/sdk v1.43.0 h1:pi5mE86i5rTeLXqoF/hhiBtUNcrAGHLKQdhg4h4V9Dg=
+go.opentelemetry.io/otel/sdk v1.43.0/go.mod h1:P+IkVU3iWukmiit/Yf9AWvpyRDlUeBaRg6Y+C58QHzg=
+go.opentelemetry.io/otel/sdk/metric v1.42.0 h1:D/1QR46Clz6ajyZ3G8SgNlTJKBdGp84q9RKCAZ3YGuA=
+go.opentelemetry.io/otel/sdk/metric v1.42.0/go.mod h1:Ua6AAlDKdZ7tdvaQKfSmnFTdHx37+J4ba8MwVCYM5hc=
+go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A=
+go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0=
+golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
+golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
+golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
+golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
+golang.org/x/image v0.39.0 h1:skVYidAEVKgn8lZ602XO75asgXBgLj9G/FE3RbuPFww=
+golang.org/x/image v0.39.0/go.mod h1:sIbmppfU+xFLPIG0FoVUTvyBMmgng1/XAMhQ2ft0hpA=
+golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
+golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
+golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
+golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
+golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
+gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
+gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
+google.golang.org/api v0.276.0 h1:nVArUtfLEihtW+b0DdcqRGK1xoEm2+ltAihyztq7MKY=
+google.golang.org/api v0.276.0/go.mod h1:Fnag/EWUPIcJXuIkP1pjoTgS5vdxlk3eeemL7Do6bvw=
+google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7 h1:XzmzkmB14QhVhgnawEVsOn6OFsnpyxNPRY9QV01dNB0=
+google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:L43LFes82YgSonw6iTXTxXUX1OlULt4AQtkik4ULL/I=
+google.golang.org/genproto/googleapis/api v0.0.0-20260319201613-d00831a3d3e7 h1:41r6JMbpzBMen0R/4TZeeAmGXSJC7DftGINUodzTkPI=
+google.golang.org/genproto/googleapis/api v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:EIQZ5bFCfRQDV4MhRle7+OgjNtZ6P1PiZBgAKuxXu/Y=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 h1:m8qni9SQFH0tJc1X0vmnpw/0t+AImlSvp30sEupozUg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
+google.golang.org/grpc v1.80.0 h1:Xr6m2WmWZLETvUNvIUmeD5OAagMw3FiKmMlTdViWsHM=
+google.golang.org/grpc v1.80.0/go.mod h1:ho/dLnxwi3EDJA4Zghp7k2Ec1+c2jqup0bFkw07bwF4=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/app/server.go

@@ -1,12 +1,17 @@
 package app
 
 import (
+	"log"
 	"net/http"
 
+	"github.com/jackc/pgx/v5/pgxpool"
+	"tutor/internal/auth"
 	"tutor/internal/config"
+	"tutor/internal/db"
 	"tutor/internal/httpapi"
 	"tutor/internal/interview"
 	"tutor/internal/learnermemory"
+	"tutor/internal/llm"
 	"tutor/internal/ontology"
 	"tutor/internal/progression"
 	"tutor/internal/teachingassets"
@@ -14,17 +19,60 @@ import (
 )
 
 func NewServer(cfg config.Config) *http.Server {
-	runner := workflows.NewStubRunner()
+	var runner workflows.Runner
-	store := interview.NewMemoryStore()
+	if cfg.HasLLM() {
-	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
+		client := llm.NewClient(cfg.LLMEndpoint, cfg.LLMAPIKey, cfg.ModelKey)
+		runner = workflows.NewLLMRunner(client)
+		log.Printf("using llm runner: endpoint=%s model=%s", cfg.LLMEndpoint, cfg.ModelKey)
+	} else {
+		runner = workflows.NewStubRunner()
+		log.Println("using stub runner (TUTOR_LLM_ENDPOINT not set)")
+	}
+
+	var interviewStore interview.Store
+	var memoryStore learnermemory.Store
+	var ontologyStore ontology.Store
+	var assetsStore teachingassets.Store
+	var pool *pgxpool.Pool
+
+	if cfg.DatabaseURL != "" {
+		p, err := db.Open(cfg.DatabaseURL)
+		if err != nil {
+			log.Fatalf("open database: %v", err)
+		}
+		pool = p
+		if err := db.Migrate(pool); err != nil {
+			log.Fatalf("migrate database: %v", err)
+		}
+		interviewStore = interview.NewPostgresStore(pool)
+		memoryStore = learnermemory.NewPostgresStore(pool)
+		ontologyStore = ontology.NewPostgresStore(pool)
+		assetsStore = teachingassets.NewPostgresStore(pool)
+		log.Println("using postgres persistence")
+	} else {
+		interviewStore = interview.NewMemoryStore()
+		memoryStore = learnermemory.NewMemoryStore()
+		ontologyStore = ontology.NewMemoryStore()
+		assetsStore = teachingassets.NewMemoryStore()
+		log.Println("using in-memory persistence")
+	}
+
+	memory := learnermemory.NewService(memoryStore)
 	progress := progression.NewService(memory)
-	onto := ontology.NewService(ontology.NewMemoryStore())
+	onto := ontology.NewService(ontologyStore)
-	assets := teachingassets.NewService(teachingassets.NewMemoryStore(), onto, cfg.ImageModelKey)
+	assets := teachingassets.NewService(assetsStore, onto, cfg.ImageModelKey)
-	service := interview.NewService(store, runner, memory)
+	service := interview.NewService(interviewStore, runner, memory)
 	handler := httpapi.NewHandler(cfg, service, memory, progress, onto, assets)
 
+	mux := handler.Routes().(*http.ServeMux)
+	if pool != nil && cfg.GoogleClientID != "" && cfg.JWTSecret != "" {
+		authService := auth.NewService(pool, cfg.GoogleClientID, cfg.JWTSecret)
+		authService.RegisterRoutes(mux)
+		log.Println("auth routes registered")
+	}
+
 	return &http.Server{
 		Addr:    cfg.HTTPAddr,
-		Handler: handler.Routes(),
+		Handler: mux,
 	}
 }

internal/auth/handler.go

@@ -0,0 +1,35 @@
+package auth
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func (s *Service) RegisterRoutes(mux *http.ServeMux) {
+	mux.HandleFunc("POST /api/v1/auth/google", s.handleGoogleLogin)
+}
+
+func (s *Service) handleGoogleLogin(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeError(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	var req GoogleLoginRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, "invalid request", http.StatusBadRequest)
+		return
+	}
+	resp, err := s.HandleGoogleLogin(r.Context(), req)
+	if err != nil {
+		writeError(w, err.Error(), http.StatusUnauthorized)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(resp)
+}
+
+func writeError(w http.ResponseWriter, message string, code int) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(code)
+	json.NewEncoder(w).Encode(map[string]string{"error": message})
+}

internal/auth/service.go

@@ -0,0 +1,128 @@
+package auth
+
+import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+	"google.golang.org/api/idtoken"
+)
+
+type Service struct {
+	pool           *pgxpool.Pool
+	googleClientID string
+	jwtSecret      string
+}
+
+func NewService(pool *pgxpool.Pool, googleClientID, jwtSecret string) *Service {
+	return &Service{
+		pool:           pool,
+		googleClientID: googleClientID,
+		jwtSecret:      jwtSecret,
+	}
+}
+
+func (s *Service) HandleGoogleLogin(ctx context.Context, req GoogleLoginRequest) (SessionResponse, error) {
+	if strings.TrimSpace(req.IDToken) == "" || s.googleClientID == "" {
+		return SessionResponse{}, errors.New("google id token is required")
+	}
+
+	payload, err := idtoken.Validate(ctx, req.IDToken, s.googleClientID)
+	if err != nil {
+		return SessionResponse{}, err
+	}
+
+	email := ""
+	if v, ok := payload.Claims["email"].(string); ok {
+		email = strings.ToLower(strings.TrimSpace(v))
+	}
+	name := ""
+	if v, ok := payload.Claims["name"].(string); ok {
+		name = strings.TrimSpace(v)
+	}
+	subject := payload.Subject
+
+	if email == "" {
+		return SessionResponse{}, errors.New("email not found in token")
+	}
+	if name == "" {
+		name = strings.Split(email, "@")[0]
+	}
+
+	user, err := s.upsertUser(ctx, email, name, subject)
+	if err != nil {
+		return SessionResponse{}, err
+	}
+
+	token, err := SignToken(s.jwtSecret, Claims{
+		UserID: user.ID,
+		Email:  user.Email,
+		Exp:    time.Now().Add(7 * 24 * time.Hour).Unix(),
+	})
+	if err != nil {
+		return SessionResponse{}, err
+	}
+
+	return SessionResponse{Token: token, User: user}, nil
+}
+
+func (s *Service) upsertUser(ctx context.Context, email, displayName, subject string) (User, error) {
+	var user User
+	err := s.pool.QueryRow(ctx, `
+		INSERT INTO users (email, display_name, provider, provider_subject)
+		VALUES ($1, $2, 'google', $3)
+		ON CONFLICT (email) DO UPDATE SET
+			display_name = EXCLUDED.display_name,
+			provider_subject = EXCLUDED.provider_subject
+		RETURNING id, email, display_name
+	`, email, displayName, subject).Scan(&user.ID, &user.Email, &user.DisplayName)
+	if err != nil {
+		return User{}, fmt.Errorf("upsert user: %w", err)
+	}
+	return user, nil
+}
+
+func SignToken(secret string, claims Claims) (string, error) {
+	body, err := json.Marshal(claims)
+	if err != nil {
+		return "", err
+	}
+	payload := base64.RawURLEncoding.EncodeToString(body)
+	mac := hmac.New(sha256.New, []byte(secret))
+	_, _ = mac.Write([]byte(payload))
+	sig := base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
+	return payload + "." + sig, nil
+}
+
+func VerifyToken(secret, token string) (Claims, error) {
+	parts := strings.Split(token, ".")
+	if len(parts) != 2 {
+		return Claims{}, errors.New("invalid token")
+	}
+	mac := hmac.New(sha256.New, []byte(secret))
+	_, _ = mac.Write([]byte(parts[0]))
+	expected := mac.Sum(nil)
+	actual, err := base64.RawURLEncoding.DecodeString(parts[1])
+	if err != nil || !hmac.Equal(expected, actual) {
+		return Claims{}, errors.New("invalid signature")
+	}
+	body, err := base64.RawURLEncoding.DecodeString(parts[0])
+	if err != nil {
+		return Claims{}, err
+	}
+	var claims Claims
+	if err := json.Unmarshal(body, &claims); err != nil {
+		return Claims{}, err
+	}
+	if claims.Exp < time.Now().Unix() {
+		return Claims{}, fmt.Errorf("token expired")
+	}
+	return claims, nil
+}

internal/auth/types.go

@@ -0,0 +1,24 @@
+package auth
+
+import "github.com/google/uuid"
+
+type GoogleLoginRequest struct {
+	IDToken string `json:"id_token"`
+}
+
+type SessionResponse struct {
+	Token string `json:"token"`
+	User  User   `json:"user"`
+}
+
+type User struct {
+	ID          uuid.UUID `json:"id"`
+	Email       string    `json:"email"`
+	DisplayName string    `json:"display_name"`
+}
+
+type Claims struct {
+	UserID uuid.UUID `json:"user_id"`
+	Email  string    `json:"email"`
+	Exp    int64     `json:"exp"`
+}

internal/config/config.go

@@ -13,24 +13,44 @@ const (
 
 type Config struct {
 	HTTPAddr        string
+	DatabaseURL     string
 	Environment     string
 	WorkflowRuntime string
 	ModelKey        string
 	ImageModelKey   string
 	ThirdOneBin     string
+	LLMAPIKey       string
+	LLMEndpoint     string
+	GoogleClientID  string
+	JWTSecret       string
+	DeploySecret    string
 }
 
 func LoadFromEnv() Config {
 	return Config{
 		HTTPAddr:        envOrDefault("TUTOR_HTTP_ADDR", defaultHTTPAddr),
+		DatabaseURL:     envOrDefault("DATABASE_URL", ""),
 		Environment:     envOrDefault("TUTOR_ENV", defaultEnvironment),
 		WorkflowRuntime: envOrDefault("TUTOR_WORKFLOW_RUNTIME", defaultWorkflowRuntime),
 		ModelKey:        envOrDefault("TUTOR_MODEL_KEY", defaultModelKey),
 		ImageModelKey:   envOrDefault("TUTOR_IMAGE_MODEL_KEY", defaultImageModelKey),
 		ThirdOneBin:     envOrDefault("THIRDONE_BIN", defaultThirdOneBin),
+		LLMAPIKey:       envOrDefault("TUTOR_LLM_API_KEY", ""),
+		LLMEndpoint:     envOrDefault("TUTOR_LLM_ENDPOINT", ""),
+		GoogleClientID:  envOrDefault("GOOGLE_CLIENT_ID", ""),
+		JWTSecret:       envOrDefault("JWT_SECRET", ""),
+		DeploySecret:    envOrDefault("TUTOR_DEPLOY_SECRET", ""),
 	}
 }
 
+func (c Config) HasLLM() bool {
+	return c.LLMEndpoint != ""
+}
+
+func (c Config) HasDeploy() bool {
+	return c.DeploySecret != ""
+}
+
 func envOrDefault(key string, fallback string) string {
 	value := os.Getenv(key)
 	if value == "" {

internal/db/db.go

@@ -0,0 +1,29 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func Open(databaseURL string) (*pgxpool.Pool, error) {
+	if databaseURL == "" {
+		return nil, fmt.Errorf("database URL is required")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	pool, err := pgxpool.New(ctx, databaseURL)
+	if err != nil {
+		return nil, fmt.Errorf("create connection pool: %w", err)
+	}
+
+	if err := pool.Ping(ctx); err != nil {
+		return nil, fmt.Errorf("ping database: %w", err)
+	}
+
+	return pool, nil
+}

internal/db/migrate.go

@@ -0,0 +1,39 @@
+package db
+
+import (
+	"context"
+	"embed"
+	"fmt"
+	"path"
+	"sort"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+//go:embed migrations/*.sql
+var migrationsFS embed.FS
+
+func Migrate(pool *pgxpool.Pool) error {
+	files, err := migrationsFS.ReadDir("migrations")
+	if err != nil {
+		return fmt.Errorf("read migrations dir: %w", err)
+	}
+
+	sort.Slice(files, func(i, j int) bool {
+		return files[i].Name() < files[j].Name()
+	})
+
+	for _, f := range files {
+		if path.Ext(f.Name()) != ".sql" {
+			continue
+		}
+		data, err := migrationsFS.ReadFile("migrations/" + f.Name())
+		if err != nil {
+			return fmt.Errorf("read migration %s: %w", f.Name(), err)
+		}
+		if _, err := pool.Exec(context.Background(), string(data)); err != nil {
+			return fmt.Errorf("run migration %s: %w", f.Name(), err)
+		}
+	}
+	return nil
+}

internal/db/migrations/001_init.sql

@@ -0,0 +1,106 @@
+-- Tutor Platform Initial Schema
+
+CREATE TABLE IF NOT EXISTS interview_sessions (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    target_role TEXT NOT NULL,
+    stack JSONB NOT NULL DEFAULT '[]',
+    interview_timeline TEXT NOT NULL,
+    questions JSONB NOT NULL DEFAULT '[]',
+    answers JSONB NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS learner_profiles (
+    user_id TEXT PRIMARY KEY,
+    target_role TEXT NOT NULL,
+    stack JSONB NOT NULL DEFAULT '[]',
+    interview_timeline TEXT NOT NULL,
+    preferences JSONB NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS learner_mastery (
+    user_id TEXT NOT NULL,
+    concept_id TEXT NOT NULL,
+    concept_label TEXT NOT NULL,
+    state TEXT NOT NULL DEFAULT 'unknown',
+    evidence JSONB NOT NULL DEFAULT '[]',
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (user_id, concept_id)
+);
+
+CREATE TABLE IF NOT EXISTS learner_misconceptions (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    concept JSONB NOT NULL DEFAULT '{}',
+    description TEXT NOT NULL,
+    evidence JSONB NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS learner_interventions (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    reason TEXT NOT NULL,
+    concept JSONB NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS learner_review_schedules (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    concept JSONB NOT NULL DEFAULT '{}',
+    due_at TIMESTAMPTZ NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS ontology_materials (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    source_type TEXT NOT NULL,
+    body TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS ontology_concepts (
+    id TEXT PRIMARY KEY,
+    material_id TEXT NOT NULL,
+    concept_id TEXT NOT NULL,
+    concept_label TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    review_state TEXT NOT NULL DEFAULT 'candidate',
+    evidence JSONB NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS ontology_edges (
+    id TEXT PRIMARY KEY,
+    from_concept_id TEXT NOT NULL,
+    to_concept_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    evidence JSONB NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS ontology_gaps (
+    id TEXT PRIMARY KEY,
+    concept_id TEXT NOT NULL,
+    reason TEXT NOT NULL,
+    evidence JSONB NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS teaching_asset_prompts (
+    id TEXT PRIMARY KEY,
+    concept_id TEXT NOT NULL,
+    asset_type TEXT NOT NULL,
+    prompt TEXT NOT NULL,
+    model_key TEXT NOT NULL,
+    review_state TEXT NOT NULL DEFAULT 'candidate',
+    requires_model_id_verification BOOLEAN NOT NULL DEFAULT TRUE,
+    source_evidence JSONB NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);

internal/db/migrations/002_auth.sql

@@ -0,0 +1,10 @@
+-- Auth: users table
+
+CREATE TABLE IF NOT EXISTS users (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email TEXT UNIQUE NOT NULL,
+    display_name TEXT NOT NULL,
+    provider TEXT NOT NULL DEFAULT 'google',
+    provider_subject TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);

internal/httpapi/deploy.go

@@ -0,0 +1,31 @@
+package httpapi
+
+import (
+	"log"
+	"net/http"
+	"os/exec"
+)
+
+func (h Handler) handleDeploy(w http.ResponseWriter, r *http.Request) {
+	if !h.cfg.HasDeploy() {
+		writeError(w, http.StatusNotFound, "deploy endpoint not configured")
+		return
+	}
+
+	if r.URL.Query().Get("secret") != h.cfg.DeploySecret {
+		writeError(w, http.StatusUnauthorized, "invalid deploy secret")
+		return
+	}
+
+	writeJSON(w, http.StatusAccepted, map[string]string{"status": "deploy started"})
+
+	go func() {
+		cmd := exec.Command("/bin/bash", "deploy.sh")
+		output, err := cmd.CombinedOutput()
+		if err != nil {
+			log.Printf("[deploy] failed: %v, output: %s", err, string(output))
+			return
+		}
+		log.Printf("[deploy] success: %s", string(output))
+	}()
+}

internal/httpapi/diagnostic.go

@@ -13,6 +13,7 @@ type createDiagnosticSessionRequest struct {
 	TargetRole        string   `json:"target_role"`
 	Stack             []string `json:"stack"`
 	InterviewTimeline string   `json:"interview_timeline"`
+	Lang              string   `json:"lang"`
 }
 
 type submitDiagnosticAnswerRequest struct {
@@ -27,11 +28,19 @@ func (h Handler) createDiagnosticSession(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
+	lang := req.Lang
+	if lang == "" {
+		lang = r.Header.Get("X-Lang")
+	}
+	if lang == "" {
+		lang = "en"
+	}
 	session, err := h.diagnostic.CreateSession(r.Context(), interview.CreateSessionInput{
 		UserID:            req.UserID,
 		TargetRole:        req.TargetRole,
 		Stack:             req.Stack,
 		InterviewTimeline: req.InterviewTimeline,
+		Lang:              lang,
 	})
 	if err != nil {
 		writeError(w, http.StatusBadRequest, err.Error())

internal/httpapi/handler.go

@@ -50,9 +50,13 @@ func (h Handler) Routes() http.Handler {
 	mux.HandleFunc("GET /api/v1/learners/{userID}/readiness-map", h.getReadinessMap)
 	mux.HandleFunc("GET /api/v1/learners/{userID}/next-challenge", h.getNextChallenge)
 	mux.HandleFunc("POST /api/v1/materials", h.ingestMaterial)
+	mux.HandleFunc("POST /api/v1/materials/upload", h.uploadMaterial)
 	mux.HandleFunc("GET /api/v1/ontology", h.getOntology)
 	mux.HandleFunc("POST /api/v1/teaching-assets/prompts", h.generateTeachingAssetPrompt)
 	mux.HandleFunc("GET /api/v1/teaching-assets", h.getTeachingAssets)
+	if h.cfg.HasDeploy() {
+		mux.HandleFunc("POST /api/v1/_deploy", h.handleDeploy)
+	}
 	mux.Handle("GET /", webapp.Handler())
 	return mux
 }

internal/httpapi/material_upload.go

@@ -0,0 +1,67 @@
+package httpapi
+
+import (
+	"io"
+	"net/http"
+	"strings"
+
+	"tutor/internal/ingestion"
+	"tutor/internal/ontology"
+)
+
+func (h Handler) uploadMaterial(w http.ResponseWriter, r *http.Request) {
+	if h.ontology == nil {
+		writeError(w, http.StatusNotFound, "ontology not configured")
+		return
+	}
+
+	if err := r.ParseMultipartForm(32 << 20); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid multipart form")
+		return
+	}
+
+	file, header, err := r.FormFile("file")
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "file field required")
+		return
+	}
+	defer file.Close()
+
+	if !ingestion.IsSupported(header.Filename) {
+		writeError(w, http.StatusBadRequest, "unsupported file format; supported: .md, .markdown, .pdf, .docx")
+		return
+	}
+
+	data, err := io.ReadAll(file)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to read file")
+		return
+	}
+
+	result, err := ingestion.ParseFromBytes(header.Filename, data)
+	if err != nil {
+		if strings.Contains(err.Error(), "unsupported") {
+			writeError(w, http.StatusBadRequest, "parse error: "+err.Error())
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "parse error: "+err.Error())
+		return
+	}
+
+	title := r.FormValue("title")
+	if title == "" {
+		title = result.Title
+	}
+
+	ingestResult, err := h.ontology.Ingest(ontology.IngestInput{
+		Title:      title,
+		SourceType: result.Format,
+		Body:       result.Body,
+	})
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	writeJSON(w, http.StatusCreated, ingestResult)
+}

internal/httpapi/material_upload_test.go

@@ -0,0 +1,221 @@
+package httpapi
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"tutor/internal/config"
+	"tutor/internal/interview"
+	"tutor/internal/learnermemory"
+	"tutor/internal/ontology"
+	"tutor/internal/progression"
+	"tutor/internal/teachingassets"
+	"tutor/internal/workflows"
+)
+
+func TestUploadMaterialMarkdown(t *testing.T) {
+	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
+	service := interview.NewService(interview.NewMemoryStore(), workflows.NewStubRunner(), memory)
+	progress := progression.NewService(memory)
+	onto := ontology.NewService(ontology.NewMemoryStore())
+	assets := teachingassets.NewService(teachingassets.NewMemoryStore(), onto, "gpt-image-v2")
+	handler := NewHandler(config.Config{Environment: "test"}, service, memory, progress, onto, assets)
+	routes := handler.Routes()
+
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	part, _ := w.CreateFormFile("file", "notes.md")
+	io.Copy(part, strings.NewReader("# Backend notes\nIdempotent API retries need transactions."))
+	w.Close()
+
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/materials/upload", &buf)
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	rec := httptest.NewRecorder()
+	routes.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+
+	var result ontology.IngestResult
+	decodeJSON(t, rec.Body, &result)
+	if len(result.Snapshot.Concepts) == 0 {
+		t.Fatal("expected concept candidates after md upload")
+	}
+}
+
+func TestUploadMaterialPDF(t *testing.T) {
+	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
+	service := interview.NewService(interview.NewMemoryStore(), workflows.NewStubRunner(), memory)
+	progress := progression.NewService(memory)
+	onto := ontology.NewService(ontology.NewMemoryStore())
+	assets := teachingassets.NewService(teachingassets.NewMemoryStore(), onto, "gpt-image-v2")
+	handler := NewHandler(config.Config{Environment: "test"}, service, memory, progress, onto, assets)
+	routes := handler.Routes()
+
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	part, _ := w.CreateFormFile("file", "notes.pdf")
+	io.Copy(part, strings.NewReader("not a real pdf"))
+	w.Close()
+
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/materials/upload", &buf)
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	rec := httptest.NewRecorder()
+	routes.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusInternalServerError {
+		t.Fatalf("expected 500 for invalid PDF, got %d: %s", rec.Code, rec.Body.String())
+	}
+}
+
+func TestUploadMaterialUnsupportedFormat(t *testing.T) {
+	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
+	service := interview.NewService(interview.NewMemoryStore(), workflows.NewStubRunner(), memory)
+	progress := progression.NewService(memory)
+	onto := ontology.NewService(ontology.NewMemoryStore())
+	assets := teachingassets.NewService(teachingassets.NewMemoryStore(), onto, "gpt-image-v2")
+	handler := NewHandler(config.Config{Environment: "test"}, service, memory, progress, onto, assets)
+	routes := handler.Routes()
+
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	part, _ := w.CreateFormFile("file", "notes.txt")
+	io.Copy(part, strings.NewReader("plain text"))
+	w.Close()
+
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/materials/upload", &buf)
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	rec := httptest.NewRecorder()
+	routes.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400 for unsupported format, got %d: %s", rec.Code, rec.Body.String())
+	}
+}
+
+func TestUploadMaterialMissingFile(t *testing.T) {
+	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
+	service := interview.NewService(interview.NewMemoryStore(), workflows.NewStubRunner(), memory)
+	progress := progression.NewService(memory)
+	onto := ontology.NewService(ontology.NewMemoryStore())
+	assets := teachingassets.NewService(teachingassets.NewMemoryStore(), onto, "gpt-image-v2")
+	handler := NewHandler(config.Config{Environment: "test"}, service, memory, progress, onto, assets)
+	routes := handler.Routes()
+
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	w.Close()
+
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/materials/upload", &buf)
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	rec := httptest.NewRecorder()
+	routes.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400 for missing file, got %d: %s", rec.Code, rec.Body.String())
+	}
+}
+
+func TestUploadMaterialWithCustomTitle(t *testing.T) {
+	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
+	service := interview.NewService(interview.NewMemoryStore(), workflows.NewStubRunner(), memory)
+	progress := progression.NewService(memory)
+	onto := ontology.NewService(ontology.NewMemoryStore())
+	assets := teachingassets.NewService(teachingassets.NewMemoryStore(), onto, "gpt-image-v2")
+	handler := NewHandler(config.Config{Environment: "test"}, service, memory, progress, onto, assets)
+	routes := handler.Routes()
+
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	w.WriteField("title", "Custom Title")
+	part, _ := w.CreateFormFile("file", "notes.md")
+	io.Copy(part, strings.NewReader("Cache invalidation with TTL."))
+	w.Close()
+
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/materials/upload", &buf)
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	rec := httptest.NewRecorder()
+	routes.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+
+	var result ontology.IngestResult
+	decodeJSON(t, rec.Body, &result)
+	if result.Material.Title != "Custom Title" {
+		t.Fatalf("title = %q, want %q", result.Material.Title, "Custom Title")
+	}
+}
+
+func TestUploadMaterialOntologyNotConfigured(t *testing.T) {
+	handler := NewHandler(config.Config{Environment: "test"}, nil, nil, nil, nil, nil)
+	routes := handler.Routes()
+
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	part, _ := w.CreateFormFile("file", "notes.md")
+	io.Copy(part, strings.NewReader("# test"))
+	w.Close()
+
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/materials/upload", &buf)
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	rec := httptest.NewRecorder()
+	routes.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusNotFound {
+		t.Fatalf("expected 404, got %d: %s", rec.Code, rec.Body.String())
+	}
+}
+
+func decodeJSON(t *testing.T, r io.Reader, v interface{}) {
+	t.Helper()
+	if err := json.NewDecoder(r).Decode(v); err != nil {
+		t.Fatalf("decode error: %v", err)
+	}
+}
+
+func TestUploadMaterialMarkdownFrontmatter(t *testing.T) {
+	memory := learnermemory.NewService(learnermemory.NewMemoryStore())
+	service := interview.NewService(interview.NewMemoryStore(), workflows.NewStubRunner(), memory)
+	progress := progression.NewService(memory)
+	onto := ontology.NewService(ontology.NewMemoryStore())
+	assets := teachingassets.NewService(teachingassets.NewMemoryStore(), onto, "gpt-image-v2")
+	handler := NewHandler(config.Config{Environment: "test"}, service, memory, progress, onto, assets)
+	routes := handler.Routes()
+
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	part, _ := w.CreateFormFile("file", "study-notes.md")
+	io.Copy(part, strings.NewReader(fmt.Sprintf("---\ntitle: Study Notes\ntags:\n  - backend\n  - go\n---\n\n# HTTP Idempotency\n\nIdempotent API retries need transactions for correctness.")))
+	w.Close()
+
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/materials/upload", &buf)
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	rec := httptest.NewRecorder()
+	routes.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+
+	var result ontology.IngestResult
+	decodeJSON(t, rec.Body, &result)
+	if len(result.Snapshot.Concepts) == 0 {
+		t.Fatal("expected concepts from markdown with frontmatter")
+	}
+	for _, c := range result.Snapshot.Concepts {
+		if c.Concept.ID == "http-idempotency" {
+			return
+		}
+	}
+	t.Fatalf("expected http-idempotency concept, got concepts: %v", result.Snapshot.Concepts)
+}

internal/ingestion/ingestion.go

@@ -0,0 +1,75 @@
+package ingestion
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type Result struct {
+	Title  string
+	Body   string
+	Format string
+}
+
+var parsers = map[string]func(string) (string, error){
+	".md":       ParseMarkdown,
+	".markdown": ParseMarkdown,
+	".pdf":      ParsePDF,
+	".docx":     ParseDOCX,
+}
+
+func ParseFile(path string) (Result, error) {
+	ext := strings.ToLower(filepath.Ext(path))
+	parse, ok := parsers[ext]
+	if !ok {
+		return Result{}, fmt.Errorf("unsupported file format: %s", ext)
+	}
+
+	body, err := parse(path)
+	if err != nil {
+		return Result{}, fmt.Errorf("parse %s: %w", ext, err)
+	}
+
+	title := strings.TrimSuffix(filepath.Base(path), ext)
+	return Result{
+		Title:  title,
+		Body:   strings.TrimSpace(body),
+		Format: ext[1:],
+	}, nil
+}
+
+func IsSupported(path string) bool {
+	ext := strings.ToLower(filepath.Ext(path))
+	_, ok := parsers[ext]
+	return ok
+}
+
+func SupportedExtensions() []string {
+	exts := make([]string, 0, len(parsers))
+	for ext := range parsers {
+		exts = append(exts, ext)
+	}
+	return exts
+}
+
+func ParseFromBytes(filename string, data []byte) (Result, error) {
+	safe := filepath.Base(filename)
+	if safe == "." || safe == string(filepath.Separator) {
+		return Result{}, fmt.Errorf("invalid filename: %q", filename)
+	}
+
+	tmpDir, err := os.MkdirTemp("", "ingestion-*")
+	if err != nil {
+		return Result{}, fmt.Errorf("create temp dir: %w", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	tmpPath := filepath.Join(tmpDir, safe)
+	if err := os.WriteFile(tmpPath, data, 0644); err != nil {
+		return Result{}, fmt.Errorf("write temp file: %w", err)
+	}
+
+	return ParseFile(tmpPath)
+}

internal/ingestion/ingestion_test.go

@@ -0,0 +1,265 @@
+package ingestion
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestParseMarkdown(t *testing.T) {
+	content := `---
+title: test
+tags: [go]
+---
+# Hello
+
+This is a test document with idempotent APIs.`
+	path := writeTempFile(t, "test.md", content)
+	defer os.Remove(path)
+
+	result, err := ParseFile(path)
+	if err != nil {
+		t.Fatalf("ParseFile error: %v", err)
+	}
+	if result.Title != "test" {
+		t.Fatalf("title = %q, want %q", result.Title, "test")
+	}
+	if !strings.Contains(result.Body, "idempotent") {
+		t.Fatal("body should contain idempotent")
+	}
+	if strings.Contains(result.Body, "---") {
+		t.Fatal("body should not contain frontmatter")
+	}
+}
+
+func TestParseMarkdownNoFrontmatter(t *testing.T) {
+	content := `# Notes
+
+Database indexes speed up queries.`
+	path := writeTempFile(t, "notes.md", content)
+	defer os.Remove(path)
+
+	result, err := ParseFile(path)
+	if err != nil {
+		t.Fatalf("ParseFile error: %v", err)
+	}
+	if !strings.Contains(result.Body, "Database indexes") {
+		t.Fatalf("body = %q, want to contain %q", result.Body, "Database indexes")
+	}
+}
+
+func TestParsePDF(t *testing.T) {
+	content := `%PDF-1.4 fake content`
+	path := writeTempFile(t, "test.pdf", content)
+	defer os.Remove(path)
+
+	result, err := ParseFile(path)
+	if err == nil {
+		t.Fatal("expected error for invalid PDF")
+	}
+	if result.Body != "" {
+		t.Fatalf("expected empty body for invalid PDF, got %q", result.Body)
+	}
+}
+
+func TestParseDOCX(t *testing.T) {
+	path := writeTempFile(t, "test.docx", "not a real docx")
+	defer os.Remove(path)
+
+	result, err := ParseFile(path)
+	if err == nil {
+		t.Fatal("expected error for invalid docx")
+	}
+	if result.Body != "" {
+		t.Fatalf("expected empty body for invalid docx, got %q", result.Body)
+	}
+}
+
+func TestParseUnsupportedFormat(t *testing.T) {
+	path := writeTempFile(t, "test.txt", "plain text")
+	defer os.Remove(path)
+
+	_, err := ParseFile(path)
+	if err == nil {
+		t.Fatal("expected error for unsupported format")
+	}
+}
+
+func TestIsSupported(t *testing.T) {
+	cases := []struct {
+		path string
+		want bool
+	}{
+		{"doc.md", true},
+		{"doc.markdown", true},
+		{"doc.pdf", true},
+		{"doc.docx", true},
+		{"doc.txt", false},
+		{"doc.html", false},
+	}
+	for _, c := range cases {
+		got := IsSupported(c.path)
+		if got != c.want {
+			t.Errorf("IsSupported(%q) = %v, want %v", c.path, got, c.want)
+		}
+	}
+}
+
+func TestParseFromBytes(t *testing.T) {
+	content := "# Hello\nThis is markdown with cache invalidation."
+	result, err := ParseFromBytes("test.md", []byte(content))
+	if err != nil {
+		t.Fatalf("ParseFromBytes error: %v", err)
+	}
+	if result.Title != "test" {
+		t.Fatalf("title = %q, want %q", result.Title, "test")
+	}
+	if !strings.Contains(result.Body, "cache invalidation") {
+		t.Fatal("body should contain cache invalidation")
+	}
+}
+
+func TestSupportedExtensions(t *testing.T) {
+	exts := SupportedExtensions()
+	if len(exts) == 0 {
+		t.Fatal("expected at least one supported extension")
+	}
+	hasMD := false
+	hasPDF := false
+	hasDOCX := false
+	for _, ext := range exts {
+		switch ext {
+		case ".md":
+			hasMD = true
+		case ".markdown":
+			hasMD = true
+		case ".pdf":
+			hasPDF = true
+		case ".docx":
+			hasDOCX = true
+		}
+	}
+	if !hasMD {
+		t.Error("expected .md or .markdown in supported extensions")
+	}
+	if !hasPDF {
+		t.Error("expected .pdf in supported extensions")
+	}
+	if !hasDOCX {
+		t.Error("expected .docx in supported extensions")
+	}
+}
+
+func TestStripFrontmatter(t *testing.T) {
+	cases := []struct {
+		input string
+		want  string
+	}{
+		{
+			input: "---\ntitle: test\n---\nbody text",
+			want:  "body text",
+		},
+		{
+			input: "no frontmatter",
+			want:  "no frontmatter",
+		},
+		{
+			input: "---\nno end marker",
+			want:  "---\nno end marker",
+		},
+		{
+			input: "---\ntags:\n  - go\n  - testing\n---\nreal body",
+			want:  "real body",
+		},
+		{
+			input: "---\ntitle: YAML with --- inside\n---\nbody after",
+			want:  "body after",
+		},
+	}
+	for _, c := range cases {
+		got := stripFrontmatter(c.input)
+		if strings.TrimSpace(got) != strings.TrimSpace(c.want) {
+			t.Errorf("stripFrontmatter(%q) = %q, want %q", c.input, got, c.want)
+		}
+	}
+}
+
+func TestStripFrontmatterMultilineYAML(t *testing.T) {
+	input := "---\ntitle: Study Notes\ndescription: |\n  This block contains --- as part of YAML\n  and more content.\n---\nbody content"
+	got := stripFrontmatter(input)
+	want := "body content"
+	if strings.TrimSpace(got) != strings.TrimSpace(want) {
+		t.Errorf("stripFrontmatter with multiline YAML = %q, want %q", got, want)
+	}
+}
+
+func TestStripFrontmatterCRLF(t *testing.T) {
+	input := "---\r\ntitle: test\r\n---\r\nbody with CRLF"
+	got := stripFrontmatter(input)
+	want := "body with CRLF"
+	if strings.TrimSpace(got) != strings.TrimSpace(want) {
+		t.Errorf("stripFrontmatter CRLF = %q, want %q", got, want)
+	}
+}
+
+func TestParseFromBytesPathTraversal(t *testing.T) {
+	filename := "../../etc/passwd"
+	_, err := ParseFromBytes(filename, []byte("malicious"))
+	if err == nil {
+		t.Fatal("expected error for path traversal filename")
+	}
+}
+
+func TestParseFromBytesInvalidFilename(t *testing.T) {
+	for _, name := range []string{"", ".", string(filepath.Separator)} {
+		_, err := ParseFromBytes(name, []byte("content"))
+		if err == nil {
+			t.Errorf("expected error for filename %q", name)
+		}
+	}
+}
+
+func TestIsSupportedCaseInsensitive(t *testing.T) {
+	cases := []string{"DOC.MD", "File.PDF", "Notes.DOCX", "FILE.MARKDOWN"}
+	for _, name := range cases {
+		if !IsSupported(name) {
+			t.Errorf("IsSupported(%q) should be true (case-insensitive)", name)
+		}
+	}
+}
+
+func TestParseMarkdownCRLF(t *testing.T) {
+	content := "# Hello\r\nCache invalidation with TTL tradeoffs.\r\n"
+	path := writeTempFile(t, "notes.md", content)
+
+	result, err := ParseFile(path)
+	if err != nil {
+		t.Fatalf("ParseFile error: %v", err)
+	}
+	if !strings.Contains(result.Body, "Cache invalidation") {
+		t.Fatalf("body = %q, want to contain %q", result.Body, "Cache invalidation")
+	}
+}
+
+func TestParseMarkdownEmptyFile(t *testing.T) {
+	path := writeTempFile(t, "empty.md", "")
+
+	result, err := ParseFile(path)
+	if err != nil {
+		t.Fatalf("ParseFile error: %v", err)
+	}
+	if result.Body != "" {
+		t.Fatalf("expected empty body, got %q", result.Body)
+	}
+}
+
+func writeTempFile(t *testing.T, name, content string) string {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, name)
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		t.Fatalf("write temp file: %v", err)
+	}
+	return path
+}

internal/ingestion/parse_docx.go

@@ -0,0 +1,20 @@
+package ingestion
+
+import (
+	"strings"
+
+	"github.com/nguyenthenguyen/docx"
+)
+
+func ParseDOCX(path string) (string, error) {
+	reader, err := docx.ReadDocxFile(path)
+	if err != nil {
+		return "", err
+	}
+	defer reader.Close()
+
+	doc := reader.Editable()
+	text := doc.GetContent()
+
+	return strings.TrimSpace(text), nil
+}

internal/ingestion/parse_markdown.go

@@ -0,0 +1,57 @@
+package ingestion
+
+import (
+	"os"
+	"strings"
+)
+
+func ParseMarkdown(path string) (string, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+
+	content := string(data)
+	content = stripFrontmatter(content)
+	content = strings.TrimSpace(content)
+	return content, nil
+}
+
+func stripFrontmatter(content string) string {
+	content = strings.TrimLeft(content, "\n\r\t ")
+	if !strings.HasPrefix(content, "---") {
+		return content
+	}
+
+	rest := content[3:]
+	closing := findFMClosing(rest)
+	if closing < 0 {
+		return content
+	}
+
+	return strings.TrimLeft(rest[closing:], "\n\r")
+}
+
+func findFMClosing(s string) int {
+	i := 0
+	for i < len(s) {
+		nl := strings.IndexByte(s[i:], '\n')
+		if nl < 0 {
+			break
+		}
+		lineStart := i + nl + 1
+		if lineStart >= len(s) {
+			break
+		}
+		end := strings.IndexByte(s[lineStart:], '\n')
+		line := s[lineStart:]
+		if end >= 0 {
+			line = s[lineStart : lineStart+end]
+		}
+		if strings.TrimRight(line, "\r") == "---" {
+			return lineStart + len(line)
+		}
+		i = lineStart + len(line)
+	}
+	return -1
+}

internal/ingestion/parse_pdf.go

@@ -0,0 +1,74 @@
+package ingestion
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/pdfcpu/pdfcpu/pkg/api"
+	"github.com/pdfcpu/pdfcpu/pkg/pdfcpu/model"
+)
+
+func ParsePDF(path string) (string, error) {
+	ctx, err := api.ReadContextFile(path)
+	if err != nil {
+		return "", err
+	}
+
+	tmpDir, err := os.MkdirTemp("", "pdf-extract-*")
+	if err != nil {
+		return "", err
+	}
+	defer os.RemoveAll(tmpDir)
+
+	conf := model.NewDefaultConfiguration()
+	if err := api.ExtractContentFile(path, tmpDir, nil, conf); err != nil {
+		return "", err
+	}
+
+	var buf strings.Builder
+	entries, err := os.ReadDir(tmpDir)
+	if err != nil {
+		return "", err
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+		content, err := os.ReadFile(filepath.Join(tmpDir, entry.Name()))
+		if err != nil {
+			return "", fmt.Errorf("read extracted content %s: %w", entry.Name(), err)
+		}
+		buf.WriteString(string(content))
+		buf.WriteString("\n")
+	}
+
+	if buf.Len() == 0 {
+		content, err := extractPageText(ctx)
+		if err == nil {
+			buf.WriteString(content)
+		}
+	}
+
+	return buf.String(), nil
+}
+
+func extractPageText(ctx *model.Context) (string, error) {
+	var buf strings.Builder
+	for i := 1; i <= ctx.PageCount; i++ {
+		r, err := api.ExtractPage(ctx, i)
+		if err != nil {
+			continue
+		}
+		data, err := io.ReadAll(r)
+		if err != nil {
+			continue
+		}
+		buf.Write(data)
+		buf.WriteString("\n")
+	}
+	return buf.String(), nil
+}

internal/interview/catalog.go

@@ -2,28 +2,49 @@ package interview
 
 import "tutor/internal/workflows"
 
-func BackendDeveloperQuestions() []Question {
+var questionPrompts = map[string]map[string]string{
-	return []Question{
+	"ko": {
+		"backend-http-idempotency":   "HTTP 메서드가 멱등성을 가지려면 어떤 조건이 필요하며, 재시도 시 왜 중요한가요?",
+		"backend-db-index-tradeoff":  "데이터베이스 인덱스를 추가하면 API가 어떻게 개선되며, 어떤 트레이드오프가 발생할 수 있나요?",
+		"backend-cache-invalidation": "API 응답을 캐싱할지 어떻게 결정하며, 오래된 데이터는 어떻게 처리하나요?",
+	},
+	"en": {
+		"backend-http-idempotency":   "What makes an HTTP method idempotent, and why does that matter for retries?",
+		"backend-db-index-tradeoff":  "When would adding a database index improve an API, and what tradeoffs can it introduce?",
+		"backend-cache-invalidation": "How would you decide whether to cache an API response, and how would you handle stale data?",
+	},
+}
+
+func BackendDeveloperQuestions(lang string) []Question {
+	if lang == "" {
+		lang = "en"
+	}
+	base := []Question{
 		{
 			ID: "backend-http-idempotency",
-			Prompt: "What makes an HTTP method idempotent, and why does that matter for retries?",
 			Concepts: []workflows.ConceptRef{
 				{ID: "http-idempotency", Label: "HTTP idempotency", Track: BackendDeveloperTrack},
 			},
 		},
 		{
 			ID: "backend-db-index-tradeoff",
-			Prompt: "When would adding a database index improve an API, and what tradeoffs can it introduce?",
 			Concepts: []workflows.ConceptRef{
 				{ID: "database-indexes", Label: "Database indexes", Track: BackendDeveloperTrack},
 			},
 		},
 		{
 			ID: "backend-cache-invalidation",
-			Prompt: "How would you decide whether to cache an API response, and how would you handle stale data?",
 			Concepts: []workflows.ConceptRef{
 				{ID: "cache-invalidation", Label: "Cache invalidation", Track: BackendDeveloperTrack},
 			},
 		},
 	}
+	for i := range base {
+		if p, ok := questionPrompts[lang][base[i].ID]; ok {
+			base[i].Prompt = p
+		} else if p, ok := questionPrompts["en"][base[i].ID]; ok {
+			base[i].Prompt = p
+		}
+	}
+	return base
 }

internal/interview/service.go

@@ -44,7 +44,7 @@ func (s *Service) CreateSession(_ context.Context, input CreateSessionInput) (Se
 		TargetRole:        input.TargetRole,
 		Stack:             append([]string(nil), input.Stack...),
 		InterviewTimeline: input.InterviewTimeline,
-		Questions:         BackendDeveloperQuestions(),
+		Questions:         BackendDeveloperQuestions(input.Lang),
 		CreatedAt:         time.Now().UTC(),
 	}
 	if s.memory != nil {

internal/interview/store_pg.go

@@ -0,0 +1,77 @@
+package interview
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type PostgresStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewPostgresStore(pool *pgxpool.Pool) *PostgresStore {
+	return &PostgresStore{pool: pool}
+}
+
+func toJSON(v any) string {
+	b, _ := json.Marshal(v)
+	return string(b)
+}
+
+func (s *PostgresStore) Create(session Session) (Session, error) {
+	_, err := s.pool.Exec(context.Background(),
+		`INSERT INTO interview_sessions (id, user_id, target_role, stack, interview_timeline, questions, answers, created_at)
+		 VALUES ($1, $2, $3, $4::jsonb, $5, $6::jsonb, $7::jsonb, $8)
+		 ON CONFLICT (id) DO UPDATE SET
+		   user_id = EXCLUDED.user_id,
+		   target_role = EXCLUDED.target_role,
+		   stack = EXCLUDED.stack,
+		   interview_timeline = EXCLUDED.interview_timeline,
+		   questions = EXCLUDED.questions,
+		   answers = EXCLUDED.answers,
+		   created_at = EXCLUDED.created_at`,
+		session.ID, session.UserID, session.TargetRole, toJSON(session.Stack),
+		session.InterviewTimeline, toJSON(session.Questions), toJSON(session.Answers), session.CreatedAt,
+	)
+	if err != nil {
+		return Session{}, fmt.Errorf("insert session: %w", err)
+	}
+	return session, nil
+}
+
+func (s *PostgresStore) Get(id string) (Session, error) {
+	var session Session
+	var stackJSON, questionsJSON, answersJSON string
+
+	err := s.pool.QueryRow(context.Background(),
+		`SELECT id, user_id, target_role, stack, interview_timeline, questions, answers, created_at
+		 FROM interview_sessions WHERE id = $1`, id,
+	).Scan(&session.ID, &session.UserID, &session.TargetRole, &stackJSON,
+		&session.InterviewTimeline, &questionsJSON, &answersJSON, &session.CreatedAt)
+	if err != nil {
+		return Session{}, ErrSessionNotFound
+	}
+
+	json.Unmarshal([]byte(stackJSON), &session.Stack)
+	json.Unmarshal([]byte(questionsJSON), &session.Questions)
+	json.Unmarshal([]byte(answersJSON), &session.Answers)
+	return session, nil
+}
+
+func (s *PostgresStore) Update(session Session) (Session, error) {
+	_, err := s.pool.Exec(context.Background(),
+		`UPDATE interview_sessions SET
+		   user_id = $2, target_role = $3, stack = $4::jsonb, interview_timeline = $5,
+		   questions = $6::jsonb, answers = $7::jsonb, created_at = $8
+		 WHERE id = $1`,
+		session.ID, session.UserID, session.TargetRole, toJSON(session.Stack),
+		session.InterviewTimeline, toJSON(session.Questions), toJSON(session.Answers), session.CreatedAt,
+	)
+	if err != nil {
+		return Session{}, fmt.Errorf("update session: %w", err)
+	}
+	return session, nil
+}

internal/interview/types.go

@@ -47,6 +47,7 @@ type CreateSessionInput struct {
 	TargetRole        string
 	Stack             []string
 	InterviewTimeline string
+	Lang              string
 }
 
 type SubmitAnswerInput struct {

internal/learnermemory/store_pg.go

@@ -0,0 +1,195 @@
+package learnermemory
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type PostgresStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewPostgresStore(pool *pgxpool.Pool) *PostgresStore {
+	return &PostgresStore{pool: pool}
+}
+
+func toJSON(v any) string {
+	b, _ := json.Marshal(v)
+	return string(b)
+}
+
+func (s *PostgresStore) UpsertProfile(profile Profile) (Profile, error) {
+	_, err := s.pool.Exec(context.Background(),
+		`INSERT INTO learner_profiles (user_id, target_role, stack, interview_timeline, preferences, updated_at)
+		 VALUES ($1, $2, $3::jsonb, $4, $5::jsonb, $6)
+		 ON CONFLICT (user_id) DO UPDATE SET
+		   target_role = EXCLUDED.target_role,
+		   stack = EXCLUDED.stack,
+		   interview_timeline = EXCLUDED.interview_timeline,
+		   preferences = EXCLUDED.preferences,
+		   updated_at = EXCLUDED.updated_at`,
+		profile.UserID, profile.TargetRole, toJSON(profile.Stack),
+		profile.InterviewTimeline, toJSON(profile.Preferences), profile.UpdatedAt,
+	)
+	if err != nil {
+		return Profile{}, fmt.Errorf("upsert profile: %w", err)
+	}
+	return profile, nil
+}
+
+func (s *PostgresStore) GetProfile(userID string) (Profile, error) {
+	var p Profile
+	var stackJSON, prefsJSON string
+	err := s.pool.QueryRow(context.Background(),
+		`SELECT user_id, target_role, stack, interview_timeline, preferences, updated_at
+		 FROM learner_profiles WHERE user_id = $1`, userID,
+	).Scan(&p.UserID, &p.TargetRole, &stackJSON, &p.InterviewTimeline, &prefsJSON, &p.UpdatedAt)
+	if err != nil {
+		return Profile{}, ErrProfileNotFound
+	}
+	json.Unmarshal([]byte(stackJSON), &p.Stack)
+	json.Unmarshal([]byte(prefsJSON), &p.Preferences)
+	return p, nil
+}
+
+func (s *PostgresStore) UpsertMastery(mastery ConceptMastery) error {
+	_, err := s.pool.Exec(context.Background(),
+		`INSERT INTO learner_mastery (user_id, concept_id, concept_label, state, evidence, updated_at)
+		 VALUES ($1, $2, $3, $4, $5::jsonb, $6)
+		 ON CONFLICT (user_id, concept_id) DO UPDATE SET
+		   concept_label = EXCLUDED.concept_label,
+		   state = EXCLUDED.state,
+		   evidence = EXCLUDED.evidence,
+		   updated_at = EXCLUDED.updated_at`,
+		mastery.UserID, mastery.Concept.ID, mastery.Concept.Label, string(mastery.State),
+		toJSON(mastery.Evidence), mastery.UpdatedAt,
+	)
+	if err != nil {
+		return fmt.Errorf("upsert mastery: %w", err)
+	}
+	return nil
+}
+
+func (s *PostgresStore) AddMisconception(m Misconception) error {
+	_, err := s.pool.Exec(context.Background(),
+		`INSERT INTO learner_misconceptions (id, user_id, concept, description, evidence, created_at)
+		 VALUES ($1, $2, $3::jsonb, $4, $5::jsonb, $6)`,
+		m.ID, m.UserID, toJSON(m.Concept), m.Description,
+		toJSON(m.Evidence), m.UpdatedAt,
+	)
+	if err != nil {
+		return fmt.Errorf("insert misconception: %w", err)
+	}
+	return nil
+}
+
+func (s *PostgresStore) AddIntervention(i Intervention) error {
+	_, err := s.pool.Exec(context.Background(),
+		`INSERT INTO learner_interventions (id, user_id, kind, reason, concept, created_at)
+		 VALUES ($1, $2, $3, $4, $5::jsonb, $6)`,
+		i.ID, i.UserID, i.Summary, i.Summary, toJSON(i.Concept), i.UpdatedAt,
+	)
+	if err != nil {
+		return fmt.Errorf("insert intervention: %w", err)
+	}
+	return nil
+}
+
+func (s *PostgresStore) AddReviewSchedule(r ReviewSchedule) error {
+	_, err := s.pool.Exec(context.Background(),
+		`INSERT INTO learner_review_schedules (id, user_id, concept, due_at, created_at)
+		 VALUES ($1, $2, $3::jsonb, $4, $5)`,
+		r.ID, r.UserID, toJSON(r.Concept), r.UpdatedAt, r.UpdatedAt,
+	)
+	if err != nil {
+		return fmt.Errorf("insert review schedule: %w", err)
+	}
+	return nil
+}
+
+func (s *PostgresStore) Snapshot(userID string) (Snapshot, error) {
+	profile, err := s.GetProfile(userID)
+	if err != nil {
+		return Snapshot{}, err
+	}
+
+	rows, err := s.pool.Query(context.Background(),
+		`SELECT concept_id, concept_label, state, evidence FROM learner_mastery WHERE user_id = $1`, userID)
+	if err != nil {
+		return Snapshot{}, fmt.Errorf("query mastery: %w", err)
+	}
+	defer rows.Close()
+
+	var mastery []ConceptMastery
+	for rows.Next() {
+		var m ConceptMastery
+		var evidenceJSON string
+		err := rows.Scan(&m.Concept.ID, &m.Concept.Label, &m.State, &evidenceJSON)
+		if err != nil {
+			continue
+		}
+		m.UserID = userID
+		json.Unmarshal([]byte(evidenceJSON), &m.Evidence)
+		mastery = append(mastery, m)
+	}
+
+	return Snapshot{
+		Profile:        profile,
+		Mastery:        mastery,
+		Misconceptions: fetchMisconceptions(s.pool, userID),
+		Interventions:  fetchInterventions(s.pool, userID),
+		ReviewSchedule: fetchReviewSchedules(s.pool, userID),
+	}, nil
+}
+
+func fetchMisconceptions(pool *pgxpool.Pool, userID string) []Misconception {
+	rows, _ := pool.Query(context.Background(),
+		`SELECT id, concept, description, evidence, created_at FROM learner_misconceptions WHERE user_id = $1`, userID)
+	defer rows.Close()
+	var items []Misconception
+	for rows.Next() {
+		var m Misconception
+		var conceptJSON, evidenceJSON string
+		rows.Scan(&m.ID, &conceptJSON, &m.Description, &evidenceJSON, &m.UpdatedAt)
+		m.UserID = userID
+		json.Unmarshal([]byte(conceptJSON), &m.Concept)
+		json.Unmarshal([]byte(evidenceJSON), &m.Evidence)
+		items = append(items, m)
+	}
+	return items
+}
+
+func fetchInterventions(pool *pgxpool.Pool, userID string) []Intervention {
+	rows, _ := pool.Query(context.Background(),
+		`SELECT id, kind, reason, concept, created_at FROM learner_interventions WHERE user_id = $1`, userID)
+	defer rows.Close()
+	var items []Intervention
+	for rows.Next() {
+		var i Intervention
+		var conceptJSON string
+		rows.Scan(&i.ID, &i.Summary, &i.Summary, &conceptJSON, &i.UpdatedAt)
+		i.UserID = userID
+		json.Unmarshal([]byte(conceptJSON), &i.Concept)
+		items = append(items, i)
+	}
+	return items
+}
+
+func fetchReviewSchedules(pool *pgxpool.Pool, userID string) []ReviewSchedule {
+	rows, _ := pool.Query(context.Background(),
+		`SELECT id, concept, due_at, created_at FROM learner_review_schedules WHERE user_id = $1`, userID)
+	defer rows.Close()
+	var items []ReviewSchedule
+	for rows.Next() {
+		var r ReviewSchedule
+		var conceptJSON string
+		rows.Scan(&r.ID, &conceptJSON, &r.UpdatedAt, &r.UpdatedAt)
+		r.UserID = userID
+		json.Unmarshal([]byte(conceptJSON), &r.Concept)
+		items = append(items, r)
+	}
+	return items
+}

internal/llm/client.go

@@ -0,0 +1,119 @@
+package llm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type Client struct {
+	endpoint   string
+	apiKey     string
+	model      string
+	httpClient *http.Client
+}
+
+func NewClient(endpoint, apiKey, model string) *Client {
+	return &Client{
+		endpoint:   strings.TrimRight(endpoint, "/"),
+		apiKey:     apiKey,
+		model:      model,
+		httpClient: &http.Client{Timeout: 60 * time.Second},
+	}
+}
+
+type ChatMessage struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type chatRequest struct {
+	Model          string        `json:"model"`
+	Messages       []ChatMessage `json:"messages"`
+	ResponseFormat *responseFmt  `json:"response_format,omitempty"`
+	Temperature    float64       `json:"temperature,omitempty"`
+}
+
+type responseFmt struct {
+	Type string `json:"type"`
+}
+
+type chatResponse struct {
+	Choices []struct {
+		Message ChatMessage `json:"message"`
+	} `json:"choices"`
+	Error *struct {
+		Message string `json:"message"`
+		Type    string `json:"type"`
+	} `json:"error,omitempty"`
+}
+
+func (c *Client) Chat(ctx context.Context, systemPrompt, userPrompt string) (string, error) {
+	return c.ChatJSON(ctx, systemPrompt, userPrompt, false)
+}
+
+func (c *Client) ChatJSON(ctx context.Context, systemPrompt, userPrompt string, jsonMode bool) (string, error) {
+	messages := []ChatMessage{
+		{Role: "system", Content: systemPrompt},
+		{Role: "user", Content: userPrompt},
+	}
+
+	req := chatRequest{
+		Model:    c.model,
+		Messages: messages,
+	}
+
+	if jsonMode {
+		req.ResponseFormat = &responseFmt{Type: "json_object"}
+	}
+
+	body, err := json.Marshal(req)
+	if err != nil {
+		return "", fmt.Errorf("marshal request: %w", err)
+	}
+
+	url := c.endpoint + "/v1/chat/completions"
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return "", fmt.Errorf("create request: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+	if c.apiKey != "" {
+		httpReq.Header.Set("Authorization", "Bearer "+c.apiKey)
+	}
+
+	resp, err := c.httpClient.Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("http do: %w", err)
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("read response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("llm api error %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	var chatResp chatResponse
+	if err := json.Unmarshal(respBody, &chatResp); err != nil {
+		return "", fmt.Errorf("unmarshal response: %w", err)
+	}
+
+	if chatResp.Error != nil {
+		return "", fmt.Errorf("llm error: %s", chatResp.Error.Message)
+	}
+
+	if len(chatResp.Choices) == 0 {
+		return "", fmt.Errorf("no choices in response")
+	}
+
+	return chatResp.Choices[0].Message.Content, nil
+}

internal/ontology/store_pg.go

@@ -0,0 +1,111 @@
+package ontology
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type PostgresStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewPostgresStore(pool *pgxpool.Pool) *PostgresStore {
+	return &PostgresStore{pool: pool}
+}
+
+func toJSON(v any) string {
+	b, _ := json.Marshal(v)
+	return string(b)
+}
+
+func (s *PostgresStore) Save(material Material, concepts []ConceptCandidate, edges []EdgeCandidate, gaps []Gap) error {
+	ctx := context.Background()
+	_, err := s.pool.Exec(ctx,
+		`INSERT INTO ontology_materials (id, title, source_type, body, created_at) VALUES ($1, $2, $3, $4, $5)`,
+		material.ID, material.Title, material.SourceType, material.Body, material.CreatedAt)
+	if err != nil {
+		return fmt.Errorf("insert material: %w", err)
+	}
+
+	for _, c := range concepts {
+		_, err := s.pool.Exec(ctx,
+			`INSERT INTO ontology_concepts (id, material_id, concept_id, concept_label, summary, review_state, evidence, created_at)
+			 VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8)`,
+			c.ID, material.ID, c.Concept.ID, c.Concept.Label, c.Summary, string(c.ReviewState),
+			toJSON(c.Evidence), c.CreatedAt)
+		if err != nil {
+			return fmt.Errorf("insert concept: %w", err)
+		}
+	}
+
+	for _, e := range edges {
+		_, err := s.pool.Exec(ctx,
+			`INSERT INTO ontology_edges (id, from_concept_id, to_concept_id, kind, evidence, created_at)
+			 VALUES ($1, $2, $3, $4, $5::jsonb, $6)`,
+			e.ID, e.From.ID, e.To.ID, string(e.Kind),
+			toJSON(e.Evidence), e.CreatedAt)
+		if err != nil {
+			return fmt.Errorf("insert edge: %w", err)
+		}
+	}
+
+	for _, g := range gaps {
+		_, err := s.pool.Exec(ctx,
+			`INSERT INTO ontology_gaps (id, concept_id, reason, evidence, created_at)
+			 VALUES ($1, $2, $3, $4::jsonb, $5)`,
+			g.ID, g.Concept.ID, g.Reason,
+			toJSON(g.SupportingEvidence), g.CreatedAt)
+		if err != nil {
+			return fmt.Errorf("insert gap: %w", err)
+		}
+	}
+	return nil
+}
+
+func (s *PostgresStore) Snapshot() Snapshot {
+	ctx := context.Background()
+	var snap Snapshot
+
+	matRows, _ := s.pool.Query(ctx, `SELECT id, title, source_type, body, created_at FROM ontology_materials`)
+	defer matRows.Close()
+	for matRows.Next() {
+		var m Material
+		matRows.Scan(&m.ID, &m.Title, &m.SourceType, &m.Body, &m.CreatedAt)
+		snap.Materials = append(snap.Materials, m)
+	}
+
+	cRows, _ := s.pool.Query(ctx, `SELECT id, concept_id, concept_label, summary, review_state, evidence, created_at FROM ontology_concepts`)
+	defer cRows.Close()
+	for cRows.Next() {
+		var c ConceptCandidate
+		var evidenceJSON string
+		cRows.Scan(&c.ID, &c.Concept.ID, &c.Concept.Label, &c.Summary, &c.ReviewState, &evidenceJSON, &c.CreatedAt)
+		json.Unmarshal([]byte(evidenceJSON), &c.Evidence)
+		snap.Concepts = append(snap.Concepts, c)
+	}
+
+	eRows, _ := s.pool.Query(ctx, `SELECT id, from_concept_id, to_concept_id, kind, evidence, created_at FROM ontology_edges`)
+	defer eRows.Close()
+	for eRows.Next() {
+		var e EdgeCandidate
+		var evidenceJSON string
+		eRows.Scan(&e.ID, &e.From.ID, &e.To.ID, &e.Kind, &evidenceJSON, &e.CreatedAt)
+		json.Unmarshal([]byte(evidenceJSON), &e.Evidence)
+		snap.Edges = append(snap.Edges, e)
+	}
+
+	gRows, _ := s.pool.Query(ctx, `SELECT id, concept_id, reason, evidence, created_at FROM ontology_gaps`)
+	defer gRows.Close()
+	for gRows.Next() {
+		var g Gap
+		var evidenceJSON string
+		gRows.Scan(&g.ID, &g.Concept.ID, &g.Reason, &evidenceJSON, &g.CreatedAt)
+		json.Unmarshal([]byte(evidenceJSON), &g.SupportingEvidence)
+		snap.Gaps = append(snap.Gaps, g)
+	}
+
+	return snap
+}

internal/teachingassets/store_pg.go

@@ -0,0 +1,53 @@
+package teachingassets
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type PostgresStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewPostgresStore(pool *pgxpool.Pool) *PostgresStore {
+	return &PostgresStore{pool: pool}
+}
+
+func toJSON(v any) string {
+	b, _ := json.Marshal(v)
+	return string(b)
+}
+
+func (s *PostgresStore) SavePrompt(prompt PromptCandidate) (PromptCandidate, error) {
+	_, err := s.pool.Exec(context.Background(),
+		`INSERT INTO teaching_asset_prompts (id, concept_id, asset_type, prompt, model_key, review_state, requires_model_id_verification, source_evidence, created_at)
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9)`,
+		prompt.ID, prompt.Concept.ID, string(prompt.AssetType), prompt.Prompt,
+		prompt.ModelKey, string(prompt.ReviewState), prompt.RequiresModelIDVerification,
+		toJSON(prompt.SourceEvidence), prompt.CreatedAt,
+	)
+	if err != nil {
+		return PromptCandidate{}, fmt.Errorf("insert prompt: %w", err)
+	}
+	return prompt, nil
+}
+
+func (s *PostgresStore) Snapshot() Snapshot {
+	rows, _ := s.pool.Query(context.Background(),
+		`SELECT id, concept_id, asset_type, prompt, model_key, review_state, requires_model_id_verification, source_evidence, created_at FROM teaching_asset_prompts`)
+	defer rows.Close()
+
+	var prompts []PromptCandidate
+	for rows.Next() {
+		var p PromptCandidate
+		var evidenceJSON string
+		rows.Scan(&p.ID, &p.Concept.ID, &p.AssetType, &p.Prompt, &p.ModelKey,
+			&p.ReviewState, &p.RequiresModelIDVerification, &evidenceJSON, &p.CreatedAt)
+		json.Unmarshal([]byte(evidenceJSON), &p.SourceEvidence)
+		prompts = append(prompts, p)
+	}
+	return Snapshot{Prompts: prompts}
+}

internal/webapp/assets_test.go

@@ -16,7 +16,7 @@ func TestHandlerServesIndex(t *testing.T) {
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d", rec.Code)
 	}
-	if !strings.Contains(rec.Body.String(), "Interview practice") {
+	if !strings.Contains(rec.Body.String(), "Turn answers into evidence") {
 		t.Fatal("expected app shell content")
 	}
 }

internal/webapp/static/app.js

@@ -1,4 +1,4 @@
-const state = {
+var state = {
   session: null,
   selectedQuestion: null,
   lastAnswer: null,
@@ -7,16 +7,27 @@ const state = {
   assetPrompt: null,
 };
 
-const els = {
+var els = {
+  loginView:         document.querySelector("#login-view"),
+  workspaceView:     document.querySelector("#workspace-view"),
+  loginError:        document.querySelector("#login-error"),
   sessionForm:       document.querySelector("#session-form"),
   answerForm:        document.querySelector("#answer-form"),
   answerText:        document.querySelector("#answer-text"),
   answerButton:      document.querySelector("#answer-button"),
   questions:         document.querySelector("#questions"),
-  feedback: document.querySelector("#feedback"),
+  setupCard:         document.querySelector("#setup-card"),
-  progress: document.querySelector("#progress"),
+  questionBar:       document.querySelector("#question-bar"),
+  answerArea:        document.querySelector("#answer-area"),
+  feedbackContent:   document.querySelector("#feedback-content"),
+  feedbackEmpty:     document.querySelector("#feedback-empty"),
+  progressContent:   document.querySelector("#progress-content"),
+  progressDivider:   document.querySelector("#progress-divider"),
   refreshProgress:   document.querySelector("#refresh-progress"),
   materialForm:      document.querySelector("#material-form"),
+  materialFile:      document.querySelector("#material-file"),
+  fileNameDisplay:   document.querySelector("#file-name"),
+  uploadFileButton:  document.querySelector("#upload-file-button"),
   assetForm:         document.querySelector("#asset-form"),
   ontology:          document.querySelector("#ontology"),
   assetOutput:       document.querySelector("#asset-output"),
@@ -24,377 +35,511 @@ const els = {
   assetButton:       document.querySelector("#asset-button"),
   status:            document.querySelector("#status-line"),
   error:             document.querySelector("#error-line"),
-  title: document.querySelector("#session-title"),
+  userInfo:          document.querySelector("#user-info"),
+  logoutButton:      document.querySelector("#logout-button"),
+  stepIndicator:     document.querySelector("#step-indicator"),
+  toolsToggle:       document.querySelector("#tools-toggle"),
+  toolsPanel:        document.querySelector("#tools-panel"),
+  gradeDisplay:      document.querySelector("#grade-display"),
+  gradeStrength:     document.querySelector("#grade-strength"),
+  scoreMetrics:      document.querySelector("#score-metrics"),
+  gapsBlock:         document.querySelector("#gaps-block"),
+  followupBlock:     document.querySelector("#followup-block"),
+  evidenceBlock:     document.querySelector("#evidence-block"),
+  progressBar:       document.querySelector("#progress-bar"),
+  readinessPct:      document.querySelector("#readiness-pct"),
+  conceptMemory:     document.querySelector("#concept-memory"),
+  nextChallengeBlock:document.querySelector("#next-challenge-block"),
 };
 
-const readinessClassMap = {
+var readinessClassMap = {
-  unknown: "pill-neutral",
+  unknown:"pill-neutral", fragile:"pill-weak", improving:"pill-warn",
-  fragile: "pill-weak",
+  interview_ready:"pill-good", strong_signal:"pill-strong",
-  improving: "pill-warn",
-  interview_ready: "pill-good",
-  strong_signal: "pill-strong",
-};
-
-const reviewClassMap = {
-  candidate: "pill-neutral",
-  reviewed: "pill-good",
-};
-
-const gradeClassMap = {
-  miss: "grade-miss",
-  partial: "grade-partial",
-  solid: "grade-solid",
-  strong: "grade-strong",
 };
+var reviewClassMap = { candidate:"pill-neutral", reviewed:"pill-good" };
+var gradeClassMap = { miss:"miss", partial:"partial", solid:"solid", strong:"strong" };
 
 function setButtonLoading(button, loadingText) {
   button.disabled = true;
   button.classList.add("is-loading");
-  const textEl = button.querySelector(".btn-text");
+  var textEl = button.querySelector(".btn-text");
   if (textEl && loadingText) {
     textEl.dataset.originalText = textEl.textContent;
     textEl.textContent = loadingText;
   }
 }
-
 function clearButtonLoading(button) {
   button.disabled = false;
   button.classList.remove("is-loading");
-  const textEl = button.querySelector(".btn-text");
+  var textEl = button.querySelector(".btn-text");
   if (textEl && textEl.dataset.originalText) {
     textEl.textContent = textEl.dataset.originalText;
     delete textEl.dataset.originalText;
   }
 }
+function setStatus(message, busy) {
+  var textEl = els.status.querySelector(".status-text");
+  if (textEl) textEl.textContent = message;
+  else els.status.textContent = message;
+  els.status.classList.toggle("is-busy", busy);
+}
+function showError(message) { els.error.textContent = message; }
+function clearError() { els.error.textContent = ""; }
+function escapeHTML(value) {
+  return String(value)
+    .replaceAll("&","&amp;").replaceAll("<","&lt;").replaceAll(">","&gt;").replaceAll('"',"&quot;").replaceAll("'","&#039;");
+}
 
-els.sessionForm.addEventListener("submit", async (event) => {
+function updateStep() {
-  event.preventDefault();
+  if (!state.session) { els.stepIndicator.textContent = ""; return; }
-  clearError();
+  if (state.lastAnswer && state.progress) {
-  setStatus("Creating diagnostic session...", true);
+    els.stepIndicator.textContent = "3/3 " + t("reviewComplete");
-  setButtonLoading(event.submitter || document.querySelector("#start-button"), "Starting...");
+  } else if (state.lastAnswer) {
+    els.stepIndicator.textContent = "2/3 " + t("answerGradedLabel");
+  } else if (state.selectedQuestion) {
+    els.stepIndicator.textContent = "2/3 " + t("answerQuestion");
+  } else {
+    els.stepIndicator.textContent = "1/3 " + t("selectQuestion");
+  }
+}
 
-  const payload = {
+/* ---- Session ---- */
-    user_id: value("#user-id"),
+els.sessionForm.addEventListener("submit", function(event) {
+  event.preventDefault(); clearError();
+  setStatus(t("creatingSession"), true);
+  setButtonLoading(event.submitter || document.querySelector("#start-button"), t("starting"));
+
+  var storedUser = JSON.parse(localStorage.getItem("tutor_user") || "{}");
+  var payload = {
+    user_id: storedUser.email || storedUser.id || "anonymous",
     target_role: value("#target-role"),
-    stack: value("#stack").split(",").map((item) => item.trim()).filter(Boolean),
+    stack: value("#stack").split(",").map(function(s){return s.trim()}).filter(Boolean),
-    interview_timeline: value("#timeline"),
+    interview_timeline: "30 days",
+    lang: localStorage.getItem("tutor_lang") || document.documentElement.lang || "ko",
   };
 
-  try {
+  request("/api/v1/diagnostic-sessions", { method:"POST", body:JSON.stringify(payload) })
-    const session = await request("/api/v1/diagnostic-sessions", {
+    .then(function(session) {
-      method: "POST",
-      body: JSON.stringify(payload),
-    });
       state.session = session;
       state.selectedQuestion = session.questions[0] || null;
       state.lastAnswer = null;
       renderSession();
       renderFeedback();
       renderProgress();
-    setStatus(`Session ${session.id} ready`);
+      setStatus(t("sessionReady", session.id));
-  } catch (error) {
+      updateStep();
-    showError(error.message);
+    })
-    setStatus("Ready");
+    ["catch"](function(error) {
-  } finally {
+      showError(error.message); setStatus(t("ready"));
+    })
+    ["finally"](function() {
       clearButtonLoading(document.querySelector("#start-button"));
-  }
     });
-
-els.refreshProgress.addEventListener("click", async () => {
-  clearError();
-  await refreshProgress();
-});
-
-els.answerForm.addEventListener("submit", async (event) => {
-  event.preventDefault();
-  clearError();
-  if (!state.session || !state.selectedQuestion) return;
-
-  setStatus("Submitting answer...", true);
-  setButtonLoading(event.submitter || els.answerButton, "Grading...");
-
-  try {
-    const answer = await request(`/api/v1/diagnostic-sessions/${state.session.id}/answers`, {
-      method: "POST",
-      body: JSON.stringify({
-        question_id: state.selectedQuestion.id,
-        answer_text: els.answerText.value,
-      }),
-    });
-    state.lastAnswer = answer;
-    renderFeedback();
-    await refreshProgress();
-    setStatus(`Answer graded as ${answer.grade.overall}`);
-  } catch (error) {
-    showError(error.message);
-    setStatus("Session ready");
-  } finally {
-    clearButtonLoading(els.answerButton);
-    els.answerButton.disabled = !state.selectedQuestion;
-  }
-});
-
-els.materialForm.addEventListener("submit", async (event) => {
-  event.preventDefault();
-  clearError();
-  setStatus("Ingesting material...", true);
-  setButtonLoading(event.submitter || document.querySelector("#material-button"), "Ingesting...");
-
-  try {
-    const result = await request("/api/v1/materials", {
-      method: "POST",
-      body: JSON.stringify({
-        title: value("#material-title"),
-        source_type: value("#material-source"),
-        body: value("#material-body"),
-      }),
-    });
-    state.ontology = result.snapshot;
-    renderOntology();
-    setStatus(`Material ${result.material.id} ingested`);
-  } catch (error) {
-    showError(error.message);
-    setStatus("Content workspace ready");
-  } finally {
-    clearButtonLoading(document.querySelector("#material-button"));
-  }
-});
-
-els.assetForm.addEventListener("submit", async (event) => {
-  event.preventDefault();
-  clearError();
-  setStatus("Generating prompt candidate...", true);
-  setButtonLoading(event.submitter || els.assetButton, "Generating...");
-
-  try {
-    const prompt = await request("/api/v1/teaching-assets/prompts", {
-      method: "POST",
-      body: JSON.stringify({
-        concept_id: els.assetConcept.value,
-        asset_type: value("#asset-type"),
-      }),
-    });
-    state.assetPrompt = prompt;
-    renderAssetPrompt();
-    setStatus(`Prompt ${prompt.id} generated`);
-  } catch (error) {
-    showError(error.message);
-    setStatus("Content workspace ready");
-  } finally {
-    clearButtonLoading(els.assetButton);
-  }
 });
 
 function renderSession() {
   if (!state.session) return;
-  els.title.textContent = `${state.session.target_role} — ${state.session.questions.length} questions`;
+  els.questionBar.style.display = "block";
-  els.questions.className = "question-list";
+  els.answerArea.style.display = "block";
+  els.setupCard.style.display = "none";
   els.questions.innerHTML = "";
 
-  state.session.questions.forEach((question) => {
+  state.session.questions.forEach(function(question) {
-    const button = document.createElement("button");
+    var btn = document.createElement("button");
-    button.type = "button";
+    btn.type = "button";
-    button.className = "question-button";
+    btn.className = "question-tab";
-    button.setAttribute("aria-pressed", String(state.selectedQuestion?.id === question.id));
+    btn.setAttribute("role","tab");
-    button.innerHTML = `<span class="question-id">${escapeHTML(question.id)}</span>${escapeHTML(question.prompt)}`;
+    btn.setAttribute("aria-selected", String(state.selectedQuestion && state.selectedQuestion.id === question.id));
-    button.addEventListener("click", () => {
+    btn.innerHTML = '<span class="question-tab-id">' + escapeHTML(question.id) + '</span>' + escapeHTML(tq(question.id) || question.prompt);
+    btn.addEventListener("click", function() {
       state.selectedQuestion = question;
       els.answerText.value = "";
       renderSession();
-      setStatus(`Selected ${question.id}`);
+      setStatus(t("selected", question.id));
+      updateStep();
     });
-    els.questions.append(button);
+    els.questions.appendChild(btn);
   });
 
   els.answerButton.disabled = !state.selectedQuestion;
+  updateStep();
 }
 
-async function refreshProgress() {
+/* ---- Answer ---- */
-  if (!state.session) return;
+els.answerForm.addEventListener("submit", function(event) {
-  setStatus("Refreshing learning progress...", true);
+  event.preventDefault(); clearError();
+  if (!state.session || !state.selectedQuestion) return;
 
-  try {
+  setStatus(t("submittingAnswer"), true);
-    const userID = encodeURIComponent(state.session.user_id);
+  setButtonLoading(event.submitter || els.answerButton, t("grading"));
-    const [memory, readiness, challenge] = await Promise.all([
+
-      request(`/api/v1/learners/${userID}/memory`),
+  request(
-      request(`/api/v1/learners/${userID}/readiness-map`),
+    "/api/v1/diagnostic-sessions/" + state.session.id + "/answers",
-      request(`/api/v1/learners/${userID}/next-challenge`),
+    { method:"POST", body:JSON.stringify({ question_id:state.selectedQuestion.id, answer_text:els.answerText.value }) }
-    ]);
+  )
-    state.progress = { memory, readiness, challenge };
+    .then(function(answer) {
-    renderProgress();
+      state.lastAnswer = answer;
-    setStatus("Learning progress updated");
+      renderFeedback();
-  } catch (error) {
+      refreshProgress();
-    showError(error.message);
+      setStatus(t("answerGraded", answer.grade.overall));
-    renderProgress();
+      updateStep();
+    })
+    ["catch"](function(error) {
+      showError(error.message); setStatus(t("sessionReadyShort"));
+    })
+    ["finally"](function() {
+      clearButtonLoading(els.answerButton);
+      els.answerButton.disabled = !state.selectedQuestion;
+    });
+});
+
+/* ---- Feedback (right sidebar) ---- */
+function renderFeedback() {
+  if (!state.lastAnswer) {
+    els.feedbackEmpty.style.display = "block";
+    els.feedbackContent.style.display = "none";
+    return;
   }
+  els.feedbackEmpty.style.display = "none";
+  els.feedbackContent.style.display = "flex";
+
+  var grade = state.lastAnswer.grade;
+  var gClass = gradeClassMap[grade.overall] || "";
+  els.gradeDisplay.textContent = grade.overall;
+  els.gradeDisplay.className = "grade-badge " + gClass;
+  els.gradeStrength.textContent = grade.strengths && grade.strengths[0] ? grade.strengths[0] : t("answerWasGraded");
+
+  els.scoreMetrics.innerHTML = Object.entries(grade.scores || {})
+    .map(function(entry) {
+      return '<div class="metric-row"><span>' + escapeHTML(entry[0].replaceAll("_"," ")) + '</span><strong>' + entry[1] + '/4</strong></div>';
+    })
+    .join("");
+
+  renderBlock(els.gapsBlock, t("gaps"), grade.gaps);
+  if (grade.follow_up && grade.follow_up.needed) {
+    els.followupBlock.className = "feedback-block has-content";
+    els.followupBlock.innerHTML = "<h4>" + t("followUp") + "</h4><p class='challenge-block'>" + escapeHTML(grade.follow_up.question) + "</p>";
+  } else {
+    els.followupBlock.className = "feedback-block";
+    els.followupBlock.innerHTML = "";
+  }
+  renderBlock(els.evidenceBlock, t("evidence"),
+    (grade.evidence || []).map(function(e){ return e.quote || e.id; }));
+}
+
+function renderBlock(el, title, items) {
+  if (!items || !items.length) { el.className = "feedback-block"; el.innerHTML = ""; return; }
+  el.className = "feedback-block has-content";
+  el.innerHTML = "<h4>" + title + "</h4><ul>" +
+    items.map(function(item){ return "<li>" + escapeHTML(item) + "</li>"; }).join("") +
+    "</ul>";
+}
+
+/* ---- File upload ---- */
+els.materialFile.addEventListener("change", function() {
+  var file = els.materialFile.files[0];
+  if (file) {
+    els.fileNameDisplay.textContent = file.name;
+    els.uploadFileButton.disabled = false;
+  } else {
+    els.fileNameDisplay.textContent = "";
+    els.uploadFileButton.disabled = true;
+  }
+});
+
+els.uploadFileButton.addEventListener("click", function() {
+  var file = els.materialFile.files[0];
+  if (!file) return;
+
+  clearError();
+  setStatus(t("ingestingMaterial"), true);
+  els.uploadFileButton.disabled = true;
+
+  var formData = new FormData();
+  formData.append("file", file);
+  var title = document.querySelector("#material-title").value;
+  if (title) formData.append("title", title);
+
+  var token = localStorage.getItem("tutor_token");
+  var lang = localStorage.getItem("tutor_lang") || document.documentElement.lang || "ko";
+  var headers = {};
+  if (token) headers["Authorization"] = "Bearer " + token;
+
+  fetch("/api/v1/materials/upload", { method:"POST", headers:headers, body:formData })
+    .then(function(response) {
+      return response.json().then(function(body) {
+        if (!response.ok) throw new Error(body.error || "Upload failed: " + response.status);
+        state.ontology = body.snapshot;
+        renderOntology();
+        setStatus(t("materialIngested", body.material.id));
+        els.materialFile.value = "";
+        els.fileNameDisplay.textContent = "";
+      });
+    })
+    ["catch"](function(error) {
+      showError(error.message); setStatus(t("contentReady"));
+    })
+    ["finally"](function() {
+      els.uploadFileButton.disabled = false;
+    });
+});
+
+/* ---- Progress ---- */
+els.refreshProgress.addEventListener("click", function() { clearError(); refreshProgress(); });
+
+function refreshProgress() {
+  if (!state.session) return Promise.resolve();
+  setStatus(t("refreshingProgress"), true);
+
+  var userID = encodeURIComponent(state.session.user_id);
+  return Promise.all([
+    request("/api/v1/learners/" + userID + "/memory"),
+    request("/api/v1/learners/" + userID + "/readiness-map"),
+    request("/api/v1/learners/" + userID + "/next-challenge"),
+  ])
+    .then(function(results) {
+      state.progress = { memory:results[0], readiness:results[1], challenge:results[2] };
+      renderProgress();
+      setStatus(t("progressUpdated"));
+      updateStep();
+    })
+    ["catch"](function(error) {
+      showError(error.message); renderProgress();
+    });
 }
 
 function renderProgress() {
   els.refreshProgress.disabled = !state.session;
   if (!state.progress) {
-    els.progress.className = "feedback empty-state";
+    els.progressContent.style.display = "none";
-    els.progress.innerHTML = `<span class="empty-hint">Answer once to update learner memory and readiness.</span>`;
+    els.progressDivider.style.display = "none";
     return;
   }
+  els.progressContent.style.display = "flex";
+  els.progressDivider.style.display = "block";
 
-  const { memory, readiness, challenge } = state.progress;
+  var r = state.progress;
-  const mastery = memory.mastery || [];
+  var pct = r.readiness.readiness_percentage || 0;
-  els.progress.className = "feedback";
+  els.readinessPct.textContent = pct + "%";
-  els.progress.innerHTML = `
+  els.progressBar.style.width = pct + "%";
-    <section>
+  els.progressBar.className = "progress-bar";
-      <div class="readiness-value">${readiness.readiness_percentage}%</div>
+  if (pct >= 70) els.progressBar.classList.add("high");
-      <p class="status-line">${escapeHTML(memory.profile.target_role)} readiness</p>
+  else if (pct >= 40) els.progressBar.classList.add("medium");
-    </section>
+  else if (pct > 0) els.progressBar.classList.add("low");
-    <section>
+
-      <h2>Concept memory</h2>
+  var mastery = r.memory.mastery || [];
-      <div>${mastery.map((item) => {
+  els.conceptMemory.innerHTML = mastery
-        const cls = readinessClassMap[item.state] || "pill-neutral";
+    .map(function(item) {
-        return `<span class="concept-pill ${cls}">${escapeHTML(item.concept.label)} — ${escapeHTML(item.state)}</span>`;
+      var cls = readinessClassMap[item.state] || "pill-neutral";
-      }).join("")}</div>
+      return '<span class="concept-pill ' + cls + '">' + escapeHTML(item.concept.label) + '</span>';
-    </section>
+    })
-    <section>
+    .join("") || '<span class="concept-pill pill-neutral">' + t("noCandidates") + '</span>';
-      <h2>Next challenge</h2>
+
-      <p class="status-line">${escapeHTML(challenge.concept.label)} — ${escapeHTML(challenge.ladder_level)}</p>
+  if (r.challenge && r.challenge.question) {
-      <p>${escapeHTML(challenge.question)}</p>
+    els.nextChallengeBlock.innerHTML =
-    </section>
+      '<strong>' + escapeHTML(r.challenge.concept.label) + ' &middot; ' + escapeHTML(r.challenge.ladder_level) + '</strong><br>' +
-  `;
+      escapeHTML(r.challenge.question);
+  } else {
+    els.nextChallengeBlock.innerHTML = "";
   }
+}
+
+/* ---- Material / Ontology ---- */
+els.materialForm.addEventListener("submit", function(event) {
+  event.preventDefault(); clearError();
+  setStatus(t("ingestingMaterial"), true);
+  setButtonLoading(event.submitter || document.querySelector("#material-button"), t("ingesting"));
+
+  request("/api/v1/materials", { method:"POST",
+    body:JSON.stringify({ title:value("#material-title"), source_type:value("#material-source"), body:value("#material-body") })
+  })
+    .then(function(result) {
+      state.ontology = result.snapshot;
+      renderOntology();
+      setStatus(t("materialIngested", result.material.id));
+    })
+    ["catch"](function(error) { showError(error.message); setStatus(t("contentReady")); })
+    ["finally"](function() { clearButtonLoading(document.querySelector("#material-button")); });
+});
 
 function renderOntology() {
   if (!state.ontology) {
     els.ontology.className = "ontology-view empty-state";
-    els.ontology.innerHTML = `<span class="empty-hint">Ingest material to inspect ontology candidates.</span>`;
+    els.ontology.innerHTML = '<span class="empty-hint">' + t("emptyOntology") + '</span>';
     return;
   }
-
+  var concepts = state.ontology.concepts || [];
-  const concepts = state.ontology.concepts || [];
   els.ontology.className = "ontology-view";
-  els.ontology.innerHTML = `
+  els.ontology.innerHTML =
-    <div class="summary-strip">
+    '<div class="summary-strip">' +
-      <span class="summary-chip">${concepts.length} concepts</span>
+      '<span class="summary-chip">' + concepts.length + ' ' + t("conceptsSuffix") + '</span>' +
-      <span class="summary-chip">${(state.ontology.edges || []).length} edges</span>
+      '<span class="summary-chip">' + (state.ontology.edges || []).length + ' ' + t("edgesSuffix") + '</span>' +
-      <span class="summary-chip">${(state.ontology.gaps || []).length} gaps</span>
+      '<span class="summary-chip">' + (state.ontology.gaps || []).length + ' ' + t("gapsSuffix") + '</span>' +
-    </div>
+    '</div>' +
-    <section>
+    '<section><h2>' + t("candidateConcepts") + '</h2><div>' +
-      <h2>Candidate concepts</h2>
+      (concepts.map(function(item) {
-      <div>${concepts.map((item) => {
+        var cls = reviewClassMap[item.review_state] || "pill-neutral";
-        const cls = reviewClassMap[item.review_state] || "pill-neutral";
+        return '<span class="concept-pill ' + cls + '">' + escapeHTML(item.concept.label) + '</span>';
-        return `<span class="concept-pill ${cls}">${escapeHTML(item.concept.label)} — ${escapeHTML(item.review_state)}</span>`;
+      }).join("") || t("noCandidates")) +
-      }).join("") || "No candidates yet."}</div>
+    '</div></section>';
-    </section>
-  `;
 
   els.assetConcept.innerHTML = concepts
-    .map((item) => `<option value="${escapeHTML(item.concept.id)}">${escapeHTML(item.concept.label)}</option>`)
+    .map(function(item) { return '<option value="' + escapeHTML(item.concept.id) + '">' + escapeHTML(item.concept.label) + '</option>'; })
     .join("");
   els.assetConcept.disabled = concepts.length === 0;
   els.assetButton.disabled = concepts.length === 0;
 }
 
+/* ---- Asset Prompt ---- */
+els.assetForm.addEventListener("submit", function(event) {
+  event.preventDefault(); clearError();
+  setStatus(t("generatingPrompt"), true);
+  setButtonLoading(event.submitter || els.assetButton, t("generating"));
+
+  request("/api/v1/teaching-assets/prompts", { method:"POST",
+    body:JSON.stringify({ concept_id:els.assetConcept.value, asset_type:value("#asset-type") })
+  })
+    .then(function(prompt) {
+      state.assetPrompt = prompt;
+      renderAssetPrompt();
+      setStatus(t("promptGenerated", prompt.id));
+    })
+    ["catch"](function(error) { showError(error.message); setStatus(t("contentReady")); })
+    ["finally"](function() { clearButtonLoading(els.assetButton); });
+});
+
 function renderAssetPrompt() {
   if (!state.assetPrompt) {
     els.assetOutput.className = "ontology-view empty-state";
-    els.assetOutput.innerHTML = `<span class="empty-hint">Generate a prompt to inspect model key, review state, and evidence.</span>`;
+    els.assetOutput.innerHTML = '<span class="empty-hint">' + t("emptyAsset") + '</span>';
     return;
   }
-
+  var prompt = state.assetPrompt;
-  const prompt = state.assetPrompt;
   els.assetOutput.className = "ontology-view";
-  els.assetOutput.innerHTML = `
+  els.assetOutput.innerHTML =
-    <div class="summary-strip">
+    '<div class="summary-strip">' +
-      <span class="summary-chip">${escapeHTML(prompt.model_key)}</span>
+      '<span class="summary-chip">' + escapeHTML(prompt.model_key) + '</span>' +
-      <span class="summary-chip">${escapeHTML(prompt.review_state)}</span>
+      '<span class="summary-chip">' + escapeHTML(prompt.review_state) + '</span>' +
-      <span class="summary-chip">verify model id: ${prompt.requires_model_id_verification ? "yes" : "no"}</span>
+      '<span class="summary-chip">' + t("verifyModelId") + ': ' + (prompt.requires_model_id_verification ? t("yes") : t("no")) + '</span>' +
-    </div>
+    '</div>' +
-    <pre class="prompt-text">${escapeHTML(prompt.prompt)}</pre>
+    '<pre class="prompt-text">' + escapeHTML(prompt.prompt) + '</pre>' +
-    ${evidenceBlock(prompt.source_evidence)}
+    evidenceBlockHtml(prompt.source_evidence);
-  `;
 }
 
-function renderFeedback() {
+function evidenceBlockHtml(evidence) {
-  if (!state.lastAnswer) {
+  if (!evidence || !evidence.length) return "";
-    els.feedback.className = "feedback empty-state";
+  return '<section><h2>' + t("evidence") + '</h2><ul class="small-list">' +
-    els.feedback.innerHTML = `<span class="empty-hint">Submit an answer to see grade, evidence, and follow-up.</span>`;
+    evidence.map(function(item) { return '<li>' + escapeHTML(item.quote || item.id) + '</li>'; }).join("") +
-    return;
+    '</ul>';
 }
 
-  const grade = state.lastAnswer.grade;
+/* ---- Tools toggle ---- */
-  const gradeClass = gradeClassMap[grade.overall] || "";
+els.toolsToggle.addEventListener("click", function() {
-  els.feedback.className = "feedback";
+  var visible = els.toolsPanel.style.display !== "none";
-  els.feedback.innerHTML = `
+  els.toolsPanel.style.display = visible ? "none" : "block";
-    <div>
+  els.toolsToggle.classList.toggle("is-active", !visible);
-      <div class="grade ${gradeClass}">${escapeHTML(grade.overall)}</div>
-      <p class="status-line">${escapeHTML(grade.strengths?.[0] || "Answer was graded.")}</p>
-    </div>
-    ${scoreRows(grade.scores)}
-    ${listBlock("Gaps", grade.gaps)}
-    ${followUpBlock(grade.follow_up)}
-    ${evidenceBlock(grade.evidence)}
-  `;
-}
-
-function scoreRows(scores) {
-  return Object.entries(scores || {})
-    .map(([label, score]) => `
-      <div class="metric-row">
-        <span>${escapeHTML(label.replaceAll("_", " "))}</span>
-        <strong>${score}/4</strong>
-      </div>
-    `)
-    .join("");
-}
-
-function listBlock(title, items = []) {
-  if (!items.length) return "";
-  return `<section><h2>${title}</h2><ul class="small-list">${items.map((item) => `<li>${escapeHTML(item)}</li>`).join("")}</ul></section>`;
-}
-
-function followUpBlock(followUp) {
-  if (!followUp?.needed) return "";
-  return `<section><h2>Follow-up</h2><p class="status-line">${escapeHTML(followUp.question)}</p></section>`;
-}
-
-function evidenceBlock(evidence = []) {
-  if (!evidence.length) return "";
-  return `<section><h2>Evidence</h2><ul class="small-list">${evidence.map((item) => `<li>${escapeHTML(item.quote || item.id)}</li>`).join("")}</ul></section>`;
-}
-
-async function request(url, options = {}) {
-  const response = await fetch(url, {
-    headers: { "Content-Type": "application/json" },
-    ...options,
 });
-  const body = await response.json();
+
-  if (!response.ok) {
+/* ---- Auth ---- */
-    throw new Error(body.error || `Request failed: ${response.status}`);
+window._tutorGoogleCallback = function(response) {
+  return request("/api/v1/auth/google", {
+    method:"POST", body:JSON.stringify({ id_token:response.credential }),
+  })
+    .then(function(res) {
+      localStorage.setItem("tutor_token", res.token);
+      localStorage.setItem("tutor_user", JSON.stringify(res.user));
+      if (els.loginError) { els.loginError.textContent = ""; els.loginError.classList.remove("visible"); }
+      renderAuth();
+    })
+    ["catch"](function(err) {
+      if (els.loginError) { els.loginError.textContent = err.message; els.loginError.classList.add("visible"); }
+    });
+};
+
+if (window._tutorPendingGoogleResponse) {
+  window._tutorGoogleCallback(window._tutorPendingGoogleResponse);
+  window._tutorPendingGoogleResponse = null;
 }
+
+function renderAuth() {
+  var user = JSON.parse(localStorage.getItem("tutor_user") || "null");
+  var token = localStorage.getItem("tutor_token");
+  if (user && token) {
+    els.loginView.style.display = "none";
+    els.workspaceView.style.display = "block";
+    els.userInfo.textContent = user.email || user.name || "User";
+    setStatus(t("signedInAs", user.email || user.name));
+    if (els.loginError) els.loginError.classList.remove("visible");
+  } else {
+    els.loginView.style.display = "flex";
+    els.workspaceView.style.display = "none";
+  }
+}
+
+/* ---- Language ---- */
+function setLanguage(lang) {
+  localStorage.setItem("tutor_lang", lang);
+  document.documentElement.lang = lang;
+  updateStaticText();
+  document.querySelectorAll(".lang-btn").forEach(function(btn) {
+    btn.classList.toggle("is-active", btn.dataset.lang === lang);
+  });
+  if (state.session) renderSession();
+  renderFeedback();
+  renderProgress();
+  renderOntology();
+  renderAssetPrompt();
+  var user = JSON.parse(localStorage.getItem("tutor_user") || "null");
+  var token = localStorage.getItem("tutor_token");
+  if (user && token) { setStatus(t("signedInAs", user.email || user.name)); }
+  else { setStatus(t("ready")); }
+  updateStep();
+}
+
+els.logoutButton.addEventListener("click", function() {
+  localStorage.removeItem("tutor_token"); localStorage.removeItem("tutor_user");
+  renderAuth(); setStatus(t("signedOut"));
+});
+
+document.querySelectorAll(".lang-switch").forEach(function(group) {
+  group.addEventListener("click", function(e) {
+    if (!e.target.dataset.lang) return;
+    setLanguage(e.target.dataset.lang);
+  });
+});
+
+/* ---- Init ---- */
+if (!localStorage.getItem("tutor_lang")) {
+  var browserLang = navigator.language || navigator.userLanguage || "";
+  localStorage.setItem("tutor_lang", browserLang.toLowerCase().startsWith("ko") ? "ko" : "en");
+  document.documentElement.lang = localStorage.getItem("tutor_lang");
+}
+
+updateStaticText();
+var savedLang = localStorage.getItem("tutor_lang") || document.documentElement.lang || "ko";
+document.querySelectorAll(".lang-btn").forEach(function(btn) {
+  btn.classList.toggle("is-active", btn.dataset.lang === savedLang);
+});
+
+/* ---- Helpers ---- */
+function request(url, options) {
+  var token = localStorage.getItem("tutor_token");
+  var lang = localStorage.getItem("tutor_lang") || document.documentElement.lang || "ko";
+  var headers = { "Content-Type":"application/json", "X-Lang":lang };
+  if (token) headers["Authorization"] = "Bearer " + token;
+  return fetch(url, Object.assign({ headers:headers }, options || {}))
+    .then(function(response) {
+      return response.json().then(function(body) {
+        if (!response.ok) throw new Error(body.error || "Request failed: " + response.status);
         return body;
+      });
+    });
 }
 
 function value(selector) {
   return document.querySelector(selector).value.trim();
 }
 
-function setStatus(message, busy = false) {
+window.renderAuth = renderAuth;
-  const textEl = els.status.querySelector(".status-text");
+window.setLanguage = setLanguage;
-  if (textEl) textEl.textContent = message;
+renderAuth();
-  else els.status.textContent = message;
-  els.status.classList.toggle("is-busy", busy);
-}
-
-function showError(message) {
-  els.error.textContent = message;
-}
-
-function clearError() {
-  els.error.textContent = "";
-}
-
-function escapeHTML(value) {
-  return String(value)
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&#039;");
-}

internal/webapp/static/i18n.js

@@ -0,0 +1,243 @@
+var i18n = {
+  ko: {
+    eyebrow: "튜터 플랫폼",
+    loginHeading: "답변을 증거로",
+    loginDesc: "짧은 연습 루프로 면접 준비도를 눈으로 확인하세요.",
+    titleWorkspace: "면접 연습",
+    subtitleWorkspace: "백엔드 면접 연습을 시작하고, 하나의 답변을 증거로 만드세요.",
+    startSession: "진단 세션 시작",
+    startHint: "면접 질문을 생성하고 첫 답변을 만들어보세요.",
+    userId: "사용자 ID",
+    targetRole: "목표 직무",
+    stack: "기술 스택",
+    timeline: "준비 기간",
+    startDiagnostic: "진단 시작",
+    signOut: "로그아웃",
+    questions: "질문 목록",
+    yourAnswer: "내 답변",
+    answerHint: "구체적인 프로덕션 관점에서 답변하세요.",
+    noActiveSession: "활성 세션 없음",
+    emptyQuestions: "면접 질문을 불러오려면 진단 세션을 시작하세요.",
+    answerLabel: "답변",
+    answerPlaceholder: "질문을 선택한 후, 구체적인 프로덕션 관점에서 답변하세요.",
+    submitAnswer: "답변 제출",
+    contentEyebrow: "콘텐츠 작업",
+    contentTitle: "소스 → 에셋 프롬프트",
+    materialTitle: "자료 제목",
+    sourceType: "소스 유형",
+    sourceMaterial: "소스 자료",
+    ingestMaterial: "자료 수집",
+    emptyOntology: "자료를 수집하면 개념 후보를 확인할 수 있습니다.",
+    concept: "개념",
+    assetType: "에셋 유형",
+    generatePrompt: "프롬프트 생성",
+    emptyAsset: "프롬프트를 생성하면 모델 키, 검토 상태, 근거를 확인할 수 있습니다.",
+    feedbackEyebrow: "피드백",
+    rubricResult: "채점 결과",
+    feedbackEmpty: "답변을 제출하면 채점 결과가 여기에 표시됩니다.",
+    emptyFeedback: "답변을 제출하면 등급, 근거, 후속 질문을 확인할 수 있습니다.",
+    progressEyebrow: "진행 상황",
+    learningState: "학습 상태",
+    emptyProgress: "답변을 제출하면 학습자 메모리와 준비도가 업데이트됩니다.",
+    refresh: "새로고침",
+    ready: "준비 완료",
+    creatingSession: "진단 세션 생성 중…",
+    sessionReady: function(id) { return "세션 " + id + " 준비 완료"; },
+    submittingAnswer: "답변 제출 중…",
+    answerGraded: function(grade) { return "답변 등급: " + grade; },
+    answerGradedLabel: "채점 완료",
+    answerQuestion: "답변 작성",
+    selectQuestion: "질문 선택",
+    reviewComplete: "복습 완료",
+    ingestingMaterial: "자료 수집 중…",
+    materialIngested: function(id) { return "자료 " + id + " 수집 완료"; },
+    generatingPrompt: "프롬프트 생성 중…",
+    promptGenerated: function(id) { return "프롬프트 " + id + " 생성 완료"; },
+    refreshingProgress: "학습 진행 상황 새로고침 중…",
+    progressUpdated: "학습 진행 상황 업데이트 완료",
+    selected: function(id) { return id + " 선택됨"; },
+    contentReady: "콘텐츠 작업 공간 준비 완료",
+    sessionReadyShort: "세션 준비 완료",
+    signedInAs: function(email) { return email + "님으로 로그인됨"; },
+    signedOut: "로그아웃됨",
+    followUp: "후속 질문",
+    evidence: "근거",
+    gaps: "부족한 점",
+    conceptMemory: "개념 메모리",
+    nextChallenge: "다음 도전",
+    readiness: "준비도",
+    modelKey: "모델 키",
+    reviewState: "검토 상태",
+    verifyModelId: "모델 ID 확인 필요",
+    yes: "예",
+    no: "아니오",
+    questionId: "질문 ID",
+    starting: "시작 중…",
+    grading: "채점 중…",
+    uploadFile: "파일 업로드",
+    uploadAndIngest: "업로드 및 수집",
+    pasteTextToggle: "또는 텍스트 붙여넣기",
+    ingesting: "수집 중…",
+    generating: "생성 중…",
+    questionsSuffix: "개 질문",
+    conceptsSuffix: "개 개념",
+    edgesSuffix: "개 엣지",
+    gapsSuffix: "개 갭",
+    candidateConcepts: "후보 개념",
+    noCandidates: "아직 후보가 없습니다.",
+    answerWasGraded: "답변이 채점되었습니다.",
+  },
+  en: {
+    eyebrow: "Tutor Platform",
+    loginHeading: "Turn answers into evidence",
+    loginDesc: "Visualize your interview readiness through short practice loops.",
+    titleWorkspace: "Interview practice",
+    subtitleWorkspace: "Start a focused backend interview loop and turn one answer into evidence.",
+    startSession: "Start diagnostic session",
+    startHint: "Generate interview questions and write your first answer.",
+    userId: "User ID",
+    targetRole: "Target role",
+    stack: "Stack",
+    timeline: "Timeline",
+    startDiagnostic: "Start diagnostic",
+    signOut: "Sign out",
+    questions: "Questions",
+    yourAnswer: "Your answer",
+    answerHint: "Answer with concrete production reasoning.",
+    noActiveSession: "No active session",
+    emptyQuestions: "Start a diagnostic session to load interview questions.",
+    answerLabel: "Answer",
+    answerPlaceholder: "Select a question, then answer with concrete production reasoning.",
+    submitAnswer: "Submit answer",
+    contentEyebrow: "Content operations",
+    contentTitle: "Source to asset prompt",
+    materialTitle: "Material title",
+    sourceType: "Source type",
+    sourceMaterial: "Source material",
+    ingestMaterial: "Ingest material",
+    emptyOntology: "Ingest material to inspect ontology candidates.",
+    concept: "Concept",
+    assetType: "Asset type",
+    generatePrompt: "Generate prompt",
+    emptyAsset: "Generate a prompt to inspect model key, review state, and evidence.",
+    feedbackEyebrow: "Feedback",
+    rubricResult: "Rubric result",
+    feedbackEmpty: "Submit an answer to see your grade and feedback here.",
+    emptyFeedback: "Submit an answer to see grade, evidence, and follow-up.",
+    progressEyebrow: "Progress",
+    learningState: "Learning state",
+    emptyProgress: "Answer once to update learner memory and readiness.",
+    refresh: "Refresh",
+    ready: "Ready",
+    creatingSession: "Creating diagnostic session…",
+    sessionReady: function(id) { return "Session " + id + " ready"; },
+    submittingAnswer: "Submitting answer…",
+    answerGraded: function(grade) { return "Answer graded as " + grade; },
+    answerGradedLabel: "Graded",
+    answerQuestion: "Answer",
+    selectQuestion: "Select",
+    reviewComplete: "Review done",
+    ingestingMaterial: "Ingesting material…",
+    materialIngested: function(id) { return "Material " + id + " ingested"; },
+    generatingPrompt: "Generating prompt candidate…",
+    promptGenerated: function(id) { return "Prompt " + id + " generated"; },
+    refreshingProgress: "Refreshing learning progress…",
+    progressUpdated: "Learning progress updated",
+    selected: function(id) { return "Selected " + id; },
+    contentReady: "Content workspace ready",
+    sessionReadyShort: "Session ready",
+    signedInAs: function(email) { return "Signed in as " + email; },
+    signedOut: "Signed out",
+    followUp: "Follow-up",
+    evidence: "Evidence",
+    gaps: "Gaps",
+    conceptMemory: "Concept memory",
+    nextChallenge: "Next challenge",
+    readiness: "readiness",
+    modelKey: "Model key",
+    reviewState: "Review state",
+    verifyModelId: "verify model id",
+    yes: "yes",
+    no: "no",
+    questionId: "question id",
+    starting: "Starting…",
+    grading: "Grading…",
+    uploadFile: "Upload file",
+    uploadAndIngest: "Upload & ingest",
+    pasteTextToggle: "Or paste text",
+    ingesting: "Ingesting…",
+    generating: "Generating…",
+    questionsSuffix: "questions",
+    conceptsSuffix: "concepts",
+    edgesSuffix: "edges",
+    gapsSuffix: "gaps",
+    candidateConcepts: "Candidate concepts",
+    noCandidates: "No candidates yet.",
+    answerWasGraded: "Answer was graded.",
+  },
+};
+
+window.t = function (key) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  var lang =
+    localStorage.getItem("tutor_lang") ||
+    document.documentElement.lang ||
+    "ko";
+  var text = i18n[lang]?.[key] ?? i18n["en"]?.[key] ?? key;
+  return typeof text === "function" ? text.apply(null, args) : text;
+}
+
+var questionTexts = {
+  ko: {
+    "backend-http-idempotency":
+      "HTTP 메서드가 멱등성을 가지려면 어떤 조건이 필요하며, 재시도 시 왜 중요한가요?",
+    "backend-db-index-tradeoff":
+      "데이터베이스 인덱스를 추가하면 API가 어떻게 개선되며, 어떤 트레이드오프가 발생할 수 있나요?",
+    "backend-cache-invalidation":
+      "API 응답을 캐싱할지 어떻게 결정하며, 오래된 데이터는 어떻게 처리하나요?",
+  },
+  en: {
+    "backend-http-idempotency":
+      "What makes an HTTP method idempotent, and why does that matter for retries?",
+    "backend-db-index-tradeoff":
+      "When would adding a database index improve an API, and what tradeoffs can it introduce?",
+    "backend-cache-invalidation":
+      "How would you decide whether to cache an API response, and how would you handle stale data?",
+  },
+};
+
+window.tq = function (id) {
+  var lang =
+    localStorage.getItem("tutor_lang") ||
+    document.documentElement.lang ||
+    "ko";
+  return questionTexts[lang]?.[id] ?? questionTexts["en"]?.[id] ?? "";
+};
+
+window.updateStaticText = function () {
+  var lang =
+    localStorage.getItem("tutor_lang") ||
+    document.documentElement.lang ||
+    "ko";
+  document.documentElement.lang = lang;
+  document.querySelectorAll("[data-i18n]").forEach(function(el) {
+    var k = el.dataset.i18n;
+    var v = i18n[lang]?.[k] ?? i18n["en"]?.[k] ?? "";
+    var text = typeof v === "function" ? v() : v;
+    if (el.classList.contains("login-divider")) {
+      el.setAttribute("data-label", text);
+    } else if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
+      if (el.placeholder !== undefined) el.placeholder = text;
+    } else if (text.indexOf("<") >= 0) {
+      el.innerHTML = text;
+    } else {
+      el.textContent = text;
+    }
+  });
+  document.querySelectorAll("[data-i18n-placeholder]").forEach(function(el) {
+    var k = el.dataset.i18nPlaceholder;
+    var v = i18n[lang]?.[k] ?? i18n["en"]?.[k] ?? "";
+    var text = typeof v === "function" ? v() : v;
+    el.placeholder = text;
+  });
+}

internal/webapp/static/index.html

@@ -4,105 +4,189 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>Tutor Platform</title>
-    <link rel="stylesheet" href="/assets/styles.css" />
+  <link rel="stylesheet" href="/assets/styles.css?v=4" />
 </head>
 <body>
-    <main class="workspace">
+  <!-- Google auth bridge (unchanged) -->
-      <aside class="setup-pane" aria-label="Diagnostic setup">
+  <script>
-        <p class="eyebrow">Tutor Platform</p>
+    window._tutorGoogleCallback = null;
-        <h1>Interview practice</h1>
+    window._tutorPendingGoogleResponse = null;
-        <p class="lede">Start a focused backend interview loop and turn one answer into evidence.</p>
+    window.handleCredentialResponse = function (response) {
+      if (window._tutorGoogleCallback) {
+        window._tutorGoogleCallback(response);
+      } else {
+        window._tutorPendingGoogleResponse = response;
+      }
+    };
+  </script>
+  <script src="https://accounts.google.com/gsi/client" async defer></script>
 
-        <form id="session-form" class="stacked-form">
+  <!-- ============ LOGIN VIEW ============ -->
+  <main id="login-view" class="login-page">
+    <div class="login-card">
+      <div class="login-brand" data-i18n="eyebrow">Tutor Platform</div>
+      <h1 class="login-heading" data-i18n="loginHeading">Turn answers into evidence</h1>
+      <p class="login-desc" data-i18n="loginDesc">짧은 연습 루프로 면접 준비도를 눈으로 확인하세요.</p>
+      <div id="auth-area" class="auth-area">
+        <div
+          id="g_id_onload"
+          data-client_id="13671390758-bp1ed6psn43bl86r8a9kv81o40nkea90.apps.googleusercontent.com"
+          data-callback="handleCredentialResponse"
+          data-auto_prompt="false"
+        ></div>
+        <div
+          class="g_id_signin"
+          data-type="standard"
+          data-size="large"
+          data-theme="outline"
+          data-text="sign_in_with"
+          data-shape="rectangular"
+          data-logo_alignment="left"
+        ></div>
+      </div>
+      <p id="login-error" class="login-error" role="alert"></p>
+      <div class="lang-switch login-lang" role="group" aria-label="Language">
+        <button type="button" data-lang="ko" class="lang-btn is-active">KO</button>
+        <button type="button" data-lang="en" class="lang-btn">EN</button>
+      </div>
+    </div>
+  </main>
+
+  <!-- ============ WORKSPACE VIEW ============ -->
+  <div id="workspace-view" class="workspace" style="display:none">
+
+    <!-- Top bar -->
+    <header class="topbar">
+      <span class="topbar-brand" data-i18n="eyebrow">Tutor Platform</span>
+      <nav class="topbar-center">
+        <span id="step-indicator" class="step-indicator"></span>
+      </nav>
+      <div class="topbar-right">
+        <button id="tools-toggle" class="icon-btn" type="button" aria-label="Tools" title="Tools">&#9881;</button>
+        <div class="lang-switch" role="group" aria-label="Language">
+          <button type="button" data-lang="ko" class="lang-btn is-active">KO</button>
+          <button type="button" data-lang="en" class="lang-btn">EN</button>
+        </div>
+        <div class="user-menu">
+          <span id="user-info" class="user-name"></span>
+          <button id="logout-button" class="link-btn" data-i18n="signOut">Sign out</button>
+        </div>
+      </div>
+    </header>
+
+    <!-- Main area: 2-column -->
+    <div class="main-grid">
+
+      <!-- LEFT: Practice -->
+      <section class="main-pane">
+
+        <!-- Session setup card (shows when no session active) -->
+        <div id="setup-card" class="setup-card">
+          <div class="card-header">
+            <h2 data-i18n="startSession">Start diagnostic</h2>
+            <p class="card-hint" data-i18n="startHint">면접 질문을 생성하고 첫 답변을 만들어보세요.</p>
+          </div>
+          <form id="session-form" class="inline-form">
+            <div class="field-row">
               <label>
-            User ID
+                <span data-i18n="targetRole">Target role</span>
-            <input id="user-id" name="user_id" value="demo-user" autocomplete="off" />
-          </label>
-          <label>
-            Target role
                 <input id="target-role" name="target_role" value="junior backend developer" />
               </label>
               <label>
-            Stack
+                <span data-i18n="stack">Stack</span>
                 <input id="stack" name="stack" value="go, postgres" />
               </label>
-          <label>
+            </div>
-            Timeline
-            <input id="timeline" name="interview_timeline" value="30 days" />
-          </label>
             <button id="start-button" type="submit">
-            <span class="btn-text">Start diagnostic</span>
+              <span class="btn-text" data-i18n="startDiagnostic">Start diagnostic</span>
               <span class="btn-spinner" aria-hidden="true"></span>
             </button>
           </form>
-
           <p id="status-line" class="status-line" role="status">
-          <span class="status-icon" aria-hidden="true"></span>
+            <span class="status-dot" aria-hidden="true"></span>
-          <span class="status-text">Ready</span>
+            <span class="status-text" data-i18n="ready">Ready</span>
           </p>
           <p id="error-line" class="error-line" role="alert"></p>
-      </aside>
-
-      <section class="practice-pane" aria-label="Diagnostic practice">
-        <div class="section-heading">
-          <div>
-            <p class="eyebrow">Diagnostic</p>
-            <h2 id="session-title">No active session</h2>
-          </div>
-        </div>
-        <div id="questions" class="question-list empty-state">
-          <span class="empty-hint">Start a diagnostic session to load interview questions.</span>
         </div>
 
+        <!-- Question selector (shows after session starts) -->
+        <div id="question-bar" class="question-bar" style="display:none">
+          <div class="bar-label" data-i18n="questions">Questions</div>
+          <div id="questions" class="question-tabs" role="tablist"></div>
+        </div>
+
+        <!-- Answer area (shows after session starts) -->
+        <div id="answer-area" class="answer-area" style="display:none">
           <form id="answer-form" class="answer-form">
-          <label for="answer-text">Answer</label>
+            <div class="answer-header">
-          <textarea id="answer-text" rows="7" placeholder="Select a question, then answer with concrete production reasoning."></textarea>
+              <label for="answer-text" data-i18n="yourAnswer">Your answer</label>
+              <span id="answer-hint" class="answer-hint" data-i18n="answerHint">구체적인 프로덕션 관점에서 답변하세요.</span>
+            </div>
+            <textarea
+              id="answer-text"
+              rows="8"
+              data-i18n-placeholder="answerPlaceholder"
+              placeholder="Select a question, then answer with concrete production reasoning."
+            ></textarea>
             <button id="answer-button" type="submit" disabled>
-            <span class="btn-text">Submit answer</span>
+              <span class="btn-text" data-i18n="submitAnswer">Submit answer</span>
               <span class="btn-spinner" aria-hidden="true"></span>
             </button>
           </form>
-
-        <section class="content-workspace" aria-label="Material and asset workspace">
-          <div class="section-heading">
-            <div>
-              <p class="eyebrow">Content operations</p>
-              <h2>Source to asset prompt</h2>
-            </div>
         </div>
 
-          <form id="material-form" class="material-form">
+        <!-- Content tools panel (hidden by default) -->
+        <div id="tools-panel" class="tools-panel" style="display:none">
+          <div class="tools-divider"></div>
+          <h2 data-i18n="contentTitle">Source to asset prompt</h2>
+
+          <form id="material-form" class="stacked-form">
+            <div class="field-row">
               <label>
-              Material title
+                <span data-i18n="materialTitle">Material title</span>
                 <input id="material-title" value="Backend interview notes" />
               </label>
               <label>
-              Source type
+                <span data-i18n="sourceType">Source type</span>
                 <input id="material-source" value="markdown" />
               </label>
+            </div>
+            <div class="file-upload-row">
+              <label class="file-label">
+                <span data-i18n="uploadFile">Upload file</span>
+                <input id="material-file" type="file" accept=".md,.markdown,.pdf,.docx" />
+              </label>
+              <span id="file-name" class="file-name"></span>
+              <button id="upload-file-button" type="button" class="small-button" data-i18n="uploadAndIngest" disabled>Upload &amp; ingest</button>
+            </div>
+            <details class="paste-toggle">
+              <summary data-i18n="pasteTextToggle">Or paste text</summary>
               <label class="wide-field">
-              Source material
+                <span data-i18n="sourceMaterial">Source material</span>
-              <textarea id="material-body" rows="5">Idempotent API retries need transactions. Cache invalidation uses TTL tradeoffs and database indexes support query plans.</textarea>
+                <textarea id="material-body" rows="5">
+Idempotent API retries need transactions. Cache invalidation uses TTL tradeoffs and database indexes support query plans.</textarea
+                >
               </label>
               <button id="material-button" type="submit">
-              <span class="btn-text">Ingest material</span>
+                <span class="btn-text" data-i18n="ingestMaterial">Ingest material</span>
                 <span class="btn-spinner" aria-hidden="true"></span>
               </button>
+            </details>
           </form>
 
           <div id="ontology" class="ontology-view empty-state">
-            <span class="empty-hint">Ingest material to inspect ontology candidates.</span>
+            <span class="empty-hint" data-i18n="emptyOntology">Ingest material to inspect ontology candidates.</span>
           </div>
 
-          <form id="asset-form" class="asset-form">
+          <form id="asset-form" class="inline-form">
             <label>
-              Concept
+              <span data-i18n="concept">Concept</span>
               <select id="asset-concept" disabled>
-                <option value="">Select a concept</option>
+                <option value="" data-i18n="concept">Select a concept</option>
               </select>
             </label>
             <label>
-              Asset type
+              <span data-i18n="assetType">Asset type</span>
               <select id="asset-type">
                 <option value="diagram">Diagram</option>
                 <option value="lesson_slice">Lesson slice</option>
@@ -111,39 +195,63 @@
               </select>
             </label>
             <button id="asset-button" type="submit" disabled>
-              <span class="btn-text">Generate prompt</span>
+              <span class="btn-text" data-i18n="generatePrompt">Generate prompt</span>
               <span class="btn-spinner" aria-hidden="true"></span>
             </button>
           </form>
 
           <div id="asset-output" class="ontology-view empty-state">
-            <span class="empty-hint">Generate a prompt to inspect model key, review state, and evidence.</span>
+            <span class="empty-hint" data-i18n="emptyAsset">Generate a prompt to inspect model key, review state, and evidence.</span>
           </div>
-        </section>
+        </div>
+
       </section>
 
-      <aside class="feedback-pane" aria-label="Feedback">
+      <!-- RIGHT: Feedback sidebar -->
-        <div class="section-heading">
+      <aside class="feedback-sidebar">
-          <div>
+
-            <p class="eyebrow">Feedback</p>
+        <!-- Empty state -->
-            <h2>Rubric result</h2>
+        <div id="feedback-empty" class="sidebar-empty">
+          <div class="empty-icon"></div>
+          <p data-i18n="feedbackEmpty">답변을 제출하면 채점 결과가 여기에 표시됩니다.</p>
         </div>
+
+        <!-- Feedback content (hidden until answer submitted) -->
+        <div id="feedback-content" class="feedback-content" style="display:none">
+          <div class="feedback-grade">
+            <div id="grade-display" class="grade-badge"></div>
+            <p id="grade-strength" class="grade-summary"></p>
           </div>
-        <div id="feedback" class="feedback empty-state">
+
-          <span class="empty-hint">Submit an answer to see grade, evidence, and follow-up.</span>
+          <div id="score-metrics" class="score-metrics"></div>
+
+          <div id="gaps-block" class="feedback-block"></div>
+          <div id="followup-block" class="feedback-block"></div>
+          <div id="evidence-block" class="feedback-block"></div>
         </div>
-        <div class="section-heading progress-heading">
+
-          <div>
+        <!-- Divider -->
-            <p class="eyebrow">Progress</p>
+        <div class="sidebar-divider" id="progress-divider" style="display:none"></div>
-            <h2>Learning state</h2>
+
+        <!-- Progress section -->
+        <div id="progress-content" class="progress-content" style="display:none">
+          <div class="progress-header">
+            <h3 data-i18n="learningState">Learning state</h3>
+            <button id="refresh-progress" class="link-btn" type="button" disabled data-i18n="refresh">Refresh</button>
           </div>
-          <button id="refresh-progress" class="small-button" type="button" disabled>Refresh</button>
+          <div class="progress-bar-wrap">
+            <div id="progress-bar" class="progress-bar" style="width:0%"></div>
+            <span id="readiness-pct" class="progress-pct">0%</span>
           </div>
-        <div id="progress" class="feedback empty-state">
+          <div id="concept-memory" class="concept-list"></div>
-          <span class="empty-hint">Answer once to update learner memory and readiness.</span>
+          <div id="next-challenge-block" class="challenge-block"></div>
         </div>
+
       </aside>
-    </main>
+    </div>
-    <script src="/assets/app.js" type="module"></script>
+  </div>
+
+  <script src="/assets/i18n.js?v=4"></script>
+  <script src="/assets/app.js?v=4"></script>
 </body>
 </html>

internal/webapp/static/styles.css

@@ -19,456 +19,436 @@
   --strong-bg: #f0faf3;
   --neutral: #6b7570;
   --neutral-bg: #f4f5f4;
+  --radius: 8px;
+  --shadow-sm: 0 1px 3px rgba(24,32,27,.06);
+  --shadow-md: 0 4px 16px rgba(24,32,27,.08);
 }
 
-* {
+*, *::before, *::after { box-sizing:border-box; }
-  box-sizing: border-box;
-}
 
 body {
-  margin: 0;
+  margin:0; min-height:100vh;
-  min-height: 100vh;
+  background:var(--bg); color:var(--text);
-  background: var(--bg);
-  color: var(--text);
   font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;
-  letter-spacing: 0;
   -webkit-font-smoothing:antialiased;
-  -moz-osx-font-smoothing: grayscale;
 }
 
-button,
+button,input,textarea,select { font:inherit; }
-input,
-textarea,
-select {
-  font: inherit;
-}
 
-.workspace {
+/* ===== LOGIN ===== */
-  display: grid;
+.login-page {
-  grid-template-columns: minmax(260px, 320px) minmax(360px, 1fr) minmax(280px, 360px);
+  display:flex; align-items:center; justify-content:center;
-  gap: 1px;
+  min-height:100vh; padding:24px;
-  min-height: 100vh;
+  background:linear-gradient(160deg,#f5f7f4 0%,#e3ebe0 100%);
-  background: var(--line);
 }
-
+.login-card {
-.setup-pane,
-.practice-pane,
-.feedback-pane {
   background:var(--surface);
-  padding: 28px;
-}
-
-.practice-pane {
-  display: flex;
-  flex-direction: column;
-  gap: 22px;
-}
-
-.eyebrow {
-  margin: 0 0 10px;
-  color: var(--accent);
-  font-size: 12px;
-  font-weight: 750;
-  letter-spacing: 0.06em;
-}
-
-html[lang="ko"] .eyebrow {
-  text-transform: none;
-  letter-spacing: 0.02em;
-}
-
-h1,
-h2 {
-  margin: 0;
-  line-height: 1.08;
-}
-
-h1 {
-  font-size: clamp(36px, 5vw, 64px);
-  line-height: 1.05;
-}
-
-h2 {
-  font-size: 22px;
-}
-
-.lede {
-  max-width: 28ch;
-  margin: 18px 0 30px;
-  color: var(--muted);
-  line-height: 1.5;
-}
-
-.stacked-form,
-.answer-form {
-  display: grid;
-  gap: 14px;
-}
-
-.material-form,
-.asset-form {
-  align-items: end;
-  display: grid;
-  gap: 14px;
-  grid-template-columns: repeat(2, minmax(180px, 1fr)) auto;
-}
-
-.wide-field {
-  grid-column: 1 / -1;
-}
-
-label {
-  display: grid;
-  gap: 7px;
-  color: var(--muted);
-  font-size: 13px;
-  font-weight: 650;
-}
-
-input,
-textarea,
-select {
-  width: 100%;
   border:1px solid var(--line);
-  border-radius: 6px;
+  border-radius:16px; padding:48px 40px 36px;
-  background: #fbfcfa;
+  max-width:400px; width:100%; text-align:center;
-  color: var(--text);
+  box-shadow:0 16px 48px rgba(24,32,27,.08);
-  padding: 12px;
+}
-  outline: none;
+.login-brand {
+  color:var(--accent); font-size:13px; font-weight:750;
+  letter-spacing:.08em; margin-bottom:16px;
+}
+.login-heading {
+  margin:0; font-size:clamp(28px,6vw,40px);
+  line-height:1.12; letter-spacing:-.01em;
+}
+.login-desc {
+  margin:12px auto 32px; max-width:30ch;
+  color:var(--muted); font-size:15px; line-height:1.55;
+}
+.login-lang { margin-top:28px; justify-content:center; }
+.login-error {
+  margin-top:16px; padding:10px 14px; border-radius:var(--radius);
+  background:var(--weak-bg); color:var(--weak);
+  font-size:13px; display:none;
+}
+.login-error.visible { display:block; }
+
+/* ===== TOPBAR ===== */
+.topbar {
+  display:flex; align-items:center; justify-content:space-between;
+  height:52px; padding:0 20px;
+  background:var(--surface); border-bottom:1px solid var(--line);
+  position:sticky; top:0; z-index:10;
+}
+.topbar-brand {
+  color:var(--accent); font-size:12px; font-weight:750;
+  letter-spacing:.06em; white-space:nowrap;
+}
+.topbar-center { display:flex; align-items:center; }
+.topbar-right {
+  display:flex; align-items:center; gap:12px;
+}
+.step-indicator {
+  font-size:12px; font-weight:650; color:var(--muted);
+}
+.user-menu { display:flex; align-items:center; gap:8px; }
+.user-name {
+  font-size:12px; font-weight:650; color:var(--muted);
+  max-width:140px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
+}
+.icon-btn {
+  min-height:32px; width:32px; border:0; border-radius:6px;
+  background:transparent; color:var(--muted);
+  cursor:pointer; font-size:16px; display:inline-flex;
+  align-items:center; justify-content:center;
+}
+.icon-btn:hover { background:var(--surface-muted); color:var(--text); }
+.link-btn {
+  border:0; background:none; color:var(--muted);
+  cursor:pointer; font-size:12px; padding:4px 8px; border-radius:4px;
+}
+.link-btn:hover { background:var(--surface-muted); color:var(--text); }
+.link-btn:disabled { opacity:.4; cursor:not-allowed; }
+
+/* ===== LANG SWITCH ===== */
+.lang-switch {
+  display:inline-flex; gap:3px;
+  background:var(--surface-muted); border-radius:6px; padding:2px;
+}
+.lang-btn {
+  min-height:26px; padding:0 8px; border:0; border-radius:4px;
+  background:transparent; color:var(--muted);
+  font-size:11px; font-weight:750; cursor:pointer;
+}
+.lang-btn:hover { background:rgba(24,32,27,.04); color:var(--text); }
+.lang-btn.is-active {
+  background:var(--surface); color:var(--accent);
+  box-shadow:0 1px 2px rgba(24,32,27,.06);
+}
+
+/* ===== MAIN GRID ===== */
+.main-grid {
+  display:grid;
+  grid-template-columns:1fr 340px;
+  min-height:calc(100vh - 52px);
+}
+.main-pane {
+  padding:28px 32px; display:flex; flex-direction:column; gap:20px;
+  max-width:800px;
+}
+.feedback-sidebar {
+  background:var(--surface);
+  border-left:1px solid var(--line);
+  padding:24px 20px;
+  overflow-y:auto;
+}
+
+/* ===== SETUP CARD ===== */
+.setup-card {
+  background:var(--surface); border:1px solid var(--line);
+  border-radius:var(--radius); padding:24px;
+  box-shadow:var(--shadow-sm);
+}
+.card-header { margin-bottom:18px; }
+.card-header h2 { margin:0 0 4px; font-size:20px; }
+.card-hint { margin:0; color:var(--muted); font-size:13px; line-height:1.5; }
+
+.inline-form { display:flex; gap:12px; align-items:end; flex-wrap:wrap; }
+.field-row { display:flex; gap:12px; flex:1; min-width:0; }
+.field-row label { flex:1; min-width:0; }
+
+.stacked-form { display:grid; gap:14px; }
+
+label { display:grid; gap:6px; color:var(--muted); font-size:12px; font-weight:650; }
+
+input, textarea, select {
+  width:100%; border:1px solid var(--line); border-radius:var(--radius);
+  background:#fbfcfa; color:var(--text); padding:10px 12px; outline:none;
+}
+select {
   appearance:none;
+  background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 24 24' fill='none' stroke='%235b665f' stroke-width='2'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");
+  background-repeat:no-repeat; background-position:right 10px center;
+  padding-right:32px;
+}
+textarea { min-height:120px; resize:vertical; line-height:1.5; }
+input:focus, textarea:focus, select:focus {
+  border-color:var(--accent); box-shadow:0 0 0 3px rgba(25,118,75,.1);
 }
 
-select {
+/* ===== BUTTONS ===== */
-  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 24 24' fill='none' stroke='%235b665f' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");
-  background-repeat: no-repeat;
-  background-position: right 12px center;
-  padding-right: 36px;
-}
-
-textarea {
-  min-height: 160px;
-  resize: vertical;
-  line-height: 1.45;
-}
-
-input:focus,
-textarea:focus,
-select:focus {
-  border-color: var(--accent);
-  box-shadow: 0 0 0 3px rgba(25, 118, 75, 0.12);
-}
-
 button {
-  min-height: 44px;
+  min-height:40px; border:0; border-radius:var(--radius);
-  border: 0;
+  background:var(--accent); color:#fff; cursor:pointer;
-  border-radius: 6px;
+  font-weight:650; display:inline-flex; align-items:center;
-  background: var(--accent);
+  justify-content:center; gap:8px; padding:0 20px;
-  color: #fff;
+  transition:background .15s ease,transform .1s ease;
-  cursor: pointer;
+  white-space:nowrap;
-  font-weight: 750;
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  gap: 8px;
-  position: relative;
 }
-
+button:hover:not(:disabled) { background:var(--accent-dark); }
-button:hover:not(:disabled) {
+button:active:not(:disabled) { transform:translateY(1px); }
-  background: var(--accent-dark);
+button:disabled { cursor:not-allowed; opacity:.45; }
-}
-
-button:active:not(:disabled) {
-  transform: translateY(1px);
-}
-
-button:disabled {
-  cursor: not-allowed;
-  opacity: 0.48;
-}
-
 .btn-spinner {
-  display: none;
+  display:none; width:14px; height:14px;
-  width: 16px;
+  border:2px solid rgba(255,255,255,.3); border-top-color:#fff;
-  height: 16px;
+  border-radius:50%; animation:spin .8s linear infinite;
-  border: 2px solid rgba(255, 255, 255, 0.35);
-  border-top-color: #fff;
-  border-radius: 50%;
-  animation: spin 0.8s linear infinite;
-}
-
-button.is-loading .btn-text {
-  opacity: 0.9;
-}
-
-button.is-loading .btn-spinner {
-  display: inline-block;
-}
-
-@keyframes spin {
-  to {
-    transform: rotate(360deg);
-  }
 }
+button.is-loading .btn-text { opacity:.85; }
+button.is-loading .btn-spinner { display:inline-block; }
+@keyframes spin { to { transform:rotate(360deg); } }
 
+/* ===== STATUS / ERROR ===== */
 .status-line {
-  display: flex;
+  display:flex; align-items:center; gap:8px;
-  align-items: center;
+  min-height:18px; margin:14px 0 0; font-size:12px; color:var(--muted);
-  gap: 8px;
-  min-height: 20px;
-  margin: 18px 0 0;
-  font-size: 13px;
-  color: var(--muted);
 }
-
+.status-dot {
-.status-icon {
+  display:inline-block; width:7px; height:7px; border-radius:50%; background:var(--accent);
-  display: inline-block;
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  background: var(--accent);
 }
-
+.status-line.is-busy .status-dot { background:var(--warn); animation:pulse 1.2s ease-in-out infinite; }
-.status-line.is-busy .status-icon {
+@keyframes pulse { 0%,100%{opacity:1} 50%{opacity:.3} }
-  background: var(--warn);
-  animation: pulse 1.2s ease-in-out infinite;
-}
-
-@keyframes pulse {
-  0%, 100% {
-    opacity: 1;
-  }
-  50% {
-    opacity: 0.35;
-  }
-}
-
 .error-line {
-  min-height: 20px;
+  min-height:18px; margin:8px 0 0; font-size:12px; color:var(--danger);
-  margin: 10px 0 0;
-  font-size: 13px;
-  color: var(--danger);
 }
 
-.section-heading {
+/* ===== QUESTION BAR ===== */
-  display: flex;
+.question-bar { margin-top:4px; }
-  align-items: end;
+.bar-label { font-size:12px; font-weight:650; color:var(--muted); margin-bottom:10px; }
-  justify-content: space-between;
+.question-tabs {
-  gap: 16px;
+  display:flex; flex-wrap:wrap; gap:8px;
 }
-
+.question-tab {
-.question-list {
+  border:1px solid var(--line); border-radius:var(--radius);
-  display: grid;
+  background:#fbfcfa; color:var(--text); padding:10px 16px;
-  gap: 10px;
+  cursor:pointer; font-size:13px; font-weight:500; text-align:left;
-}
+  transition:border-color .15s,border-left-color .15s,background .15s;
-
-.question-button {
-  border: 1px solid var(--line);
   border-left:3px solid transparent;
-  background: #fbfcfa;
+}
-  color: var(--text);
+.question-tab:hover { border-color:var(--accent); }
-  padding: 16px;
+.question-tab[aria-selected="true"] {
-  min-height: 72px;
+  border-color:var(--accent); border-left-color:var(--accent);
-  text-align: left;
+  background:var(--surface-muted); font-weight:650;
-  border-radius: 6px;
+}
-  transition: border-color 0.15s ease, background 0.15s ease;
+.question-tab-id {
+  display:block; font-size:11px; color:var(--accent); font-weight:750; margin-bottom:3px;
 }
 
-.question-button:hover:not(:disabled) {
+/* ===== ANSWER AREA ===== */
-  border-color: var(--accent);
+.answer-form { display:grid; gap:12px; }
+.answer-header {
+  display:flex; align-items:baseline; justify-content:space-between; gap:12px;
+}
+.answer-header label {
+  font-size:14px; font-weight:700; color:var(--text);
+}
+.answer-hint { font-size:12px; color:var(--muted); }
+
+/* ===== TOOLS PANEL ===== */
+.tools-divider {
+  height:1px; background:var(--line); margin:12px 0 8px;
+}
+.tools-panel { display:flex; flex-direction:column; gap:16px; }
+.tools-panel h2 { font-size:18px; margin:0; }
+
+/* ===== FEEDBACK SIDEBAR ===== */
+.sidebar-empty {
+  text-align:center; padding:40px 12px; color:var(--muted);
+}
+.sidebar-empty .empty-icon {
+  width:40px; height:40px; margin:0 auto 14px; opacity:.35;
+  background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='40' height='40' viewBox='0 0 24 24' fill='none' stroke='%235b665f' stroke-width='1.5' stroke-linecap='round'%3E%3Cpath d='M12 20h9'/%3E%3Cpath d='M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4Z'/%3E%3C/svg%3E");
+  background-size:contain; background-repeat:no-repeat; background-position:center;
+}
+.sidebar-empty p { margin:0; font-size:13px; line-height:1.55; }
+.feedback-content { display:flex; flex-direction:column; gap:16px; }
+
+/* Grade badge */
+.feedback-grade { text-align:center; padding:8px 0 4px; }
+.grade-badge {
+  display:inline-block; padding:6px 20px; border-radius:999px;
+  font-size:14px; font-weight:800; letter-spacing:.02em;
+}
+.grade-badge.miss   { background:var(--weak-bg); color:var(--weak); }
+.grade-badge.partial{ background:var(--warn-bg); color:var(--warn); }
+.grade-badge.solid  { background:var(--good-bg); color:var(--good); }
+.grade-badge.strong { background:var(--strong-bg); color:var(--strong); }
+.grade-summary {
+  margin:8px 0 0; font-size:12px; color:var(--muted);
 }
 
-.question-button[aria-pressed="true"] {
+/* Score metrics */
-  border-color: var(--accent);
+.score-metrics { display:grid; gap:1px; background:var(--line); border-radius:var(--radius); overflow:hidden; }
-  border-left-color: var(--accent);
+.metric-row {
-  background: var(--surface-muted);
+  display:grid; grid-template-columns:1fr auto;
-}
+  gap:8px; padding:10px 14px; background:var(--surface);
-
-.question-id {
-  display: block;
-  margin-bottom: 5px;
-  color: var(--accent);
-  font-size: 12px;
-  font-weight: 750;
-}
-
-.empty-state {
-  border: 1px dashed var(--line);
-  border-radius: 6px;
-  color: var(--muted);
-  padding: 22px 18px;
-  text-align: center;
   font-size:13px;
-  line-height: 1.5;
+}
+.metric-row strong { color:var(--accent); }
+
+/* Feedback blocks */
+.feedback-block { display:none; }
+.feedback-block.has-content { display:block; }
+.feedback-block h4 {
+  margin:0 0 6px; font-size:12px; font-weight:750; color:var(--muted);
+  letter-spacing:.03em; text-transform:uppercase;
+}
+.feedback-block ul {
+  margin:0; padding-left:18px; font-size:13px; color:var(--muted); line-height:1.6;
 }
 
+/* ===== PROGRESS SECTION ===== */
+.sidebar-divider {
+  height:1px; background:var(--line); margin:20px 0;
+}
+.progress-content { display:flex; flex-direction:column; gap:14px; }
+.progress-header {
+  display:flex; align-items:center; justify-content:space-between;
+}
+.progress-header h3 { margin:0; font-size:16px; }
+.progress-bar-wrap {
+  position:relative; height:28px; background:var(--surface-muted);
+  border-radius:14px; overflow:hidden;
+}
+.progress-bar {
+  height:100%; background:var(--accent); border-radius:14px;
+  transition:width .5s ease;
+  min-width:0;
+}
+.progress-bar.high { background:var(--strong); }
+.progress-bar.medium { background:var(--good); }
+.progress-bar.low { background:var(--warn); }
+.progress-pct {
+  position:absolute; right:14px; top:50%; transform:translateY(-50%);
+  font-size:12px; font-weight:800; color:var(--text);
+}
+
+/* Concept pills */
+.concept-list { display:flex; flex-wrap:wrap; gap:6px; }
+.concept-pill {
+  display:inline-flex; align-items:center; gap:6px;
+  border:1px solid var(--line); border-radius:999px;
+  padding:5px 12px; font-size:12px; font-weight:650; background:var(--surface);
+}
+.pill-neutral { background:var(--neutral-bg); border-color:#d5dad3; color:var(--neutral); }
+.pill-weak    { background:var(--weak-bg);   border-color:#e8bdb9; color:var(--weak); }
+.pill-warn    { background:var(--warn-bg);   border-color:#edd5b5; color:var(--warn); }
+.pill-good    { background:var(--good-bg);   border-color:#b8d9e8; color:var(--good); }
+.pill-strong  { background:var(--strong-bg); border-color:#b8dfc6; color:var(--strong); }
+
+/* Challenge */
+.challenge-block {
+  border:1px solid var(--line); border-radius:var(--radius);
+  padding:14px; font-size:13px; line-height:1.55; color:var(--muted);
+}
+.challenge-block strong { color:var(--text); }
+
+/* ===== EMPTY STATE ===== */
+.empty-state {
+  border:1px dashed var(--line); border-radius:var(--radius);
+  color:var(--muted); padding:18px 16px; text-align:center;
+  font-size:12px; line-height:1.5;
+}
 .empty-hint::before {
-  content: "";
+  content:""; display:block; width:20px; height:20px;
-  display: block;
+  margin:0 auto 8px; opacity:.4;
-  width: 24px;
+  background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='20' height='20' viewBox='0 0 24 24' fill='none' stroke='%235b665f' stroke-width='1.5' stroke-linecap='round'%3E%3Ccircle cx='12' cy='12' r='10'/%3E%3Cpath d='M12 16v-4'/%3E%3Cpath d='M12 8h.01'/%3E%3C/svg%3E");
-  height: 24px;
-  margin: 0 auto 10px;
-  opacity: 0.45;
-  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='%235b665f' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='12' cy='12' r='10'/%3E%3Cpath d='M12 16v-4'/%3E%3Cpath d='M12 8h.01'/%3E%3C/svg%3E");
   background-size:contain;
 }
 
-.feedback {
+/* ===== ONTOLOGY ===== */
-  display: grid;
+.ontology-view { display:grid; gap:10px; }
-  gap: 16px;
+.summary-strip { display:flex; flex-wrap:wrap; gap:8px; }
-  margin-top: 22px;
+.summary-chip {
+  background:var(--surface-muted); border-radius:999px;
+  color:var(--muted); font-size:11px; font-weight:750; padding:5px 10px;
+}
+.prompt-text {
+  background:#fbfcfa; border:1px solid var(--line); border-radius:var(--radius);
+  margin:0; padding:12px; white-space:pre-wrap; font-size:12px; line-height:1.5; color:var(--text);
 }
 
-.progress-heading {
+/* ===== FILE UPLOAD ===== */
-  margin-top: 34px;
+.file-upload-row {
-}
+  display: flex;
-
+  align-items: center;
-.small-button {
-  min-height: 34px;
-  padding: 0 12px;
-  font-size: 12px;
-}
-
-.metric-row {
-  display: grid;
-  grid-template-columns: 1fr auto;
   gap: 10px;
-  padding: 10px 0;
+  grid-column: 1 / -1;
-  border-bottom: 1px solid var(--line);
 }
 
-.metric-row:last-child {
+.file-label {
-  border-bottom: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  font-size: 13px;
+  font-weight: 650;
+  color: var(--muted);
 }
 
-.grade {
+.file-label input[type="file"] {
-  font-size: 38px;
+  padding: 8px;
-  font-weight: 800;
+  font-size: 12px;
-  line-height: 1.1;
-}
-
-.grade-miss {
-  color: var(--weak);
-}
-
-.grade-partial {
-  color: var(--warn);
-}
-
-.grade-solid {
-  color: var(--good);
-}
-
-.grade-strong {
-  color: var(--strong);
-}
-
-.readiness-value {
-  color: var(--accent);
-  font-size: 48px;
-  font-weight: 850;
-  line-height: 1;
-}
-
-.concept-pill {
-  display: inline-flex;
-  margin: 4px 6px 4px 0;
   border: 1px solid var(--line);
-  border-radius: 999px;
+  border-radius: 6px;
+  background: #fbfcfa;
+  color: var(--text);
+  cursor: pointer;
+  min-width: 200px;
+}
+
+.file-label input[type="file"]::file-selector-button {
+  border: 1px solid var(--line);
+  border-radius: 4px;
   padding: 6px 10px;
+  background: var(--surface);
+  color: var(--text);
+  cursor: pointer;
+  font-size: 12px;
+  font-weight: 650;
+  margin-right: 10px;
+}
+
+.file-label input[type="file"]::file-selector-button:hover {
+  background: var(--surface-muted);
+}
+
+.file-name {
+  font-size: 12px;
+  color: var(--muted);
+  flex: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.paste-toggle {
+  grid-column: 1 / -1;
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 10px 14px;
+  background: #fbfcfa;
+}
+
+.paste-toggle summary {
+  cursor: pointer;
   color: var(--muted);
   font-size: 12px;
   font-weight: 650;
-  background: var(--surface);
 }
 
-.pill-neutral {
+.paste-toggle[open] summary {
-  background: var(--neutral-bg);
+  margin-bottom: 12px;
-  border-color: #d5dad3;
-  color: var(--neutral);
 }
 
-.pill-weak {
+.paste-toggle .wide-field {
-  background: var(--weak-bg);
+  grid-column: 1 / -1;
-  border-color: #e8bdb9;
-  color: var(--weak);
 }
 
-.pill-warn {
+.small-button {
-  background: var(--warn-bg);
+  min-height: 32px;
-  border-color: #edd5b5;
+  padding: 0 14px;
-  color: var(--warn);
-}
-
-.pill-good {
-  background: var(--good-bg);
-  border-color: #b8d9e8;
-  color: var(--good);
-}
-
-.pill-strong {
-  background: var(--strong-bg);
-  border-color: #b8dfc6;
-  color: var(--strong);
-}
-
-.small-list {
-  margin: 0;
-  padding-left: 18px;
-  color: var(--muted);
-  line-height: 1.45;
-}
-
-.content-workspace {
-  border-top: 2px solid var(--line);
-  display: grid;
-  gap: 18px;
-  padding-top: 28px;
-  margin-top: 6px;
-}
-
-.ontology-view {
-  display: grid;
-  gap: 12px;
-}
-
-.summary-strip {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 10px;
-}
-
-.summary-chip {
-  background: var(--surface-muted);
-  border-radius: 999px;
-  color: var(--muted);
   font-size: 12px;
-  font-weight: 750;
-  padding: 7px 12px;
 }
 
-.prompt-text {
+/* ===== RESPONSIVE ===== */
-  background: #fbfcfa;
+@media (max-width:900px) {
-  border: 1px solid var(--line);
+  .main-grid { grid-template-columns:1fr; }
-  border-radius: 6px;
+  .main-pane { padding:20px; }
-  margin: 0;
+  .feedback-sidebar { border-left:0; border-top:1px solid var(--line); padding:20px; }
-  padding: 14px;
+  .topbar { flex-wrap:wrap; height:auto; gap:8px; padding:10px 14px; }
-  white-space: pre-wrap;
+  .topbar-right { flex-wrap:wrap; justify-content:flex-end; }
-  font-size: 13px;
-  line-height: 1.5;
-  color: var(--text);
-}
-
-@media (max-width: 980px) {
-  .workspace {
-    grid-template-columns: 1fr;
-  }
-
-  h1 {
-    font-size: 42px;
-  }
-
-  .material-form,
-  .asset-form {
-    grid-template-columns: 1fr;
-  }
 }

internal/workflows/llm_runner.go

@@ -0,0 +1,133 @@
+package workflows
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+
+	"tutor/internal/llm"
+)
+
+type LLMRunner struct {
+	client *llm.Client
+}
+
+func NewLLMRunner(client *llm.Client) *LLMRunner {
+	return &LLMRunner{client: client}
+}
+
+func (r *LLMRunner) DiagnoseJobSeeker(ctx context.Context, input DiagnosticInput) (DiagnosticResult, error) {
+	raw, err := r.client.ChatJSON(ctx, diagnoseSystemPrompt(), diagnoseUserPrompt(input), true)
+	if err != nil {
+		return DiagnosticResult{}, fmt.Errorf("diagnose_job_seeker: %w", err)
+	}
+
+	var result DiagnosticResult
+	if err := extractJSON(raw, &result); err != nil {
+		return DiagnosticResult{}, fmt.Errorf("diagnose_job_seeker parse: %w", err)
+	}
+	return result, nil
+}
+
+func (r *LLMRunner) GradeInterviewAnswer(ctx context.Context, input GradeAnswerInput) (GradedAnswer, error) {
+	raw, err := r.client.ChatJSON(ctx, gradeAnswerSystemPrompt(), gradeAnswerUserPrompt(input), true)
+	if err != nil {
+		return GradedAnswer{}, fmt.Errorf("grade_interview_answer: %w", err)
+	}
+
+	var result GradedAnswer
+	if err := extractJSON(raw, &result); err != nil {
+		return GradedAnswer{}, fmt.Errorf("grade_interview_answer parse: %w", err)
+	}
+
+	result.UserID = input.UserID
+	result.AnswerID = input.AnswerID
+	result.QuestionID = input.QuestionID
+	return result, nil
+}
+
+func (r *LLMRunner) ExtractLearningMemory(ctx context.Context, grade GradedAnswer) (MemoryUpdateCandidate, error) {
+	raw, err := r.client.ChatJSON(ctx, extractMemorySystemPrompt(), extractMemoryUserPrompt(grade), true)
+	if err != nil {
+		return MemoryUpdateCandidate{}, fmt.Errorf("extract_learning_memory: %w", err)
+	}
+
+	candidate := MemoryUpdateCandidate{
+		UserID:         grade.UserID,
+		SourceAnswerID: grade.AnswerID,
+	}
+	if err := extractJSON(raw, &candidate); err != nil {
+		return MemoryUpdateCandidate{}, fmt.Errorf("extract_learning_memory parse: %w", err)
+	}
+	return candidate, nil
+}
+
+func (r *LLMRunner) SelectNextChallenge(ctx context.Context, input NextChallengeInput) (NextChallenge, error) {
+	raw, err := r.client.ChatJSON(ctx, nextChallengeSystemPrompt(), nextChallengeUserPrompt("", ""), true)
+	if err != nil {
+		return NextChallenge{}, fmt.Errorf("select_next_challenge: %w", err)
+	}
+
+	var next NextChallenge
+	if err := extractJSON(raw, &next); err != nil {
+		return NextChallenge{}, fmt.Errorf("select_next_challenge parse: %w", err)
+	}
+	next.UserID = input.UserID
+	next.Track = input.Track
+	return next, nil
+}
+
+func (r *LLMRunner) UpdateReadinessMap(ctx context.Context, input ReadinessUpdateInput) (ReadinessUpdate, error) {
+	raw, err := r.client.ChatJSON(ctx, readinessUpdateSystemPrompt(), readinessUpdateUserPrompt(input), true)
+	if err != nil {
+		return ReadinessUpdate{}, fmt.Errorf("update_readiness_map: %w", err)
+	}
+
+	var update ReadinessUpdate
+	if err := extractJSON(raw, &update); err != nil {
+		return ReadinessUpdate{}, fmt.Errorf("update_readiness_map parse: %w", err)
+	}
+	update.UserID = input.UserID
+	update.Track = input.Track
+	return update, nil
+}
+
+func extractJSON(raw string, target any) error {
+	clean := strings.TrimSpace(raw)
+	if strings.HasPrefix(clean, "```") {
+		clean = stripCodeFences(clean)
+	}
+	if err := json.Unmarshal([]byte(clean), target); err != nil {
+		return fmt.Errorf("%w: %s", err, firstBytes(clean, 200))
+	}
+	return nil
+}
+
+var errCodeFence = errors.New("code fence")
+
+func stripCodeFences(input string) string {
+	lines := strings.Split(input, "\n")
+	start := 0
+	end := len(lines)
+	for i, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "```") {
+			if start == 0 {
+				start = i + 1
+				continue
+			}
+			end = i
+			break
+		}
+	}
+	return strings.Join(lines[start:end], "\n")
+}
+
+func firstBytes(input string, limit int) string {
+	if len(input) > limit {
+		return input[:limit] + "..."
+	}
+	return input
+}

internal/workflows/prompts.go

@@ -0,0 +1,180 @@
+package workflows
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+func gradeAnswerSystemPrompt() string {
+	return fmt.Sprintf(`You are an expert technical interviewer grading a candidate's answer. Output valid JSON matching this schema:
+
+{
+  "user_id": "string",
+  "answer_id": "string",
+  "question_id": "string",
+  "concepts": [{"id": "string", "label": "string", "track": "string"}],
+  "scores": {
+    "correctness": 0,
+    "depth": 0,
+    "communication": 0,
+    "production_judgment": 0
+  },
+  "overall": "miss|partial|solid|strong",
+  "strengths": ["string"],
+  "gaps": ["string"],
+  "evidence": [{"kind": "answer|grading|source|session|asset", "id": "string", "quote": "string", "confidence": 0.0}],
+  "misconception_candidates": [{"label": "string", "description": "string", "evidence": [], "confidence": 0.0}],
+  "follow_up": {"needed": true, "question": "string", "purpose": "clarify|repair|stretch|pressure_test"}
+}
+
+Scoring rules:
+- scores: 1-4 integer scale (1=inadequate, 2=surface, 3=solid, 4=strong).
+- correctness: factual accuracy
+- depth: covers tradeoffs, edge cases, production context
+- communication: clarity, structure, conciseness
+- production_judgment: practical experience signals in the answer
+- overall: "miss" if mostly wrong, "partial" if some correct parts, "solid" if mostly correct with depth, "strong" if comprehensive and production-ready.
+- evidence: always include at least one EvidenceRef with kind "grading", quote from the answer, and confidence 0.5-1.0.
+- follow_up.needed: true unless the answer is "strong" and complete. Set purpose to "clarify" for unclear answers, "repair" for misconceptions, "stretch" to test depth, "pressure_test" for strong answers.
+- misconception_candidates: list any detected wrong mental models.
+
+Respond with ONLY the JSON object, no markdown fences.`)
+}
+
+func gradeAnswerUserPrompt(input GradeAnswerInput) string {
+	payload, _ := json.Marshal(input)
+	return fmt.Sprintf("Grade this interview answer: %s", string(payload))
+}
+
+func extractMemorySystemPrompt() string {
+	return fmt.Sprintf(`You are a learner memory extraction agent. From a graded interview answer, produce memory updates. Output valid JSON matching this schema:
+
+{
+  "updates": [
+    {
+      "kind": "concept_mastery|misconception|intervention|review_schedule",
+      "concept": {"id": "string", "label": "string", "track": "string"},
+      "proposed_state": "unknown|fragile|improving|interview_ready|strong_signal",
+      "summary": "string",
+      "evidence": [{"kind": "grading", "id": "string", "quote": "string", "confidence": 0.0}],
+      "confidence": 0.0,
+      "durability": "tentative|confirmed"
+    }
+  ]
+}
+
+Rules:
+- For every concept in the grading, create a concept_mastery update with proposed_state derived from overall grade: "miss"→fragile, "partial"→improving, "solid"→interview_ready, "strong"→strong_signal.
+- If follow_up.needed is true and overall is "miss" or "partial", add a misconception update (kind="misconception") for each concept with proposed_state "fragile".
+- If follow_up.needed is true, add an intervention update (kind="intervention") for each concept with the follow_up question as summary.
+- If the answer shows gaps, add a review_schedule update (kind="review_schedule") for each concept with a review reason.
+- Confidence: 0.5-0.7 for tentative, 0.8-1.0 for confirmed. Durability: "confirmed" only for "strong" overall.
+
+Respond with ONLY the JSON object, no markdown fences.`)
+}
+
+func extractMemoryUserPrompt(grade GradedAnswer) string {
+	payload, _ := json.Marshal(grade)
+	return fmt.Sprintf("Extract memory updates from this graded answer: %s", string(payload))
+}
+
+func nextChallengeSystemPrompt() string {
+	return fmt.Sprintf(`You are a challenge selection agent. Given learner memory state, select the next challenge. Output valid JSON matching this schema:
+
+{
+  "concept": {"id": "string", "label": "string", "track": "string"},
+  "ladder_level": "define|tradeoffs|debug|design_constraints|interview_pressure",
+  "question": "string",
+  "rationale": "string",
+  "difficulty_action": "lower|hold|raise|recover",
+  "evidence": [{"kind": "grading", "id": "string", "quote": "string", "confidence": 0.0}]
+}
+
+Rules:
+- Pick the concept with the weakest readiness state.
+- ladder_level: fragile→define, improving→tradeoffs, interview_ready→design_constraints, strong_signal→interview_pressure.
+- difficulty_action: fragile→recover, improving→hold, interview_ready+→raise.
+- Generate one concrete interview question for the selected concept at the appropriate ladder level.
+- rationale: explain why this concept and level was chosen.
+- evidence: reference the concept's existing evidence.
+
+Respond with ONLY the JSON object, no markdown fences.`)
+}
+
+func nextChallengeUserPrompt(masteryJSON, profileJSON string) string {
+	return fmt.Sprintf(`Learner mastery: %s
+
+Learner profile: %s
+
+Select the next challenge for this learner.`, masteryJSON, profileJSON)
+}
+
+func diagnoseSystemPrompt() string {
+	return fmt.Sprintf(`You are a diagnostic interview agent. Given a job seeker's profile, produce an initial readiness assessment. Output valid JSON matching this schema:
+
+{
+  "user_id": "string",
+  "track": "string",
+  "target_role": "string",
+  "stack": ["string"],
+  "initial_readiness": "unknown|fragile|improving|interview_ready|strong_signal",
+  "concept_findings": [
+    {
+      "concept": {"id": "string", "label": "string", "track": "string"},
+      "readiness": "unknown|fragile|improving|interview_ready|strong_signal",
+      "reason": "string",
+      "evidence": []
+    }
+  ],
+  "recommended_next_concepts": [{"id": "string", "label": "string", "track": "string"}]
+}
+
+Rules:
+- initial_readiness: default to "unknown" unless you have strong signals from the profile.
+- For each concept, estimate readiness based on the stack and target role. Default to "unknown" if no strong signal.
+- recommended_next_concepts: pick up to 3 concepts to start with.
+- evidence: always empty for initial diagnostic (no answers yet).
+
+Respond with ONLY the JSON object, no markdown fences.`)
+}
+
+func diagnoseUserPrompt(input DiagnosticInput) string {
+	payload, _ := json.Marshal(input)
+	return fmt.Sprintf("Assess initial readiness for this job seeker: %s", string(payload))
+}
+
+func readinessUpdateSystemPrompt() string {
+	return fmt.Sprintf(`You are a readiness update agent. Given learner memory state, produce readiness deltas and unlocks. Output valid JSON matching this schema:
+
+{
+  "concept_updates": [
+    {
+      "concept": {"id": "string", "label": "string", "track": "string"},
+      "previous": "unknown|fragile|improving|interview_ready|strong_signal",
+      "next": "unknown|fragile|improving|interview_ready|strong_signal",
+      "reason": "string",
+      "evidence": [{"kind": "grading", "id": "string", "quote": "string", "confidence": 0.0}]
+    }
+  ],
+  "unlocks": [
+    {
+      "kind": "boss_question|review_card|portfolio_entry",
+      "label": "string",
+      "reason": "string"
+    }
+  ]
+}
+
+Rules:
+- For each concept, determine if the readiness state should change based on evidence quality and quantity.
+- Unlock boss_question when 3+ concepts are at interview_ready or strong_signal.
+- Unlock review_card when concepts have misconceptions that need revisiting.
+- Unlock portfolio_entry when a concept reaches strong_signal.
+
+Respond with ONLY the JSON object, no markdown fences.`)
+}
+
+func readinessUpdateUserPrompt(input ReadinessUpdateInput) string {
+	payload, _ := json.Marshal(input)
+	return fmt.Sprintf("Analyze readiness updates for: %s", string(payload))
+}

maskweaver.config.json

@@ -0,0 +1,92 @@
+{
+  "dummyHumans": {
+    "pool": [
+      {
+        "id": "deepseek-flash",
+        "model": "opencode-go/deepseek-v4-flash",
+        "tier": "flash",
+        "maxConcurrent": 5,
+        "capabilities": [
+          "search",
+          "formatting",
+          "simple-coding",
+          "file-ops"
+        ],
+        "costTier": "low",
+        "description": "DeepSeek V4 Flash - 빠름. 단순 검색/포매팅/파일작업"
+      },
+      {
+        "id": "deepseek-general",
+        "model": "opencode-go/deepseek-v4-flash",
+        "tier": "human",
+        "maxConcurrent": 3,
+        "capabilities": [
+          "coding",
+          "testing",
+          "refactoring",
+          "backend"
+        ],
+        "costTier": "medium",
+        "description": "DeepSeek V4 Flash - 일반. 코딩/리팩토링/백엔드"
+      },
+      {
+        "id": "qwen-vision",
+        "model": "opencode-go/qwen3.6-plus",
+        "tier": "human",
+        "maxConcurrent": 3,
+        "capabilities": [
+          "vision",
+          "frontend",
+          "testing"
+        ],
+        "costTier": "medium",
+        "description": "Qwen 3.6 Plus - 비전. 이미지 분석/프론트엔드/테스트"
+      },
+      {
+        "id": "deepseek-pro",
+        "model": "opencode-go/deepseek-v4-pro",
+        "tier": "premium",
+        "maxConcurrent": 2,
+        "capabilities": [
+          "architecture",
+          "debugging",
+          "reasoning",
+          "complex-coding",
+          "refactoring"
+        ],
+        "costTier": "high",
+        "description": "DeepSeek V4 Pro - 고급 추론. 아키텍처/복잡 디버깅"
+      },
+      {
+        "id": "kimi-vision",
+        "model": "opencode-go/kimi-k2.6",
+        "tier": "premium",
+        "maxConcurrent": 2,
+        "capabilities": [
+          "vision",
+          "reasoning",
+          "complex-coding",
+          "architecture",
+          "debugging"
+        ],
+        "costTier": "high",
+        "description": "Kimi K2.6 - 비전 고급. 이미지 분석/복잡 추론"
+      }
+    ]
+  },
+  "operator": {
+    "model": "opencode-go/deepseek-v4-pro",
+    "maxConcurrent": 2,
+    "description": "Squad Operator model - 작업 오케스트레이션 및 고급 추론"
+  },
+  "memory": {
+    "provider": "text-only",
+    "enabled": false
+  },
+  "gdc": {
+    "enabled": "auto",
+    "strictVerify": false,
+    "autoSyncOnPrepare": true
+  },
+  "language": "ko"
+}

openspec/changes/bootstrap-job-tutor-platform/specs/tutor-workflows/spec.md

@@ -56,3 +56,30 @@ boundary.
 - **WHEN** it invokes the workflow layer
 - **THEN** it calls a typed Go interface
 - **AND** does not mutate product state by parsing freeform shell output.
+
+### Requirement: LLM runner calls OpenAI-compatible API
+
+The system SHALL provide an LLM-based workflow runner that implements the
+Runner interface by calling an OpenAI-compatible chat completions API when
+TUTOR_LLM_API_KEY is configured.
+
+#### Scenario: grader uses LLM when configured
+
+- **GIVEN** TUTOR_LLM_API_KEY and TUTOR_LLM_ENDPOINT are set
+- **WHEN** the server starts
+- **THEN** an LLMRunner wraps the configured model
+- **AND** GradeInterviewAnswer calls the LLM with a structured grading prompt
+- **AND** the response is parsed into the typed GradedAnswer contract.
+
+#### Scenario: memory extraction uses LLM when configured
+
+- **GIVEN** an LLM runner is active
+- **WHEN** ExtractLearningMemory is called with a graded answer
+- **THEN** the LLM produces MemoryUpdateCandidate with concept mastery, misconception, intervention, and review schedule updates.
+
+#### Scenario: falls back to stub when unconfigured
+
+- **GIVEN** TUTOR_LLM_API_KEY is empty
+- **WHEN** the server starts
+- **THEN** a StubRunner is used
+- **AND** grading and memory extraction produce deterministic stub output.