alive-ai 0.1.13 → 0.1.15

package/README.md

@@ -31,7 +31,7 @@ The emotional layer now has real runtime consequences:
 | Complex emotions | Guilt, pride, jealousy, embarrassment, and anticipation. | They do not just label the dashboard. They push fear, sadness, anger, dominance, trust, arousal, joy, and future-facing behavior in different directions. |
 | Hormones | Oxytocin, dopamine, serotonin, cortisol, melatonin, plus residual metabolites. | Hormones modulate perception, soul valence/arousal, emotional deltas, somatic body state, interoception, impulse probability, and prompt guidance. Stress makes her more vigilant; bonding increases trust; dopamine increases pursuit; serotonin stabilizes; melatonin slows her down. |
 | Internal body state | Energy, arousal, certainty, social satiety, cognitive load, connection craving, body sensations, and somatic memories. | The body state is persisted and feeds prompt tone, sleep/rest behavior, and whether she feels steady, overloaded, touchy, open, or withdrawn. |
-| Circadian rhythm | Phase, sleep pressure, sleep debt, forced-awake windows, sleep cycle ID, wake time, and sleepiness. | She becomes sleepy, slows down, falls asleep, stops outward proactive behavior while asleep, can be woken by a message, recovers sleep debt, and wakes with lower or higher energy depending on rest. |
+| Circadian rhythm | Phase, sleep pressure, sleep debt in hours, forced-awake windows, sleep cycle ID, wake time, and sleepiness. | She becomes sleepy, slows down, falls asleep, stops outward proactive behavior while asleep, can be woken by a message, recovers sleep debt, and wakes with lower or higher energy depending on rest. After 2am, high sleep pressure shortens user wake-up windows so she can drift back to sleep instead of staying pinned awake. |
 | Dreams | One normalized dream per sleep cycle, generated from memory fragments and emotion tags. | Dreams are saved, can appear in morning context, and are exposed in the dashboard and static Pages demo. |
 | Narrative | Relationship phase (first_meeting → bonded) tracked per user. Key moments are detected from message content. | Phase and moment count are injected into the LLM prompt each turn. The dashboard shows the current phase and total key moments. |
 | Curiosity | Per-user knowledge map across topics detected in messages. Topics range from 0 (unknown) to 1 (well-understood). | When knowledge on a topic is below 0.3 she asks a direct question. At 40% probability otherwise she surfaces curiosity as a prompt hint. Dashboard shows topics sorted by curiosity level. |
@@ -277,7 +277,13 @@ The real WebUI streams local runtime state over Server-Sent Events and shows:
 - attachment, circadian rhythm, sleepiness, body memory, dreams, curiosity, and conflicts,
 - runtime health through local endpoints.
 
-The WebUI script is intentionally shipped as a single static file because the npm package has to run locally without a frontend build step. `npm run smoke` compiles the Python modules and checks the CLI; release validation also parses the embedded dashboard script so tab navigation, chat, settings, and thought rendering cannot be broken by a syntax error.
+The WebUI hydrates from durable runtime stores instead of only the current browser session. It resolves the active dashboard user from explicit WebUI input, live Telegram activity, configured owner ID, runtime state, and finally the most active user folder on disk. Chat rows are journaled per active user under `data/users/<user>/webui_chat.jsonl` and merged with episodic Telegram conversation history, including legacy flat `data/conversations` history after upgrades. `/state` and the SSE stream now use the same composed snapshot: visible chat, runtime state, soul state, aliveness state, current thoughts, memory counters, and the active dashboard user.
+
+Sleep debt is stored and shown as hours on a 0-8h pressure scale. The UI no longer reports it as a misleading capped percentage, so a persisted `5.6h` debt displays as `5.6h` with the matching pressure bar.
+
+Settings edits validate JSON before saving and write atomically, so a bad edit cannot corrupt the existing config file. The Settings tab also protects unsaved edits while switching tabs.
+
+The WebUI script is intentionally shipped as a single static file because the npm package has to run locally without a frontend build step. `npm run smoke` compiles the Python modules and checks the CLI; release validation also parses the embedded dashboard script and verifies required dashboard hooks so tab navigation, chat, settings, and thought rendering cannot be broken by a syntax error.
 
 GitHub Pages cannot run the Python/FastAPI backend, so the public page includes a static export of the actual WebUI with mocked state:
 

package/brain/default_mode.py

@@ -251,7 +251,8 @@ class DefaultModeProcessor:
         if data_path:
             self.data_path = data_path
         else:
-            self.data_path = Path(__file__).parent.parent / "data"
+            from core.paths import data_dir
+            self.data_path = data_dir()
 
         self.data_path.mkdir(parents=True, exist_ok=True)
 

package/cli/check_webui_static.js

@@ -26,4 +26,20 @@ if (count === 0) {
 }
 
 JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+for (const page of ["home", "chat", "settings"]) {
+  if (!html.includes(`data-page="${page}"`)) {
+    console.error(`Missing bottom-nav data-page="${page}" hook.`);
+    process.exit(1);
+  }
+  if (!html.includes(`id="page-${page}"`)) {
+    console.error(`Missing page container #page-${page}.`);
+    process.exit(1);
+  }
+}
+for (const required of ["/static/manifest.json", "/static/icon.svg"]) {
+  if (!html.includes(required)) {
+    console.error(`Missing static asset reference: ${required}`);
+    process.exit(1);
+  }
+}
 console.log(`WebUI static check passed (${count} inline script parsed).`);

package/core/message_handler.py

@@ -264,11 +264,13 @@ def _get_or_create_user_memory(self, user_id: str):
     if cache_key in _user_memories:
         return _user_memories[cache_key]
 
-    # Create new memory instance for this user using INSTANCE-SPECIFIC data path
+    # Create new memory instance for this user using the canonical per-user path.
     from brain.memory import Memory
+    from core.user_manager import UserManager
 
-    # Use instance's data path (self.base / "data") for proper isolation
-    instance_data_path = self.base / "data"
+    user_manager = UserManager()
+    user_manager.migrate_legacy_data(user_id)
+    instance_data_path = user_manager.get_user_paths(user_id)["base"]
 
     memory = Memory(
         nervous=self.nervous,
@@ -462,6 +464,7 @@ async def _process_single_message(self, data: dict):
         if self._subconscious: self._subconscious.register_interaction()
         if chat_id: self._default_chat_id = chat_id
         text = data.get("text", "")
+        message_id = data.get("message_id")
 
         circadian_interaction = {}
         if CIRCADIAN_AVAILABLE:
@@ -786,7 +789,7 @@ async def _process_single_message(self, data: dict):
         # Track if we asked a question (for follow-ups)
         _follow_up.record_message_sent(response)
 
-        await _send_response(self, response, emotion, chat_id, text, user_id)
+        await _send_response(self, response, emotion, chat_id, text, user_id, message_id=message_id)
         if self._subconscious: _feed_learning(self._subconscious, text)
 
         # Actually send the media (we already decided what to send)
@@ -1094,7 +1097,7 @@ IMPORTANT: You are sending this media ALONG with your message. Reference it natu
         return fallback_response(emotion, msg)
 
 
-async def _send_response(self, response, emotion, chat_id, text, user_id="default"):
+async def _send_response(self, response, emotion, chat_id, text, user_id="default", message_id=None):
     mood = emotion.get("mood", "neutral")
 
     # Process any action tags in the response (pass instance config path)
@@ -1123,9 +1126,19 @@ async def _send_response(self, response, emotion, chat_id, text, user_id="defaul
                 "chat_id": chat_id,
                 "fallback_text": response,
                 "mood": mood,
+                "user_id": user_id,
+                "reply_to_message_id": message_id,
+                "source": "runtime",
             })
             return
-    await self.nervous.emit("send_text", {"text": response, "mood": mood, "chat_id": chat_id})
+    await self.nervous.emit("send_text", {
+        "text": response,
+        "mood": mood,
+        "chat_id": chat_id,
+        "user_id": user_id,
+        "reply_to_message_id": message_id,
+        "source": "runtime",
+    })
 
 
 def _process_self_authorship_actions(response: str, user_id: str = "default", self_path: Path = None) -> tuple:

package/heart/circadian.py

@@ -140,9 +140,21 @@ class CircadianEngine:
         return round(self._clamp(sleepiness), 2)
 
     def _should_auto_sleep(self, now: datetime) -> bool:
