Revert "add teacher retention, feedback-loop, and issue-report analytics to admin backend"

This reverts commit c5b36039af43f2a5fead8efe0ba08ca4b3b49db3.

chatkit/backend/alembic/versions/0015_issue_reports.py

@@ -1,54 +0,0 @@
-"""add issue_reports table
-
-Revision ID: 0015_issue_reports
-Revises: 0014_teacher_vocabulary
-Create Date: 2026-07-22
-
-Backs the "report an issue" form: submissions are emailed to admins and
-also persisted here so they show up as a dismissible alert in the admin
-dashboard until dismissed.
-"""
-from alembic import op
-import sqlalchemy as sa
-
-from app.db import active_schema
-
-revision = "0015_issue_reports"
-down_revision = "0014_teacher_vocabulary"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    schema = active_schema()
-    inspector = sa.inspect(op.get_bind())
-    tables = inspector.get_table_names(schema=schema)
-
-    if "issue_reports" not in tables:
-        op.create_table(
-            "issue_reports",
-            sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
-            sa.Column("reporter_email", sa.String(255), nullable=False),
-            sa.Column("category", sa.String(32), nullable=False, server_default="bug"),
-            sa.Column("subject", sa.String(255), nullable=False),
-            sa.Column("description", sa.Text(), nullable=False),
-            sa.Column("page_context", sa.String(255), server_default=""),
-            sa.Column("status", sa.String(16), nullable=False, server_default="open"),
-            sa.Column(
-                "created_at",
-                sa.DateTime(timezone=True),
-                server_default=sa.func.now(),
-                nullable=False,
-            ),
-            sa.Column("dismissed_at", sa.DateTime(timezone=True), nullable=True),
-            schema=schema,
-        )
-        op.create_index(
-            "ix_issue_reports_created_at", "issue_reports", ["created_at"], schema=schema
-        )
-
-
-def downgrade() -> None:
-    schema = active_schema()
-    op.drop_index("ix_issue_reports_created_at", table_name="issue_reports", schema=schema)
-    op.drop_table("issue_reports", schema=schema)

chatkit/backend/app/admin.py

