@mmerterden/multi-agent-pipeline 8.6.2 → 10.0.6

package/pipeline/skills/shared/external/swiftdata/SKILL.md

@@ -6,18 +6,19 @@ description: "Implement, review, or improve data persistence using SwiftData. Us
 # SwiftData
 
 Persist, query, and manage structured data in iOS 26+ apps using SwiftData
-with Swift 6.2.
+with Swift 6.3.
 
 ## Contents
 
 - [Model Definition](#model-definition)
 - [ModelContainer Setup](#modelcontainer-setup)
+- [CloudKit Sync](#cloudkit-sync)
 - [CRUD Operations](#crud-operations)
-- [@Query in SwiftUI](#query-in-swiftui)
+- [`@Query in SwiftUI`](#query-in-swiftui)
 - [#Predicate](#predicate)
 - [FetchDescriptor](#fetchdescriptor)
 - [Schema Versioning and Migration](#schema-versioning-and-migration)
-- [Concurrency (@ModelActor)](#concurrency-modelactor)
+- [Concurrency (`@ModelActor`)](#concurrency-modelactor)
 - [SwiftUI Integration](#swiftui-integration)
 - [Common Mistakes](#common-mistakes)
 - [Review Checklist](#review-checklist)
@@ -47,15 +48,15 @@ class Trip {
 }
 ```
 
-**@Attribute options**: `.externalStorage`, `.unique`, `.spotlight`, `.allowsCloudEncryption`, `.preserveValueOnDeletion` (iOS 18+), `.ephemeral`, `.transformable(by:)`. Rename: `@Attribute(originalName: "old_name")`.
+**`@Attribute` options**: `.externalStorage`, `.unique`, `.spotlight`, `.allowsCloudEncryption`, `.preserveValueOnDeletion` (iOS 18+), `.ephemeral`, `.transformable(by:)`. Rename: `@Attribute(originalName: "old_name")`.
 
-**@Relationship**: `deleteRule:` `.cascade`/`.nullify`(default)/`.deny`/`.noAction`. Specify `inverse:` for reliable behavior. Unidirectional (iOS 18+): `inverse: nil`.
+**`@Relationship`**: `deleteRule:` `.cascade`/`.nullify`(default)/`.deny`/`.noAction`. Specify `inverse:` for reliable behavior. Unidirectional (iOS 18+): `inverse: nil`.
 
 **#Unique (iOS 18+)**: `#Unique<Person>([\.firstName, \.lastName])` -- compound uniqueness.
 
 **Inheritance (iOS 26+)**: `@Model class BusinessTrip: Trip { var company: String }`.
 
-Supported types: `Bool`, `Int`/`UInt` variants, `Float`, `Double`, `String`, `Date`, `Data`, `URL`, `UUID`, `Decimal`, `Array`, `Dictionary`, `Set`, `Codable` enums, `Codable` structs (composite, iOS 18+), relationships to `@Model` classes.
+Supported types: `Bool`, `Int`/`UInt` variants, `Float`, `Double`, `String`, `Date`, `Data`, `URL`, `UUID`, `Decimal`, `Array`, `Dictionary`, `Set`, `Codable` enums, `Codable` structs and other compatible `Codable` value types, and relationships to `@Model` classes.
 
 ## ModelContainer Setup
 
@@ -78,6 +79,28 @@ let container = try ModelContainer(for: Trip.self,
     configurations: ModelConfiguration(isStoredInMemoryOnly: true))
 ```
 
+## CloudKit Sync
+
+`ModelConfiguration(..., cloudKitDatabase:)` opts a SwiftData store into
+automatic CloudKit sync, but app entitlements still gate sync.
+
+For any SwiftData CloudKit setup or schema-review task, include a separate
+**Capabilities** verdict before schema findings:
+
+- **Capabilities**: Xcode target has the iCloud capability with CloudKit enabled
+  and the intended container selected, plus Background Modes > Remote
+  notifications. Without these entitlements, automatic sync is not fully
+  configured even if `cloudKitDatabase` is set.
+- **Schema compatibility**: no `@Attribute(.unique)` or `#Unique`;
+  relationships are optional, have explicit inverses where needed, and avoid
+  `.deny`; large `Data` uses `@Attribute(.externalStorage)`.
+- **Scalar attributes**: do not make every scalar optional just for CloudKit.
+  Keep required scalars nonoptional when initializers, defaults, or migrations
+  provide valid values.
+- **Schema rollout**: initialize the development schema only in nonproduction
+  builds, verify it in CloudKit Dashboard, promote before release, and treat
+  production changes as additive only.
+
 ## CRUD Operations
 
 ```swift
@@ -104,7 +127,7 @@ try modelContext.transaction {
 }
 ```
 
-## @Query in SwiftUI
+## `@Query` in SwiftUI
 
 ```swift
 struct TripListView: View {
@@ -147,7 +170,7 @@ struct RecentView: View {
 #Predicate<Trip> { $0.tags.contains { $0.name == "adventure" } }        // Collection
 ```
 
-Supported: `==`, `!=`, `<`, `<=`, `>`, `>=`, `&&`, `||`, `!`, `contains()`, `allSatisfy()`, `filter()`, `starts(with:)`, `localizedStandardContains()`, `caseInsensitiveCompare()`, arithmetic, ternary, optional chaining, nil coalescing, type casting. **Not supported**: flow control, nested declarations, arbitrary method calls.
+Supported: `==`, `!=`, `<`, `<=`, `>`, `>=`, `&&`, `||`, `!`, `contains()`, `allSatisfy()`, `filter()`, `starts(with:)`, `localizedStandardContains()`, `caseInsensitiveCompare()`, arithmetic, conditional expressions, optional chaining and binding, nil coalescing, type casting. **Avoid**: loops, nested declarations, mutations, and arbitrary unsupported method calls.
 
 ## FetchDescriptor
 
@@ -201,7 +224,7 @@ static let migrateV2toV3 = MigrationStage.custom(
 
 Lightweight handles: adding optional/defaulted properties, renaming (`originalName`), removing properties, adding model types.
 
-## Concurrency (@ModelActor)
+## Concurrency (`@ModelActor`)
 
 ```swift
 @ModelActor
@@ -257,11 +280,11 @@ struct DetailView: View {
 
 ## Common Mistakes
 
-**1. @Model on struct** -- Use class. `@Model` requires reference semantics.
+**1. `@Model` on struct** -- Use class. `@Model` requires reference semantics.
 
-**2. @Transient without default** -- Always provide default: `@Transient var x: Bool = false`.
+**2. `@Transient` without default** -- Always provide default: `@Transient var x: Bool = false`.
 
-**3. Missing .modelContainer** -- @Query returns empty without a container on the view hierarchy.
+**3. Missing .modelContainer** -- `@Query` returns empty without a container on the view hierarchy.
 
 **4. Passing model objects across actors:**
 ```swift
@@ -287,9 +310,9 @@ struct DetailView: View {
 // CORRECT: #Predicate<Trip> { $0.tags.contains { $0.name == "x" } }
 ```
 
-**8. No save in @ModelActor** -- Always call `try modelContext.save()` explicitly.
+**8. No save in `@ModelActor`** -- Always call `try modelContext.save()` explicitly.
 
-**9. ObservableObject with @Model** -- Never use `ObservableObject`/`@Published`. `@Model` generates `Observable`. Use `@Query` in views.
+**9. ObservableObject with `@Model`** -- Never use `ObservableObject`/`@Published`. `@Model` generates `Observable`. Use `@Query` in views.
 
 **10. Non-optional relationship without default:**
 ```swift
@@ -317,18 +340,16 @@ struct DetailView: View {
 - [ ] `PersistentIdentifier` used across actor boundaries
 - [ ] Schema changes have `VersionedSchema` + `SchemaMigrationPlan`
 - [ ] Large data uses `@Attribute(.externalStorage)`
-- [ ] CloudKit models use optionals and avoid unique constraints
+- [ ] CloudKit models avoid uniqueness, use optional relationships, avoid `.deny`, and do not blanket-optionalize scalars
+- [ ] CloudKit sync has iCloud + CloudKit, Remote notifications, and production schema rollout checked
 - [ ] Explicit `save()` in `@ModelActor` methods
 - [ ] Previews use `ModelConfiguration(isStoredInMemoryOnly: true)`
 - [ ] `@Model` classes accessed from SwiftUI views are on `@MainActor` via `@ModelActor` or MainActor isolation
 
 ## References
 
-- See `references/swiftdata-advanced.md` for custom data stores, history
-  tracking, CloudKit, Core Data coexistence, composite attributes,
-  model inheritance, undo/redo, and performance patterns.
-- See `references/swiftdata-queries.md` for @Query variants, FetchDescriptor
-  deep dive, sectioned queries, dynamic queries, and background fetch patterns.
-- See `references/core-data-coexistence.md` for standalone Core Data patterns
-  and Core Data to SwiftData migration strategies.
-
+- [references/swiftdata-advanced.md](references/swiftdata-advanced.md)  -  custom data stores, history tracking, CloudKit, composite attributes, model inheritance, undo/redo, performance
+- [references/swiftdata-queries.md](references/swiftdata-queries.md)  -  `@Query` variants, FetchDescriptor deep dive, sectioned queries, dynamic queries, background fetch
+- [references/core-data-coexistence.md](references/core-data-coexistence.md)  -  standalone Core Data patterns and Core Data to SwiftData migration
+- [references/predicate-pitfalls.md](references/predicate-pitfalls.md)  -  #Predicate runtime crashes, unsupported expressions, safe patterns
+- [references/indexing.md](references/indexing.md)  -  #Index macro, compound indexes, when to index, migration

package/pipeline/skills/shared/external/swiftdata/evals/evals.json

@@ -0,0 +1,47 @@
+{
+  "skill_name": "swiftdata",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Review this SwiftData CloudKit schema for an iOS 26 app: Profile uses @Attribute(.unique) on email, has a required @Relationship(deleteRule: .deny) owner, stores avatarData as Data, and a reviewer says every scalar property must become optional for sync. Give concise corrected guidance with a model sketch.",
+      "expected_output": "A review that flags SwiftData CloudKit schema incompatibilities, keeps scalar optionality precise, and covers CloudKit capability and schema rollout concerns.",
+      "files": [],
+      "assertions": [
+        "Flags @Attribute(.unique), #Unique, or unique constraints as incompatible with SwiftData CloudKit sync.",
+        "Flags the required relationship and recommends optional relationships for CloudKit-backed SwiftData models.",
+        "Flags the .deny delete rule as incompatible with SwiftData CloudKit sync.",
+        "Recommends @Attribute(.externalStorage) for large Data payloads such as image blobs.",
+        "Does not claim every scalar property must be optional.",
+        "Mentions iCloud CloudKit capability, Remote notifications background mode, or CloudKit schema promotion/additive rollout."
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "A SwiftData list is slow. It filters trips by destination, sorts by startDate, and uses #Predicate with Date.now directly plus a helper method call on the model. The draft fix adds indexes to every property and says adding indexes never needs migration testing. Review the plan and give corrected predicate and indexing guidance.",
+      "expected_output": "A review that fixes predicate capture and unsupported-call risks, recommends targeted #Index usage for frequent filters/sorts, and avoids unsourced migration guarantees.",
+      "files": [],
+      "assertions": [
+        "Recommends capturing changing values such as Date.now into a local let before building the predicate.",
+        "Warns against arbitrary unsupported helper method calls inside #Predicate and suggests stored properties or post-fetch filtering when needed.",
+        "Recommends targeted #Index declarations for frequently filtered or sorted properties rather than indexing every property.",
+        "Mentions compound indexes when a query filters and sorts by a repeated property combination.",
+        "Does not claim adding or removing indexes is always migration-free or never needs testing.",
+        "Suggests profiling or Instruments/Core Data diagnostics to verify query behavior."
+      ]
+    },
+    {
+      "id": 3,
+      "prompt": "A Core Data app wants to add SwiftData screens against the existing SQLite store while keeping the old stack alive. The model includes a Codable Address struct and a renamed persisted field. Explain how to route the work and what boundary guidance matters, without turning the answer into a full Core Data tutorial.",
+      "expected_output": "A boundary answer that treats Core Data + SwiftData coexistence or migration as SwiftData-owned, avoids unsupported Codable availability claims, and preserves store/schema alignment guidance.",
+      "files": [],
+      "assertions": [
+        "States that Core Data + SwiftData coexistence or migration should use the swiftdata skill.",
+        "Explains that SwiftData must point at the existing persistent store URL when sharing or migrating data.",
+        "Mentions matching entity names, property names, types, and relationships across the Core Data model and SwiftData @Model classes.",
+        "Mentions @Attribute(originalName:) or equivalent rename mapping for renamed persisted fields.",
+        "States that compatible Codable structs or enums can be stored as SwiftData model properties without asserting an unsupported iOS 18+ threshold for Codable value storage.",
+        "Avoids expanding into a standalone Core Data stack tutorial."
+      ]
+    }
+  ]
+}

package/pipeline/skills/shared/external/swiftdata/references/core-data-coexistence.md

@@ -290,7 +290,7 @@ struct MyApp: App {
 
 ## Migration from Core Data to SwiftData
 
-### Step 1: Map Core Data Entities to @Model Classes
+### Step 1: Map Core Data Entities to `@Model` Classes
 
 Create a `@Model` class for each Core Data entity. Property names and types
 must align with the `.xcdatamodeld` definition.
@@ -362,8 +362,8 @@ class Tag {
 | URI | URL |
 | Decimal | Decimal |
 | Transformable | Codable struct (composite, iOS 18+) |
-| To-one relationship | Optional reference to @Model |
-| To-many relationship | Array of @Model |
+| To-one relationship | Optional reference to `@Model` |
+| To-many relationship | Array of `@Model` |
 
 ### Step 2: Schema Versioning Considerations
 

package/pipeline/skills/shared/external/swiftdata/references/indexing.md

@@ -0,0 +1,75 @@
+# SwiftData Indexing
+
+Indexes speed up queries on frequently filtered or sorted properties.
+
+Docs: [Index macro](https://sosumi.ai/documentation/swiftdata/index(_:)-74ia2)
+
+## #Index (iOS 18+)
+
+### Single-Property Index
+
+```swift
+@Model
+class Trip {
+    @Attribute(.unique) var id: UUID
+    var destination: String
+    var startDate: Date
+    var isFavorite: Bool
+
+    init(destination: String, startDate: Date) {
+        self.id = UUID()
+        self.destination = destination
+        self.startDate = startDate
+        self.isFavorite = false
+    }
+}
+```
+
+Use `#Index` on the model to declare indexes:
+
+```swift
+@Model
+class Trip {
+    #Index<Trip>([\.destination], [\.startDate])
+    // ...
+}
+```
+
+This creates two single-column indexes: one on `destination` and one on `startDate`.
+
+### Compound Index
+
+```swift
+@Model
+class Trip {
+    #Index<Trip>([\.isFavorite, \.startDate])
+    // ...
+}
+```
+
+A compound index on `(isFavorite, startDate)` accelerates queries that filter on `isFavorite` and sort by `startDate`.
+
+## When to Index
+
+**Index when:**
+- A property appears in `#Predicate` filters on large collections (1000+ rows)
+- A property is used in `SortDescriptor` on large collections
+
+**Don't index when:**
+- The collection is small (< few hundred rows)
+- The property is rarely queried
+- The property changes very frequently (index maintenance cost)
+- The property has very low cardinality (e.g., a Boolean on a small table)
+- Another schema constraint or existing index already covers the query pattern,
+  unless profiling shows a separate index helps
+
+## Index and Migration
+
+Treat adding or removing an index as a schema change. Test it on representative
+stores and keep a `VersionedSchema` / `SchemaMigrationPlan` ready for any
+release where the aggregate schema changes exceed SwiftData's automatic
+migration support.
+
+## Verifying Index Usage
+
+Use Instruments > Core Data template to verify that queries use indexes. Look for "Full Table Scan" warnings on frequently executed fetches  -  these indicate a missing index.

package/pipeline/skills/shared/external/swiftdata/references/predicate-pitfalls.md

@@ -0,0 +1,54 @@
+# #Predicate Pitfalls
+
+Common runtime crashes and build errors when using `#Predicate` with SwiftData.
+
+## Unsupported Expressions
+
+`#Predicate` compiles Swift expressions into a query representation. Only a subset of Swift is supported. Unsupported expressions compile but crash at runtime.
+
+| Pattern | Crash? | Fix |
+| --- | --- | --- |
+| `$0.name.uppercased() == "PARIS"` | Runtime crash | Use `localizedStandardContains` or `caseInsensitiveCompare` |
+| `$0.name.count > 5` | Runtime crash | Store length in a separate property or filter after fetch |
+| `$0.tags.count == 0` | Runtime crash | Use `$0.tags.isEmpty` (iOS 17.4+) or a stored flag |
+| `$0.name.isEmpty` on optional String | Runtime crash on some OS versions | Use `$0.name == nil \|\| $0.name == ""` |
+| Custom computed property | Runtime crash | Only stored `@Attribute` properties work in predicates |
+| `Date.now` captured by value | Stale predicate | Create a `let now = Date()` before the predicate and capture it |
+| Enum raw value comparison | Runtime crash (pre-iOS 18) | Store the raw value as a separate property, or target iOS 18+ |
+| Loops, declarations, mutation, or switch-heavy control flow | Build error or runtime failure | Use boolean logic, ternary expressions, optional chaining, or optional binding patterns supported by Foundation `Predicate` |
+| Arbitrary method calls | Runtime crash | Only supported methods (see below) work |
+
+## Supported Operations
+
+**Comparisons:** `==`, `!=`, `<`, `<=`, `>`, `>=`
+
+**Logic:** `&&`, `||`, `!`
+
+**String:** `localizedStandardContains(_:)`, `contains(_:)`, `starts(with:)`, `caseInsensitiveCompare(_:)`
+
+**Collections:** `contains(where:)`, `allSatisfy(_:)`, `filter(_:)`, `.isEmpty`
+
+**Other:** optional chaining, nil coalescing (`??`), ternary (`? :`), arithmetic (`+`, `-`, `*`, `/`), type casting (`as?`, `is`)
+
+## Safe Pattern: Build Predicates Dynamically
+
+```swift
+func tripPredicate(searchText: String, favoritesOnly: Bool) -> Predicate<Trip> {
+    let now = Date()
+    return #Predicate<Trip> { trip in
+        (searchText.isEmpty || trip.destination.localizedStandardContains(searchText))
+        && (!favoritesOnly || trip.isFavorite)
+        && trip.startDate > now
+    }
+}
+```
+
+Capture all external values as `let` bindings outside the predicate closure. The predicate captures them by value at creation time.
+
+## Debugging Predicate Crashes
+
+When a predicate crashes at runtime with `SwiftData.PredicateError` or `NSInvalidArgumentException`:
+
+1. Simplify the predicate to a single clause and add clauses back one at a time
+2. Check each clause uses only supported operations on stored properties
+3. Test on the minimum deployment target  -  some operations were added in later iOS versions

package/pipeline/skills/shared/external/swiftdata/references/swiftdata-advanced.md

@@ -286,15 +286,16 @@ let localConfig = ModelConfiguration(
 1. Enable iCloud capability in Xcode.
 2. Add CloudKit entitlement (`com.apple.developer.icloud-services`).
 3. Configure a CloudKit container identifier.
-4. Use the container identifier in `ModelConfiguration`.
+4. Enable Background Modes > Remote notifications.
+5. Use the container identifier in `ModelConfiguration`.
 
 ### CloudKit-Compatible Model Design
 
 ```swift
 @Model
 class SyncedNote {
-    // Use optional properties -- records may arrive partially from other devices
-    var title: String?
+    // Keep required scalars nonoptional when defaults/initializers support them
+    var title: String = ""
     var body: String?
 
     // Encrypt sensitive fields in CloudKit
@@ -318,12 +319,14 @@ class SyncedNote {
 - **Unique constraints**: CloudKit does not enforce uniqueness server-side.
   Avoid `@Attribute(.unique)` and `#Unique` on CloudKit-synced models. Use
   `cloudKitDatabase: .none` for local-only stores that need uniqueness.
-- **Optional properties**: Prefer optionals for all properties on synced models.
-  Records from other devices may arrive with missing fields.
-- **Delete rules**: `.cascade` may cause unexpected deletions when sync delivers
-  partial data. Test thoroughly.
-- **Schema changes**: CloudKit schemas are additive-only in production. New
-  fields are fine; removing or renaming fields requires careful migration.
+- **Relationships**: CloudKit requires optional relationships. Do not make every
+  scalar optional just for CloudKit; keep required scalars when defaults,
+  initializers, or migrations provide valid values.
+- **Delete rules**: `.deny` is unsupported for CloudKit sync; enforce that
+  invariant in app logic if needed.
+- **Schema changes**: Initialize and verify the development schema in
+  nonproduction builds, promote it before release, and treat production changes
+  as additive-only.
 
 ### Multiple Stores: Local + Synced
 
@@ -482,7 +485,8 @@ let trips = try modelContext.fetch(descriptor)
 - Use `fetchCount` when only the count is needed.
 - Use `fetchIdentifiers` when only IDs are needed.
 - Use `propertiesToFetch` to limit loaded data.
-- Use `@Attribute(.externalStorage)` for `Data` properties over ~100KB.
+- Use `@Attribute(.externalStorage)` for large `Data` payloads such as images
+  and blobs.
 - Disable `includePendingChanges` if unsaved data is not needed in results.
 - Call `modelContext.save()` periodically during large imports to flush memory.
 

package/pipeline/skills/shared/external/swiftdata/references/swiftdata-queries.md

@@ -1,6 +1,6 @@
 # SwiftData Queries Reference
 
-Deep reference for all @Query initializer variants, FetchDescriptor options,
+Deep reference for all `@Query` initializer variants, FetchDescriptor options,
 sort descriptors, sectioned queries, dynamic query switching, background fetch
 patterns, and aggregate queries.
 
@@ -8,16 +8,16 @@ patterns, and aggregate queries.
 
 ## Contents
 
-- [@Query Initializer Variants](#query-initializer-variants)
+- [`@Query Initializer Variants`](#query-initializer-variants)
 - [FetchDescriptor Deep Dive](#fetchdescriptor-deep-dive)
 - [Complex Sort Descriptors](#complex-sort-descriptors)
 - [Sectioned Queries Pattern](#sectioned-queries-pattern)
 - [Dynamic Query Switching](#dynamic-query-switching)
-- [Background Fetch Patterns with @ModelActor](#background-fetch-patterns-with-modelactor)
+- [Background Fetch Patterns with `@ModelActor`](#background-fetch-patterns-with-modelactor)
 - [Aggregate Queries](#aggregate-queries)
 - [Enumerate for Large Datasets](#enumerate-for-large-datasets)
 
-## @Query Initializer Variants
+## `@Query` Initializer Variants
 
 `@Query` is a SwiftUI property wrapper (`DynamicProperty`) that automatically
 fetches and observes persistent model data. All variants are `@MainActor`.
@@ -463,7 +463,7 @@ struct AdvancedTripList: View {
 
 ---
 
-## Background Fetch Patterns with @ModelActor
+## Background Fetch Patterns with `@ModelActor`
 
 ### Basic Background Fetch
 

package/pipeline/skills/shared/external/swiftdata-pro/SKILL.md

@@ -54,7 +54,7 @@ var sights: [Sight]
 @Relationship(deleteRule: .cascade, inverse: \Sight.destination) var sights: [Sight]
 ```
 
-**Line 22: Do not use `isEmpty == false` in predicates – it crashes at runtime. Use `!` instead.**
+**Line 22: Do not use `isEmpty == false` in predicates - it crashes at runtime. Use `!` instead.**
 
 ```swift
 // Before
@@ -87,7 +87,7 @@ class DestinationStore {
 ### Summary
 
 1. **Data loss (high):** Missing delete rule on line 8 of Destination.swift means sights will be orphaned when a destination is deleted.
-2. **Crash (high):** `isEmpty == false` on line 22 will crash at runtime – use `!isEmpty` instead.
+2. **Crash (high):** `isEmpty == false` on line 22 will crash at runtime - use `!isEmpty` instead.
 3. **Incorrect behavior (high):** `@Query` on line 5 of DestinationListView.swift only works inside SwiftUI views.
 
 End of example.

package/pipeline/skills/shared/external/swiftdata-pro/references/class-inheritance.md

@@ -42,7 +42,7 @@ Notice how both the parent and child classes must use the `@Model` macro.
 
 **Important:** When using a 26 release or later as minimum deployment target, we must still mark subclassed models with `@available`. However, we do *not* need to do the same with code using that model, because Xcode can match the deployment target and the model availability.
 
-When providing the schemas as part of model container creation, make sure to list both the parent class and its child classes – SwiftData is *not* able to infer the connection by itself.
+When providing the schemas as part of model container creation, make sure to list both the parent class and its child classes - SwiftData is *not* able to infer the connection by itself.
 
 If you create a relationship to a model that has subclasses, the relationship might contain the parent class or any of its subclasses.
 
@@ -58,7 +58,7 @@ For example, the `articles` array here might contain `Article`, `Tutorial`, or `
 }
 ```
 
-If only one subclass is supported, it should be written specifically. If several subclasses but not all should be in the relationship, you might have no choice but to add another level of subclasses: BaseClass -> Subclass -> Subsubclass. However, this is not a good idea – deep subclassing is generally frowned upon, and will increase complexity in migrations.
+If only one subclass is supported, it should be written specifically. If several subclasses but not all should be in the relationship, you might have no choice but to add another level of subclasses: BaseClass -> Subclass -> Subsubclass. However, this is not a good idea - deep subclassing is generally frowned upon, and will increase complexity in migrations.
 
 
 ## Filtering with subclasses

package/pipeline/skills/shared/external/swiftdata-pro/references/cloudkit.md

@@ -7,4 +7,4 @@
 - All relationships must be marked optional.
 - Indexes and subclasses are supported in CloudKit, as long as the correct OS release is used.
 
-Keep in mind that CloudKit is designed for *eventual consistency* – any SwiftData code written with CloudKit support must be able to function if data has yet to synchronize.
+Keep in mind that CloudKit is designed for *eventual consistency* - any SwiftData code written with CloudKit support must be able to function if data has yet to synchronize.

package/pipeline/skills/shared/external/swiftdata-pro/references/core-rules.md

@@ -4,17 +4,17 @@
 - There is no need to check `modelContext.hasChanges` before saving; just call `save()` directly.
 - `ModelContext` and model instances must never cross actor boundaries. Model containers and persistent identifiers *are* sendable, so if you need a model instance to be transferred across actors you should send its identifier and re-fetch in the destination context. For more help with Swift concurrency, suggest the [Swift Concurrency Pro agent skill](https://github.com/twostraws/swift-concurrency-agent-skill).
 - When using `@Relationship` to define a relationship from one model to another, place the macro on one side of the relationship only. Trying to use it on both sides causes a circular reference.
-- Persistent identifiers are temporary before they are saved for the first time. Temporary IDs start with a lowercase “t”, and a model will be given a new ID after it is saved for the first time. As a result, you must save an object before relying on its ID.
+- Persistent identifiers are temporary before they are saved for the first time. Temporary IDs start with a lowercase "t", and a model will be given a new ID after it is saved for the first time. As a result, you must save an object before relying on its ID.
 - Do not attempt to use the property name `description` in any `@Model` class; it is explicitly disallowed.
 - Do not attempt to add property observers to `@Model` classes; they will be quietly ignored.
-- `@Attribute(.externalStorage)` is a *suggestion*, not a *requirement*, and only applies to properties of type `Data` – SwiftData will do what it thinks is best.
-- `@Transient` properties are not persisted, and must have a default value. They reset to that default when the object is fetched from the store. If the value is derived from other stored properties, using a computed property is usually a better idea – use `@Transient` only if the value is expensive to produce.
+- `@Attribute(.externalStorage)` is a *suggestion*, not a *requirement*, and only applies to properties of type `Data` - SwiftData will do what it thinks is best.
+- `@Transient` properties are not persisted, and must have a default value. They reset to that default when the object is fetched from the store. If the value is derived from other stored properties, using a computed property is usually a better idea - use `@Transient` only if the value is expensive to produce.
 - It is nearly always a good idea to have a specific migration schema in place, even if the project is only dealing with lightweight migrations.
 - It is nearly always a good idea to have an explicit delete rule in place for relationships. This is most commonly `@Relationship(deleteRule: .cascade)`, but others are available. The default is `.nullify`, which sets the related model's reference to nil when the parent is deleted. This can leave orphaned objects or crash if the property is non-optional.
 - Do not attempt to use `@Query` outside of SwiftUI views; it is designed to work specifically *inside* views, and will not operate correctly outside. For more help with SwiftUI, suggest the [SwiftUI Pro agent skill](https://github.com/twostraws/swiftui-agent-skill).
 - If you only need the number of items matching a query, consider `ModelContext.fetchCount()` with a fetch descriptor. This will *not* live update if the data changes unless something else triggers the update, such as `@Query`, so it should be used carefully.
-- When using `FetchDescriptor`, it may sometimes be beneficial to set the `relationshipKeyPathsForPrefetching` property. It’s an empty array by default, but if you know certain relationships will be used it’s more efficient to fetch them upfront.
+- When using `FetchDescriptor`, it may sometimes be beneficial to set the `relationshipKeyPathsForPrefetching` property. It's an empty array by default, but if you know certain relationships will be used it's more efficient to fetch them upfront.
 - Similarly, you should consider setting `propertiesToFetch` so that only properties that are used are actually fetched. (It fetches all properties by default.)
-- SwiftData frequently gets inverse relationships wrong, so it’s almost always a good idea to be explicit with the `@Relationship` macro by specifying the exact inverse relationship.
+- SwiftData frequently gets inverse relationships wrong, so it's almost always a good idea to be explicit with the `@Relationship` macro by specifying the exact inverse relationship.
 - Do not write `#Unique` more than once per model; you can only have one, placed inside the model class. If you need multiple uniqueness constraints, pass them as separate key path arrays in a single `#Unique`, e.g. `#Unique<Foo>([\.email], [\.username])`.
-- Enum properties stored in a model must conform to `Codable`. Some agents will insist that enums with associated values are not supported, but this is wrong – they work just fine.
+- Enum properties stored in a model must conform to `Codable`. Some agents will insist that enums with associated values are not supported, but this is wrong - they work just fine.