Refactor to add answer grid & assoicate llm parsing

chatkit/backend/app/answer_grid.py

@@ -0,0 +1,229 @@
+"""Canonical answer-grid data model.
+
+Single source of truth for per-student report generation:
+- total_questions (N)
+- official_answers: 1xN vector of letters
+- students: m rows of N letters (or None for blank)
+- questions: N question metadata entries for rendering wrong blocks
+
+Single-choice only. Letters A-Z. All comparisons are case-insensitive trim.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+_BLANK_MARKERS = {"", "-", "–", "—", "n/a", "none", "null"}
+_LETTER_RE = re.compile(r"^[A-Z]$")
+
+
+@dataclass(frozen=True)
+class QuestionMeta:
+    number: int
+    text: str
+    options: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class StudentRow:
+    name: str
+    answers: tuple[Optional[str], ...]
+
+
+@dataclass(frozen=True)
+class AnswerGrid:
+    total_questions: int
+    official_answers: tuple[Optional[str], ...]
+    students: tuple[StudentRow, ...]
+    questions: tuple[QuestionMeta, ...]
+
+
+@dataclass(frozen=True)
+class WrongAnswer:
+    question: QuestionMeta
+    student_answer: Optional[str]
+    correct_answer: str
+
+
+def normalize_letter(raw: Optional[str]) -> Optional[str]:
+    """Normalize a raw cell to a single uppercase letter or None."""
+    if raw is None:
+        return None
+    s = str(raw).strip()
+    if s.casefold() in _BLANK_MARKERS:
+        return None
+    s = s.upper()
+    # Tolerate "A)" or "A) foo" -> "A"
+    if len(s) > 1 and s[0].isalpha() and s[1] in (")", ".", "、", " "):
+        s = s[0]
+    return s if _LETTER_RE.match(s) else None
+
+
+def _normalize_row(
+    answers: list, n: int
+) -> tuple[Optional[str], ...]:
+    """Normalize an answer row: pad/truncate to length n."""
+    out: list[Optional[str]] = []
+    for i in range(n):
+        raw = answers[i] if i < len(answers) else None
+        out.append(normalize_letter(raw))
+    return tuple(out)
+
+
+def from_dict(payload: dict) -> AnswerGrid:
+    """Parse + validate a client-submitted answer grid."""
+    if not isinstance(payload, dict):
+        raise ValueError("payload must be a dict")
+
+    n_raw = payload.get("total_questions")
+    if not isinstance(n_raw, int) or n_raw < 1:
+        raise ValueError("total_questions must be a positive integer")
+    n = n_raw
+
+    official = payload.get("official_answers") or []
+    if not isinstance(official, list):
+        raise ValueError("official_answers must be a list")
+    official_tuple = _normalize_row(official, n)
+
+    students_raw = payload.get("students") or []
+    if not isinstance(students_raw, list):
+        raise ValueError("students must be a list")
+    students: list[StudentRow] = []
+    for i, s in enumerate(students_raw):
+        if not isinstance(s, dict):
+            raise ValueError(f"students[{i}] must be a dict")
+        name = str(s.get("name") or f"Student {i + 1}")
+        answers = s.get("answers") or []
+        if not isinstance(answers, list):
+            raise ValueError(f"students[{i}].answers must be a list")
+        students.append(StudentRow(name=name, answers=_normalize_row(answers, n)))
+
+    questions_raw = payload.get("questions") or []
+    if not isinstance(questions_raw, list):
+        raise ValueError("questions must be a list")
+    questions: list[QuestionMeta] = []
+    for i in range(n):
+        q = questions_raw[i] if i < len(questions_raw) else {}
+        if not isinstance(q, dict):
+            q = {}
+        number = q.get("number") if isinstance(q.get("number"), int) else i + 1
+        text = str(q.get("text") or "")
+        opts_raw = q.get("options") or []
+        opts = tuple(str(o) for o in opts_raw) if isinstance(opts_raw, list) else ()
+        questions.append(QuestionMeta(number=number, text=text, options=opts))
+
+    return AnswerGrid(
+        total_questions=n,
+        official_answers=official_tuple,
+        students=tuple(students),
+        questions=tuple(questions),
+    )
+
+
+def to_dict(grid: AnswerGrid) -> dict:
+    """Serialize an AnswerGrid to JSON-friendly dict."""
+    return {
+        "total_questions": grid.total_questions,
+        "official_answers": list(grid.official_answers),
+        "students": [
+            {"name": s.name, "answers": list(s.answers)} for s in grid.students
+        ],
+        "questions": [
+            {"number": q.number, "text": q.text, "options": list(q.options)}
+            for q in grid.questions
+        ],
+    }
+
+
+def seed_from_parsed(
+    questions_data: dict,
+    student_answers_data: dict,
+    teacher_answers_data: dict,
+) -> AnswerGrid:
+    """Synthesize an initial grid from existing parsed JSON.
+
+    - N is derived from questions_data if present, else from teacher_answers length,
+      else from the longest student row.
+    - Student rows are padded/truncated to N.
+    - Cells are normalized to letters or None.
+    """
+    q_list = (questions_data or {}).get("questions") or []
+    t_list = (teacher_answers_data or {}).get("answers") or []
+    s_list = (student_answers_data or {}).get("students") or []
+
+    if q_list:
+        n = len(q_list)
+    elif t_list:
+        n = max((a.get("question_number", 0) for a in t_list), default=0)
+    else:
+        longest = 0
+        for s in s_list:
+            ans = s.get("answers") or []
+            nums = [a.get("question_number", 0) for a in ans]
+            if nums:
+                longest = max(longest, max(nums))
+        n = longest
+
+    n = max(n, 1)
+
+    # Build official answers by question_number index
+    official: list[Optional[str]] = [None] * n
+    for a in t_list:
+        qn = a.get("question_number")
+        if isinstance(qn, int) and 1 <= qn <= n:
+            official[qn - 1] = normalize_letter(a.get("correct_answer"))
+
+    # Build student rows by question_number index
+    students: list[StudentRow] = []
+    for i, s in enumerate(s_list):
+        row: list[Optional[str]] = [None] * n
+        for a in s.get("answers") or []:
+            qn = a.get("question_number")
+            if isinstance(qn, int) and 1 <= qn <= n:
+                row[qn - 1] = normalize_letter(a.get("answer"))
+        name = str(s.get("name") or f"Student {i + 1}")
+        students.append(StudentRow(name=name, answers=tuple(row)))
+
+    # Build question metadata
+    questions: list[QuestionMeta] = []
+    for i in range(n):
+        q = q_list[i] if i < len(q_list) else {}
+        number = q.get("number") if isinstance(q.get("number"), int) else i + 1
+        text = str(q.get("text") or "")
+        opts_raw = q.get("options") or []
+        opts = tuple(str(o) for o in opts_raw) if isinstance(opts_raw, list) else ()
+        questions.append(QuestionMeta(number=number, text=text, options=opts))
+
+    return AnswerGrid(
+        total_questions=n,
+        official_answers=tuple(official),
+        students=tuple(students),
+        questions=tuple(questions),
+    )
+
+
+def diff_student(grid: AnswerGrid, student_index: int) -> list[WrongAnswer]:
+    """Return the student's wrong answers ordered by question number.
+
+    Skips questions where the official key is blank (None).
+    """
+    if student_index < 0 or student_index >= len(grid.students):
+        raise IndexError(f"student_index {student_index} out of range")
+    row = grid.students[student_index].answers
+    wrongs: list[WrongAnswer] = []
+    for i, correct in enumerate(grid.official_answers):
+        if correct is None:
+            continue
+        student_ans = row[i] if i < len(row) else None
+        # Blank student answer is always wrong when a key exists
+        if student_ans != correct:
+            wrongs.append(
+                WrongAnswer(
+                    question=grid.questions[i],
+                    student_answer=student_ans,
+                    correct_answer=correct,
+                )
+            )
+    return wrongs

chatkit/backend/app/database.py

@@ -219,6 +219,38 @@ async def delete_parsed_data(session_id: int, data_type: Optional[str] = None):
         await db.commit()
 
 
+# ---- Answer Grid CRUD ----
+
+ANSWER_GRID_DATA_TYPE = "answer_grid"
+
+
+async def save_answer_grid(session_id: int, grid_dict: dict) -> int:
+    """Save confirmed answer grid, replacing any previous one for the session."""
+    await delete_parsed_data(session_id, ANSWER_GRID_DATA_TYPE)
+    return await save_parsed_data(
+        session_id=session_id,
+        data_type=ANSWER_GRID_DATA_TYPE,
+        file_name="",
+        raw_text="",
+        structured_data=grid_dict,
+    )
+
+
+async def get_answer_grid(session_id: int) -> Optional[dict]:
+    """Return the saved answer grid dict or None if not confirmed."""
+    db_path = _get_db_path()
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT structured_data FROM parsed_data WHERE session_id = ? AND data_type = ? ORDER BY created_at DESC LIMIT 1",
+            (session_id, ANSWER_GRID_DATA_TYPE),
+        ) as cursor:
+            row = await cursor.fetchone()
+            if not row:
+                return None
+            return json.loads(row["structured_data"])
+
+
 # ---- Prompt CRUD ----
 
 async def save_prompt(user_id: int, name: str, content: str, is_default: bool = False) -> int:

chatkit/backend/app/main.py

@@ -28,10 +28,15 @@ from .database import (
     save_report,
     get_reports,
     get_report,
+    save_answer_grid,
+    get_answer_grid,
+    delete_parsed_data,
+    ANSWER_GRID_DATA_TYPE,
 )
 from .auth import get_current_user, register_user, login_user
 from .file_processor import process_uploaded_files
-from .report_generator import generate_student_report, get_default_prompt, get_student_names, build_student_prompt
+from .answer_grid import from_dict as grid_from_dict, seed_from_parsed, to_dict as grid_to_dict
+from .report_generator import generate_student_report, build_student_markdown
 
 STATIC_DIR = Path(__file__).parent.parent / "static"
 
@@ -140,6 +145,8 @@ async def api_upload_files(
     try:
         structured = await process_uploaded_files(files, data_type, session_id, description=description, model=model)
         await update_session_status(session_id, "processed")
+        # Invalidate any previously-confirmed answer grid since inputs changed
+        await delete_parsed_data(session_id, ANSWER_GRID_DATA_TYPE)
         return {"status": "ok", "data_type": data_type, "data": structured}
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
@@ -185,12 +192,6 @@ async def api_list_all_prompts(user=Depends(get_current_user)):
     return {"prompts": prompts}
 
 
-@app.get("/api/prompts/default")
-async def api_get_default_prompt():
-    """Get the default analysis prompt template."""
-    return {"content": get_default_prompt()}
-
-
 @app.post("/api/prompts")
 async def api_save_prompt(body: PromptRequest, user=Depends(get_current_user)):
     prompt_id = await save_prompt(user["id"], body.name, body.content)
@@ -225,101 +226,134 @@ async def api_delete_prompt(prompt_id: int, user=Depends(get_current_user)):
 
 
 # =============================================================================
-# Report Generation Endpoints
+# Answer Grid Endpoints (canonical data for report generation)
 # =============================================================================
 
-class PreviewStudentPromptRequest(BaseModel):
-    student_index: int
-    prompt_template: Optional[str] = None
-
-
-class GenerateStudentReportRequest(BaseModel):
-    student_index: int
-    prompt_template: Optional[str] = None
-    model: str = "gpt-5.4"
+class AnswerGridPayload(BaseModel):
+    total_questions: int
+    official_answers: list[Optional[str]]
+    students: list[dict]
+    questions: list[dict]
 
 
-@app.post("/api/sessions/{session_id}/preview-student-prompt")
-async def api_preview_student_prompt(
-    session_id: int, body: PreviewStudentPromptRequest, user=Depends(get_current_user)
-):
-    """Preview the filled prompt for a single student (raw data substituted into template)."""
+async def _session_or_404(session_id: int, user: dict) -> dict:
     session = await get_session(session_id)
     if not session or session["user_id"] != user["id"]:
         raise HTTPException(status_code=404, detail="Session not found")
+    return session
+
 
+@app.get("/api/sessions/{session_id}/answer-grid")
+async def api_get_answer_grid(session_id: int, user=Depends(get_current_user)):
+    """Return the saved grid, or a seeded grid synthesized from parsed data."""
+    await _session_or_404(session_id, user)
+
+    saved = await get_answer_grid(session_id)
+    if saved:
+        return {"grid": saved, "is_confirmed": True}
+
+    # Seed from parsed data
     data = await get_parsed_data(session_id)
-    questions = {}
-    student_answers = {}
-    teacher_answers = {}
+    questions_data: dict = {}
+    student_answers_data: dict = {}
+    teacher_answers_data: dict = {}
     for item in data:
         if item["data_type"] == "questions":
-            questions = item["structured_data"]
+            questions_data = item["structured_data"]
         elif item["data_type"] == "student_answers":
-            student_answers = item["structured_data"]
+            student_answers_data = item["structured_data"]
         elif item["data_type"] == "teacher_answers":
-            teacher_answers = item["structured_data"]
+            teacher_answers_data = item["structured_data"]
 
-    students = student_answers.get("students", [])
-    if body.student_index < 0 or body.student_index >= len(students):
-        raise HTTPException(status_code=400, detail=f"Invalid student index: {body.student_index}")
+    grid = seed_from_parsed(questions_data, student_answers_data, teacher_answers_data)
+    return {"grid": grid_to_dict(grid), "is_confirmed": False}
 
-    student = students[body.student_index]
-    result = build_student_prompt(student, questions, teacher_answers, body.prompt_template)
-    return result
 
+@app.post("/api/sessions/{session_id}/answer-grid")
+async def api_save_answer_grid(
+    session_id: int, body: AnswerGridPayload, user=Depends(get_current_user)
+):
+    """Persist a user-confirmed answer grid."""
+    await _session_or_404(session_id, user)
 
-@app.get("/api/sessions/{session_id}/students")
-async def api_get_students(session_id: int, user=Depends(get_current_user)):
-    """Return the list of student names from parsed student_answers data."""
-    session = await get_session(session_id)
-    if not session or session["user_id"] != user["id"]:
-        raise HTTPException(status_code=404, detail="Session not found")
+    try:
+        grid = grid_from_dict(body.model_dump())
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
 
-    data = await get_parsed_data(session_id)
-    student_answers = {}
-    for item in data:
-        if item["data_type"] == "student_answers":
-            student_answers = item["structured_data"]
-            break
+    grid_dict = grid_to_dict(grid)
+    await save_answer_grid(session_id, grid_dict)
+    return {"grid": grid_dict, "is_confirmed": True}
 
-    return {"students": get_student_names(student_answers)}
 
+# =============================================================================
+# Report Generation Endpoints
+# =============================================================================
 
-@app.post("/api/sessions/{session_id}/generate-student-report")
-async def api_generate_student_report(
-    session_id: int, body: GenerateStudentReportRequest, user=Depends(get_current_user)
+class PreviewStudentPromptRequest(BaseModel):
+    student_index: int
+
+
+class GenerateStudentReportRequest(BaseModel):
+    student_index: int
+    model: str = "gpt-5.4"
+
+
+async def _require_confirmed_grid(session_id: int):
+    saved = await get_answer_grid(session_id)
+    if not saved:
+        raise HTTPException(
+            status_code=400,
+            detail="Answer grid not confirmed. Please confirm it in step 2 first.",
+        )
+    try:
+        return grid_from_dict(saved)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid saved grid: {e}")
+
+
+@app.post("/api/sessions/{session_id}/preview-student-prompt")
+async def api_preview_student_prompt(
+    session_id: int, body: PreviewStudentPromptRequest, user=Depends(get_current_user)
 ):
-    """Generate a report for a single student, focused on their wrong answers."""
-    session = await get_session(session_id)
-    if not session or session["user_id"] != user["id"]:
-        raise HTTPException(status_code=404, detail="Session not found")
+    """Preview the markdown prompt that will be sent to the LLM."""
+    await _session_or_404(session_id, user)
+    grid = await _require_confirmed_grid(session_id)
 
-    data = await get_parsed_data(session_id)
-    questions = {}
-    student_answers = {}
-    teacher_answers = {}
-    for item in data:
-        if item["data_type"] == "questions":
-            questions = item["structured_data"]
-        elif item["data_type"] == "student_answers":
-            student_answers = item["structured_data"]
-        elif item["data_type"] == "teacher_answers":
-            teacher_answers = item["structured_data"]
+    if body.student_index < 0 or body.student_index >= len(grid.students):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid student index: {body.student_index}",
+        )
 
-    if not questions:
-        raise HTTPException(status_code=400, detail="No questions data found.")
+    prompt = build_student_markdown(grid, body.student_index)
+    return {
+        "student_name": prompt.student_name,
+        "total_questions": prompt.total_questions,
+        "wrong_count": prompt.wrong_count,
+        "markdown_prompt": prompt.markdown_prompt,
+    }
 
-    students = student_answers.get("students", [])
-    if body.student_index < 0 or body.student_index >= len(students):
-        raise HTTPException(status_code=400, detail=f"Invalid student index: {body.student_index}")
 
-    student = students[body.student_index]
+@app.post("/api/sessions/{session_id}/generate-student-report")
+async def api_generate_student_report(
+    session_id: int, body: GenerateStudentReportRequest, user=Depends(get_current_user)
+):
+    """Generate an HTML report for one student from the confirmed grid."""
+    await _session_or_404(session_id, user)
+    grid = await _require_confirmed_grid(session_id)
+
+    if body.student_index < 0 or body.student_index >= len(grid.students):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid student index: {body.student_index}",
+        )
 
     try:
-        html = await generate_student_report(student, questions, teacher_answers, body.prompt_template, body.model)
+        html = await generate_student_report(grid, body.student_index, body.model)
         report_id = await save_report(session_id, None, html)
-        return {"report_id": report_id, "html_content": html, "student_name": student.get("name", "")}
+        student_name = grid.students[body.student_index].name
+        return {"report_id": report_id, "html_content": html, "student_name": student_name}
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Report generation failed: {str(e)}")
 

chatkit/backend/app/report_generator.py

@@ -1,13 +1,18 @@
-"""Report generation using OpenAI GPT directly (no ChatKit)."""
+"""Report generation from a confirmed AnswerGrid.
+
+Builds compact markdown prompts containing only the wrong-answer blocks for
+each student, then calls OpenAI to produce an HTML report.
+"""
 
 from __future__ import annotations
 
-import json
 import logging
 import re
+from dataclasses import dataclass
 
 from openai import AsyncOpenAI
 
+from .answer_grid import AnswerGrid, WrongAnswer, diff_student
 from .config import get_settings
 
 logger = logging.getLogger(__name__)
@@ -37,20 +42,13 @@ def extract_html(content: str) -> str:
     match = re.search(r"```html?\s*\n(.*?)```", content, re.DOTALL)
     if match:
         return match.group(1).strip()
-    stripped = content.strip()
-    if stripped.startswith("<!DOCTYPE") or stripped.startswith("<html"):
-        return stripped
-    return stripped
-
+    return content.strip()
 
-# ---------------------------------------------------------------------------
-# Per-student report generation
-# ---------------------------------------------------------------------------
 
 STUDENT_REPORT_SYSTEM_PROMPT = """You are ClassLens, an AI teaching assistant that creates a focused, personalized exam analysis report for a single student.
 
 ## Your Task