@@ -23,11 +23,9 @@ from .database import (
     admin_list_students,
     delete_session,
     delete_user,
-    dismiss_issue_report,
     get_active_users,
     get_answer_grid,
     get_assessments_processed,
-    get_feedback_loop_funnel,
     get_parsed_data,
     get_practice_quiz_funnel,
     get_quiz_results,
@@ -38,10 +36,8 @@ from .database import (
     get_student,
     get_student_improvement_summary,
     get_student_timeline,
-    get_teacher_retention,
     get_teacher_vocabulary,
     list_all_users,
-    list_open_issue_reports,
     set_teacher_vocabulary,
     set_user_admin,
     wipe_quiz_data,
@@ -105,34 +101,6 @@ async def dashboard_student_improvement(_admin=Depends(get_current_admin)):
     return await get_student_improvement_summary()
 
 
-@router.get("/analytics/teacher-retention")
-async def dashboard_teacher_retention(_admin=Depends(get_current_admin)):
-    return await get_teacher_retention()
-
-
-@router.get("/analytics/feedback-loop")
-async def dashboard_feedback_loop(_admin=Depends(get_current_admin)):
-    return await get_feedback_loop_funnel()
-
-
-# ---- Issue reports (admin only) ----
-
-
-@router.get("/issues")
-async def dashboard_list_issues(_admin=Depends(get_current_admin)):
-    return {"issues": await list_open_issue_reports()}
-
-
-@router.post("/issues/{issue_id}/dismiss")
-async def dashboard_dismiss_issue(issue_id: int, _admin=Depends(get_current_admin)):
-    ok = await dismiss_issue_report(issue_id)
-    if not ok:
-        raise HTTPException(
-            status_code=404, detail="Issue not found or already dismissed"
-        )
-    return {"status": "dismissed"}
-
-
 # ---- User management (admin only) ----
 
 

chatkit/backend/app/auth.py

@@ -28,11 +28,11 @@ security = HTTPBearer(auto_error=False)
 
 # Grants admin access to this account regardless of the `is_admin` flag in
 # Supabase — so it doesn't need a manual DB update to stay an admin.
-EXTRA_ADMIN_EMAIL = "astraealiu44@gmail.com"
+_EXTRA_ADMIN_EMAIL = "astraealiu44@gmail.com"
 
 
 def _apply_admin_override(user: dict) -> dict:
-    if user.get("email") == EXTRA_ADMIN_EMAIL and not user.get("is_admin"):
+    if user.get("email") == _EXTRA_ADMIN_EMAIL and not user.get("is_admin"):
         return {**user, "is_admin": True}
     return user
 

chatkit/backend/app/config.py

@@ -51,16 +51,6 @@ class Settings(BaseModel):
     # Frontend URL for redirects
     frontend_url: str = "http://localhost:3000"
 
-    # SMTP — used only to email admins when a "report an issue" form is
-    # submitted (see app/notifications.py). Left blank, sending is skipped
-    # (logged, not raised) so the report still saves and shows up in the
-    # admin dashboard even with no mail server configured.
-    smtp_host: str = ""
-    smtp_port: int = 587
-    smtp_user: str = ""
-    smtp_password: str = ""
-    smtp_from: str = ""
-
 
 @lru_cache
 def get_settings() -> Settings:
@@ -86,9 +76,4 @@ def get_settings() -> Settings:
         upload_dir=os.getenv("UPLOAD_DIR", ""),
         max_file_size_mb=int(os.getenv("MAX_FILE_SIZE_MB", "20")),
         frontend_url=os.getenv("FRONTEND_URL", "http://localhost:3000"),
-        smtp_host=os.getenv("SMTP_HOST", ""),
-        smtp_port=int(os.getenv("SMTP_PORT", "587")),
-        smtp_user=os.getenv("SMTP_USER", ""),
-        smtp_password=os.getenv("SMTP_PASSWORD", ""),
-        smtp_from=os.getenv("SMTP_FROM", ""),
     )

chatkit/backend/app/database.py

@@ -27,7 +27,6 @@ from .taxonomy import MAIN_CATEGORIES
 from .models import (
     AnswerGrid as AnswerGridRecord,
     Base,
-    IssueReport,
     LoginEvent,
     ParsedData,
     PracticeQuiz,
@@ -46,16 +45,6 @@ def _now() -> datetime:
     return datetime.now(timezone.utc)
 
 
-def _aware(dt: datetime) -> datetime:
-    """Postgres (DateTime(timezone=True)) round-trips tz-aware datetimes;
-    SQLite always hands back naive ones regardless of column type. Anything
-    comparing a DB-fetched datetime against another in plain Python (not a
-    SQL WHERE clause, which each dialect handles consistently on its own)
-    needs both sides on the same footing — assume naive values are UTC,
-    since every datetime this app writes is generated via _now()."""
-    return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
-
-
 def _row(obj) -> dict:
     """Serialize an ORM object to a plain dict of its columns."""
     return {c.key: getattr(obj, c.key) for c in obj.__table__.columns}
@@ -174,60 +163,6 @@ async def set_user_admin(user_id: int, is_admin: bool):
         await db.commit()
 
 
-async def get_admin_emails() -> list[str]:
-    """Every teacher with is_admin=True in the DB — used as the recipient
-    list for issue-report notifications. Doesn't include email-based admin
-    overrides granted only in code (see auth._apply_admin_override); callers
-    that need those too should merge them in separately."""
-    async with get_sessionmaker()() as db:
-        res = await db.execute(select(Teacher.email).where(Teacher.is_admin.is_(True)))
-        return [e for (e,) in res.all()]
-
-
-async def create_issue_report(
-    reporter_email: str,
-    category: str,
-    subject: str,
-    description: str,
-    page_context: str = "",
-) -> dict:
-    async with get_sessionmaker()() as db:
-        report = IssueReport(
-            reporter_email=reporter_email,
-            category=category,
-            subject=subject,
-            description=description,
-            page_context=page_context,
-        )
-        db.add(report)
-        await db.flush()
-        await db.refresh(report)
-        row = _row(report)
-        await db.commit()
-        return row
-
-
-async def list_open_issue_reports() -> list[dict]:
-    async with get_sessionmaker()() as db:
-        res = await db.execute(
-            select(IssueReport)
-            .where(IssueReport.status == "open")
-            .order_by(IssueReport.created_at.desc())
-        )
-        return [_row(r) for r in res.scalars().all()]
-
-
-async def dismiss_issue_report(report_id: int) -> bool:
-    async with get_sessionmaker()() as db:
-        res = await db.execute(
-            update(IssueReport)
-            .where(IssueReport.id == report_id, IssueReport.status == "open")
-            .values(status="dismissed", dismissed_at=_now())
-        )
-        await db.commit()
-        return res.rowcount > 0  # type: ignore[attr-defined]
-
-
 async def list_all_users() -> list[dict]:
     """Admin: all teachers (without password hashes), with per-teacher counts."""
     async with get_sessionmaker()() as db:
@@ -1305,50 +1240,6 @@ async def get_active_users(weeks: int = 12) -> dict:
     }
 
 
-async def get_teacher_retention() -> dict:
-    """Of teachers whose account is old enough to judge, what share came back
-    and logged in again *after* their first week / first month — not just
-    during initial signup/onboarding. Shows sustained use rather than
-    one-time testing.
-
-    A teacher only counts toward a window's denominator once their account
-    has existed at least that long (a 3-day-old account can't yet prove or
-    disprove week-1 retention), and toward the numerator if any login_event
-    for them lands strictly after `created_at + window`.
-    """
-    now = _now()
-    async with get_sessionmaker()() as db:
-        teachers_res = await db.execute(select(Teacher.id, Teacher.created_at))
-        teachers = [(tid, _aware(created_at)) for tid, created_at in teachers_res.all()]
-
-        logins_res = await db.execute(
-            select(LoginEvent.user_id, LoginEvent.created_at).where(
-                LoginEvent.role == "teacher"
-            )
-        )
-        logins_by_teacher: dict[int, list[datetime]] = {}
-        for user_id, created_at in logins_res.all():
-            logins_by_teacher.setdefault(user_id, []).append(_aware(created_at))
-
-    def window_stats(days: int) -> dict:
-        eligible = 0
-        retained = 0
-        for teacher_id, created_at in teachers:
-            cutoff = created_at + timedelta(days=days)
-            if cutoff > now:
-                continue  # account not old enough to judge this window yet
-            eligible += 1
-            if any(t > cutoff for t in logins_by_teacher.get(teacher_id, [])):
-                retained += 1
-        pct = round(100 * retained / eligible, 1) if eligible else 0.0
-        return {"eligible": eligible, "retained": retained, "pct": pct}
-
-    return {
-        "week": window_stats(7),
-        "month": window_stats(30),
-    }
-
-
 async def get_assessments_processed(months: int = 6) -> dict:
     """Monthly counts of exams uploaded (saved quizzes) and student reports
     generated, for the admin analytics bar chart."""
@@ -1428,129 +1319,6 @@ async def get_practice_quiz_funnel(teacher_id: Optional[int] = None) -> dict:
     }
 
 
