fix(climate): write mode-correct setpoints and stop REST reverting live state

Two independent bugs made a second change (e.g. adjusting the target
temperature right after switching cool -> heat) fail to take, and made
Home Assistant settle back on a previous state while DKN Cloud NA showed
the correct one.

Wrong setpoint key on write:

_writable_temperature_property_for_mode() ignored its hvac_mode argument
and resolved the key from real_mode/mode in the cached device payload.
That payload still describes the pre-change state, so a heat setpoint was
emitted as setpoint_air_cool: the unit switched to heat but the heat
setpoint never moved. The same defect broke AUTO in steady state, where
real_mode=cool made the write target setpoint_air_cool while the read
used setpoint_air_auto, so the value could never appear to change.

target_temperature() and writable_target_temperature_key() now accept the
mode the caller intends, and that mode takes priority over anything in the
device payload. Device-reported modes remain a fallback only for payloads
that do not expose the requested mode's setpoint.

async_set_temperature() no longer re-sends power+mode; async_set_hvac_mode()
already sent them, and the stale-cache condition guarding the resend was
always true. It now waits (bounded) for the cloud to echo the mode before
sending the setpoint, matching the ensure_mode ordering the smoke test uses.

REST snapshot reverting live state:

The coordinator merged {**existing, **device}, letting the lagging REST
/installations snapshot win over live Socket.IO pushes. Once the socket
confirmed a write, _reconcile_optimistic dropped the overlay, leaving
nothing to stop the next poll from reverting the state.

Socket-pushed values are now tracked per device and applied after the REST
payload. They are discarded when the socket session changes, since updates
may have been missed while it was down and REST becomes authoritative again.

Also report hvac_action and target_temperature against the effective
(optimistic-aware) mode so the action cannot contradict the reported mode
while a change propagates.

