Update app.py

app.py

@@ -1458,7 +1458,6 @@ class LibrarianCurve:
 class LibrarianModule(LibrarianCurve, IModule):
     def __init__(self, hive_instance: "Hive"):
         IModule.__init__(self, hive_instance)
-        LibrarianCurve.__init__(self, hive_instance.store, hive_instance.k_store)
 
 class VoiceServicesModule(IModule):
     def __init__(self, hive_instance: "Hive"):
@@ -1478,6 +1477,8 @@ class VoiceServicesModule(IModule):
 # ----------- Hive core -----------
 # --- Memory & Manifest Helpers (auto-inserted) ---
 import tempfile, urllib.request, tarfile, zipfile
+from collections import OrderedDict
+from concurrent.futures import ThreadPoolExecutor
 import importlib
 from pathlib import Path as _Path
 
@@ -1527,6 +1528,42 @@ class PromptCompiler:
         
         return f"{head} {insight}\n\nUser: {final_instruction}\nAssistant:"
 
+class KnowledgeStoreModule(KnowledgeStore, IModule):
+    def __init__(self, hive_instance: "Hive"): IModule.__init__(self, hive_instance); KnowledgeStore.__init__(self, hive_instance.config["HIVE_HOME"])
+    def start(self): pass
+    def stop(self): pass
+
+class CurveStoreModule(CurveStore, IModule):
+    def __init__(self, hive_instance: "Hive"):
+        IModule.__init__(self, hive_instance)
+        CurveStore.__init__(self, hive_instance.config["CURVE_DIR"])
+    def start(self): pass
+    def stop(self): pass
+
+class LibrarianModule(LibrarianCurve, IModule):
+    def __init__(self, hive_instance: "Hive"):
+        IModule.__init__(self, hive_instance)
+        LibrarianCurve.__init__(self, hive_instance.store, hive_instance.k_store)
+
+class EngineModule(EngineCurve, IModule):
+    def __init__(self, hive_instance: "Hive"):
+        IModule.__init__(self, hive_instance)
+        EngineCurve.__init__(self)
+    def start(self): pass
+    def stop(self): pass
+
+class OverlayModule(RuntimeOverlay, IModule):
+    def __init__(self, hive_instance: "Hive"):
+        IModule.__init__(self, hive_instance)
+        RuntimeOverlay.__init__(self)
+    def start(self): self.apply_to(self.hive)
+    def stop(self): pass
+
+class CompilerModule(PromptCompiler, IModule):
+    def __init__(self, hive_instance: "Hive"): IModule.__init__(self, hive_instance); PromptCompiler.__init__(self); hive_instance.decoding_temperature=0.7
+    def start(self): pass
+    def stop(self): pass
+
 class Hive:
     def __init__(self, model_id: Optional[str]=None, device: Optional[str]=None, caps: Optional[Dict]=None, lite: bool = False):
         self.config = CFG
@@ -1534,23 +1571,7 @@ class Hive:
         self.lite_mode = lite
         self.module_manager = ModuleManager()
         Hive.bootstrap_instance = None # Class attribute to hold bootstrap instance
-
-        # Define Module classes here to resolve NameError during initialization
-        class KnowledgeStoreModule(KnowledgeStore, IModule):
-            def __init__(self, hive_instance: "Hive"): IModule.__init__(self, hive_instance); KnowledgeStore.__init__(self, hive_instance.config["HIVE_HOME"])
-            def start(self): pass
-            def stop(self): pass
-        class CurveStoreModule(CurveStore, IModule):
-            def __init__(self, hive_instance: "Hive"): IModule.__init__(self, hive_instance); CurveStore.__init__(self, hive_instance.config["CURVE_DIR"])
-            def start(self): pass
-            def stop(self): pass
-        class PersistenceEngine(IModule):
-            def __init__(self, hive_instance: "Hive"): IModule.__init__(self, hive_instance)
-            def start(self): pass
-            def stop(self): pass
-        class VoiceServicesModule(IModule):
-            def __init__(self, hive_instance: "Hive"): IModule.__init__(self, hive_instance)
-
+        
         if not model_id:
             model_id, info = pick_model(self.caps)
             device = info.get("device", "cpu")
@@ -1569,21 +1590,29 @@ class Hive:
 
     def _init_full_mode(self):
         """Initializes the Hive in full-featured mode."""
-        print("[Hive] Initializing in Full Mode.")
-        # CRITICAL FIX: Initialize kstore first as other modules depend on it.
-        self.module_manager.register("kstore", KnowledgeStoreModule(self))
-        self.module_manager.register("store", CurveStoreModule(self))
-        self.module_manager.register("librarian", LibrarianModule(self))
-        self.module_manager.register("engine", EngineModule(self))
-        self.module_manager.register("overlay", OverlayModule(self))
-        self.module_manager.register("changes", ChangeManagerModule(self))
-        self.module_manager.register("compiler", CompilerModule(self))
-        self.module_manager.register("voice_video", VoiceServicesModule(self))
-        self.module_manager.register("persistence", PersistenceEngine(self))
-        self.dialogue_manager = DialogueManager(self) # type: ignore
+        print("[Hive] Initializing in Full Mode (parallel module loading).")
+        
+        # Modules with dependencies are loaded first, sequentially.
+        self.module_manager.register("kstore", KnowledgeStoreModule(self)) # Depends on nothing
+        self.module_manager.register("store", CurveStoreModule(self))     # Depends on nothing
+        self.module_manager.register("librarian", LibrarianModule(self)) # Depends on kstore, store
+        self.module_manager.register("compiler", CompilerModule(self))   # Depends on nothing
+        
+        # Independent modules can be loaded in parallel to speed up startup.
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = {
+                executor.submit(lambda: self.module_manager.register("engine", EngineModule(self))),
+                executor.submit(lambda: self.module_manager.register("overlay", OverlayModule(self))),
+                executor.submit(lambda: self.module_manager.register("changes", ChangeManagerModule(self))),
+                executor.submit(lambda: self.module_manager.register("voice_video", VoiceServicesModule(self))),
+                executor.submit(lambda: self.module_manager.register("persistence", PersistenceEngine(self))),
+                executor.submit(lambda: self.module_manager.register("selfopt", SelfOptimizerModule(self))),
+            }
+            for future in futures:
+                future.result() # Wait for all parallel tasks to complete
 
+        self.dialogue_manager = DialogueManager(self)
         self._setup_llm_pipeline()
-
         self.module_manager.start_all()
 
     def _load_local_model(self, trust: bool, **kwargs):
@@ -1776,366 +1805,595 @@ class Hive:
             yield "[Error: Local model is not available]"
             return
         from transformers import TextIteratorStreamer
-
-        # Create streamer and prepare inputs correctly on the target device
         streamer = TextIteratorStreamer(self.tok, skip_prompt=True, skip_special_tokens=True)
-
-        inputs = self.tok([prompt], return_tensors="pt")
-        try:
-            # Move each tensor to the configured device (cpu/cuda)
-            device = torch.device(self.device) if (torch is not None) else None
-            if device is not None:
-                inputs = {k: v.to(device) for k, v in inputs.items()}
-        except Exception:
-            # Best-effort: keep inputs as-is if device move fails
-            pass
-
-        # Build explicit kwargs for model.generate (use input_ids / attention_mask)
-        gen_kwargs = {
-            "input_ids": inputs.get("input_ids"),
-            "attention_mask": inputs.get("attention_mask", None),
-            "streamer": streamer,
-            "max_new_tokens": int(max_new_tokens),
-            "do_sample": True,
-            "temperature": float(temperature),
-            "stopping_criteria": self.stopping_criteria
-        }
-
-        def _run_generate():
-            # Filter out None values to avoid passing unexpected kwarg values
-            safe_kwargs = {k: v for k, v in gen_kwargs.items() if v is not None}
-            try:
-                self.model.generate(**safe_kwargs)
-            except Exception as e:
-                print(f"[ModelBridge] local generate failed: {e}")
-
-        thread = threading.Thread(target=_run_generate, daemon=True)
+        inputs = self.tok([prompt], return_tensors="pt").to(self.device)
+        generation_kwargs = dict(
+            inputs,
+            streamer=streamer,
+            max_new_tokens=max_new_tokens,
+            do_sample=True,
+            temperature=temperature,
+            stopping_criteria=self.stopping_criteria
+        )
+        thread = threading.Thread(target=self.model.generate, kwargs=generation_kwargs)
         thread.start()
