fix(vegas): keep plugin data and visuals fresh during Vegas scroll mode

src/display_controller.py

@@ -398,6 +398,12 @@ def _initialize_vegas_mode(self):
                 check_interval=10  # Check every 10 frames (~80ms at 125 FPS)
             )
 
+            # Set up plugin update tick to keep data fresh during Vegas mode
+            self.vegas_coordinator.set_update_tick(
+                self._tick_plugin_updates_for_vegas,
+                interval=1.0
+            )
+
             logger.info("Vegas mode coordinator initialized")
 
         except Exception as e:
@@ -434,6 +440,38 @@ def _check_vegas_interrupt(self) -> bool:
 
         return False
 
+    def _tick_plugin_updates_for_vegas(self):
+        """
+        Run scheduled plugin updates and return IDs of plugins that were updated.
+
+        Called periodically by the Vegas coordinator to keep plugin data fresh
+        during Vegas mode. Returns a list of plugin IDs whose data changed so
+        Vegas can refresh their content in the scroll.
+
+        Returns:
+            List of updated plugin IDs, or None if no updates occurred
+        """
+        if not self.plugin_manager or not hasattr(self.plugin_manager, 'plugin_last_update'):
+            self._tick_plugin_updates()
+            return None
+
+        # Snapshot update timestamps before ticking
+        old_times = dict(self.plugin_manager.plugin_last_update)
+
+        # Run the scheduled updates
+        self._tick_plugin_updates()
+
+        # Detect which plugins were actually updated
+        updated = []
+        for plugin_id, new_time in self.plugin_manager.plugin_last_update.items():
+            if new_time > old_times.get(plugin_id, 0.0):
+                updated.append(plugin_id)
+
+        if updated:
+            logger.info("Vegas update tick: %d plugin(s) updated: %s", len(updated), updated)
+
+        return updated or None
+
     def _check_schedule(self):
         """Check if display should be active based on schedule."""
         # Get fresh config from config_service to support hot-reload

src/vegas_mode/coordinator.py