Co-authored-by: anthropic/claude-opus-5

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,13 @@
+homeassistant-dkncloudna
+Copyright (c) 2026 Sebastien Lavoie
+Copyright (c) 2026 James Griffin-Allwood
+
+Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+This repository is a fork of homeassistant-dkncloudna by Sebastien
+Lavoie (https://github.com/lavoiesl/homeassistant-dkncloudna), which
+is itself a port of the homebridge-dkncloudna plugin by @plecong
+(https://github.com/plecong/homebridge-dkncloudna), licensed under
+the Apache License, Version 2.0. Portions of this project (API
+protocol details, device mode mappings, and overall behavior) are
+derived from those works.

README.md

@@ -31,7 +31,7 @@ Any Daikin mini-split system connected to the **DKN Cloud NA** WiFi adapter (Nor
 1. Open HACS in your Home Assistant instance
 2. Go to **Integrations**
 3. Click the **⋮** menu → **Custom repositories**
-4. Add `https://github.com/lavoiesl/homeassistant-dkncloudna` as an **Integration**
+4. Add `https://github.com/thatguygriff/homeassistant-dkncloudna` as an **Integration**
 5. Search for **DKN Cloud NA** and install it
 6. Restart Home Assistant
 

custom_components/dkncloudna/api.py

@@ -65,6 +65,10 @@ class DknCloudNaClient:
         self._socket_refresh_callback: Callable[[], Awaitable[None]] | None = None
         self._last_command_ack: dict[str, Any] | None = None
         self._recent_socket_events: deque[dict[str, Any]] = deque(maxlen=20)
+        # Incremented on every successful Socket.IO connection so consumers can
+        # tell that live state accumulated from the previous session is no
+        # longer trustworthy and must be re-synced from REST.
+        self.socket_session = 0
 
     def clear_password(self) -> None:
         """Discard password from memory after token exchange."""
@@ -194,6 +198,7 @@ class DknCloudNaClient:
         self._socket = sio
         self._socket_installations = installation_ids
         self._socket_token = self.token
+        self.socket_session += 1
         return True
 
     async def _ensure_socket_ready_for_write_locked(self, installation_id: str) -> None:

custom_components/dkncloudna/climate.py

@@ -133,10 +133,16 @@ class DknClimateEntity(DknEntity, ClimateEntity):
 
     @property
     def hvac_action(self) -> HVACAction | None:
-        if self.hvac_mode == HVACMode.OFF:
+        mode = self.hvac_mode
+        if mode == HVACMode.OFF:
             return HVACAction.OFF
 
-        action = inferred_hvac_action(self._device_data)
+        action = inferred_hvac_action(
+            self._device_data,
+            mode=_HVAC_TO_MODE.get(mode),
+            target=self.target_temperature,
+            power=True,
+        )
         if action == "heating":
             return HVACAction.HEATING
         if action == "cooling":
@@ -158,7 +164,12 @@ class DknClimateEntity(DknEntity, ClimateEntity):
         mode = self.hvac_mode
         if mode in _NO_TARGET_TEMP_MODES:
             return None
-        fallback = model_target_temperature(self._device_data)
+        # Read the setpoint for the effective mode so the value shown matches
+        # the key a write would target, even while a mode change is still
+        # propagating through the cloud.
+        fallback = model_target_temperature(self._device_data, _HVAC_TO_MODE.get(mode))
+        if fallback is None:
+            fallback = model_target_temperature(self._device_data)
         if fallback is None:
             return None
         return self._optimistic_get("target_temp", fallback)
@@ -239,31 +250,22 @@ class DknClimateEntity(DknEntity, ClimateEntity):
             )
 
         installation_id = self._installation_id
-        property_name = self._writable_temperature_property_for_mode(target_mode)
-        device_temp = self._to_device_temperature(float(temperature))
+        requested_mode_code = _HVAC_TO_MODE.get(target_mode)
 
         async with self._get_device_lock():
+            # A mode change made moments ago (either above, or by a separate
+            # set_hvac_mode call from the UI) may not have landed in the cloud
+            # yet. Give it a bounded window to be echoed back before writing the
+            # setpoint, so the setpoint is not applied against the old mode.
+            if (
+                requested_mode_code is not None
+                and self._device_data.get("mode") != requested_mode_code
+            ):
+                await self._async_wait_for_device_value("mode", requested_mode_code)
+
+            property_name = self._writable_temperature_property_for_mode(target_mode)
+            device_temp = self._to_device_temperature(float(temperature))
             try:
-                requested_mode_code = _HVAC_TO_MODE.get(target_mode)
-                if (
-                    requested_mode_code is not None
-                    and self._device_data.get("mode") != requested_mode_code
-                ):
-                    await self.coordinator.client.async_send_machine_event(
-                        installation_id, self._command_mac, "power", True
-                    )
-                    await self.coordinator.client.async_send_machine_event(
-                        installation_id, self._command_mac, "mode", requested_mode_code
-                    )
-                    self._optimistic_set(
-                        "power", True, device_key="power", device_value=True
-                    )
-                    self._optimistic_set(
-                        "hvac_mode",
-                        target_mode,
-                        device_key="mode",
-                        device_value=requested_mode_code,
-                    )
                 await self.coordinator.client.async_send_machine_event(
                     installation_id, self._command_mac, property_name, device_temp
                 )
@@ -354,10 +356,14 @@ class DknClimateEntity(DknEntity, ClimateEntity):
         return key
 
     def _writable_temperature_property_for_mode(self, hvac_mode: HVACMode) -> str:
-        preferred = writable_target_temperature_key(self._device_data)
-        if preferred is not None:
-            return preferred
-        return self._temperature_property_for_mode(hvac_mode)
+        # The key must follow the mode being requested, not whatever mode the
+        # cached device payload still reports; that payload lags behind a mode
+        # change and would send e.g. a heat setpoint to setpoint_air_cool.
+        requested = self._temperature_property_for_mode(hvac_mode)
+        preferred = writable_target_temperature_key(
+            self._device_data, _HVAC_TO_MODE.get(hvac_mode)
+        )
+        return preferred or requested
 
     def _to_device_temperature(self, temperature_c: float) -> float | int:
         return to_device_temperature(temperature_c, self._device_data.get("units"))

custom_components/dkncloudna/const.py

@@ -48,6 +48,12 @@ OPTIMISTIC_TTL_SEC: float = 30.0
 # Post-write coordinator refresh: coalesced delay after a device command.
 POST_WRITE_REFRESH_DELAY_SEC: float = 1.0
 
+# Bounded wait for the cloud to echo a dependent write (e.g. confirming a mode
+# change before the matching setpoint is sent) and the poll step used while
+# waiting.
+DEVICE_ECHO_TIMEOUT_SEC: float = 8.0
+DEVICE_ECHO_POLL_SEC: float = 0.25
+
 # Device modes (from homebridge plugin src/types.ts)
 # DeviceMode: 1=Auto, 2=Cool, 3=Heat, 4=Fan, 5=Dry
 DEVICE_MODE_AUTO = 1

custom_components/dkncloudna/coordinator.py

@@ -44,6 +44,11 @@ class DknCoordinator(DataUpdateCoordinator[dict[str, dict[str, Any]]]):
         self.client = client
         self._entry = entry
         self.entry_id = entry.entry_id
+        # Values pushed over Socket.IO during the current socket session, keyed
+        # by mac. The REST /installations snapshot can lag behind reality, so
+        # these take precedence over it until the socket reconnects.
+        self._live_state: dict[str, dict[str, Any]] = {}
+        self._live_state_session: int = 0
 
     async def _async_update_data(self) -> dict[str, dict[str, Any]]:
         """Fetch all installations and flatten into {mac: device_dict}."""
@@ -65,6 +70,7 @@ class DknCoordinator(DataUpdateCoordinator[dict[str, dict[str, Any]]]):
             raise UpdateFailed(f"Unexpected error: {type(err).__name__}") from err
 
         self._persist_tokens_if_changed()
+        self._discard_stale_live_state()
 
         devices: dict[str, dict[str, Any]] = {}
         existing = self.data or {}
@@ -77,11 +83,27 @@ class DknCoordinator(DataUpdateCoordinator[dict[str, dict[str, Any]]]):
                 devices[mac] = {
                     **existing.get(mac, {}),
                     **device,
+                    # Socket.IO pushes are the live source of truth; the REST
+                    # snapshot is frequently a few minutes behind and would
+                    # otherwise revert state the socket already reported.
+                    **self._live_state.get(mac, {}),
                     "_installation_id": inst_id,
                 }
 
         return devices
 
+    def _discard_stale_live_state(self) -> None:
+        """Drop accumulated live state when the socket session has changed.
+
+        A new socket session means updates may have been missed while it was
+        down, so the REST snapshot becomes authoritative again until fresh
+        pushes arrive.
+        """
+        session = self.client.socket_session
+        if session != self._live_state_session:
+            self._live_state_session = session
+            self._live_state = {}
+
     def _persist_tokens_if_changed(self) -> None:
         """Save refreshed tokens back to the config entry so they survive restarts."""
         opts = self._entry.options
@@ -105,6 +127,8 @@ class DknCoordinator(DataUpdateCoordinator[dict[str, dict[str, Any]]]):
         self, mac: str, data: dict[str, Any]
     ) -> None:
         """Merge live device-data from Socket.IO into coordinator state."""
+        self._discard_stale_live_state()
+        self._live_state[mac] = {**self._live_state.get(mac, {}), **data}
         current = dict(self.data or {})
         current[mac] = {**current.get(mac, {}), **data}
         self.async_set_updated_data(current)

custom_components/dkncloudna/entity.py

@@ -10,6 +10,8 @@ from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, Device
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
+    DEVICE_ECHO_POLL_SEC,
+    DEVICE_ECHO_TIMEOUT_SEC,
     DOMAIN,
     MANUFACTURER,
     OPTIMISTIC_TTL_SEC,
@@ -137,6 +139,37 @@ class DknEntity(CoordinatorEntity[DknCoordinator]):
         self._reconcile_optimistic()
         super()._handle_coordinator_update()
 
+    # ------------------------------------------------------------------
+    # Waiting for the cloud to echo a write
+    # ------------------------------------------------------------------
+
+    async def _async_wait_for_device_value(
+        self,
+        device_key: str,
+        expected: Any,
+        timeout: float = DEVICE_ECHO_TIMEOUT_SEC,
+    ) -> bool:
+        """Wait until the device reports ``expected`` for ``device_key``.
+
+        Socket.IO pushes land in coordinator data, so polling it is enough. A
+        single mid-window refresh covers the case where no push arrives.
+        Returns whether the value was observed before the timeout.
+        """
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + timeout
+        refreshed = False
+        while True:
+            if self._device_data.get(device_key) == expected:
+                return True
+            remaining = deadline - loop.time()
+            if remaining <= 0:
+                return False
+            if not refreshed and remaining < timeout / 2:
+                refreshed = True
+                await self.coordinator.async_request_refresh()
+                continue
+            await asyncio.sleep(min(DEVICE_ECHO_POLL_SEC, remaining))
+
     # ------------------------------------------------------------------
     # Post-write coordinator refresh (coalesced)
     # ------------------------------------------------------------------

custom_components/dkncloudna/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "issue_tracker": "https://github.com/lavoiesl/homeassistant-dkncloudna/issues",
   "requirements": ["python-socketio>=4.6.1,<5"],
-  "version": "0.2.0"
+  "version": "0.2.1"
 }