-        if self._is_forced_awake(now):
+        sleepiness = self.get_sleepiness()
+        if not (2 <= now.hour < 6 and sleepiness >= 0.85):
             return False
-        return 2 <= now.hour < 6 and self.get_sleepiness() >= 0.85
+        if not self._is_forced_awake(now):
+            return True
+        # After 2am, sleep pressure can override a user wake-up. Messages can
+        # briefly rouse her, but they should not pin her awake for another hour.
+        if sleepiness >= 0.95:
+            return True
+        try:
+            until = datetime.fromisoformat(self.forced_awake_until) if self.forced_awake_until else now
+            forced_started = until - timedelta(minutes=self._forced_awake_duration_minutes(now))
+            return (now - forced_started).total_seconds() >= 10 * 60
+        except Exception:
+            return sleepiness >= 0.9
 
     def _should_auto_wake(self, now: datetime) -> bool:
         slept = self._hours_asleep(now)
@@ -231,9 +243,21 @@ class CircadianEngine:
         self._save()
         return True
 
-    def stay_up_for_user(self, duration_minutes: int = 45):
+    def _forced_awake_duration_minutes(self, now: datetime = None) -> int:
+        now = now or self._now()
+        sleepiness = self.get_sleepiness()
+        if 2 <= now.hour < 6 and sleepiness >= 0.9:
+            return 10
+        if 0 <= now.hour < 6 and sleepiness >= 0.85:
+            return 20
+        if now.hour >= 23 and sleepiness >= 0.75:
+            return 30
+        return 45
+
+    def stay_up_for_user(self, duration_minutes: int = None):
         """User is keeping her awake past bedtime."""
         now = self._now()
+        duration_minutes = duration_minutes or self._forced_awake_duration_minutes(now)
         self.forced_awake = True
         self.forced_awake_until = (now + timedelta(minutes=duration_minutes)).isoformat()
         self.last_transition_reason = "staying_up_for_user"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alive-ai",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Local-first emotional AI runtime with memory, impulses, and a live dashboard.",
   "license": "MIT",
   "homepage": "https://vindepemarte.github.io/alive-ai/",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alive-ai-runtime"
-version = "0.1.13"
+version = "0.1.15"
 description = "Local-first emotional AI runtime with memory, impulses, and a live dashboard."
 readme = "README.md"
 requires-python = ">=3.11"

package/webui/app.py

@@ -13,6 +13,13 @@ from fastapi import FastAPI, Request, BackgroundTasks
 from fastapi.responses import HTMLResponse, StreamingResponse, FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from core.paths import data_dir, media_dir
+from .persistence import (
+    append_chat_message,
+    count_visible_messages,
+    load_chat_messages,
+    new_message_id,
+    resolve_active_user_id,
+)
 
 
 app = FastAPI(title="Alive-AI Dashboard")
@@ -21,26 +28,45 @@ app = FastAPI(title="Alive-AI Dashboard")
 _start_time = datetime.now()
 
 
-def load_persistent_stats() -> dict:
+def load_persistent_stats(active_user: str = None) -> dict:
     """Load stats from actual data sources on startup"""
     stats = {"messages": 0, "memories": 0, "evaluations": 0}
 
     # Try different base paths
     base_paths = [data_dir()]
 
-    # Count messages from conversation summaries (in users/*/summaries/)
+    if active_user:
+        try:
+            stats["messages"] = count_visible_messages(active_user)
+        except Exception:
+            pass
+
+    # Count actual per-user conversation rows and WebUI journal rows.
     for base_path in base_paths:
         try:
-            # Look for summaries in users/*/summaries/
             users_path = base_path / "users"
             if users_path.exists():
                 count = 0
                 for user_dir in users_path.iterdir():
-                    summaries_path = user_dir / "summaries"
-                    if summaries_path.exists():
-                        count += len(list(summaries_path.glob("*.json")))
+                    conv_path = user_dir / "conversations"
+                    if conv_path.exists():
+                        for conv_file in conv_path.glob("*.jsonl"):
+                            with conv_file.open() as fh:
+                                for line in fh:
+                                    try:
+                                        row = json.loads(line)
+                                        if row.get("user"):
+                                            count += 1
+                                        if row.get("ai"):
+                                            count += 1
+                                    except Exception:
+                                        continue
+                    journal_path = user_dir / "webui_chat.jsonl"
+                    if journal_path.exists():
+                        with journal_path.open() as fh:
+                            count += sum(1 for _ in fh)
                 if count > 0:
-                    stats["messages"] = count
+                    stats["messages"] = max(stats["messages"], count)
                     break
         except Exception:
             pass
@@ -245,6 +271,79 @@ aliveness_state = {
 }
 
 
+def _active_user_id(explicit=None) -> str:
+    return resolve_active_user_id(explicit, self_ref=_self_ref, dashboard_state=alive_ai_state)
+
+
+def _runtime_state_dict() -> dict:
+    runtime_state = getattr(_self_ref, "state", None)
+    if runtime_state and hasattr(runtime_state, "to_dict"):
+        try:
+            return runtime_state.to_dict()
+        except Exception:
+            return {}
+    return {}
+
+
+def _runtime_chat_ready() -> bool:
+    nervous = getattr(_self_ref, "nervous", None)
+    listeners = getattr(nervous, "listeners", {}) if nervous else {}
+    # Bridge registers one listener; the runtime handler is attached during Self.start().
+    return len(listeners.get("message_received", [])) > 1
+
+
+def _subconscious_thoughts(limit: int = 10) -> list:
+    thoughts = []
+    sub = getattr(_self_ref, "_subconscious", None)
+    wm = getattr(sub, "working_memory", None)
+    if wm and hasattr(wm, "get_recent_thoughts"):
+        try:
+            for thought in wm.get_recent_thoughts(limit):
+                thoughts.append({
+                    "thought": getattr(thought, "content", ""),
+                    "type": getattr(thought, "type", "reflection"),
+                    "emotion": getattr(thought, "emotion", {}) or {},
+                    "time": _format_time(getattr(thought, "created_at", None)),
+                })
+        except Exception:
+            thoughts = []
+    if thoughts:
+        return thoughts[-limit:]
+    return alive_ai_state.get("recent_thoughts", [])[-limit:]
+
+
+def _format_time(value) -> str:
+    if not value:
+        return datetime.now().strftime("%H:%M:%S")
+    try:
+        if isinstance(value, datetime):
+            return value.strftime("%H:%M:%S")
+        return datetime.fromisoformat(str(value)).strftime("%H:%M:%S")
+    except Exception:
+        text = str(value)
+        return text[11:19] if len(text) >= 19 else text
+
+
+def build_snapshot(user_id: str = None) -> dict:
+    """Compose the dashboard state from live and durable runtime stores."""
+    active_user = _active_user_id(user_id)
+    snapshot = dict(alive_ai_state)
+    snapshot["active_user"] = active_user
+    snapshot["runtime"] = _runtime_state_dict()
+    snapshot["soul"] = soul_state
+    snapshot["aliveness"] = aliveness_state
+    snapshot["conversation"] = load_chat_messages(active_user)
+    snapshot["stats"] = {
+        **snapshot.get("stats", {}),
+        **load_persistent_stats(active_user),
+    }
+    thoughts = _subconscious_thoughts()
+    snapshot["recent_thoughts"] = thoughts
+    snapshot["current_thought"] = thoughts[-1]["thought"] if thoughts else alive_ai_state.get("current_thought")
+    snapshot["updated_at"] = datetime.now().isoformat()
+    return snapshot
+
+
 def update_state(data: dict):
     """Called by nervous system to update state"""
     global alive_ai_state
@@ -255,15 +354,24 @@ def update_state(data: dict):
         client.set()
 
 
-def add_conversation(role: str, content: str):
+def add_conversation(role: str, content: str, message_id: str = None,
+                     status: str = "sent", user_id: str = None,
+                     source: str = "runtime"):
     """Add a message to conversation history"""
+    if message_id and any(m.get("message_id") == message_id for m in alive_ai_state["conversation"]):
+        return
     alive_ai_state["conversation"].append({
+        "message_id": message_id or new_message_id(role),
         "role": role,
         "content": content,
-        "time": datetime.now().strftime("%H:%M:%S")
+        "time": datetime.now().strftime("%H:%M:%S"),
+        "status": status,
+        "source": source,
     })
     # Keep last 20 messages
     alive_ai_state["conversation"] = alive_ai_state["conversation"][-20:]
