Update src/reasoning_panel.py

src/reasoning_panel.py

@@ -6,62 +6,94 @@ from typing import Dict, List
 import streamlit as st
 
 
+def _render_popover_for_item(
+    label: str,
+    ref_nums: List[int],
+    registry: List[Dict[str, object]],
+) -> None:
+    """Render an expander with top‑K evidence for a single bullet."""
+    if not ref_nums:
+        return
+    with st.expander(label, expanded=False):
+        for n in ref_nums:
+            rec = next((r for r in registry if int(r.get("n", r.get("rank", -1))) == int(n)), None)
+            if not rec:
+                continue
+            title = f"[{n}] {rec.get('doc_name','')} — p.{rec.get('page',0)} | score {float(rec.get('score',0.0)):.3f}"
+            st.markdown(f"**{title}**")
+            st.write(rec.get("text", ""))
+            if rec.get("source_path"):
+                st.caption(rec["source_path"])
+
+
 def _bullets_html(items: List[str]) -> str:
-    """
-    Render a list of strings as a markdown bullet list.
-    Items may include HTML <sup>...</sup> markers for citations.
-    """
     if not items:
         return "_(none)_"
-    lines = [f"- {s}" for s in items]
-    return "\n".join(lines)
+    return "\n".join([f"- {s}" for s in items])
 
 
 def build_panel_data(result: Dict[str, object]) -> Dict[str, object]:
     """
-    Build a minimal data bundle from ai_core.GenerationResult as a plain dict
-    suitable for rendering in Streamlit. This function is intentionally light-weight.
+    Extract renderable data from ai_core.GenerationResult->dict.
     """
-    soap = result.get("soap", {}) if isinstance(result, dict) else {}
     meta = result.get("meta", {}) if isinstance(result, dict) else {}
-    citations = result.get("citations", []) if isinstance(result, dict) else []
-
     annotated = meta.get("annotated", {}) if isinstance(meta, dict) else {}
+    claim_mapping = meta.get("claim_mapping", {}) if isinstance(meta, dict) else {}
+
     assess_html = annotated.get("assessment_html", []) if isinstance(annotated, dict) else []
     plan_html = annotated.get("plan_html", []) if isinstance(annotated, dict) else []
 
+    assess_map_items = claim_mapping.get("assessment", {}).get("items", []) if isinstance(claim_mapping, dict) else []
+    plan_map_items = claim_mapping.get("plan", {}).get("items", []) if isinstance(claim_mapping, dict) else []
+
     return {
         "assessment_html": assess_html,
         "plan_html": plan_html,
-        "citations": citations,
+        "assessment_map": assess_map_items,
+        "plan_map": plan_map_items,
+        "citations": result.get("citations", []),
         "timings": meta.get("timings", {}),
+        "map_mode": meta.get("map_mode", "production"),
+        "registry_cap": meta.get("registry_cap", None),
     }
 
 
 def render_reasoning_panel(panel_data: Dict[str, object]) -> None:
     """
-    Render annotated bullets and consolidated evidence registry.
+    Render annotated bullets with per‑bullet popovers and global evidence registry.
     """
     st.subheader("Reasoning & Evidence")
 
-    # Annotated sections
+    timings = panel_data.get("timings", {})
+    map_mode = panel_data.get("map_mode", "production")
+    cap = panel_data.get("registry_cap", None)
+    st.caption(f"Evidence mode: **{map_mode}**" + (f"  |  registry cap: {cap}" if cap else ""))
+
+    registry = panel_data.get("citations", [])
+
     col1, col2 = st.columns(2)
     with col1:
         st.markdown("**Assessment (annotated)**")
         st.markdown(_bullets_html(panel_data.get("assessment_html", [])), unsafe_allow_html=True)
+        # Popovers per assessment bullet
+        for i, it in enumerate(panel_data.get("assessment_map", []), start=1):
+            _render_popover_for_item(f"[?] Evidence for Assessment #{i}", it.get("ref_nums", []), registry)
+
     with col2:
         st.markdown("**Plan (annotated)**")
         st.markdown(_bullets_html(panel_data.get("plan_html", [])), unsafe_allow_html=True)
+        # Popovers per plan bullet
+        for i, it in enumerate(panel_data.get("plan_map", []), start=1):
+            _render_popover_for_item(f"[?] Evidence for Plan #{i}", it.get("ref_nums", []), registry)
 
-    # Evidence registry
     st.markdown("---")
     st.markdown("**Evidence Registry** (global refs)")
-    citations = panel_data.get("citations", [])
-    if not citations:
+
+    if not registry:
         st.caption("No evidence available. Build the FAISS index in Step 1 to enable mapping.")
         return
 
-    for r in citations:
+    for r in registry:
         with st.container(border=True):
             n = r.get("n", r.get("rank", "?"))
             doc = r.get("doc_name", "")
@@ -73,6 +105,10 @@ def render_reasoning_panel(panel_data: Dict[str, object]) -> None:
             if sp:
                 st.caption(sp)
 
+    if isinstance(timings, dict):
+        st.caption(f"Timings: {timings}")
+
+