custom_components/dkncloudna/model.py

@@ -84,19 +84,35 @@ def target_temperature_key(mode: int | None) -> str | None:
     return None
 
 
-def target_temperature(data: dict[str, Any]) -> float | None:
-    """Return the requested target temperature in Celsius."""
-    key = target_temperature_key(requested_mode(data))
+def target_temperature(data: dict[str, Any], mode: int | None = None) -> float | None:
+    """Return the target temperature in Celsius for ``mode``.
+
+    ``mode`` defaults to the device's requested mode. Callers that already know
+    the effective mode (for example while an optimistic mode change is still
+    propagating) should pass it so the read uses the same setpoint key the
+    write used.
+    """
+    key = target_temperature_key(mode if mode is not None else requested_mode(data))
     if key is None:
         return None
     return to_celsius(data.get(key), data.get("units"))
 
 
-def writable_target_temperature_key(data: dict[str, Any]) -> str | None:
-    """Return the setpoint key most likely to be writable for the current state."""
+def writable_target_temperature_key(
+    data: dict[str, Any], mode: int | None = None
+) -> str | None:
+    """Return the setpoint key to write for ``mode``.
+
+    ``mode`` is the mode the write is intended for and takes priority over
+    anything in ``data``, which may still describe the pre-change state while a
+    mode change propagates through the cloud. The device-reported modes are
+    only consulted as a fallback for payloads that do not expose the requested
+    mode's setpoint at all.
+    """
     candidates: list[str] = []
