feat: Show active scene as effect on light entity

Add HA standard effect support so the active scene name displays on the
light card and users can activate scenes from the effect picker.

- Add active_scene_name field to GoveeDeviceState, set on scene
  activation, cleared on power off / color / color temp / mutual
  exclusion (music mode, DreamView, DIY scene)
- Implement effect_list and effect properties on GoveeLightEntity
- Handle ATTR_EFFECT in async_turn_on to send SceneCommand
- Load scenes in async_added_to_hass with duplicate name deduplication
- Respect CONF_ENABLE_SCENES option (disabled = no effect support)
- Preserve active_scene_name across API polls in coordinator
- Add 25 new tests (10 state model + 15 light entity)
- Bump version to 2026.2.9

Author: Tom Lasswell

custom_components/govee/coordinator.py

@@ -471,6 +471,9 @@ async def _fetch_device_state(
                 self._preserve_optimistic_field(
                     existing_state, state, device_id, "active_scene", "scene"
                 )
+                self._preserve_optimistic_field(
+                    existing_state, state, device_id, "active_scene_name", "scene name"
+                )
                 self._preserve_optimistic_field(
                     existing_state, state, device_id, "dreamview_enabled", "DreamView"
                 )
@@ -944,6 +947,7 @@ def clear_scene(self, device_id: str) -> None:
         state = self._states.get(device_id)
         if state:
             state.active_scene = None
+            state.active_scene_name = None
             state.source = "optimistic"
 
     def clear_diy_scene(self, device_id: str) -> None:

custom_components/govee/light.py

@@ -15,6 +15,7 @@
 from homeassistant.components.light import (  # type: ignore[attr-defined]
     ATTR_BRIGHTNESS,
     ATTR_COLOR_TEMP_KELVIN,
+    ATTR_EFFECT,
     ATTR_RGB_COLOR,
     ColorMode,
     LightEntity,
@@ -26,6 +27,8 @@
 from homeassistant.helpers.restore_state import RestoreEntity
 
 from .const import (
+    CONF_ENABLE_SCENES,
+    DEFAULT_ENABLE_SCENES,
     SEGMENT_MODE_GROUPED,
     SEGMENT_MODE_INDIVIDUAL,
 )
@@ -38,6 +41,7 @@
     GoveeDevice,
     PowerCommand,
     RGBColor,
+    SceneCommand,
 )
 from .platforms.grouped_segment import GoveeGroupedSegmentEntity
 from .platforms.segment import GoveeSegmentEntity
@@ -61,10 +65,13 @@ async def async_setup_entry(
     # Get per-device segment modes
     device_modes = entry.options.get("segment_mode_by_device", {})
 
+    # Check if scenes are enabled in options
+    enable_scenes = entry.options.get(CONF_ENABLE_SCENES, DEFAULT_ENABLE_SCENES)
+
     for device in coordinator.devices.values():
         # Only create light entities for devices with power control (not fans)
         if device.supports_power and not device.is_fan:
-            entities.append(GoveeLightEntity(coordinator, device))
+            entities.append(GoveeLightEntity(coordinator, device, enable_scenes))
 
         # Create segment entities for RGBIC devices based on per-device mode
         if device.supports_segments and device.segment_count > 0:
@@ -124,6 +131,7 @@ def __init__(
         self,
         coordinator: GoveeCoordinator,
         device: GoveeDevice,
+        enable_scenes: bool = True,
     ) -> None:
         """Initialize the light entity."""
         super().__init__(coordinator, device)
@@ -138,10 +146,16 @@ def __init__(
         # Get device brightness range
         self._brightness_min, self._brightness_max = device.brightness_range
 
-        # Add effect support if device has scenes
-        if device.supports_scenes:
+        # Effect support: only if device has scenes AND scenes are enabled
+        self._enable_scenes = device.supports_scenes and enable_scenes
+        if self._enable_scenes:
             self._attr_supported_features = LightEntityFeature.EFFECT
 
+        # Scene-to-effect mappings (populated in async_added_to_hass)
+        self._effect_to_scene: dict[str, tuple[int, str]] = {}
+        self._scene_id_to_effect: dict[str, str] = {}
+        self._effect_names: list[str] = []
+
     def _determine_color_modes(self) -> set[ColorMode]:
         """Determine supported color modes from device capabilities."""
         modes: set[ColorMode] = set()
@@ -220,6 +234,24 @@ def max_color_temp_kelvin(self) -> int:
         temp_range = self._device.color_temp_range
         return temp_range.max_kelvin if temp_range else 9000
 
+    @property
+    def effect_list(self) -> list[str] | None:
+        """Return list of available effects (scene names)."""
+        return self._effect_names if self._effect_names else None
+
+    @property
+    def effect(self) -> str | None:
+        """Return currently active effect (scene name)."""
+        state = self.device_state
+        if not state or not state.active_scene:
+            return None
+        # Look up display name from scene ID mapping
+        effect_name = self._scene_id_to_effect.get(state.active_scene)
+        if effect_name:
+            return effect_name
+        # Fall back to stored scene name if ID not in mapping
+        return state.active_scene_name
+
     def _ha_to_device_brightness(self, ha_brightness: int) -> int:
         """Convert HA brightness (0-255) to device range, respecting min."""
         ratio = ha_brightness / HA_BRIGHTNESS_MAX
@@ -233,11 +265,29 @@ def _device_to_ha_brightness(self, device_brightness: int) -> int:
         if device_range <= 0:
             return 0
         return int(
-            (device_brightness - self._brightness_min) / device_range * HA_BRIGHTNESS_MAX
+            (device_brightness - self._brightness_min)
+            / device_range
+            * HA_BRIGHTNESS_MAX
         )
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the light on with optional parameters."""
+        # Handle effect (scene activation)
+        if ATTR_EFFECT in kwargs:
+            effect_name = kwargs[ATTR_EFFECT]
+            scene_info = self._effect_to_scene.get(effect_name)
+            if scene_info:
+                scene_id, scene_name = scene_info
+                await self.coordinator.async_control_device(
+                    self._device_id,
+                    SceneCommand(scene_id=scene_id, scene_name=scene_name),
+                )
+            else:
+                _LOGGER.warning(
+                    "Unknown effect '%s' for %s", effect_name, self._device.name
+                )
+            return
+
         # Handle brightness
         if ATTR_BRIGHTNESS in kwargs:
             ha_brightness = kwargs[ATTR_BRIGHTNESS]
@@ -289,8 +339,35 @@ async def async_turn_off(self, **kwargs: Any) -> None:
             PowerCommand(power_on=False),
         )
 
+    def _build_effect_mapping(self, scenes: list[dict[str, Any]]) -> None:
+        """Build effect name mappings from scene data.
+
+        Handles duplicate scene names by appending a counter,
+        mirroring the logic in GoveeSceneSelectEntity.
+        """
+        self._effect_to_scene = {}
+        self._scene_id_to_effect = {}
+        names: list[str] = []
+
+        for scene_data in scenes:
+            scene_id = scene_data.get("value", {}).get("id", 0)
+            scene_name = scene_data.get("name", f"Scene {scene_id}")
+
+            # Handle duplicate names by appending counter
+            unique_name = scene_name
+            counter = 1
+            while unique_name in self._effect_to_scene:
+                unique_name = f"{scene_name} ({counter})"
+                counter += 1
+
+            self._effect_to_scene[unique_name] = (scene_id, scene_name)
+            self._scene_id_to_effect[str(scene_id)] = unique_name
+            names.append(unique_name)
+
+        self._effect_names = names
+
     async def async_added_to_hass(self) -> None:
-        """Restore state for group devices."""
+        """Restore state for group devices and load scenes for effects."""
         await super().async_added_to_hass()
 
         if self._device.is_group:
@@ -304,3 +381,9 @@ async def async_added_to_hass(self) -> None:
                         last_state.attributes["brightness"]
                     )
                 self.coordinator.restore_group_state(self._device_id, power, brightness)
+
+        # Load scenes for effect support (skip group devices - no scene API support)
+        if self._enable_scenes and not self._device.is_group:
+            scenes = await self.coordinator.async_get_scenes(self._device_id)
+            if scenes:
+                self._build_effect_mapping(scenes)

custom_components/govee/manifest.json

@@ -16,6 +16,6 @@
     "cryptography>=41.0.0"
   ],
   "ssdp": [],
-  "version": "2026.2.8",
+  "version": "2026.2.9",
   "zeroconf": []
 }

custom_components/govee/models/state.py

@@ -83,6 +83,7 @@ class GoveeDeviceState:
     color: RGBColor | None = None
     color_temp_kelvin: int | None = None
     active_scene: str | None = None
+    active_scene_name: str | None = None  # Display name of active scene
     active_diy_scene: str | None = None  # DIY scene ID (separate from regular scenes)
     segments: list[SegmentState] = field(default_factory=list)
     diy_style: str | None = None  # DIY animation style (Fade, Jumping, etc.)
@@ -110,7 +111,9 @@ class GoveeDeviceState:
     fan_speed: int | None = None  # Fan speed mode value (1=Low, 2=Medium, 3=High)
 
     # Purifier state
-    purifier_mode: int | None = None  # Purifier mode value (1=Sleep, 2=Low, 3=High, etc.)
+    purifier_mode: int | None = (
+        None  # Purifier mode value (1=Sleep, 2=Low, 3=High, etc.)
+    )
 
     # Last activated scene (for restoring after music mode off)
     last_scene_id: str | None = None
@@ -205,6 +208,7 @@ def apply_optimistic_power(self, power_on: bool) -> None:
         # Clear scene when turning off (scene is no longer active)
         if not power_on:
             self.active_scene = None
+            self.active_scene_name = None
 
     def apply_optimistic_brightness(self, brightness: int) -> None:
         """Apply optimistic brightness update."""
@@ -216,12 +220,18 @@ def apply_optimistic_color(self, color: RGBColor) -> None:
         self.color = color
         self.color_temp_kelvin = None  # RGB mode
         self.source = "optimistic"
+        # Setting a color overrides any running scene
+        self.active_scene = None
+        self.active_scene_name = None
 
     def apply_optimistic_color_temp(self, kelvin: int) -> None:
         """Apply optimistic color temperature update."""
         self.color_temp_kelvin = kelvin
         self.color = None  # Color temp mode
         self.source = "optimistic"
+        # Setting color temp overrides any running scene
+        self.active_scene = None
+        self.active_scene_name = None
 
     def apply_optimistic_scene(
         self, scene_id: str, scene_name: str | None = None
@@ -232,6 +242,7 @@ def apply_optimistic_scene(
         When a Scene is activated, DreamView, music mode, and DIY scene are cleared.
         """
         self.active_scene = scene_id
+        self.active_scene_name = scene_name
         self.last_scene_id = scene_id
         self.last_scene_name = scene_name
         self.source = "optimistic"
@@ -256,6 +267,7 @@ def apply_optimistic_diy_scene(self, scene_id: str) -> None:
         self.music_mode_value = None
         self.music_mode_name = None
         self.active_scene = None
+        self.active_scene_name = None
 
     def apply_optimistic_diy_style(
         self, style: str, style_value: int | None = None
@@ -282,6 +294,7 @@ def apply_optimistic_music_mode(self, enabled: bool) -> None:
         if enabled:
             self.dreamview_enabled = False
             self.active_scene = None
+            self.active_scene_name = None
             self.active_diy_scene = None
 
     def apply_optimistic_music_mode_struct(
@@ -308,6 +321,7 @@ def apply_optimistic_music_mode_struct(
         # Mutual exclusion: clear other modes when enabling music mode
         self.dreamview_enabled = False
         self.active_scene = None
+        self.active_scene_name = None
         self.active_diy_scene = None
 
     def apply_optimistic_oscillation(self, oscillating: bool) -> None:
@@ -340,6 +354,7 @@ def apply_optimistic_dreamview(self, enabled: bool) -> None:
             self.music_mode_value = None
             self.music_mode_name = None
             self.active_scene = None
+            self.active_scene_name = None
             self.active_diy_scene = None
 
     @classmethod