Update src/streamlit_app.py

src/streamlit_app.py

@@ -7,6 +7,7 @@ import sqlite3
 import hashlib
 import uuid
 import base64
+from difflib import SequenceMatcher
 from datetime import datetime
 from typing import Dict, List, Any, Optional, Tuple
 
@@ -30,13 +31,10 @@ EMBED_PATH = os.path.join(BUILD_DIR, "embeddings.npy")
 CONFIG_PATH = os.path.join(BUILD_DIR, "config.json")
 QUESTION_BANK_FILE = os.path.join(BASE_DIR, "exam_questions_pmqs.json")
 LOGO_FILE = os.path.join(BASE_DIR, "logo.png")
-MEDICAL_IMAGE_DIR = os.path.join(BASE_DIR, "medical_images")
-IMAGE_MANIFEST_FILE = os.path.join(BASE_DIR, "medical_images_manifest.json")
-
 DB_PATH = os.getenv("BRAINCHAT_DB", "brainchat.db")
 OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
 OPENAI_IMAGE_MODEL = os.getenv("OPENAI_IMAGE_MODEL", "gpt-image-1")
-ENABLE_AI_IMAGES = os.getenv("ENABLE_AI_IMAGES", "false").lower() == "true"
+ENABLE_AI_IMAGES = os.getenv("ENABLE_AI_IMAGES", "true").lower() == "true"
 TEACHER_PASSWORD = os.getenv("TEACHER_PASSWORD", "teacher123")
 
 TOPICS = [
@@ -302,6 +300,19 @@ def init_db() -> None:
         )
     """)
 
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS feedback_rules (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            topic TEXT,
+            rule_text TEXT,
+            source_question_id TEXT,
+            decision_type TEXT,
+            created_by TEXT,
+            created_at TEXT,
+            active INTEGER DEFAULT 1
+        )
+    """)
+
     # Migrate older installations without deleting data.
     ensure_column(conn, "quiz_attempts", "source_refs_json", "TEXT")
     ensure_column(conn, "quiz_attempts", "source_mix_json", "TEXT")
@@ -685,14 +696,72 @@ def load_rejected_patterns(topic: str) -> List[Dict[str, Any]]:
 
 def is_rejected_or_too_similar(question: str, rejected: List[Dict[str, Any]]) -> bool:
     q_hash = question_hash(question)
+    normalised = normalise_question_text(question)
     for item in rejected:
+        rejected_question = item.get("question", "")
         if item.get("question_hash") == q_hash:
             return True
-        if token_jaccard(question, item.get("question", "")) >= 0.72:
+        if token_jaccard(question, rejected_question) >= 0.68:
+            return True
+        if SequenceMatcher(None, normalised, normalise_question_text(rejected_question)).ratio() >= 0.86:
             return True
     return False
 
 
