From a55a7d50f9b3626b754ffbda9a5a64277e27f2f6 Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 11:48:57 +0700
Subject: [PATCH 01/11] feat(companion): map cover/scene/sensor domains; make
 primary optional
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add three HA domains to the companion mapper, following the light/switch/lock
pattern:
- cover:  state-dependent open/close/stop (+ all three as secondary)
- scene:  single turn_on ("Activate"); state masked to a stable "scene" token
          (HA's raw state is a last-activated timestamp)
- sensor: read-only — no primary action, unit_of_measurement folded into
          state ("21.5 °C")

EntityCard.primary becomes optional (additive, NO protocol v bump): senders
that always include it stay valid, readers must tolerate its absence so a
read-only sensor renders no primary tile.

Update docs (p2p-protocol, ha-integration-notes) and EntityMapper tests
(cover/scene/sensor cases; sensor is now mapped, not filtered out).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../companion/bridge/EntityMapper.kt          | 39 ++++++++--
 .../homeassistant/companion/p2p/Messages.kt   |  4 +-
 .../companion/EntityMapperTest.kt             | 72 ++++++++++++++++---
 docs/ha-integration-notes.md                  |  8 ++-
 docs/p2p-protocol.md                          | 11 ++-
 5 files changed, 114 insertions(+), 20 deletions(-)

diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt
index d85fa24..2c19189 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt
@@ -6,35 +6,55 @@ import ru.gentslava.homeassistant.companion.p2p.EntityCard
 
 /**
  * Maps Home Assistant states to our P2P EntityCard/EntityAction (see docs/ha-integration-notes.md).
- * MVP domains: light, switch, lock. Labels are English for now — localization is a later task
- * (the watch renders labels as-is).
+ * Domains: light, switch, lock, cover, scene, sensor. Labels are English for now — localization
+ * is a later task (the watch renders labels as-is).
+ *
+ * sensor is read-only: no primary action (the unit is folded into [state]). scene is stateless: a
+ * single "Activate" action with a stable display state (its HA state is a timestamp we don't show).
  */
 object EntityMapper {
 
-    val SUPPORTED_DOMAINS = setOf("light", "switch", "lock")
+    val SUPPORTED_DOMAINS = setOf("light", "switch", "lock", "cover", "scene", "sensor")
 
     fun cards(states: List<HaState>): List<EntityCard> = states.mapNotNull(::toCard)
 
     fun toCard(s: HaState): EntityCard? {
         if (s.domain !in SUPPORTED_DOMAINS) return null
-        val primary = primaryAction(s)
         return EntityCard(
             entityId = s.entityId,
             domain = s.domain,
             name = s.friendlyName,
-            state = s.state,
+            state = displayState(s),
             icon = s.domain,
-            primary = primary,
+            primary = primaryAction(s),
             secondary = secondaryActions(s),
         )
     }
 
-    private fun primaryAction(s: HaState): EntityAction = when (s.domain) {
+    /** What the watch shows as the entity's state line. */
+    private fun displayState(s: HaState): String = when (s.domain) {
+        // A scene's HA state is a last-activated timestamp — show a stable token instead.
+        "scene" -> "scene"
+        // Fold the unit into the value so the watch needs no extra field: "21.5" + "°C".
+        "sensor" -> s.attr("unit_of_measurement")?.let { "${s.state} $it" } ?: s.state
+        else -> s.state
+    }
+
+    private fun primaryAction(s: HaState): EntityAction? = when (s.domain) {
         "lock" -> if (s.state == "locked") {
             action("Unlock", "lock", "unlock", s.entityId)
         } else {
             action("Lock", "lock", "lock", s.entityId)
         }
+        "cover" -> when (s.state) {
+            "open" -> action("Close", "cover", "close_cover", s.entityId)
+            "closed" -> action("Open", "cover", "open_cover", s.entityId)
+            "opening", "closing" -> action("Stop", "cover", "stop_cover", s.entityId)
+            else -> action("Open", "cover", "open_cover", s.entityId)
+        }
+        "scene" -> action("Activate", "scene", "turn_on", s.entityId)
+        // Read-only: no primary tile on the watch.
+        "sensor" -> null
         // light / switch
         else -> action("Toggle", s.domain, "toggle", s.entityId)
     }
@@ -48,6 +68,11 @@ object EntityMapper {
             action("On", "switch", "turn_on", s.entityId),
             action("Off", "switch", "turn_off", s.entityId),
         )
+        "cover" -> listOf(
+            action("Open", "cover", "open_cover", s.entityId),
+            action("Close", "cover", "close_cover", s.entityId),
+            action("Stop", "cover", "stop_cover", s.entityId),
+        )
         else -> emptyList()
     }
 
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt
index 3be374d..51d8b23 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt
@@ -37,7 +37,9 @@ data class EntityCard(
     val name: String,
     val state: String,
     val icon: String? = null,
-    val primary: EntityAction,
+    // Omitted for read-only cards (e.g. sensor): the watch renders no primary tile. Additive,
+    // backward-compatible — existing senders always include it, readers tolerate its absence.
+    val primary: EntityAction? = null,
     val secondary: List<EntityAction> = emptyList(),
 )
 
diff --git a/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt
index f917024..8ce7a4b 100644
--- a/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt
+++ b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt
@@ -17,36 +17,91 @@ class EntityMapperTest {
         attributes = buildJsonObject { if (name != null) put("friendly_name", name) },
     )
 
+    private fun stateWithUnit(id: String, st: String, unit: String) = HaState(
+        entityId = id,
+        state = st,
+        attributes = buildJsonObject { put("unit_of_measurement", unit) },
+    )
+
     @Test fun lightMapsToTogglePrimary() {
         val card = EntityMapper.toCard(state("light.kitchen", "on", "Kitchen"))!!
         assertEquals("light", card.domain)
         assertEquals("Kitchen", card.name)
         assertEquals("on", card.state)
-        assertEquals("toggle", card.primary.service)
-        assertEquals(mapOf("entity_id" to "light.kitchen"), card.primary.data)
+        assertEquals("toggle", card.primary!!.service)
+        assertEquals(mapOf("entity_id" to "light.kitchen"), card.primary!!.data)
     }
 
     @Test fun switchMapsToToggle() {
         val card = EntityMapper.toCard(state("switch.router", "off"))!!
-        assertEquals("toggle", card.primary.service)
+        assertEquals("toggle", card.primary!!.service)
         // friendly_name fallback humanizes object_id
         assertEquals("Router", card.name)
     }
 
     @Test fun lockLockedExposesUnlock() {
         val card = EntityMapper.toCard(state("lock.front_door", "locked"))!!
-        assertEquals("unlock", card.primary.service)
-        assertEquals("lock", card.primary.domain)
+        assertEquals("unlock", card.primary!!.service)
+        assertEquals("lock", card.primary!!.domain)
     }
 
     @Test fun lockUnlockedExposesLock() {
         val card = EntityMapper.toCard(state("lock.front_door", "unlocked"))!!
-        assertEquals("lock", card.primary.service)
+        assertEquals("lock", card.primary!!.service)
+    }
+
+    @Test fun coverClosedExposesOpen() {
+        val card = EntityMapper.toCard(state("cover.garage", "closed"))!!
+        assertEquals("open_cover", card.primary!!.service)
+        assertEquals("cover", card.primary!!.domain)
+    }
+
+    @Test fun coverOpenExposesClose() {
+        val card = EntityMapper.toCard(state("cover.garage", "open"))!!
+        assertEquals("close_cover", card.primary!!.service)
+    }
+
+    @Test fun coverTransitionalExposesStop() {
+        assertEquals("stop_cover", EntityMapper.toCard(state("cover.g", "opening"))!!.primary!!.service)
+        assertEquals("stop_cover", EntityMapper.toCard(state("cover.g", "closing"))!!.primary!!.service)
+    }
+
+    @Test fun coverHasThreeSecondaries() {
+        val card = EntityMapper.toCard(state("cover.garage", "open"))!!
+        assertEquals(
+            setOf("open_cover", "close_cover", "stop_cover"),
+            card.secondary.map { it.service }.toSet(),
+        )
+    }
+
+    @Test fun sceneExposesTurnOn() {
+        val card = EntityMapper.toCard(state("scene.movie", "2026-06-15T10:00:00"))!!
+        assertEquals("turn_on", card.primary!!.service)
+        assertEquals("scene", card.primary!!.domain)
+        assertTrue(card.secondary.isEmpty())
+        // The raw timestamp state is masked with a stable token.
+        assertEquals("scene", card.state)
+    }
+
+    @Test fun sensorHasNoPrimary() {
+        val card = EntityMapper.toCard(state("sensor.temperature", "21.5"))!!
+        assertNull(card.primary)
+        assertTrue(card.secondary.isEmpty())
+    }
+
+    @Test fun sensorFoldsUnitIntoState() {
+        val card = EntityMapper.toCard(stateWithUnit("sensor.temperature", "21.5", "°C"))!!
+        assertEquals("21.5 °C", card.state)
+    }
+
+    @Test fun sensorWithoutUnitKeepsRawState() {
+        val card = EntityMapper.toCard(state("sensor.humidity", "60"))!!
+        assertEquals("60", card.state)
     }
 
     @Test fun unsupportedDomainIsFilteredOut() {
-        assertNull(EntityMapper.toCard(state("sensor.temperature", "21.5")))
         assertNull(EntityMapper.toCard(state("climate.living", "heat")))
+        assertNull(EntityMapper.toCard(state("media_player.tv", "playing")))
     }
 
     @Test fun cardsKeepsOnlySupportedDomains() {
@@ -58,7 +113,8 @@ class EntityMapperTest {
                 state("automation.d", "on"),
             ),
         )
-        assertEquals(2, cards.size)
+        // light, sensor, lock are supported; automation is not.
+        assertEquals(3, cards.size)
         assertTrue(cards.all { it.domain in EntityMapper.SUPPORTED_DOMAINS })
     }
 }
