feat: add wrong-answer note for cross-session quiz review

Persist structured quiz mistakes on submission and expose them in a
new review page accessible from the utility sidebar.

Backend:
- New wrong_answers SQLite table (cascade on session delete) with
  add/list/count/update/delete store methods
- Hook POST /api/v1/sessions/{id}/quiz-results to also insert one row
  per incorrect answer, preserving the existing [Quiz Performance]
  text message consumed by the LLM context builder
- New GET /api/v1/wrong-answers (resolved filter + pagination),
  PATCH /{id} (resolved toggle), DELETE /{id}

Frontend:
- New /wrong-answers page under the (utility) route group with
  unresolved/all filter, mark-as-resolved, delete, and session link
- Sidebar nav entry using the NotebookPen icon
- English and Chinese i18n strings for all new UI text

Tests:
- 8 store tests covering filter, cascade, resolved toggle, delete
- 6 router tests including a regression test that record_quiz_results
  still writes the [Quiz Performance] text message

Author: cskwork

deeptutor/api/main.py

@@ -214,6 +214,7 @@ async def selective_access_log(request, call_next):
     tutorbot,
     unified_ws,
     vision_solver,
+    wrong_answers,
 )
 
 # Include routers
@@ -227,6 +228,7 @@ async def selective_access_log(request, call_next):
 app.include_router(guide.router, prefix="/api/v1/guide", tags=["guide"])
 app.include_router(memory.router, prefix="/api/v1/memory", tags=["memory"])
 app.include_router(sessions.router, prefix="/api/v1/sessions", tags=["sessions"])
+app.include_router(wrong_answers.router, prefix="/api/v1/wrong-answers", tags=["wrong-answers"])
 app.include_router(settings.router, prefix="/api/v1/settings", tags=["settings"])
 app.include_router(system.router, prefix="/api/v1/system", tags=["system"])
 app.include_router(plugins_api.router, prefix="/api/v1/plugins", tags=["plugins"])

deeptutor/api/routers/sessions.py

@@ -99,9 +99,14 @@ async def record_quiz_results(session_id: str, payload: QuizResultsRequest):
         content=content,
         capability="deep_question",
     )
+    wrong_answer_count = await store.add_wrong_answers(
+        session_id,
+        [item.model_dump() for item in payload.answers],
+    )
     return {
         "recorded": True,
         "session_id": session_id,
         "answer_count": len(payload.answers),
+        "wrong_answer_count": wrong_answer_count,
         "content": content,
     }

deeptutor/api/routers/wrong_answers.py

@@ -0,0 +1,74 @@
+"""
+Wrong answer notebook API — persists and exposes quiz mistakes for review.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from deeptutor.services.session import get_sqlite_session_store
+
+router = APIRouter()
+
+
+class WrongAnswerItem(BaseModel):
+    id: int
+    session_id: str
+    session_title: str = ""
+    question_id: str = ""
+    question: str
+    user_answer: str = ""
+    correct_answer: str = ""
+    resolved: bool
+    created_at: float
+    resolved_at: float | None = None
+
+
+class WrongAnswerListResponse(BaseModel):
+    items: list[WrongAnswerItem]
+    total: int
+
+
+class WrongAnswerResolveRequest(BaseModel):
+    resolved: bool
+
+
+@router.get("", response_model=WrongAnswerListResponse)
+async def list_wrong_answers(
+    resolved: bool | None = Query(default=None),
+    limit: int = Query(default=50, ge=1, le=200),
+    offset: int = Query(default=0, ge=0),
+) -> WrongAnswerListResponse:
+    store = get_sqlite_session_store()
+    items = await store.list_wrong_answers(
+        resolved=resolved, limit=limit, offset=offset
+    )
+    total = await store.count_wrong_answers(resolved=resolved)
+    return WrongAnswerListResponse(
+        items=[WrongAnswerItem(**item) for item in items],
+        total=total,
+    )
+
+
+@router.patch("/{wrong_answer_id}")
+async def update_wrong_answer(
+    wrong_answer_id: int,
+    payload: WrongAnswerResolveRequest,
+):
+    store = get_sqlite_session_store()
+    updated = await store.update_wrong_answer_resolved(
+        wrong_answer_id, payload.resolved
+    )
+    if not updated:
+        raise HTTPException(status_code=404, detail="Wrong answer not found")
+    return {"updated": True, "id": wrong_answer_id, "resolved": payload.resolved}
+
+
+@router.delete("/{wrong_answer_id}")
+async def delete_wrong_answer(wrong_answer_id: int):
+    store = get_sqlite_session_store()
+    deleted = await store.delete_wrong_answer(wrong_answer_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Wrong answer not found")
+    return {"deleted": True, "id": wrong_answer_id}

deeptutor/services/session/sqlite_store.py

@@ -145,6 +145,24 @@ def _initialize(self) -> None:
 
                 CREATE INDEX IF NOT EXISTS idx_turn_events_turn_seq
                     ON turn_events(turn_id, seq);
+
+                CREATE TABLE IF NOT EXISTS wrong_answers (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+                    question_id TEXT DEFAULT '',
+                    question TEXT NOT NULL,
+                    user_answer TEXT DEFAULT '',
+                    correct_answer TEXT DEFAULT '',
+                    resolved INTEGER NOT NULL DEFAULT 0,
+                    created_at REAL NOT NULL,
+                    resolved_at REAL
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_wrong_answers_session
+                    ON wrong_answers(session_id, created_at DESC);
+
+                CREATE INDEX IF NOT EXISTS idx_wrong_answers_resolved
+                    ON wrong_answers(resolved, created_at DESC);
                 """
             )
             columns = {row[1] for row in conn.execute("PRAGMA table_info(sessions)").fetchall()}
