Mirror a live Apple Watch run on a propped-up iPhone

Add an ephemeral live-run presence channel (separate from the durable
iCloud progress sync) so a propped-up iPhone can mirror the Watch's
Ready → work/rest → Finish flow in real time as the user swipes.

Watch drives, phone mirrors (read-only), so there's no echo loop:
- Watch's ExerciseProgressView broadcasts a LiveProgress frame on every
  phase transition (and an ended signal on leave) via sendMessage,
  reachable-only — throwaway presence, never written to iCloud.
- Timers ride as wall-clock anchors (Date kept native in the WC dict to
  preserve sub-second precision), so both devices count independently
  off shared start times and stay in lockstep without streaming ticks.
- Phone holds a transient LiveRunState; ContentView auto-presents a
  read-only LiveProgressMirrorView full-screen cover while a run is live.

Claude-Session: https://claude.ai/code/session_01SCv7zvGFcKy47KSTnTLxRe

Workouts/Connectivity/LiveRunState.swift

@@ -0,0 +1,47 @@
+//
+// LiveRunState.swift
+// Workouts
+//
+// Copyright 2025 Rouslan Zenetl. All Rights Reserved.
+//
+
+import Foundation
+import Observation
+
+/// Phone-side holder for the *ephemeral* live-run frames the watch broadcasts while it drives
+/// an exercise (see `LiveProgress`). The mirror UI observes this; nothing here is persisted.
+///
+/// Phase 1 is watch-drives / phone-mirrors, so this is read-only state fed by the connectivity
+/// bridge — the phone never sends back, which is why there's no echo loop to guard against yet.
+@Observable
+@MainActor
+final class LiveRunState {
+    /// The latest frame from the driving device, or `nil` when no run is being mirrored.
+    private(set) var current: LiveProgress?
+
+    /// A log the user manually closed the mirror for; suppressed until that run ends.
+    private var mutedLogID: String?
+
+    /// The frame to actually present, honoring a manual dismiss.
+    var presentable: LiveProgress? {
+        guard let c = current, c.logID != mutedLogID else { return nil }
+        return c
+    }
+
+    /// Apply an incoming frame, dropping a stale one for the same run.
+    func apply(_ frame: LiveProgress) {
+        if let c = current, c.logID == frame.logID, frame.version < c.version { return }
+        current = frame
+    }
+
+    /// The driver left the run (cancel / done / navigated away) — stop mirroring it.
+    func end(logID: String) {
+        if current?.logID == logID { current = nil }
+        if mutedLogID == logID { mutedLogID = nil }
+    }
+
+    /// The user dismissed the mirror; don't re-present this run until it ends.
+    func mute() {
+        mutedLogID = current?.logID
+    }
+}

Workouts/Connectivity/PhoneConnectivityBridge.swift

@@ -12,6 +12,7 @@ import WatchConnectivity
 final class PhoneConnectivityBridge: NSObject {
     private let container: ModelContainer
     private let syncEngine: SyncEngine
+    private let liveRunState: LiveRunState
     private var session: WCSession?
 
     /// Exclusive-edit lock published to the watch. While the phone has a workout's
@@ -24,9 +25,10 @@ final class PhoneConnectivityBridge: NSObject {
 
     private var context: ModelContext { container.mainContext }
 
-    init(container: ModelContainer, syncEngine: SyncEngine) {
+    init(container: ModelContainer, syncEngine: SyncEngine, liveRunState: LiveRunState) {
         self.container = container
         self.syncEngine = syncEngine
+        self.liveRunState = liveRunState
         super.init()
     }
 
@@ -90,6 +92,14 @@ final class PhoneConnectivityBridge: NSObject {
             if let doc = WCPayload.decodeWorkoutUpdate(dict) {
                 Task { @MainActor in await self.syncEngine.ingestFromWatch(doc) }
             }
+        case WCPayload.liveProgressType:
+            if let frame = WCPayload.decodeLiveProgress(dict) {
+                Task { @MainActor in self.liveRunState.apply(frame) }
+            }
+        case WCPayload.liveEndedType:
+            if let logID = dict[WCPayload.lpLogIDKey] as? String {
+                Task { @MainActor in self.liveRunState.end(logID: logID) }
+            }
         default:
             break
         }