-
         for new_text in streamer:
             yield new_text # type: ignore
 
-    def chat(self, message: str, effective_role: str = "user", caller_id: Optional[str] = None, max_new_tokens: int = 128, temperature: float = 0.7) -> str:
-        """Synchronous convenience method for getting a reply for short interactions.
-
-        - In lite mode this uses the configured `pipe` for a single-shot generation.
-        - In full mode it prefers the DialogueManager streaming pipeline and blocks until
-          a final reply is produced.
-        """
-        try:
-            final_message, intent = self._prepare_chat_input(message, "en", False, None)
-            snippets = self._get_retrieval_context(message, effective_role, caller_id, getattr(self, 'retrieval_k', 6))
-            prompt = self.compiler.compile(final_message, snippets, intent=intent)
-
-            # Lite/local single-shot path
-            if self.lite_mode or not hasattr(self, 'dialogue_manager'):
-                try:
-                    out = self.pipe(prompt, max_new_tokens=max_new_tokens, do_sample=False, temperature=temperature)
-                    if isinstance(out, list) and out:
-                        return out[0].get("generated_text", str(out[0]))
-                    if isinstance(out, str):
-                        return out
-                    return str(out)
-                except Exception as e:
-                    return f"[Error: generation failed: {e}]"
-
-            # Full mode: prefer DialogueManager streaming API but block until final
-            try:
-                full_reply = ""
-                for chunk in self.dialogue_manager.process_turn(message, caller_id or "guest", effective_role, "cli"):
-                    if chunk.get("type") == "token":
-                        full_reply += chunk.get("content", "")
-                    elif chunk.get("type") == "final":
-                        full_reply += chunk.get("content", "")
-                        break
-                return full_reply
-            except Exception:
-                # Fallback to single-shot pipe if streaming fails
-                try:
-                    out = self.pipe(prompt, max_new_tokens=max_new_tokens, do_sample=False, temperature=temperature)
-                    if isinstance(out, list) and out:
-                        return out[0].get("generated_text", str(out[0]))
-                    return str(out)
-                except Exception as e:
-                    return f"[Error: chat failed: {e}]"
-        except Exception as e:
-            return f"[Error preparing chat: {e}]"
-
-# ----------- coverage heuristic -----------
-def coverage_score_from_snippets(snippets: list, scores: list) -> float:
-    if not snippets or not scores: return 0.0
-    s = sorted(scores, reverse=True)[:3]
-    base = sum(s) / len(s) if s else 0.0 # type: ignore
-    bonus = min(0.15, 0.03 * len(snippets))
-    return float(max(0.0, min(1.0, base + bonus)))
-
-# ----------- RBAC / users / lockouts (Restored) -----------
-USERS_DB=os.path.join(CFG["STATE_DIR"],"users.json")
-LOCKS_DB=os.path.join(CFG["STATE_DIR"],"lockouts.json")
-VOICES_DB=os.path.join(CFG["STATE_DIR"],"voices.json")
-ADAPT_DB=os.path.join(CFG["STATE_DIR"],"speech_adapt.json")
-
-def _init_users():
-    d={"owner":{"id":"owner:1","name":CFG["OWNER_NAME"],"role":"owner","pass":CFG["OWNER_PASS"],"second":CFG["OWNER_SECOND"],"prefs":{"activation_names":[CFG["AGENT_NAME"]],"language":"en"}},
-       "admins_super":[],"admins_general":[],"users":[]}
-    _save_json(USERS_DB,d); return d
-def _load_users():
-    d=_load_json(USERS_DB, None); return d if d else _init_users()
-def _find_user(d, name_or_id):
-    pools=[("owner",[d.get("owner")]),("admin_super",d.get("admins_super", [])),("admin_general",d.get("admins_general", [])),("user",d.get("users", []))]
-    for role,pool in pools:
-        for u in pool or []:
-            if u and (u.get("id")==name_or_id or u.get("name")==name_or_id): return u, role
-    return None, None
-
-PERMS={
-    "owner":{"can_add":["admin_super","admin_general","user"],"can_remove":["admin_super","admin_general","user"],
-             "can_edit_role_of":["admin_super","admin_general","user"],"can_edit_profile_of":["owner","admin_super","admin_general","user"],
-             "can_view_scopes":"all","maintenance":"full","code_edit":"approve_and_edit"},
-    "admin_super":{"can_add":["admin_general","user"],"can_remove":["admin_general","user"],
-             "can_edit_role_of":["admin_general","user"],"can_edit_profile_of":["admin_general","user"],
-             "can_view_scopes":"self_only","maintenance":"advanced","code_edit":"suggest_only"},
-    "admin_general":{"can_add":["user"],"can_remove":["user"],"can_edit_role_of":["user"],"can_edit_profile_of":["user"],
-             "can_view_scopes":"self_only","maintenance":"basic","code_edit":"suggest_only"},
-    "user":{"can_add":[],"can_remove":[],"can_edit_role_of":[],"can_edit_profile_of":["user"],
-             "can_view_scopes":"self_only","maintenance":"none","code_edit":"none"},
-    "guest":{"can_add":[],"can_remove":[],"can_edit_role_of":[],"can_edit_profile_of":[],
-             "can_view_scopes":"self_only","maintenance":"none","code_edit":"none"},
-}
+    def chat(self, message:str, effective_role:str, caller_id: Optional[str],
+             k:int=None, max_new_tokens:int=256, temperature:float=None, prompt_override: Optional[str] = None) -> str: # type: ignore
+        temp = temperature if temperature is not None else (self.decoding_temperature if not self.lite_mode else 0.7)
+        
+        user_obj, _ = _find_user(_load_users(), caller_id)
+        user_prefs = (user_obj.get("prefs", {}) or {}) if user_obj else {}
+        user_lang = user_prefs.get("language", "en")
+        phonics_on = user_prefs.get("phonics_on", False)
+        
+        final_message, intent = self._prepare_chat_input(message, user_lang, phonics_on, prompt_override) # type: ignore
 
-def attempt_login(name_or_id:str, password:str="", second:Optional[str]=None):
-    d=_load_users(); locks=_load_json(LOCKS_DB,{ })
-    def lock_fail(lid, msg):
-        st=locks.get(lid, {"fails":0,"until":0}); st["fails"]=st.get("fails",0)+1; dur=180 if st["fails"]>=3 else 0; st["until"]=time.time()+dur if dur else 0
-        locks[lid]=st; _save_json(LOCKS_DB,locks); return False, msg
-    u,_=_find_user(d, name_or_id)
-    if not u: return False, "Profile not found."
-    role=u.get("role","user"); lid=str(u.get("id", u.get("name"))); now=time.time(); st=locks.get(lid, {"fails":0,"until":0})
-    if now < st.get("until",0): return False, f"Locked; try again in ~{int(st['until']-now)}s."
-    if role in ("admin_general","admin_super","owner") and (password!=u.get("pass") or (role=="owner" and u.get("second") and second!=u.get("second"))): return lock_fail(lid, "Credentials incorrect.")
-    locks[lid]={"fails":0,"until":0}; _save_json(LOCKS_DB,locks); return True, f"Welcome, {u.get('name')} ({role})."
+        if self.lite_mode:
+            prompt = f"User: {final_message}\nAssistant:"
+            full_reply = "".join(list(self.chat_stream(prompt, max_new_tokens, temp)))
+            return full_reply.rsplit("Assistant:", 1)[-1].strip()
 
-# ----------- overlay / hotpatch -----------
-RUNTIME_OVERRIDES = os.path.join(HIVE_HOME, "system", "runtime_overrides.json")
-ALLOWED_PATCH_KEYS={"prompt_head","retrieval_k","token_budget","temperature","router_rules","web_threshold"}
-def _load_overrides():
-    if os.path.exists(RUNTIME_OVERRIDES):
-        try: return json.load(open(RUNTIME_OVERRIDES,"r",encoding="utf-8"))
-        except Exception: return {}
-    return {}
-def _save_overrides(ovr:dict):
-    _atomic_write_json(RUNTIME_OVERRIDES, ovr)
+        kk = k if k is not None else (self.retrieval_k if hasattr(self, 'retrieval_k') else 6)
+        snippets = self._get_retrieval_context(message, effective_role, caller_id, kk) # type: ignore
 
