feat: enhance session summary UI and streamline headache logging with guided wizard steps.

README.md

@@ -89,6 +89,15 @@ Copy `.env.example` to `.env` and configure:
 | `API_TOKEN`                  | No       | Bearer token for LAN deployments                                                   |
 | `LANGSMITH_API_KEY`          | No       | For LangGraph tracing (free at [smith.langchain.com](https://smith.langchain.com)) |
 
+## Privacy & Data
+
+Mini Minder stores all health data **locally** in an unencrypted SQLite file (`mini_minder.db`). No data is sent to a remote database.
+
+**Text pipelines** — Session summaries, memory notes, appointment exports, and health-history queries are redacted by [`pii_guard.py`](src/reachy_mini_conversation_app/pii_guard.py) before reaching any cloud LLM. Names are replaced with roles (e.g. _"the patient"_) and medication names are replaced with symptom categories (e.g. _"migraine prevention medication"_).
+
+> [!IMPORTANT]
+> **Audio gap:** Microphone audio is streamed directly to the OpenAI Realtime API as raw PCM frames. There is no way to redact speech before it leaves the device. If the user speaks their name, medication names, or other sensitive details aloud, OpenAI's servers will receive that audio. OpenAI's [API data usage policy](https://openai.com/policies/api-data-usage-policies) states that API inputs are not used for model training, but the audio does traverse their infrastructure. Eliminating this gap would require switching to a local speech-to-text model.
+
 ## Knowledge Graph (Optional)
 
 For cross-session memory (entity extraction, relationship tracking), you can connect a Neo4j graph database via Docker:

frontend/src/components/ComponentOverlay.tsx

@@ -11,7 +11,7 @@ interface ComponentOverlayProps {
 }
 
 // Components that render full-screen (TV-distance readable)
-const FULLSCREEN_COMPONENTS = new Set(["HeadacheLog", "MedLog"]);
+const FULLSCREEN_COMPONENTS = new Set(["HeadacheLog", "MedLog", "SessionSummary"]);
 
 export function ComponentOverlay({ component, onDismiss }: ComponentOverlayProps) {
   const isFullscreen = FULLSCREEN_COMPONENTS.has(component.name);
@@ -39,7 +39,7 @@ export function ComponentOverlay({ component, onDismiss }: ComponentOverlayProps
     if (isSessionSummary) {
       const timer = setTimeout(() => {
         onDismiss();
-      }, 15000);
+      }, 5000);
       return () => clearTimeout(timer);
     }
   }, [component, onDismiss]);

frontend/src/components/DashboardGrid.tsx

@@ -68,7 +68,7 @@ export function DashboardGrid({ isSessionActive, isConnected, userName, showCame
         {/* Quick Stats - 1x1 */}
         <QuickStatsCard 
           daysActive={stats.days_active_this_week ?? 0}
-          headachesThisWeek={stats.headaches.filter(h => h.intensity > 0).length}
+          headachesThisWeek={stats.headaches.reduce((sum, h) => sum + (h.count ?? (h.intensity > 0 ? 1 : 0)), 0)}
           isLoading={isLoading}
           hasData={stats.profile.onboarding_completed}
         />
@@ -83,7 +83,7 @@ export function DashboardGrid({ isSessionActive, isConnected, userName, showCame
           onboardingCompleted={stats.profile.onboarding_completed}
           medicationTaken={stats.medication.taken}
           medicationTotal={stats.medication.total}
-          headachesToday={stats.headaches.filter(h => h.intensity > 0).length}
+          headachesToday={stats.headaches.length > 0 ? (stats.headaches[stats.headaches.length - 1].count ?? (stats.headaches[stats.headaches.length - 1].intensity > 0 ? 1 : 0)) : 0}
         />
       </div>
       
@@ -422,7 +422,7 @@ function QuickStatsCard({
         </div>
         <div style={{ flex: 1 }}>
           <div style={{ fontSize: 18, fontWeight: 600, color: "var(--color-text-primary)" }}>
-            {isLoading ? "—" : hasData ? `${headachesThisWeek} day${headachesThisWeek !== 1 ? "s" : ""}` : "—"}
+            {isLoading ? "—" : hasData ? `${headachesThisWeek} total` : "—"}
           </div>
           <div style={{ 
             fontSize: 12, 
@@ -444,23 +444,43 @@ function HeadacheCalendarCard({
 }: { 
   headaches: DashboardStats["headaches"];
 }) {
-  // Intensity classes from mockup
-  const getBarStyle = (intensity: number): React.CSSProperties => {
-    if (intensity === 0) return { background: "var(--color-surface-overlay)", height: 8 };
-    if (intensity <= 2.5) return { background: "rgba(255, 193, 204, 0.3)", height: 20 };
-    if (intensity <= 5) return { background: "rgba(255, 193, 204, 0.5)", height: 35 };
-    if (intensity <= 7.5) return { background: "rgba(255, 193, 204, 0.7)", height: 50 };
+  const MAX_BAR_HEIGHT = 80;
+  
+  const getBarStyle = (intensity: number, count: number): React.CSSProperties => {
+    if (intensity === 0 && count === 0) return { 
+      background: "var(--color-surface-overlay)", 
+      height: 6,
+      opacity: 0.5,
+    };
+    // Scale height proportionally: count drives height, intensity drives color
+    const heightFraction = Math.min(count / 4, 1); // 4+ headaches = full bar
+    const height = Math.max(16, heightFraction * MAX_BAR_HEIGHT);
+    
+    if (intensity <= 3) return { 
+      background: "linear-gradient(to top, rgba(255, 193, 204, 0.2), rgba(255, 193, 204, 0.35))", 
+      height,
+    };
+    if (intensity <= 5) return { 
+      background: "linear-gradient(to top, rgba(255, 193, 204, 0.3), rgba(255, 193, 204, 0.55))", 
+      height,
+    };
+    if (intensity <= 7) return { 
+      background: "linear-gradient(to top, rgba(255, 193, 204, 0.5), rgba(255, 193, 204, 0.75))", 
+      height,
+    };
     return { 
-      background: "var(--color-accent-pink)", 
-      height: 65, 
-      boxShadow: "0 0 12px rgba(255, 193, 204, 0.4)" 
+      background: "linear-gradient(to top, rgba(255, 193, 204, 0.6), var(--color-accent-pink))", 
+      height, 
+      boxShadow: "0 0 16px rgba(255, 193, 204, 0.3)",
     };
   };
   
   // Default days if no data
   const days = headaches.length > 0 
     ? headaches 
-    : ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"].map(day => ({ day, intensity: 0 }));
+    : ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"].map(day => ({ day, intensity: 0, count: 0 }));
+
+  const today = new Date().toLocaleDateString("en-US", { weekday: "short" });
   
   return (
     <div 
@@ -472,8 +492,8 @@ function HeadacheCalendarCard({
         minHeight: 120,
       }}
     >
-      <div style={{ display: "flex", alignItems: "center", gap: 14, marginBottom: 16 }}>
-        <Brain style={{ width: 30, height: 30, color: "var(--color-accent-pink)" }} />
+      <div style={{ display: "flex", alignItems: "center", gap: 14, marginBottom: 20 }}>
+        <Brain style={{ width: 28, height: 28, color: "var(--color-accent-pink)" }} />
         <span style={{ 
           fontSize: 12, 
           fontWeight: 600, 
@@ -485,37 +505,70 @@ function HeadacheCalendarCard({
         </span>
       </div>
       
-      <div style={{ display: "flex", gap: 6, flex: 1, alignItems: "flex-end" }}>
-        {days.map((day, i) => (
-          <div 
-            key={i} 
-            style={{ 
-              flex: 1, 
-              display: "flex", 
-              flexDirection: "column", 
-              alignItems: "center", 
-              gap: 8 
-            }}
-          >
+      <div style={{ 
+        display: "flex", 
+        gap: 8, 
+        flex: 1, 
+        alignItems: "flex-end",
+        paddingTop: 20,
+      }}>
+        {days.map((day, i) => {
+          const isToday = day.day === today;
+          const hasData = day.count > 0 || day.intensity > 0;
+          return (
             <div 
-              style={{
-                width: "100%",
-                borderRadius: 6,
-                minHeight: 8,
-                transition: "all 0.3s ease",
-                ...getBarStyle(day.intensity),
+              key={i} 
+              style={{ 
+                flex: 1, 
+                display: "flex", 
+                flexDirection: "column", 
+                alignItems: "center", 
+                gap: 10,
               }}
-            />
-            <span style={{ 
-              fontSize: 9, 
-              fontWeight: 600, 
-              color: "var(--color-text-secondary)", 
-              textTransform: "uppercase" 
-            }}>
-              {day.day}
-            </span>
-          </div>
-        ))}
+            >
+              {/* Count badge */}
+              <div style={{ height: 16, display: "flex", alignItems: "center" }}>
+                {day.count > 1 && (
+                  <span style={{
+                    fontSize: 10,
+                    fontWeight: 700,
+                    color: "var(--color-accent-pink)",
+                    whiteSpace: "nowrap",
+                  }}>
+                    ×{day.count}
+                  </span>
+                )}
+              </div>
+              
+              {/* Bar */}
+              <div 
+                style={{
+                  width: "100%",
+                  maxWidth: 28,
+                  borderRadius: 8,
+                  minHeight: 6,
+                  transition: "all 0.4s cubic-bezier(0.4, 0, 0.2, 1)",
+                  ...getBarStyle(day.intensity, day.count ?? (day.intensity > 0 ? 1 : 0)),
+                  ...(isToday && hasData ? { 
+                    outline: "2px solid rgba(255, 193, 204, 0.4)",
+                    outlineOffset: 2,
+                  } : {}),
+                }}
+              />
+              
+              {/* Day label */}
+              <span style={{ 
+                fontSize: 10, 
+                fontWeight: isToday ? 700 : 500, 
+                color: isToday ? "var(--color-text-primary)" : "var(--color-text-secondary)", 
+                textTransform: "uppercase",
+                letterSpacing: "0.02em",
+              }}>
+                {day.day}
+              </span>
+            </div>
+          );
+        })}
       </div>
     </div>
   );

frontend/src/hooks/useDashboardData.ts

@@ -22,6 +22,7 @@ interface MedicationStats {
 interface HeadacheDay {
   day: string;
   intensity: number;
+  count: number;
 }
 
 export interface DashboardStats {

frontend/src/registry/SessionSummary.tsx

@@ -34,10 +34,10 @@ function SummarySection({
   children: React.ReactNode;
 }) {
   return (
-    <div className="mb-5">
-      <div className="flex items-center gap-2 mb-2.5">
-        <Icon className="w-4 h-4 text-muted" />
-        <span className="text-[10px] font-bold text-muted uppercase tracking-wider">
+    <div className="mb-8">
+      <div className="flex items-center gap-3 mb-4">
+        <Icon className="w-6 h-6 text-muted" />
+        <span className="text-base font-bold text-muted uppercase tracking-wider">
           {title}
         </span>
       </div>
@@ -54,26 +54,24 @@ export function SessionSummary(props: SessionSummaryProps) {
 
   return (
     <div
-      className="relative overflow-hidden rounded-2xl p-5
-                 bg-gradient-to-br from-surface-elevated/90 to-surface-subtle/95
-                 border border-cta/15
-                 shadow-[0_4px_24px_rgba(0,0,0,0.4),inset_0_1px_0_rgba(255,255,255,0.05)]"
+      className="relative h-full overflow-y-auto p-10
+                 bg-gradient-to-br from-surface-elevated/90 to-surface-subtle/95"
     >
       {/* Top accent line */}
-      <div className="absolute top-0 left-[20%] right-[20%] h-0.5 bg-gradient-to-r from-transparent via-cta to-transparent opacity-60" />
+      <div className="absolute top-0 left-[20%] right-[20%] h-1 bg-gradient-to-r from-transparent via-cta to-transparent opacity-60" />
 
       {/* Header */}
-      <div className="flex items-center gap-3.5 mb-5 pb-4 border-b border-white/5">
+      <div className="flex items-center gap-5 mb-8 pb-6 border-b border-white/5">
         <div
-          className="relative w-11 h-11 rounded-xl flex items-center justify-center
+          className="relative w-16 h-16 rounded-xl flex items-center justify-center
                      bg-gradient-to-br from-cta/25 to-cta/10
                      border border-cta/30"
         >
-          <ClipboardCheck className="w-5 h-5 text-cta" />
+          <ClipboardCheck className="w-8 h-8 text-cta" />
         </div>
         <div className="flex-1">
-          <h3 className="text-base font-bold tracking-tight">Session Summary</h3>
-          <p className="text-[11px] text-muted mt-0.5">
+          <h3 className="text-3xl font-bold tracking-tight">Session Summary</h3>
+          <p className="text-lg text-muted mt-1">
             {props.session_date} · {props.session_duration}
           </p>
         </div>
@@ -82,16 +80,16 @@ export function SessionSummary(props: SessionSummaryProps) {
       {/* Medications Logged */}
       {medications_logged.length > 0 && (
         <SummarySection icon={Pill} title="Medications Logged">
-          <div className="flex flex-col gap-1.5">
+          <div className="flex flex-col gap-2.5">
             {medications_logged.map((med, i) => (
               <div
                 key={i}
-                className="flex items-center gap-3 px-3 py-2.5 rounded-lg
+                className="flex items-center gap-4 px-5 py-4 rounded-xl
                            bg-surface-subtle/60 border border-success/20"
               >
-                <span className="text-success text-[14px] font-bold">✓</span>
-                <span className="flex-1 text-[13px] text-primary font-medium">{med.name}</span>
-                <span className="text-[11px] text-muted">{med.time}</span>
+                <span className="text-success text-xl font-bold">✓</span>
+                <span className="flex-1 text-xl text-primary font-medium">{med.name}</span>
+                <span className="text-base text-muted">{med.time}</span>
               </div>
             ))}
           </div>
@@ -101,16 +99,16 @@ export function SessionSummary(props: SessionSummaryProps) {
       {/* Headaches Reported */}
       {headaches_logged.length > 0 && (
         <SummarySection icon={Brain} title="Headaches Reported">
-          <div className="flex flex-col gap-1.5">
+          <div className="flex flex-col gap-2.5">
             {headaches_logged.map((h, i) => (
               <div
                 key={i}
-                className="flex items-center gap-3 px-3 py-2.5 rounded-lg
+                className="flex items-center gap-4 px-5 py-4 rounded-xl
                            bg-surface-subtle/60 border border-warning/20"
               >
-                <span className="text-[13px] text-primary">Started: {h.onset}</span>
+                <span className="text-xl text-primary">Started: {h.onset}</span>
                 {h.intensity && (
-                  <span className="ml-auto text-[11px] font-bold text-error">
+                  <span className="ml-auto text-base font-bold text-error">
                     Intensity: {h.intensity}/10
                   </span>
                 )}
@@ -123,19 +121,19 @@ export function SessionSummary(props: SessionSummaryProps) {
       {/* Questions for Provider */}
       {questions_for_provider.length > 0 && (
         <SummarySection icon={HelpCircle} title="Questions for Your Provider">
-          <div className="flex flex-col gap-1.5">
+          <div className="flex flex-col gap-2.5">
             {questions_for_provider.map((q, i) => (
               <div
                 key={i}
-                className="px-3 py-2.5 rounded-lg
+                className="px-5 py-4 rounded-xl
                            bg-surface-subtle/60 border-l-3 border-l-cta border border-cta/10
-                           text-[13px] text-secondary italic"
+                           text-xl text-secondary italic"
               >
                 &quot;{q}&quot;
               </div>
             ))}
           </div>
-          <p className="text-[11px] text-cta mt-2 font-medium">
+          <p className="text-base text-cta mt-3 font-medium">
             These will be included in your next appointment export.
           </p>
         </SummarySection>
@@ -144,11 +142,11 @@ export function SessionSummary(props: SessionSummaryProps) {
       {/* Items Mentioned */}
       {items_mentioned.length > 0 && (
         <SummarySection icon={MessageSquare} title="Also Mentioned">
-          <div className="flex flex-wrap gap-1.5">
+          <div className="flex flex-wrap gap-2.5">
             {items_mentioned.map((item, i) => (
               <span
                 key={i}
-                className="px-2.5 py-1 rounded-full bg-surface-overlay text-muted text-[11px] font-medium"
+                className="px-4 py-2 rounded-full bg-surface-overlay text-muted text-base font-medium"
               >
                 {item}
               </span>
@@ -159,16 +157,16 @@ export function SessionSummary(props: SessionSummaryProps) {
 
       {/* Next Check-in */}
       {props.next_checkin && (
-        <div className="flex items-center gap-3 px-4 py-3 rounded-xl bg-success/10 border border-success/20 mb-4">
-          <Clock className="w-4 h-4 text-success" />
-          <span className="text-[13px] text-success font-medium">
+        <div className="flex items-center gap-4 px-6 py-5 rounded-xl bg-success/10 border border-success/20 mb-6">
+          <Clock className="w-6 h-6 text-success" />
+          <span className="text-xl text-success font-medium">
             Next check-in: {props.next_checkin}
           </span>
         </div>
       )}
 
       {/* Disclaimer */}
-      <p className="text-[10px] text-muted text-center italic leading-relaxed">
+      <p className="text-sm text-muted text-center italic leading-relaxed">
         This is a summary of what you shared, not a professional evaluation.
         Discuss any concerns with your healthcare provider.
       </p>

src/reachy_mini_conversation_app/console.py

@@ -116,6 +116,32 @@ class LocalStream:
         ):
             self._settings_app.include_router(stream_router)
 
+        # ── Persistent structured logging ──
+        # Attach a RotatingFileHandler to the package logger so ALL INFO+
+        # messages (tool calls, UI events, session lifecycle) are captured
+        # to a persistent, searchable file – not just terminal scrollback.
+        try:
+            from logging.handlers import RotatingFileHandler
+
+            pkg_logger = logging.getLogger("reachy_mini_conversation_app")
+            # Only add once (guard against duplicate LocalStream inits)
+            if not any(isinstance(h, RotatingFileHandler) for h in pkg_logger.handlers):
+                fh = RotatingFileHandler(
+                    "minder_session.log",
+                    maxBytes=5 * 1024 * 1024,  # 5 MB
+                    backupCount=3,
+                )
+                fh.setLevel(logging.INFO)
+                fh.setFormatter(
+                    logging.Formatter(
+                        "%(asctime)s %(levelname)s %(name)s:%(lineno)d | %(message)s"
+                    )
+                )
+                pkg_logger.addHandler(fh)
+                logger.info("Persistent session log: minder_session.log (5MB×3)")
+        except Exception as e:
+            logger.warning("Failed to set up session file logging: %s", e)
+
     def _get_minder_db(self) -> Any:
         """Try to get the MiniMinderDB from the handler's deps."""
         try:
@@ -1522,37 +1548,15 @@ class LocalStream:
                             "Wakeword .feed() returned True — will start session"
                         )
                         await self._start_session_from_wakeword()
-            # ── Idle timeout check ──
-            if (
-                self._is_session_active
-                and self._last_activity_time > 0
-                and (_time.monotonic() - self._last_activity_time)
-                > self._idle_timeout_secs
-            ):
-                logger.info(
-                    "Session idle for %.0fs — auto-ending session",
-                    self._idle_timeout_secs,
-                )
-                self._is_session_active = False
-                self._is_listening = False
-                try:
-                    await self.handler.shutdown()
-                    logger.info("Idle timeout: handler shutdown complete")
-                except Exception as e:
-                    logger.error("Idle timeout shutdown failed: %s", e)
-                self._wakeword_detector.reset()
-                self._wakeword_resume_after = _time.monotonic() + 3.0
-                self._last_activity_time = 0.0
-                try:
-                    await emit_session_event("ended")
-                except Exception:
-                    pass
-
-                # Generate and emit real SessionSummary via gpt-4.1-mini
-                asyncio.create_task(
-                    self._generate_post_session_summary(),
-                    name="idle-session-summary",
-                )
+            # ── Idle timeout check — DISABLED per user request ──
+            # Sessions no longer auto-end on silence.
+            # if (
+            #     self._is_session_active
+            #     and self._last_activity_time > 0
+            #     and (_time.monotonic() - self._last_activity_time)
+            #     > self._idle_timeout_secs
+            # ):
+            #     ...idle timeout logic removed...
 
             await asyncio.sleep(0)  # avoid busy loop
 

src/reachy_mini_conversation_app/profiles/_reachy_mini_minder_locked_profile/instructions.txt

@@ -53,17 +53,23 @@ When in doubt, fewer tools = faster response. Never call tools speculatively.
 
 ## Tool Usage Guidelines
 
-### Starting Entries
-- When a user mentions a headache, immediately call `start_headache_entry` with any details they already provided.
-- When a user mentions taking medication, call `start_medication_entry`.
+### Starting & Building Entries (log_entry)
+- Use `log_entry` for ALL entry logging. Set `entry_type` to "headache" or "medication".
+- When a user mentions a headache, immediately call `log_entry` with `entry_type: "headache"` and any details they already provided.
+- When a user mentions taking medication, call `log_entry` with `entry_type: "medication"`.
 - If the user says something ambiguous like "I need to log something", ask whether it's a headache or medication.
-
-### Building Entries
-- As the user provides details, call `update_headache_entry` or `update_medication_entry` to add each piece of information.
+- As the user provides details, call `log_entry` again to update the active entry with new fields.
 - Guide the user through the important fields, but don't require all of them. Minimum for headache: intensity. Minimum for medication: medication_name.
 - For headaches, try to collect: intensity, location, pain_type. The rest are optional bonus details.
 - For medications, try to collect: medication_name, dose. The rest are optional.
 
+### Speech ↔ UI Synchronization — CRITICAL
+- When `log_entry` returns `wizard_step` and `next_question`, you MUST speak that question (or a natural variation of it) — do NOT ask about a different field.
+- The on-screen UI shows the same question to the user. Your speech must match what they see.
+- If `wizard_step` is "done", all core fields are filled — offer to save.
+- If `next_question` is null, the remaining fields are optional — you may ask about them or offer to save.
+- Example: if `wizard_step` is "location" and `next_question` is "Where is the pain?", you should say something like "Where is the pain?" or "Whereabouts on your head is it?" — NOT "What does it feel like?" (which is a different step).
+
 ### Saving and Discarding
 - When the user indicates they're done (or you've collected the key details), confirm what you have and then call `save_current_entry`.
 - If the user wants to cancel, call `discard_current_entry`.

src/reachy_mini_conversation_app/profiles/_reachy_mini_minder_locked_profile/log_entry.py

@@ -150,6 +150,16 @@ class LogEntry(Tool):
         "notes",
     ]
 
+    # Human-readable questions for each wizard step (must match frontend STEP_META)
+    _STEP_QUESTIONS: Dict[str, str] = {
+        "intensity": "How intense is the pain, on a scale of 1 to 10?",
+        "location": "Where is the pain?",
+        "pain_type": "What does it feel like?",
+        "onset_time": "When did it start?",
+        "triggers": "Any suspected triggers?",
+        "medication_taken": "Did you take anything for it?",
+    }
+
     async def _handle_headache(
         self, deps: ToolDependencies, fields: Dict[str, Any]
     ) -> Dict[str, Any]:
@@ -200,6 +210,10 @@ class LogEntry(Tool):
                 "total_steps": 3,  # Core steps: intensity, location, pain_type
             },
         )
+
+        # Include wizard state in tool result so LLM can coordinate speech
+        result["wizard_step"] = wizard_step or "done"
+        result["next_question"] = self._STEP_QUESTIONS.get(wizard_step or "")
         return result
 
     # ── Medication ─────────────────────────────────────────────────────

src/reachy_mini_conversation_app/stream_api.py

@@ -420,7 +420,7 @@ async def emit_tool_start(
     args: dict[str, Any],
     event_id: str,
 ) -> None:
-    """Emit tool execution started event."""
+    """Emit tool execution started event and persist to conversation log."""
     event = ToolEvent(
         type="tool.start",
         id=event_id,
@@ -430,6 +430,18 @@ async def emit_tool_start(
     )
     await manager.broadcast(event)
 
+    # Persist tool start to conversation log for post-mortem debugging
+    if _conversation_logger and _current_session_id:
+        try:
+            _conversation_logger.log_turn(
+                session_id=_current_session_id,
+                role="tool",
+                content=f"{name}({json.dumps(args, default=str)})",
+                metadata={"event_id": event_id, "status": "started"},
+            )
+        except Exception as e:
+            logger.warning("Failed to log tool start: %s", e)
+
 
 async def emit_tool_result(
     name: str,
@@ -437,7 +449,7 @@ async def emit_tool_result(
     event_id: str,
     status: str = "completed",
 ) -> None:
-    """Emit tool execution completed event."""
+    """Emit tool execution completed event and persist to conversation log."""
     event = ToolEvent(
         type="tool.result",
         id=event_id,
@@ -447,6 +459,22 @@ async def emit_tool_result(
     )
     await manager.broadcast(event)
 
+    # Persist tool result to conversation log
+    if _conversation_logger and _current_session_id:
+        try:
+            # Truncate large results to avoid bloating the DB
+            result_str = json.dumps(result, default=str)
+            if len(result_str) > 1000:
+                result_str = result_str[:1000] + "...(truncated)"
+            _conversation_logger.log_turn(
+                session_id=_current_session_id,
+                role="tool_result",
+                content=f"{name} -> {result_str}",
+                metadata={"event_id": event_id, "status": status},
+            )
+        except Exception as e:
+            logger.warning("Failed to log tool result: %s", e)
+
 
 async def emit_ui_component(
     component_name: str,
@@ -454,7 +482,7 @@ async def emit_ui_component(
     message_id: str | None = None,
     event_id: str | None = None,
 ) -> None:
-    """Emit a Gen-UI component event.
+    """Emit a Gen-UI component event and persist to conversation log.
 
     Args:
         component_name: Registry key for the React component
@@ -464,15 +492,35 @@ async def emit_ui_component(
     """
     import uuid
 
+    eid = event_id or str(uuid.uuid4())
     event = UIComponentEvent(
         type="ui.component",
-        id=event_id or str(uuid.uuid4()),
+        id=eid,
         name=component_name,
         props=props,
         message_id=message_id,
     )
     await manager.broadcast(event)
 
+    # Persist UI event to conversation log for post-mortem debugging
+    if _conversation_logger and _current_session_id:
+        try:
+            # Log component name and a summary of props (skip large blobs)
+            props_summary = {
+                k: v for k, v in props.items() if not isinstance(v, (bytes, bytearray))
+            }
+            props_str = json.dumps(props_summary, default=str)
+            if len(props_str) > 500:
+                props_str = props_str[:500] + "...(truncated)"
+            _conversation_logger.log_turn(
+                session_id=_current_session_id,
+                role="ui",
+                content=f"{component_name}: {props_str}",
+                metadata={"event_id": eid, "message_id": message_id},
+            )
+        except Exception as e:
+            logger.warning("Failed to log UI component event: %s", e)
+
 
 async def emit_ui_dismiss() -> None:
     """Emit a UI dismiss event to close the active GenUI overlay."""
@@ -666,6 +714,30 @@ async def observability_metrics() -> dict[str, Any]:
     }
 
 
+@router.get("/session-log")
+async def session_log(session_id: str | None = None) -> dict[str, Any]:
+    """Get the full event log for a session (transcripts, tool calls, UI events).
+
+    Used for post-mortem debugging when terminal scrollback is unavailable.
+
+    Args:
+        session_id: Optional session ID. Defaults to current session.
+    """
+    if not _conversation_logger:
+        return {"error": "Conversation logger not initialized", "turns": []}
+
+    target = session_id or _current_session_id
+    if not target:
+        return {"error": "No active session", "turns": []}
+
+    turns = _conversation_logger.get_session(target)
+    return {
+        "session_id": target,
+        "turn_count": len(turns),
+        "turns": turns,
+    }
+
+
 @router.get("/cost-summary")
 async def cost_summary(session_id: str | None = None) -> dict[str, Any]:
     """Get aggregated token usage and cost for cost monitoring.
@@ -802,6 +874,7 @@ async def dashboard_stats() -> dict[str, Any]:
                 {
                     "day": day_names[day.weekday()],
                     "intensity": max_intensity,
+                    "count": len(day_headaches),
                 }
             )
 

tests/test_session_logging.py

@@ -0,0 +1,190 @@
+"""Tests for session event logging (tool calls, UI events persistence)."""
+
+import json
+import asyncio
+from unittest.mock import patch, MagicMock, AsyncMock
+
+import pytest
+
+import reachy_mini_conversation_app.stream_api as stream_api
+
+
+@pytest.fixture
+def mock_conversation_logger():
+    """Provide a mock ConversationLogger and wire it into stream_api."""
+    mock_logger = MagicMock()
+    mock_logger.log_turn = MagicMock(return_value=1)
+    mock_logger.get_session = MagicMock(return_value=[])
+
+    original_logger = stream_api._conversation_logger
+    original_session_id = stream_api._current_session_id
+    stream_api._conversation_logger = mock_logger
+    stream_api._current_session_id = "test-session-abc"
+
+    yield mock_logger
+
+    stream_api._conversation_logger = original_logger
+    stream_api._current_session_id = original_session_id
+
+
+@pytest.fixture
+def mock_broadcast():
+    """Mock the broadcast to avoid needing real WebSocket connections."""
+    with patch.object(stream_api.manager, "broadcast", new_callable=AsyncMock) as m:
+        yield m
+
+
+# ─────────────────────────────────────────────────────────────
+# Tool event persistence
+# ─────────────────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_emit_tool_start_persists_to_conversation_log(
+    mock_conversation_logger, mock_broadcast
+):
+    """emit_tool_start should log a 'tool' turn to the conversation log."""
+    await stream_api.emit_tool_start(
+        name="log_entry",
+        args={"type": "headache", "intensity": 7},
+        event_id="evt-001",
+    )
+
+    mock_conversation_logger.log_turn.assert_called_once()
+    call_kwargs = mock_conversation_logger.log_turn.call_args
+    assert call_kwargs[1]["role"] == "tool"
+    assert "log_entry" in call_kwargs[1]["content"]
+    assert "headache" in call_kwargs[1]["content"]
+    assert call_kwargs[1]["session_id"] == "test-session-abc"
+
+
+@pytest.mark.asyncio
+async def test_emit_tool_result_persists_to_conversation_log(
+    mock_conversation_logger, mock_broadcast
+):
+    """emit_tool_result should log a 'tool_result' turn."""
+    await stream_api.emit_tool_result(
+        name="log_entry",
+        result={"status": "ok", "entry_id": 42},
+        event_id="evt-001",
+        status="completed",
+    )
+
+    mock_conversation_logger.log_turn.assert_called_once()
+    call_kwargs = mock_conversation_logger.log_turn.call_args
+    assert call_kwargs[1]["role"] == "tool_result"
+    assert "log_entry" in call_kwargs[1]["content"]
+    assert call_kwargs[1]["metadata"]["status"] == "completed"
+
+
+@pytest.mark.asyncio
+async def test_emit_tool_result_truncates_large_results(
+    mock_conversation_logger, mock_broadcast
+):
+    """Large tool results should be truncated to avoid DB bloat."""
+    big_result = {"data": "x" * 2000}
+
+    await stream_api.emit_tool_result(
+        name="big_tool",
+        result=big_result,
+        event_id="evt-002",
+    )
+
+    call_kwargs = mock_conversation_logger.log_turn.call_args
+    content = call_kwargs[1]["content"]
+    assert len(content) < 1200  # truncated from 2000+
+    assert "truncated" in content
+
+
+# ─────────────────────────────────────────────────────────────
+# UI event persistence
+# ─────────────────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_emit_ui_component_persists_to_conversation_log(
+    mock_conversation_logger, mock_broadcast
+):
+    """emit_ui_component should log a 'ui' turn."""
+    await stream_api.emit_ui_component(
+        component_name="HeadacheLog",
+        props={"intensity": 7, "location": "frontal"},
+        message_id="msg-001",
+    )
+
+    mock_conversation_logger.log_turn.assert_called_once()
+    call_kwargs = mock_conversation_logger.log_turn.call_args
+    assert call_kwargs[1]["role"] == "ui"
+    assert "HeadacheLog" in call_kwargs[1]["content"]
+    assert "frontal" in call_kwargs[1]["content"]
+
+
+@pytest.mark.asyncio
+async def test_emit_ui_component_truncates_large_props(
+    mock_conversation_logger, mock_broadcast
+):
+    """Large UI props should be truncated."""
+    big_props = {"data": "y" * 1000}
+
+    await stream_api.emit_ui_component(
+        component_name="BigComponent",
+        props=big_props,
+    )
+
+    call_kwargs = mock_conversation_logger.log_turn.call_args
+    content = call_kwargs[1]["content"]
+    assert len(content) < 700  # truncated from 1000+
+
+
+# ─────────────────────────────────���───────────────────────────
+# No-op when logger is not initialized
+# ─────────────────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_emit_tool_start_no_crash_without_logger(mock_broadcast):
+    """Should not crash when conversation logger is not initialized."""
+    original = stream_api._conversation_logger
+    stream_api._conversation_logger = None
+    try:
+        await stream_api.emit_tool_start(
+            name="test_tool",
+            args={"a": 1},
+            event_id="evt-999",
+        )
+        # Should complete without error
+    finally:
+        stream_api._conversation_logger = original
+
+
+# ─────────────────────────────────────────────────────────────
+# Session-log endpoint
+# ─────────────────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_session_log_endpoint_returns_turns(mock_conversation_logger):
+    """GET /session-log should return turns from ConversationLogger."""
+    mock_conversation_logger.get_session.return_value = [
+        {"turn_index": 0, "role": "user", "content": "Hello"},
+        {"turn_index": 1, "role": "tool", "content": "log_entry({})"},
+        {"turn_index": 2, "role": "ui", "content": "HeadacheLog: {}"},
+    ]
+
+    result = await stream_api.session_log(session_id="test-session-abc")
+
+    assert result["session_id"] == "test-session-abc"
+    assert result["turn_count"] == 3
+    assert result["turns"][1]["role"] == "tool"
+
+
+@pytest.mark.asyncio
+async def test_session_log_endpoint_no_logger():
+    """Should return error when logger not initialized."""
+    original = stream_api._conversation_logger
+    stream_api._conversation_logger = None
+    try:
+        result = await stream_api.session_log()
+        assert "error" in result
+    finally:
+        stream_api._conversation_logger = original