Update src/app.py

src/app.py

@@ -9,6 +9,9 @@ import zipfile
 import tracker
 import rag_engine
 import doc_loader 
+# NEW IMPORT: Modular Admin
+import modules.admin_panel as admin_panel
+
 from openai import OpenAI
 from datetime import datetime
 from test_integration import run_tests
@@ -27,105 +30,77 @@ if "roles" not in st.session_state:
 
 if "quiz_state" not in st.session_state:
     st.session_state.quiz_state = {
-        "active": False,        # Is a question currently displayed?
-        "question_data": None,  # The current acronym/doc object
-        "user_answer": "",      # What the user typed
-        "feedback": None,       # The LLM's grading response
-        "streak": 0,            # Fun gamification metric
-        "generated_question_text": ""
+        "active": False, "question_data": None, "user_answer": "", 
+        "feedback": None, "streak": 0, "generated_question_text": ""
     }
 
-# NEW: Quiz History for Study Guide
-if "quiz_history" not in st.session_state:
-    st.session_state.quiz_history = []
+if "quiz_history" not in st.session_state: st.session_state.quiz_history = []
+if "active_index" not in st.session_state: st.session_state.active_index = None
 
-if "active_index" not in st.session_state:
-    st.session_state.active_index = None
+# NEW: Debug State Variables
+if "last_prompt_sent" not in st.session_state: st.session_state.last_prompt_sent = ""
+if "last_context_used" not in st.session_state: st.session_state.last_context_used = ""
 
-# --- FLATTENER LOGIC (Integrated) ---
+# --- HELPER FUNCTIONS ---
 class OutlineProcessor:
     """Parses text outlines for the Flattener tool."""
-    def __init__(self, file_content):
-        self.raw_lines = file_content.split('\n')
-    
-    def _is_list_item(self, line):
-        pattern = r"^\s*(\d+\.|[a-zA-Z]\.|-|\*)\s+"
-        return bool(re.match(pattern, line))
-
+    def __init__(self, file_content): self.raw_lines = file_content.split('\n')
+    def _is_list_item(self, line): return bool(re.match(r"^\s*(\d+\.|[a-zA-Z]\.|-|\*)\s+", line))
     def _merge_multiline_items(self):
         merged_lines = []
         for line in self.raw_lines:
             stripped = line.strip()
             if not stripped: continue
-            if not merged_lines:
-                merged_lines.append(line)
-                continue
-            if not self._is_list_item(line):
-                merged_lines[-1] = merged_lines[-1].rstrip() + " " + stripped
-            else:
-                merged_lines.append(line)
+            if not merged_lines: merged_lines.append(line); continue
+            if not self._is_list_item(line): merged_lines[-1] = merged_lines[-1].rstrip() + " " + stripped
+            else: merged_lines.append(line)
         return merged_lines
-
     def parse(self):
         clean_lines = self._merge_multiline_items()
-        stack = []
-        results = []
+        stack = []; results = []
         for line in clean_lines:
             stripped = line.strip()
             indent = len(line) - len(line.lstrip())
-            while stack and stack[-1]['indent'] >= indent:
-                stack.pop()
+            while stack and stack[-1]['indent'] >= indent: stack.pop()
             stack.append({'indent': indent, 'text': stripped})
-            if len(stack) > 1:
-                context_str = " > ".join([item['text'] for item in stack[:-1]])
-            else:
-                context_str = "ROOT"
+            context_str = " > ".join([item['text'] for item in stack[:-1]]) if len(stack) > 1 else "ROOT"
             results.append({"context": context_str, "target": stripped})
         return results
 
-# --- HELPER FUNCTIONS ---
 def query_model_universal(messages, max_tokens, model_choice, user_key=None):
     """Unified router for both Chat and Tools."""
+    # CAPTURE FOR DEBUGGING
+    # We grab the last user message as the "Prompt"
+    if messages and messages[-1]['role'] == 'user':
+        st.session_state.last_prompt_sent = messages[-1]['content']
+
     if "GPT-4o" in model_choice:
         key = user_key if user_key else OPENAI_KEY
         if not key: return "[Error: No OpenAI API Key]", None
-        
         client = OpenAI(api_key=key)
         try:
-            resp = client.chat.completions.create(
-                model="gpt-4o", max_tokens=max_tokens, messages=messages, temperature=0.3
-            )
+            resp = client.chat.completions.create(model="gpt-4o", max_tokens=max_tokens, messages=messages, temperature=0.3)
             usage = {"input": resp.usage.prompt_tokens, "output": resp.usage.completion_tokens}
             return resp.choices[0].message.content, usage