-    for mode in (live_mode(data), requested_mode(data), DEVICE_MODE_AUTO):
-        key = target_temperature_key(mode)
+    preference = (mode, live_mode(data), requested_mode(data), DEVICE_MODE_AUTO)
+    for candidate_mode in preference:
+        key = target_temperature_key(candidate_mode)
         if key is not None and key not in candidates:
             candidates.append(key)
 
@@ -107,15 +123,28 @@ def writable_target_temperature_key(data: dict[str, Any]) -> str | None:
     return candidates[0] if candidates else None
 
 
-def inferred_hvac_action(data: dict[str, Any]) -> str:
-    """Infer the active HVAC action from requested mode and temperatures."""
-    power = as_bool(data.get("power"))
+def inferred_hvac_action(
+    data: dict[str, Any],
+    mode: int | None = None,
+    target: float | None = None,
+    power: bool | None = None,
+) -> str:
+    """Infer the active HVAC action from the effective mode and temperatures.
+
+    ``mode``, ``target`` and ``power`` let callers supply the effective
+    (possibly still optimistic) values so the reported action matches the
+    reported mode.
+    """
+    if power is None:
+        power = as_bool(data.get("power"))
     if not power:
         return "off"
 
-    mode = requested_mode(data)
+    if mode is None:
+        mode = requested_mode(data)
     current = current_temperature(data)
-    target = target_temperature(data)
+    if target is None:
+        target = target_temperature(data, mode)
 
     if mode == DEVICE_MODE_HEAT:
         if current is not None and target is not None and current < target: