Workouts 2.0: re-base persistence on iCloud Drive documents

Replace Core Data + NSPersistentCloudKitContainer + App-Group store +
WatchConnectivity dictionary sync with the QuickRabbit iCloud-documents
architecture:

- iCloud Drive JSON documents are the sole source of truth (one file per
  aggregate: Splits/<ULID>.json, Workouts/YYYY/MM/<ULID>.json), with a
  rebuildable SwiftData cache populated only by an NSMetadataQuery observer
  and a connect-time reconcile. Soft-delete tombstones; hard iCloud gate.
- Shared model layer (ULID, Codable *Documents + stateless mappers, @Model
  cache entities, SwiftData container) compiled into both targets.
- New iPhone<->Watch bridge over WatchConnectivity keyed by ULIDs; the phone
  is the sole writer of iCloud Drive, the watch round-trips documents.
- AppServices DI + iCloud-required root gate; Swift 6 strict concurrency.
- Starter splits generated on demand from the bundled YAML catalogs.
- Migrate to XcodeGen (project.yml), iOS 26 / watchOS 26; CloudDocuments
  entitlement (drop CloudKit/App Group/aps-environment).
- Duration stored as Int seconds (was a Date epoch hack); fix workout
  end-on-create, undismissable delete dialog, toolbar-hiding nav stacks,
  and the Settings placeholder.
- Add README/CHANGELOG/LICENSE, .gitignore, refreshed REQUIREMENTS, and the
  Scripts/ TestFlight pipeline (release.sh + ASC API scripts).

MARKETING_VERSION 2.0.

Workouts/Views/WorkoutLogs/PlanEditView.swift

@@ -6,13 +6,15 @@
 //
 
 import SwiftUI
-import CoreData
+import SwiftData
 
 struct PlanEditView: View {
-    @Environment(\.managedObjectContext) private var viewContext
+    @Environment(SyncEngine.self) private var sync
+    @Environment(\.modelContext) private var modelContext
     @Environment(\.dismiss) private var dismiss
 
-    @ObservedObject var workoutLog: WorkoutLog
+    let workout: Workout
+    let logID: String
 
     @State private var sets: Int = 3
     @State private var reps: Int = 12
@@ -21,11 +23,6 @@ struct PlanEditView: View {
     @State private var durationSeconds: Int = 0
     @State private var selectedLoadType: LoadType = .weight
 
-    // Find the corresponding exercise in the split for syncing changes
-    private var correspondingExercise: Exercise? {
-        workoutLog.workout?.split?.exercisesArray.first { $0.name == workoutLog.exerciseName }
-    }
-
     var body: some View {
         NavigationStack {
             Form {
@@ -135,34 +132,54 @@ struct PlanEditView: View {
                 }
             }
             .onAppear {
-                sets = Int(workoutLog.sets)
-                reps = Int(workoutLog.reps)
-                weight = Int(workoutLog.weight)
-                durationMinutes = workoutLog.durationMinutes
-                durationSeconds = workoutLog.durationSeconds
-                selectedLoadType = workoutLog.loadTypeEnum
+                if let log = WorkoutDocument(from: workout).logs.first(where: { $0.id == logID }) {
+                    sets = log.sets
+                    reps = log.reps
+                    weight = log.weight
+                    durationMinutes = log.durationSeconds / 60
+                    durationSeconds = log.durationSeconds % 60
+                    selectedLoadType = LoadType(rawValue: log.loadType) ?? .weight
+                }
             }
         }
     }
 
     private func saveChanges() {
-        workoutLog.sets = Int32(sets)
-        workoutLog.reps = Int32(reps)
-        workoutLog.weight = Int32(weight)
-        workoutLog.durationMinutes = durationMinutes
-        workoutLog.durationSeconds = durationSeconds
-        workoutLog.loadTypeEnum = selectedLoadType
+        let totalSeconds = durationMinutes * 60 + durationSeconds
 
-        // Sync to corresponding exercise
-        if let exercise = correspondingExercise {
-            exercise.sets = workoutLog.sets
-            exercise.reps = workoutLog.reps
-            exercise.weight = workoutLog.weight
-            exercise.loadType = workoutLog.loadType
-            exercise.duration = workoutLog.duration
+        // 1) Update the log within the parent workout document.
+        var doc = WorkoutDocument(from: workout)
+        guard let i = doc.logs.firstIndex(where: { $0.id == logID }) else { return }
+        doc.logs[i].sets = sets
+        doc.logs[i].reps = reps
+        doc.logs[i].weight = weight
+        doc.logs[i].durationSeconds = totalSeconds
+        doc.logs[i].loadType = selectedLoadType.rawValue
+        doc.updatedAt = Date()
+        let exerciseName = doc.logs[i].exerciseName
+        let workoutDoc = doc
+
+        // 2) Mirror the plan onto the matching exercise in the split template.
+        var splitDoc: SplitDocument?
+        if let splitID = doc.splitID,
+           let split = CacheMapper.fetchSplit(id: splitID, in: modelContext) {
+            var sDoc = SplitDocument(from: split)
+            if let ei = sDoc.exercises.firstIndex(where: { $0.name == exerciseName }) {
+                sDoc.exercises[ei].sets = sets
+                sDoc.exercises[ei].reps = reps
+                sDoc.exercises[ei].weight = weight
+                sDoc.exercises[ei].durationSeconds = totalSeconds
+                sDoc.exercises[ei].loadType = selectedLoadType.rawValue
+                sDoc.updatedAt = Date()
+                splitDoc = sDoc
+            }
         }
 
-        try? viewContext.save()
-        WatchConnectivityManager.shared.syncAllData()
+        Task {
+            await sync.save(workout: workoutDoc)
+            if let splitDoc {
+                await sync.save(split: splitDoc)
+            }
+        }
     }
 }