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
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/phone-android/app/src/main/AndroidManifest.xml b/apps/phone-android/app/src/main/AndroidManifest.xml
index 53e9280..eb7a5d7 100644
--- a/apps/phone-android/app/src/main/AndroidManifest.xml
+++ b/apps/phone-android/app/src/main/AndroidManifest.xml
@@ -9,6 +9,13 @@
     <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.
+         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_DATA_SYNC" />
+    <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 +47,11 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+
+        <service
+            android:name=".p2p.HaBridgeService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync" />
     </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/bridge/EntityMapper.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/bridge/EntityMapper.kt
index d85fa24..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
@@ -6,40 +6,66 @@ 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? {
+        // 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 {
             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)
+        }
     }
 
-    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),
@@ -48,7 +74,13 @@ 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()
+        }
     }
 
     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..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
@@ -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
 
 /**
@@ -16,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)) {
@@ -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..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
@@ -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
@@ -14,31 +16,41 @@ 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(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 }
     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. */
-    suspend fun getStates(): Result<List<HaState>> =
-        call("GET", "/api/states").mapCatching { json.decodeFromString<List<HaState>>(it) }
+    /**
+     * 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.
+     */
+    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()
+            }
+        }
 
     /** 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 { }
     }
@@ -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/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/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/Messages.kt b/apps/phone-android/app/src/main/java/ru/gentslava/homeassistant/companion/p2p/Messages.kt
index 3be374d..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).
@@ -37,7 +38,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(),
 )
 
@@ -85,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..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
@@ -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
@@ -39,8 +40,21 @@ 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
 
+    @Volatile
+    private var registered = false
+
+    @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)
@@ -50,13 +64,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)
@@ -65,26 +81,60 @@ 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 ${retryDelayMs}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
+                            retryDelayMs = RETRY_MIN_MS // connected — reset backoff
+                            Log.i(TAG, "P2P receiver registered on ${connected.name}")
+                        }
+                        .addOnFailureListener {
+                            registered = false
+                            logErr("registerReceiver", it)
+                            scheduleRetry()
+                        }
+                }
+            }
+            .addOnFailureListener {
+                logErr("getBondedDevices", it)
+                scheduleRetry()
             }
-            .addOnFailureListener { logErr("getBondedDevices", it) }
+    }
+
+    private fun scheduleRetry() {
+        if (!running) return
+        val d = retryDelayMs
+        retryDelayMs = (retryDelayMs * 2).coerceAtMost(RETRY_MAX_MS) // exponential backoff
+        scope.launch {
+            delay(d)
+            ensureRegistered()
+        }
     }
 
     private fun sendRaw(json: String) {
@@ -108,6 +158,8 @@ class WearEngineP2pService(
     private companion object {
         const val TAG = "WearEngineP2p"
         const val SEND_SUCCESS = 207
+        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).
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/EntityMapperTest.kt b/apps/phone-android/app/src/test/java/ru/gentslava/homeassistant/companion/EntityMapperTest.kt
index f917024..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
@@ -17,36 +17,102 @@ 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 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() {
@@ -58,7 +124,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/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"))
+    }
+}
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\""))
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/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/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/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/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..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';
 
@@ -59,9 +58,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 +77,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 +115,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..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';
 
@@ -63,6 +62,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 +100,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-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-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/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/connection.png b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/connection.png
new file mode 100644
index 0000000..ce878dd
Binary files /dev/null and b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/connection.png differ
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 0000000..d1c490d
Binary files /dev/null and b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/cover.png differ
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 0000000..8839603
Binary files /dev/null and b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/debug.png differ
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 0000000..00109a8
Binary files /dev/null and b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/info.png differ
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 0000000..5729c13
Binary files /dev/null and b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/scene.png differ
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 0000000..e95fafe
Binary files /dev/null and b/apps/watch-lite/entry/src/main/js/MainAbility/common/icons/server.png differ
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);
-    }
-}
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..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) : '—');
@@ -74,8 +79,38 @@ 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 || '');
 
+        // 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() }];
@@ -108,6 +143,32 @@ 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;
+        }
+
         this.actions = [{ id: 'toggle', name: 'Toggle', state: 'Call service', iconSrc: ICON_POWER, color: actionColorGray() }];
     },
 
@@ -117,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)
@@ -129,12 +194,17 @@ 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
         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);
@@ -158,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
         };
     },
 
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..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
@@ -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: [] }
     ];
 }
 
@@ -33,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;
 }
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/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..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).
 
@@ -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 —
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