-async def get_feedback_loop_funnel(teacher_id: Optional[int] = None) -> dict:
-    """Exam result → weakness identified → practice generated → practice
-    completed → later reassessment, for the admin funnel chart.
-
-    The unit here is one student's result on one real exam (a
-    StudentResult row on a Quiz with status="saved" and no
-    source_practice_quiz_id — i.e. not the synthetic quiz row a completed
-    practice quiz feeds into the dashboard as). PracticeQuiz has no FK back
-    to the exam that triggered it, so each stage is correlated by student +
-    timestamp ordering instead: the practice quiz counted for a given exam
-    result is the earliest one generated for that student after the exam,
-    and a "reassessment" is any later real exam for that same student after
-    that practice was completed.
-    """
-    async with get_sessionmaker()() as db:
-        quiz_stmt = select(Quiz.id, Quiz.created_at).where(
-            Quiz.status == "saved", Quiz.source_practice_quiz_id.is_(None)
-        )
-        if teacher_id is not None:
-            quiz_stmt = quiz_stmt.where(Quiz.teacher_id == teacher_id)
-        quiz_res = await db.execute(quiz_stmt)
-        quiz_created_at: dict[int, datetime] = {
-            qid: _aware(dt) for qid, dt in quiz_res.all()
-        }
-
-        empty = {
-            "uploaded": 0,
-            "weakness_identified": 0,
-            "practice_generated": 0,
-            "practice_completed": 0,
-            "reassessed": 0,
-        }
-        if not quiz_created_at:
-            return empty
-
-        result_res = await db.execute(
-            select(
-                StudentResult.quiz_id,
-                StudentResult.student_id,
-                StudentResult.weaknesses,
-            ).where(StudentResult.quiz_id.in_(quiz_created_at.keys()))
-        )
-        results = result_res.all()
-        if not results:
-            return empty
-
-        student_ids = {sid for _, sid, _ in results}
-
-        pq_stmt = select(
-            PracticeQuiz.student_id,
-            PracticeQuiz.created_at,
-            PracticeQuiz.completed_at,
-            PracticeQuiz.status,
-        ).where(PracticeQuiz.student_id.in_(student_ids))
-        if teacher_id is not None:
-            pq_stmt = pq_stmt.where(PracticeQuiz.teacher_id == teacher_id)
-        pq_res = await db.execute(pq_stmt)
-        practice_by_student: dict[int, list[tuple]] = {}
-        for sid, created_at, completed_at, status in pq_res.all():
-            practice_by_student.setdefault(sid, []).append(
-                (
-                    _aware(created_at),
-                    _aware(completed_at) if completed_at else None,
-                    status,
-                )
-            )
-
-        # Every real exam per student (quiz_id kept so a student's own
-        # triggering exam is never counted as its own "later" reassessment).
-        exam_stmt = (
-            select(StudentResult.student_id, Quiz.id, Quiz.created_at)
-            .join(Quiz, StudentResult.quiz_id == Quiz.id)
-            .where(Quiz.status == "saved", Quiz.source_practice_quiz_id.is_(None))
-        )
-        if teacher_id is not None:
-            exam_stmt = exam_stmt.where(Quiz.teacher_id == teacher_id)
-        exam_res = await db.execute(exam_stmt)
-        exams_by_student: dict[int, list[tuple]] = {}
-        for sid, qid, created_at in exam_res.all():
-            exams_by_student.setdefault(sid, []).append((qid, _aware(created_at)))
-
-    uploaded = len(results)
-    weakness_identified = 0
-    practice_generated = 0
-    practice_completed = 0
-    reassessed = 0
-
-    for quiz_id, student_id, weaknesses in results:
-        if not (weaknesses or "").strip():
-            continue
-        weakness_identified += 1
-
-        quiz_time = quiz_created_at[quiz_id]
-        practices_after = sorted(
-            (p for p in practice_by_student.get(student_id, []) if p[0] > quiz_time),
-            key=lambda p: p[0],
-        )
-        if not practices_after:
-            continue
-        practice_generated += 1
-
-        _, completed_at, status = practices_after[0]
-        if status != "completed" or completed_at is None:
-            continue
-        practice_completed += 1
-
-        later_exams = [
-            t
-            for other_qid, t in exams_by_student.get(student_id, [])
-            if other_qid != quiz_id and t > completed_at
-        ]
-        if later_exams:
-            reassessed += 1
-
-    return {
-        "uploaded": uploaded,
-        "weakness_identified": weakness_identified,
-        "practice_generated": practice_generated,
-        "practice_completed": practice_completed,
-        "reassessed": reassessed,
-    }
-
-
 async def get_all_students_category_history(
     teacher_id: Optional[int] = None,
 ) -> dict[int, dict[str, list[dict]]]:

chatkit/backend/app/main.py

@@ -58,8 +58,6 @@ from .database import (
     list_practice_quizzes,
     mark_practice_quiz_opened,
     submit_practice_quiz,
-    create_issue_report,
-    get_admin_emails,
 )
 from .auth import (
     get_current_user,
@@ -71,11 +69,9 @@ from .auth import (
     get_student_from_raw_token,
     login_student,
     public_student,
-    EXTRA_ADMIN_EMAIL,
 )
 from .config import get_settings
 from .crypto import encrypt
-from .notifications import send_issue_report_email
 from .student_credentials import (
     ensure_student_login,
     generate_unique_username,
@@ -1094,54 +1090,6 @@ async def api_rewrite_question(
         raise HTTPException(status_code=500, detail=f"Rewrite failed: {str(e)}")
 
 
-# =============================================================================
-# Issue Reports ("report an issue" form — any logged-in teacher)
-# =============================================================================
-
-_ISSUE_CATEGORIES = {"bug", "feature", "other"}
-
-
-class IssueReportRequest(BaseModel):
-    category: str = "bug"
-    subject: str
-    description: str
-    page_context: str = ""
-
-
-@app.post("/api/issues")
-async def api_submit_issue_report(
-    body: IssueReportRequest, user=Depends(get_current_user)
-):
-    if body.category not in _ISSUE_CATEGORIES:
-        raise HTTPException(status_code=400, detail="Invalid category.")
-    if not body.subject.strip() or not body.description.strip():
-        raise HTTPException(
-            status_code=400, detail="Subject and description are required."
-        )
-
-    report = await create_issue_report(
-        user["email"],
-        body.category,
-        body.subject.strip(),
-        body.description.strip(),
-        body.page_context,
-    )
-
-    # DB-flagged admins plus the code-level admin override (see
-    # auth._apply_admin_override) — that account is an admin in the app but
-    # was never flipped in the DB, so get_admin_emails() alone would miss it.
-    admin_emails = {*await get_admin_emails(), EXTRA_ADMIN_EMAIL}
-    await send_issue_report_email(
-        sorted(admin_emails),
-        user["email"],
-        body.category,
-        body.subject.strip(),
-        body.description.strip(),
-        body.page_context,
-    )
-    return {"status": "submitted", "id": report["id"]}
-
-
 # =============================================================================
 # Practice Quizzes (individualized, student-facing, single-attempt, no login)
 # =============================================================================

chatkit/backend/app/models.py

@@ -339,26 +339,3 @@ class LoginEvent(Base):
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True), server_default=func.now(), index=True
     )
-
-
-class IssueReport(Base):
-    """A "report an issue" submission — emailed to admins on creation and
-    surfaced as a dismissible alert in the admin dashboard until an admin
-    dismisses it. No FK to teachers: intentionally keeps working even if the
-    reporting account is later deleted."""
-
-    __tablename__ = "issue_reports"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    reporter_email: Mapped[str] = mapped_column(String(255), nullable=False)
-    category: Mapped[str] = mapped_column(String(32), nullable=False, default="bug")
-    subject: Mapped[str] = mapped_column(String(255), nullable=False)
-    description: Mapped[str] = mapped_column(Text, nullable=False)
-    page_context: Mapped[str] = mapped_column(String(255), default="")
-    status: Mapped[str] = mapped_column(String(16), nullable=False, default="open")
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), server_default=func.now(), index=True
-    )
-    dismissed_at: Mapped[Optional[datetime]] = mapped_column(
-        DateTime(timezone=True), nullable=True
-    )