-        except Exception as e:
-            return f"[OpenAI Error: {e}]", None
+        except Exception as e: return f"[OpenAI Error: {e}]", None
     else:
-        model_map = {
-            "Granite 4 (IBM)": "granite4:latest",
-            "Llama 3.2 (Meta)": "llama3.2:latest",
-            "Gemma 3 (Google)": "gemma3:latest"
-        }
+        model_map = {"Granite 4 (IBM)": "granite4:latest", "Llama 3.2 (Meta)": "llama3.2:latest", "Gemma 3 (Google)": "gemma3:latest"}
         tech_name = model_map.get(model_choice)
         if not tech_name: return "[Error: Model Map Failed]", None
-        
         url = f"{API_URL_ROOT}/generate"
-        
-        hist = ""
-        sys_msg = "You are a helpful assistant."
+        hist = ""; sys_msg = "You are a helpful assistant."
         for m in messages:
             if m['role']=='system': sys_msg = m['content']
             elif m['role']=='user': hist += f"User: {m['content']}\n"
             elif m['role']=='assistant': hist += f"Assistant: {m['content']}\n"
         hist += "Assistant: "
-        
         try:
             r = requests.post(url, json={"text": hist, "persona": sys_msg, "max_tokens": max_tokens, "model": tech_name}, timeout=600)
             if r.status_code == 200:
                 d = r.json()
                 return d.get("response", ""), d.get("usage", {"input":0,"output":0})
             return f"[Local Error {r.status_code}]", None
-        except Exception as e:
-            return f"[Conn Error: {e}]", None
+        except Exception as e: return f"[Conn Error: {e}]", None
 
 def update_sidebar_metrics():
     if metric_placeholder:
@@ -134,15 +109,9 @@ def update_sidebar_metrics():
         metric_placeholder.metric("My Tokens Today", u_stats["input"] + u_stats["output"])
 
 def generate_study_guide_md(history):
-    """Converts quiz history to a Markdown string."""
-    md = "# ⚓ Study Guide\n\n"
-    md += f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n"
+    md = "# ⚓ Study Guide\n\nGenerated: " + datetime.now().strftime('%Y-%m-%d %H:%M') + "\n\n"
     for item in history:
-        md += f"## Q: {item['question']}\n"
-        md += f"**Your Answer:** {item['user_answer']}\n\n"
-        md += f"**Grade:** {item['grade']}\n\n"
-        md += f"**Context/Correct Info:**\n> {item['context']}\n\n"
-        md += "---\n\n"
+        md += f"## Q: {item['question']}\n**Your Answer:** {item['user_answer']}\n\n**Grade:** {item['grade']}\n\n**Context/Correct Info:**\n> {item['context']}\n\n---\n\n"
     return md
 
 # --- LOGIN ---
@@ -159,10 +128,8 @@ if "authentication_status" not in st.session_state or st.session_state["authenti
     with register_tab:
         st.header("Create Account")
         with st.form("reg_form"):
-            new_user = st.text_input("Username")
-            new_name = st.text_input("Display Name")
-            new_email = st.text_input("Email")
-            new_pwd = st.text_input("Password", type="password")
+            new_user = st.text_input("Username"); new_name = st.text_input("Display Name")
+            new_email = st.text_input("Email"); new_pwd = st.text_input("Password", type="password")
             invite = st.text_input("Invitation Passcode") 
             if st.form_submit_button("Register"):
                 success, msg = tracker.register_user(new_email, new_user, new_name, new_pwd, invite)
@@ -177,15 +144,12 @@ with st.sidebar:
     st.write(f"Welcome, **{st.session_state.name}**")
     st.header("📊 Usage Tracker")
     metric_placeholder = st.empty()
+    
+    # NEW: Modular Admin Integration
     if "admin" in st.session_state.roles:
-        st.divider()
-        st.header("🛡️ Admin Tools")
-        log_path = tracker.get_log_path()
-        if log_path.exists():
-            with open(log_path, "r") as f: log_data = f.read()
-            st.download_button("📥 Download Usage Logs", log_data, f"usage_log_{datetime.now().strftime('%Y-%m-%d')}.json", "application/json")
+        admin_panel.render_admin_sidebar()
+            
     st.divider()
-
     st.header("🌲 Pinecone Settings")
     pc_key = os.getenv("PINECONE_API_KEY")
     if pc_key:
@@ -193,39 +157,27 @@ with st.sidebar:
         indexes = pm.list_indexes()
         selected_index = st.selectbox("Active Index", indexes)
         st.session_state.active_index = selected_index
-        
-        # 2. SAFETY CHECK VISUAL (FIXED)
         if selected_index:
-            # Check if the user has already selected a model; default to MiniLM if not
             current_model = st.session_state.get("active_embed_model", "sentence-transformers/all-MiniLM-L6-v2")
             try:
                 emb_fn = rag_engine.get_embedding_func(current_model)
                 test_vec = emb_fn.embed_query("test")
                 active_model_dim = len(test_vec)
-                is_compatible = pm.check_dimension_compatibility(selected_index, active_model_dim)
-                if is_compatible:
-                    st.caption(f"✅ Compatible with Model ({active_model_dim}d)")
-                else:
-                    st.error(f"❌ Mismatch! Model is {active_model_dim}d, Index is not.")
-            except Exception as e:
-                st.caption(f"⚠️ Could not verify dims: {e}")
-        
+                if pm.check_dimension_compatibility(selected_index, active_model_dim): st.caption(f"✅ Compatible ({active_model_dim}d)")
+                else: st.error(f"❌ Mismatch! Model: {active_model_dim}d")
+            except Exception as e: st.caption(f"⚠️ Check failed: {e}")
         with st.expander("Create New Index"):
             new_idx_name = st.text_input("Index Name")
-            new_idx_dim = st.selectbox("Vector Dimension", [384, 768, 1024, 1536, 3072], index=0)
+            new_idx_dim = st.selectbox("Dimension", [384, 768, 1024, 1536, 3072], index=0)
             if st.button("Create"):
-                with st.spinner("Provisioning Cloud Index..."):
+                with st.spinner("Provisioning..."):
                     ok, msg = pm.create_index(new_idx_name, dimension=new_idx_dim)
-                    if ok: 
-                        st.success(msg)
-                        time.sleep(2)
-                        st.rerun()
+                    if ok: st.success(msg); time.sleep(2); st.rerun()
                     else: st.error(msg)
-    else:
-        st.warning("No Pinecone Key Found")
+    else: st.warning("No Pinecone Key")
     
     st.header("🧠 Intelligence")
-    st.subheader("1. Embeddings (The Memory)")
+    st.subheader("1. Embeddings")
     embed_options = {
         "Standard (All-MiniLM, 384d)": "sentence-transformers/all-MiniLM-L6-v2",
         "High-Perf (MPNet, 768d)": "sentence-transformers/all-mpnet-base-v2",
@@ -234,27 +186,17 @@ with st.sidebar:
     embed_choice_label = st.selectbox("Select Embedding Model", list(embed_options.keys()))
     st.session_state.active_embed_model = embed_options[embed_choice_label]
     
-    st.subheader("2. Chat Model (The Brain)")
-    model_map = {
-        "Granite 4 (IBM)": "granite4:latest", 
-        "Llama 3.2 (Meta)": "llama3.2:latest",
-        "Gemma 3 (Google)": "gemma3:latest"
-    }
+    st.subheader("2. Chat Model")
+    model_map = {"Granite 4 (IBM)": "granite4:latest", "Llama 3.2 (Meta)": "llama3.2:latest", "Gemma 3 (Google)": "gemma3:latest"}
     opts = list(model_map.keys())
-    model_captions = ["Slower, free, private" for _ in opts]
     is_admin = "admin" in st.session_state.roles
     user_key = None
     if not is_admin:
-        user_key = st.text_input("🔓 Unlock GPT-4o (Enter API Key)", type="password", key=f"key_{st.session_state.username}")
-        if user_key: 
-            st.session_state.user_openai_key = user_key
-            st.caption("✅ Key Active")
-        else: st.session_state.user_openai_key = None
+        user_key = st.text_input("Unlock GPT-4o", type="password")
+        st.session_state.user_openai_key = user_key if user_key else None
     else: st.session_state.user_openai_key = None
-    if is_admin or st.session_state.get("user_openai_key"):
-        opts.append("GPT-4o (Omni)")
-        model_captions.append("Fast, smart, sends data to OpenAI")
-    model_choice = st.radio("Select Model:", opts, captions=model_captions, key="model_selector_radio")
+    if is_admin or st.session_state.get("user_openai_key"): opts.append("GPT-4o (Omni)")
+    model_choice = st.radio("Select Model:", opts, key="model_selector_radio")
     st.info(f"Connected to: **{model_choice}**")
     st.divider()
     if st.session_state.authenticator: st.session_state.authenticator.logout(location='sidebar')
@@ -269,6 +211,10 @@ tab1, tab2, tab3 = st.tabs(["💬 Chat Playground", "📂 Knowledge & Tools", "
 with tab1:
     st.header("Discussion & Analysis")
     if "messages" not in st.session_state: st.session_state.messages = []
+    
+    # RENDER DEBUG OVERLAY (If enabled in Admin)
+    admin_panel.render_debug_overlay("Chat Tab")
+
     c1, c2 = st.columns([3, 1])
     with c1: st.caption(f"Active Model: **{st.session_state.get('model_selector_radio', 'Granite')}**")
     with c2: use_rag = st.toggle("Enable Knowledge Base", value=False)
@@ -279,6 +225,8 @@ with tab1:
         with st.chat_message("user"): st.markdown(prompt)
         context_txt = ""
         sys_p = "You are a helpful AI assistant."
+        st.session_state.last_context_used = "" # Reset context debug
+
         if use_rag:
             if not st.session_state.active_index: st.error("⚠️ Please select an Active Index in the sidebar first.")
             else:
@@ -290,19 +238,16 @@ with tab1:
                         embed_model_name=st.session_state.active_embed_model
                     )
                     if docs:
-                        sys_p = (
-                            "You are a Navy Document Analyst. "
-                            "You must answer the user's question based PRIMARILY on the provided Context. "
-                            "If the Context contains the answer, output it clearly. "
-                            "If the Context does NOT contain the answer, simply state: "
-                            "'I cannot find that specific information in the documents provided.'"
-                        )
+                        sys_p = "You are a Navy Document Analyst. Answer based PRIMARILY on the Context."
                         for i, d in enumerate(docs):
                             src = d.metadata.get('source', 'Unknown')
                             context_txt += f"<document index='{i+1}' source='{src}'>\n{d.page_content}\n</document>\n"
+                        # Debug Capture
+                        st.session_state.last_context_used = context_txt
         if context_txt:
             final_prompt = f"User Question: {prompt}\n\n<context>\n{context_txt}\n</context>\n\nInstruction: Answer using the context above."
         else: final_prompt = prompt
+        
         with st.chat_message("assistant"):
             with st.spinner("Thinking..."):
                 hist = [{"role":"system", "content":sys_p}] + st.session_state.messages[-6:-1] + [{"role":"user", "content":final_prompt}]
@@ -320,49 +265,40 @@ with tab1:
 with tab2:
     st.header("Document Processor")
     c1, c2 = st.columns([1, 1])
-    with c1: uploaded_file = st.file_uploader("Upload File (PDF, PPT, Doc, Text)", type=["pdf", "docx", "pptx", "txt", "md"])
+    with c1: uploaded_file = st.file_uploader("Upload File", type=["pdf", "docx", "pptx", "txt", "md"])
     with c2:
-        use_vision = st.toggle("👁️ Enable Vision Mode", help="Use GPT-4o to read diagrams/tables.")
-        if use_vision and "GPT-4o" not in opts: st.warning("Vision requires OpenAI Access.")
-
+        use_vision = st.toggle("👁️ Enable Vision Mode")
+        if use_vision and "GPT-4o" not in opts: st.warning("Vision requires OpenAI.")
     if uploaded_file:
         temp_path = rag_engine.save_uploaded_file(uploaded_file, st.session_state.username)
         col_a, col_b, col_c = st.columns(3)
         with col_a:
-            chunk_strategy = st.selectbox("Chunking Strategy", ["paragraph", "token"], key="chunk_selector")
-            if st.button("📥 Add to Knowledge Base", type="primary"):
-                if not st.session_state.active_index: st.error("Please select an Active Index.")
+            chunk_strategy = st.selectbox("Chunking Strategy", ["paragraph", "token"])
+            if st.button("📥 Add to KB", type="primary"):
+                if not st.session_state.active_index: st.error("Select Index first.")
                 else:
                     with st.spinner("Ingesting..."):
-                        ok, msg = rag_engine.ingest_file(
-                            file_path=temp_path, 
-                            username=st.session_state.username, 
-                            index_name=st.session_state.active_index,
-                            strategy=chunk_strategy,
-                            embed_model_name=st.session_state.active_embed_model
-                        )
-                        if ok: 
-                            tracker.upload_user_db(st.session_state.username)
-                            st.success(msg)
+                        ok, msg = rag_engine.ingest_file(temp_path, st.session_state.username, st.session_state.active_index, st.session_state.active_embed_model, chunk_strategy)
+                        if ok: tracker.upload_user_db(st.session_state.username); st.success(msg)
                         else: st.error(msg)
         with col_b:
             st.write(""); st.write("")
-            if st.button("📝 Summarize Document"):
-                with st.spinner("Reading..."):
+            if st.button("📝 Summarize"):
+                with st.spinner("Summarizing..."):
                     key = st.session_state.get("user_openai_key") or OPENAI_KEY
                     class FileObj:
                         def __init__(self, p, n): self.path=p; self.name=n
                         def read(self): 
                             with open(self.path, "rb") as f: return f.read()
                     raw = doc_loader.extract_text_from_file(FileObj(temp_path, uploaded_file.name), use_vision=use_vision, api_key=key)
-                    prompt = f"Summarize this document:\n\n{raw[:20000]}"
+                    prompt = f"Summarize:\n\n{raw[:20000]}"
                     msgs = [{"role":"user", "content": prompt}]
                     summ, usage = query_model_universal(msgs, 1000, model_choice, st.session_state.get("user_openai_key"))
-                    st.subheader("Summary Result"); st.markdown(summ)
+                    st.subheader("Summary"); st.markdown(summ)
         with col_c:
             st.write(""); st.write("")
             if "flattened_result" not in st.session_state: st.session_state.flattened_result = None
-            if st.button("📄 Flatten Context"):
+            if st.button("📄 Flatten"):
                 with st.spinner("Flattening..."):
                     key = st.session_state.get("user_openai_key") or OPENAI_KEY
                     with open(temp_path, "rb") as f:
@@ -370,232 +306,147 @@ with tab2:
                             def __init__(self, data, n): self.data=data; self.name=n
                             def read(self): return self.data
                         raw = doc_loader.extract_text_from_file(Wrapper(f.read(), uploaded_file.name), use_vision=use_vision, api_key=key)
-                    proc = OutlineProcessor(raw)
-                    items = proc.parse()
-                    out_txt = []
-                    bar = st.progress(0)
+                    proc = OutlineProcessor(raw); items = proc.parse()
+                    out_txt = []; bar = st.progress(0)
                     for i, item in enumerate(items):
                         p = f"Context: {item['context']}\nTarget: {item['target']}\nRewrite as one sentence."
                         m = [{"role":"user", "content": p}]
                         res, _ = query_model_universal(m, 300, model_choice, st.session_state.get("user_openai_key"))
-                        out_txt.append(res)
-                        bar.progress((i+1)/len(items))
+                        out_txt.append(res); bar.progress((i+1)/len(items))
                     final_flattened_text = "\n".join(out_txt)
                     st.session_state.flattened_result = {"text": final_flattened_text, "source": f"{uploaded_file.name}_flat"}
                     st.rerun()
             if st.session_state.flattened_result:
                 res = st.session_state.flattened_result
-                st.success("Flattening Complete!")
-                st.text_area("Result", res["text"], height=200)
-                if st.button("📥 Index This Flattened Version"):
-                    if not st.session_state.active_index: st.error("Please select an Active Index.")
+                st.success("Complete!"); st.text_area("Result", res["text"], height=200)
+                if st.button("📥 Index Flat"):
+                    if not st.session_state.active_index: st.error("Select Index.")
                     else:
                         with st.spinner("Indexing..."):
-                            ok, msg = rag_engine.process_and_add_text(
-                                text=res["text"], 
-                                source_name=res["source"], 
-                                username=st.session_state.username,
-                                index_name=st.session_state.active_index
-                            )
-                            if ok: 
-                                tracker.upload_user_db(st.session_state.username)
-                                st.success(msg)
+                            ok, msg = rag_engine.process_and_add_text(res["text"], res["source"], st.session_state.username, st.session_state.active_index)
+                            if ok: tracker.upload_user_db(st.session_state.username); st.success(msg)
                             else: st.error(msg)
     st.divider()
     st.subheader("Database Management")
-    col_db_1, col_db_2 = st.columns([2, 1])
-    with col_db_1: st.info("If Quiz Mode is failing, your local files might be missing.")
-    with col_db_2:
+    c1, c2 = st.columns([2, 1])
+    with c1: st.info("Missing local files? Resync below.")
+    with c2:
         if st.button("🔄 Resync from Pinecone"):
-            if not st.session_state.active_index: st.error("Select Index first.")
+            if not st.session_state.active_index: st.error("Select Index.")
             else:
-                with st.spinner("Downloading memories..."):
+                with st.spinner("Resyncing..."):
                     ok, msg = rag_engine.rebuild_cache_from_pinecone(st.session_state.username, st.session_state.active_index)
                     if ok: st.success(msg); time.sleep(1); st.rerun()
                     else: st.error(msg)
-    st.divider()
     docs = rag_engine.list_documents(st.session_state.username) 
     if docs:
         for d in docs:
             c1, c2 = st.columns([4,1])
-            c1.text(f"📄 {d['filename']} (Cached)")
+            c1.text(f"📄 {d['filename']}")
             if c2.button("🗑️", key=d['source']):
-                if not st.session_state.active_index: st.error("Select Index first.")
+                if not st.session_state.active_index: st.error("Select Index.")
                 else:
                     rag_engine.delete_document(st.session_state.username, d['source'], st.session_state.active_index)
-                    tracker.upload_user_db(st.session_state.username)
-                    st.rerun()
-    else: st.warning("Local Cache Empty. Click 'Resync' above if you have data in Pinecone.")
+                    tracker.upload_user_db(st.session_state.username); st.rerun()
+    else: st.warning("Cache Empty.")
 
 # === TAB 3: QUIZ MODE ===
 with tab3:
     st.header("⚓ Qualification Board Simulator")
     
-    # 1. MODE SELECTION & RESET LOGIC
-    col_mode, col_streak = st.columns([3, 1])
-    with col_mode:
-        quiz_mode = st.radio("Select Quiz Mode:", ["⚡ Acronym Lightning Round", "📖 Document Deep Dive"], horizontal=True)
+    # RENDER DEBUG OVERLAY (If enabled)
+    admin_panel.render_debug_overlay("Quiz Tab")
     
-    # New: Focus Topic Input
-    if "Document" in quiz_mode:
-        focus_topic = st.text_input("🎯 Focus Topic (Optional)", placeholder="e.g., PPBE, Shipyards, Radar...", help="Leave empty for random questions.")
-    else:
-        focus_topic = None
+    col_mode, col_streak = st.columns([3, 1])
+    with col_mode: quiz_mode = st.radio("Mode:", ["⚡ Acronym Lightning Round", "📖 Document Deep Dive"], horizontal=True)
+    if "Document" in quiz_mode: focus_topic = st.text_input("🎯 Focus Topic", placeholder="e.g., PPBE...", help="Leave empty for random.")
+    else: focus_topic = None
 
     if "last_quiz_mode" not in st.session_state: st.session_state.last_quiz_mode = quiz_mode
     if "quiz_trigger" not in st.session_state: st.session_state.quiz_trigger = False
-
     if st.session_state.last_quiz_mode != quiz_mode:
-        st.session_state.quiz_state["active"] = False
-        st.session_state.quiz_state["question_data"] = None
-        st.session_state.quiz_state["feedback"] = None
-        st.session_state.quiz_state["generated_question_text"] = ""
-        st.session_state.last_quiz_mode = quiz_mode
-        st.rerun()
+        st.session_state.quiz_state["active"] = False; st.session_state.quiz_state["question_data"] = None; st.session_state.quiz_state["feedback"] = None; st.session_state.quiz_state["generated_question_text"] = ""
+        st.session_state.last_quiz_mode = quiz_mode; st.rerun()
     
-    quiz = QuizEngine()
-    qs = st.session_state.quiz_state
-    
-    with col_streak:
-        st.metric("Streak", qs["streak"])
-        if st.button("Reset"): qs["streak"] = 0
-
-    # New: Study Guide Download
+    quiz = QuizEngine(); qs = st.session_state.quiz_state
+    with col_streak: st.metric("Streak", qs["streak"]); 
+    if st.button("Reset"): qs["streak"] = 0
     if st.session_state.quiz_history:
-        with st.expander(f"📚 Review Study Guide ({len(st.session_state.quiz_history)} items)"):
-            st.download_button(
-                "📥 Download Markdown", 
-                generate_study_guide_md(st.session_state.quiz_history), 
-                f"StudyGuide_{datetime.now().strftime('%Y%m%d')}.md"
-            )
-
+        with st.expander(f"📚 Review Study Guide ({len(st.session_state.quiz_history)})"):
+            st.download_button("📥 Download Markdown", generate_study_guide_md(st.session_state.quiz_history), f"StudyGuide_{datetime.now().strftime('%Y%m%d')}.md")
     st.divider()
 
     def generate_question():
-        with st.spinner("Consulting the Board..."):
+        with st.spinner("Consulting Board..."):
+            st.session_state.last_context_used = "" # Reset context debug
             if "Acronym" in quiz_mode:
                 q_data = quiz.get_random_acronym()
-                if q_data:
-                    qs["active"] = True; qs["question_data"] = q_data; qs["feedback"] = None; qs["generated_question_text"] = q_data["question"]
-                else: st.error("No acronyms found! Run the extractor first.")
+                if q_data: qs["active"]=True; qs["question_data"]=q_data; qs["feedback"]=None; qs["generated_question_text"]=q_data["question"]
+                else: st.error("No acronyms.")
             else:
-                valid_question_found = False
-                attempts = 0
-                last_error = None
-
+                valid_question_found = False; attempts = 0; last_error = None
                 while not valid_question_found and attempts < 5:
                     attempts += 1
                     q_ctx = quiz.get_document_context(st.session_state.username, topic_filter=focus_topic)
-                    
-                    # ERROR HANDLING SWITCH
-                    if q_ctx and "error" in q_ctx:
-                        last_error = q_ctx["error"]
-                        break # Stop trying, we know why it failed (e.g., Topic not found)
-                    
+                    if q_ctx and "error" in q_ctx: last_error = q_ctx["error"]; break
                     if q_ctx:
                         prompt = quiz.construct_question_generation_prompt(q_ctx["context_text"])
-                        question_text, usage = query_model_universal([{"role": "user", "content": prompt}], 300, model_choice, st.session_state.get("user_openai_key"))
+                        # DEBUG CAPTURE
+                        st.session_state.last_context_used = q_ctx["context_text"]
                         
+                        question_text, usage = query_model_universal([{"role": "user", "content": prompt}], 300, model_choice, st.session_state.get("user_openai_key"))
                         if "UNABLE" not in question_text and len(question_text) > 10:
-                            valid_question_found = True; qs["active"] = True; qs["question_data"] = q_ctx; qs["generated_question_text"] = question_text; qs["feedback"] = None
-                
+                            valid_question_found = True; qs["active"]=True; qs["question_data"]=q_ctx; qs["generated_question_text"]=question_text; qs["feedback"]=None
                 if not valid_question_found:
-                    # SPECIFIC USER FEEDBACK
-                    if last_error == "topic_not_found":
-                        st.warning(f"Could not find any documents containing the topic: **'{focus_topic}'**. \n\nCheck your spelling or try a broader term.")
-                    elif focus_topic: 
-                        st.warning(f"Found documents with '{focus_topic}', but the AI struggled to form a question. Try again or check the document content.")
-                    else: 
-                        st.warning("Could not generate a question. Your 'Knowledge & Tools' local cache might be empty or corrupted. \n\n**Try clicking '🔄 Resync from Pinecone' in Tab 2.**")
-
-    if st.session_state.quiz_trigger:
-        st.session_state.quiz_trigger = False
-        generate_question()
-        st.rerun()
+                    if last_error == "topic_not_found": st.warning(f"Topic '{focus_topic}' not found.")
+                    elif focus_topic: st.warning(f"Found '{focus_topic}' but could not generate question.")
+                    else: st.warning("Could not generate question. Try Resync.")
 
+    if st.session_state.quiz_trigger: st.session_state.quiz_trigger = False; generate_question(); st.rerun()
     if not qs["active"]:
-        if st.button("🚀 Generate New Question", type="primary"):
-            generate_question()
-            st.rerun()
+        if st.button("🚀 New Question", type="primary"): generate_question(); st.rerun()
 
     if qs["active"]:
         st.markdown(f"### {qs['generated_question_text']}")
         if "document" in qs.get("question_data", {}).get("type", ""): st.caption(f"Source: *{qs['question_data']['source_file']}*")
-        
         with st.form(key="quiz_response"):
-            user_ans = st.text_area("Your Answer:")
-            sub = st.form_submit_button("Submit Answer")
-            
+            user_ans = st.text_area("Answer:")
+            sub = st.form_submit_button("Submit")
         if sub and user_ans:
-            with st.spinner("Consulting the Knowledge Base & Grading..."):
+            with st.spinner("Grading..."):
                 data = qs["question_data"]
-                
-                # Grading Logic Branch
                 if data["type"] == "acronym":
-                    prompt = quiz.construct_acronym_grading_prompt(
-                        data["term"], data["correct_definition"], user_ans
-                    )
-                    # For acronyms, the context is just the definition
+                    prompt = quiz.construct_acronym_grading_prompt(data["term"], data["correct_definition"], user_ans)
                     final_context_for_history = data["correct_definition"]
-                
                 else:
-                    # --- RAG ENHANCEMENT START ---
-                    # 1. Start with the original seed text
-                    combined_context = f"--- PRIMARY SOURCE (SEED) ---\n{data['context_text']}\n\n"
-                    
-                    # 2. Search Pinecone for 5 more relevant chunks using the generated question
-                    # We check if index/model are active first
+                    combined_context = f"--- PRIMARY SOURCE ---\n{data['context_text']}\n\n"
+                    # RERANKED SEARCH INJECTION
                     if st.session_state.active_index and st.session_state.get("active_embed_model"):
                         try:
-                            # We search for K=10 and Rerank to Top 5 (or just take Top 5 if no reranker)
-                            # Using the helper function from rag_engine
                             related_docs = rag_engine.search_knowledge_base(
                                 query=qs["generated_question_text"], 
                                 username=st.session_state.username,
                                 index_name=st.session_state.active_index,
                                 embed_model_name=st.session_state.active_embed_model,
-                                k=15,       # Fetch a broad net
-                                final_k=5   # Narrow down to Top 5 most relevant
+                                k=15, final_k=5 # Broad retrieval + Rerank
                             )
-                            
                             if related_docs:
-                                combined_context += "--- RELATED DOCUMENTATION (RETRIEVED) ---\n"
-                                for i, doc in enumerate(related_docs):
-                                    combined_context += f"[Source {i+1}]: {doc.page_content}\n\n"
-                        except Exception as e:
-                            # If search fails, we just proceed with the primary source
-                            print(f"Grading Search Failed: {e}")
-                    
-                    # 3. Construct the Prompt with the super-context
-                    prompt = quiz.construct_grading_prompt(
-                        qs["generated_question_text"], user_ans, combined_context
-                    )
+                                combined_context += "--- RELATED ---\n"
+                                for i, doc in enumerate(related_docs): combined_context += f"[Source {i+1}]: {doc.page_content}\n\n"
+                        except Exception as e: print(f"Search failed: {e}")
                     
-                    # Save this rich context for the Study Guide
+                    prompt = quiz.construct_grading_prompt(qs["generated_question_text"], user_ans, combined_context)
                     final_context_for_history = combined_context
-                    # --- RAG ENHANCEMENT END ---
+                    # DEBUG CAPTURE FOR GRADING
+                    st.session_state.last_context_used = combined_context
 
-                # Call LLM
                 msgs = [{"role": "user", "content": prompt}]
-                grade, _ = query_model_universal(
-                    msgs, 1000, model_choice, st.session_state.get("user_openai_key")
-                )
-                
+                grade, _ = query_model_universal(msgs, 1000, model_choice, st.session_state.get("user_openai_key"))
                 qs["feedback"] = grade
-                
-                # Update Streak
                 is_pass = "PASS" in grade
                 if is_pass: qs["streak"] += 1
                 elif "FAIL" in grade: qs["streak"] = 0
-
-                # Save to History (Using the enhanced context!)
-                st.session_state.quiz_history.append({
-                    "question": qs["generated_question_text"],
-                    "user_answer": user_ans,
-                    "grade": "PASS" if is_pass else "FAIL",
-                    "context": final_context_for_history
-                })
-                
+                st.session_state.quiz_history.append({"question": qs["generated_question_text"], "user_answer": user_ans, "grade": "PASS" if is_pass else "FAIL", "context": final_context_for_history})
                 st.rerun()
 
     if qs["feedback"]:
@@ -603,15 +454,11 @@ with tab3:
         if "PASS" in qs["feedback"]: st.success("✅ CORRECT")
         else:
             if "FAIL" in qs["feedback"]: st.error("❌ INCORRECT")
-            else: st.warning("⚠️ PARTIAL / COMMENTARY")
+            else: st.warning("⚠️ PARTIAL")
         st.markdown(qs["feedback"])
-        
         data = qs["question_data"]
-        if data["type"] == "acronym": st.info(f"**Official Definition:** {data['correct_definition']}")
+        if data["type"] == "acronym": st.info(f"**Definition:** {data['correct_definition']}")
         elif data["type"] == "document":
-            with st.expander("Show Source Text (Answer Key)"): st.info(data["context_text"])
-        
+            with st.expander("Show Answer Key"): st.info(data["context_text"])
         if st.button("Next Question ➡️"):
-            st.session_state.quiz_trigger = True
-            qs["active"] = False; qs["question_data"] = None; qs["feedback"] = None
-            st.rerun()
+            st.session_state.quiz_trigger = True; qs["active"]=False; qs["question_data"]=None; qs["feedback"]=None; st.rerun()