feat: enhance time parsing for log entries, introduce a health pattern checking tool, and adjust wakeword detection test parameters.

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", "SessionSummary", "OnboardingProgress", "OnboardingSummary", "MyMedsList"]);
+const FULLSCREEN_COMPONENTS = new Set(["HeadacheLog", "MedLog", "MedStatus", "SessionSummary", "OnboardingProgress", "OnboardingSummary", "MyMedsList", "QuickReply"]);
 
 export function ComponentOverlay({ component, onDismiss }: ComponentOverlayProps) {
   const isFullscreen = FULLSCREEN_COMPONENTS.has(component.name);

frontend/src/registry/MedStatus.tsx

@@ -27,20 +27,20 @@ function StatusIcon({ status }: { status: Medication["status"] }) {
   switch (status) {
     case "logged":
       return (
-        <div className="w-7 h-7 rounded-full flex items-center justify-center bg-success/15 text-success">
-          <Check className="w-4 h-4" strokeWidth={3} />
+        <div className="w-10 h-10 rounded-full flex items-center justify-center bg-success/15 text-success">
+          <Check className="w-5 h-5" strokeWidth={3} />
         </div>
       );
     case "pending":
       return (
-        <div className="w-7 h-7 rounded-full flex items-center justify-center bg-warning/15 text-warning">
-          <Circle className="w-4 h-4" />
+        <div className="w-10 h-10 rounded-full flex items-center justify-center bg-warning/15 text-warning">
+          <Circle className="w-5 h-5" />
         </div>
       );
     case "missed_window":
       return (
-        <div className="w-7 h-7 rounded-full flex items-center justify-center bg-error/15 text-error">
-          <AlertCircle className="w-4 h-4" />
+        <div className="w-10 h-10 rounded-full flex items-center justify-center bg-error/15 text-error">
+          <AlertCircle className="w-5 h-5" />
         </div>
       );
   }
@@ -67,29 +67,27 @@ export function MedStatus({
 
   return (
     <div
-      className="relative overflow-hidden rounded-2xl p-5
-                 bg-gradient-to-br from-surface-elevated/90 to-surface-subtle/95
-                 border border-success/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-success to-transparent opacity-60" />
+      <div className="absolute top-0 left-[20%] right-[20%] h-1 bg-gradient-to-r from-transparent via-success 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-14 h-14 rounded-xl flex items-center justify-center
                      bg-gradient-to-br from-success/25 to-success/10
                      border border-success/30"
         >
-          <Pill className="w-5 h-5 text-success" />
+          <Pill className="w-7 h-7 text-success" />
         </div>
         <div className="flex-1">
-          <h3 className="text-base font-bold tracking-tight">Today&apos;s Medications</h3>
-          <p className="text-[11px] text-muted mt-0.5">{formatDate(date)}</p>
+          <h3 className="text-3xl font-bold tracking-tight">Today&apos;s Medications</h3>
+          <p className="text-lg text-muted mt-1">{formatDate(date)}</p>
         </div>
         {total > 0 && (
-          <span className="text-[10px] font-extrabold px-2.5 py-1 rounded-full bg-success/15 text-success border border-success/20">
+          <span className="text-sm font-extrabold px-3.5 py-1.5 rounded-full bg-success/15 text-success border border-success/20">
             {logged} of {total}
           </span>
         )}
@@ -97,11 +95,11 @@ export function MedStatus({
 
       {/* Scheduled Medication List */}
       {medications.length > 0 && (
-        <div className="flex flex-col gap-2.5">
+        <div className="flex flex-col gap-3">
           {medications.map((med, index) => (
             <div
               key={index}
-              className={`flex items-center gap-3.5 p-3.5 rounded-xl
+              className={`flex items-center gap-4 p-5 rounded-xl
                          bg-surface-subtle/60 border transition-all
                          ${med.status === "logged" 
                            ? "border-success/30" 
@@ -112,10 +110,10 @@ export function MedStatus({
             >
               <StatusIcon status={med.status} />
               <div className="flex-1 min-w-0">
-                <p className="text-[0.9rem] font-semibold text-primary truncate">
+                <p className="text-xl font-semibold text-primary truncate">
                   {med.name}
                 </p>
-                <p className="text-[11px] text-muted mt-0.5">
+                <p className="text-base text-muted mt-1">
                   {med.status === "logged" && med.logged_at
                     ? `Logged at ${med.logged_at}`
                     : `${med.scheduled_window} — not yet logged`}
@@ -128,30 +126,30 @@ export function MedStatus({
 
       {/* Ad-Hoc Medications Section */}
       {hasAdHoc && (
-        <div className="mt-4">
-          <div className="flex items-center gap-2 mb-2.5">
+        <div className="mt-6">
+          <div className="flex items-center gap-2 mb-3">
             <div className="flex-1 h-px bg-white/5" />
-            <span className="text-[10px] font-semibold uppercase tracking-wider text-muted">
+            <span className="text-sm font-semibold uppercase tracking-wider text-muted">
               Other medications logged
             </span>
             <div className="flex-1 h-px bg-white/5" />
           </div>
-          <div className="flex flex-col gap-2">
+          <div className="flex flex-col gap-2.5">
             {ad_hoc_medications!.map((med, index) => (
               <div
                 key={`adhoc-${index}`}
-                className="flex items-center gap-3.5 p-3 rounded-xl
+                className="flex items-center gap-4 p-4 rounded-xl
                            bg-surface-subtle/40 border border-white/5 transition-all"
               >
-                <div className="w-7 h-7 rounded-full flex items-center justify-center bg-cta/10 text-cta">
-                  <Plus className="w-3.5 h-3.5" strokeWidth={2.5} />
+                <div className="w-9 h-9 rounded-full flex items-center justify-center bg-cta/10 text-cta">
+                  <Plus className="w-5 h-5" strokeWidth={2.5} />
                 </div>
                 <div className="flex-1 min-w-0">
-                  <p className="text-[0.85rem] font-medium text-primary/80 truncate">
+                  <p className="text-lg font-medium text-primary/80 truncate">
                     {med.name}
                     {med.dose && <span className="text-muted ml-1.5">({med.dose})</span>}
                   </p>
-                  <p className="text-[10px] text-muted mt-0.5">
+                  <p className="text-sm text-muted mt-0.5">
                     {med.logged_at ? `Logged at ${med.logged_at}` : "Logged today"}
                     {" · "}
                     <span className="text-cta/70">Not in regular medications</span>
@@ -165,13 +163,13 @@ export function MedStatus({
 
       {/* Robot Message */}
       {robot_message && (
-        <div className="mt-4 px-4 py-3 rounded-xl bg-cta/10 border border-cta/20">
-          <p className="text-[13px] text-cta font-medium">{robot_message}</p>
+        <div className="mt-6 px-6 py-4 rounded-xl bg-cta/10 border border-cta/20">
+          <p className="text-lg text-cta font-medium">{robot_message}</p>
         </div>
       )}
 
       {/* Disclaimer */}
-      <p className="mt-4 text-[10px] text-muted text-center italic">
+      <p className="mt-6 text-sm text-muted text-center italic">
         This shows what was logged in the app, not verified medication intake.
       </p>
     </div>

src/reachy_mini_conversation_app/appointment_export.py

@@ -104,6 +104,11 @@ async def generate_appointment_summary(
                 else f'- "{excerpt}"\n'
             )
 
+    # Add graph-derived summary if available
+    graph_summary = _generate_graph_summary()
+    if graph_summary:
+        data_summary += f"\n{graph_summary}"
+
     # Generate summary via LLM
     try:
         # PII guard: redact excerpts before sending to cloud LLM
@@ -155,6 +160,74 @@ async def generate_appointment_summary(
         }
 
 
+def _generate_graph_summary() -> str:
+    """Query Neo4j for appointment-relevant patterns.
+
+    Returns a formatted text block for inclusion in the LLM prompt.
+    Returns empty string if Neo4j is unavailable.
+    """
+    try:
+        from reachy_mini_conversation_app.session_enrichment import (
+            get_session_enrichment,
+        )
+
+        enrichment = get_session_enrichment()
+        if not enrichment or not enrichment._graph:
+            return ""
+
+        graph = enrichment._graph
+        lines = ["### Knowledge Graph Observations\n"]
+
+        # Medication adherence from events
+        try:
+            from reachy_mini_conversation_app.pattern_detector import PatternDetector
+
+            detector = PatternDetector(graph)
+            insights = detector.run_analysis()
+            if insights:
+                lines.append("**Detected Patterns:**")
+                for insight in insights[:5]:
+                    lines.append(f"- {insight.pattern_type}: {insight.summary}")
+                    if insight.detail:
+                        lines.append(f"  ({insight.detail})")
+                lines.append("")
+        except Exception as e:
+            logger.debug("Pattern detection for appointment export failed: %s", e)
+
+        # Cross-session co-occurrences
+        try:
+            from reachy_mini_conversation_app.database import MiniMinderDB
+            from reachy_mini_conversation_app.config import DB_PATH
+
+            db = MiniMinderDB(DB_PATH)
+            profile = db.get_or_create_profile()
+            db.close()
+            patient_name = profile.get("display_name") or profile.get("name", "Patient")
+
+            co_occurrences = graph.get_cross_session_co_occurrences(
+                patient_name, days=30
+            )
+            if co_occurrences:
+                lines.append("**Recurring Co-Occurrences:**")
+                for co in co_occurrences[:5]:
+                    lines.append(
+                        f"- {co.get('type_a', '?')} and {co.get('type_b', '?')} "
+                        f"co-occurred {co.get('co_count', 0)} time(s)"
+                    )
+                lines.append("")
+        except Exception as e:
+            logger.debug("Co-occurrence query for appointment failed: %s", e)
+
+        # Only return if we actually found something
+        if len(lines) > 1:
+            return "\n".join(lines)
+        return ""
+
+    except Exception as e:
+        logger.debug("Graph summary for appointment export unavailable: %s", e)
+        return ""
+
+
 def _generate_fallback_summary(
     headaches: List[Dict],
     medications: List[Dict],

src/reachy_mini_conversation_app/database.py

@@ -750,17 +750,23 @@ h1 {{ color: #333; }}
             if logged_entry:
                 # Format logged time
                 logged_at = None
-                actual_time = logged_entry.get("actual_time") or logged_entry.get(
-                    "created_at"
-                )
-                if actual_time:
+                actual_time = logged_entry.get("actual_time")
+                created_at = logged_entry.get("created_at")
+
+                # Try actual_time first, then created_at
+                for ts in (actual_time, created_at):
+                    if not ts or logged_at:
+                        continue
+                    ts_str = str(ts)
                     try:
-                        dt = datetime.fromisoformat(
-                            str(actual_time).replace("Z", "+00:00")
-                        )
+                        dt = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
                         logged_at = dt.strftime("%I:%M %p").lstrip("0")
                     except ValueError:
-                        logged_at = str(actual_time)
+                        # Not a valid datetime (e.g. "now", "morning")
+                        continue
+
+                if not logged_at:
+                    logged_at = "earlier today"
 
                 scheduled_status.append(
                     {

src/reachy_mini_conversation_app/entry_state.py

@@ -19,13 +19,16 @@ EntryMode = Literal["idle", "headache", "medication"]
 class EntryStateManager:
     """Manages the active entry being built via voice conversation."""
 
-    def __init__(self, database: MiniMinderDB) -> None:
+    def __init__(self, database: MiniMinderDB, graph_memory: Any = None) -> None:
         self._db = database
+        self._graph = graph_memory
         self.entry_mode: EntryMode = "idle"
         self.active_headache: Dict[str, Any] = {}
         self.active_medication: Dict[str, Any] = {}
 
-    def start_headache(self, initial_data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    def start_headache(
+        self, initial_data: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
         """Begin a new headache diary entry."""
         self.entry_mode = "headache"
         self.active_headache = dict(initial_data) if initial_data else {}
@@ -35,26 +38,100 @@ class EntryStateManager:
     def update_headache(self, updates: Dict[str, Any]) -> Dict[str, Any]:
         """Update fields on the active headache entry."""
         if self.entry_mode != "headache":
-            return {"error": "No active headache entry. Use start_headache_entry first."}
+            return {
+                "error": "No active headache entry. Use start_headache_entry first."
+            }
         self.active_headache.update(updates)
         logger.info("Updated headache entry: %s", self.active_headache)
         return {"status": "updated", "fields": self.active_headache}
 
-    def start_medication(self, initial_data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    def start_medication(
+        self, initial_data: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
         """Begin a new medication log entry."""
         self.entry_mode = "medication"
         self.active_medication = dict(initial_data) if initial_data else {}
         logger.info("Started medication entry: %s", self.active_medication)
-        return {"status": "started", "mode": "medication", "fields": self.active_medication}
+        return {
+            "status": "started",
+            "mode": "medication",
+            "fields": self.active_medication,
+        }
 
     def update_medication(self, updates: Dict[str, Any]) -> Dict[str, Any]:
         """Update fields on the active medication entry."""
         if self.entry_mode != "medication":
-            return {"error": "No active medication entry. Use start_medication_entry first."}
+            return {
+                "error": "No active medication entry. Use start_medication_entry first."
+            }
         self.active_medication.update(updates)
         logger.info("Updated medication entry: %s", self.active_medication)
         return {"status": "updated", "fields": self.active_medication}
 
+    def _get_patient_name(self) -> str:
+        """Resolve patient name from profile for graph writes."""
+        try:
+            profile = self._db.get_or_create_profile()
+            return profile.get("display_name") or profile.get("name", "Patient")
+        except Exception:
+            return "Patient"
+
+    def _write_headache_to_graph(self, data: Dict[str, Any]) -> None:
+        """Write-through: mirror headache entry to Neo4j graph."""
+        if not self._graph or not getattr(self._graph, "is_connected", False):
+            return
+        try:
+            patient_name = self._get_patient_name()
+            notes_parts = []
+            if data.get("location"):
+                notes_parts.append(f"location: {data['location']}")
+            if data.get("intensity"):
+                notes_parts.append(f"intensity: {data['intensity']}/10")
+            if data.get("triggers"):
+                notes_parts.append(f"triggers: {data['triggers']}")
+            if data.get("notes"):
+                notes_parts.append(data["notes"])
+            notes = "; ".join(notes_parts) if notes_parts else None
+
+            self._graph.add_event(
+                event_type="headache",
+                notes=notes,
+                patient_name=patient_name,
+            )
+            logger.info("Graph write-through: headache event for %s", patient_name)
+        except Exception as e:
+            logger.warning("Graph write-through (headache) failed: %s", e)
+
+    def _write_medication_to_graph(self, data: Dict[str, Any]) -> None:
+        """Write-through: mirror medication entry to Neo4j graph."""
+        if not self._graph or not getattr(self._graph, "is_connected", False):
+            return
+        try:
+            patient_name = self._get_patient_name()
+            med_name = data.get("medication_name", "")
+            notes = data.get("notes")
+
+            self._graph.add_event(
+                event_type="medication_taken",
+                notes=f"{med_name}" + (f" — {notes}" if notes else ""),
+                patient_name=patient_name,
+            )
+
+            # Ensure TAKES relationship exists
+            if med_name:
+                try:
+                    self._graph.link_patient_takes_medication(patient_name, med_name)
+                except Exception:
+                    pass  # Relationship may not exist yet if med node missing
+
+            logger.info(
+                "Graph write-through: medication_taken (%s) for %s",
+                med_name,
+                patient_name,
+            )
+        except Exception as e:
+            logger.warning("Graph write-through (medication) failed: %s", e)
+
     def save_current(self) -> Dict[str, Any]:
         """Validate and persist the active entry to the database."""
         if self.entry_mode == "headache":
@@ -62,6 +139,7 @@ class EntryStateManager:
             if not data:
                 return {"error": "Headache entry is empty. Nothing to save."}
             row_id = self._db.insert_headache(data)
+            self._write_headache_to_graph(data)
             self.active_headache = {}
             self.entry_mode = "idle"
             return {"status": "saved", "type": "headache", "id": row_id}
@@ -71,6 +149,7 @@ class EntryStateManager:
             if not data.get("medication_name"):
                 return {"error": "Medication name is required before saving."}
             row_id = self._db.insert_medication(data)
+            self._write_medication_to_graph(data)
             self.active_medication = {}
             self.entry_mode = "idle"
             return {"status": "saved", "type": "medication", "id": row_id}
@@ -89,6 +168,10 @@ class EntryStateManager:
         """Return the current entry state."""
         return {
             "mode": self.entry_mode,
-            "active_headache": self.active_headache if self.entry_mode == "headache" else None,
-            "active_medication": self.active_medication if self.entry_mode == "medication" else None,
+            "active_headache": (
+                self.active_headache if self.entry_mode == "headache" else None
+            ),
+            "active_medication": (
+                self.active_medication if self.entry_mode == "medication" else None
+            ),
         }

src/reachy_mini_conversation_app/langgraph_agent/nodes/report_builder.py

@@ -1,7 +1,8 @@
 import asyncio
+import logging
 import uuid
 from datetime import datetime
-from typing import Dict, Any
+from typing import Dict, Any, List
 
 from langchain_core.messages import AIMessage
 from langgraph.graph.ui import push_ui_message
@@ -9,6 +10,8 @@ from langgraph.graph.ui import push_ui_message
 from reachy_mini_conversation_app.database import MiniMinderDB
 from reachy_mini_conversation_app.config import DB_PATH
 
+logger = logging.getLogger(__name__)
+
 
 def _fetch_report_data():
     """Synchronous DB access — runs in a thread to avoid blocking the event loop."""
@@ -20,6 +23,27 @@ def _fetch_report_data():
     return headaches, medications, profile
 
 
+def _fetch_graph_insights() -> List[Dict[str, Any]]:
+    """Attempt to fetch pattern insights from Neo4j — runs in a thread."""
+    try:
+        from reachy_mini_conversation_app.session_enrichment import (
+            get_session_enrichment,
+        )
+
+        enrichment = get_session_enrichment()
+        if not enrichment or not enrichment._graph:
+            return []
+
+        from reachy_mini_conversation_app.pattern_detector import PatternDetector
+
+        detector = PatternDetector(enrichment._graph)
+        insights = detector.run_analysis()
+        return [i.to_dict() for i in insights]
+    except Exception as e:
+        logger.debug("Graph insights not available for report: %s", e)
+        return []
+
+
 def _save_report(
     report_type: str, title: str, content: str, metadata: dict | None = None
 ) -> int:
@@ -33,6 +57,9 @@ def _save_report(
 async def report_builder_node(state: Dict[str, Any]):
     headaches, medications, profile = await asyncio.to_thread(_fetch_report_data)
 
+    # Fetch graph insights
+    graph_insights = await asyncio.to_thread(_fetch_graph_insights)
+
     display_name = profile.get("display_name", "User")
     title = f"Health Report for {display_name}"
 
@@ -63,10 +90,25 @@ async def report_builder_node(state: Dict[str, Any]):
         f"Total entries: {len(medications)}",
         "\n### Headache Diary",
         f"Total episodes logged: {len(headaches)}",
-        "\n### Professional Notes",
-        "Patient shows consistent tracking. Intensity remains stable.",
     ]
 
+    # Add graph pattern insights if available
+    if graph_insights:
+        contentLines.append("\n### Patterns & Correlations")
+        for gi in graph_insights:
+            summary = gi.get("summary", "")
+            pattern_type = gi.get("pattern_type", "")
+            contentLines.append(f"- **{pattern_type}:** {summary}")
+            if gi.get("detail"):
+                contentLines.append(f"  _{gi['detail']}_")
+
+    contentLines.extend(
+        [
+            "\n### Professional Notes",
+            "Patient shows consistent tracking. Intensity remains stable.",
+        ]
+    )
+
     accumulated_content = ""
     for line in contentLines:
         accumulated_content += line + "\n"

src/reachy_mini_conversation_app/langgraph_agent/nodes/trend_analyzer.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
-from typing import Dict, Any
+import logging
+from typing import Dict, Any, List
 from langchain_core.messages import AIMessage
 from langgraph.graph.ui import push_ui_message
 from datetime import datetime
@@ -9,6 +10,8 @@ from collections import Counter
 from reachy_mini_conversation_app.database import MiniMinderDB
 from reachy_mini_conversation_app.config import DB_PATH
 
+logger = logging.getLogger(__name__)
+
 
 def _fetch_trend_data():
     """Synchronous DB access — runs in a thread to avoid blocking the event loop."""
@@ -19,11 +22,33 @@ def _fetch_trend_data():
     return headaches, profile
 
 
+def _fetch_graph_insights() -> List[Dict[str, Any]]:
+    """Attempt to fetch pattern insights from Neo4j — runs in a thread."""
+    try:
+        from reachy_mini_conversation_app.session_enrichment import (
+            get_session_enrichment,
+        )
+
+        enrichment = get_session_enrichment()
+        if not enrichment or not enrichment._graph:
+            return []
+
+        from reachy_mini_conversation_app.pattern_detector import PatternDetector
+
+        detector = PatternDetector(enrichment._graph)
+        insights = detector.run_analysis()
+        return [i.to_dict() for i in insights]
+    except Exception as e:
+        logger.debug("Graph insights not available for trend analysis: %s", e)
+        return []
+
+
 def _save_trend_report(
     chart_data: list,
     total_episodes: int,
     worst_day: str,
     insight: str | None,
+    graph_insights: list,
     metadata: dict | None = None,
 ) -> int:
     """Save trend analysis as a report — runs in a thread."""
@@ -38,6 +63,17 @@ def _save_trend_report(
     ]
     for entry in chart_data:
         lines.append(f"- **{entry['day']}:** {entry['count']}")
+
+    if graph_insights:
+        lines.append("")
+        lines.append("### Patterns & Correlations")
+        for gi in graph_insights:
+            lines.append(
+                f"- **{gi.get('pattern_type', 'pattern')}:** {gi.get('summary', '')}"
+            )
+            if gi.get("detail"):
+                lines.append(f"  _{gi['detail']}_")
+
     if insight:
         lines.append("")
         lines.append(f"### AI Insight")
@@ -55,6 +91,9 @@ def _save_trend_report(
 async def trend_analyzer_node(state: Dict[str, Any]):
     headaches, profile = await asyncio.to_thread(_fetch_trend_data)
 
+    # Fetch graph insights in parallel with analysis
+    graph_insights = await asyncio.to_thread(_fetch_graph_insights)
+
     # 2. Analyze trends
     # Count headaches per day of week
     days_of_week = []
@@ -92,6 +131,7 @@ async def trend_analyzer_node(state: Dict[str, Any]):
         len(headaches),
         worst_day,
         insight_text,
+        graph_insights,
         {
             "doctorName": profile.get("neurologist_name"),
             "doctorEmail": profile.get("neurologist_email"),
@@ -111,6 +151,7 @@ async def trend_analyzer_node(state: Dict[str, Any]):
             "total_episodes": len(headaches),
             "worst_day": worst_day,
             "insight": insight_text,
+            "graphInsights": graph_insights,
             "doctorName": profile.get("neurologist_name"),
             "doctorEmail": profile.get("neurologist_email"),
             "savedId": saved_id,

src/reachy_mini_conversation_app/main.py

@@ -150,6 +150,7 @@ def run(
         if graph_memory.connect():
             init_session_enrichment(graph_memory=graph_memory)
             enable_session_enrichment()
+            entry_state._graph = graph_memory  # Enable write-through
             logger.info("Session enrichment enabled with Neo4j")
         else:
             init_session_enrichment(graph_memory=None)

src/reachy_mini_conversation_app/memory_graph.py

@@ -7,7 +7,7 @@ and events to support relationship-aware context for Elena and caregiver triage
 from __future__ import annotations
 
 import logging
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional
 
 try:
@@ -556,3 +556,108 @@ class GraphMemory:
             lines.append("")
 
         return "\n".join(lines)
+
+    # -----------------------------------------------------------------
+    # Cross-session entity memory
+    # -----------------------------------------------------------------
+
+    def get_entity_timeline(
+        self, entity_name: str, days: int = 30
+    ) -> List[Dict[str, Any]]:
+        """Return sessions where an entity was mentioned, with context.
+
+        Args:
+            entity_name: Name of the entity to trace (case-insensitive).
+            days: Look-back window in days.
+
+        Returns:
+            List of dicts with session_id, timestamp, relationship, and context.
+        """
+        cutoff = (datetime.now() - timedelta(days=days)).isoformat()
+        query = """
+        MATCH (n)-[r]-(e)
+        WHERE toLower(n.name) = toLower($entity_name)
+          AND (e.timestamp IS NULL OR e.timestamp >= $cutoff)
+        RETURN
+          labels(n)[0] AS entity_type,
+          n.name AS entity_name,
+          type(r) AS relationship,
+          labels(e)[0] AS related_type,
+          e.type AS event_type,
+          e.timestamp AS timestamp,
+          e.notes AS notes
+        ORDER BY e.timestamp DESC
+        LIMIT 20
+        """
+        try:
+            rows = self._execute(query, {"entity_name": entity_name, "cutoff": cutoff})
+            return [dict(r) for r in rows] if rows else []
+        except Exception as e:
+            logger.debug("Entity timeline query failed: %s", e)
+            return []
+
+    def get_cross_session_co_occurrences(
+        self, patient_name: str, days: int = 30, min_sessions: int = 2
+    ) -> List[Dict[str, Any]]:
+        """Find entities that appear together across multiple sessions.
+
+        Uses MENTIONED_WITH relationships to identify recurring co-occurrences.
+
+        Args:
+            patient_name: Patient to scope the query to.
+            days: Look-back window in days.
+            min_sessions: Minimum number of co-occurrences to include.
+
+        Returns:
+            List of co-occurrence dicts with entity pairs and counts.
+        """
+        query = """
+        MATCH (p:Person {name: $patient_name})-[:EXPERIENCED]->(e1:Event)
+        MATCH (e1)-[:MENTIONED_WITH]-(e2:Event)
+        WHERE e1.timestamp >= $cutoff AND e2.timestamp >= $cutoff
+          AND id(e1) < id(e2)
+        WITH e1.type AS type_a, e2.type AS type_b,
+             e1.notes AS notes_a, e2.notes AS notes_b,
+             count(*) AS co_count
+        WHERE co_count >= $min_sessions
+        RETURN type_a, type_b, notes_a, notes_b, co_count
+        ORDER BY co_count DESC
+        LIMIT 10
+        """
+        cutoff = (datetime.now() - timedelta(days=days)).isoformat()
+        try:
+            rows = self._execute(
+                query,
+                {
+                    "patient_name": patient_name,
+                    "cutoff": cutoff,
+                    "min_sessions": min_sessions,
+                },
+            )
+            return [dict(r) for r in rows] if rows else []
+        except Exception as e:
+            logger.debug("Co-occurrence query failed: %s", e)
+            return []
+
+    def format_entity_recall_for_prompt(
+        self, patient_name: str, days: int = 30, max_items: int = 3
+    ) -> str:
+        """Format structured entity recall for system prompt injection.
+
+        Returns a block of text summarising cross-session entity patterns
+        that can be appended to the LLM's context.
+        """
+        co_occurrences = self.get_cross_session_co_occurrences(patient_name, days=days)
+        if not co_occurrences:
+            return ""
+
+        lines = ["## Cross-Session Patterns\n"]
+        for co in co_occurrences[:max_items]:
+            type_a = co.get("type_a", "event")
+            type_b = co.get("type_b", "event")
+            count = co.get("co_count", 0)
+            lines.append(
+                f"- {type_a} and {type_b} have co-occurred {count} time(s) recently"
+            )
+
+        return "\n".join(lines)

src/reachy_mini_conversation_app/openai_realtime.py

@@ -153,7 +153,11 @@ class OpenaiRealtimeHandler(RealtimeHandler):
 
             # Patient context from Neo4j
             if enrichment and enrichment._graph:
-                patient_name = profile.get("name") if profile else None
+                patient_name = (
+                    (profile.get("display_name") or profile.get("name"))
+                    if profile
+                    else None
+                )
                 if patient_name:
                     ctx = enrichment._graph.format_context_for_prompt(patient_name)
                     if ctx:
@@ -170,6 +174,17 @@ class OpenaiRealtimeHandler(RealtimeHandler):
                 if insights_text:
                     graph_parts.append(insights_text)
 
+            # Cross-session entity memory (co-occurrences)
+            if enrichment and enrichment._graph and patient_name:
+                try:
+                    entity_recall = enrichment._graph.format_entity_recall_for_prompt(
+                        patient_name
+                    )
+                    if entity_recall:
+                        graph_parts.append(entity_recall)
+                except Exception:
+                    pass  # Entity recall is optional
+
             if graph_parts:
                 state.graph_context = "\n\n".join(graph_parts)
                 logger.info(
@@ -909,6 +924,43 @@ class OpenaiRealtimeHandler(RealtimeHandler):
                                 "If this IS the welcome step, introduce yourself warmly. "
                                 "You MUST respond in British English only."
                             )
+                        elif tool_name in (
+                            "check_medication",
+                            "check_health_patterns",
+                            "session_summary",
+                            "query_health_history",
+                        ):
+                            # These tools emit GenUI *and* return a message
+                            # that MUST be spoken aloud so the user hears it.
+                            force_speech = True
+                            resp_instructions = (
+                                "The information is now displayed on screen. "
+                                "You MUST speak the 'message' from the tool result aloud to the user "
+                                "so they understand what they are seeing. Be warm and conversational. "
+                                "You MUST respond in British English only."
+                            )
+                        elif tool_name == "log_entry":
+                            # After logging an entry, the robot MUST speak to
+                            # confirm details with the user before saving.
+                            force_speech = True
+                            resp_instructions = (
+                                "The entry details are now shown on screen. "
+                                "You MUST speak to the user. Summarise what you have recorded "
+                                "and ask the user to confirm it is correct before saving. "
+                                "Say something like 'I have [details]. Shall I save this?' "
+                                "NEVER call entry_control(save) without the user's explicit verbal confirmation. "
+                                "You MUST respond in British English only."
+                            )
+                        elif tool_name == "entry_control":
+                            # After saving/discarding, the robot should confirm
+                            force_speech = True
+                            resp_instructions = (
+                                "The entry has been processed. "
+                                "Briefly confirm to the user what happened — "
+                                "e.g. 'Done, that's been saved.' or 'No worries, I've discarded it.' "
+                                "Keep it short and warm. "
+                                "You MUST respond in British English only."
+                            )
                         else:
                             resp_instructions = (
                                 "Use the tool result just returned and answer concisely in speech. "

src/reachy_mini_conversation_app/profiles/_reachy_mini_minder_locked_profile/log_entry.py

@@ -7,6 +7,7 @@ Auto-detects whether to start a new entry or update the active one.
 
 import logging
 import uuid
+from datetime import datetime, timedelta
 from typing import Any, Dict
 
 from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
@@ -97,11 +98,11 @@ class LogEntry(Tool):
             },
             "scheduled_time": {
                 "type": "string",
-                "description": "When the medication was supposed to be taken",
+                "description": "When the medication was supposed to be taken (ISO datetime, or relative like '8am', 'morning')",
             },
             "actual_time": {
                 "type": "string",
-                "description": "When the medication was actually taken",
+                "description": "When the medication was actually taken (ISO datetime, or relative like 'now', '2 hours ago', '8am')",
             },
             # ── Shared fields ──────────────────────────────────────────
             "medication_taken": {
@@ -217,6 +218,75 @@ class LogEntry(Tool):
         return result
 
     # ── Medication ─────────────────────────────────────────────────────
+
+    @staticmethod
+    def _normalize_time(raw: str) -> str:
+        """Convert LLM-provided time text to ISO datetime string.
+
+        Handles: 'now', 'just now', '8am', '8:30 PM', '2 hours ago',
+        'morning', 'evening', and already-valid ISO datetime strings.
+        """
+        import re
+
+        now = datetime.now()
+        text = raw.strip().lower()
+
+        # Already a valid ISO datetime? Return as-is.
+        try:
+            datetime.fromisoformat(raw.replace("Z", "+00:00"))
+            return raw
+        except (ValueError, TypeError):
+            pass
+
+        # "now", "just now", "right now"
+        if text in ("now", "just now", "right now"):
+            return now.strftime("%Y-%m-%d %H:%M:%S")
+
+        # Relative: "X hours/minutes ago"
+        m = re.match(r"(\d+)\s*(hours?|minutes?|mins?)\s*ago", text)
+        if m:
+            amount = int(m.group(1))
+            unit = m.group(2)
+            if unit.startswith("hour"):
+                dt = now - timedelta(hours=amount)
+            else:
+                dt = now - timedelta(minutes=amount)
+            return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+        # Bare time: "8am", "8:30pm", "14:00", "8 am"
+        m = re.match(r"(\d{1,2}):?(\d{2})?\s*(am|pm)?$", text)
+        if m:
+            hour = int(m.group(1))
+            minute = int(m.group(2) or 0)
+            ampm = m.group(3)
+            if ampm == "pm" and hour < 12:
+                hour += 12
+            elif ampm == "am" and hour == 12:
+                hour = 0
+            dt = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+            return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+        # Time-of-day words
+        _TOD_MAP = {
+            "morning": 8,
+            "this morning": 8,
+            "afternoon": 13,
+            "this afternoon": 13,
+            "evening": 18,
+            "this evening": 18,
+            "night": 21,
+            "tonight": 21,
+            "last night": 21,
+            "noon": 12,
+            "midday": 12,
+        }
+        if text in _TOD_MAP:
+            dt = now.replace(hour=_TOD_MAP[text], minute=0, second=0, microsecond=0)
+            return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+        # Can't parse — default to now
+        return now.strftime("%Y-%m-%d %H:%M:%S")
+
     async def _handle_medication(
         self, deps: ToolDependencies, fields: Dict[str, Any]
     ) -> Dict[str, Any]:
@@ -296,6 +366,34 @@ class LogEntry(Tool):
                 else:
                     is_ad_hoc = True
 
+        # ── Duplicate-awareness (soft warning, never blocks) ─────────────
+        # If this medication was already logged today, note it so the robot
+        # can mention it — but always proceed with logging. The patient
+        # said they took it, so we record it.
+        duplicate_logged_at = None
+        if med_name and esm.entry_mode != "medication" and deps.database:
+            today_status = deps.database.get_todays_medication_status()
+            for entry in today_status.get("scheduled", []):
+                if (
+                    entry.get("name", "").lower() == med_name.lower()
+                    and entry.get("status") == "logged"
+                ):
+                    duplicate_logged_at = entry.get("logged_at", "earlier today")
+                    break
+            if not duplicate_logged_at:
+                for entry in today_status.get("ad_hoc", []):
+                    if entry.get("name", "").lower() == med_name.lower():
+                        duplicate_logged_at = entry.get("logged_at", "earlier today")
+                        break
+
+        # ── Normalize time fields to ISO datetime ─���──────────────────────
+        # The LLM may send raw text like "now", "8am", "2 hours ago".
+        # Convert to proper datetime strings before storage.
+        for time_field in ("actual_time", "scheduled_time"):
+            raw = fields.get(time_field)
+            if raw and isinstance(raw, str):
+                fields[time_field] = self._normalize_time(raw)
+
         # Convert bools to ints for SQLite
         for field in ("taken", "taken_late"):
             if field in fields:
@@ -310,8 +408,35 @@ class LogEntry(Tool):
             capture_status = "capturing"
             robot_message = None
 
-        # Emit MedLog GenUI
+        # If the key field (medication_name) is present, switch to confirmation
         med_data = dict(esm.active_medication or {})
+        has_med_name = bool(
+            med_data.get("medication_name") or fields.get("medication_name")
+        )
+        if has_med_name and capture_status == "capturing":
+            capture_status = "needs_confirmation"
+            if duplicate_logged_at:
+                robot_message = (
+                    f"I have a record that you already took {med_name} "
+                    f"at {duplicate_logged_at} today."
+                )
+                result["confirmation_required"] = True
+                result["duplicate_logged_at"] = duplicate_logged_at
+                result["voice_instruction"] = (
+                    f"Factually tell the user: 'I have a record that you took "
+                    f"{med_name} at {duplicate_logged_at} today.' "
+                    f"Then ask: 'Would you still like me to log this?' "
+                    f"Do NOT save until the user confirms. Be factual, not judgmental."
+                )
+            else:
+                robot_message = "Does this look right?"
+                result["confirmation_required"] = True
+                result["voice_instruction"] = (
+                    "Summarise the medication entry and ask the user to confirm "
+                    "before saving. Do NOT save until the user says yes."
+                )
+
+        # Emit MedLog GenUI
         taken_val = med_data.get("taken")
         await emit_ui_component(
             component_name="MedLog",

src/reachy_mini_conversation_app/profiles/_reachy_mini_minder_locked_profile/tools.txt

@@ -8,6 +8,7 @@ entry_control
 get_recent_entries
 check_medication
 query_health_history
+check_health_patterns
 
 # Onboarding & setup tools (unchanged)
 get_current_datetime

src/reachy_mini_conversation_app/tools/check_health_patterns.py

@@ -0,0 +1,111 @@
+"""Check health patterns tool.
+
+A lightweight tool the LLM can invoke mid-conversation when the user
+mentions symptoms. Queries the Neo4j PatternDetector for relevant
+correlations, temporal clusters, and frequency changes, returning
+structured insight text the LLM can weave into its response.
+
+Examples:
+- User says "I have a headache" → LLM calls this to check for patterns
+- User says "I forgot my medication" → LLM checks missed-dose impact
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict
+
+from reachy_mini_conversation_app.tools.core_tools import Tool, ToolDependencies
+
+logger = logging.getLogger(__name__)
+
+
+class CheckHealthPatternsTool(Tool):
+    """Check for relevant health patterns in the knowledge graph."""
+
+    name = "check_health_patterns"
+    description = (
+        "Check the knowledge graph for health patterns relevant to what the user "
+        "just mentioned. Call this when the user reports a symptom (headache, pain, "
+        "fatigue, etc.) or mentions missing medication. Returns observational insights "
+        "about correlations and temporal patterns. Use the returned insights naturally "
+        "in conversation — never state them as medical facts."
+    )
+    parameters_schema = {
+        "type": "object",
+        "properties": {
+            "symptom_or_context": {
+                "type": "string",
+                "description": (
+                    "What the user mentioned (e.g., 'headache', 'missed medication', "
+                    "'feeling tired'). Used to filter relevant patterns."
+                ),
+            },
+        },
+        "required": ["symptom_or_context"],
+    }
+
+    async def __call__(
+        self,
+        deps: ToolDependencies,
+        symptom_or_context: str = "",
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        graph = deps.graph_memory
+        if not graph or not getattr(graph, "is_connected", False):
+            logger.debug("Neo4j not available for pattern check")
+            return {"patterns_found": 0, "insights": []}
+
+        try:
+            from reachy_mini_conversation_app.pattern_detector import PatternDetector
+
+            detector = PatternDetector(graph)
+            all_insights = detector.run_analysis()
+
+            if not all_insights:
+                return {"patterns_found": 0, "insights": []}
+
+            # Filter for relevance to the mentioned symptom/context
+            keyword = symptom_or_context.lower()
+            relevant = []
+            for insight in all_insights:
+                summary_lower = insight.summary.lower()
+                detail_lower = (insight.detail or "").lower()
+                # Include if the insight mentions the keyword or is high-confidence
+                if (
+                    keyword in summary_lower
+                    or keyword in detail_lower
+                    or insight.confidence >= 0.7
+                ):
+                    relevant.append(
+                        {
+                            "pattern_type": insight.pattern_type,
+                            "summary": insight.summary,
+                            "detail": insight.detail,
+                            "confidence": insight.confidence,
+                        }
+                    )
+
+            # Cap at 3 most relevant to keep response concise
+            relevant = relevant[:3]
+
+            if relevant:
+                logger.info(
+                    "Pattern check for '%s': %d relevant insights",
+                    symptom_or_context,
+                    len(relevant),
+                )
+
+            return {
+                "patterns_found": len(relevant),
+                "insights": relevant,
+                "guidance": (
+                    "Share these observations naturally and conversationally. "
+                    "Use language like 'I've noticed...' or 'It seems like...'. "
+                    "Never state patterns as medical facts or give medical advice."
+                ),
+            }
+
+        except Exception as e:
+            logger.warning("Pattern check failed: %s", e)
+            return {"patterns_found": 0, "insights": []}

src/reachy_mini_conversation_app/tools/check_medication.py

@@ -69,6 +69,13 @@ class CheckMedicationTool(Tool):
             await self._emit_med_status_ui(deps, conv_log_result.get("message", ""))
             return conv_log_result
 
+        # Fall back to SQLite medication_entries (the source of truth for logged meds)
+        if deps.database:
+            db_result = self._check_database(deps, medication_name, time_of_day)
+            if db_result.get("logged"):
+                await self._emit_med_status_ui(deps, db_result.get("message", ""))
+                return db_result
+
         # No record found — still show the UI
         result = self._format_no_record(medication_name, time_of_day, deps)
         await self._emit_med_status_ui(deps, result.get("message", ""))
@@ -121,7 +128,9 @@ class CheckMedicationTool(Tool):
             patient_name = "Patient"  # Default
             if deps.database:
                 profile = deps.database.get_or_create_profile()
-                patient_name = profile.get("name", "Patient")
+                patient_name = profile.get("display_name") or profile.get(
+                    "name", "Patient"
+                )
 
             result = graph.check_medication_today(
                 patient_name=patient_name,
@@ -227,6 +236,7 @@ class CheckMedicationTool(Tool):
         return {
             "logged": True,
             "message": message,
+            "voice_instruction": "Speak the message aloud to the user while they view the medication status on screen.",
             "details": result,
         }
 
@@ -256,9 +266,72 @@ class CheckMedicationTool(Tool):
         return {
             "logged": True,
             "message": message,
+            "voice_instruction": "Speak the message aloud to the user while they view the medication status on screen.",
             "details": {"source": "conversation_log", "turn": turn},
         }
 
+    def _check_database(
+        self,
+        deps: ToolDependencies,
+        medication_name: Optional[str],
+        time_of_day: Optional[str],
+    ) -> Dict[str, Any]:
+        """Check SQLite medication_entries via get_todays_medication_status."""
+        try:
+            today_status = deps.database.get_todays_medication_status()
+            scheduled = today_status.get("scheduled", [])
+            ad_hoc = today_status.get("ad_hoc", [])
+
+            # Collect all logged entries
+            logged_entries = []
+            for entry in scheduled:
+                if entry.get("status") == "logged":
+                    if medication_name:
+                        if entry.get("name", "").lower() == medication_name.lower():
+                            logged_entries.append(entry)
+                    else:
+                        logged_entries.append(entry)
+            for entry in ad_hoc:
+                if medication_name:
+                    if entry.get("name", "").lower() == medication_name.lower():
+                        logged_entries.append(entry)
+                else:
+                    logged_entries.append(entry)
+
+            if not logged_entries:
+                return {"logged": False}
+
+            # Build factual message
+            med_phrase = medication_name or "your medication"
+            if time_of_day:
+                med_phrase = f"your {time_of_day} medication"
+
+            if len(logged_entries) == 1:
+                logged_at = logged_entries[0].get("logged_at", "earlier today")
+                message = f"Yes, I have a record that you took {med_phrase} at {logged_at} today."
+            else:
+                times = [e.get("logged_at", "earlier") for e in logged_entries]
+                names = [e.get("name", "medication") for e in logged_entries]
+                if medication_name:
+                    message = (
+                        f"I have {len(logged_entries)} records of you taking "
+                        f"{med_phrase} today."
+                    )
+                else:
+                    med_list = ", ".join(f"{n} at {t}" for n, t in zip(names, times))
+                    message = f"Yes, I have records of you taking: {med_list}."
+
+            return {
+                "logged": True,
+                "message": message,
+                "voice_instruction": "Speak the message aloud to the user while they view the medication status on screen.",
+                "details": {"source": "database", "entries": logged_entries},
+            }
+
+        except Exception as e:
+            logger.warning("Database medication check failed: %s", e)
+            return {"logged": False}
+
     def _format_no_record(
         self,
         medication_name: Optional[str],
@@ -287,6 +360,7 @@ class CheckMedicationTool(Tool):
                     "What medication do you usually take? I can help you set it up "
                     "so I can remind you."
                 ),
+                "voice_instruction": "Speak the message aloud to the user.",
                 "guidance": "setup_medication",
                 "next_action": "Ask about their regular medications",
                 "details": {"reason": "no_medications_configured"},
@@ -305,6 +379,7 @@ class CheckMedicationTool(Tool):
         return {
             "logged": False,
             "message": message,
+            "voice_instruction": "Speak the message aloud to the user while they view the medication status on screen.",
             "guidance": "log_medication",
             "details": {},
         }

tests/test_wakeword_and_end_session.py

@@ -102,8 +102,8 @@ class TestWakewordDetector:
 
         detector = WakewordDetector()
         assert detector.model_name == "hey_reachy"
-        assert detector.threshold == 0.8
-        assert detector.enabled is True
+        assert detector.threshold == 0.7
+        assert detector.enabled is False
 
     def test_disabled_returns_false(self):
         """When disabled, feed() should always return False."""
@@ -176,8 +176,8 @@ class TestWakewordDetector:
     def test_feed_triggers_on_sustained_high_confidence(self):
         """Sustained high-confidence predictions should trigger detection.
 
-        With _PATIENCE_FRAMES=3, the model's prediction_buffer must contain
-        3 consecutive above-threshold scores before detection fires.
+        With _PATIENCE_FRAMES=1, the model's prediction_buffer must contain
+        at least 1 above-threshold score before detection fires.
         """
         from reachy_mini_conversation_app.wakeword_detector import (
             WakewordDetector,
@@ -186,7 +186,7 @@ class TestWakewordDetector:
         from collections import defaultdict, deque
         from functools import partial
 
-        detector = WakewordDetector(threshold=0.5)
+        detector = WakewordDetector(threshold=0.5, enabled=True)
         mock_model = MagicMock()
         mock_model.predict.return_value = {"hey_reachy": 0.95}
         # Pre-populate prediction_buffer with enough consecutive high scores
@@ -213,7 +213,7 @@ class TestWakewordDetector:
         from collections import defaultdict, deque
         from functools import partial
 
-        detector = WakewordDetector(threshold=0.5)
+        detector = WakewordDetector(threshold=0.5, enabled=True)
         mock_model = MagicMock()
         # Simulate: one high score, then low
         mock_model.predict.side_effect = [
@@ -230,11 +230,8 @@ class TestWakewordDetector:
         audio = np.random.randint(-5000, 5000, 1280 * 3, dtype=np.int16)
         result = detector.feed(audio, 16000)
 
-        # The spike should NOT trigger because our consecutive-hit check
-        # requires 3 consecutive above-threshold scores in prediction_buffer,
-        # and we only have 1.
-        # Note: with mock, prediction_buffer isn't auto-populated by predict(),
-        # so the first spike will see an empty buffer and be blocked.
+        # The spike should NOT trigger because the prediction_buffer is empty
+        # (mock doesn't auto-populate it), so the consecutive-hit check blocks.
         # Verify predict was called WITHOUT patience kwargs
         call_kwargs = mock_model.predict.call_args_list[0]
         assert len(call_kwargs[1]) == 0  # no keyword args (no patience/threshold)
@@ -243,14 +240,14 @@ class TestWakewordDetector:
         """Input at 48kHz should be resampled to 16kHz internally."""
         from reachy_mini_conversation_app.wakeword_detector import WakewordDetector
 
-        detector = WakewordDetector()
+        detector = WakewordDetector(enabled=True)
         mock_model = MagicMock()
         mock_model.predict.return_value = {"hey_reachy": 0.0}
         detector._model = mock_model
         detector._initialised = True
 
         # 4800 samples at 48kHz → 1600 samples at 16kHz (> 1280 chunk)
-        # Use loud audio to pass the RMS energy gate
+        # Use loud audio to pass the RMS energy gate (> _MIN_RMS_ENERGY)
         audio_48k = np.random.randint(-5000, 5000, 4800, dtype=np.int16)
         detector.feed(audio_48k, 48000)
         # Model should have been called with prediction