chatkit/backend/app/notifications.py

@@ -1,68 +0,0 @@
-"""Email notifications. Currently just one: notify admins when a "report an
-issue" form is submitted. Kept separate from app/auth.py's password-related
-crypto and app/database.py's persistence — this module only ever sends mail,
-never touches the DB or auth.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import smtplib
-from email.message import EmailMessage
-
-from .config import get_settings
-
-logger = logging.getLogger(__name__)
-
-
-def _send_sync(to_addrs: list[str], subject: str, body: str) -> None:
-    settings = get_settings()
-    msg = EmailMessage()
-    msg["Subject"] = subject
-    msg["From"] = settings.smtp_from or settings.smtp_user
-    msg["To"] = ", ".join(to_addrs)
-    msg.set_content(body)
-
-    with smtplib.SMTP(settings.smtp_host, settings.smtp_port, timeout=10) as smtp:
-        smtp.starttls()
-        if settings.smtp_user:
-            smtp.login(settings.smtp_user, settings.smtp_password)
-        smtp.send_message(msg)
-
-
-async def send_issue_report_email(
-    to_addrs: list[str],
-    reporter_email: str,
-    category: str,
-    subject: str,
-    description: str,
-    page_context: str,
-) -> None:
-    """Best-effort notification — never raises. A submitted report is
-    already saved to the DB and visible in the admin dashboard before this
-    runs, so a mail-server hiccup shouldn't turn into a 500 for the person
-    reporting the issue."""
-    settings = get_settings()
-    if not settings.smtp_host or not to_addrs:
-        logger.info(
-            "Skipping issue-report email (SMTP not configured or no admin recipients): %s",
-            subject,
-        )
-        return
-
-    body = (
-        f"New issue report from {reporter_email}\n"
-        f"Category: {category}\n"
-        f"Page: {page_context or '(not provided)'}\n\n"
-        f"{description}"
-    )
-    try:
-        # smtplib is blocking network I/O — keep it off the event loop the
-        # same way bcrypt hashing is (see app/auth.py), so one slow/hung
-        # mail-server connection can't stall every other in-flight request.
-        await asyncio.to_thread(
-            _send_sync, to_addrs, f"[ClassLens] New issue report: {subject}", body
-        )
-    except Exception as exc:
-        logger.warning("Failed to send issue-report email: %s", exc)

chatkit/backend/tests/test_database.py

@@ -135,128 +135,6 @@ async def test_stats_and_lists_scope_to_teacher(fresh_db):
     assert len(await database.admin_list_sessions()) == 2  # admin sees both
 
 
-@pytest.mark.unit
-async def test_teacher_retention_windows(fresh_db):
-    from datetime import datetime, timedelta, timezone
-
-    from app.db import get_sessionmaker
-    from app.models import LoginEvent, Teacher
-
-    now = datetime.now(timezone.utc)
-    async with get_sessionmaker()() as db:
-        old_returning = Teacher(
-            email="returning@example.com",
-            password_hash="h",
-            created_at=now - timedelta(days=40),
-        )
-        old_one_time = Teacher(
-            email="onetime@example.com",
-            password_hash="h",
-            created_at=now - timedelta(days=40),
-        )
-        too_new = Teacher(
-            email="new@example.com", password_hash="h", created_at=now - timedelta(days=3)
-        )
-        db.add_all([old_returning, old_one_time, too_new])
-        await db.flush()
-        # Returning teacher logged in again well after both the week and
-        # month cutoffs from their signup.
-        db.add(
-            LoginEvent(
-                role="teacher", user_id=old_returning.id, created_at=now - timedelta(days=2)
-            )
-        )
-        await db.commit()
-
-    retention = await database.get_teacher_retention()
-    # Only the two 40-day-old accounts are eligible for either window — the
-    # 3-day-old one hasn't existed long enough to judge yet.
-    assert retention["week"]["eligible"] == 2
-    assert retention["week"]["retained"] == 1
-    assert retention["week"]["pct"] == 50.0
-    assert retention["month"]["eligible"] == 2
-    assert retention["month"]["retained"] == 1
-
-
-@pytest.mark.unit
-async def test_feedback_loop_funnel_stages(fresh_db):
-    from datetime import datetime, timedelta, timezone
-
-    from app.db import get_sessionmaker
-    from app.models import PracticeQuiz, Quiz, StudentResult
-
-    uid = await database.create_user("t@example.com", "h")
-    s1 = await database.match_or_create_student(uid, "Alice")
-    s2 = await database.match_or_create_student(uid, "Bob")
-
-    now = datetime.now(timezone.utc)
-    t0 = now - timedelta(days=10)
-    async with get_sessionmaker()() as db:
-        quiz1 = Quiz(teacher_id=uid, title="Exam 1", status="saved", created_at=t0)
-        db.add(quiz1)
-        await db.flush()
-        db.add_all(
-            [
-                # Alice: weakness identified, practice generated + completed,
-                # then reassessed with a later real exam — completes all 5 stages.
-                StudentResult(
-                    quiz_id=quiz1.id, student_id=s1, score=60.0, weaknesses="verb tense"
-                ),
-                # Bob: no weakness identified — stops at stage 1.
-                StudentResult(quiz_id=quiz1.id, student_id=s2, score=95.0, weaknesses=""),
-            ]
-        )
-        db.add(
-            PracticeQuiz(
-                teacher_id=uid,
-                student_id=s1,
-                share_token="tok1",
-                status="completed",
-                created_at=t0 + timedelta(days=1),
-                completed_at=t0 + timedelta(days=2),
-            )
-        )
-        await db.flush()
-        quiz2 = Quiz(
-            teacher_id=uid, title="Exam 2", status="saved", created_at=t0 + timedelta(days=3)
-        )
-        db.add(quiz2)
-        await db.flush()
-        db.add(StudentResult(quiz_id=quiz2.id, student_id=s1, score=80.0))
-        await db.commit()
-
-    funnel = await database.get_feedback_loop_funnel()
-    # Alice+Bob's results on quiz1, plus Alice's reassessment result on quiz2.
-    assert funnel["uploaded"] == 3
-    assert funnel["weakness_identified"] == 1  # Alice only
-    assert funnel["practice_generated"] == 1
-    assert funnel["practice_completed"] == 1
-    assert funnel["reassessed"] == 1  # Alice's quiz2 came after her practice completed
-
-
-@pytest.mark.unit
-async def test_issue_report_lifecycle(fresh_db):
-    admin_id = await database.create_user("admin@example.com", "h")
-    await database.set_user_admin(admin_id, True)
-    await database.create_user("teacher@example.com", "h")
-
-    assert await database.get_admin_emails() == ["admin@example.com"]
-
-    created = await database.create_issue_report(
-        "teacher@example.com", "bug", "Upload fails", "Steps to reproduce...", "/dashboard"
-    )
-    assert created["status"] == "open"
-
-    open_issues = await database.list_open_issue_reports()
-    assert len(open_issues) == 1
-    assert open_issues[0]["subject"] == "Upload fails"
-
-    assert await database.dismiss_issue_report(created["id"]) is True
-    assert await database.list_open_issue_reports() == []
-    # Already dismissed — dismissing again finds nothing to update.
-    assert await database.dismiss_issue_report(created["id"]) is False
-
-
 @pytest.mark.unit
 def test_score_student_grades_only_concrete_keys():
     grid = grid_from_dict(