Update app.py

app.py

@@ -1656,10 +1656,15 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
             if hive_instance.lite_mode:
                 # Lite mode: direct, non-streaming response.
                 reply = hive_instance.chat(sanitized_m, eff, current_user_id)
-                messages_hist.append({"role": "assistant", "content": reply})
+                messages_hist.append({"role": "assistant", "content": reply or "[No response from model]"})
                 yield messages_hist, gr.Textbox(value="", interactive=True)
             else:
                 # Full mode uses the DialogueManager for a streaming response.
+                if not hasattr(hive_instance, 'dialogue_manager'):
+                    error_msg = "Dialogue Manager not available. Full core may still be initializing."
+                    messages_hist.append({"role": "assistant", "content": error_msg})
+                    yield messages_hist, gr.Textbox(value="", interactive=True)
+                    return
                 full_reply = ""
                 messages_hist.append({"role": "assistant", "content": ""})  # Placeholder for the stream
                 try:
@@ -1744,17 +1749,21 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
         def get_hive_instance():
             global HIVE_INSTANCE
 
-            # If the full hive is ready, ensure we are using it.
+            # If the full hive is ready, ensure we are using it, and it's a valid instance.
             if bootstrap_instance.hive_ready.is_set():
-                if HIVE_INSTANCE is None or HIVE_INSTANCE.lite_mode:
+                if bootstrap_instance.hive_instance is not None and (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.")
+                if bootstrap_instance.lite_core_ready.is_set() and bootstrap_instance.hive_lite_instance is not None:
+                    HIVE_INSTANCE = bootstrap_instance.hive_lite_instance
+                    print("[UI] Using Lite Hive instance while full core initializes.")
+                else:
+                    # Neither lite nor full is ready.
+                    return None
             return HIVE_INSTANCE
 
 
@@ -1781,11 +1790,15 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
                 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])
+        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], show_progress="hidden")
         def stream_video():
             """Streams video frames from the VideoService to the UI."""
             hive_instance = get_hive_instance()
-            if not hive_instance or hive_instance.lite_mode or not hasattr(hive_instance, 'video_service'):
+            if not (
+                hive_instance and not hive_instance.lite_mode and 
+                hasattr(hive_instance, 'video_service') and hive_instance.video_service and
+                CFG["VIDEO_ENABLED"]
+            ):
                 yield None
                 return
 
@@ -1793,7 +1806,7 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
             while not video_service.stop_event.is_set():
                 frame = video_service.get_frame()
                 if frame is not None:
-                    yield frame
+                    yield cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                 time.sleep(0.05) # ~20 fps
         demo.load(stream_video, None, video_out)
 
@@ -2021,17 +2034,21 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
             return msg
         mem_compress_btn.click(lambda: compress_memory(get_hive_instance()), [], [compress_status])
 
-        def do_hotpatch(patch_json): # type: ignore
+        def do_hotpatch(mode, role, patch_json): # type: ignore
             """
             Applies a runtime hotpatch from the admin console.
             """
+            if not is_admin(mode, role):
+                return "Hotpatching is an admin-only feature."
             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])
+            
+            hive_instance = get_hive_instance()
+            if hive_instance.lite_mode or not hasattr(hive_instance, 'overlay'):
+                return "Hotpatching is not available in Lite Mode."
+            ok, msg = hive_instance.overlay.patch(patch, actor_role=role)
+            return msg
+        hotpatch_apply.click(do_hotpatch,[mode_state, role_state, hotpatch_patch],[hotpatch_status])
 
         # This state will hold the session hash for guest users.
         session_id_state = gr.State(None)
@@ -2135,13 +2152,21 @@ class Bootstrap:
 
         def full_init_task():
             """Initializes the full Hive instance."""
-            llm_thread.join() # Wait for the LLM to be loaded
-            get_hive_instance(lite=False) # This will replace the lite instance with the full one
-            self.hive_ready.set()
+            try:
+                llm_thread.join() # Wait for the LLM to be loaded
+                get_hive_instance(lite=False) # This will replace the lite instance with the full one
+                self.hive_ready.set()
+            except Exception as e:
+                print(f"[ERROR] Failed to initialize Full Hive Core: {e}")
+                traceback.print_exc()
+                # Do not set hive_ready on failure, so app stays in lite mode.
 
         def self_optimize_task():
             """Kicks off the self-optimization process after full initialization."""
             self.hive_ready.wait()  # Wait for the full hive to be ready
+            if not self.hive_instance or self.hive_instance.lite_mode:
+                print("[Bootstrap] Skipping self-optimization as full core is not available.")
+                return
             if self.hive_instance and hasattr(self.hive_instance, 'selfopt'):
                 print("[Bootstrap] Triggering initial self-optimization cycle.")
                 self.hive_instance.selfopt.trigger_once()
@@ -2149,8 +2174,13 @@ class Bootstrap:
         def voice_init_task():
             """Initializes voice models in a separate thread."""
             asr_thread.join()
-            tts_thread.join()
-            self.voice_ready.set()
+            tts_thread.join() # Wait for both ASR and TTS threads
+            try:
+                # Additional checks can be added here if needed
+                self.voice_ready.set()
+            except Exception as e:
+                print(f"[ERROR] Voice initialization failed: {e}")
+                traceback.print_exc()
 
         # --- Launch Background Initialization Tasks ---
         tasks = {
@@ -2171,14 +2201,22 @@ class Bootstrap:
 
     def _init_lite_core(self):
         """Initializes the fast, responsive lite core."""
-        # This now correctly creates the initial lite instance via the global function
-        get_hive_instance(lite=True, caps=self.caps)
-        self.lite_core_ready.set()
+        try:
+            # This now correctly creates the initial lite instance via the global function
+            get_hive_instance(lite=True, caps=self.caps)
+            self.lite_core_ready.set()
+        except Exception as e:
+            print(f"[ERROR] Failed to initialize Lite Hive Core: {e}")
+            traceback.print_exc()
+            # Still set the event so the UI doesn't hang, but it will show an error.
+            self.lite_core_ready.set()
 
     def soft_restart(self):
         """Performs a hot-reload of the application logic without restarting the process."""
         print("[Bootstrap] Performing soft restart (hot-reload)...")
         self.hive_ready.clear()
+        self.lite_core_ready.clear()
+        self.voice_ready.clear()
         if self.hive_instance:
             self.hive_instance.module_manager.stop_all()
         if self.app and hasattr(self.app, 'close'): # type: ignore