+    if user_id:
+        alive_ai_state["active_user"] = user_id
     if role == "user":
         alive_ai_state["last_user_message"] = content
     else:
@@ -316,7 +424,7 @@ async def event_generator(request: Request):
 
     try:
         # Send initial state
-        yield f"event: state\ndata: {json.dumps(alive_ai_state)}\n\n"
+        yield f"event: state\ndata: {json.dumps(build_snapshot())}\n\n"
 
         while True:
             if await request.is_disconnected():
@@ -331,7 +439,7 @@ async def event_generator(request: Request):
                 continue
 
             # Send updated state
-            yield f"event: state\ndata: {json.dumps(alive_ai_state)}\n\n"
+            yield f"event: state\ndata: {json.dumps(build_snapshot())}\n\n"
     except asyncio.CancelledError:
         pass  # Client disconnected normally
     except Exception as e:
@@ -372,7 +480,7 @@ async def sse_events(request: Request):
 @app.get("/state")
 async def get_state():
     """Get current state (for polling fallback)"""
-    return alive_ai_state
+    return build_snapshot()
 
 
 @app.get("/avatar")
@@ -407,7 +515,7 @@ async def health():
 @app.get("/api/stats")
 async def get_persistent_stats():
     """Get stats refreshed from actual data sources"""
-    stats = load_persistent_stats()
+    stats = load_persistent_stats(_active_user_id())
 
     # Update global state with fresh stats
     alive_ai_state["stats"] = stats
@@ -456,9 +564,10 @@ async def get_memory_status():
 @app.get("/thoughts")
 async def get_thoughts():
     """Get recent thoughts from subconscious"""
+    thoughts = _subconscious_thoughts()
     return {
-        "current_thought": alive_ai_state.get("current_thought"),
-        "recent_thoughts": alive_ai_state.get("recent_thoughts", [])
+        "current_thought": thoughts[-1]["thought"] if thoughts else alive_ai_state.get("current_thought"),
+        "recent_thoughts": thoughts
     }
 
 
@@ -726,7 +835,7 @@ async def get_memory_state():
     # Try to get fresh data from emotional memory system
     try:
         from brain.emotional_memory import get_emotional_memory_system
-        system = get_emotional_memory_system()
+        system = get_emotional_memory_system(_active_user_id())
         stats = system.get_stats()
         recent_high = system.get_recent_high_emotion(hours=24, limit=1)
 
@@ -851,8 +960,7 @@ async def get_new_aliveness():
     try:
         from brain.narrative import get_narrative_engine
         ne = get_narrative_engine()
-        from core.settings import get as settings_get
-        owner_id = str(settings_get("TELEGRAM_OWNER_ID", ""))
+        owner_id = _active_user_id()
 
         # Fallback: when owner_id is empty (terminal mode), find the most active user
         if not owner_id:
@@ -887,7 +995,7 @@ async def get_new_aliveness():
 
             result["narrative"] = {
                 "phase": data.get("phase", "first_meeting"),
-                "message_count": msg_count,
+                "message_count": max(msg_count, count_visible_messages(owner_id)),
                 "moments": len(data.get("key_moments", []))
             }
         else:
@@ -906,8 +1014,7 @@ async def get_new_aliveness():
     # Linguistic
     try:
         from brain.linguistic import get_linguistic_profile
-        from core.settings import get as settings_get
-        owner_id = str(settings_get("TELEGRAM_OWNER_ID", ""))
+        owner_id = _active_user_id()
         if owner_id:
             lp = get_linguistic_profile(owner_id)
             patterns = lp.get_absorbed_patterns() if hasattr(lp, 'get_absorbed_patterns') else {}
@@ -925,8 +1032,7 @@ async def get_new_aliveness():
     # Curiosity
     try:
         from brain.curiosity import get_curiosity_drive
-        from core.settings import get as settings_get
-        owner_id = str(settings_get("TELEGRAM_OWNER_ID", ""))
+        owner_id = _active_user_id()
 
         # Fallback: when owner_id is empty (terminal mode), find the most active user
         if not owner_id:
@@ -966,22 +1072,35 @@ async def get_new_aliveness():
 async def chat_endpoint(request: Request, background_tasks: BackgroundTasks):
     data = await request.json()
     text = data.get("text", "").strip()