diff --git a/docs/ha-integration-notes.md b/docs/ha-integration-notes.md
index 6fbe94d..adb2104 100644
--- a/docs/ha-integration-notes.md
+++ b/docs/ha-integration-notes.md
@@ -48,13 +48,16 @@ home-assistant.io. Don't invent fields — what's here is verified; gaps are fla
 - Numeric params may be sent as strings (HA's own WS example uses `"brightness": "101"`) — so our
   `EntityAction.data: Record<string,string>` is compatible as-is.
 
-## MVP domains
+## Supported domains
 
 | Domain | States | Services |
 |--------|--------|----------|
 | `light` | `on` / `off` / `unavailable` / `unknown` | `turn_on` (brightness 1..255, brightness_pct 0..100, rgb_color, color_temp_kelvin, transition), `turn_off`, `toggle` |
 | `switch` | `on` / `off` / `unavailable` / `unknown` | `turn_on`, `turn_off`, `toggle` (only param: entity_id) |
 | `lock` | `locked` / `unlocked` / `locking` / `unlocking` / `jammed` / `open` / `unavailable` / `unknown` | `lock`, `unlock`, `open` (unlatch; only if supported; optional `code`) |
+| `cover` | `open` / `closed` / `opening` / `closing` / `unavailable` | `open_cover`, `close_cover`, `stop_cover` (Phase 4: no position slider; `current_position` not used) |
+| `scene` | a last-activated timestamp (treated as stateless) | `turn_on` (activate) |
+| `sensor` | a numeric/text value (read-only) | none — no service call |
 
 `light.turn_on`: **don't** send `brightness` and `brightness_pct` together. HA silently ignores
 params the device doesn't support.
@@ -75,6 +78,9 @@ Build `primary` per domain (all `kind:'SERVICE'`, `data` ≥ `{ entity_id }`):
 - **light:** `toggle`; optional secondary `turn_on` with `brightness_pct`.
 - **switch:** `toggle`.
 - **lock:** state-dependent — `locked` → `unlock`, `unlocked` → `lock`; secondary `open` if supported.
+- **cover:** state-dependent — `open` → `close_cover`, `closed` → `open_cover`, `opening`/`closing` → `stop_cover`; secondary = all three (`open_cover`/`close_cover`/`stop_cover`).
+- **scene:** `turn_on` ("Activate"); no secondary. `state` is masked to the token `"scene"` (HA's raw state is a timestamp).
+- **sensor:** **no `primary`** (read-only) — omit it; fold `attributes.unit_of_measurement` into `state` (`"21.5 °C"`); no secondary.
 
 `CALL_SERVICE` → REST is a direct pass-through (no transform):
 ```
diff --git a/docs/p2p-protocol.md b/docs/p2p-protocol.md
index 489875d..f09ea37 100644
--- a/docs/p2p-protocol.md
+++ b/docs/p2p-protocol.md
@@ -107,15 +107,20 @@ than crashing.
 ```ts
 interface EntityCard {
   entity_id: string;          // e.g. "light.kitchen"
-  domain: string;             // "light" | "switch" | "lock" (MVP)
+  domain: string;             // "light"|"switch"|"lock"|"cover"|"scene"|"sensor"
   name: string;               // display name (companion may localize)
-  state: string;              // "on"/"off", "locked"/"unlocked", …
+  state: string;              // "on"/"off", "locked"/"unlocked", "21.5 °C", …
   icon?: string;              // optional icon hint
-  primary: EntityAction;      // main tap action
+  primary?: EntityAction;     // main tap action; OMITTED for read-only cards (sensor)
   secondary: EntityAction[];  // extra actions in the details screen
 }
 ```
 
+`primary` is optional and additive (no `v` bump): senders that always include it stay valid, and
+readers must tolerate its absence — a card without `primary` renders no main action tile (e.g. a
+read-only `sensor`). For `sensor`, the companion folds the unit into `state` (`"21.5 °C"`); for
+`scene`, `state` is a stable token (`"scene"`), not HA's last-activated timestamp.
+
 ### `EntityAction`
 A self-describing HA service call. The watch renders `label` and, on tap, sends `domain` +
 `service` + `data` back as a `CALL_SERVICE`. The watch does **not** interpret HA semantics —

From 29cfda4794ca95c0d2bec93a86cd7c9f9b0873ad Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 11:57:15 +0700
Subject: [PATCH 02/11] feat(watch): add cover/scene/sensor domains; render
 primary label as plain text
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

watch-lite + watch-arkts mirror the companion's new domains:
- cover:  state-dependent open/close/stop
- scene:  single Activate
- sensor: read-only — no primary (EntityCard.primary now optional)

Also fixes a latent arkts bug: EntityDetails rendered the primary label via
$r() (a resource id), which never resolved the companion's plain-text labels
("Open", "Activate", …). Now rendered as plain Text, which also fixes the
existing light/switch/lock primary tile on real devices. Mock labels switched
to plain text to match.

Adds cover/scene watch-lite icons (128px, monochrome) and mock entries on
both watches. All three apps build: companion tests green, watch-lite and
watch-arkts assembleHap successful.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../MockHomeAssistantRepository.ets           | 127 +++++++++++++-----
 .../src/main/ets/domain/model/EntityCard.ets  |   3 +-
 .../src/main/ets/pages/EntityDetails.ets      |  22 ++-
 .../entry/src/main/ets/pages/Index.ets        |  18 +++
 .../MainAbility/common/constants/domains.js   |   5 +-
 .../js/MainAbility/common/icons/cover.png     | Bin 0 -> 464 bytes
 .../js/MainAbility/common/icons/scene.png     | Bin 0 -> 663 bytes
 .../main/js/MainAbility/pages/entity/index.js |  40 ++++++
 .../main/js/MainAbility/pages/index/index.js  |   5 +-
 9 files changed, 176 insertions(+), 44 deletions(-)
 create mode 100644 apps/watch-lite/entry/src/main/js/MainAbility/common/icons/cover.png
 create mode 100644 apps/watch-lite/entry/src/main/js/MainAbility/common/icons/scene.png

diff --git a/apps/watch-arkts/entry/src/main/ets/data/repository/MockHomeAssistantRepository.ets b/apps/watch-arkts/entry/src/main/ets/data/repository/MockHomeAssistantRepository.ets
index eaba180..88e709e 100644
--- a/apps/watch-arkts/entry/src/main/ets/data/repository/MockHomeAssistantRepository.ets
+++ b/apps/watch-arkts/entry/src/main/ets/data/repository/MockHomeAssistantRepository.ets
@@ -30,6 +30,9 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
       } else if (card.domain === 'light' || card.domain === 'switch') {
         const next: string = (card.state === 'on') ? 'off' : 'on';
         this.entities[idx] = this.withState(card, next);
+      } else if (card.domain === 'cover') {
+        const nextCover: string = (card.state === 'open') ? 'closed' : 'open';
+        this.entities[idx] = this.withState(card, nextCover);
       }
     }
 
@@ -56,6 +59,17 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
       this.entities[idx] = this.withState(card, nextLock);
       return;
     }
+
+    if (card.domain === 'cover') {
+      let next: string = card.state;
+      if (action.service === 'open_cover') next = 'open';
+      else if (action.service === 'close_cover') next = 'closed';
+      // stop_cover: leave state as-is
+      this.entities[idx] = this.withState(card, next);
+      return;
+    }
+
+    // scene (turn_on) has no persistent state to flip; sensor is read-only — nothing to do.
   }
 
   // ===== generators =====
@@ -66,6 +80,7 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
     const lightsCount: number = this.randomIntInclusive(1, 2);
     const locksCount: number = this.randomIntInclusive(1, 2);
     const switchesCount: number = this.randomIntInclusive(1, 2);
+    const coversCount: number = this.randomIntInclusive(1, 2);
 
     let i: number = 1;
 
@@ -81,6 +96,14 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
       out.push(this.makeSwitch(i));
       i++;
     }
+    for (let n: number = 0; n < coversCount; n++) {
+      out.push(this.makeCover(i));
+      i++;
+    }
+    out.push(this.makeScene(i));
+    i++;
+    out.push(this.makeSensor(i));
+    i++;
 
     return out;
   }
@@ -89,16 +112,11 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
     const id: string = this.uuid();
     const state: string = this.randomBool() ? 'on' : 'off';
 
-    const primary: EntityAction = this.makeServiceAction(
-      'light',
-      'toggle',
-      state === 'on' ? 'app.string.Entity_light_disable_label' : 'app.string.Entity_light_enable_label',
-      id
-    );
+    const primary: EntityAction = this.makeServiceAction('light', 'toggle', 'Toggle', id);
 
     const secondary: EntityAction[] = [];
-    secondary.push(this.makeServiceAction('light', 'turn_on', 'Turn on', id));
-    secondary.push(this.makeServiceAction('light', 'turn_off', 'Turn off', id));
+    secondary.push(this.makeServiceAction('light', 'turn_on', 'On', id));
+    secondary.push(this.makeServiceAction('light', 'turn_off', 'Off', id));
 
     const card: EntityCard = {
       entity_id: id,
@@ -116,12 +134,9 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
     const id: string = this.uuid();
     const state: string = this.randomBool() ? 'locked' : 'unlocked';
 
-    const primary: EntityAction = this.makeServiceAction(
-      'lock',
-      'toggle',
-      state === 'locked' ? 'app.string.Entity_lock_disable_label' : 'app.string.Entity_lock_enable_label',
-      id
-    );
+    const primary: EntityAction = state === 'locked'
+      ? this.makeServiceAction('lock', 'unlock', 'Unlock', id)
+      : this.makeServiceAction('lock', 'lock', 'Lock', id);
 
     const secondary: EntityAction[] = [];
     secondary.push(this.makeServiceAction('lock', 'lock', 'Lock', id));
@@ -143,16 +158,11 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
     const id: string = this.uuid();
     const state: string = this.randomBool() ? 'on' : 'off';
 
-    const primary: EntityAction = this.makeServiceAction(
-      'switch',
-      'toggle',
-      state === 'on' ? 'app.string.Entity_switch_disable_label' : 'app.string.Entity_switch_enable_label',
-      id
-    );
+    const primary: EntityAction = this.makeServiceAction('switch', 'toggle', 'Toggle', id);
 
     const secondary: EntityAction[] = [];
-    secondary.push(this.makeServiceAction('switch', 'turn_on', 'Turn on', id));
-    secondary.push(this.makeServiceAction('switch', 'turn_off', 'Turn off', id));
+    secondary.push(this.makeServiceAction('switch', 'turn_on', 'On', id));
+    secondary.push(this.makeServiceAction('switch', 'turn_off', 'Off', id));
 
     const card: EntityCard = {
       entity_id: id,
@@ -166,6 +176,59 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
     return card;
   }
 
+  private makeCover(i: number): EntityCard {
+    const id: string = this.uuid();
+    const state: string = this.randomBool() ? 'open' : 'closed';
+
+    const card: EntityCard = {
+      entity_id: id,
+      name: `Cover ${i}`,
+      domain: 'cover',
+      state: state,
+      primary: this.coverPrimary(id, state),
+      secondary: [
+        this.makeServiceAction('cover', 'open_cover', 'Open', id),
+        this.makeServiceAction('cover', 'close_cover', 'Close', id),
+        this.makeServiceAction('cover', 'stop_cover', 'Stop', id),
+      ]
+    };
+
+    return card;
+  }
+
+  private makeScene(i: number): EntityCard {
+    const id: string = this.uuid();
+    const card: EntityCard = {
+      entity_id: id,
+      name: `Scene ${i}`,
+      domain: 'scene',
+      state: 'scene',
+      primary: this.makeServiceAction('scene', 'turn_on', 'Activate', id),
+      secondary: []
+    };
+    return card;
+  }
+
+  private makeSensor(i: number): EntityCard {
+    const id: string = this.uuid();
+    const value: number = this.randomIntInclusive(18, 26);
+    // Read-only: no primary action; unit folded into state (like the companion does).
+    const card: EntityCard = {
+      entity_id: id,
+      name: `Sensor ${i}`,
+      domain: 'sensor',
+      state: `${value} °C`,
+      secondary: []
+    };
+    return card;
+  }
+
+  private coverPrimary(id: string, state: string): EntityAction {
+    if (state === 'open') return this.makeServiceAction('cover', 'close_cover', 'Close', id);
+    if (state === 'closed') return this.makeServiceAction('cover', 'open_cover', 'Open', id);
+    return this.makeServiceAction('cover', 'stop_cover', 'Stop', id);
+  }
+
   private withState(card: EntityCard, newState: string): EntityCard {
     const updated: EntityCard = {
       entity_id: card.entity_id,
@@ -180,19 +243,15 @@ export class MockHomeAssistantRepository implements HomeAssistantRepository {
 
   private rebuildPrimary(domain: string, entityId: string, state: string): EntityAction {
     if (domain === 'lock') {
-      return this.makeServiceAction(
-        'lock',
-        'toggle',
-        state === 'locked' ? 'Unlock' : 'Lock',
-        entityId
-      );
+      return state === 'locked'
+        ? this.makeServiceAction('lock', 'unlock', 'Unlock', entityId)
+        : this.makeServiceAction('lock', 'lock', 'Lock', entityId);
+    }
+    if (domain === 'cover') {
+      return this.coverPrimary(entityId, state);
     }
-    return this.makeServiceAction(
-      domain,
-      'toggle',
-      state === 'on' ? 'Turn off' : 'Turn on',
-      entityId
-    );
+    // light / switch
+    return this.makeServiceAction(domain, 'toggle', 'Toggle', entityId);
   }
 
   private makeServiceAction(domain: string, service: string, label: string, entityId: string): EntityAction {
diff --git a/apps/watch-arkts/entry/src/main/ets/domain/model/EntityCard.ets b/apps/watch-arkts/entry/src/main/ets/domain/model/EntityCard.ets
index debeb69..dfe9980 100644
--- a/apps/watch-arkts/entry/src/main/ets/domain/model/EntityCard.ets
+++ b/apps/watch-arkts/entry/src/main/ets/domain/model/EntityCard.ets
@@ -15,6 +15,7 @@ export interface EntityCard {
   name: string;
   state: string;
   icon?: string;
-  primary: EntityAction;
+  // Omitted for read-only cards (e.g. sensor) — the details screen renders no primary tile.
+  primary?: EntityAction;
   secondary: EntityAction[];
 }
diff --git a/apps/watch-arkts/entry/src/main/ets/pages/EntityDetails.ets b/apps/watch-arkts/entry/src/main/ets/pages/EntityDetails.ets
index 910668d..a2c5dd3 100644
--- a/apps/watch-arkts/entry/src/main/ets/pages/EntityDetails.ets
+++ b/apps/watch-arkts/entry/src/main/ets/pages/EntityDetails.ets
@@ -59,9 +59,16 @@ struct EntityDetails {
     return entity ? entity.state : '-';
   }
 
-  private primaryLabel(): string | Resource {
+  private hasPrimary(): boolean {
     const entity: EntityCard | undefined = this.getCard();
-    return entity ? $r(entity.primary.label) : '-';
+    return !!entity && !!entity.primary;
+  }
+
+  // Render the label as plain text — the companion sends localized strings (e.g. "Open",
+  // "Activate"), not resource ids, so $r() would not resolve them.
+  private primaryLabel(): string {
+    const entity: EntityCard | undefined = this.getCard();
+    return entity && entity.primary ? entity.primary.label : '-';
   }
 
   private secondaryActions(): EntityAction[] {
@@ -71,8 +78,9 @@ struct EntityDetails {
 
   private runPrimary(): void {
     const entity: EntityCard | undefined = this.getCard();
-    if (!entity) return;
-    this.store.runAction(entity.primary);
+    const action: EntityAction | undefined = entity ? entity.primary : undefined;
+    if (!action) return;
+    this.store.runAction(action);
   }
 
   private runSecondary(a: EntityAction): void {
@@ -108,10 +116,10 @@ struct EntityDetails {
             .alignItems(VerticalAlign.Center);
           };
 
-          // Primary
+          // Primary — omitted for read-only cards (e.g. sensor)
           ArcListItem() {
-            if (!this.getCard()) {
-              // empty
+            if (!this.hasPrimary()) {
+              // read-only: no primary tile
             } else {
               Row() {
                 SystemTile({
diff --git a/apps/watch-arkts/entry/src/main/ets/pages/Index.ets b/apps/watch-arkts/entry/src/main/ets/pages/Index.ets
index 8f50c31..3c5418b 100644
--- a/apps/watch-arkts/entry/src/main/ets/pages/Index.ets
+++ b/apps/watch-arkts/entry/src/main/ets/pages/Index.ets
@@ -63,6 +63,15 @@ struct Index {
       if (domain === 'switch') {
         return '🎚️';
       }
+      if (domain === 'cover') {
+        return '🪟';
+      }
+      if (domain === 'scene') {
+        return '🎬';
+      }
+      if (domain === 'sensor') {
+        return '📊';
+      }
       return domain.substring(0, 1).toUpperCase();
     } else return '?';
   }
@@ -92,6 +101,15 @@ struct Index {
     if (domain === 'switch') {
       return 0xFF27AE60; // зелёный
     }
+    if (domain === 'cover') {
+      return 0xFF2D9CDB; // синий
+    }
+    if (domain === 'scene') {
+      return 0xFFBB6BD9; // сиреневый
+    }
+    if (domain === 'sensor') {
+      return 0xFF56CCF2; // голубой
+    }
     return 0xFF4A4A4A; // дефолт/unknown
   }
 
diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/common/constants/domains.js b/apps/watch-lite/entry/src/main/js/MainAbility/common/constants/domains.js
index f905f61..bd2abb6 100644
--- a/apps/watch-lite/entry/src/main/js/MainAbility/common/constants/domains.js
+++ b/apps/watch-lite/entry/src/main/js/MainAbility/common/constants/domains.js
@@ -6,7 +6,10 @@
 var MAP = {
     light:  { icon: '/common/icons/light.png',  color: '#F2C94C' },
     switch: { icon: '/common/icons/switch.png', color: '#27AE60' },
-    lock:   { icon: '/common/icons/lock.png',   color: '#8E44AD' }
+    lock:   { icon: '/common/icons/lock.png',   color: '#8E44AD' },
+    cover:  { icon: '/common/icons/cover.png',  color: '#2D9CDB' },
+    scene:  { icon: '/common/icons/scene.png',  color: '#BB6BD9' },
+    sensor: { icon: '/common/icons/sensor.png', color: '#56CCF2' }
 };
 
 export function uiFor(domain) {
diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/cover.png b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/cover.png
new file mode 100644
index 0000000000000000000000000000000000000000..d1c490d429d35dc94ffd05453d787f3a04411998
GIT binary patch
literal 464
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrV4Uvh;uumf=k2YFflmw=SRJdo
z{{+Xq5^9j&aL@3rphBj=rVFKvK;=;IfBSE#Pj&n6haaiEFI;T@(Rqqkoo>tZ(um5B
z;>Z4L@z)(aS!p5GaP<C+er3jpKXWU8?l?BbPULDGW1M%hzRth$$2C@ckK-A)9*viN
z@53-hvB84z2&aM{Lm^X#u)`dNM=S#7-}g5xt^TyXj{8TyEKKIk9mRr|4Iv5aFjeX(
z8t>c*-SC~^{3d3YS+lKKs`x+XSVN3NRSdM{*}A5^>=o0HjlWRckbaX9Xg`Kxpp(i)
z-`F15{08pIXMBzKm~Bq;At^Ry6j|3Ge*AaTuQSmzr`-Q`)nfiXo_V|3SGY|0C;VVj
zdU{;nTt=4-hVt(GjY<~w{Kxk*y%N0Be%#*l=Thbevi$O}AZBQI{k(=LUL)qjtsM=Z
Pm}2mB^>bP0l+XkKuh*^=

literal 0
HcmV?d00001

diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/scene.png b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/scene.png
new file mode 100644
index 0000000000000000000000000000000000000000..5729c1360f5d28a0b27c9a372df18e939834b1d3
GIT binary patch
literal 663
zcmV;I0%-k-P)<h;3K|Lk000e1NJLTq004jh004jp1^@s6!#-il0007BNkl<Zc%1Fr
z4Q|^o5Cvhe_rEiP0xhbfaV*=Cx%+0m1K31%mWY*~ZIdKPk|arzBuSDaNs^=(bI!Se
z{aSqht%VL?{@H%=Er1R{-~h;5zlROrs|gLl0N{`T+}idDyakW}2pj-$%YT9k;GPK!
z!~oz>0noPl2vh(^O;9M907yf91SSA|&j8>z1|k5;FrR@4;8_z8jsd{M2SC{3SHuVK
zsu><obO7nYJ418;y3YXMH%V*&$wNC+YybiWaK-k|&>JN(03Bxl@LM1*fW#qPDJ}qk
z19->w&#)UNDgZrhY|X9S$T3FiuVLH6uO56#2(1oXZRiOxv^Z#&!FLRy>;bzDy;}_B
z4wW|e>M@i!2w~_|Ls)tM>fkHI@b))#=(S>a+Z#Ffnju{J1`fS`441s9gYOf<X)or`
zd&b}m&`jAI;1+L&+TRTNDFFUaaLL05Z-qJ!gqA;wG=^>IBjM!%P-7Sceh%<ki9=9A
z7)6G@SMES*F^qyk-z$B%t}%?_L*Hw2&<-(-MuY#W-GQrxFd7bhul3<q#W0!=eb2uP
zf{O~^Ex$l9a<)G%06i`)fV2(0T3i5E8i8>c09<4MiJN+r$N;V|LZdPOxYz*B+}IJi
z{m}vFnCJkKH}@>j0i0okM`QqS@d2c7@T=kjc*Ow3g9v~y$Y&t}&}{|)zcnxcPzL%a
zOaS_x0l;qyQ~;#G9)$`(|HB1v?-m%aTLKq=J~IID_G1Ge4*C{k0Q$!O;I{%c0P4WM
x!UiCf_zxqic>_q2BuSDaNs=T<k|aq<J^<b$(2m@ew(kG{002ovPDHLkV1j>-6a4@H

literal 0
HcmV?d00001

diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/pages/entity/index.js b/apps/watch-lite/entry/src/main/js/MainAbility/pages/entity/index.js
index 263afe8..05ccb3b 100644
--- a/apps/watch-lite/entry/src/main/js/MainAbility/pages/entity/index.js
+++ b/apps/watch-lite/entry/src/main/js/MainAbility/pages/entity/index.js
@@ -74,6 +74,8 @@ export default {
     _rebuildActions() {
         const ICON_POWER = '/common/icons/power.png';
         const ICON_LOCK = '/common/icons/lock.png';
+        const ICON_COVER = '/common/icons/cover.png';
+        const ICON_SCENE = '/common/icons/scene.png';
         const st = String(this.state || '');
 
         if (this.domain === 'light' || this.domain === 'switch') {
@@ -108,6 +110,39 @@ export default {
             return;
         }
 
+        if (this.domain === 'cover') {
+            if (st === 'open') {
+                this.actions = [{ id: 'close_cover', name: 'Close', state: 'Change state', iconSrc: ICON_COVER, color: actionColorBlue() }];
+                return;
+            }
+            if (st === 'closed') {
+                this.actions = [{ id: 'open_cover', name: 'Open', state: 'Change state', iconSrc: ICON_COVER, color: actionColorGreen() }];
+                return;
+            }
+            if (st === 'opening' || st === 'closing') {
+                this.actions = [{ id: 'stop_cover', name: 'Stop', state: 'Change state', iconSrc: ICON_COVER, color: actionColorRed() }];
+                return;
+            }
+            this.actions = [
+                { id: 'open_cover', name: 'Open', state: 'Change state', iconSrc: ICON_COVER, color: actionColorGreen() },
+                { id: 'close_cover', name: 'Close', state: 'Change state', iconSrc: ICON_COVER, color: actionColorBlue() },
+                { id: 'stop_cover', name: 'Stop', state: 'Change state', iconSrc: ICON_COVER, color: actionColorRed() }
+            ];
+            return;
+        }
+
+        if (this.domain === 'scene') {
+            this.actions = [{ id: 'turn_on', name: 'Activate', state: 'Activate scene', iconSrc: ICON_SCENE, color: actionColorGreen() }];
+            return;
+        }
+
+        if (this.domain === 'sensor') {
+            // Read-only: no actions, just the state header.
+            this.actions = [];
+            this.statusText = 'Read-only';
+            return;
+        }
+
         this.actions = [{ id: 'toggle', name: 'Toggle', state: 'Call service', iconSrc: ICON_POWER, color: actionColorGray() }];
     },
 
@@ -129,7 +164,12 @@ export default {
         } else if (this.domain === 'lock') {
             if (service === 'lock') nextState = 'locked';
             if (service === 'unlock') nextState = 'unlocked';
+        } else if (this.domain === 'cover') {
+            if (service === 'open_cover') nextState = 'open';
+            if (service === 'close_cover') nextState = 'closed';
+            // stop_cover: leave state as-is
         }
+        // scene: turn_on has no persistent state to flip (keep the "scene" token)
         this._setState(nextState);
 
         // 2) call HA via the companion; confirm or roll back
diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/pages/index/index.js b/apps/watch-lite/entry/src/main/js/MainAbility/pages/index/index.js
index 451183c..84109f8 100644
--- a/apps/watch-lite/entry/src/main/js/MainAbility/pages/index/index.js
+++ b/apps/watch-lite/entry/src/main/js/MainAbility/pages/index/index.js
@@ -17,7 +17,10 @@ function mockItems() {
     return [
         { id: 'light.kitchen', name: 'Kitchen', state: 'off', domain: 'light', iconSrc: '/common/icons/light.png', color: '#F2C94C', primary: null, secondary: [] },
         { id: 'switch.router', name: 'Router', state: 'on', domain: 'switch', iconSrc: '/common/icons/switch.png', color: '#27AE60', primary: null, secondary: [] },
-        { id: 'lock.front_door', name: 'Front door', state: 'locked', domain: 'lock', iconSrc: '/common/icons/lock.png', color: '#8E44AD', primary: null, secondary: [] }
+        { id: 'lock.front_door', name: 'Front door', state: 'locked', domain: 'lock', iconSrc: '/common/icons/lock.png', color: '#8E44AD', primary: null, secondary: [] },
+        { id: 'cover.garage', name: 'Garage', state: 'closed', domain: 'cover', iconSrc: '/common/icons/cover.png', color: '#2D9CDB', primary: null, secondary: [] },
+        { id: 'scene.movie', name: 'Movie', state: 'scene', domain: 'scene', iconSrc: '/common/icons/scene.png', color: '#BB6BD9', primary: null, secondary: [] },
+        { id: 'sensor.temperature', name: 'Temperature', state: '21 °C', domain: 'sensor', iconSrc: '/common/icons/sensor.png', color: '#56CCF2', primary: null, secondary: [] }
     ];
 }
 

From df87a2c917a76b7af0dc425fd9dcda0e9fc2a711 Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 12:39:02 +0700
Subject: [PATCH 03/11] fix(companion): harden HA client + P2P parsing (review
 K2,B3-B6)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- K2: @Volatile on WearEngineP2pService.device — it's written from HMS
  callbacks and read from send coroutines; without a barrier sendRaw could
  read a stale null and silently drop a reply.
- B3: getStates parses element-by-element — one malformed HA state object no
  longer fails the entire sync (partial data > all-or-nothing).
- B4: unavailable/unknown entities get no primary/secondary action, per
  ha-integration-notes (uses the previously-unused HaState.isAvailable).
- B5: OkHttp callTimeout(7s) so a large /api/states stays within the watch's
  8s P2P budget.
- B6: parseIncoming validates protocol v — a mismatched version returns an
  explicit error ACK (UnsupportedVersion) instead of being mis-parsed as v1.

Adds tests for unavailable-no-actions and version rejection. All green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../companion/bridge/EntityMapper.kt          | 11 +++++--
 .../companion/bridge/HaBridge.kt              |  5 ++++
 .../homeassistant/companion/ha/HaClient.kt    | 29 +++++++++++++++----
 .../homeassistant/companion/p2p/Messages.kt   |  8 +++++
 .../companion/p2p/WearEngineP2pService.kt     |  3 ++
 .../companion/EntityMapperTest.kt             | 11 +++++++
 .../homeassistant/companion/MessagesTest.kt   | 14 +++++++++
 7 files changed, 74 insertions(+), 7 deletions(-)

diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt
index 2c19189..c369abc 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt
@@ -40,7 +40,10 @@ object EntityMapper {
         else -> s.state
     }
 
-    private fun primaryAction(s: HaState): EntityAction? = when (s.domain) {
+    private fun primaryAction(s: HaState): EntityAction? {
+        // unavailable/unknown entities get no actionable primary (see ha-integration-notes.md).
+        if (!s.isAvailable) return null
+        return when (s.domain) {
         "lock" -> if (s.state == "locked") {
             action("Unlock", "lock", "unlock", s.entityId)
         } else {
@@ -57,9 +60,12 @@ object EntityMapper {
         "sensor" -> null
         // light / switch
         else -> action("Toggle", s.domain, "toggle", s.entityId)
+        }
     }
 
-    private fun secondaryActions(s: HaState): List<EntityAction> = when (s.domain) {
+    private fun secondaryActions(s: HaState): List<EntityAction> {
+        if (!s.isAvailable) return emptyList()
+        return when (s.domain) {
         "light" -> listOf(
             action("On", "light", "turn_on", s.entityId),
             action("Off", "light", "turn_off", s.entityId),
@@ -74,6 +80,7 @@ object EntityMapper {
             action("Stop", "cover", "stop_cover", s.entityId),
         )
         else -> emptyList()
+        }
     }
 
     private fun action(label: String, domain: String, service: String, entityId: String) =
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/HaBridge.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/HaBridge.kt
index e21932f..d5c36cc 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/HaBridge.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/HaBridge.kt
@@ -9,6 +9,7 @@ import ru.gentslava.homeassistant.companion.p2p.SyncEntityRequest
 import ru.gentslava.homeassistant.companion.p2p.SyncEntityResponse
 import ru.gentslava.homeassistant.companion.p2p.SyncRequest
 import ru.gentslava.homeassistant.companion.p2p.SyncResponse
+import ru.gentslava.homeassistant.companion.p2p.UnsupportedVersion
 import ru.gentslava.homeassistant.companion.p2p.parseIncoming
 
 /**
@@ -37,6 +38,10 @@ class HaBridge(private val client: HaClient) {
             onFailure = { ackError(msg.id, it) },
         )
 
+        is UnsupportedVersion -> encode(
+            Ack(id = msg.id, ok = false, error = "unsupported protocol v${msg.v}"),
+        )
+
         null -> null
     }
 
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaClient.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaClient.kt
index 5a7488d..1262c31 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaClient.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaClient.kt
@@ -4,6 +4,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromJsonElement
+import kotlinx.serialization.json.jsonArray
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import okhttp3.Request
@@ -17,8 +19,10 @@ import java.util.concurrent.TimeUnit
 class HaClient(private val config: HaConfig) {
 
     private val http = OkHttpClient.Builder()
-        .connectTimeout(5, TimeUnit.SECONDS)
-        .readTimeout(5, TimeUnit.SECONDS)
+        .connectTimeout(CONNECT_TIMEOUT_S, TimeUnit.SECONDS)
+        .readTimeout(READ_TIMEOUT_S, TimeUnit.SECONDS)
+        // Whole-call budget so a large /api/states stays within the watch's 8s P2P timeout.
+        .callTimeout(CALL_TIMEOUT_S, TimeUnit.SECONDS)
         .build()
 
     private val json = Json { ignoreUnknownKeys = true }
@@ -27,9 +31,17 @@ class HaClient(private val config: HaConfig) {
     /** GET /api/ -> {"message":"API running."}. Validates host + token. */
     suspend fun checkApi(): Result<Unit> = call("GET", "/api/").map { }
 
-    /** GET /api/states -> all entities. */
+    /**
+     * GET /api/states -> all entities. Parsed element-by-element: a single malformed state
+     * object (some custom integration) is skipped rather than failing the whole sync — the
+     * protocol prefers fast partial data over an all-or-nothing reply.
+     */
     suspend fun getStates(): Result<List<HaState>> =
-        call("GET", "/api/states").mapCatching { json.decodeFromString<List<HaState>>(it) }
+        call("GET", "/api/states").mapCatching { raw ->
+            json.parseToJsonElement(raw).jsonArray.mapNotNull { el ->
+                runCatching { json.decodeFromJsonElement<HaState>(el) }.getOrNull()
+            }
+        }
 
     /** GET /api/states/<entity_id> -> one entity, or null on 404. */
     suspend fun getState(entityId: String): Result<HaState?> =
@@ -65,11 +77,18 @@ class HaClient(private val config: HaConfig) {
                         resp.isSuccessful -> text
                         resp.code == 401 -> throw HaError("HA returned 401 (check token)")
                         resp.code == 404 -> throw NotFound()
-                        else -> throw HaError("HA returned ${resp.code}: ${text.take(140)}")
+                        else -> throw HaError("HA returned ${resp.code}: ${text.take(ERR_BODY_MAX)}")
                     }
                 }
             }
         }
+
+    private companion object {
+        const val CONNECT_TIMEOUT_S = 5L
+        const val READ_TIMEOUT_S = 5L
+        const val CALL_TIMEOUT_S = 7L // stay inside the watch's 8s P2P budget
+        const val ERR_BODY_MAX = 140
+    }
 }
 
 class HaError(message: String) : Exception(message)
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt
index 51d8b23..2a12fa3 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt
@@ -6,6 +6,7 @@ import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
 import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.intOrNull
 
 /**
  * Wire types for the watch <-> phone P2P protocol. Mirror of docs/p2p-protocol.md (v1).
@@ -87,10 +88,17 @@ data class CallServiceRequest(
     val data: Map<String, String>,
 ) : IncomingMsg
 
+/** A request whose protocol `v` this companion doesn't speak — answered with an error ACK. */
+data class UnsupportedVersion(override val id: String, val v: Int) : IncomingMsg
+
 /** Parse one inbound JSON message. Returns null if it's not a recognized request. */
 fun parseIncoming(json: String): IncomingMsg? = runCatching {
     val obj = P2pJson.parseToJsonElement(json).jsonObject
     val id = obj["id"]?.jsonPrimitive?.contentOrNull ?: return null
+    // Guard the contract version: a message tagged with a different `v` is answered explicitly
+    // (UnsupportedVersion -> error ACK) instead of being silently mis-parsed as v1.
+    val v = obj["v"]?.jsonPrimitive?.intOrNull
+    if (v != null && v != PROTOCOL_VERSION) return UnsupportedVersion(id, v)
     when (obj["type"]?.jsonPrimitive?.contentOrNull) {
         "SYNC_REQUEST" -> SyncRequest(id)
         "SYNC_ENTITY_REQUEST" -> {
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
index 749d9f3..c20fb33 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
@@ -39,6 +39,9 @@ class WearEngineP2pService(
         setPeerFingerPrint(PEER_FINGERPRINT)
     }
 
+    // Written from HMS callbacks, read from send coroutines on Dispatchers.Default — needs a
+    // memory barrier so sendRaw never reads a stale null after the device is found.
+    @Volatile
     private var device: Device? = null
 
     private val receiver = Receiver { message: Message ->
diff --git a/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt
index 8ce7a4b..ee0bd02 100644
--- a/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt
+++ b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt
@@ -104,6 +104,17 @@ class EntityMapperTest {
         assertNull(EntityMapper.toCard(state("media_player.tv", "playing")))
     }
 
+    @Test fun unavailableEntityHasNoActions() {
+        val card = EntityMapper.toCard(state("light.kitchen", "unavailable"))!!
+        assertNull(card.primary)
+        assertTrue(card.secondary.isEmpty())
+        assertEquals("unavailable", card.state) // state still passes through
+    }
+
+    @Test fun unknownStateHasNoPrimary() {
+        assertNull(EntityMapper.toCard(state("switch.router", "unknown"))!!.primary)
+    }
+
     @Test fun cardsKeepsOnlySupportedDomains() {
         val cards = EntityMapper.cards(
             listOf(
diff --git a/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/MessagesTest.kt b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/MessagesTest.kt
index da77fa0..d6e1e37 100644
--- a/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/MessagesTest.kt
+++ b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/MessagesTest.kt
@@ -10,6 +10,7 @@ import ru.gentslava.homeassistant.companion.p2p.CallServiceRequest
 import ru.gentslava.homeassistant.companion.p2p.P2pJson
 import ru.gentslava.homeassistant.companion.p2p.SyncEntityRequest
 import ru.gentslava.homeassistant.companion.p2p.SyncRequest
+import ru.gentslava.homeassistant.companion.p2p.UnsupportedVersion
 import ru.gentslava.homeassistant.companion.p2p.parseIncoming
 
 class MessagesTest {
@@ -44,6 +45,19 @@ class MessagesTest {
         assertNull(parseIncoming("not json"))
     }
 
+    @Test fun futureProtocolVersionIsRejected() {
+        val msg = parseIncoming("""{"v":2,"id":"sync-9","type":"SYNC_REQUEST"}""")
+        assertTrue(msg is UnsupportedVersion)
+        msg as UnsupportedVersion
+        assertEquals("sync-9", msg.id)
+        assertEquals(2, msg.v)
+    }
+
+    @Test fun missingVersionIsTolerated() {
+        // Absent v is treated as current (lenient) — still parses as the typed request.
+        assertTrue(parseIncoming("""{"id":"sync-1","type":"SYNC_REQUEST"}""") is SyncRequest)
+    }
+
     @Test fun ackSerializesWithProtocolFields() {
         val json = P2pJson.encodeToString(Ack(id = "svc-3", ok = false, error = "HA returned 401"))
         assertTrue(json.contains("\"type\":\"ACK\""))

From 071c2ea68ec59946eaa959c84a9e9f09a4e3ed4f Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 12:47:10 +0700
Subject: [PATCH 04/11] feat(companion): run Wear Engine bridge in a foreground
 service (review K3-K5)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- K3: new HaBridgeService (foreground, START_STICKY) owns the P2P transport
  instead of MainActivity, so it survives Activity recreation (rotation /
  theme) and keeps the watch reachable while backgrounded. stop() now runs on
  service destroy — no leaked scope / duplicate receivers.
- K4: the bridge starts after first-time "Connect & test" succeeds, not only
  if config was already present at onCreate — fixes the first-run case where
  the watch couldn't reach HA until an app restart.
- K5: WearEngineP2pService re-resolves the watch and re-registers the receiver
  with a 5s retry — handles the watch connecting late, dropping, or
  reconnecting on a new Device (was a one-shot registration before).

Manifest: foreground-service + connected-device + notifications permissions,
service declaration (foregroundServiceType=connectedDevice). Builds clean;
on-device verification pending (adb device dropped).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../app/src/main/AndroidManifest.xml          | 10 +++
 .../homeassistant/companion/MainActivity.kt   | 16 ++--
 .../companion/p2p/HaBridgeService.kt          | 79 +++++++++++++++++++
 .../companion/p2p/WearEngineP2pService.kt     | 65 ++++++++++++---
 4 files changed, 152 insertions(+), 18 deletions(-)
 create mode 100644 apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/HaBridgeService.kt

diff --git a/apps/phone-android/app/src/main/AndroidManifest.xml b/apps/phone-android/app/src/main/AndroidManifest.xml
index 53e9280..8cdd9ee 100644
--- a/apps/phone-android/app/src/main/AndroidManifest.xml
+++ b/apps/phone-android/app/src/main/AndroidManifest.xml
@@ -9,6 +9,11 @@
     <uses-permission android:name="com.huawei.wearengine.permission.DEVICE_MANAGER" />
     <uses-permission android:name="com.huawei.wearengine.permission.NOTIFY" />
 
+    <!-- Foreground service: keep the watch bridge alive across Activity recreation / background -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
     <!-- Android 11+ package visibility: the Wear Engine SDK binds to the Huawei Health /
          HMS Core services via an implicit intent. Without these <queries>, queryIntentServices
          returns empty ("implicitIntent List are null") and Wear Engine never reaches the
@@ -40,6 +45,11 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+
+        <service
+            android:name=".p2p.HaBridgeService"
+            android:exported="false"
+            android:foregroundServiceType="connectedDevice" />
     </application>
 
 </manifest>
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/MainActivity.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/MainActivity.kt
index 8f79316..4ccfdef 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/MainActivity.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/MainActivity.kt
@@ -36,17 +36,17 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import kotlinx.coroutines.launch
 import ru.gentslava.homeassistant.companion.bridge.EntityMapper
-import ru.gentslava.homeassistant.companion.bridge.HaBridge
 import ru.gentslava.homeassistant.companion.ha.HaClient
 import ru.gentslava.homeassistant.companion.ha.HaConfig
 import ru.gentslava.homeassistant.companion.p2p.EntityCard
-import ru.gentslava.homeassistant.companion.p2p.WearEngineP2pService
+import ru.gentslava.homeassistant.companion.p2p.HaBridgeService
 import ru.gentslava.homeassistant.companion.ui.HaColorScheme
 import ru.gentslava.homeassistant.companion.ui.HaLightColorScheme
 import ru.gentslava.homeassistant.companion.ui.entityAccent
@@ -54,14 +54,15 @@ import ru.gentslava.homeassistant.companion.ui.entityGlyph
 
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
-        enableEdgeToEdge()
         super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
         val config = HaConfig(this)
         val client = HaClient(config)
 
-        // Start the watch transport so a paired watch can reach HA through this companion.
-        val p2p = WearEngineP2pService(this, HaBridge(client))
-        if (config.isConfigured) p2p.start()
+        // The watch bridge runs in a foreground service so it survives Activity recreation and
+        // keeps working in the background. Start it once HA is already configured; first-time
+        // setup starts it from "Connect & test" (see CompanionScreen).
+        if (config.isConfigured) HaBridgeService.start(this)
 
         setContent {
             MaterialTheme(colorScheme = if (isSystemInDarkTheme()) HaColorScheme else HaLightColorScheme) {
@@ -78,6 +79,7 @@ private fun CompanionScreen(config: HaConfig, client: HaClient) {
     var status by remember { mutableStateOf(if (config.isConfigured) "Configured" else "Not configured") }
     var cards by remember { mutableStateOf<List<EntityCard>>(emptyList()) }
     val scope = rememberCoroutineScope()
+    val context = LocalContext.current
 
     Column(
         Modifier
@@ -126,6 +128,8 @@ private fun CompanionScreen(config: HaConfig, client: HaClient) {
                                 onSuccess = { states ->
                                     cards = EntityMapper.cards(states)
                                     status = "Connected — ${cards.size} entities"
+                                    // First-time setup: bring the watch bridge up now (K4).
+                                    HaBridgeService.start(context)
                                 },
                                 onFailure = { status = "States error: ${it.message}" },
                             )
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/HaBridgeService.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/HaBridgeService.kt
new file mode 100644
index 0000000..502ee03
--- /dev/null
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/HaBridgeService.kt
@@ -0,0 +1,79 @@
+package ru.gentslava.homeassistant.companion.p2p
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+import ru.gentslava.homeassistant.companion.bridge.HaBridge
+import ru.gentslava.homeassistant.companion.ha.HaClient
+import ru.gentslava.homeassistant.companion.ha.HaConfig
+
+/**
+ * Foreground service that owns the Wear Engine P2P bridge.
+ *
+ * Hosting the transport here (not in the Activity) means it survives Activity recreation
+ * (rotation, theme change) and keeps the watch reachable while the app is backgrounded — the
+ * companion's whole job is to be an always-available bridge. Start it once HA is configured;
+ * [WearEngineP2pService] then keeps a receiver registered and reconnects on its own.
+ */
+class HaBridgeService : Service() {
+    private var p2p: WearEngineP2pService? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        startForeground(NOTIF_ID, buildNotification())
+        val bridge = HaBridge(HaClient(HaConfig(this)))
+        p2p = WearEngineP2pService(this, bridge).also { it.start() }
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int = START_STICKY
+
+    override fun onDestroy() {
+        p2p?.stop()
+        p2p = null
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    private fun buildNotification(): Notification {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "Home Assistant bridge",
+                NotificationManager.IMPORTANCE_LOW,
+            ).apply { description = "Keeps your watch connected to Home Assistant" }
+            getSystemService(NotificationManager::class.java).createNotificationChannel(channel)
+        }
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle("Home Assistant")
+            .setContentText("Bridging your watch to Home Assistant")
+            .setSmallIcon(android.R.drawable.stat_sys_data_bluetooth)
+            .setOngoing(true)
+            .build()
+    }
+
+    companion object {
+        private const val CHANNEL_ID = "ha_bridge"
+        private const val NOTIF_ID = 1
+
+        /** Start (or no-op if already running) the bridge service. Safe to call repeatedly. */
+        fun start(context: Context) {
+            val intent = Intent(context, HaBridgeService::class.java)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+        }
+
+        fun stop(context: Context) {
+            context.stopService(Intent(context, HaBridgeService::class.java))
+        }
+    }
+}
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
index c20fb33..a2351f6 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
@@ -14,6 +14,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import ru.gentslava.homeassistant.companion.bridge.HaBridge
 import java.nio.charset.StandardCharsets
@@ -44,6 +45,12 @@ class WearEngineP2pService(
     @Volatile
     private var device: Device? = null
 
+    @Volatile
+    private var registered = false
+
+    @Volatile
+    private var running = false
+
     private val receiver = Receiver { message: Message ->
         if (message.type != Message.MESSAGE_TYPE_DATA) return@Receiver
         val request = String(message.data, StandardCharsets.UTF_8)
@@ -53,13 +60,15 @@ class WearEngineP2pService(
         }
     }
 
-    /** Request permission, find the connected watch, and start receiving. */
+    /** Request permission, then keep a receiver registered on the connected watch (idempotent). */
     fun start() {
+        if (running) return
+        running = true
         Log.i(TAG, "start: requesting Wear Engine permission")
         authClient.requestPermission(object : AuthCallback {
             override fun onOk(permissions: Array<out Permission>) {
                 Log.i(TAG, "permission granted: ${permissions.joinToString { it.name }}")
-                findDeviceAndRegister()
+                ensureRegistered()
             }
             override fun onCancel() { Log.e(TAG, "Wear Engine permission cancelled") }
         }, Permission.DEVICE_MANAGER)
@@ -68,26 +77,57 @@ class WearEngineP2pService(
     }
 
     fun stop() {
+        running = false
+        registered = false
+        device = null
         p2pClient.unregisterReceiver(receiver)
             .addOnFailureListener { logErr("unregisterReceiver", it) }
         scope.cancel()
     }
 
-    private fun findDeviceAndRegister() {
+    /**
+     * Resolve the connected watch and (re)register the receiver. Re-runnable: handles the watch
+     * connecting after start, dropping, or reconnecting on a new [Device]. Retries with a fixed
+     * backoff while no connected watch is found or registration fails.
+     */
+    private fun ensureRegistered() {
+        if (!running) return
         deviceClient.getBondedDevices()
             .addOnSuccessListener { devices ->
-                Log.i(TAG, "bonded devices: ${devices.size} [${devices.joinToString { "${it.name}:conn=${it.isConnected}" }}]")
-                device = devices.firstOrNull { it.isConnected }
-                val d = device
-                if (d == null) {
-                    Log.w(TAG, "no connected watch")
+                val connected = devices.firstOrNull { it.isConnected }
+                if (connected == null) {
+                    Log.w(TAG, "no connected watch; retry in ${RETRY_MS}ms")
+                    device = null
+                    registered = false
+                    scheduleRetry()
                     return@addOnSuccessListener
                 }
-                p2pClient.registerReceiver(d, receiver)
-                    .addOnSuccessListener { Log.i(TAG, "P2P receiver registered") }
-                    .addOnFailureListener { logErr("registerReceiver", it) }
+                if (connected != device || !registered) {
+                    device = connected
+                    p2pClient.registerReceiver(connected, receiver)
+                        .addOnSuccessListener {
+                            registered = true
+                            Log.i(TAG, "P2P receiver registered on ${connected.name}")
+                        }
+                        .addOnFailureListener {
+                            registered = false
+                            logErr("registerReceiver", it)
+                            scheduleRetry()
+                        }
+                }
             }
-            .addOnFailureListener { logErr("getBondedDevices", it) }
+            .addOnFailureListener {
+                logErr("getBondedDevices", it)
+                scheduleRetry()
+            }
+    }
+
+    private fun scheduleRetry() {
+        if (!running) return
+        scope.launch {
+            delay(RETRY_MS)
+            ensureRegistered()
+        }
     }
 
     private fun sendRaw(json: String) {
@@ -111,6 +151,7 @@ class WearEngineP2pService(
     private companion object {
         const val TAG = "WearEngineP2p"
         const val SEND_SUCCESS = 207
+        const val RETRY_MS = 5_000L // re-resolve the watch / re-register on this cadence
 
         // The watch app this companion pairs with. bundleName is fixed; fingerprint must match the
         // watch app's signing cert — fill it in (see README, Phase 1e).

From fd8c3f579eab43c7c0f2d9da06446234779bbcaa Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 12:51:24 +0700
Subject: [PATCH 05/11] refactor(companion): HaService interface + HaBridge
 tests; domain glyphs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- T2: extract HaService interface; HaClient implements it and HaBridge depends
  on it — the bridge is now unit-testable without HTTP, and a future WebSocket
  client can replace HaClient without touching the bridge.
- T1: add HaBridgeTest (fake HaService) covering the orchestration node:
  sync success/failure, call-service pass-through + error, unsupported version,
  unrecognized message — all previously untested.
- T4: companion UI entityGlyph/entityAccent now cover cover/scene/sensor
  (were "?" / inactive after the domains were added).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../companion/bridge/HaBridge.kt              |  4 +-
 .../homeassistant/companion/ha/HaClient.kt    | 10 +--
 .../homeassistant/companion/ha/HaService.kt   | 13 ++++
 .../homeassistant/companion/ui/Theme.kt       | 16 +++-
 .../homeassistant/companion/HaBridgeTest.kt   | 76 +++++++++++++++++++
 5 files changed, 109 insertions(+), 10 deletions(-)
 create mode 100644 apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaService.kt
 create mode 100644 apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/HaBridgeTest.kt

diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/HaBridge.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/HaBridge.kt
index d5c36cc..ce75d88 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/HaBridge.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/HaBridge.kt
@@ -1,7 +1,7 @@
 package ru.gentslava.homeassistant.companion.bridge
 
 import kotlinx.serialization.encodeToString
-import ru.gentslava.homeassistant.companion.ha.HaClient
+import ru.gentslava.homeassistant.companion.ha.HaService
 import ru.gentslava.homeassistant.companion.p2p.Ack
 import ru.gentslava.homeassistant.companion.p2p.CallServiceRequest
 import ru.gentslava.homeassistant.companion.p2p.P2pJson
@@ -17,7 +17,7 @@ import ru.gentslava.homeassistant.companion.p2p.parseIncoming
  * reply to send back. Transport-agnostic: in/out are JSON strings, so it is unit-testable without
  * Wear Engine. Reply `id` always echoes the request `id` (P2P correlation, see docs/p2p-protocol.md).
  */
-class HaBridge(private val client: HaClient) {
+class HaBridge(private val client: HaService) {
 
     /** Handle a raw inbound message; returns the JSON reply, or null if unrecognized. */
     suspend fun handle(rawJson: String): String? = when (val msg = parseIncoming(rawJson)) {
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaClient.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaClient.kt
index 1262c31..95700b0 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaClient.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaClient.kt
@@ -16,7 +16,7 @@ import java.util.concurrent.TimeUnit
  * Home Assistant REST client (see docs/ha-integration-notes.md).
  * Auth via `Authorization: Bearer <token>`. All calls run on Dispatchers.IO and return Result.
  */
-class HaClient(private val config: HaConfig) {
+class HaClient(private val config: HaConfig) : HaService {
 
     private val http = OkHttpClient.Builder()
         .connectTimeout(CONNECT_TIMEOUT_S, TimeUnit.SECONDS)
@@ -29,14 +29,14 @@ class HaClient(private val config: HaConfig) {
     private val jsonMedia = "application/json".toMediaType()
 
     /** GET /api/ -> {"message":"API running."}. Validates host + token. */
-    suspend fun checkApi(): Result<Unit> = call("GET", "/api/").map { }
+    override suspend fun checkApi(): Result<Unit> = call("GET", "/api/").map { }
 
     /**
      * GET /api/states -> all entities. Parsed element-by-element: a single malformed state
      * object (some custom integration) is skipped rather than failing the whole sync — the
      * protocol prefers fast partial data over an all-or-nothing reply.
      */
-    suspend fun getStates(): Result<List<HaState>> =
+    override suspend fun getStates(): Result<List<HaState>> =
         call("GET", "/api/states").mapCatching { raw ->
             json.parseToJsonElement(raw).jsonArray.mapNotNull { el ->
                 runCatching { json.decodeFromJsonElement<HaState>(el) }.getOrNull()
@@ -44,13 +44,13 @@ class HaClient(private val config: HaConfig) {
         }
 
     /** GET /api/states/<entity_id> -> one entity, or null on 404. */
-    suspend fun getState(entityId: String): Result<HaState?> =
+    override suspend fun getState(entityId: String): Result<HaState?> =
         call("GET", "/api/states/$entityId")
             .mapCatching { json.decodeFromString<HaState>(it) }
             .recoverCatching { e -> if (e is NotFound) null else throw e }
 
     /** POST /api/services/<domain>/<service> with `data` as the flat body (see notes). */
-    suspend fun callService(domain: String, service: String, data: Map<String, String>): Result<Unit> {
+    override suspend fun callService(domain: String, service: String, data: Map<String, String>): Result<Unit> {
         val body = json.encodeToString(data)
         return call("POST", "/api/services/$domain/$service", body).map { }
     }
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaService.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaService.kt
new file mode 100644
index 0000000..1eb3c9b
--- /dev/null
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ha/HaService.kt
@@ -0,0 +1,13 @@
+package ru.gentslava.homeassistant.companion.ha
+
+/**
+ * Home Assistant data source used by [ru.gentslava.homeassistant.companion.bridge.HaBridge].
+ * An interface so the bridge can be unit-tested with a fake (no network), and so a future
+ * WebSocket-backed implementation can replace [HaClient] without touching the bridge.
+ */
+interface HaService {
+    suspend fun checkApi(): Result<Unit>
+    suspend fun getStates(): Result<List<HaState>>
+    suspend fun getState(entityId: String): Result<HaState?>
+    suspend fun callService(domain: String, service: String, data: Map<String, String>): Result<Unit>
+}
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ui/Theme.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ui/Theme.kt
index 0a8917f..15eddba 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ui/Theme.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/ui/Theme.kt
@@ -52,18 +52,28 @@ val HaLightColorScheme = lightColorScheme(
     outline = Color(0xFFE0E0E0),
 )
 
+val HaCyan = Color(0xFF56CCF2)    // sensor
+val HaPurple = Color(0xFFBB6BD9)  // scene
+val HaSky = Color(0xFF2D9CDB)     // cover open
+
 /** Accent color for an entity given its domain + state (matches the watch palette). */
 fun entityAccent(domain: String, state: String): Color = when (domain) {
     "light" -> if (state == "on") HaAmber else HaInactive
     "switch" -> if (state == "on") HaGreen else HaInactive
     "lock" -> if (state == "locked") HaBlue else HaRed
+    "cover" -> if (state == "open") HaSky else HaInactive
+    "scene" -> HaPurple
+    "sensor" -> HaCyan
     else -> HaInactive
 }
 
 /** A short glyph for an entity domain. */
 fun entityGlyph(domain: String): String = when (domain) {
-    "light" -> "💡"   // 💡
-    "switch" -> "🔌"  // 🔌
-    "lock" -> "🔒"    // 🔒
+    "light" -> "💡"
+    "switch" -> "🔌"
+    "lock" -> "🔒"
+    "cover" -> "🪟"
+    "scene" -> "🎬"
+    "sensor" -> "📊"
     else -> "?"
 }
diff --git a/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/HaBridgeTest.kt b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/HaBridgeTest.kt
new file mode 100644
index 0000000..fc84efc
--- /dev/null
+++ b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/HaBridgeTest.kt
@@ -0,0 +1,76 @@
+package ru.gentslava.homeassistant.companion
+
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.buildJsonObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import ru.gentslava.homeassistant.companion.bridge.HaBridge
+import ru.gentslava.homeassistant.companion.ha.HaService
+import ru.gentslava.homeassistant.companion.ha.HaState
+
+/** In-memory HaService so the bridge is tested without Wear Engine or HTTP. */
+private class FakeHaService(
+    private val states: Result<List<HaState>> = Result.success(emptyList()),
+    private val state: Result<HaState?> = Result.success(null),
+    private val call: Result<Unit> = Result.success(Unit),
+) : HaService {
+    var lastCall: Triple<String, String, Map<String, String>>? = null
+    override suspend fun checkApi() = Result.success(Unit)
+    override suspend fun getStates() = states
+    override suspend fun getState(entityId: String) = state
+    override suspend fun callService(domain: String, service: String, data: Map<String, String>): Result<Unit> {
+        lastCall = Triple(domain, service, data)
+        return call
+    }
+}
+
+class HaBridgeTest {
+    private fun st(id: String, s: String) =
+        HaState(entityId = id, state = s, attributes = buildJsonObject {})
+
+    @Test fun syncRequestReturnsCardsEchoingId() = runBlocking {
+        val bridge = HaBridge(FakeHaService(states = Result.success(listOf(st("light.k", "on")))))
+        val reply = bridge.handle("""{"v":1,"id":"s1","type":"SYNC_REQUEST"}""")!!
+        assertTrue(reply.contains("\"type\":\"SYNC_RESPONSE\""))
+        assertTrue(reply.contains("\"id\":\"s1\""))
+        assertTrue(reply.contains("light.k"))
+    }
+
+    @Test fun syncRequestFailureReturnsErrorAck() = runBlocking {
+        val bridge = HaBridge(FakeHaService(states = Result.failure(RuntimeException("boom"))))
+        val reply = bridge.handle("""{"v":1,"id":"s2","type":"SYNC_REQUEST"}""")!!
+        assertTrue(reply.contains("\"type\":\"ACK\""))
+        assertTrue(reply.contains("\"ok\":false"))
+        assertTrue(reply.contains("\"id\":\"s2\""))
+    }
+
+    @Test fun callServicePassesThroughAndAcks() = runBlocking {
+        val fake = FakeHaService()
+        val reply = HaBridge(fake).handle(
+            """{"v":1,"id":"c1","type":"CALL_SERVICE","domain":"light","service":"toggle","data":{"entity_id":"light.k"}}""",
+        )!!
+        assertTrue(reply.contains("\"ok\":true"))
+        assertEquals(Triple("light", "toggle", mapOf("entity_id" to "light.k")), fake.lastCall)
+    }
+
+    @Test fun callServiceFailureSurfacesError() = runBlocking {
+        val bridge = HaBridge(FakeHaService(call = Result.failure(RuntimeException("HA returned 401"))))
+        val reply = bridge.handle(
+            """{"v":1,"id":"c2","type":"CALL_SERVICE","domain":"light","service":"toggle","data":{}}""",
+        )!!
+        assertTrue(reply.contains("\"ok\":false"))
+        assertTrue(reply.contains("HA returned 401"))
+    }
+
+    @Test fun unsupportedVersionReturnsErrorAck() = runBlocking {
+        val reply = HaBridge(FakeHaService()).handle("""{"v":99,"id":"v1","type":"SYNC_REQUEST"}""")!!
+        assertTrue(reply.contains("\"ok\":false"))
+        assertTrue(reply.contains("unsupported protocol v99"))
+    }
+
+    @Test fun unrecognizedMessageReturnsNull() = runBlocking {
+        assertNull(HaBridge(FakeHaService()).handle("not json"))
+    }
+}

From bf2495ed5310de223e9fe49c3dde8f567f57ff48 Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 12:55:56 +0700
Subject: [PATCH 06/11] fix(watch-arkts): allow-list peer, P2P error handling,
 Mock UI (review K6,B8-B10,V3)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- K6: wearEngineRemoteAppNameList -> ru.gentslava.homeassistant.companion
  (was the com.yourcompany.ha.bridge placeholder). It must match the bundle in
  setRemoteApp or Wear Engine rejects P2P and the app silently drops to Mock.
- B9: onIncoming wraps JSON.parse in try/catch — a malformed payload from the
  companion no longer throws out of the Wear Engine receiver callback.
- B10: refreshEntity now catches errors into lastError (was try/finally only,
  so a P2P timeout produced an unhandled rejection and no offline banner).
- B8: Services.tryUpgradeToReal() + store.sync calls it — if the app fell back
  to Mock at startup, it reconnects the real P2P repo once the phone is
  reachable instead of being stuck on fake data forever.
- V3: runAction refreshes the entity after callAction so the details screen
  reflects the new state (Mock updated in place but the UI never refreshed).

All compile: assembleHap successful.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../entry/src/main/ets/app/Services.ets       | 19 ++++++++++++
 .../repository/P2pHomeAssistantRepository.ets | 12 +++++++-
 .../presentation/store/HomeAssistantStore.ets | 10 +++++++
 apps/watch-arkts/entry/src/main/module.json5  |  2 +-
 .../repo/MockHomeAssistantRepository.js       | 30 -------------------
 5 files changed, 41 insertions(+), 32 deletions(-)
 delete mode 100644 apps/watch-lite/entry/src/main/js/MainAbility/common/repo/MockHomeAssistantRepository.js

diff --git a/apps/watch-arkts/entry/src/main/ets/app/Services.ets b/apps/watch-arkts/entry/src/main/ets/app/Services.ets
index f0a69b5..47f92e1 100644
--- a/apps/watch-arkts/entry/src/main/ets/app/Services.ets
+++ b/apps/watch-arkts/entry/src/main/ets/app/Services.ets
@@ -11,8 +11,10 @@ import { HomeAssistantRepository } from '../domain/repository/HomeAssistantRepos
 
 export class Services {
   static repo: HomeAssistantRepository | null = null;
+  private static ctx: common.UIAbilityContext | null = null;
 
   static async initWithFallback(ctx: common.UIAbilityContext): Promise<void> {
+    Services.ctx = ctx;
     // Не даём инициализации повиснуть на эмуляторе
     // const repo: HomeAssistantRepository = new MockHomeAssistantRepository();
     const repo: HomeAssistantRepository = await Services.tryInitRealRepo(ctx, 1200)
@@ -26,6 +28,23 @@ export class Services {
     await store.sync();
   }
 
+  /**
+   * If we're currently on the Mock repo (real P2P wasn't available at startup), try to (re)connect
+   * the real repo. Returns true if it upgraded. This is what stops the app from being stuck on Mock
+   * fake data forever once the phone/companion becomes reachable — called before each sync.
+   */
+  static async tryUpgradeToReal(): Promise<boolean> {
+    if (!(Services.repo instanceof MockHomeAssistantRepository)) return false;
+    if (!Services.ctx) return false;
+    const real: HomeAssistantRepository | null =
+      await Services.tryInitRealRepo(Services.ctx, 1200).catch(() => null);
+    if (real) {
+      Services.repo = real;
+      return true;
+    }
+    return false;
+  }
+
   private static async tryInitRealRepo(ctx: common.UIAbilityContext, timeoutMs: number): Promise<HomeAssistantRepository> {
     const p2p: WearEngineP2pClient = new WearEngineP2pClient(ctx);
 
diff --git a/apps/watch-arkts/entry/src/main/ets/data/repository/P2pHomeAssistantRepository.ets b/apps/watch-arkts/entry/src/main/ets/data/repository/P2pHomeAssistantRepository.ets
index 29a264a..6bd4d53 100644
--- a/apps/watch-arkts/entry/src/main/ets/data/repository/P2pHomeAssistantRepository.ets
+++ b/apps/watch-arkts/entry/src/main/ets/data/repository/P2pHomeAssistantRepository.ets
@@ -80,8 +80,18 @@ export class P2pHomeAssistantRepository implements HomeAssistantRepository {
   }
 
   private onIncoming(payload: string): void {
-    const msg: AnyMsg = fromJson<AnyMsg>(payload);
+    // The companion is a separate app — a malformed/non-JSON payload must not throw out of this
+    // Wear Engine callback (it would break further receiving). Ignore it; the matching request
+    // times out on its own.
+    let msg: AnyMsg;
+    try {
+      msg = fromJson<AnyMsg>(payload);
+    } catch (e) {
+      return;
+    }
+
     const id: string = msg.id;
+    if (!id) return;
 
     const p: PendingMsg | undefined = this.pending.get(id);
     if (!p) return;
diff --git a/apps/watch-arkts/entry/src/main/ets/presentation/store/HomeAssistantStore.ets b/apps/watch-arkts/entry/src/main/ets/presentation/store/HomeAssistantStore.ets
index 41a3c8e..8641da6 100644
--- a/apps/watch-arkts/entry/src/main/ets/presentation/store/HomeAssistantStore.ets
+++ b/apps/watch-arkts/entry/src/main/ets/presentation/store/HomeAssistantStore.ets
@@ -13,6 +13,10 @@ export class HomeAssistantStore {
       return;
     }
 
+    // If we fell back to Mock at startup, try to (re)connect the real P2P repo now so the watch
+    // doesn't stay on fake data once the phone becomes reachable.
+    await Services.tryUpgradeToReal();
+
     try {
       this.isSyncing = true;
       this.lastError = '';
@@ -56,6 +60,8 @@ export class HomeAssistantStore {
       }
 
       this.cards = next;
+    } catch (e) {
+      this.lastError = `${e}`;
     } finally {
       this.isSyncing = false;
     }
@@ -70,6 +76,10 @@ export class HomeAssistantStore {
     try {
       this.lastError = '';
       await Services.repo.callAction(action);
+      // Reflect the new state in the UI: Mock updates in place, real P2P returns the
+      // authoritative card. Without this the details screen looks unresponsive after a tap.
+      const entityId: string = action.data['entity_id'] ? action.data['entity_id'] : '';
+      if (entityId.length > 0) await this.refreshEntity(entityId);
     } catch (e) {
       this.lastError = `${e}`;
     }
diff --git a/apps/watch-arkts/entry/src/main/module.json5 b/apps/watch-arkts/entry/src/main/module.json5
index b727398..0e4b8aa 100644
--- a/apps/watch-arkts/entry/src/main/module.json5
+++ b/apps/watch-arkts/entry/src/main/module.json5
@@ -39,7 +39,7 @@
       },
       {
         "name": "wearEngineRemoteAppNameList",
-        "value": "com.yourcompany.ha.bridge"
+        "value": "ru.gentslava.homeassistant.companion"
       }
     ]
   }
diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/common/repo/MockHomeAssistantRepository.js b/apps/watch-lite/entry/src/main/js/MainAbility/common/repo/MockHomeAssistantRepository.js
deleted file mode 100644
index 3b50eab..0000000
--- a/apps/watch-lite/entry/src/main/js/MainAbility/common/repo/MockHomeAssistantRepository.js
+++ /dev/null
@@ -1,30 +0,0 @@
-export default class MockHomeAssistantRepository {
-    sync() {
-        // Возвращаем Promise как в настоящем репозитории
-        return Promise.resolve([
-            {
-                entity_id: 'light.kitchen',
-                name: 'Kitchen',
-                state: 'off',
-                domain: 'light'
-            },
-            {
-                entity_id: 'switch.router',
-                name: 'Router',
-                state: 'on',
-                domain: 'switch'
-            },
-            {
-                entity_id: 'lock.front_door',
-                name: 'Front door',
-                state: 'locked',
-                domain: 'lock'
-            }
-        ]);
-    }
-
-    runAction(action) {
-        // Всегда успешно
-        return Promise.resolve(true);
-    }
-}

From ad8e80a56f511cc117da58ded8a352c5682326fe Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 12:59:38 +0700
Subject: [PATCH 07/11] fix(watch-lite): render companion actions; add Settings
 icons (review B7,K7,C1)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- B7: the entity screen now renders the companion-provided primary+secondary
  actions (per the P2P contract — the watch shouldn't re-derive HA semantics)
  and sends each action's own domain/service/data on tap. The local per-domain
  table is kept only as a mock/offline fallback. navEntity carries the actions
  so they survive a back-and-return.
- K7: add the 4 missing Settings icons (connection/server/debug/info, 128px
  monochrome) — the Settings screen referenced non-existent files.
- C1: dead MockHomeAssistantRepository.js (used Promise, banned on lite) was
  removed in the previous commit — it was superseded by mockItems() + haRepository.

watch-lite assembleHap successful.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../MainAbility/common/icons/connection.png   | Bin 0 -> 662 bytes
 .../js/MainAbility/common/icons/debug.png     | Bin 0 -> 835 bytes
 .../main/js/MainAbility/common/icons/info.png | Bin 0 -> 804 bytes
 .../js/MainAbility/common/icons/server.png    | Bin 0 -> 439 bytes
 .../main/js/MainAbility/pages/entity/index.js |  52 ++++++++++++++----
 5 files changed, 42 insertions(+), 10 deletions(-)
 create mode 100644 apps/watch-lite/entry/src/main/js/MainAbility/common/icons/connection.png
 create mode 100644 apps/watch-lite/entry/src/main/js/MainAbility/common/icons/debug.png
 create mode 100644 apps/watch-lite/entry/src/main/js/MainAbility/common/icons/info.png
 create mode 100644 apps/watch-lite/entry/src/main/js/MainAbility/common/icons/server.png

diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/connection.png b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/connection.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce878dd3f2495a0fcfe30def7fd2f3c6401671c7
GIT binary patch
literal 662
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrV2bs0aSW-L^Y-q=yxRsmtO40K
z{{P?9W-G$cX4akSsdlvZ-sFHMxd|s*i)DbC7!Lfq73lJQ@BCWd?A+h~a&{ijKD<t<
zD_6|8_=R=5;#a1562I~iJt9k%98BkTT9u^CZ<j3)Br-Ge!_6jvT{|Wo-fz_L??L){
zp=}#>GtapAMQ+VJK_{`&trxXt-x0p@qch-Wip|E?Ctv*ypW(F5#5hQ~`qC|Dk-}|_
zfwQ(Bwvy9-;B#5YBxk$nR<GWuzt?XHw>-GWa3=4<3FakcJKL5!3H*9xdFVm-wJ$Cl
za-0Wx(o%NF-eGQga9uE<?P2=8UwgAI&MI5xIWbRYYh&qpo>Q0d8zwS$oBTPG&0Sjd
zFY{CS{V6ZG^M1MPl;aR?h&&u$TW3(D8_oLQZc{qX|ChH9zCAW8ERMP523y~ssJM%J
z>^4lh{#~n>@58PiIfv(qHWjHi&hIMPIA!a;DeR6jXWdqNua)+@R>kab%)Z!)^ZVC#
z+B_*gRA<_IPigIs>uco_qRYc}G|jtX_3z2MbXS=_(>Ju<y=zwYeV6sE*7H3!KlC4R
z&)J!~N9otLcWXpk=WTqHv_@4j?^mwE=iJFp0+$!tK3MtKCt4@z*up^n0uEEBU#w^D
zbbW2Py=(Kf$P*p8kNIv}fnp35m<4=W8Sei-B3MLKUiA0n&;P3~$=B{!9K-O>{7IY+
z%TlHfFAJ&{3QXZVaC6}|B}ENkhJES`M>!n|nF3;FGR(1klIhCVdWz-2nSkht52te<
sP(Pg8+7@rb@V@O%7q2{uT@5M!80w~Xct8135Dk*>boFyt=akR{0Jo+vpa1{>

literal 0
HcmV?d00001

diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/debug.png b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/debug.png
new file mode 100644
index 0000000000000000000000000000000000000000..8839603cf9e877bc02f721409fa898dcb48f19c7
GIT binary patch
literal 835
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrVCM34aSW-L^LFmVq9z9(*Uta{
z&%b<eLp(i-HL*Cq=v?t>wVRs@SzB_Mfm%>NgWVCcjx%S<>xBguXBDmHW5{xBc&Koo
zKp??_!$5{bf{%%Zow2Q%;qXq&xl3O=aXqaH*6IjKT=pbN??AR<2$!+y^&rN7S`AJh
zA+-a$kF4ef3JEdV`R-_D(VX|Xi1C}+D;-CvC%a-Al+9x-ye6<Gt=l2F^og=VWK+$j
zw}#*T`Cpyuv2?qAZ0ri-rJel8OK1H#ek0m2T;$EEJi-4xZ_R%8e>7)2r*-GlUZ*`h
z?=61zOPC4n(@c1(W~g+i^wWC}mWO+8+c%wh;vK^spnGPD%+jWn_m0Hc?z{Em{zUE-
zpS15xE!6P)Cwp?iIgNj!tmm6QuJGG;NAAIzL$RSBEDB<tp4_i2d*|NN?VE1geA2$`
zl57J1>TcQA*(U>;G}dp)P-xu4@G94g=hmLJ4DZAGy*@7f@F*mkF<}FP-s<~%xleFC
zF!}ka@FwSiT~SugR5cma9QI@QY9{^Y<4tacv#bGs=De8`Z=w3^O5Eioaz(NX*P0j(
zV}!8#yCYq<YZ=~Io+xEl`pD;mzaK+H_gsc7@!&g;Hj6W`aV+>|dDBwglQHIYPS>$i
z&4$~#*D}9cJ@3R2(Y%F0FIK@feE%MX`2o6)T^={W7@p2gSpLEP`fZK{zxMn!iT}CZ
z<MzrQ0n1G4v{r<&|43_%-D>suLE+ThtxIO6i~BsZY+N<hL2tq8aPP0njE<;G;Bwm;
zS~k@ojsHS!@l&N=XKO#LR_#z<C*-nxYW&Y*0@wAfeOekgb@mRE$qRBGh_<f!#Wmec
zXbMkM=mOiv$EH8t>7nrd)eU3r&o2ufwS0^*Yx}gmZ|yym((|Feu5LUx`TeBqo0Sda
zoaHlW+GD)^S^iF~Sbj46{MJ7{53(6oaU1DgFJheH_uB7Fs1w7|CZE%xZVW3J!6^_U
h*w`6Sk}`;6^^rN?|B+qoE2oQqxSp<lF6*2UngAyIaIF9U

literal 0
HcmV?d00001

diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/info.png b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/info.png
new file mode 100644
index 0000000000000000000000000000000000000000..00109a883e99b230aec50de883a7586ef9830223
GIT binary patch
literal 804
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrV0!K8;uumf=k48#dAA*STmlVG
z{QqynZM&m@o4rpbGu`9f=ZFOY<(7}M%yROjf!a{P3axF5M#laB=67W5x6c*-;dxk{
zZPC@HcNtaR4W`5&Ikl{u$NA<VS*iPq98bB*a%!F`)a15?WYjISDmTn@?!PlrbH}o#
z(!zA<!l%!cd&-7y);;s{=xmd<uZ5?%%HB<Q`Ydf>l(!8_*zF4z6}8*hT~?dO-IOVP
zy!%SNF{4)Ayu<O5>9zT-JIwxt_UiHK88X&wjuf3$za_4H!U^UJ8-Gr9Qs8xX{w$oc
zv4*K6udcQ91k(q-ujgie>nwjA=*#HIaOL^EVp;y#jIOfN+z;F>|G#?K^CkrgzpYOh
zE4H8Pn|<Y{#)dfz<yG4cW){h8;W_YS_x(by8$J!1XUn74`!d9s+4)Fa)?>JQ?wZ!`
zR71wF`=!6X{@b6n=f`%@(wwBF_xRr3VA!fE-0<=J?)*>63BO_`9(_H{%%IC;aOeA#
z&;LVX6Dwrimfnk;Uc$7(?9cLmWg2TvJ?OP&sxZ!|VECZVWFW&R(Z|5!&d{dJa9FV6
zA;*CNmIRC6{Ox`d=Gx1=`oZR{TKM^2Aqz;wWcGw##SVTy+63k?*L?T2V_c9b$naHS
z&YpLvj1MF}+|lpmWRRWBV9|59^Y!0Zzm9TvWqxs$G!tf!I?ZfQ%eCa<-F$1tU2O`y
z*Ht+iKKVO6U*ExbaBHftL#4={lD9iHGUhG*|Gw0G;eC^xhq*m6_xJ&wVKr}d?5zBc
z0yivKGVj%NGnDW;ie=R8%;&7mS#|hWDd(!AEGvFZ&Q5<-#JSN`Fn!kR4HF|br0wPm
z__{n|bHV5Gu%j^-W9n@81Tvhv_b|Lo(f8GkS-FYjJ(WkB(<IF6(_`n{uDrkU<2L?A
zSu@kFD?7D=Gg>nRTBZI6tV=kq;BxSo{S@68**1+kU($8OHfr%)T=Me#E!`Ejy1h`7
eDUg>l|2MNt(3BN&&-(6wBt2dIT-G@yGywn$fL$yA

literal 0
HcmV?d00001

diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/server.png b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/server.png
new file mode 100644
index 0000000000000000000000000000000000000000..e95fafed1bf50a405c71bd1c765208005c40bf49
GIT binary patch
literal 439
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrV65|WaSW-L^Y)Hm-eCg)7Ke)`
z{_j5%@~Y{GX2teTXQ$+`1ZYnZ+Oba$r~?5Wc!nK!{eExv<6Zt6u4(O6U%z_B?D?j4
zOBoA3e?GQShas=-S;bU+#+0A4wmkIQHrwo2TEoMr^oH_zY@3fPVEALgdv8DIA<1bC
z599oAvQ+l|`M_|&nW3$l^FaJ;o7o5W`59~%#WBBMey6;_Ds_I++eiP`C*9o4!V@mW
zFnh<Dk6LpXTNLu=oSM#{_+#!zMh1ol3U?0}>}oumd)HxGo<g+w1g>3;iY3gMf~9I7
zp7}hu!0>|YTCrNeju}7(AJA}?1UM6DPbu^3muzg8d7oI^JrJ;~v03--ft}O#pJxS{
zD}&qIWzrTV47(b?%5cl;sR0>>nH~5UC1A|{71tf^9;n*Yc(8=o($CyrO5TG6Z}Wn6
hOQkswp?Kiyw)_C|EfYH#C*K2!db;|#taD0e0stnTvF!i=

literal 0
HcmV?d00001

diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/pages/entity/index.js b/apps/watch-lite/entry/src/main/js/MainAbility/pages/entity/index.js
index 05ccb3b..e6d5555 100644
--- a/apps/watch-lite/entry/src/main/js/MainAbility/pages/entity/index.js
+++ b/apps/watch-lite/entry/src/main/js/MainAbility/pages/entity/index.js
@@ -46,6 +46,11 @@ export default {
         this.iconSrc = p.iconSrc ? String(p.iconSrc) : '/common/icons/unknown.png';
         this.domain = domainFromEntityId(this.entityId);
 
+        // Companion-authored actions (the contract: the watch renders these, it doesn't decide
+        // HA semantics). Kept for _rebuildActions; the local table is only a mock/offline fallback.
+        this.primary = p.primary || null;
+        this.secondary = p.secondary || [];
+
         const store = ensureStore();
         const saved = store.statesById[this.entityId];
         this.state = saved !== undefined ? saved : (p.state ? String(p.state) : '—');
@@ -78,6 +83,34 @@ export default {
         const ICON_SCENE = '/common/icons/scene.png';
         const st = String(this.state || '');
 
+        // Preferred path: render the companion-provided actions (primary + secondary) verbatim.
+        // Falls through to the local per-domain table only when there are none (mock/offline).
+        const companion = [];
+        if (this.primary) companion.push(this.primary);
+        if (this.secondary && this.secondary.length) {
+            for (let i = 0; i < this.secondary.length; i++) companion.push(this.secondary[i]);
+        }
+        if (companion.length > 0) {
+            const items = [];
+            for (let i = 0; i < companion.length; i++) {
+                const a = companion[i];
+                items.push({
+                    id: a.service, name: a.label, state: 'Call service',
+                    iconSrc: this.iconSrc, color: actionColorBlue(),
+                    domain: a.domain, service: a.service, data: a.data
+                });
+            }
+            this.actions = items;
+            return;
+        }
+
+        if (this.domain === 'sensor') {
+            // Read-only (also the companion sensor case: no primary, empty secondary).
+            this.actions = [];
+            this.statusText = 'Read-only';
+            return;
+        }
+
         if (this.domain === 'light' || this.domain === 'switch') {
             if (st === 'on') {
                 this.actions = [{ id: 'turn_off', name: 'Turn off', state: 'Switch state', iconSrc: ICON_POWER, color: actionColorBlue() }];
@@ -136,13 +169,6 @@ export default {
             return;
         }
 
-        if (this.domain === 'sensor') {
-            // Read-only: no actions, just the state header.
-            this.actions = [];
-            this.statusText = 'Read-only';
-            return;
-        }
-
         this.actions = [{ id: 'toggle', name: 'Toggle', state: 'Call service', iconSrc: ICON_POWER, color: actionColorGray() }];
     },
 
@@ -152,7 +178,11 @@ export default {
         this.statusText = '';
 
         const self = this;
-        const service = action && action.id ? String(action.id) : '';
+        // Action items carry the companion's domain/service/data; fall back to local fields.
+        const service = action && action.service ? String(action.service)
+            : (action && action.id ? String(action.id) : '');
+        const domain = action && action.domain ? String(action.domain) : this.domain;
+        const data = action && action.data ? action.data : { entity_id: this.entityId };
         const prevState = this.state;
 
         // 1) optimistic local + store update (so the list reflects it immediately)
@@ -174,7 +204,7 @@ export default {
 
         // 2) call HA via the companion; confirm or roll back
         callAction(
-            { domain: this.domain, service: service, data: { entity_id: this.entityId } },
+            { domain: domain, service: service, data: data },
             function () {
                 syncEntity(self.entityId, function (card) {
                     if (card) self._setState(card.state);
@@ -198,7 +228,9 @@ export default {
             name: this.name,
             state: next,
             iconSrc: this.iconSrc,
-            domain: this.domain
+            domain: this.domain,
+            primary: this.primary,
+            secondary: this.secondary
         };
     },
 

From 75866166a88b09c24ec387ab77603eb3e32cd297 Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 13:08:48 +0700
Subject: [PATCH 08/11] fix(companion): FGS type dataSync (connectedDevice
 crashed) + reconnect backoff
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On-device the foreground service crashed at startForeground: FGS type
connectedDevice on Android 14+ (targetSDK 35) additionally requires a
BT/network runtime permission. Switched to dataSync (semantically: syncing HA
state <-> watch) which needs only the normal FOREGROUND_SERVICE_DATA_SYNC.

Also: the reconnect loop polled getBondedDevices every fixed 5s forever while
the watch was away (CPU wakeups / battery). Now exponential backoff 5s..60s,
reset on connect. HA itself is never polled — the companion calls HA only on a
watch request (SYNC/CALL_SERVICE), so there are no background HA requests.

Verified on device: no crash, service starts, bridge reaches requestPermission
(code=8 Scope unauthorized — pending Wear Engine approval, as before).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../phone-android/app/src/main/AndroidManifest.xml |  8 +++++---
 .../companion/p2p/WearEngineP2pService.kt          | 14 +++++++++++---
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/apps/phone-android/app/src/main/AndroidManifest.xml b/apps/phone-android/app/src/main/AndroidManifest.xml
index 8cdd9ee..eb7a5d7 100644
--- a/apps/phone-android/app/src/main/AndroidManifest.xml
+++ b/apps/phone-android/app/src/main/AndroidManifest.xml
@@ -9,9 +9,11 @@
     <uses-permission android:name="com.huawei.wearengine.permission.DEVICE_MANAGER" />
     <uses-permission android:name="com.huawei.wearengine.permission.NOTIFY" />
 
-    <!-- Foreground service: keep the watch bridge alive across Activity recreation / background -->
+    <!-- Foreground service: keep the watch bridge alive across Activity recreation / background.
+         Type dataSync (syncing HA state <-> watch) needs only this normal permission; the
+         connectedDevice type would additionally require a BT/network runtime permission. -->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <!-- Android 11+ package visibility: the Wear Engine SDK binds to the Huawei Health /
@@ -49,7 +51,7 @@
         <service
             android:name=".p2p.HaBridgeService"
             android:exported="false"
-            android:foregroundServiceType="connectedDevice" />
+            android:foregroundServiceType="dataSync" />
     </application>
 
 </manifest>
diff --git a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
index a2351f6..8599f37 100644
--- a/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
+++ b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/WearEngineP2pService.kt
@@ -51,6 +51,10 @@ class WearEngineP2pService(
     @Volatile
     private var running = false
 
+    // Backoff for the reconnect loop so a watch that's away doesn't cause 5s CPU wakeups forever.
+    @Volatile
+    private var retryDelayMs = RETRY_MIN_MS
+
     private val receiver = Receiver { message: Message ->
         if (message.type != Message.MESSAGE_TYPE_DATA) return@Receiver
         val request = String(message.data, StandardCharsets.UTF_8)
@@ -96,7 +100,7 @@ class WearEngineP2pService(
             .addOnSuccessListener { devices ->
                 val connected = devices.firstOrNull { it.isConnected }
                 if (connected == null) {
-                    Log.w(TAG, "no connected watch; retry in ${RETRY_MS}ms")
+                    Log.w(TAG, "no connected watch; retry in ${retryDelayMs}ms")
                     device = null
                     registered = false
                     scheduleRetry()
@@ -107,6 +111,7 @@ class WearEngineP2pService(
                     p2pClient.registerReceiver(connected, receiver)
                         .addOnSuccessListener {
                             registered = true
+                            retryDelayMs = RETRY_MIN_MS // connected — reset backoff
                             Log.i(TAG, "P2P receiver registered on ${connected.name}")
                         }
                         .addOnFailureListener {
@@ -124,8 +129,10 @@ class WearEngineP2pService(
 
     private fun scheduleRetry() {
         if (!running) return
+        val d = retryDelayMs
+        retryDelayMs = (retryDelayMs * 2).coerceAtMost(RETRY_MAX_MS) // exponential backoff
         scope.launch {
-            delay(RETRY_MS)
+            delay(d)
             ensureRegistered()
         }
     }
@@ -151,7 +158,8 @@ class WearEngineP2pService(
     private companion object {
         const val TAG = "WearEngineP2p"
         const val SEND_SUCCESS = 207
-        const val RETRY_MS = 5_000L // re-resolve the watch / re-register on this cadence
+        const val RETRY_MIN_MS = 5_000L  // first reconnect attempt delay
+        const val RETRY_MAX_MS = 60_000L // backoff ceiling — at most one wakeup per minute when away
 
         // The watch app this companion pairs with. bundleName is fixed; fingerprint must match the
         // watch app's signing cert — fill it in (see README, Phase 1e).

From 556f4a4fc977be9c629706faa64ca1b57ada1239 Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 13:09:51 +0700
Subject: [PATCH 09/11] ci: add companion test + build workflow (review K8/C2)

The monorepo exists to protect the shared P2P contract, but nothing ran on
push. The companion is the only app with a headless suite, so guard it:
gradle test + assembleDebug on every push/PR touching apps/phone-android or
the protocol doc. Path-filtered per ADR-0006. The watch apps have no
CI-runnable build (DevEco/JerryScript, device-only).

Builds without agconnect-services.json (AGC plugin stays commented out).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/companion.yml | 39 +++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 .github/workflows/companion.yml

diff --git a/.github/workflows/companion.yml b/.github/workflows/companion.yml
new file mode 100644
index 0000000..3870d5a
--- /dev/null
+++ b/.github/workflows/companion.yml
@@ -0,0 +1,39 @@
+name: companion
+
+# Guards the shared P2P contract: the companion is the only app with a headless
+# test suite, so it runs on every push/PR that touches it. The watch apps have no
+# CI-runnable build (DevEco/JerryScript, device-only) — see their AGENTS.md.
+on:
+  push:
+    paths:
+      - 'apps/phone-android/**'
+      - 'docs/p2p-protocol.md'
+      - '.github/workflows/companion.yml'
+  pull_request:
+    paths:
+      - 'apps/phone-android/**'
+      - 'docs/p2p-protocol.md'
+      - '.github/workflows/companion.yml'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/phone-android
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Unit tests
+        run: ./gradlew test --no-daemon
+
+      - name: Assemble debug APK
+        run: ./gradlew assembleDebug --no-daemon

From 82d35e8ee1429ae398de52ec73a0dc2e95113a63 Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 13:26:11 +0700
Subject: [PATCH 10/11] =?UTF-8?q?docs:=20sync=20with=20code=20=E2=80=94=20?=
 =?UTF-8?q?companion=20exists,=20peer=20configured,=206=20domains=20(revie?=
 =?UTF-8?q?w=20B11)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The docs described an earlier state and actively misled agents:
- companion was "not written / separate repo" — it's implemented in
  apps/phone-android/ (README, architecture.md).
- setRemoteApp / PEER_FINGERPRINT described as "commented out / placeholder" —
  they're configured with the real companion bundle + debug-cert fingerprint
  (p2p-protocol.md, ADR-0003, watch-arkts AGENTS.md, CLAUDE.md, DEVELOPMENT.md).
- supported domains listed as 3 — now 6 (light/switch/lock/cover/scene/sensor),
  and the "ask first before adding domains" gate updated (root AGENTS.md,
  architecture.md, spec).
- AGP 8.7 -> 8.13.2 (phone AGENTS.md).

Remaining real placeholder noted accurately: module.json5 client_id.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 AGENTS.md                                  |  2 +-
 CLAUDE.md                                  |  5 +++--
 DEVELOPMENT.md                             |  5 +++--
 README.md                                  |  2 +-
 apps/phone-android/AGENTS.md               |  2 +-
 apps/watch-arkts/AGENTS.md                 |  4 ++--
 docs/adr/0003-wear-engine-p2p-transport.md |  3 ++-
 docs/architecture.md                       | 12 +++++++-----
 docs/p2p-protocol.md                       |  8 ++++----
 docs/specs/01-real-ha-integration.md       |  4 ++--
 10 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 2f96120..1fd46c8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -21,7 +21,7 @@ incompatible developer platforms, so there are two watch apps sharing one design
 contract ([docs/platform-constraints.md](docs/platform-constraints.md)).
 
 Maturity: real-HA-integration in progress ([docs/specs/01-real-ha-integration.md](docs/specs/01-real-ha-integration.md)).
-Domains: `light`, `switch`, `lock`. Localization: EN + RU.
+Domains: `light`, `switch`, `lock`, `cover`, `scene`, `sensor` (sensor read-only). Localization: EN + RU.
 
 ## The three apps — read the right rules
 
diff --git a/CLAUDE.md b/CLAUDE.md
index a881435..97c6a3d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -32,8 +32,9 @@ Claude-specific guidance.
   Mock run + Code Linter; watch-lite = builds/installs on a real GT; companion = `./gradlew test`.
   State the evidence; if you couldn't run a check, say so instead of asserting it passed.
 - **Scope discipline.** Touch only what the task needs, and don't carry one app's conventions into
-  another. Don't remove deliberate placeholders (`setRemoteApp`, `PEER_FINGERPRINT`, `module.json5`
-  metadata) — see the per-app gotchas.
+  another. `setRemoteApp` / `PEER_FINGERPRINT` are now filled with the real companion bundle +
+  debug-cert fingerprint; the remaining deliberate placeholder is `module.json5`'s `client_id`
+  (`PUT_YOUR_CLIENT_ID_HERE`) — don't remove it. See the per-app gotchas.
 - **Surface assumptions and ask** when requirements are ambiguous — the repo author prefers an
   extra question over a wrong inference.
 
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index baedf3d..f0bd93c 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -42,8 +42,9 @@ The human owns decisions; agents own execution. Stop and get a human decision be
 
 - Reversing or adding an **ADR** (architecture, transport, protocol).
 - A **breaking P2P protocol change** (`v` bump) — it commits the future companion repo to a contract.
-- Filling in real secrets/identity: `setRemoteApp(...)` / `PEER_FINGERPRINT` / `client_id` /
-  `supportLists` / `agconnect-services.json` (today intentional placeholders).
+- Filling in real secrets/identity: `setRemoteApp(...)` / `PEER_FINGERPRINT` / `supportLists` are
+  filled (real companion bundle + debug-cert fingerprint); still placeholders: `module.json5`'s
+  `client_id` and `agconnect-services.json` (git-ignored, local-only).
 - Adding a **production dependency** to a watch app (they are intentionally dependency-free).
 - Anything where the spec is ambiguous — the author prefers an extra question over a wrong inference.
 
diff --git a/README.md b/README.md
index f50f640..1186815 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ sharing one design and one wire contract — see [docs/platform-constraints.md](
 |------|------|--------|-------|
 | [`apps/watch-arkts/`](apps/watch-arkts/) | Full-wearable watch app | **Watch 4/5/Ultimate** | ArkTS + ArkUI (Stage), `ArcList` |
 | [`apps/watch-lite/`](apps/watch-lite/) | Lite-wearable watch app | **Watch GT 4/5/6** | JS (FA), HML/CSS, JerryScript (ES5.1) |
-| [`apps/phone-android/`](apps/phone-android/) | Phone companion (P2P ↔ HA REST) | Android | Kotlin + Compose — *not written yet* |
+| [`apps/phone-android/`](apps/phone-android/) | Phone companion (P2P ↔ HA REST) | Android | Kotlin + Compose |
 
 The two watch apps are **mirror architectures in different runtimes** — they share the
 [P2P protocol](docs/p2p-protocol.md), the domain model, and the layering, but **no code**
diff --git a/apps/phone-android/AGENTS.md b/apps/phone-android/AGENTS.md
index 8a1063c..c3fc0b2 100644
--- a/apps/phone-android/AGENTS.md
+++ b/apps/phone-android/AGENTS.md
@@ -9,7 +9,7 @@ Different stack from the watches (Kotlin, not ArkTS/JS). Open `apps/phone-androi
 | | |
 |---|---|
 | Language / UI | Kotlin, Jetpack Compose (Material3) |
-| Build | Gradle (version catalog `gradle/libs.versions.toml`), AGP 8.7, JDK 17 |
+| Build | Gradle (version catalog `gradle/libs.versions.toml`), AGP 8.13.2, JDK 17 |
 | SDK | compileSdk 35, minSdk 26, targetSdk 35 |
 | App id | `ru.gentslava.homeassistant.companion` (companion). The watch peer is `ru.gentslava.homeassistant` |
 | HA | OkHttp + kotlinx-serialization (`Bearer` token) |
diff --git a/apps/watch-arkts/AGENTS.md b/apps/watch-arkts/AGENTS.md
index 820af07..7b05961 100644
--- a/apps/watch-arkts/AGENTS.md
+++ b/apps/watch-arkts/AGENTS.md
@@ -63,7 +63,7 @@ Architecture map: [../../docs/architecture.md](../../docs/architecture.md). Deci
 ## Gotchas
 
 - **Emulator always uses Mock.** No paired phone ⇒ `hasConnectedPeer()` false ⇒ `MockHomeAssistantRepository`. By design; keep Mock working.
-- **`setRemoteApp(bundleName, fingerprint)` is commented out** in `entry/src/main/ets/app/Services.ets` — real P2P won't connect until the companion's bundleName + fingerprint are filled in.
-- **`module.json5` metadata are placeholders:** `client_id`, `wearEngineRemoteAppNameList`.
+- **`setRemoteApp(bundleName, fingerprint)` is configured** in `entry/src/main/ets/app/Services.ets` with the real companion bundle + debug-cert fingerprint. Real P2P additionally needs Wear Engine approved in AGC.
+- **`module.json5`:** `wearEngineRemoteAppNameList` is the real companion bundle; `client_id` is still a placeholder (`PUT_YOUR_CLIENT_ID_HERE`) — fill it from this watch app's own AGC registration.
 - **`Services.initWithFallback` is fire-and-forget** (not awaited) — UI never blocks on P2P.
 - **P2P correlates by `id`, 8s timeout**; replies may arrive out of order. Protocol change = bump `v` + update [../../docs/p2p-protocol.md](../../docs/p2p-protocol.md).
diff --git a/docs/adr/0003-wear-engine-p2p-transport.md b/docs/adr/0003-wear-engine-p2p-transport.md
index d4ffa7c..57548fe 100644
--- a/docs/adr/0003-wear-engine-p2p-transport.md
+++ b/docs/adr/0003-wear-engine-p2p-transport.md
@@ -28,7 +28,8 @@ sides.
   mostly a companion + UI-mapping change.
 - Two repos must evolve in lockstep on protocol changes — bump `v` and update both sides together.
 - Real-device P2P requires the companion's `bundleName` + signing `fingerprint` via
-  `WearEngineP2pClient.setRemoteApp(...)`; these are **currently commented out** in `Services.ets`.
+  `WearEngineP2pClient.setRemoteApp(...)`; these are **configured** in `Services.ets` (real
+  companion bundle + debug-cert fingerprint). It additionally needs Wear Engine approved in AGC.
 - Hard dependency on Huawei Wear Engine + a paired Huawei phone; no standalone watch operation.
 
 ## Alternatives considered
diff --git a/docs/architecture.md b/docs/architecture.md
index 6b20aa9..b55b697 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -24,9 +24,10 @@ The watch has **no direct network access to Home Assistant**. It talks to an And
 └──────────────────────────┘                      └────────────────────┘              └────────────────┘
 ```
 
-The companion app lives in a **separate repository** and is not written yet. The P2P
-message protocol is therefore a forward-looking **contract** that both sides must honor —
-treat [p2p-protocol.md](p2p-protocol.md) as the source of truth when building either side.
+The companion app lives in this monorepo at [`apps/phone-android/`](../apps/phone-android/)
+(Kotlin + Compose; HA REST client, transport-agnostic bridge, Wear Engine P2P service, JUnit
+tests). The P2P message protocol is the **contract** both sides honor — treat
+[p2p-protocol.md](p2p-protocol.md) as the source of truth when building either side.
 
 ## Layers (Clean Architecture)
 
@@ -128,8 +129,9 @@ no clipped text or buttons at the top/bottom arcs.
 
 ## Extension points (where future work plugs in)
 
-- **New HA domain** (`light`/`switch`/`lock` today): UI mapping (icon/color/labels) + DTO/actions
-  + companion REST + mock entities. Walkthrough in [CONTRIBUTING.md](../CONTRIBUTING.md).
+- **New HA domain** (`light`/`switch`/`lock`/`cover`/`scene`/`sensor` today): UI mapping
+  (icon/color/labels) + DTO/actions + companion REST + mock entities. Walkthrough in
+  [CONTRIBUTING.md](../CONTRIBUTING.md).
 - **Remote access** (cloud / external URL + TLS): a new `HomeAssistantRepository` implementation
   in `data/`, selected in `Services`. The UI and domain stay untouched.
 - **On-watch connection config**: currently the companion owns base URL + token; a settings UI
diff --git a/docs/p2p-protocol.md b/docs/p2p-protocol.md
index f09ea37..29fad39 100644
--- a/docs/p2p-protocol.md
+++ b/docs/p2p-protocol.md
@@ -17,10 +17,10 @@ sync with them; if they diverge, the `.ets` files win and this doc is a bug.
 - **Channel:** Wear Engine P2P messaging (`@kit.WearEngine`).
 - **Encoding:** each message is a single UTF-8 JSON string (one JSON object per P2P message).
 - **Peer pairing:** the watch resolves the first connected device and targets the companion by
-  `remoteApp = { bundleName, fingerprint }`. ⚠️ These are configured via
-  `WearEngineP2pClient.setRemoteApp(...)` and are **currently commented out** in
-  [`Services.ets`](../apps/watch-arkts/entry/src/main/ets/app/Services.ets) — real-device P2P will not connect
-  until the companion's bundleName + signing fingerprint are filled in.
+  `remoteApp = { bundleName, fingerprint }`, configured via `WearEngineP2pClient.setRemoteApp(...)`
+  in [`Services.ets`](../apps/watch-arkts/entry/src/main/ets/app/Services.ets). It is **configured**
+  with the real companion bundle (`ru.gentslava.homeassistant.companion`) + its debug-cert
+  fingerprint; real-device P2P additionally needs Wear Engine approved in AppGallery Connect.
 - **Direction:** the watch is always the initiator. The companion only sends replies (it never
   pushes unsolicited messages in v1).
 
diff --git a/docs/specs/01-real-ha-integration.md b/docs/specs/01-real-ha-integration.md
index d6cb613..7c111a9 100644
--- a/docs/specs/01-real-ha-integration.md
+++ b/docs/specs/01-real-ha-integration.md
@@ -79,8 +79,8 @@ docs/p2p-protocol.md                    extend: handshake/config, connection err
 
 - **Always:** keep the mock path working as an offline/dev fallback; bump `v` + update both watch
   apps when changing [p2p-protocol.md](../p2p-protocol.md); keep watch-lite ES5.1-clean.
-- **Ask first:** adding domains beyond light/switch/lock; switching to HA WebSocket; adding a
-  production dependency to a watch app (they are dependency-free today).
+- **Ask first:** adding domains beyond the current set (light/switch/lock/cover/scene/sensor);
+  switching to HA WebSocket; adding a production dependency to a watch app (dependency-free today).
 - **Never:** commit HA tokens / `client_id` / signing fingerprints; hardcode a user's HA URL.
 
 ## Success Criteria

From ab094397c3a88aee751e0ef35ba2b6d1a13762e2 Mon Sep 17 00:00:00 2001
From: Vyacheslav Scherbinin <gentslava@mail.ru>
Date: Mon, 15 Jun 2026 13:28:35 +0700
Subject: [PATCH 11/11] refactor(watch): debugMode off by default, offline
 auto-retry, drop unused imports
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- watch-lite TD7: debugMode defaults to false — a fresh install with no
  companion now shows the honest "Offline — open the phone app" instead of
  fake mock data.
- watch-lite M2: index onShow retries loadEntities when the list is empty
  (offline first load), so returning to the screen auto-recovers instead of
  requiring a manual pull-down with no on-screen affordance.
- watch-arkts: drop unused ArcListAttribute/ArcListItemAttribute imports
  (Index/EntityDetails/Settings) — Code Linter warnings.

Both watch apps assembleHap successfully.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../entry/src/main/ets/pages/EntityDetails.ets         |  1 -
 apps/watch-arkts/entry/src/main/ets/pages/Index.ets    |  1 -
 apps/watch-arkts/entry/src/main/ets/pages/Settings.ets |  1 -
 .../entry/src/main/js/MainAbility/pages/index/index.js | 10 ++++++++--
 .../src/main/js/MainAbility/pages/settings/index.js    |  2 +-
 5 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/apps/watch-arkts/entry/src/main/ets/pages/EntityDetails.ets b/apps/watch-arkts/entry/src/main/ets/pages/EntityDetails.ets
index a2c5dd3..bfc178c 100644
--- a/apps/watch-arkts/entry/src/main/ets/pages/EntityDetails.ets
+++ b/apps/watch-arkts/entry/src/main/ets/pages/EntityDetails.ets
@@ -2,7 +2,6 @@ import router from '@ohos.router';
 import { AppStorageV2 } from '@ohos.arkui.StateManagement';
 import {
   ArcList, ArcListItem,
-  ArcListAttribute,
   ComponentContent, LengthMetrics
 } from '@kit.ArkUI';
 
diff --git a/apps/watch-arkts/entry/src/main/ets/pages/Index.ets b/apps/watch-arkts/entry/src/main/ets/pages/Index.ets
index 3c5418b..d820053 100644
--- a/apps/watch-arkts/entry/src/main/ets/pages/Index.ets
+++ b/apps/watch-arkts/entry/src/main/ets/pages/Index.ets
@@ -2,7 +2,6 @@ import router from '@ohos.router';
 import { AppStorageV2 } from '@ohos.arkui.StateManagement';
 import {
   ArcList, ArcListItem,
-  ArcListAttribute,
   ComponentContent, LengthMetrics,
 } from '@kit.ArkUI';
 
diff --git a/apps/watch-arkts/entry/src/main/ets/pages/Settings.ets b/apps/watch-arkts/entry/src/main/ets/pages/Settings.ets
index 6a64978..f59e508 100644
--- a/apps/watch-arkts/entry/src/main/ets/pages/Settings.ets
+++ b/apps/watch-arkts/entry/src/main/ets/pages/Settings.ets
@@ -2,7 +2,6 @@ import router from '@ohos.router';
 import { AppStorageV2 } from '@ohos.arkui.StateManagement';
 import {
   ArcList, ArcListItem,
-  ArcListAttribute, ArcListItemAttribute,
   ComponentContent, LengthMetrics,
 } from '@kit.ArkUI';
 
diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/pages/index/index.js b/apps/watch-lite/entry/src/main/js/MainAbility/pages/index/index.js
index 84109f8..1de7480 100644
--- a/apps/watch-lite/entry/src/main/js/MainAbility/pages/index/index.js
+++ b/apps/watch-lite/entry/src/main/js/MainAbility/pages/index/index.js
@@ -36,9 +36,15 @@ export default {
         this.loadEntities();
     },
 
-    // On Lite this fires when returning via replace/back — re-apply optimistic states.
+    // On Lite this fires when returning via replace/back. If the first load failed (offline),
+    // retry it on return — otherwise the list stays empty until a manual pull-down. Else just
+    // re-apply optimistic states.
     onShow() {
-        this._applyStoreStates();
+        if (!this.items || this.items.length === 0) {
+            this.loadEntities();
+        } else {
+            this._applyStoreStates();
+        }
     },
 
     loadEntities() {
diff --git a/apps/watch-lite/entry/src/main/js/MainAbility/pages/settings/index.js b/apps/watch-lite/entry/src/main/js/MainAbility/pages/settings/index.js
index 4037d64..9ab3492 100644
--- a/apps/watch-lite/entry/src/main/js/MainAbility/pages/settings/index.js
+++ b/apps/watch-lite/entry/src/main/js/MainAbility/pages/settings/index.js
@@ -9,7 +9,7 @@ function ensureStore() {
 
     // defaults
     const s = st.settings;
-    if (s.debugMode === undefined) s.debugMode = true;     // like your "Mock data on emulator"
+    if (s.debugMode === undefined) s.debugMode = false;    // off by default: show honest "Offline", not mock data
     if (s.connectionMode === undefined) s.connectionMode = 'local'; // local/cloud (future)
     return st;
 }