@@ -90,6 +90,14 @@ def __init__(
         self._interrupt_check: Optional[Callable[[], bool]] = None
         self._interrupt_check_interval: int = 10  # Check every N frames
 
+        # Plugin update tick for keeping data fresh during Vegas mode
+        self._update_tick: Optional[Callable[[], Optional[List[str]]]] = None
+        self._update_tick_interval: float = 1.0  # Tick every 1 second
+        self._update_thread: Optional[threading.Thread] = None
+        self._update_results: Optional[List[str]] = None
+        self._update_results_lock = threading.Lock()
+        self._last_update_tick_time: float = 0.0
+
         # Config update tracking
         self._config_version = 0
         self._pending_config_update = False
@@ -158,6 +166,25 @@ def set_interrupt_checker(
         self._interrupt_check = checker
         self._interrupt_check_interval = max(1, check_interval)
 
+    def set_update_tick(
+        self,
+        callback: Callable[[], Optional[List[str]]],
+        interval: float = 1.0
+    ) -> None:
+        """
+        Set the callback for periodic plugin update ticking during Vegas mode.
+
+        This keeps plugin data fresh while the Vegas render loop is running.
+        The callback should run scheduled plugin updates and return a list of
+        plugin IDs that were actually updated, or None/empty if no updates occurred.
+
+        Args:
+            callback: Callable that returns list of updated plugin IDs or None
+            interval: Seconds between update tick calls (default 1.0)
+        """
+        self._update_tick = callback
+        self._update_tick_interval = max(0.5, interval)
+
     def start(self) -> bool:
         """
         Start Vegas mode operation.
@@ -210,6 +237,9 @@ def stop(self) -> None:
                 self.stats['total_runtime_seconds'] += time.time() - self._start_time
                 self._start_time = None
 
+        # Wait for in-flight background update before tearing down state
+        self._drain_update_thread()
+
         # Cleanup components
         self.render_pipeline.reset()
         self.stream_manager.reset()
@@ -305,71 +335,83 @@ def run_iteration(self) -> bool:
         last_fps_log_time = start_time
         fps_frame_count = 0
 
-        logger.info("Starting Vegas iteration for %.1fs", duration)
+        self._last_update_tick_time = start_time
 
-        while True:
-            # Check for STATIC mode plugin that should pause scroll
-            static_plugin = self._check_static_plugin_trigger()
-            if static_plugin:
-                if not self._handle_static_pause(static_plugin):
-                    # Static pause was interrupted
-                    return False
-                # After static pause, skip this segment and continue
-                self.stream_manager.get_next_segment()  # Consume the segment
-                continue
-
-            # Run frame
-            if not self.run_frame():
-                # Check why we stopped
-                with self._state_lock:
-                    if self._should_stop:
-                        return False
-                    if self._is_paused:
-                        # Paused for live priority - let caller handle
-                        return False
-
-            # Sleep for frame interval
-            time.sleep(frame_interval)
-
-            # Increment frame count and check for interrupt periodically
-            frame_count += 1
-            fps_frame_count += 1
-
-            # Periodic FPS logging
-            current_time = time.time()
-            if current_time - last_fps_log_time >= fps_log_interval:
-                fps = fps_frame_count / (current_time - last_fps_log_time)
-                logger.info(
-                    "Vegas FPS: %.1f (target: %d, frames: %d)",
-                    fps, self.vegas_config.target_fps, fps_frame_count
-                )
-                last_fps_log_time = current_time
-                fps_frame_count = 0
+        logger.info("Starting Vegas iteration for %.1fs", duration)
 
-            if (self._interrupt_check and
-                    frame_count % self._interrupt_check_interval == 0):
-                try:
-                    if self._interrupt_check():
-                        logger.debug(
-                            "Vegas interrupted by callback after %d frames",
-                            frame_count
-                        )
+        try:
+            while True:
+                # Check for STATIC mode plugin that should pause scroll
+                static_plugin = self._check_static_plugin_trigger()
+                if static_plugin:
+                    if not self._handle_static_pause(static_plugin):
+                        # Static pause was interrupted
                         return False
-                except Exception:
-                    # Log but don't let interrupt check errors stop Vegas
-                    logger.exception("Interrupt check failed")
-
-            # Check elapsed time
-            elapsed = time.time() - start_time
-            if elapsed >= duration:
-                break
-
-            # Check for cycle completion
-            if self.render_pipeline.is_cycle_complete():
-                break
+                    # After static pause, skip this segment and continue
+                    self.stream_manager.get_next_segment()  # Consume the segment
+                    continue
+
+                # Run frame
+                if not self.run_frame():
+                    # Check why we stopped
+                    with self._state_lock:
+                        if self._should_stop:
+                            return False
+                        if self._is_paused:
+                            # Paused for live priority - let caller handle
+                            return False
+
+                # Sleep for frame interval
+                time.sleep(frame_interval)
+
+                # Increment frame count and check for interrupt periodically
+                frame_count += 1
+                fps_frame_count += 1
+
+                # Periodic FPS logging
+                current_time = time.time()
+                if current_time - last_fps_log_time >= fps_log_interval:
+                    fps = fps_frame_count / (current_time - last_fps_log_time)
+                    logger.info(
+                        "Vegas FPS: %.1f (target: %d, frames: %d)",
+                        fps, self.vegas_config.target_fps, fps_frame_count
+                    )
+                    last_fps_log_time = current_time
+                    fps_frame_count = 0
+
+                # Periodic plugin update tick to keep data fresh (non-blocking)
+                self._drive_background_updates()
+
+                if (self._interrupt_check and
+                        frame_count % self._interrupt_check_interval == 0):
+                    try:
+                        if self._interrupt_check():
+                            logger.debug(
+                                "Vegas interrupted by callback after %d frames",
+                                frame_count
+                            )
+                            return False
+                    except Exception:
+                        # Log but don't let interrupt check errors stop Vegas
+                        logger.exception("Interrupt check failed")
+
+                # Check elapsed time
+                elapsed = time.time() - start_time
+                if elapsed >= duration:
+                    break
+
+                # Check for cycle completion
+                if self.render_pipeline.is_cycle_complete():
+                    break
+
+            logger.info("Vegas iteration completed after %.1fs", time.time() - start_time)
+            return True
 
-        logger.info("Vegas iteration completed after %.1fs", time.time() - start_time)
-        return True
+        finally:
+            # Ensure background update thread finishes before the main loop
+            # resumes its own _tick_plugin_updates() calls, preventing concurrent
+            # run_scheduled_updates() execution.
+            self._drain_update_thread()
 
     def _check_live_priority(self) -> bool:
         """
@@ -458,6 +500,71 @@ def _apply_pending_config(self) -> None:
                 if self._pending_config is None:
                     self._pending_config_update = False
 
+    def _run_update_tick_background(self) -> None:
+        """Run the plugin update tick in a background thread.
+
+        Stores results for the render loop to pick up on its next iteration,
+        so the scroll never blocks on API calls.
+        """
+        try:
+            updated_plugins = self._update_tick()
+            if updated_plugins:
+                with self._update_results_lock:
+                    # Accumulate rather than replace to avoid losing notifications
+                    # if a previous result hasn't been picked up yet
+                    if self._update_results is None:
+                        self._update_results = updated_plugins
+                    else:
+                        self._update_results.extend(updated_plugins)
+        except Exception:
+            logger.exception("Background plugin update tick failed")
+
+    def _drain_update_thread(self, timeout: float = 2.0) -> None:
+        """Wait for any in-flight background update thread to finish.
+
+        Called when transitioning out of Vegas mode so the main-loop
+        ``_tick_plugin_updates`` call doesn't race with a still-running
+        background thread.
+        """
+        if self._update_thread is not None and self._update_thread.is_alive():
+            self._update_thread.join(timeout=timeout)
+            if self._update_thread.is_alive():
+                logger.warning(
+                    "Background update thread did not finish within %.1fs", timeout
+                )
+
+    def _drive_background_updates(self) -> None:
+        """Collect finished background update results and launch new ticks.
+
+        Safe to call from both the main render loop and the static-pause
+        wait loop so that plugin data stays fresh regardless of which
+        code path is active.
+        """
+        # 1. Collect results from a previously completed background update
+        with self._update_results_lock:
+            ready_results = self._update_results
+            self._update_results = None
+        if ready_results:
+            for pid in ready_results:
+                self.mark_plugin_updated(pid)
+
+        # 2. Kick off a new background update if interval elapsed and none running
+        current_time = time.time()
+        if (self._update_tick and
+                current_time - self._last_update_tick_time >= self._update_tick_interval):
+            thread_alive = (
+                self._update_thread is not None
+                and self._update_thread.is_alive()
+            )
+            if not thread_alive:
+                self._last_update_tick_time = current_time
+                self._update_thread = threading.Thread(
+                    target=self._run_update_tick_background,
+                    daemon=True,
+                    name="vegas-update-tick",
+                )
+                self._update_thread.start()
+
     def mark_plugin_updated(self, plugin_id: str) -> None:
         """
         Notify that a plugin's data has been updated.
@@ -576,6 +683,9 @@ def _handle_static_pause(self, plugin: 'BasePlugin') -> bool:
                     logger.info("Static pause interrupted by live priority")
                     return False
 
+                # Keep plugin data fresh during static pause
+                self._drive_background_updates()
+
                 # Sleep in small increments to remain responsive
                 time.sleep(0.1)
 

src/vegas_mode/plugin_adapter.py

@@ -408,7 +408,10 @@ def _capture_display_content(
             original_image = self.display_manager.image.copy()
             logger.info("[%s] Fallback: saved original display state", plugin_id)
 
-            # Ensure plugin has fresh data before capturing
+            # Lightweight in-memory data refresh before capturing.
+            # Full update() is intentionally skipped here — the background
+            # update tick in the Vegas coordinator handles periodic API
+            # refreshes so we don't block the content-fetch thread.
             has_update_data = hasattr(plugin, 'update_data')
             logger.info("[%s] Fallback: has update_data=%s", plugin_id, has_update_data)
             if has_update_data:
@@ -582,6 +585,28 @@ def invalidate_cache(self, plugin_id: Optional[str] = None) -> None:
             else:
                 self._content_cache.clear()
 
+    def invalidate_plugin_scroll_cache(self, plugin: 'BasePlugin', plugin_id: str) -> None:
+        """
+        Clear a plugin's scroll_helper cache so Vegas re-fetches fresh visuals.
+
+        Uses scroll_helper.clear_cache() to reset all cached state (cached_image,
+        cached_array, total_scroll_width, scroll_position, etc.) — not just the
+        image.  Without this, plugins that use scroll_helper (stocks, news,
+        odds-ticker, etc.) would keep serving stale scroll images even after
+        their data refreshes.
+
+        Args:
+            plugin: Plugin instance
+            plugin_id: Plugin identifier
+        """
+        scroll_helper = getattr(plugin, 'scroll_helper', None)
+        if scroll_helper is None:
+            return
+
+        if getattr(scroll_helper, 'cached_image', None) is not None:
+            scroll_helper.clear_cache()
+            logger.debug("[%s] Cleared scroll_helper cache", plugin_id)
+
     def get_content_type(self, plugin: 'BasePlugin', plugin_id: str) -> str:
         """
         Get the type of content a plugin provides.

src/vegas_mode/stream_manager.py

@@ -217,6 +217,15 @@ def process_updates(self) -> None:
         refreshed_segments = {}
         for plugin_id in updated_plugins:
             self.plugin_adapter.invalidate_cache(plugin_id)
+
+            # Clear the plugin's scroll_helper cache so the visual is rebuilt
+            # from fresh data (affects stocks, news, odds-ticker, etc.)
+            plugin = None
+            if hasattr(self.plugin_manager, 'plugins'):
+                plugin = self.plugin_manager.plugins.get(plugin_id)
+            if plugin:
+                self.plugin_adapter.invalidate_plugin_scroll_cache(plugin, plugin_id)
+
             segment = self._fetch_plugin_content(plugin_id)
             if segment:
                 refreshed_segments[plugin_id] = segment