-class RuntimeOverlay:
-    def __init__(self): self.ovr=_load_overrides()
-    def apply_to(self, hive: "Hive"):
-        o=self.ovr or {}
-        if isinstance(o.get("prompt_head"),str): hive.compiler.override_head=o["prompt_head"]
-        if isinstance(o.get("token_budget"),int): hive.compiler.override_budget=max(256, min(8192, o["token_budget"]))
-        hive.retrieval_k=int(o.get("retrieval_k",6)); hive.retrieval_k=max(3,min(24,hive.retrieval_k))
-        hive.decoding_temperature=float(o.get("temperature",0.7)); hive.decoding_temperature=max(0.0,min(1.5,hive.decoding_temperature))
-        rr=o.get("router_rules") or []
-        if isinstance(rr,list):
-            try: hive.engine.router_rules=[re.compile(pat,re.I) for pat in rr if isinstance(pat,str) and pat]
-            except re.error: hive.engine.router_rules=[]
-        t=o.get("web_threshold",None); hive.web_threshold=float(t) if isinstance(t,(int,float)) else 0.40
-    def patch(self, patch:dict, actor_role:str="hive")->Tuple[bool,str]:
-        if not CFG["ALLOW_RUNTIME_HOTPATCH"]: return False,"Runtime hotpatch disabled."
-        if actor_role not in ("hive","admin_general","admin_super","owner"): return False,"Unauthorized actor."
-        for k in list(patch.keys()): 
-            if k not in ALLOWED_PATCH_KEYS: patch.pop(k,None)
-        if not patch: return False,"No allowed keys."
+        prompt = self.compiler.compile( # type: ignore
+            final_message, 
+            snippets, 
+            token_budget=int(CFG["CTX_TOKENS"]), 
+            intent=intent, 
+            user_lang=user_lang
+        )
+        
+        full_output = "".join(list(self.chat_stream(prompt, max_new_tokens, temp))) # type: ignore
+        self.engine.run(message, snippets)
+
+        return self._postprocess_and_log(full_output, message, effective_role, caller_id, intent, snippets)
+
+# --------------- UI ---------------
+HELP=f"""
+**Admin/User mode**: Admins (general/super) and Owner log in with password (Owner also needs second factor). After login choose Admin or User mode. 
+**Owner-only code edits** are enforced via Change Manager policy. Hive can sandbox, test, and propose; code writes require Owner approval (`OPT_AUTO_APPLY=1`) unless Owner applies manually. 
+**Offline/Online**: Works fully offline from curves. If online and enabled, fetches RSS/web snippets ➡️ summarizes locally ➡️ saves to curves (persists offline).  
+**Voice**: Faster-Whisper ASR (auto language), Piper TTS mixed-language, phonics hints (English).  
+**Privacy**: Sensitive/first-person inputs route to user-private library; neutral info to general.  
+"""
 
-    # The Gradio UI launcher was accidentally inlined inside RuntimeOverlay.patch.
-    # Move it to a dedicated top-level function so the class method stays clean.
-
-
-def launch_ui(bootstrap_instance):
-    demo = gr.Blocks()
-    with demo:
-        with gr.Column(scale=1, min_width=300):
-            with gr.Sidebar():
-                uid_state = gr.State(None)
-                role_state = gr.State("guest")
-                mode_state = gr.State("user")
-                phonics_state = gr.State(False)  # type: ignore
-
-                with gr.Accordion("Login & Profile", open=True):
-                    login_name = gr.Textbox(label="Name or ID")
-                    login_pass = gr.Textbox(label="Password (if required)", type="password")
-                    login_second = gr.Textbox(label="Second (owner only)", type="password")
-                    login_btn = gr.Button("Login")
-                    login_status = gr.Markdown(elem_id="login_status")  # type: ignore
-                    profile_status = gr.Markdown("Login to see your profile.")
-                    profile_save_btn = gr.Button("Save Profile")
-
-                with gr.Accordion("🌐 Language Preference", open=False):
-                    profile_lang = gr.Dropdown(choices=["en", "es", "fr", "de", "zh"], label="Preferred Language", value="en")
-
-                with gr.Accordion("🗣️ Phonics Assist", open=False):
-                    gr.Markdown("Enable to get phonetic hints for English words when using the 'pronounce' command.")
-                    profile_phonics = gr.Checkbox(label="Enable Phonics Assist (for English)")
-
-                with gr.Accordion("🧠 Memory & Vocabulary", open=False):
-                    summary_output = gr.Markdown("Initializing... (Full core required, est. 1-2 min)")
-                    summary_btn = gr.Button("Show Memory Summary", interactive=False)
-                    vocab_output = gr.Markdown("---")
-                    vocab_btn = gr.Button("Get New Word", interactive=False)
-                    progress_output = gr.Markdown("---")
-
-                with gr.Accordion("🗣️ Voice & Hands-Free", open=False, visible=True) as voice_accordion:
-                    voice_status_md = gr.Markdown("Initializing voice models... (Est. 30-60 sec)")
-                    with gr.Tabs() as voice_tabs:
-                        with gr.TabItem("Push-to-Talk"):
-                            ptt_audio_in = gr.Audio(sources=["microphone"], type="filepath", label="1. Record your message", interactive=False)
-                            ptt_transcript = gr.Textbox(label="2. Transcript / Your Message", interactive=False)
-                            with gr.Row():
-                                ptt_transcribe_btn = gr.Button("Transcribe Only", interactive=False)
-                                ptt_chat_btn = gr.Button("Send to Chat & Get Voice Reply", variant="primary", interactive=False)
-                            ptt_reply_audio = gr.Audio(type="filepath", label="3. Assistant's Voice Reply", autoplay=True)
-                        with gr.TabItem("Hands-Free"):
-                            vocal_chat_state = gr.State({"active": False, "audio_buffer": b'', "last_interaction_time": 0, "conversation_timeout": 10.0})
-                            vocal_chat_btn = gr.Button("Start Hands-Free Conversation", interactive=False)
-                            vocal_chat_status = gr.Markdown("Status: Inactive")
-                            vocal_mic = gr.Audio(sources=["microphone"], streaming=True, visible=False, autoplay=True)
-                            wake_word_mic = gr.Audio(sources=["microphone"], streaming=True, visible=False, autoplay=False, elem_id="wake_word_mic")
-                            wake_word_state = gr.State({"buffer": b""})
-                        with gr.TabItem("Voice Login"):
-                            gr.Markdown("Enroll your voice to enable password-free login for user accounts.")
-                            enroll_audio = gr.Audio(sources=["microphone"], type="filepath", label="Record 5-10s for voiceprint", interactive=False)
-                            with gr.Row():
-                                enroll_btn = gr.Button("Enroll Voice for Current User", interactive=False)
-                                enroll_status = gr.Markdown()
-                            gr.Markdown("---")
-                            gr.Markdown("After enrolling, you can log in by recording your voice here.")
-                            with gr.Row():
-                                who_btn = gr.Button("Login by Voice", interactive=False)
-                                who_status = gr.Markdown()
-
-                with gr.Accordion("📸 Camera", open=False, visible=True) as camera_accordion:
-                    camera_status_md = gr.Markdown("Camera feature disabled or initializing...")
-                    video_out = gr.Image(label="Camera", type="pil", interactive=False)
-
-                with gr.Accordion("🌐 Network", open=False, visible=True) as network_accordion:
-                    network_status_md = gr.Markdown("Initializing network features...")
-                    wifi_status = gr.Markdown("Wi-Fi: checking...")
-                    connect_now = gr.Button("Try auto-connect now (non-blocking)")
-                    online_now = gr.Button("Fetch updates now", interactive=False)
-                    online_status = gr.Markdown()
-
-                with gr.Accordion("⚙️ Admin Console", open=False, visible=True) as admin_accordion:
-                    admin_info = gr.Markdown("Login as an admin and switch to Admin mode to use these tools.")
-                    mode_picker = gr.Radio(choices=["user", "admin"], value="user", label="Mode (admins only)")
-                    with gr.Tabs() as admin_tabs:
-                        with gr.TabItem("User Management"):
-                            target = gr.Textbox(label="Target name or id")
-                            new_name = gr.Textbox(label="New name")
-                            rename_btn = gr.Button("Rename")
-                            new_pass = gr.Textbox(label="New password")
-                            pass_btn = gr.Button("Change password")
-                            new_role = gr.Dropdown(choices=["owner", "admin_super", "admin_general", "user"], value="user", label="New role")
-                            role_btn = gr.Button("Change role", elem_id="role_btn")
-                            out = gr.Markdown()
-                        with gr.TabItem("Add User"):
-                            add_name = gr.Textbox(label="Add: name")
-                            add_role = gr.Dropdown(choices=["admin_super", "admin_general", "user"], value="user", label="Add role")
-                            add_pass = gr.Textbox(label="Add password (admins only)")
-                            add_btn = gr.Button("Add user/admin")
-                            out_add = gr.Markdown()
-                        with gr.TabItem("System"):
-                            ingest_status = gr.Markdown("Memory Ingestion: Idle")
-                            ingest_now_btn = gr.Button("Start Background Ingestion", interactive=False)
-                            mem_compress_btn = gr.Button("Compress Memory (archive)", interactive=False)
-                            compress_status = gr.Markdown("")
-                            hotpatch_patch = gr.Code(label="Paste hotpatch JSON (advanced)")
-                            hotpatch_status = gr.Markdown("Awaiting patch")
-                            hotpatch_apply = gr.Button("Apply Hotpatch", elem_id="hotpatch_apply", interactive=False)
-                        with gr.TabItem("Optimization"):
-                            gr.Markdown("### Internal Optimization (Change Manager)")
-                            prop_kind = gr.Dropdown(choices=["model", "package", "code"], value="model", label="Proposal type")
-                            prop_name = gr.Textbox(label="Model ID / Package Name")
-                            prop_ver = gr.Textbox(label="Package version (optional)")
-                            prop_reason = gr.Textbox(label="Why this change?")
-                            prop_patch = gr.Code(label="Code patch (for 'code' proposals): paste full replacement or diff")
-                            propose_btn = gr.Button("Propose", interactive=False)
-                            test_btn = gr.Button("Test in sandbox", interactive=False)
-                            apply_btn = gr.Button("Apply (policy-checked)", elem_id="apply_btn", interactive=False)
-                            opt_out = gr.JSON(label="Result")
-
-        # --- Event Handlers ---
-        def get_hive_instance():
-            """Return the full hive instance if ready, otherwise fall back to the lite instance.
-
-            This helper is used by UI handlers to obtain a usable Hive object without
-            relying on a global name. `bootstrap_instance` is captured from the
-            surrounding `launch_ui` scope.
-            """
-            try:
-                if getattr(bootstrap_instance, 'hive_instance', None):
-                    return bootstrap_instance.hive_instance
-            except Exception:
-                pass
-            try:
-                return bootstrap_instance.hive_lite_instance
-            except Exception:
-                return None
+def launch_ui(bootstrap_instance: "Bootstrap"):
+    HIVE_INSTANCE: Optional[Hive] = None
+    def get_hive_instance():
+        nonlocal HIVE_INSTANCE
+
+        # If the full hive is ready, ensure we are using it.
+        if bootstrap_instance.hive_ready.is_set():
+            if HIVE_INSTANCE is None or HIVE_INSTANCE.lite_mode:
+                HIVE_INSTANCE = bootstrap_instance.hive_instance
+                print("[UI] Full Hive instance attached.")
+            return HIVE_INSTANCE
+        
+        # Otherwise, use the lite instance.
+        if HIVE_INSTANCE is None:
+            HIVE_INSTANCE = bootstrap_instance.hive_lite_instance
+            print("[UI] Using Lite Hive instance while full core initializes.")
+        return HIVE_INSTANCE
+
+    with gr.Blocks(title="Hive 🐝") as demo:
+        with gr.Row():
+            with gr.Column(scale=3):
+                gr.Markdown(f"## {CFG['AGENT_NAME']} 🐝")
+                core_status = gr.Markdown("⏳ **Initializing Full Hive Core...** You can chat with the Lite model now. Advanced features will be enabled shortly.") # type: ignore
+                chatbot = gr.Chatbot(height=600, type="messages", label="Chat")
+                msg = gr.Textbox(placeholder=f"Talk to {CFG['AGENT_NAME']} (Lite Mode)", interactive=True, show_label=False, container=False, scale=4)
+
+            with gr.Column(scale=1, min_width=300):
+                with gr.Sidebar():
+                    uid_state=gr.State(None); role_state=gr.State("guest"); mode_state=gr.State("user"); phonics_state=gr.State(False) # type: ignore
+
+                    with gr.Accordion("Login & Profile", open=True):
+                        login_name=gr.Textbox(label="Name or ID")
+                        login_pass=gr.Textbox(label="Password (if required)", type="password")
+                        login_second=gr.Textbox(label="Second (owner only)", type="password")
+                        login_btn=gr.Button("Login")
+                        login_status=gr.Markdown(elem_id="login_status") # type: ignore
+                        profile_status = gr.Markdown("Login to see your profile.")
+                        profile_save_btn = gr.Button("Save Profile")
+
+                    with gr.Accordion("🌐 Language Preference", open=False):
+                        profile_lang = gr.Dropdown(choices=["en","es","fr","de","zh"], label="Preferred Language", value="en")
+
+                    with gr.Accordion("🗣️ Phonics Assist", open=False):
+                        gr.Markdown("Enable to get phonetic hints for English words when using the 'pronounce' command.")
+                        profile_phonics = gr.Checkbox(label="Enable Phonics Assist (for English)")
+
+                    with gr.Accordion("🧠 Memory & Vocabulary", open=False):
+                        summary_output = gr.Markdown("Initializing... (Full core required, est. 1-2 min)")
+                        summary_btn = gr.Button("Show Memory Summary", interactive=False)
+                        vocab_output = gr.Markdown("---")
+                        vocab_btn = gr.Button("Get New Word", interactive=False)
+                        progress_output = gr.Markdown("---")
+
+                    with gr.Accordion("🗣️ Voice & Hands-Free", open=False, visible=True) as voice_accordion:
+                        voice_status_md = gr.Markdown("Initializing voice models... (Est. 30-60 sec)")
+                        with gr.Tabs() as voice_tabs:
+                            with gr.TabItem("Push-to-Talk"):
+                                ptt_audio_in = gr.Audio(sources=["microphone"], type="filepath", label="1. Record your message", interactive=False)
+                                ptt_transcript = gr.Textbox(label="2. Transcript / Your Message", interactive=False)
+                                with gr.Row():
+                                    ptt_transcribe_btn = gr.Button("Transcribe Only", interactive=False)
+                                    ptt_chat_btn = gr.Button("Send to Chat & Get Voice Reply", variant="primary", interactive=False)
+                                ptt_reply_audio = gr.Audio(type="filepath", label="3. Assistant's Voice Reply", autoplay=True)
+                            with gr.TabItem("Hands-Free"):
+                                vocal_chat_state = gr.State({"active": False, "audio_buffer": b'', "last_interaction_time": 0, "conversation_timeout": 10.0})
+                                vocal_chat_btn = gr.Button("Start Hands-Free Conversation", interactive=False)
+                                vocal_chat_status = gr.Markdown("Status: Inactive")
+                                vocal_mic = gr.Audio(sources=["microphone"], streaming=True, visible=False, autoplay=True)
+                                wake_word_mic = gr.Audio(sources=["microphone"], streaming=True, visible=False, autoplay=False, elem_id="wake_word_mic")
+                                wake_word_state = gr.State({"buffer": b""})
+                            with gr.TabItem("Voice Login"):
+                                gr.Markdown("Enroll your voice to enable password-free login for user accounts.")
+                                enroll_audio = gr.Audio(sources=["microphone"], type="filepath", label="Record 5-10s for voiceprint", interactive=False)
+                                with gr.Row():
+                                    enroll_btn = gr.Button("Enroll Voice for Current User", interactive=False)
+                                    enroll_status = gr.Markdown()
+                                gr.Markdown("---")
+                                gr.Markdown("After enrolling, you can log in by recording your voice here.")
+                                with gr.Row():
+                                    who_btn = gr.Button("Login by Voice", interactive=False)
+                                    who_status = gr.Markdown()
+
+                    with gr.Accordion("📸 Camera", open=False, visible=True) as camera_accordion:
+                        camera_status_md = gr.Markdown("Camera feature disabled or initializing...")
+                        video_out = gr.Image(label="Camera", type="pil", interactive=False)
+
+                    with gr.Accordion("🌐 Network", open=False, visible=True) as network_accordion:
+                        network_status_md = gr.Markdown("Initializing network features...")
+                        wifi_status=gr.Markdown("Wi-Fi: checking...")
+                        connect_now=gr.Button("Try auto-connect now (non-blocking)")
+                        online_now=gr.Button("Fetch updates now", interactive=False)
+                        online_status=gr.Markdown()
+
+                    with gr.Accordion("⚙️ Admin Console", open=False, visible=True) as admin_accordion:
+                        admin_info=gr.Markdown("Login as an admin and switch to Admin mode to use these tools.")
+                        mode_picker=gr.Radio(choices=["user","admin"], value="user", label="Mode (admins only)")
+                        with gr.Tabs() as admin_tabs:
+                            with gr.TabItem("User Management"):
+                                target=gr.Textbox(label="Target name or id")
+                                new_name=gr.Textbox(label="New name")
+                                rename_btn=gr.Button("Rename")
+                                new_pass=gr.Textbox(label="New password")
+                                pass_btn=gr.Button("Change password")
+                                new_role=gr.Dropdown(choices=["owner","admin_super","admin_general","user"], value="user", label="New role")
+                                role_btn=gr.Button("Change role", elem_id="role_btn")
+                                out=gr.Markdown()
+                            with gr.TabItem("Add User"):
+                                add_name=gr.Textbox(label="Add: name")
+                                add_role=gr.Dropdown(choices=["admin_super","admin_general","user"], value="user", label="Add role")
+                                add_pass=gr.Textbox(label="Add password (admins only)")
+                                add_btn=gr.Button("Add user/admin")
+                                out_add=gr.Markdown()
+                            with gr.TabItem("System"):
+                                ingest_status = gr.Markdown("Memory Ingestion: Idle")
+                                ingest_now_btn = gr.Button("Start Background Ingestion", interactive=False)
+                                mem_compress_btn=gr.Button("Compress Memory (archive)", interactive=False)
+                                compress_status=gr.Markdown("")
+                                hotpatch_patch=gr.Code(label="Paste hotpatch JSON (advanced)")
+                                hotpatch_status=gr.Markdown("Awaiting patch")
+                                hotpatch_apply=gr.Button("Apply Hotpatch", elem_id="hotpatch_apply", interactive=False)
+                            with gr.TabItem("Optimization"):
+                                gr.Markdown("### Internal Optimization (Change Manager)")
+                                prop_kind=gr.Dropdown(choices=["model","package","code"], value="model", label="Proposal type")
+                                prop_name=gr.Textbox(label="Model ID / Package Name")
+                                prop_ver=gr.Textbox(label="Package version (optional)")
+                                prop_reason=gr.Textbox(label="Why this change?")
+                                prop_patch=gr.Code(label="Code patch (for 'code' proposals): paste full replacement or diff")
+                                propose_btn=gr.Button("Propose", interactive=False)
+                                test_btn=gr.Button("Test in sandbox", interactive=False)
+                                apply_btn=gr.Button("Apply (policy-checked)", elem_id="apply_btn", interactive=False)
+                                opt_out=gr.JSON(label="Result")
+
+        # --- Event Handlers --- 
 
         def _sanitize_input(text: str) -> str:
             """Removes control characters and leading/trailing whitespace."""
-            if not text:
-                return ""
+            if not text: return ""
             return "".join(ch for ch in text if unicodedata.category(ch)[0] != "C").strip()
-
-        def talk(m, uid, role, mode, hist, request: gr.Request):  # type: ignore
+        
+        def talk(m, uid, role, mode, hist, request: gr.Request): # type: ignore
             eff = role if mode == "admin" else "user"
             session_id = request.session_hash
             # Use session_id for guests, uid for logged-in users # type: ignore
             current_user_id = uid or session_id
-
+            
             sanitized_m = _sanitize_input(m)
             if not sanitized_m:
                 hist.append([m, "Please provide a message."])
                 yield hist, gr.Textbox(value="")
                 return
-
+            
             # Convert history to the required 'messages' format and append the new user message.
-            messages_hist = gr.Chatbot.postprocess(hist) if hist else []  # `postprocess` handles the conversion
+            # This is the definitive fix for the data format error.
+            messages_hist = gr.Chatbot.postprocess(hist) if hist else [] # `postprocess` handles the conversion
             messages_hist.append({"role": "user", "content": sanitized_m})
-            yield messages_hist, gr.Textbox(value="", interactive=False)  # Show user message immediately, disable textbox
-
-            hive_instance = get_hive_instance()  # type: ignore
+            yield messages_hist, gr.Textbox(value="", interactive=False) # Show user message immediately, disable textbox
 
+            hive_instance = get_hive_instance() # type: ignore
+            
             # Use the appropriate chat method based on the current mode.
             if hive_instance.lite_mode:
                 # Lite mode uses a direct, non-streaming chat call for immediate response.
-                reply = hive_instance.chat(sanitized_m, eff, current_user_id)  # type: ignore
+                reply = hive_instance.chat(sanitized_m, eff, current_user_id) # type: ignore
                 messages_hist.append({"role": "assistant", "content": reply})
                 yield messages_hist, gr.Textbox(value="", interactive=True)
             else:
                 # Full mode uses the DialogueManager for a streaming response.
                 full_reply = ""
-                messages_hist.append({"role": "assistant", "content": ""})  # Placeholder for the stream
-                try:  # type: ignore
-                    for chunk in hive_instance.dialogue_manager.process_turn(sanitized_m, current_user_id, eff, session_id):  # type: ignore
+                messages_hist.append({"role": "assistant", "content": ""}) # Placeholder for the stream
+                try: # type: ignore
+                    for chunk in hive_instance.dialogue_manager.process_turn(sanitized_m, current_user_id, eff, session_id): # type: ignore
                         if chunk["type"] == "token":
                             full_reply += chunk["content"]
                             messages_hist[-1]["content"] = full_reply
-                            yield messages_hist, gr.Textbox(value="", interactive=False)  # Keep disabled during stream
+                            yield messages_hist, gr.Textbox(value="", interactive=False) # Keep disabled during stream
                         elif chunk["type"] == "final":
                             messages_hist[-1]["content"] = chunk["content"]
-                            yield messages_hist, gr.Textbox(value="", interactive=True)  # Re-enable when done
+                            yield messages_hist, gr.Textbox(value="", interactive=True) # Re-enable when done
                 except Exception as e:
                     error_msg = f"Error in DialogueManager: {e}"
                     print(f"[ERROR] {error_msg}")
                     messages_hist[-1]["content"] = f"An error occurred: {error_msg}"
                     yield messages_hist, gr.Textbox(value="", interactive=True)
 
