La montre enregistre enfin sa trace GPS

La cible watchOS ne contenait pas une ligne de localisation : ni
CLLocationManager, ni HKWorkoutRouteBuilder, et aucune clé NSLocation dans son
Info.plist. Tant que les séances partaient de l'app Exercice d'Apple, c'est
elle qui écrivait la trace et CoachHealthRoute la relisait après coup. Dès
qu'une séance démarre depuis CoachWatch, plus personne ne l'écrit : la sortie
n'aurait ni carte, ni parcours dans Santé.

Le filtrage vit dans `RouteFilter`, en Foundation pur, donc testable ici :
rejet des points imprécis (> 50 m, seuil de l'exemple Apple), des sauts
impossibles, des doublons et des points arrivés dans le désordre, puis cumul de
la distance (haversine) et du dénivelé.

Le dénivelé a demandé deux passes. L'hystérésis seule laissait passer 297 m de
D+ sur un parcours PLAT : une oscillation d'amplitude égale au seuil est
comptée à chaque alternance, ce qui est inhérent à tout seuil. D'où un lissage
préalable, qui annule le bruit alternant. Contrepartie assumée et testée : une
pointe franchie en quelques points est écrêtée, donc sous-comptée — sans
conséquence, le D+ qui fait foi restant celui, barométrique, qu'Apple écrit
dans les métadonnées de la séance.

Quatre pièges documentés, tous traités dans le code :
- `allowsBackgroundLocationUpdates` sans `UIBackgroundModes` = `location`
  TERMINE l'app. Un garde-fou vérifie le plist avant d'armer le drapeau.
- Ne jamais demander « Always » sur watchOS : Apple décrit ce prompt comme
  « mostly a placeholder » et le parcours comme un comportement indéfini.
- Interdit de relancer la localisation depuis l'arrière-plan : la pause garde
  le flux ouvert et ignore les points, au lieu de couper le manager.
- Le CPU tue le GPS — d'où l'insertion des points par lots et la trace
  d'affichage bornée à 1500 points.

Corrigé après lecture de la doc : `finishRoute` s'appelle APRÈS `finishWorkout`
et reçoit le workout pour s'y associer. J'avais écrit l'inverse, avec nil, ce
qui aurait perdu l'association à chaque sortie. Et `finishWorkout()` rend nil
sans erreur quand la montre est verrouillée : on sauvegarde alors la trace sans
association plutôt que de la jeter.

15 tests, dont 4 vérifiés rouges en désactivant le lissage. Les trois fichiers
sont déclarés dans la cible CoachWatch (pbxproj sauvegardé en .bak-outdoor) :
aucun « Add Files » à faire sur le Mac.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

ios/App/CoachWatch/WorkoutManager.swift

@@ -49,8 +49,18 @@ final class WorkoutManager: NSObject, ObservableObject {
         // ne la produit pas, les stats restent vides : `ingest` retombe alors
         // sur la vitesse moyenne dérivée de la distance.
         let speedType = Self.speedType(for: activityType)
-        let read: Set<HKObjectType> = [hr, energy, distanceType, speedType]
-        let share: Set<HKSampleType> = [HKQuantityType.workoutType(), hr, energy, distanceType]
+        // La trace exige d'être demandée en lecture ET en écriture — Apple :
+        // « you must request permission to read and share both HKWorkout and
+        // HKWorkoutRoute samples ». Sans elle, `finishRoute` échoue et la
+        // sortie n'a pas de parcours.
+        let route = HKSeriesType.workoutRoute()
+        let outdoor = (locationType == .outdoor)
+        var read: Set<HKObjectType> = [hr, energy, distanceType, speedType]
+        var share: Set<HKSampleType> = [HKQuantityType.workoutType(), hr, energy, distanceType]
+        if outdoor {
+            read.insert(route)
+            share.insert(route)
+        }
 
         do {
             try await healthStore.requestAuthorization(toShare: share, read: read)
@@ -66,6 +76,12 @@ final class WorkoutManager: NSObject, ObservableObject {
             return
         }
 
+        // Demandée ici, donc au premier plan : watchOS n'affiche pas la feuille
+        // d'autorisation depuis l'arrière-plan. Volontairement « quand
+        // l'app est active » et jamais « toujours » — sur watchOS ce dernier
+        // mène à un parcours d'autorisation qui boucle.
+        if outdoor { LocationTracker.shared.requestAuthorization() }
+
         let config = HKWorkoutConfiguration()
         config.activityType = activityType
         config.locationType = locationType
@@ -87,6 +103,19 @@ final class WorkoutManager: NSObject, ObservableObject {
             isRunning = true
             statusMessage = nil
             workoutLog.info("beginCollection OK, isRunning=true")
+
+            // GPS uniquement en extérieur : en salle il ne ferait que vider la
+            // batterie pour une trace immobile.
+            if outdoor {
+                // Apple déconseille d'instancier un HKWorkoutRouteBuilder
+                // directement : celui du builder de séance associe la trace.
+                let routeBuilder = builder.seriesBuilder(for: HKSeriesType.workoutRoute())
+                    as? HKWorkoutRouteBuilder
+                if routeBuilder == nil {
+                    workoutLog.error("seriesBuilder n'a pas rendu un HKWorkoutRouteBuilder")
+                }
+                LocationTracker.shared.start(activity: activityType, routeBuilder: routeBuilder)
+            }
         } catch {
             self.session = nil
             self.builder = nil
@@ -264,14 +293,26 @@ extension WorkoutManager: HKWorkoutSessionDelegate {
             let paused = (toState == .paused)
             Task { @MainActor in
                 self.isPaused = paused
+                // Le flux GPS reste ouvert pendant la pause : watchOS interdit
+                // de redémarrer la localisation depuis l'arrière-plan, donc on
+                // ignore les points au lieu de couper le manager.
+                LocationTracker.shared.setPaused(paused)
                 ConnectivityManager.shared.sendPaused(paused)
             }
         }
         guard toState == .ended else { return }
         let builder = workoutSession.associatedWorkoutBuilder()
-        Task {
+        Task { @MainActor in
+            // Ordre imposé par Apple : couper le GPS, clore la collecte,
+            // sauvegarder la séance, et SEULEMENT ensuite clore la trace en
+            // l'associant au workout obtenu.
+            LocationTracker.shared.stopTracking()
             try? await builder.endCollection(at: date)
-            _ = try? await builder.finishWorkout()
+            // ⚠️ `finishWorkout()` rend `nil` SANS erreur quand la montre est
+            // verrouillée : ce n'est pas un échec. On poursuit avec `nil`, la
+            // trace sera sauvegardée sans association plutôt que perdue.
+            let workout = try? await builder.finishWorkout()
+            await LocationTracker.shared.finishRoute(with: workout)
         }
         Task { @MainActor in
             self.isRunning = false