-Generate a complete, self-contained HTML report analyzing this student's exam performance.
+Generate a complete, self-contained HTML report analyzing this student's exam performance based ONLY on the wrong-answer blocks provided. The system has already pre-filtered to the questions this student got wrong — do not guess about questions not included.
 
 ## Language
 - Use Traditional Chinese (繁體中文) for all content
@@ -59,13 +57,13 @@ Generate a complete, self-contained HTML report analyzing this student's exam pe
 ## HTML Report Sections
 
 ### Section 1: 📋 Student Overview (學生概覽)
-- Student name (use partial name for privacy, e.g., 李X恩)
-- Total questions, correct count, wrong count, score percentage
+- Student name (partial name for privacy, e.g., 李X恩)
+- Total questions, wrong count, score percentage (derived from counts)
 - A brief overall assessment
 
 ### Section 2: 📝 Wrong Answer Analysis (錯題詳解)
-For EACH wrong answer:
-- Question number, full question text, type
+For EACH wrong answer block provided:
+- Question number, full question text
 - ❌ Student's wrong answer vs ✅ Correct answer
 - Concept tags (e.g., 🎯 細節理解, 🔍 推論能力)
 - Why the student likely chose the wrong answer
@@ -107,108 +105,88 @@ Use this dark theme:
 Return ONLY the complete HTML document. No markdown code fences. Just raw HTML starting with <!DOCTYPE html>."""
 
 
-DEFAULT_STUDENT_PROMPT = """請為以下學生生成個人化的考試分析報告。
-
-## 資料格式說明
-- 在學生答案中，「-」表示該題答對
-- 其他文字為學生的實際作答內容（學生錯誤答案）
-
-## 學生姓名：{student_name}
-
-## 考試總題數：{total_questions}
-
-## 考試題目：
-{questions}
-
-## 該學生的答案：
-{student_answers}
-
-## 標準答案：
-{teacher_answers}
-
-請判斷哪些題目答錯，針對每一道錯題提供詳細分析，找出錯誤模式，並給出具體的學習建議。
-如果未提供標準答案，請根據題目內容推斷正確答案。"""
-
-
-def get_default_prompt() -> str:
-    return DEFAULT_STUDENT_PROMPT
-
-
-def build_student_prompt(
-    student: dict,
-    questions_data: dict,
-    teacher_answers_data: dict,
-    prompt_template: str | None = None,
-) -> dict:
-    """Build the filled prompt for a student (for preview).
-
-    Passes raw data — no filtering. The prompt instructs the LLM how to read it.
-    """
-    template = prompt_template or DEFAULT_STUDENT_PROMPT
-    total_questions = len(questions_data.get("questions", []))
-    student_name = student.get("name", "Unknown")
-    student_answers = student.get("answers", [])
-
-    teacher_answers = teacher_answers_data.get("answers", [])
+@dataclass(frozen=True)
+class StudentPrompt:
+    student_name: str
+    total_questions: int
+    wrong_count: int
+    markdown_prompt: str
+
+
+def build_wrong_block(wa: WrongAnswer) -> str:
+    """Render one wrong-question block in markdown format."""
+    lines = [f"### 第 {wa.question.number} 題"]
+    if wa.question.text:
+        lines.append(f"**題目**: {wa.question.text}")
+    if wa.question.options:
+        options_str = "\n".join(f"- {o}" for o in wa.question.options)
+        lines.append(f"**選項**:\n{options_str}")
+    lines.append(f"**學生作答**: {wa.student_answer if wa.student_answer else '（未作答）'}")
+    lines.append(f"**正確答案**: {wa.correct_answer}")
+    return "\n".join(lines)
+
+
+def build_student_markdown(grid: AnswerGrid, student_index: int) -> StudentPrompt:
+    """Assemble the full markdown prompt for one student."""
+    if student_index < 0 or student_index >= len(grid.students):
+        raise IndexError(f"student_index {student_index} out of range")
+
+    student = grid.students[student_index]
+    wrongs = diff_student(grid, student_index)
+
+    if not wrongs:
+        markdown = (
+            f"## 學生：{student.name}\n"
+            f"## 總題數：{grid.total_questions}，答錯：0\n\n"
+            f"本次測驗全部答對，請為此學生生成鼓勵性的 HTML 報告，"
+            f"肯定其學習成果並建議延伸學習方向。"
+        )
+    else:
+        blocks = "\n\n".join(build_wrong_block(w) for w in wrongs)
+        markdown = (
+            f"## 學生：{student.name}\n"
+            f"## 總題數：{grid.total_questions}，答錯：{len(wrongs)}\n\n"
+            f"{blocks}\n\n"
+            f"請為此學生生成個人化 HTML 報告，聚焦以上錯題。"
+        )
 
-    filled = template.format(
-        student_name=student_name,
-        total_questions=total_questions,
-        questions=json.dumps(questions_data, ensure_ascii=False, indent=2),
-        student_answers=json.dumps(student_answers, ensure_ascii=False, indent=2),
-        teacher_answers=json.dumps(teacher_answers, ensure_ascii=False, indent=2) if teacher_answers else "（未提供）",
+    return StudentPrompt(
+        student_name=student.name,
+        total_questions=grid.total_questions,
+        wrong_count=len(wrongs),
+        markdown_prompt=markdown,
     )
 
-    return {
-        "filled_prompt": filled,
-        "student_name": student_name,
-        "total_questions": total_questions,
-    }
-
-
-def get_student_names(student_answers_data: dict) -> list[dict]:
-    """Extract student names/ids from parsed student answers data."""
-    students = student_answers_data.get("students", [])
-    result = []
-    for i, s in enumerate(students):
-        result.append({
-            "index": i,
-            "name": s.get("name", f"Student {i + 1}"),
-            "id": s.get("id", ""),
-        })
-    return result
-
 
 async def generate_student_report(
-    student: dict,
-    questions_data: dict,
-    teacher_answers_data: dict,
-    prompt_template: str | None = None,
+    grid: AnswerGrid,
+    student_index: int,
     model: str = "gpt-5.4",
 ) -> str:
-    """Generate HTML report for a single student.
-
-    Sends raw data to the LLM — the prompt_template controls how data is interpreted.
-    """
+    """Generate an HTML report for a single student using the markdown prompt."""
     settings = get_settings()
     client = AsyncOpenAI(api_key=settings.openai_api_key)
 
-    result = build_student_prompt(student, questions_data, teacher_answers_data, prompt_template)
-    filled_prompt = result["filled_prompt"]
-    student_name = result["student_name"]
+    prompt = build_student_markdown(grid, student_index)
 
-    prompt_tokens = _estimate_tokens(STUDENT_REPORT_SYSTEM_PROMPT) + _estimate_tokens(filled_prompt)
+    prompt_tokens = _estimate_tokens(STUDENT_REPORT_SYSTEM_PROMPT) + _estimate_tokens(
+        prompt.markdown_prompt
+    )
     context_limit = MODEL_CONTEXT_LIMITS.get(model, DEFAULT_CONTEXT_LIMIT)
     available = context_limit - prompt_tokens - TOKEN_SAFETY_MARGIN
 
     logger.info(
-        "Student report for %s — ~%d prompt tokens, %d available (model: %s)",
-        student_name, prompt_tokens, available, model,
+        "Student report for %s — wrong=%d, ~%d prompt tokens, %d available (model: %s)",
+        prompt.student_name,
+        prompt.wrong_count,
+        prompt_tokens,
+        available,
+        model,
     )
 
     if available < MIN_COMPLETION_TOKENS:
         raise ValueError(
-            f"學生 {student_name} 的資料過大（約 {prompt_tokens:,} tokens），請減少題目數量。"
+            f"學生 {prompt.student_name} 的資料過大（約 {prompt_tokens:,} tokens）。"
         )
 
     max_completion = min(DESIRED_COMPLETION_TOKENS, available)
@@ -217,7 +195,7 @@ async def generate_student_report(
         "model": model,
         "messages": [
             {"role": "system", "content": STUDENT_REPORT_SYSTEM_PROMPT},
-            {"role": "user", "content": filled_prompt},
+            {"role": "user", "content": prompt.markdown_prompt},
         ],
         "max_completion_tokens": max_completion,
         "temperature": 0.3,
@@ -241,5 +219,7 @@ async def generate_student_report(
         detail = f"finish_reason={reason}"
         if refusal:
             detail += f", refusal={refusal}"
-        raise ValueError(f"Model returned empty content for {student_name} ({detail}).")
+        raise ValueError(
+            f"Model returned empty content for {prompt.student_name} ({detail})."
+        )
     return extract_html(html_content)

chatkit/backend/pyproject.toml

@@ -28,3 +28,14 @@ dev = [
 [build-system]
 requires = ["setuptools>=68.0", "wheel"]
 build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["app*"]
+exclude = ["static*", "tests*"]
+
+[tool.pytest.ini_options]
+markers = [
+    "unit: marks tests as unit tests",
+    "integration: marks tests as integration tests",
+]
+asyncio_mode = "auto"

chatkit/backend/tests/test_answer_grid.py

@@ -0,0 +1,319 @@
+"""Unit tests for answer_grid module."""
+
+from __future__ import annotations
+
+import pytest
+
+from app.answer_grid import (
+    AnswerGrid,
+    QuestionMeta,
+    StudentRow,
+    diff_student,
+    from_dict,
+    normalize_letter,
+    seed_from_parsed,
+    to_dict,
+)
+
+
+# ---------------------------------------------------------------------------
+# normalize_letter
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize(
+    "raw, expected",
+    [
+        ("A", "A"),
+        ("a", "A"),
+        (" b ", "B"),
+        ("C)", "C"),
+        ("D) foo", "D"),
+        ("", None),
+        ("-", None),
+        ("–", None),
+        ("—", None),
+        (None, None),
+        ("   ", None),
+        ("N/A", None),
+        ("invalid", None),
+        ("AB", None),
+    ],
+)
+def test_normalize_letter(raw, expected):
+    assert normalize_letter(raw) == expected
+
+
+# ---------------------------------------------------------------------------
+# from_dict validation
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.unit
+def test_from_dict_minimal_valid():
+    payload = {
+        "total_questions": 2,
+        "official_answers": ["A", "B"],
+        "students": [{"name": "Alice", "answers": ["A", "C"]}],
+        "questions": [
+            {"number": 1, "text": "Q1", "options": ["A) x", "B) y"]},
+            {"number": 2, "text": "Q2", "options": ["A) x", "B) y"]},
+        ],
+    }
+    grid = from_dict(payload)
+    assert grid.total_questions == 2
+    assert grid.official_answers == ("A", "B")
+    assert grid.students[0].name == "Alice"
+    assert grid.students[0].answers == ("A", "C")
+
+
+@pytest.mark.unit
+def test_from_dict_pads_short_student_row():
+    payload = {
+        "total_questions": 3,
+        "official_answers": ["A", "B", "C"],
+        "students": [{"name": "Alice", "answers": ["A"]}],
+        "questions": [{"text": "Q"}, {"text": "Q"}, {"text": "Q"}],
+    }
+    grid = from_dict(payload)
+    assert grid.students[0].answers == ("A", None, None)
+
+
+@pytest.mark.unit
+def test_from_dict_truncates_long_student_row():
+    payload = {
+        "total_questions": 2,
+        "official_answers": ["A", "B"],
+        "students": [{"name": "Alice", "answers": ["A", "B", "C", "D"]}],
+        "questions": [],
+    }
+    grid = from_dict(payload)
+    assert grid.students[0].answers == ("A", "B")
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize(
+    "bad_field",
+    [
+        {"total_questions": 0},
+        {"total_questions": -1},
+        {"total_questions": "three"},
+    ],
+)
+def test_from_dict_rejects_bad_n(bad_field):
+    payload = {
+        "total_questions": 2,
+        "official_answers": ["A", "B"],
+        "students": [],
+        "questions": [],
+    }
+    payload.update(bad_field)
+    with pytest.raises(ValueError):
+        from_dict(payload)
+
+
+@pytest.mark.unit
+def test_from_dict_default_student_name():
+    payload = {
+        "total_questions": 1,
+        "official_answers": ["A"],
+        "students": [{"answers": ["A"]}],
+        "questions": [],
+    }
+    grid = from_dict(payload)
+    assert grid.students[0].name == "Student 1"
+
+
+# ---------------------------------------------------------------------------
+# to_dict roundtrip
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.unit
+def test_to_dict_roundtrip():
+    payload = {
+        "total_questions": 2,
+        "official_answers": ["A", "B"],
+        "students": [{"name": "Alice", "answers": ["A", "C"]}],
+        "questions": [
+            {"number": 1, "text": "Q1", "options": ["A) x", "B) y"]},
+            {"number": 2, "text": "Q2", "options": ["A) x", "B) y"]},
+        ],
+    }
+    grid = from_dict(payload)
+    again = from_dict(to_dict(grid))
+    assert grid == again
+
+
+# ---------------------------------------------------------------------------
+# seed_from_parsed
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.unit
+def test_seed_from_parsed_basic():
+    questions = {
+        "questions": [
+            {"number": 1, "text": "Q1", "options": ["A) a", "B) b"]},
+            {"number": 2, "text": "Q2", "options": ["A) a", "B) b"]},
+        ]
+    }
+    students = {
+        "students": [
+            {
+                "name": "Alice",
+                "answers": [
+                    {"question_number": 1, "answer": "A"},
+                    {"question_number": 2, "answer": "b"},
+                ],
+            }
+        ]
+    }
+    teachers = {
+        "answers": [
+            {"question_number": 1, "correct_answer": "A"},
+            {"question_number": 2, "correct_answer": "B"},
+        ]
+    }
+    grid = seed_from_parsed(questions, students, teachers)
+    assert grid.total_questions == 2
+    assert grid.official_answers == ("A", "B")
+    assert grid.students[0].answers == ("A", "B")
+    assert grid.questions[0].text == "Q1"
+
+
+@pytest.mark.unit
+def test_seed_from_parsed_handles_dash_as_blank():
+    questions = {"questions": [{"number": 1, "text": "Q"}]}
+    students = {
+        "students": [
+            {"name": "Alice", "answers": [{"question_number": 1, "answer": "-"}]}
+        ]
+    }
+    teachers = {"answers": [{"question_number": 1, "correct_answer": "A"}]}
+    grid = seed_from_parsed(questions, students, teachers)
+    # Dash normalizes to None — diff treats None != "A" as wrong
+    assert grid.students[0].answers == (None,)
+
+
+@pytest.mark.unit
+def test_seed_from_parsed_no_questions_derives_n_from_teacher():
+    questions = {}
+    students = {
+        "students": [{"name": "A", "answers": [{"question_number": 1, "answer": "A"}]}]
+    }
+    teachers = {
+        "answers": [
+            {"question_number": 1, "correct_answer": "A"},
+            {"question_number": 2, "correct_answer": "B"},
+            {"question_number": 3, "correct_answer": "C"},
+        ]
+    }
+    grid = seed_from_parsed(questions, students, teachers)
+    assert grid.total_questions == 3
+    assert grid.official_answers == ("A", "B", "C")
+
+
+@pytest.mark.unit
+def test_seed_from_parsed_all_empty_gives_n_one():
+    grid = seed_from_parsed({}, {}, {})
+    assert grid.total_questions == 1
+    assert grid.students == ()
+    assert grid.official_answers == (None,)
+
+
+# ---------------------------------------------------------------------------
+# diff_student
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.unit
+def test_diff_student_returns_only_wrong():
+    grid = AnswerGrid(
+        total_questions=3,
+        official_answers=("A", "B", "C"),
+        students=(StudentRow(name="Alice", answers=("A", "D", "C")),),
+        questions=(
+            QuestionMeta(number=1, text="Q1", options=()),
+            QuestionMeta(number=2, text="Q2", options=()),
+            QuestionMeta(number=3, text="Q3", options=()),
+        ),
+    )
+    wrongs = diff_student(grid, 0)
+    assert len(wrongs) == 1
+    assert wrongs[0].question.number == 2
+    assert wrongs[0].student_answer == "D"
+    assert wrongs[0].correct_answer == "B"
+
+
+@pytest.mark.unit
+def test_diff_student_blank_student_answer_is_wrong():
+    grid = AnswerGrid(
+        total_questions=2,
+        official_answers=("A", "B"),
+        students=(StudentRow(name="Alice", answers=("A", None)),),
+        questions=(
+            QuestionMeta(number=1, text="Q1", options=()),
+            QuestionMeta(number=2, text="Q2", options=()),
+        ),
+    )
+    wrongs = diff_student(grid, 0)
+    assert len(wrongs) == 1
+    assert wrongs[0].student_answer is None
+
+
+@pytest.mark.unit
+def test_diff_student_skips_blank_official_key():
+    grid = AnswerGrid(
+        total_questions=2,
+        official_answers=("A", None),  # Q2 key missing
+        students=(StudentRow(name="Alice", answers=("B", "C")),),
+        questions=(
+            QuestionMeta(number=1, text="Q1", options=()),
+            QuestionMeta(number=2, text="Q2", options=()),
+        ),
+    )
+    wrongs = diff_student(grid, 0)
+    assert len(wrongs) == 1
+    assert wrongs[0].question.number == 1
+
+
+@pytest.mark.unit
+def test_diff_student_all_correct():
+    grid = AnswerGrid(
+        total_questions=2,
+        official_answers=("A", "B"),
+        students=(StudentRow(name="Alice", answers=("A", "B")),),
+        questions=(
+            QuestionMeta(number=1, text="Q1", options=()),
+            QuestionMeta(number=2, text="Q2", options=()),
+        ),
+    )
+    assert diff_student(grid, 0) == []
+
+
+@pytest.mark.unit
+def test_diff_student_out_of_range():
+    grid = AnswerGrid(
+        total_questions=1,
+        official_answers=("A",),
+        students=(),
+        questions=(QuestionMeta(number=1, text="Q", options=()),),
+    )
+    with pytest.raises(IndexError):
+        diff_student(grid, 0)
+
+
+@pytest.mark.unit
+def test_diff_student_preserves_question_order():
+    grid = AnswerGrid(
+        total_questions=4,
+        official_answers=("A", "B", "C", "D"),
+        students=(StudentRow(name="Alice", answers=("X", "B", "Y", "Z")),),
+        questions=tuple(
+            QuestionMeta(number=i + 1, text=f"Q{i+1}", options=()) for i in range(4)
+        ),
+    )
+    wrongs = diff_student(grid, 0)
+    assert [w.question.number for w in wrongs] == [1, 3, 4]

chatkit/backend/tests/test_report_generator.py

@@ -0,0 +1,126 @@
+"""Unit tests for report_generator prompt assembly."""
+
+from __future__ import annotations
+
+import pytest
+
+from app.answer_grid import AnswerGrid, QuestionMeta, StudentRow, WrongAnswer
+from app.report_generator import (
+    build_student_markdown,
+    build_wrong_block,
+    extract_html,
+)
+
+
+def _make_grid(official, student_answers) -> AnswerGrid:
+    n = len(official)
+    return AnswerGrid(
+        total_questions=n,
+        official_answers=tuple(official),
+        students=(StudentRow(name="Alice", answers=tuple(student_answers)),),
+        questions=tuple(
+            QuestionMeta(number=i + 1, text=f"Q{i+1}", options=("A) a", "B) b", "C) c"))
+            for i in range(n)
+        ),
+    )
+
+
+@pytest.mark.unit
+def test_build_wrong_block_full():
+    wa = WrongAnswer(
+        question=QuestionMeta(
+            number=3,
+            text="What is 2+2?",
+            options=("A) 3", "B) 4", "C) 5"),
+        ),
+        student_answer="A",
+        correct_answer="B",
+    )
+    block = build_wrong_block(wa)
+    assert "### 第 3 題" in block
+    assert "What is 2+2?" in block
+    assert "A) 3" in block
+    assert "**學生作答**: A" in block
+    assert "**正確答案**: B" in block
+
+
+@pytest.mark.unit
+def test_build_wrong_block_without_options():
+    wa = WrongAnswer(
+        question=QuestionMeta(number=1, text="Q1", options=()),
+        student_answer="A",
+        correct_answer="B",
+    )
+    block = build_wrong_block(wa)
+    assert "**選項**" not in block
+    assert "**學生作答**: A" in block
+
+
+@pytest.mark.unit
+def test_build_wrong_block_blank_student_answer():
+    wa = WrongAnswer(
+        question=QuestionMeta(number=1, text="Q", options=()),
+        student_answer=None,
+        correct_answer="A",
+    )
+    block = build_wrong_block(wa)
+    assert "（未作答）" in block
+
+
+@pytest.mark.unit
+def test_build_student_markdown_filters_to_wrong_only():
+    grid = _make_grid(["A", "B", "C"], ["A", "X", "C"])
+    result = build_student_markdown(grid, 0)
+    assert result.wrong_count == 1
+    assert result.total_questions == 3
+    assert "### 第 2 題" in result.markdown_prompt
+    assert "### 第 1 題" not in result.markdown_prompt
+    assert "### 第 3 題" not in result.markdown_prompt
+
+
+@pytest.mark.unit
+def test_build_student_markdown_header_contains_counts():
+    grid = _make_grid(["A", "B", "C"], ["X", "Y", "Z"])
+    result = build_student_markdown(grid, 0)
+    assert "總題數：3，答錯：3" in result.markdown_prompt
+    assert "學生：Alice" in result.markdown_prompt
+
+
+@pytest.mark.unit
+def test_build_student_markdown_all_correct_path():
+    grid = _make_grid(["A", "B"], ["A", "B"])
+    result = build_student_markdown(grid, 0)
+    assert result.wrong_count == 0
+    assert "答錯：0" in result.markdown_prompt
+    assert "全部答對" in result.markdown_prompt
+
+
+@pytest.mark.unit
+def test_build_student_markdown_preserves_question_ordering():
+    grid = _make_grid(["A", "B", "C", "D"], ["X", "B", "Y", "Z"])
+    result = build_student_markdown(grid, 0)
+    # Blocks must appear in Q1, Q3, Q4 order
+    idx1 = result.markdown_prompt.index("### 第 1 題")
+    idx3 = result.markdown_prompt.index("### 第 3 題")
+    idx4 = result.markdown_prompt.index("### 第 4 題")
+    assert idx1 < idx3 < idx4
+
+
+@pytest.mark.unit
+def test_build_student_markdown_out_of_range():
+    grid = _make_grid(["A"], ["A"])
+    with pytest.raises(IndexError):
+        build_student_markdown(grid, 5)
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize(
+    "content, expected",
+    [
+        ("<!DOCTYPE html><html></html>", "<!DOCTYPE html><html></html>"),
+        ("```html\n<!DOCTYPE html><html></html>\n```", "<!DOCTYPE html><html></html>"),
+        ("  <html></html>  ", "<html></html>"),
+    ],
+)
+def test_extract_html(content, expected):
+    assert extract_html(content) == expected

chatkit/frontend/src/App.tsx

@@ -39,7 +39,6 @@ export default function App() {
   const [currentStep, setCurrentStep] = useState<1 | 2 | 3>(1);
   const [sessionId, setSessionId] = useState<number | null>(null);
   const [parsedData, setParsedData] = useState<Record<string, unknown>>({});
-  const [promptContent, setPromptContent] = useState("");
   const [students, setStudents] = useState<StudentInfo[]>([]);
   const [selectedIndices, setSelectedIndices] = useState<number[]>([]);
   const [reports, setReports] = useState<StudentReport[]>([]);
@@ -58,15 +57,6 @@ export default function App() {
     }
   }, []);
 
-  // Load default prompt
-  useEffect(() => {
-    if (user && !promptContent) {
-      apiGet<{ content: string }>("/api/prompts/default")
-        .then((res) => setPromptContent(res.content))
-        .catch(() => {});
-    }
-  }, [user]);
-
   // Create session when user is authenticated and no session exists
   useEffect(() => {
     if (user && !sessionId) {
@@ -94,7 +84,6 @@ export default function App() {
     setUser(null);
     setSessionId(null);
     setParsedData({});
-    setPromptContent("");
     setStudents([]);
     setSelectedIndices([]);
     setReports([]);
@@ -140,7 +129,6 @@ export default function App() {
           student_name: string;
         }>(`/api/sessions/${sessionId}/generate-student-report`, {
           student_index: idx,
-          prompt_template: promptContent || undefined,
           model,
         });
 
@@ -267,15 +255,11 @@ ${doneReports
                   />
                   {sessionId && (
                     <PromptEditor
-                      promptContent={promptContent}
-                      onPromptChange={setPromptContent}
                       sessionId={sessionId}
                       onGenerate={handleGenerateReports}
                       isGenerating={isGenerating}
                       selectedCount={selectedIndices.length}
                       selectedIndices={selectedIndices}
-                      parsedData={parsedData}
-                      onParsedDataUpdate={handleParsedDataUpdate}
                     />
                   )}
                 </>

chatkit/frontend/src/components/step2/AnswerGridEditor.tsx

@@ -0,0 +1,283 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { apiGet, apiPost } from "../../lib/api";
+
+export interface QuestionMeta {
+  number: number;
+  text: string;
+  options: string[];
+}
+
+export interface StudentRow {
+  name: string;
+  answers: (string | null)[];
+}
+
+export interface AnswerGrid {
+  total_questions: number;
+  official_answers: (string | null)[];
+  students: StudentRow[];
+  questions: QuestionMeta[];
+}
+
+interface AnswerGridResponse {
+  grid: AnswerGrid;
+  is_confirmed: boolean;
+}
+
+interface AnswerGridEditorProps {
+  sessionId: number;
+  onConfirmedChange: (grid: AnswerGrid | null) => void;
+}
+
+function normalizeCell(raw: string): string | null {
+  const trimmed = raw.trim().toUpperCase();
+  if (!trimmed || trimmed === "-") return null;
+  // Take first letter only, allow A-Z
+  const first = trimmed.charAt(0);
+  return /^[A-Z]$/.test(first) ? first : null;
+}
+
+function resizeRow(row: (string | null)[], n: number): (string | null)[] {
+  if (row.length === n) return row;
+  if (row.length > n) return row.slice(0, n);
+  return [...row, ...Array<string | null>(n - row.length).fill(null)];
+}
+
+function resizeQuestions(qs: QuestionMeta[], n: number): QuestionMeta[] {
+  if (qs.length === n) return qs;
+  if (qs.length > n) return qs.slice(0, n);
+  const pad: QuestionMeta[] = [];
+  for (let i = qs.length; i < n; i++) {
+    pad.push({ number: i + 1, text: "", options: [] });
+  }
+  return [...qs, ...pad];
+}
+
+export function AnswerGridEditor({
+  sessionId,
+  onConfirmedChange,
+}: AnswerGridEditorProps) {
+  const [grid, setGrid] = useState<AnswerGrid | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [saved, setSaved] = useState(false);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    setLoading(true);
+    apiGet<AnswerGridResponse>(`/api/sessions/${sessionId}/answer-grid`)
+      .then((res) => {
+        setGrid(res.grid);
+        setSaved(res.is_confirmed);
+        if (res.is_confirmed) {
+          onConfirmedChange(res.grid);
+        }
+      })
+      .catch((e) => setError(e instanceof Error ? e.message : "Failed to load grid"))
+      .finally(() => setLoading(false));
+  }, [sessionId]);
+
+  const qNums = useMemo(() => {
+    if (!grid) return [];
+    return Array.from({ length: grid.total_questions }, (_, i) => i + 1);
+  }, [grid]);
+
+  const markDirty = useCallback(() => {
+    setSaved(false);
+    onConfirmedChange(null);
+  }, [onConfirmedChange]);
+
+  const updateN = useCallback(
+    (n: number) => {
+      if (!grid || n < 1) return;
+      setGrid({
+        ...grid,
+        total_questions: n,
+        official_answers: resizeRow(grid.official_answers, n),
+        students: grid.students.map((s) => ({
+          ...s,
+          answers: resizeRow(s.answers, n),
+        })),
+        questions: resizeQuestions(grid.questions, n),
+      });
+      markDirty();
+    },
+    [grid, markDirty]
+  );
+
+  const updateStudentCell = useCallback(
+    (studentIdx: number, qIdx: number, raw: string) => {
+      if (!grid) return;
+      const value = normalizeCell(raw);
+      const nextStudents = grid.students.map((s, i) => {
+        if (i !== studentIdx) return s;
+        const nextAnswers = [...s.answers];
+        nextAnswers[qIdx] = value;
+        return { ...s, answers: nextAnswers };
+      });
+      setGrid({ ...grid, students: nextStudents });
+      markDirty();
+    },
+    [grid, markDirty]
+  );
+
+  const updateOfficialCell = useCallback(
+    (qIdx: number, raw: string) => {
+      if (!grid) return;
+      const value = normalizeCell(raw);
+      const next = [...grid.official_answers];
+      next[qIdx] = value;
+      setGrid({ ...grid, official_answers: next });
+      markDirty();
+    },
+    [grid, markDirty]
+  );
+
+  const handleSave = useCallback(async () => {
+    if (!grid) return;
+    setSaving(true);
+    setError("");
+    try {
+      const res = await apiPost<AnswerGridResponse>(
+        `/api/sessions/${sessionId}/answer-grid`,
+        grid
+      );
+      setGrid(res.grid);
+      setSaved(true);
+      onConfirmedChange(res.grid);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to save grid");
+    } finally {
+      setSaving(false);
+    }
+  }, [grid, sessionId, onConfirmedChange]);
+
+  if (loading) {
+    return (
+      <div className="card p-8 text-center">
+        <div className="inline-block w-6 h-6 border-2 border-[var(--color-primary)] border-t-transparent rounded-full animate-spin" />
+      </div>
+    );
+  }
+
+  if (!grid) {
+    return (
+      <div className="card p-8 text-center">
+        <p className="text-[var(--color-text-muted)]">
+          {error || "尚未上傳任何資料，請回到上一步先解析檔案"}
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="card p-5 space-y-4">
+      <div className="flex items-center justify-between flex-wrap gap-3">
+        <div>
+          <h3 className="font-display text-lg font-semibold text-[var(--color-text)]">
+            📋 確認答案表 (Answer Grid)
+          </h3>
+          <p className="text-xs text-[var(--color-text-muted)] mt-1">
+            請核對學生作答與標準答案，確認後才能生成報告。支援單選題（A-Z）。
+          </p>
+        </div>
+        <div className="flex items-center gap-2">
+          <label className="text-sm text-[var(--color-text-muted)]">題數：</label>
+          <input
+            type="number"
+            min={1}
+            max={200}
+            value={grid.total_questions}
+            onChange={(e) => updateN(Number(e.target.value))}
+            className="input !w-20 !py-1 text-sm"
+          />
+        </div>
+      </div>
+
+      <div className="overflow-x-auto max-h-[60vh] overflow-y-auto">
+        <table className="w-full text-sm border-separate border-spacing-0">
+          <thead className="sticky top-0 bg-[var(--color-surface)] z-10">
+            <tr>
+              <th className="text-left py-2 px-3 border-b border-[var(--color-border)] sticky left-0 bg-[var(--color-surface)] z-20 min-w-[120px]">
+                學生
+              </th>
+              {qNums.map((n) => (
+                <th
+                  key={n}
+                  className="text-center py-2 px-2 border-b border-[var(--color-border)] text-[var(--color-text-muted)] min-w-[48px]"
+                >
+                  Q{n}
+                </th>
+              ))}
+            </tr>
+          </thead>
+          <tbody>
+            {grid.students.map((s, si) => (
+              <tr key={si}>
+                <td className="py-1 px-3 border-b border-[var(--color-border)]/50 sticky left-0 bg-[var(--color-background)] z-10 font-medium text-[var(--color-text)]">
+                  {s.name}
+                </td>
+                {qNums.map((n, qi) => (
+                  <td
+                    key={n}
+                    className="border-b border-[var(--color-border)]/50 p-0.5"
+                  >
+                    <input
+                      type="text"
+                      maxLength={2}
+                      defaultValue={s.answers[qi] ?? ""}
+                      onBlur={(e) => updateStudentCell(si, qi, e.target.value)}
+                      className="w-full text-center py-1 bg-transparent text-[var(--color-text)] border border-transparent hover:border-[var(--color-border)] focus:border-[var(--color-primary)] focus:outline-none rounded"
+                    />
+                  </td>
+                ))}
+              </tr>
+            ))}
+
+            {/* Answer key row */}
+            <tr className="bg-[var(--color-primary)]/5">
+              <td className="py-2 px-3 border-t-2 border-[var(--color-primary)] sticky left-0 bg-[var(--color-surface)] z-10 font-bold text-[var(--color-primary)]">
+                ✅ 標準答案
+              </td>
+              {qNums.map((n, qi) => (
+                <td
+                  key={n}
+                  className="border-t-2 border-[var(--color-primary)] p-0.5"
+                >
+                  <input
+                    type="text"
+                    maxLength={2}
+                    defaultValue={grid.official_answers[qi] ?? ""}
+                    onBlur={(e) => updateOfficialCell(qi, e.target.value)}
+                    className="w-full text-center py-1 bg-transparent text-[var(--color-success)] font-semibold border border-transparent hover:border-[var(--color-border)] focus:border-[var(--color-primary)] focus:outline-none rounded"
+                  />
+                </td>
+              ))}
+            </tr>
+          </tbody>
+        </table>
+      </div>
+
+      {error && (
+        <p className="text-sm text-red-400 text-center">{error}</p>
+      )}
+
+      <div className="flex items-center justify-between flex-wrap gap-3">
+        <div className="text-xs text-[var(--color-text-muted)]">
+          {saved ? (
+            <span className="text-[var(--color-success)]">✓ 已確認（可生成報告）</span>
+          ) : (
+            <span className="text-amber-400">⚠ 尚未確認，編輯後請按下「確認儲存」</span>
+          )}
+        </div>
+        <button
+          onClick={handleSave}
+          disabled={saving}
+          className="btn btn-primary text-sm disabled:opacity-50"
+        >
+          {saving ? "儲存中..." : saved ? "重新儲存" : "確認儲存"}
+        </button>
+      </div>
+    </div>
+  );
+}

chatkit/frontend/src/components/step2/DataPreviewModal.tsx

@@ -1,176 +1,61 @@
-import { useState, useEffect } from "react";
+import { useEffect, useState } from "react";
 import { apiPost } from "../../lib/api";
 
 interface DataPreviewModalProps {
-  parsedData: Record<string, unknown>;
-  onParsedDataUpdate: (dataType: string, data: unknown) => void;
   onGenerate: () => void;
   onClose: () => void;
   isGenerating: boolean;
   sessionId: number;
   selectedIndices: number[];
-  promptTemplate: string;
 }
 
-type TabKey = "questions" | "student_answers" | "teacher_answers" | "final_prompt";
-
-const DATA_TABS: { key: Exclude<TabKey, "final_prompt">; label: string; icon: string }[] = [
-  { key: "questions", label: "考試題目", icon: "📝" },
-  { key: "student_answers", label: "學生答案", icon: "👨‍🎓" },
-  { key: "teacher_answers", label: "標準答案", icon: "✅" },
-];
-
-interface StudentInfo {
-  index: number;
-  name: string;
+interface PreviewResponse {
+  student_name: string;
+  total_questions: number;
+  wrong_count: number;
+  markdown_prompt: string;
 }
 
 export function DataPreviewModal({
-  parsedData,
-  onParsedDataUpdate,
   onGenerate,
   onClose,
   isGenerating,
   sessionId,
   selectedIndices,
-  promptTemplate,
 }: DataPreviewModalProps) {
-  const [activeTab, setActiveTab] = useState<TabKey>("final_prompt");
-  const [editTexts, setEditTexts] = useState<Record<string, string>>({
-    questions: "",
-    student_answers: "",
-    teacher_answers: "",
-  });
-  const [parseErrors, setParseErrors] = useState<Record<string, string>>({});
-
-  // Final prompt preview state
-  const [previewStudentIdx, setPreviewStudentIdx] = useState<number>(
+  const [previewIdx, setPreviewIdx] = useState<number>(
     selectedIndices.length > 0 ? selectedIndices[0] : 0
   );
-  const [filledPrompt, setFilledPrompt] = useState("");
-  const [promptLoading, setPromptLoading] = useState(false);
-  const [promptMeta, setPromptMeta] = useState<{
-    student_name: string;
-    total_questions: number;
-  } | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [preview, setPreview] = useState<PreviewResponse | null>(null);
+  const [error, setError] = useState("");
 
-  // Build students list from parsedData
-  const students: StudentInfo[] = (() => {
-    const sa = parsedData.student_answers as { students?: { name?: string }[] } | undefined;
-    return (sa?.students || []).map((s, i) => ({
-      index: i,
-      name: s.name || `Student ${i + 1}`,
-    }));
-  })();
-
-  const selectedStudents = students.filter((s) => selectedIndices.includes(s.index));
-
-  // Initialize edit texts from parsedData
   useEffect(() => {
-    const texts: Record<string, string> = {};
-    for (const tab of DATA_TABS) {
-      const data = parsedData[tab.key];
-      texts[tab.key] = data ? JSON.stringify(data, null, 2) : "";
-    }
-    setEditTexts(texts);
-  }, []);
-
-  // Load filled prompt when tab is active or student changes
-  useEffect(() => {
-    if (activeTab !== "final_prompt") return;
-    loadFilledPrompt(previewStudentIdx);
-  }, [activeTab, previewStudentIdx]);
-
-  const loadFilledPrompt = async (studentIndex: number) => {
-    setPromptLoading(true);
-    setFilledPrompt("");
-    setPromptMeta(null);
-    try {
-      const res = await apiPost<{
-        filled_prompt: string;
-        student_name: string;
-        total_questions: number;
-      }>(`/api/sessions/${sessionId}/preview-student-prompt`, {
-        student_index: studentIndex,
-        prompt_template: promptTemplate || undefined,
-      });
-      setFilledPrompt(res.filled_prompt);
-      setPromptMeta({
-        student_name: res.student_name,
-        total_questions: res.total_questions,
-      });
-    } catch (err) {
-      setFilledPrompt(
-        `Error: ${err instanceof Error ? err.message : "Failed to load preview"}`
-      );
-    }
-    setPromptLoading(false);
-  };
-
-  const handleTextChange = (key: string, value: string) => {
-    setEditTexts((prev) => ({ ...prev, [key]: value }));
-    setParseErrors((prev) => {
-      const next = { ...prev };
-      delete next[key];
-      return next;
-    });
-  };
-
-  const handleSave = (key: string) => {
-    try {
-      const parsed = JSON.parse(editTexts[key]);
-      onParsedDataUpdate(key, parsed);
-      setParseErrors((prev) => {
-        const next = { ...prev };
-        delete next[key];
-        return next;
-      });
-    } catch {
-      setParseErrors((prev) => ({ ...prev, [key]: "JSON 格式錯誤，請檢查語法" }));
-    }
-  };
-
-  const handleGenerate = () => {
-    let hasError = false;
-    for (const tab of DATA_TABS) {
-      if (!editTexts[tab.key].trim()) continue;
-      try {
-        const parsed = JSON.parse(editTexts[tab.key]);
-        onParsedDataUpdate(tab.key, parsed);
-      } catch {
-        setParseErrors((prev) => ({ ...prev, [tab.key]: "JSON 格式錯誤，請檢查語法" }));
-        setActiveTab(tab.key);
-        hasError = true;
-        break;
-      }
-    }
-    if (!hasError) onGenerate();
-  };
-
-  const getItemCount = (key: string): number => {
-    try {
-      const data = JSON.parse(editTexts[key]);
-      if (key === "questions") return data?.questions?.length ?? 0;
-      if (key === "student_answers") return data?.students?.length ?? 0;
-      if (key === "teacher_answers") return data?.answers?.length ?? 0;
-    } catch {}
-    return 0;
-  };
+    setLoading(true);
+    setError("");
+    setPreview(null);
+    apiPost<PreviewResponse>(
+      `/api/sessions/${sessionId}/preview-student-prompt`,
+      { student_index: previewIdx }
+    )
+      .then(setPreview)
+      .catch((e) =>
+        setError(e instanceof Error ? e.message : "Failed to load preview")
+      )
+      .finally(() => setLoading(false));
+  }, [previewIdx, sessionId]);
 
   return (
     <div className="fixed inset-0 z-50 flex items-center justify-center p-4">
-      {/* Backdrop */}
       <div
         className="absolute inset-0 bg-black/50 backdrop-blur-sm"
         onClick={onClose}
       />
 
-      {/* Modal */}
-      <div className="relative w-full max-w-5xl max-h-[90vh] flex flex-col card overflow-hidden">
-        {/* Header */}
+      <div className="relative w-full max-w-4xl max-h-[90vh] flex flex-col card overflow-hidden">
         <div className="flex items-center justify-between p-5 border-b border-[var(--color-border)]">
           <h3 className="font-display text-xl font-bold text-[var(--color-text)]">
-            預覽分析資料
+            🔍 最終提示詞預覽
           </h3>
           <button
             onClick={onClose}
@@ -180,128 +65,69 @@ export function DataPreviewModal({
           </button>
         </div>
 
-        {/* Tabs */}
-        <div className="flex border-b border-[var(--color-border)]">
-          {/* Final prompt tab first */}
-          <button
-            onClick={() => setActiveTab("final_prompt")}
-            className={`px-4 py-3 text-sm font-semibold transition-colors relative ${
-              activeTab === "final_prompt"
-                ? "text-[var(--color-accent)] bg-[var(--color-accent)]/5"
-                : "text-[var(--color-text-muted)] hover:text-[var(--color-text)] hover:bg-[var(--color-surface)]"
-            }`}
-          >
-            <span>🔍 最終提示詞</span>
-            {activeTab === "final_prompt" && (
-              <span className="absolute bottom-0 left-0 right-0 h-0.5 bg-[var(--color-accent)]" />
-            )}
-          </button>
-          {DATA_TABS.map((tab) => {
-            const count = getItemCount(tab.key);
-            const hasError = !!parseErrors[tab.key];
-            return (
-              <button
-                key={tab.key}
-                onClick={() => setActiveTab(tab.key)}
-                className={`flex-1 px-4 py-3 text-sm font-semibold transition-colors relative ${
-                  activeTab === tab.key
-                    ? "text-[var(--color-primary)] bg-[var(--color-primary)]/5"
-                    : "text-[var(--color-text-muted)] hover:text-[var(--color-text)] hover:bg-[var(--color-surface)]"
-                } ${hasError ? "!text-red-500" : ""}`}
-              >
-                <span>{tab.icon} {tab.label}</span>
-                {count > 0 && (
-                  <span className="ml-2 text-xs badge badge-success">{count}</span>
-                )}
-                {activeTab === tab.key && (
-                  <span className="absolute bottom-0 left-0 right-0 h-0.5 bg-[var(--color-primary)]" />
-                )}
-              </button>
-            );
-          })}
-        </div>
-
-        {/* Content */}
         <div className="flex-1 overflow-hidden flex flex-col p-5 min-h-0">
-          {activeTab === "final_prompt" ? (
-            /* Final prompt preview */
-            <>
-              <div className="flex items-center gap-3 mb-3 flex-wrap">
-                <label className="text-sm font-semibold text-[var(--color-text)]">
-                  預覽學生：
-                </label>
-                <select
-                  value={previewStudentIdx}
-                  onChange={(e) => setPreviewStudentIdx(Number(e.target.value))}
-                  className="input !w-auto !py-1.5 text-sm"
+          <div className="flex items-center gap-3 mb-3 flex-wrap">
+            <label className="text-sm font-semibold text-[var(--color-text)]">
+              預覽學生：
+            </label>
+            <select
+              value={previewIdx}
+              onChange={(e) => setPreviewIdx(Number(e.target.value))}
+              className="input !w-auto !py-1.5 text-sm"
+            >
+              {selectedIndices.map((idx) => (
+                <option key={idx} value={idx}>
+                  Student {idx + 1}
+                </option>
+              ))}
+            </select>
+            {preview && (
+              <>
+                <span className="badge badge-success text-xs">
+                  {preview.student_name}
+                </span>
+                <span className="badge badge-success text-xs">
+                  總題數 {preview.total_questions}
+                </span>
+                <span
+                  className={`badge text-xs ${
+                    preview.wrong_count === 0 ? "badge-success" : "bg-amber-500/20 text-amber-400"
+                  }`}
                 >
-                  {selectedStudents.map((s) => (
-                    <option key={s.index} value={s.index}>
-                      {s.name}
-                    </option>
-                  ))}
-                </select>
-                {promptMeta && (
-                  <span className="badge badge-success text-xs">
-                    總題數 {promptMeta.total_questions}
-                  </span>
-                )}
-              </div>
-              <p className="text-xs text-[var(--color-text-muted)] mb-3">
-                以下是實際送給 LLM 的完整提示詞，變數已替換為該學生的原始資料
-              </p>
-              {promptLoading ? (
-                <div className="flex-1 flex items-center justify-center">
-                  <div className="w-6 h-6 border-2 border-[var(--color-primary)] border-t-transparent rounded-full animate-spin" />
-                </div>
-              ) : (
-                <textarea
-                  value={filledPrompt}
-                  readOnly
-                  className="input !rounded-xl font-mono text-sm leading-relaxed resize-y flex-1"
-                  spellCheck={false}
-                />
-              )}
-            </>
+                  錯 {preview.wrong_count}
+                </span>
+              </>
+            )}
+          </div>
+
+          <p className="text-xs text-[var(--color-text-muted)] mb-3">
+            以下是實際送給 LLM 的完整提示詞（僅含該學生答錯的題目）
+          </p>
+
+          {loading ? (
+            <div className="flex-1 flex items-center justify-center">
+              <div className="w-6 h-6 border-2 border-[var(--color-primary)] border-t-transparent rounded-full animate-spin" />
+            </div>
+          ) : error ? (
+            <div className="flex-1 px-3 py-2 rounded-lg bg-red-500/10 text-red-400 text-sm">
+              {error}
+            </div>
           ) : (
-            /* Data editing tabs */
-            <>
-              <div className="flex items-center justify-between mb-3">
-                <p className="text-sm text-[var(--color-text-muted)]">
-                  可直接編輯下方 JSON 資料，修改後點擊「套用修改」儲存
-                </p>
-                <button
-                  onClick={() => handleSave(activeTab)}
-                  className="btn btn-outline text-sm !py-1.5 !px-3"
-                >
-                  套用修改
-                </button>
-              </div>
-
-              {parseErrors[activeTab] && (
-                <div className="mb-3 px-3 py-2 rounded-lg bg-red-500/10 text-red-500 text-sm">
-                  {parseErrors[activeTab]}
-                </div>
-              )}
-
-              <textarea
-                value={editTexts[activeTab] || ""}
-                onChange={(e) => handleTextChange(activeTab, e.target.value)}
-                className="input !rounded-xl font-mono text-sm leading-relaxed resize-y flex-1"
-                placeholder={`尚未上傳${DATA_TABS.find((t) => t.key === activeTab)?.label ?? ""}資料`}
-                spellCheck={false}
-              />
-            </>
+            <textarea
+              value={preview?.markdown_prompt ?? ""}
+              readOnly
+              className="input !rounded-xl font-mono text-sm leading-relaxed resize-y flex-1"
+              spellCheck={false}
+            />
           )}
         </div>
 
-        {/* Footer */}
         <div className="flex items-center justify-end gap-3 p-5 border-t border-[var(--color-border)]">
           <button onClick={onClose} className="btn btn-outline">
             返回編輯
           </button>
           <button
-            onClick={handleGenerate}
+            onClick={onGenerate}
             disabled={isGenerating}
             className="btn btn-accent text-lg px-8 py-3 disabled:opacity-50 disabled:cursor-not-allowed"
           >

chatkit/frontend/src/components/step2/PromptEditor.tsx

@@ -1,197 +1,59 @@
-import { useState, useEffect } from "react";
-import { apiGet, apiPost } from "../../lib/api";
+import { useState } from "react";
 import { ModelSelector } from "../ModelSelector";
 import { DataPreviewModal } from "./DataPreviewModal";
-
-interface Prompt {
-  id: number;
-  name: string;
-  content: string;
-  user_id: number;
-  author_email?: string;
-}
+import { AnswerGridEditor, type AnswerGrid } from "./AnswerGridEditor";
 
 interface PromptEditorProps {
-  promptContent: string;
-  onPromptChange: (content: string) => void;
   sessionId: number;
   onGenerate: (model: string) => void;
   isGenerating: boolean;
   selectedCount: number;
   selectedIndices: number[];
-  parsedData: Record<string, unknown>;
-  onParsedDataUpdate: (dataType: string, data: unknown) => void;
 }
 
 export function PromptEditor({
-  promptContent,
-  onPromptChange,
   sessionId,
   onGenerate,
   isGenerating,
   selectedCount,
   selectedIndices,
-  parsedData,
-  onParsedDataUpdate,
 }: PromptEditorProps) {
-  const [prompts, setPrompts] = useState<Prompt[]>([]);
-  const [allPrompts, setAllPrompts] = useState<Prompt[]>([]);
-  const [saveName, setSaveName] = useState("");
-  const [showSave, setShowSave] = useState(false);
-  const [showOthers, setShowOthers] = useState(false);
-  const [saving, setSaving] = useState(false);
   const [model, setModel] = useState("gpt-5.4");
   const [showPreview, setShowPreview] = useState(false);
+  const [confirmedGrid, setConfirmedGrid] = useState<AnswerGrid | null>(null);
 
-  useEffect(() => {
-    loadPrompts();
-  }, []);
-
-  const loadPrompts = async () => {
-    try {
-      const [mine, all] = await Promise.all([
-        apiGet<{ prompts: Prompt[] }>("/api/prompts"),
-        apiGet<{ prompts: Prompt[] }>("/api/prompts/all"),
-      ]);
-      setPrompts(mine.prompts);
-      setAllPrompts(all.prompts);
-    } catch {}
-  };
+  const canGenerate =
+    !isGenerating && selectedCount > 0 && confirmedGrid !== null;
 
-  const handleSave = async () => {
-    if (!saveName.trim()) return;
-    setSaving(true);
-    try {
-      await apiPost("/api/prompts", { name: saveName, content: promptContent });
-      setSaveName("");
-      setShowSave(false);
-      await loadPrompts();
-    } catch {}
-    setSaving(false);
-  };
-
-  const handleLoadPrompt = (prompt: Prompt) => {
-    onPromptChange(prompt.content);
-    setShowOthers(false);
-  };
+  const buttonLabel = (() => {
+    if (selectedCount === 0) return "請先選擇學生";
+    if (!confirmedGrid) return "請先確認答案表";
+    return `預覽並生成報告（${selectedCount} 位學生）→`;
+  })();
 
   return (
     <div className="space-y-4">
-      {/* Toolbar */}
-      <div className="flex flex-wrap items-center gap-3">
-        {/* Load own prompts */}
-        {prompts.length > 0 && (
-          <select
-            onChange={(e) => {
-              const p = prompts.find((p) => p.id === Number(e.target.value));
-              if (p) onPromptChange(p.content);
-            }}
-            defaultValue=""
-            className="input !w-auto !py-2 text-sm"
-          >
-            <option value="" disabled>我的提示詞...</option>
-            {prompts.map((p) => (
-              <option key={p.id} value={p.id}>{p.name}</option>
-            ))}
-          </select>
-        )}
-
-        {/* Load others' prompts */}
-        <button
-          onClick={() => setShowOthers(!showOthers)}
-          className="btn btn-outline text-sm !py-2"
-        >
-          瀏覽其他人的提示詞
-        </button>
-
-        {/* Save button */}
-        <button
-          onClick={() => setShowSave(!showSave)}
-          className="btn btn-outline text-sm !py-2"
-        >
-          儲存提示詞
-        </button>
+      <AnswerGridEditor
+        sessionId={sessionId}
+        onConfirmedChange={setConfirmedGrid}
+      />
 
-        {/* Model selector - right aligned */}
-        <div className="ml-auto">
-          <ModelSelector value={model} onChange={setModel} label="報告模型：" />
-        </div>
+      <div className="flex items-center justify-end">
+        <ModelSelector value={model} onChange={setModel} label="報告模型：" />
       </div>
 
-      {/* Others' prompts dropdown */}
-      {showOthers && (
-        <div className="card p-4 max-h-48 overflow-y-auto">
-          <h4 className="text-sm font-semibold text-[var(--color-text-muted)] mb-2">所有提示詞</h4>
-          {allPrompts.length === 0 ? (
-            <p className="text-sm text-[var(--color-text-muted)]">目前沒有其他人的提示詞</p>
-          ) : (
-            <div className="space-y-2">
-              {allPrompts.map((p) => (
-                <button
-                  key={p.id}
-                  onClick={() => handleLoadPrompt(p)}
-                  className="w-full text-left p-2 rounded-lg hover:bg-[var(--color-primary)]/10 transition-colors"
-                >
-                  <span className="text-sm text-[var(--color-text)]">{p.name}</span>
-                  {p.author_email && (
-                    <span className="text-xs text-[var(--color-text-muted)] ml-2">
-                      by {p.author_email}
-                    </span>
-                  )}
-                </button>
-              ))}
-            </div>
-          )}
-        </div>
-      )}
-
-      {/* Save prompt form */}
-      {showSave && (
-        <div className="card p-4 flex items-center gap-3">
-          <input
-            type="text"
-            value={saveName}
-            onChange={(e) => setSaveName(e.target.value)}
-            placeholder="提示詞名稱..."
-            className="input !py-2 text-sm flex-1"
-          />
-          <button
-            onClick={handleSave}
-            disabled={saving || !saveName.trim()}
-            className="btn btn-primary text-sm !py-2 disabled:opacity-50"
-          >
-            {saving ? "..." : "儲存"}
-          </button>
-        </div>
-      )}
-
-      {/* Prompt textarea */}
-      <textarea
-        value={promptContent}
-        onChange={(e) => onPromptChange(e.target.value)}
-        rows={10}
-        className="input !rounded-xl font-mono text-sm leading-relaxed resize-y"
-        placeholder="輸入分析提示詞..."
-      />
-
-      {/* Preview button */}
       <div className="text-center">
         <button
           onClick={() => setShowPreview(true)}
-          disabled={isGenerating || selectedCount === 0}
+          disabled={!canGenerate}
           className="btn btn-accent text-lg px-8 py-4 disabled:opacity-50 disabled:cursor-not-allowed"
         >
-          {selectedCount === 0
-            ? "請先選擇學生"
-            : `預覽分析資料（${selectedCount} 位學生）→`}
+          {buttonLabel}
         </button>
       </div>
 
-      {/* Data preview modal */}
       {showPreview && (
         <DataPreviewModal
-          parsedData={parsedData}
-          onParsedDataUpdate={onParsedDataUpdate}
           onGenerate={() => {
             setShowPreview(false);
             onGenerate(model);
@@ -200,7 +62,6 @@ export function PromptEditor({
           isGenerating={isGenerating}
           sessionId={sessionId}
           selectedIndices={selectedIndices}
-          promptTemplate={promptContent}
         />
       )}
     </div>