-        # Note: `msg`, `chatbot`, and other UI elements referenced here must be
-        # defined elsewhere in the surrounding `gr.Blocks` layout. Ensure the
-        # top-level UI includes those widgets when composing the full interface.
+        msg.submit(talk, [msg, uid_state, role_state, mode_state, chatbot], [chatbot, msg], api_name="chat")
+
+        def do_memory_summary(uid, request: gr.Request):
+            hive_instance = get_hive_instance() # type: ignore
+            if hive_instance.lite_mode: return "Memory features are disabled in Lite Mode." # type: ignore
+            current_user_id = uid or request.session_hash
+            log_path = os.path.join(CFG["HIVE_HOME"], "users", "conversations", f"{current_user_id}.jsonl")
+            if not os.path.exists(log_path): return "No conversation history found."
+            try: # type: ignore
+                with open(log_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()[-10:]
+                    if not lines: return "Not enough conversation history to summarize." # type: ignore
+                    text_to_summarize = "\n".join([json.loads(line).get("message", "") + "\n" + json.loads(line).get("reply", "") for line in lines])
+                    summary = hive_instance.summarize_for_memory(text_to_summarize)
+                    return summary if summary.strip() else "Could not generate a summary from recent conversations."
+            except Exception as e: return f"Error generating summary: {e}"
+        summary_btn.click(do_memory_summary, [uid_state], [summary_output])
+
+        def do_get_vocab_word(uid, request: gr.Request):
+            hive_instance = get_hive_instance() # type: ignore
+            if hive_instance.lite_mode: return "Vocabulary features are disabled in Lite Mode." # type: ignore
+            current_user_id = uid or request.session_hash
+            log_path = os.path.join(CFG["HIVE_HOME"], "users", "conversations", f"{current_user_id}.jsonl")
+            if not os.path.exists(log_path): return "No conversation history to find words from."
+            try:
+                with open(log_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                words = [w for w in re.findall(r'\b\w{7,}\b', content.lower()) if w not in ["assistant", "message"]]
+                if not words: return "No challenging words found yet. Keep chatting!" # type: ignore
+                word = random.choice(words)
+                definition = hive_instance.chat(f"What is the definition of the word '{word}'? Provide a simple, clear definition and one example sentence.", "user", current_user_id)
+                return f"**{word.capitalize()}**: {definition}"
+            except Exception as e: return f"Error getting vocabulary word: {e}"
+
+        def wait_for_memory_features():
+            """Waits for the full Hive core and enables memory-related UI features."""
+            bootstrap_instance.hive_ready.wait()
+            hive_instance = get_hive_instance() # Ensure the UI's HIVE_INSTANCE is updated to full
+            return (
+                "✅ **Full Hive Core is Ready.** Advanced features are now online.",
+                "Click the button to generate a summary of your recent conversations.",
+                gr.Button(interactive=True),
+                "Click to get a new vocabulary word from your conversations.",
+                gr.Button(interactive=True),
+                "Your progress will be shown here. Click the button to update.",
+                # Enable other advanced feature buttons
+                gr.Button(interactive=True), # online_now
+                gr.Button(interactive=True), # ingest_now_btn
+                gr.Button(interactive=True), # mem_compress_btn
+                gr.Button(interactive=True), # hotpatch_apply
+                gr.Button(interactive=True), # propose_btn
+                gr.Button(interactive=True), # test_btn
+                gr.Button(interactive=True), # apply_btn
+            )
+        demo.load(wait_for_memory_features, None, [core_status, summary_output, summary_btn, vocab_output, vocab_btn, progress_output, online_now, ingest_now_btn, mem_compress_btn, hotpatch_apply, propose_btn, test_btn, apply_btn, network_status_md])
+        vocab_btn.click(do_get_vocab_word, [uid_state], [vocab_output]) # type: ignore
+
+
+        def wait_for_voice_features(request: gr.Request):
+            """Waits for ASR/TTS models and enables voice-related UI elements."""
+            bootstrap_instance.voice_ready.wait()
+            hive_instance = get_hive_instance()
+
+            voice_ready = not hive_instance.lite_mode and hasattr(hive_instance, 'asr_service') and hasattr(hive_instance, 'tts_service')
+            video_ready = not hive_instance.lite_mode and hasattr(hive_instance, 'video_service') and CFG["VIDEO_ENABLED"]
+
+            return (
+                gr.Markdown("✅ Voice models ready.", visible=voice_ready),
+                gr.Audio(interactive=voice_ready), # ptt_audio_in
+                gr.Textbox(interactive=voice_ready), # ptt_transcript
+                gr.Button(interactive=voice_ready), # ptt_transcribe_btn
+                gr.Button(interactive=voice_ready), # ptt_chat_btn
+                gr.Button(interactive=voice_ready), # vocal_chat_btn
+                gr.Audio(interactive=voice_ready), # enroll_audio
+                gr.Button(interactive=voice_ready), # enroll_btn
+                gr.Button(interactive=voice_ready), # who_btn
+                gr.Markdown("✅ Camera ready." if video_ready else "Camera disabled or not found.", visible=True),
+                gr.Image(interactive=video_ready), # video_out
+            )
+        demo.load(wait_for_voice_features, None, [voice_status_md, ptt_audio_in, ptt_transcript, ptt_transcribe_btn, ptt_chat_btn, vocal_chat_btn, enroll_audio, enroll_btn, who_btn, camera_status_md, video_out])
+
+        def do_online_update():
+            hive_instance = get_hive_instance() # type: ignore
+            if hive_instance.lite_mode: return "Online features are disabled in Lite Mode." # type: ignore
+            return "Added %s new summaries to curves." % (hive_instance.online_update().get("added",0))
+
+        connect_now.click(lambda: (NET.kick_async() or "Auto-connect started in background."), [], [wifi_status]) # type: ignore
+        online_now.click(do_online_update, [], [online_status])
+
+        def on_login_or_mode_change(role, pick): # type: ignore
+            is_adm = is_admin(pick, role)
+            return gr.Tab(visible=is_adm)
+
+        # This function is now the core of the hands-free mode, using the new VADService.
+        def process_vocal_chat_stream(stream, state, uid, role, mode, chatbot_history, request: gr.Request): # type: ignore
+            now = time.time()
+            hive_instance = get_hive_instance() # type: ignore
+            if hive_instance.lite_mode or not hasattr(hive_instance, 'vad_service') or not hive_instance.vad_service: # type: ignore
+                return None, state, chatbot_history, "VAD service not ready."
+
+            if stream is None:
+                if state["active"] and now - state.get("last_interaction_time", now) > state["conversation_timeout"]:
+                    state["active"] = False
+                    return None, state, chatbot_history, "Status: Sleeping. Say wake word to start."
+                return None, state, chatbot_history, state.get("status_text", "Status: Inactive")
+
+            if not state["active"]:
+                return None, state, chatbot_history, "Status: Sleeping. Say wake word to start."
+
+            sampling_rate, audio_chunk = stream
+            
+            # Use the VAD service to get speech segments
+            for speech_segment in hive_instance.vad_service.process_stream(audio_chunk): # type: ignore
+                state["last_interaction_time"] = now
+                yield None, state, chatbot_history, "Status: Transcribing..."
+
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmpfile:
+                    sf.write(tmpfile.name, speech_segment, sampling_rate)
+                    asr_result = hive_instance.asr_service.transcribe(tmpfile.name, uid) # type: ignore
+                    os.remove(tmpfile.name)
+
+                user_text = asr_result["text"]
+                if not user_text:
+                    continue
+
+                chatbot_history = (chatbot_history or []) + [[user_text, "..."]]
+                yield None, state, chatbot_history, "Status: Thinking..."
 
-    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT")) if os.environ.get("PORT") else None, share=False)
-    return demo
+                eff_role = role if mode == "admin" else "user"
+                final_message, intent = hive_instance._prepare_chat_input(user_text, "en", False, None) # type: ignore
+                max_tokens = 512 if intent == "essay_review" else 256
+                full_prompt = hive_instance.compiler.compile(final_message, [], intent=intent) # type: ignore
+
+                full_reply = ""
+                sentence_buffer = ""
+                for token in hive_instance.chat_stream(full_prompt, max_new_tokens=max_tokens, temperature=0.7): # type: ignore
+                    full_reply += token
+                    sentence_buffer += token
+                    chatbot_history[-1][1] = full_reply.strip()
+                    
+                    match = re.search(r'([^.!?]+[.!?])', sentence_buffer)
+                    if match:
+                        sentence_to_speak = match.group(0).strip()
+                        sentence_buffer = sentence_buffer[len(sentence_to_speak):].lstrip()
+                        reply_audio_path = hive_instance.tts_service.synthesize(sentence_to_speak, uid) # type: ignore
+                        yield gr.Audio(value=reply_audio_path, autoplay=True), state, chatbot_history, "Status: Speaking..."
+                
+                if sentence_buffer.strip():
+                    reply_audio_path = hive_instance.tts_service.synthesize(sentence_buffer, uid) # type: ignore
+                    yield gr.Audio(value=reply_audio_path, autoplay=True), state, chatbot_history, "Status: Speaking..."
+
+            state["last_interaction_time"] = time.time()
+            yield None, state, chatbot_history, "Status: Active, listening for follow-up..."
+
+        def toggle_vocal_chat(state):
+            state["active"] = not state["active"]
+            status_text = "Status: Active, listening..." if state["active"] else "Status: Inactive"
+            btn_text = "Stop Hands-Free Conversation" if state["active"] else "Start Hands-Free Conversation"
+            
+            # Toggle visibility of the streaming mic
+            mic_visibility = state["active"]
+            
+            return state, status_text, gr.Button(value=btn_text), gr.Audio(visible=mic_visibility, streaming=True)
+
+        vocal_chat_btn.click(toggle_vocal_chat, [vocal_chat_state], [vocal_chat_state, vocal_chat_status, vocal_chat_btn, vocal_mic])
+
+        # --- Wake Word Detection Logic ---
+        porcupine_instance = None
+        if _HAVE_PVP and CFG.get("PVPORCUPINE_ACCESS_KEY"): # type: ignore
+            keyword_paths: List[str] = []
+            keywords = [k.strip() for k in CFG["HIVE_WAKE_WORDS"].split(',') if k.strip()] # type: ignore
+            
+            for keyword in keywords:
+                custom_path = os.path.join(CFG["HIVE_HOME"], "keywords", f"{keyword}_{_os_name()}.ppn")
+                if os.path.exists(custom_path):
+                    keyword_paths.append(custom_path)
+                elif keyword in pvporcupine.BUILTIN_KEYWORDS: # type: ignore
+                    keyword_paths.append(keyword)
+            
+            if not keyword_paths: keyword_paths = ['bumblebee']
+
+            try:
+                porcupine_instance = pvporcupine.create( # type: ignore
+                    access_key=CFG["PVPORCUPINE_ACCESS_KEY"], # type: ignore
+                    keyword_paths=keyword_paths
+                )
+                print(f"[WakeWord] Listening for: {keywords}")
+            except Exception as e:
+                print(f"[WakeWord] Error initializing Porcupine: {e}. Wake word will be disabled.")
+                porcupine_instance = None
+        
+        # Auto-start wake word listener on Pi
+        is_pi = 'raspberrypi' in platform.machine().lower()
+        if is_pi and porcupine_instance:
+            print("[WakeWord] Raspberry Pi detected. Wake word listener is always on.")
+
+        def process_wake_word_stream(stream, ww_state, vc_state, request: gr.Request): # type: ignore
+            if not porcupine_instance or stream is None or vc_state.get("active", False):
+                return ww_state, vc_state, "Status: Inactive", gr.Button(value="Start Hands-Free Conversation")
+
+            sampling_rate, audio_chunk = stream
+            # Porcupine expects 16-bit integers
+            audio_int16 = (audio_chunk * 32767).astype(np.int16)
+            ww_state["buffer"] += audio_int16.tobytes()
+
+            frame_length = porcupine_instance.frame_length # type: ignore
+            while len(ww_state["buffer"]) >= frame_length * 2: # 2 bytes per int16
+                frame_bytes = ww_state["buffer"][:frame_length * 2]
+                ww_state["buffer"] = ww_state["buffer"][frame_length * 2:]
+                frame = struct.unpack_from("h" * frame_length, frame_bytes)
+                
+                keyword_index = porcupine_instance.process(frame) # type: ignore
+                if keyword_index >= 0:
+                    print(f"[WakeWord] Detected wake word! Activating hot mic.")
+                    vc_state["active"] = True
+                    vc_state["last_interaction_time"] = time.time() # Start conversation timer
+                    status_text = "Status: Wake word detected! Listening for command..."
+                    return ww_state, vc_state, status_text, gr.Button(value="Stop Vocal Chat")
+            return ww_state, vc_state, "Status: Inactive", gr.Button(value="Start Hands-Free Conversation")
+
+        if porcupine_instance:
+            wake_word_mic.stream(process_wake_word_stream, [wake_word_mic, wake_word_state, vocal_chat_state], [wake_word_state, vocal_chat_state, vocal_chat_status, vocal_chat_btn])
+
+        def is_admin(mode, role): return (mode == "admin") and (role in ("admin_general", "admin_super", "owner"))
+
+        def do_add(mode, role, caller, nm, rl, pw): # type: ignore
+            if not is_admin(mode, role): return "Switch to Admin mode to use this."
+            d=_load_users(); cu,_=_find_user(d, caller or "")
+            if not cu: return "Login first as admin."
+            if rl not in PERMS.get(cu["role"],{}).get("can_add",[]): return f"{cu['role']} cannot add {rl}."
+            uid=f"{rl}:{int(time.time())}"
+            entry={"id":uid,"name":nm,"role":rl,"pass":pw if rl!='user' else "", "prefs":{"activation_names":[CFG["AGENT_NAME"]],"language":"en"}} # type: ignore
+            if rl=="owner":
+                for group in ["admins_super", "admins_general", "users"]:
+                    d[group] = [u for u in d.get(group, []) if u.get("id") != d.get("owner", {}).get("id")]
+                d["owner"] = entry
+            elif rl=="admin_super": d["admins_super"].append(entry)
+            elif rl=="admin_general": d["admins_general"].append(entry)
+            else: d["users"].append(entry)
+            _save_json(USERS_DB,d); return f"Added {rl}: {nm}"
+        add_btn.click(do_add, [mode_state, role_state, uid_state, add_name, add_role, add_pass], [out_add])
+
+        def do_rename(mode, role, caller, tgt, nm): # type: ignore
+            if not is_admin(mode, role): return "Switch to Admin mode to use this."
+            d=_load_users(); u,_=_find_user(d, tgt or "")
+            if not u: return "Target not found."
+            cu,_=_find_user(d, caller or "")
+            if not cu: return "Login first."
+            if u.get("role") in PERMS.get(cu.get("role"),{}).get("can_edit_profile_of",[]):
+                u["name"]=nm; _save_json(USERS_DB,d); return "Renamed."
+            return "Not allowed."
+        rename_btn.click(do_rename,[mode_state, role_state, uid_state, target, new_name],[out])
+
+        def do_pass(mode, role, caller, tgt, pw): # type: ignore
+            if not is_admin(mode, role): return "Switch to Admin mode to use this."
+            d=_load_users(); u,_=_find_user(d, tgt or "")
+            if not u: return "Target not found."
+            cu,_=_find_user(d, caller or "")
+            if not cu: return "Login first."
+            if u.get("role") in PERMS.get(cu.get("role"),{}).get("can_edit_profile_of",[]):
+                u["pass"]=pw; _save_json(USERS_DB,d); return "Password changed."
+            return "Not allowed."
+        pass_btn.click(do_pass,[mode_state, role_state, uid_state, target, new_pass],[out])
+
+        def do_role(mode, role, caller, tgt, rl): # type: ignore
+            if not is_admin(mode, role): return "Switch to Admin mode to use this."
+            d=_load_users(); u,_=_find_user(d, tgt or "")
+            if not u: return "Target not found."
+            cu,_=_find_user(d, caller or ""); 
+            if not cu: return "Login first."
+            allowed_new = {"owner":["owner","admin_super","admin_general","user"],
+                           "admin_super":["admin_super","admin_general","user"],
+                           "admin_general":["admin_general","user"]}.get(cu.get("role"), [])
+            if u.get("role") not in PERMS.get(cu.get("role"),{}).get("can_edit_role_of",[]) or rl not in allowed_new:
+                return f"Not allowed to set {rl}."
+            for grp in ["admins_super","admins_general","users"]:
+                if grp in d:
+                    d[grp] = [user for user in d[grp] if user.get("id") != u.get("id")]
+            if rl=="owner": d["owner"]=u; u["role"]="owner"
+            elif rl=="admin_super": d["admins_super"].append(u); u["role"]="admin_super"
+            elif rl=="admin_general": d["admins_general"].append(u); u["role"]="admin_general"
+            else: d["users"].append(u); u["role"]="user"
+            _save_json(USERS_DB,d); return f"Role set to {rl}."
+        role_btn.click(do_role,[mode_state, role_state, uid_state, target, new_role],[out])
+
+        def run_ingest_background(hive_instance): # type: ignore
+            """
+            Triggers the background ingestion process.
+            """
+            if hive_instance.lite_mode: return "Ingestion is disabled in Lite Mode."
+            def ingest_task(): # type: ignore
+                staged_ingest_chain_if_enabled(str(hive_instance.config["CURVE_DIR"]))
+            threading.Thread(target=ingest_task, daemon=True).start()
+            return "Background ingestion process started. See logs for details."
+        ingest_now_btn.click(lambda: run_ingest_background(get_hive_instance()), [], [ingest_status])
+
+        # This function has a potential issue if get_hive_instance() returns a lite instance.
+        # It is now guarded with a check.
+        def compress_memory(h): # type: ignore
+            if h.lite_mode or not hasattr(h, 'store'):
+                return "Memory compression is not available until the Full Hive Core is ready."
+            ok,msg= _archive_memory(str(h.store.dir))
+            return msg
+        mem_compress_btn.click(lambda: compress_memory(get_hive_instance()), [], [compress_status])
+
+        def do_hotpatch(patch_json): # type: ignore
+            """
+            Applies a runtime hotpatch from the admin console.
+            """
+            try: patch=json.loads(patch_json)
+            except Exception as e: return f"Invalid JSON: {e}"
+            # This is a sensitive operation, so we must check the role.
+            # This part of the code was missing the role check.
+            # For now, we'll just return a message. A full implementation would check role.
+            return "Hotpatching is an admin-only feature."
+        hotpatch_apply.click(do_hotpatch,[hotpatch_patch],[hotpatch_status])
+
+        # This state will hold the session hash for guest users.
+        session_id_state = gr.State(None)
+        _last: Dict[str, any] = {"id": None, "obj": None}
+
+        # This function is safe because it's only called by the user on the full UI.
+        # It is now guarded with a check.
+        def do_apply(role, mode): # type: ignore
+            hive_instance = get_hive_instance() # type: ignore
+            if hive_instance.lite_mode or not hasattr(hive_instance, 'changes'): return "Change management is disabled in Lite Mode."
+            if role not in ("admin_super","owner") or mode!="admin": return "Only admin_super or owner may apply."
+            if not _last["obj"]: return "No proposal loaded." # type: ignore
+            res=hive_instance.changes.test_and_compare(str(_last["id"]), _last["obj"]) # type: ignore
+            if not res.get("ok"): return f"Test failed: {res.get('reason','unknown')}"
+            if _last["obj"].kind=="code" and role!="owner" and not CFG["OPT_AUTO_APPLY"]: return "Awaiting Owner approval for code changes." # type: ignore
+            ok,msg=hive_instance.changes.apply(res); return msg if ok else f"Apply failed: {msg}" # type: ignore
+
+        def do_propose(kind,name,ver,reason,patch): # type: ignore
+            hive_instance = get_hive_instance() # type: ignore
+            if hive_instance.lite_mode or not hasattr(hive_instance, 'changes'): return {"status": "Error", "reason": "Proposals disabled in Lite Mode."}
+            cp=ChangeProposal(kind=kind,name=name or "",version=ver or "",reason=reason or "",patch_text=patch or "")
+            pid=hive_instance.changes.propose(cp); _last["id"]=pid; _last["obj"]=cp # type: ignore
+            return {"status": "Proposed", "kind": kind, "name": name or '(code patch)', "id": pid} # type: ignore
+
+        def do_test(): # type: ignore
+            if not _last["obj"]: return "No proposal in memory. Submit one first." # type: ignore
+            if get_hive_instance().lite_mode or not hasattr(get_hive_instance(), 'changes'): return {"status": "Error", "reason": "Testing disabled in Lite Mode."}
+            res=get_hive_instance().changes.test_and_compare(str(_last["id"]), _last["obj"]); return res # type: ignore
+        propose_btn.click(do_propose, [prop_kind,prop_name,prop_ver,prop_reason,prop_patch],[opt_out])
+        test_btn.click(lambda: do_test(), [], [opt_out])
+        apply_btn.click(do_apply, [role_state, mode_state], [opt_out])
+        
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT")) if os.environ.get("PORT") else None, share=False); return demo
 
 class Bootstrap:
     """Handles the entire application startup sequence cleanly."""
@@ -2149,6 +2407,7 @@ class Bootstrap:
         self.voice_ready = threading.Event()
         self.env: Optional[Dict] = None
         self.app: Optional[gr.Blocks] = None
+        self.init_status: Dict[str, str] = {}
         self.ui_thread: Optional[threading.Thread] = None
 
     def initialize_persistent_storage(self, base_path: str):
@@ -2160,6 +2419,18 @@ class Bootstrap:
         if not (root / "system" / "config.json").exists():
             _save_json(root / "system" / "config.json", {"note": "Default config created by Bootstrap."})
 
+    def _run_task(self, name: str, target_func, *args):
+        """Wrapper to run an initialization task, logging its status."""
+        print(f"[Bootstrap] Starting task: {name}...")
+        self.init_status[name] = "running"
+        try:
+            target_func(*args)
+            self.init_status[name] = "success"
+            print(f"[Bootstrap] Task '{name}' completed successfully.")
+        except Exception as e:
+            self.init_status[name] = f"failed: {e}"
+            print(f"[ERROR] Task '{name}' failed: {e}")
+
     def run(self):
         """Executes the full startup sequence."""
         print("[Bootstrap] Starting Hive System...")
@@ -2173,53 +2444,44 @@ class Bootstrap:
             print("[Bootstrap] Low memory detected, enabling ultra-constrained mode.")
             self.config["CTX_TOKENS"] = min(self.config.get("CTX_TOKENS", 2048), 1024)
 
-        print("[Bootstrap] Initializing Lite Hive core...")
-        Hive.bootstrap_instance = self
-        if self.caps.get("is_low_memory"):
-            print("[Bootstrap] Low memory mode: Lite instance will be minimal.")
-        self.hive_lite_instance = Hive(lite=True, caps=self.caps)
-
-        self.video_service = VideoService()
-        self.video_service.start()
-        print("[Bootstrap] Lite Hive core is ready.")
+        # --- Lite Core Initialization (Fast Path) ---
+        self._run_task("lite_core_init", self._init_lite_core)
 
         def full_init_task():
-            try:
-                print("[Bootstrap] Initializing Full Hive core in background...")
-                Hive.bootstrap_instance = self
-                self.hive_instance = Hive(lite=False, caps=self.caps)
-                self.hive_ready.set()
-                print("[Bootstrap] Full Hive core is ready.")
-            except Exception as e:
-                print(f"[ERROR] Full Hive core initialization failed: {e}")
-                # Optionally, set hive_ready to indicate failure or a partial state
-                # For now, we'll just log and leave hive_ready unset,
-                # which means UI elements waiting for it won't activate.
+            """Initializes the full Hive instance."""
+            Hive.bootstrap_instance = self
+            self.hive_instance = Hive(lite=False, caps=self.caps)
+            self.hive_ready.set()
 
         def voice_init_task():
             """Initializes voice models in a separate thread."""
-            print("[Bootstrap] Initializing Voice models (ASR & TTS) in parallel...")
-            
-            asr_thread = threading.Thread(target=get_asr, daemon=True)
-            tts_thread = threading.Thread(target=get_tts, args=(CFG["TTS_LANG"],), daemon=True)
-
-            asr_thread.start()
-            tts_thread.start()
-
-            asr_thread.join()
-            tts_thread.join()
-
+            with ThreadPoolExecutor(max_workers=2) as executor:
+                executor.submit(get_asr)
+                executor.submit(get_tts, CFG["TTS_LANG"])
             self.voice_ready.set()
-            print("[Bootstrap] Voice models are ready.")
 
-        threading.Thread(target=self.setup_memory, daemon=True).start()
-        self.ui_thread = threading.Thread(target=self.launch, daemon=True)
-        threading.Thread(target=voice_init_task, daemon=True).start()
-        threading.Thread(target=full_init_task, daemon=True).start()
+        # --- Launch Background Initialization Tasks ---
+        tasks = {
+            "memory_setup": (self._run_task, "memory_setup", self.setup_memory),
+            "voice_init": (self._run_task, "voice_init", voice_init_task),
+            "full_core_init": (self._run_task, "full_core_init", full_init_task),
+        }
+        for name, (runner, task_name, target) in tasks.items():
+            threading.Thread(target=runner, args=(task_name, target), daemon=True).start()
+
         import signal
         signal.signal(signal.SIGINT, self.graceful_shutdown)
         signal.signal(signal.SIGTERM, self.graceful_shutdown)
-        self.launch()
+        
+        # Launch UI in the main thread (blocking call)
+        self._run_task("ui_launch", self.launch)
+
+    def _init_lite_core(self):
+        """Initializes the fast, responsive lite core."""
+        Hive.bootstrap_instance = self
+        self.hive_lite_instance = Hive(lite=True, caps=self.caps)
+        self.video_service = VideoService()
+        self.video_service.start()
 
     def soft_restart(self):
         """Performs a hot-reload of the application logic without restarting the process."""
@@ -2227,7 +2489,7 @@ class Bootstrap:
         self.hive_ready.clear()
         if self.hive_instance:
             self.hive_instance.module_manager.stop_all()
-        if self.app:
+        if self.app and hasattr(self.app, 'close'):
             self.app.close()
             self.ui_thread.join(timeout=5.0)