@@ -731,6 +749,164 @@ async def get_session_with_messages(self, session_id: str) -> dict[str, Any] | N
         session["active_turns"] = await self.list_active_turns(session_id)
         return session
 
+    def _add_wrong_answers_sync(
+        self,
+        session_id: str,
+        items: list[dict[str, Any]],
+    ) -> int:
+        if not items:
+            return 0
+        now = time.time()
+        with self._connect() as conn:
+            session = conn.execute(
+                "SELECT id FROM sessions WHERE id = ?",
+                (session_id,),
+            ).fetchone()
+            if session is None:
+                raise ValueError(f"Session not found: {session_id}")
+            inserted = 0
+            for item in items:
+                if item.get("is_correct"):
+                    continue
+                question = (item.get("question") or "").strip()
+                if not question:
+                    continue
+                conn.execute(
+                    """
+                    INSERT INTO wrong_answers (
+                        session_id, question_id, question, user_answer,
+                        correct_answer, resolved, created_at, resolved_at
+                    ) VALUES (?, ?, ?, ?, ?, 0, ?, NULL)
+                    """,
+                    (
+                        session_id,
+                        item.get("question_id") or "",
+                        question,
+                        item.get("user_answer") or "",
+                        item.get("correct_answer") or "",
+                        now,
+                    ),
+                )
+                inserted += 1
+            conn.commit()
+        return inserted
+
+    async def add_wrong_answers(
+        self,
+        session_id: str,
+        items: list[dict[str, Any]],
+    ) -> int:
+        return await self._run(self._add_wrong_answers_sync, session_id, items)
+
+    def _list_wrong_answers_sync(
+        self,
+        resolved: bool | None,
+        limit: int,
+        offset: int,
+    ) -> list[dict[str, Any]]:
+        query = """
+            SELECT
+                w.id,
+                w.session_id,
+                COALESCE(s.title, '') AS session_title,
+                w.question_id,
+                w.question,
+                w.user_answer,
+                w.correct_answer,
+                w.resolved,
+                w.created_at,
+                w.resolved_at
+            FROM wrong_answers w
+            LEFT JOIN sessions s ON s.id = w.session_id
+        """
+        params: list[Any] = []
+        if resolved is not None:
+            query += " WHERE w.resolved = ?"
+            params.append(1 if resolved else 0)
+        query += " ORDER BY w.created_at DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+        with self._connect() as conn:
+            rows = conn.execute(query, tuple(params)).fetchall()
+        return [
+            {
+                "id": int(row["id"]),
+                "session_id": row["session_id"],
+                "session_title": row["session_title"] or "",
+                "question_id": row["question_id"] or "",
+                "question": row["question"],
+                "user_answer": row["user_answer"] or "",
+                "correct_answer": row["correct_answer"] or "",
+                "resolved": bool(row["resolved"]),
+                "created_at": float(row["created_at"]),
+                "resolved_at": (
+                    float(row["resolved_at"]) if row["resolved_at"] is not None else None
+                ),
+            }
+            for row in rows
+        ]
+
+    async def list_wrong_answers(
+        self,
+        resolved: bool | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        return await self._run(
+            self._list_wrong_answers_sync, resolved, limit, offset
+        )
+
+    def _count_wrong_answers_sync(self, resolved: bool | None) -> int:
+        query = "SELECT COUNT(*) AS count FROM wrong_answers"
+        params: tuple[Any, ...] = ()
+        if resolved is not None:
+            query += " WHERE resolved = ?"
+            params = (1 if resolved else 0,)
+        with self._connect() as conn:
+            row = conn.execute(query, params).fetchone()
+        return int(row["count"]) if row else 0
+
+    async def count_wrong_answers(self, resolved: bool | None = None) -> int:
+        return await self._run(self._count_wrong_answers_sync, resolved)
+
+    def _update_wrong_answer_resolved_sync(
+        self,
+        wrong_answer_id: int,
+        resolved: bool,
+    ) -> bool:
+        now = time.time() if resolved else None
+        with self._connect() as conn:
+            cur = conn.execute(
+                """
+                UPDATE wrong_answers
+                SET resolved = ?, resolved_at = ?
+                WHERE id = ?
+                """,
+                (1 if resolved else 0, now, wrong_answer_id),
+            )
+            conn.commit()
+        return cur.rowcount > 0
+
+    async def update_wrong_answer_resolved(
+        self,
+        wrong_answer_id: int,
+        resolved: bool,
+    ) -> bool:
+        return await self._run(
+            self._update_wrong_answer_resolved_sync, wrong_answer_id, resolved
+        )
+
+    def _delete_wrong_answer_sync(self, wrong_answer_id: int) -> bool:
+        with self._connect() as conn:
+            cur = conn.execute(
+                "DELETE FROM wrong_answers WHERE id = ?",
+                (wrong_answer_id,),
+            )
+            conn.commit()
+        return cur.rowcount > 0
+
+    async def delete_wrong_answer(self, wrong_answer_id: int) -> bool:
+        return await self._run(self._delete_wrong_answer_sync, wrong_answer_id)
+
 
 _instance: SQLiteSessionStore | None = None