-    if not text or not _self_ref:
+    if not text or not _self_ref or not _runtime_chat_ready():
         return JSONResponse({"status": "error", "message": "No text or AI not ready"}, 400)
-    # Add user message immediately to conversation
-    add_conversation("user", text)
+    user_id = _active_user_id(data.get("user_id"))
+    message_id = data.get("message_id") or new_message_id("webui_user")
+    append_chat_message(user_id, "user", text, message_id=message_id, status="pending", source="webui")
+    add_conversation("user", text, message_id=message_id, status="pending", user_id=user_id, source="webui")
     update_state({})
-    # Fire message handler in background
+
     async def _send():
-        from core.message_handler import handle_message
-        await handle_message(_self_ref, {
-            "user_id": "webui",
-            "text": text,
-            "chat_id": "webui",
-            "source": "webui"
-        })
+        try:
+            await _self_ref.nervous.emit("message_received", {
+                "message_id": message_id,
+                "user_id": user_id,
+                "webui_user_id": user_id,
+                "text": text,
+                "chat_id": "webui",
+                "source": "webui"
+            })
+        except Exception as e:
+            append_chat_message(
+                user_id,
+                "alive_ai",
+                f"Something went wrong while processing that message: {e}",
+                status="error",
+                source="webui",
+            )
+            update_state({"thinking": False})
     background_tasks.add_task(_send)
-    return JSONResponse({"status": "sent"})
+    return JSONResponse({"status": "sent", "message_id": message_id, "user_id": user_id})
 
 
 @app.get("/api/settings")
@@ -1013,13 +1132,18 @@ async def save_settings(request: Request):
     if fname not in allowed:
         return JSONResponse({"status": "error", "message": "Invalid file"}, 400)
     config_dir = Path(os.environ.get("ALIVE_AI_ROOT", ".")) / "config"
+    config_dir.mkdir(parents=True, exist_ok=True)
     p = config_dir / fname
     content = data.get("content")
     try:
         if fname.endswith(".json"):
-            p.write_text(json.dumps(content, indent=2, ensure_ascii=False))
+            text = json.dumps(content, indent=2, ensure_ascii=False) + "\n"
+            json.loads(text)
         else:
-            p.write_text(content)
+            text = str(content or "")
+        tmp = p.with_suffix(p.suffix + ".tmp")
+        tmp.write_text(text)
+        tmp.replace(p)
         return {"status": "saved"}
     except Exception as e:
         return JSONResponse({"status": "error", "message": str(e)}, 500)

package/webui/bridge.py

@@ -10,6 +10,7 @@ from .app import (
     update_interoceptive_state, update_idle_state, update_bids_state,
     update_memory_state, update_inconsistency_state
 )
+from .persistence import append_chat_message, new_message_id, resolve_active_user_id
 
 _webui_server = None
 
@@ -46,16 +47,25 @@ def init_bridge(nervous, ai=None):
 
     async def on_message_sent(data):
         """Track outgoing messages"""
-        text = data.get("text", "")
-        add_conversation("alive_ai", text)
+        text = data.get("text") or data.get("fallback_text", "")
+        user_id = resolve_active_user_id(data.get("user_id"), dashboard_state=alive_ai_state)
+        message_id = data.get("message_id") or new_message_id("alive_ai")
+        append_chat_message(user_id, "alive_ai", text, message_id=message_id,
+                            status="sent", source=data.get("source", "runtime"))
+        add_conversation("alive_ai", text, message_id=message_id, user_id=user_id,
+                         source=data.get("source", "runtime"))
         alive_ai_state["stats"]["messages"] = alive_ai_state["stats"].get("messages", 0) + 1
         update_state({})
 
     async def on_message_received(data):
         """Track incoming messages"""
         text = data.get("text", "")
-        user_id = data.get("user_id", "unknown")
-        add_conversation("user", text)
+        user_id = resolve_active_user_id(data.get("webui_user_id") or data.get("user_id"), dashboard_state=alive_ai_state)
+        message_id = data.get("message_id") or new_message_id("user")
+        append_chat_message(user_id, "user", text, message_id=message_id,
+                            status="sent", source=data.get("source", "runtime"))
+        add_conversation("user", text, message_id=message_id, user_id=user_id,
+                         source=data.get("source", "runtime"))
         # Track active user
         alive_ai_state["active_user"] = user_id