+def load_feedback_rules(topic: str, limit: int = 30) -> List[Dict[str, Any]]:
+    conn = get_conn()
+    rows = conn.execute("""
+        SELECT id, topic, rule_text, source_question_id, decision_type, created_by, created_at
+        FROM feedback_rules
+        WHERE active=1 AND (topic=? OR topic='General Neurology')
+        ORDER BY created_at DESC
+        LIMIT ?
+    """, (topic, limit)).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def save_feedback_rule(
+    topic: str,
+    rule_text: str,
+    question_id: str,
+    decision_type: str,
+    reviewer: str,
+) -> None:
+    cleaned = re.sub(r"\s+", " ", (rule_text or "").strip())
+    if not cleaned:
+        return
+    conn = get_conn()
+    duplicate = conn.execute("""
+        SELECT id FROM feedback_rules
+        WHERE active=1 AND topic=? AND lower(rule_text)=lower(?)
+    """, (topic, cleaned)).fetchone()
+    if not duplicate:
+        conn.execute("""
+            INSERT INTO feedback_rules(
+                topic, rule_text, source_question_id, decision_type,
+                created_by, created_at, active
+            ) VALUES (?, ?, ?, ?, ?, ?, 1)
+        """, (topic, cleaned, question_id, decision_type, reviewer, now_iso()))
+        conn.commit()
+    conn.close()
+
+
+def load_generated_questions_df(limit: int = 500) -> pd.DataFrame:
+    conn = get_conn()
+    try:
+        return pd.read_sql_query("""
+            SELECT question_id, topic, difficulty, question, options_json,
+                   correct_option, explanation, subtopic, source_refs_json,
+                   status, created_at, student_id, language
+            FROM generated_questions
+            ORDER BY created_at DESC
+            LIMIT ?
+        """, conn, params=(limit,))
+    finally:
+        conn.close()
+
+
 def load_approved_questions(topic: str, difficulty: str, limit: int = 12) -> List[Dict[str, Any]]:
     conn = get_conn()
     rows = conn.execute("""
@@ -744,7 +813,7 @@ def create_question_review(
     reporter_id: str,
     issue_type: str,
     comment: str,
-) -> None:
+) -> bool:
     qid = question.get("question_id") or str(uuid.uuid4())
     conn = get_conn()
 
@@ -757,7 +826,8 @@ def create_question_review(
                 subtopic, source_refs_json, question_hash, status, created_at
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """, (
-            qid, reporter_id, "", question.get("topic", "General Neurology"), question.get("difficulty", "Any"),
+            qid, reporter_id, question.get("language", ""),
+            question.get("topic", "General Neurology"), question.get("difficulty", "Any"),
             question.get("question", ""), json.dumps(question.get("options", []), ensure_ascii=False),
             question.get("correct_option", "A"), question.get("explanation", ""),
             question.get("subtopic", ""), json.dumps(question.get("source_refs", []), ensure_ascii=False),
@@ -766,6 +836,15 @@ def create_question_review(
     else:
         conn.execute("UPDATE generated_questions SET status='flagged' WHERE question_id=?", (qid,))
 
+    pending = conn.execute("""
+        SELECT id FROM question_reviews
+        WHERE question_id=? AND review_status='pending'
+    """, (qid,)).fetchone()
+    if pending:
+        conn.commit()
+        conn.close()
+        return False
+
     conn.execute("""
         INSERT INTO question_reviews(
             question_id, reporter_type, reporter_id, issue_type,
@@ -774,6 +853,7 @@ def create_question_review(
     """, (qid, reporter_type, reporter_id, issue_type, comment, now_iso()))
     conn.commit()
     conn.close()
+    return True
 
 
 def load_pending_reviews() -> pd.DataFrame:
@@ -859,8 +939,33 @@ def approve_review(
         corrected_explanation, reviewer, now_iso(), review_id,
     ))
     conn.execute("UPDATE generated_questions SET status='approved' WHERE question_id=?", (question_id,))
+
+    original_changed = (
+        normalise_question_text(row["question"]) != normalise_question_text(corrected_question)
+        or row["correct_option"] != corrected_answer
+        or json.loads(row["options_json"] or "[]") != corrected_options
+        or (row["explanation"] or "").strip() != (corrected_explanation or "").strip()
+    )
+    if original_changed:
+        reason = professor_comment.strip() or "Original formulation replaced by a professor-corrected version."
+        duplicate = conn.execute("""
+            SELECT id FROM rejected_question_patterns
+            WHERE active=1 AND question_hash=?
+        """, (row["question_hash"],)).fetchone()
+        if not duplicate:
+            conn.execute("""
+                INSERT INTO rejected_question_patterns(
+                    question_id, topic, question, question_hash, reason,
+                    rejected_by, created_at, active
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, 1)
+            """, (
+                question_id, row["topic"], row["question"], row["question_hash"],
+                reason, reviewer, now_iso(),
+            ))
+
     conn.commit()
     conn.close()
+    save_feedback_rule(row["topic"], professor_comment, question_id, "approved_correction", reviewer)
 
 
 def reject_review(
@@ -875,15 +980,20 @@ def reject_review(
         conn.close()
         raise ValueError("Generated question not found.")
 
-    conn.execute("""
-        INSERT INTO rejected_question_patterns(
-            question_id, topic, question, question_hash, reason,
-            rejected_by, created_at, active
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, 1)
-    """, (
-        question_id, row["topic"], row["question"], row["question_hash"],
-        reason, reviewer, now_iso(),
-    ))
+    duplicate = conn.execute("""
+        SELECT id FROM rejected_question_patterns
+        WHERE active=1 AND question_hash=?
+    """, (row["question_hash"],)).fetchone()
+    if not duplicate:
+        conn.execute("""
+            INSERT INTO rejected_question_patterns(
+                question_id, topic, question, question_hash, reason,
+                rejected_by, created_at, active
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, 1)
+        """, (
+            question_id, row["topic"], row["question"], row["question_hash"],
+            reason, reviewer, now_iso(),
+        ))
     conn.execute("""
         UPDATE question_reviews SET
             professor_comment=?, review_status='rejected', reviewer=?, reviewed_at=?
@@ -893,6 +1003,8 @@ def reject_review(
     conn.execute("UPDATE approved_questions SET active=0 WHERE question_id=?", (question_id,))
     conn.commit()
     conn.close()
+    save_feedback_rule(row["topic"], reason, question_id, "rejected", reviewer)
+
 
 # =====================================================
 # AI HELPERS
@@ -978,6 +1090,7 @@ def generate_mcqs(
     approved = load_approved_questions(topic, difficulty, limit=n_questions)
     approved_items = [approved_to_quiz_item(x) for x in approved]
     rejected = load_rejected_patterns(topic)
+    feedback_rules = load_feedback_rules(topic)
 
     # Use some approved questions directly so professor corrections affect the next quiz immediately.
     final_questions = approved_items[: min(len(approved_items), max(1, n_questions // 2))]
@@ -1013,6 +1126,7 @@ def generate_mcqs(
         {"question": x.get("question", ""), "reason": x.get("reason", "")}
         for x in rejected[:10]
     ]
+    professor_rules = [x.get("rule_text", "") for x in feedback_rules if x.get("rule_text")]
 
     lang_instruction = "Write everything in English." if language == "English" else "Escribe todo en español."
     requested = needed + 4
@@ -1047,6 +1161,9 @@ Past exam-style examples:
 Rejected patterns and reasons:
 {json.dumps(rejected_guidance, ensure_ascii=False)[:5000]}
 
+Professor feedback rules learned from earlier reviews:
+{json.dumps(professor_rules, ensure_ascii=False)[:5000]}
+
 Course context:
 {context}
 """
@@ -1225,51 +1342,82 @@ Context:
         return "", source_refs, source_mix, str(exc)
 
 
-def generate_ai_medical_image(topic: str, depth_level: str, language: str) -> Tuple[Optional[bytes], Optional[str]]:
+def generate_ai_medical_image(
+    topic: str,
+    depth_level: str,
+    language: str,
+    visual_focus: str,
+    visual_style: str,
+) -> Tuple[Optional[bytes], List[Dict[str, Any]], Dict[str, float], str, Optional[str]]:
+    records, rag_error = search_hybrid(
+        f"{topic} {visual_focus} anatomy mechanism diagnosis educational illustration",
+        final_k=7,
+    )
+    source_refs = compact_source_refs(records)
+    source_mix = calculate_source_mix(records)
+    context = build_context(records)
+
+    if rag_error:
+        return None, source_refs, source_mix, "", rag_error
     if not ENABLE_AI_IMAGES:
-        return None, "AI image generation is disabled. Set ENABLE_AI_IMAGES=true to enable it."
+        return None, source_refs, source_mix, "", (
+            "AI image generation is disabled. Set ENABLE_AI_IMAGES=true to enable it."
+        )
+
     client = get_client()
     if client is None:
-        return None, "OPENAI_API_KEY is missing."
-
-    language_instruction = "English labels" if language == "English" else "Spanish labels"
-    prompt = (
-        f"Create a clean medical education illustration for {topic}, suitable for {depth_level.lower()} learners, "
-        f"with {language_instruction}. White background, simple labelled anatomy or mechanism, no decorative art, "
-        "no patient-identifying features, no treatment recommendation, and no exact dosage information. "
-        "The image must be clearly educational rather than diagnostic."
+        return None, source_refs, source_mix, "", "OPENAI_API_KEY is missing."
+
+    label_language = "English" if language == "English" else "Spanish"
+    focus = visual_focus.strip() or topic
+    brief_prompt = f"""
+You are preparing a source-grounded prompt for a medical education image generator.
+
+Topic: {topic}
+Requested focus: {focus}
+Learner level: {depth_level}
+Visual style: {visual_style}
+Label language: {label_language}
+
+Create one concise image-generation brief. Use only facts supported by the supplied course context.
+The image must be educational, uncluttered and medically cautious. Prefer a simplified labelled mechanism, anatomy overview or process illustration. Avoid exact medication doses, diagnostic certainty, photorealistic patients, identifiable people and decorative imagery. Use minimal text because image models may misspell labels. Do not include citations inside the image.
+
+Course context:
+{context}
+"""
+
+    try:
+        brief_response = client.chat.completions.create(
+            model=OPENAI_MODEL,
+            messages=[{"role": "user", "content": brief_prompt}],
+            temperature=0.10,
+        )
+        visual_brief = (brief_response.choices[0].message.content or "").strip()
+    except Exception:
+        visual_brief = (
+            f"Create a clean {visual_style.lower()} for {focus} within {topic}, suitable for "
+            f"{depth_level.lower()} medical learners, using {label_language} labels."
+        )
+
+    final_prompt = (
+        f"{visual_brief} White background, clear hierarchy, high-resolution educational medical illustration. "
+        "No patient-identifying features. No diagnosis claim. No exact dosage. No decorative border. "
+        "Use only a few large, legible labels. The output is an educational illustration, not a diagnostic image."
     )
+
     try:
         response = client.images.generate(
             model=OPENAI_IMAGE_MODEL,
-            prompt=prompt,
+            prompt=final_prompt,
             size="1024x1024",
         )
         item = response.data[0]
         if getattr(item, "b64_json", None):
-            return base64.b64decode(item.b64_json), None
-        return None, "The image API returned no image data."
+            return base64.b64decode(item.b64_json), source_refs, source_mix, visual_brief, None
+        return None, source_refs, source_mix, visual_brief, "The image API returned no image data."
     except Exception as exc:
-        return None, str(exc)
+        return None, source_refs, source_mix, visual_brief, str(exc)
 
-# =====================================================
-# MEDICAL IMAGE LIBRARY
-# =====================================================
-@st.cache_data(show_spinner=False)
-def load_image_manifest() -> List[Dict[str, Any]]:
-    if not os.path.exists(IMAGE_MANIFEST_FILE):
-        return []
-    try:
-        with open(IMAGE_MANIFEST_FILE, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        return data if isinstance(data, list) else []
-    except Exception:
-        return []
-
-
-def topic_images(topic: str) -> List[Dict[str, Any]]:
-    manifest = load_image_manifest()
-    return [x for x in manifest if x.get("topic") in [topic, "General Neurology"] and x.get("approved", False)]
 
 # =====================================================
 # BADGES AND REPORTS
@@ -1437,6 +1585,20 @@ def issue_options(language: str) -> List[str]:
         "Other",
     ]
 
+
+def professor_issue_options() -> List[str]:
+    return [
+        "Incorrect correct answer",
+        "Ambiguous wording",
+        "More than one defensible answer",
+        "Weak or implausible distractors",
+        "Incorrect or incomplete explanation",
+        "Unsupported by Neurology Guiones",
+        "Wrong difficulty level",
+        "Duplicate or near-duplicate question",
+        "Other",
+    ]
+
 # =====================================================
 # STUDENT MODE
 # =====================================================
@@ -1468,7 +1630,6 @@ def student_mode() -> None:
                     "Structured outline",
                     "Concept map",
                     "Clinical decision pathway",
-                    "Approved medical images",
                     "AI-generated educational image",
                 ]
             else:
@@ -1480,7 +1641,6 @@ def student_mode() -> None:
                     "Esquema estructurado",
                     "Mapa conceptual",
                     "Ruta de decisión clínica",
-                    "Imágenes médicas aprobadas",
                     "Imagen educativa generada por IA",
                 ]
             tutor_activity = st.selectbox(t("activity"), activities)
@@ -1488,35 +1648,40 @@ def student_mode() -> None:
         free_question = tutor_activity in ["Free question", "Pregunta libre"]
         q = st.text_area(t("ask_question"), height=120) if free_question else ""
 
-        if tutor_activity in ["Approved medical images", "Imágenes médicas aprobadas"]:
-            images = topic_images(topic)
-            if not images:
-                st.info(
-                    "No approved images are registered for this topic. Add files to src/medical_images and update src/medical_images_manifest.json."
-                )
-            for image in images:
-                image_path = os.path.join(MEDICAL_IMAGE_DIR, image.get("file", ""))
-                if os.path.exists(image_path):
-                    st.image(image_path, caption=image.get("caption", "Approved educational image"), use_container_width=True)
-                    st.caption(
-                        f"Source: {image.get('source', 'Not specified')} | "
-                        f"Licence: {image.get('license', 'Not specified')} | "
-                        f"Approved by: {image.get('approved_by', 'Professor')}"
-                    )
-                else:
-                    st.warning(f"Image file not found: {image_path}")
-
-        elif tutor_activity in ["AI-generated educational image", "Imagen educativa generada por IA"]:
+        if tutor_activity in ["AI-generated educational image", "Imagen educativa generada por IA"]:
             st.warning(
-                "AI-generated educational illustration. It must not be used for diagnosis or exact anatomical measurement. Professor review is recommended."
+                "AI-generated educational illustration. It may contain inaccuracies and must not be used for diagnosis or exact anatomical measurement."
+                if st.session_state["language"] == "English"
+                else "Ilustración educativa generada por IA. Puede contener inexactitudes y no debe utilizarse para diagnóstico ni mediciones anatómicas exactas."
+            )
+            visual_focus = st.text_input(
+                "What should the image show?" if st.session_state["language"] == "English"
+                else "¿Qué debe mostrar la imagen?",
+                value=topic,
+                key="ai_visual_focus",
+            )
+            visual_style = st.selectbox(
+                "Image format" if st.session_state["language"] == "English" else "Formato de imagen",
+                ["Labelled medical illustration", "Mechanism diagram", "Clinical infographic"],
+                key="ai_visual_style",
             )
             if st.button("Generate educational image", key="generate_ai_image"):
-                with st.spinner("Generating educational illustration..."):
-                    image_bytes, image_error = generate_ai_medical_image(topic, depth_level, st.session_state["language"])
+                with st.spinner("Generating source-grounded educational illustration..."):
+                    image_bytes, refs, mix, visual_brief, image_error = generate_ai_medical_image(
+                        topic, depth_level, st.session_state["language"], visual_focus, visual_style
+                    )
                 if image_error:
                     st.error(image_error)
                 elif image_bytes:
-                    st.image(image_bytes, caption=f"AI-generated educational illustration: {topic}", use_container_width=True)
+                    st.image(
+                        image_bytes,
+                        caption=f"AI-generated educational illustration: {visual_focus}",
+                        use_container_width=True,
+                    )
+                    with st.expander("Image-generation brief", expanded=False):
+                        st.write(visual_brief)
+                    display_source_mix(mix)
+                    display_sources(refs)
 
         elif tutor_activity in ["Concept map", "Mapa conceptual", "Clinical decision pathway", "Ruta de decisión clínica"]:
             visual_type = "concept map" if tutor_activity in ["Concept map", "Mapa conceptual"] else "clinical decision pathway"
@@ -1650,8 +1815,11 @@ def student_mode() -> None:
                             key=f"comment_{item.get('question_id', i)}",
                         )
                         if st.button("Send to professor", key=f"flag_{item.get('question_id', i)}"):
-                            create_question_review(item, "student", sid, issue_type, comment)
-                            st.success("Question sent for professor review.")
+                            created = create_question_review(item, "student", sid, issue_type, comment)
+                            if created:
+                                st.success("Question sent for professor review.")
+                            else:
+                                st.info("This question is already waiting for professor review.")
 
                 display_source_mix(st.session_state.get("quiz_source_mix", {}))
                 display_sources(st.session_state.get("quiz_source_refs", []))
@@ -1686,115 +1854,220 @@ def student_mode() -> None:
 # TEACHER MODE
 # =====================================================
 def render_question_review_tab() -> None:
-    st.subheader("Professor Question Review")
+    st.subheader("Human-in-the-loop Question Improvement")
     st.caption(
-        "Corrections are stored in the approved question bank. Rejected questions are blocked by exact and similarity checks in future generation."
+        "A professor can flag any generated question, correct and approve it, or reject it. "
+        "Approved corrections become trusted examples. Rejected questions and professor rules are used to block similar future errors."
     )
 
     reviewer = st.text_input("Reviewer name", value=st.session_state.get("reviewer_name", "Professor"))
     st.session_state["reviewer_name"] = reviewer
-    pending = load_pending_reviews()
-
-    c1, c2, c3 = st.columns(3)
-    c1.metric("Pending reviews", len(pending))
 
+    pending = load_pending_reviews()
     conn = get_conn()
     approved_count = conn.execute("SELECT COUNT(*) FROM approved_questions WHERE active=1").fetchone()[0]
     rejected_count = conn.execute("SELECT COUNT(*) FROM rejected_question_patterns WHERE active=1").fetchone()[0]
+    rule_count = conn.execute("SELECT COUNT(*) FROM feedback_rules WHERE active=1").fetchone()[0]
     conn.close()
+
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Pending reviews", len(pending))
     c2.metric("Approved questions", approved_count)
     c3.metric("Rejected patterns", rejected_count)
+    c4.metric("Professor rules", rule_count)
 
-    if pending.empty:
-        st.success("No pending question reviews.")
-    else:
-        review_labels = [
-            f"#{int(row.review_id)} | {row.topic} | {str(row.question)[:75]}"
-            for row in pending.itertuples()
-        ]
-        selected_label = st.selectbox("Select review", review_labels)
-        selected_index = review_labels.index(selected_label)
-        row = pending.iloc[selected_index]
-
-        options = json.loads(row["options_json"] or "[]")
-        source_refs = json.loads(row["source_refs_json"] or "[]")
-
-        st.markdown(f"### Original question\n{row['question']}")
-        st.write("Original options:")
-        for option in options:
-            st.write(option)
-        st.markdown(f"**Current correct answer:** {row['correct_option']}")
-        st.markdown(f"**Current explanation:** {row['explanation']}")
-        st.warning(f"Reported issue: {row['issue_type']} — {row['reporter_comment'] or 'No comment provided'}")
-        display_sources(source_refs)
-
-        st.markdown("### Professor correction")
-        corrected_question = st.text_area(
-            "Corrected question", value=row["question"], key=f"corrected_q_{row['review_id']}"
-        )
+    pending_tab, history_tab, memory_tab = st.tabs([
+        "Pending Corrections", "Generated Question History", "Learning Memory"
+    ])
 
-        corrected_options = []
-        for i in range(5):
-            default = options[i] if i < len(options) else f"{chr(65+i)}. "
-            corrected_options.append(
-                st.text_input(
-                    f"Option {chr(65+i)}", value=default,
-                    key=f"corrected_opt_{row['review_id']}_{i}",
-                )
+    with pending_tab:
+        if pending.empty:
+            st.success("No pending question reviews.")
+        else:
+            review_labels = [
+                f"#{int(row.review_id)} | {row.topic} | {str(row.question)[:75]}"
+                for row in pending.itertuples()
+            ]
+            selected_label = st.selectbox("Select review", review_labels, key="pending_review_select")
+            selected_index = review_labels.index(selected_label)
+            row = pending.iloc[selected_index]
+
+            options = json.loads(row["options_json"] or "[]")
+            source_refs = json.loads(row["source_refs_json"] or "[]")
+
+            st.markdown(f"### Original question\n{row['question']}")
+            st.write("Original options:")
+            for option in options:
+                st.write(option)
+            st.markdown(f"**Current correct answer:** {row['correct_option']}")
+            st.markdown(f"**Current explanation:** {row['explanation']}")
+            st.warning(
+                f"Reported by {row['reporter_type']}: {row['issue_type']} — "
+                f"{row['reporter_comment'] or 'No comment provided'}"
             )
+            display_sources(source_refs)
 
-        answer_index = "ABCDE".find(str(row["correct_option"]).upper())
-        corrected_answer = st.selectbox(
-            "Correct answer", list("ABCDE"), index=max(answer_index, 0),
-            key=f"corrected_answer_{row['review_id']}",
-        )
-        corrected_explanation = st.text_area(
-            "Corrected explanation", value=row["explanation"],
-            key=f"corrected_exp_{row['review_id']}",
-        )
-        professor_comment = st.text_area(
-            "Professor comment", key=f"prof_comment_{row['review_id']}"
-        )
+            st.markdown("### Professor correction")
+            corrected_question = st.text_area(
+                "Corrected question", value=row["question"], key=f"corrected_q_{row['review_id']}"
+            )
+            corrected_options = []
+            for i in range(5):
+                default = options[i] if i < len(options) else f"{chr(65+i)}. "
+                corrected_options.append(
+                    st.text_input(
+                        f"Option {chr(65+i)}", value=default,
+                        key=f"corrected_opt_{row['review_id']}_{i}",
+                    )
+                )
 
-        b1, b2 = st.columns(2)
-        with b1:
-            if st.button("Correct and approve", type="primary", key=f"approve_{row['review_id']}"):
-                if not corrected_question.strip() or any(not x.strip() for x in corrected_options):
-                    st.error("Question and all five options are required.")
-                else:
-                    approve_review(
-                        int(row["review_id"]), row["question_id"], reviewer or "Professor",
-                        professor_comment, corrected_question, corrected_options,
-                        corrected_answer, corrected_explanation,
+            answer_index = "ABCDE".find(str(row["correct_option"]).upper())
+            corrected_answer = st.selectbox(
+                "Correct answer", list("ABCDE"), index=max(answer_index, 0),
+                key=f"corrected_answer_{row['review_id']}",
+            )
+            corrected_explanation = st.text_area(
+                "Corrected explanation", value=row["explanation"],
+                key=f"corrected_exp_{row['review_id']}",
+            )
+            professor_comment = st.text_area(
+                "Professor rule or reason",
+                placeholder="Example: Avoid absolute wording such as 'always'; treatment depends on seizure type and contraindications.",
+                key=f"prof_comment_{row['review_id']}",
+            )
+            st.caption(
+                "This comment is saved as a reusable rule for future question generation. "
+                "Use a general instruction, not only a description of this single question."
+            )
+
+            b1, b2 = st.columns(2)
+            with b1:
+                if st.button("Correct and approve", type="primary", key=f"approve_{row['review_id']}"):
+                    if not corrected_question.strip() or any(not x.strip() for x in corrected_options):
+                        st.error("Question and all five options are required.")
+                    else:
+                        approve_review(
+                            int(row["review_id"]), row["question_id"], reviewer or "Professor",
+                            professor_comment, corrected_question, corrected_options,
+                            corrected_answer, corrected_explanation,
+                        )
+                        st.success("Correction approved. Future quizzes will use it as a trusted example.")
+                        st.rerun()
+            with b2:
+                if st.button("Reject and block pattern", key=f"reject_{row['review_id']}"):
+                    reason = professor_comment or row["issue_type"] or "Rejected by professor"
+                    reject_review(
+                        int(row["review_id"]), row["question_id"],
+                        reviewer or "Professor", reason,
                     )
-                    st.success("Correction approved and added to the approved question bank.")
+                    st.success("Question rejected. Its question pattern and professor rule are now blocked in future generation.")
                     st.rerun()
-        with b2:
-            if st.button("Reject and block pattern", key=f"reject_{row['review_id']}"):
-                reason = professor_comment or row["issue_type"] or "Rejected by professor"
-                reject_review(
-                    int(row["review_id"]), row["question_id"],
-                    reviewer or "Professor", reason,
+
+    with history_tab:
+        st.markdown("### Professor direct flagging")
+        st.caption(
+            "Use this screen to flag a poorly formulated question even when no student has reported it."
+        )
+        history = load_generated_questions_df()
+        if history.empty:
+            st.info("No generated questions have been stored yet.")
+        else:
+            f1, f2 = st.columns(2)
+            with f1:
+                topic_filter = st.selectbox(
+                    "Filter topic", ["All"] + TOPICS, key="history_topic_filter"
+                )
+            with f2:
+                status_values = sorted(history["status"].fillna("unreviewed").unique().tolist())
+                status_filter = st.selectbox(
+                    "Filter status", ["All"] + status_values, key="history_status_filter"
                 )
-                st.success("Question rejected. Its pattern will be blocked in future generation.")
-                st.rerun()
 
-    st.divider()
-    st.subheader("Approved Question Bank")
-    conn = get_conn()
-    approved_df = pd.read_sql_query(
-        "SELECT id, question_id, topic, difficulty, question, correct_option, approved_by, approved_at, active FROM approved_questions ORDER BY approved_at DESC",
-        conn,
-    )
-    rejected_df = pd.read_sql_query(
-        "SELECT id, topic, question, reason, rejected_by, created_at, active FROM rejected_question_patterns ORDER BY created_at DESC",
-        conn,
-    )
-    conn.close()
+            filtered = history.copy()
+            if topic_filter != "All":
+                filtered = filtered[filtered["topic"] == topic_filter]
+            if status_filter != "All":
+                filtered = filtered[filtered["status"] == status_filter]
+
+            if filtered.empty:
+                st.info("No questions match the selected filters.")
+            else:
+                labels = [
+                    f"{r.created_at} | {r.topic} | {r.status} | {str(r.question)[:80]}"
+                    for r in filtered.itertuples()
+                ]
+                chosen = st.selectbox("Select generated question", labels, key="history_question_select")
+                row = filtered.iloc[labels.index(chosen)]
+                options = json.loads(row["options_json"] or "[]")
+                refs = json.loads(row["source_refs_json"] or "[]")
+
+                st.markdown(f"### {row['question']}")
+                for option in options:
+                    st.write(option)
+                st.markdown(f"**Correct answer:** {row['correct_option']}")
+                st.markdown(f"**Explanation:** {row['explanation']}")
+                st.caption(
+                    f"Topic: {row['topic']} | Difficulty: {row['difficulty']} | Status: {row['status']}"
+                )
+                display_sources(refs)
+
+                issue = st.selectbox(
+                    "Why is this question poor?", professor_issue_options(),
+                    key="professor_direct_issue",
+                )
+                comment = st.text_area(
+                    "Initial correction note",
+                    placeholder="Describe the error and the quality rule that future questions should follow.",
+                    key="professor_direct_comment",
+                )
+                if st.button("Flag for correction", type="primary", key="professor_direct_flag"):
+                    item = {
+                        "question_id": row["question_id"],
+                        "topic": row["topic"],
+                        "difficulty": row["difficulty"],
+                        "language": row["language"],
+                        "question": row["question"],
+                        "options": options,
+                        "correct_option": row["correct_option"],
+                        "explanation": row["explanation"],
+                        "subtopic": row["subtopic"],
+                        "source_refs": refs,
+                    }
+                    created = create_question_review(
+                        item, "professor", reviewer or "Professor", issue, comment
+                    )
+                    if created:
+                        st.success("Question added to Pending Corrections.")
+                    else:
+                        st.info("This question is already waiting for review.")
+
+    with memory_tab:
+        st.markdown("### Supervised learning memory")
+        st.info(
+            "This is immediate human-in-the-loop learning through retrieval and filtering, not automatic model fine-tuning. "
+            "Approved questions are reused directly and as examples; rejected questions are blocked; professor comments become generation rules."
+        )
+        conn = get_conn()
+        approved_df = pd.read_sql_query(
+            "SELECT id, question_id, topic, difficulty, question, correct_option, approved_by, approved_at, active FROM approved_questions ORDER BY approved_at DESC",
+            conn,
+        )
+        rejected_df = pd.read_sql_query(
+            "SELECT id, topic, question, reason, rejected_by, created_at, active FROM rejected_question_patterns ORDER BY created_at DESC",
+            conn,
+        )
+        rules_df = pd.read_sql_query(
+            "SELECT id, topic, rule_text, decision_type, created_by, created_at, active FROM feedback_rules ORDER BY created_at DESC",
+            conn,
+        )
+        conn.close()
 
-    st.dataframe(approved_df, use_container_width=True)
-    with st.expander("Rejected question memory"):
+        st.markdown("#### Approved question bank")
+        st.dataframe(approved_df, use_container_width=True)
+        st.markdown("#### Rejected question memory")
         st.dataframe(rejected_df, use_container_width=True)
+        st.markdown("#### Professor feedback rules")
+        st.dataframe(rules_df, use_container_width=True)
 
 
 def teacher_mode() -> None:
@@ -1875,12 +2148,25 @@ The source boost is applied only when a passage meets a minimum semantic-relevan
         )
         st.code(json.dumps(SOURCE_PRIORITY, indent=2), language="json")
 
-        images = load_image_manifest()
-        st.metric("Approved image records", len([x for x in images if x.get("approved")]))
-        if images:
-            st.dataframe(pd.DataFrame(images), use_container_width=True)
-        else:
-            st.info("No image manifest records found. Use src/medical_images_manifest.json.")
+        st.markdown("### AI-generated visual content")
+        c1, c2 = st.columns(2)
+        c1.metric("AI image generation", "Enabled" if ENABLE_AI_IMAGES else "Disabled")
+        c2.metric("Image model", OPENAI_IMAGE_MODEL)
+        st.caption(
+            "No medical image folder or manifest is required. Each AI image request is prepared from retrieved course passages and displayed with its supporting-source composition."
+        )
+
+        st.markdown("### Question-learning protocol")
+        st.markdown(
+            """
+1. A student or professor flags a question.
+2. The professor corrects and approves it, or rejects it.
+3. Corrected questions enter the approved bank and are reused directly and as examples.
+4. Rejected questions are blocked through exact-hash, word-overlap and near-text similarity checks.
+5. Professor comments become reusable generation rules.
+6. The original formulation is blocked whenever the professor replaces or materially corrects it.
+"""
+        )
 
         st.markdown("### RAG build status")
         missing = [p for p in [CHUNKS_PATH, TOKENS_PATH, EMBED_PATH, CONFIG_PATH] if not os.path.exists(p)]