@mmerterden/multi-agent-pipeline 20.36.0 → 20.37.1

package/pipeline/skills/shared/external/swift-concurrency/references/swift-6-2-additions.md

@@ -0,0 +1,18 @@
+# Other Swift 6.2 Additions
+
+Smaller Swift 6.2 additions next to the approachable-concurrency defaults. Each is covered in more depth in
+concurrency-patterns.md.
+
+- `Task.immediate` (SE-0472) runs synchronously on the current actor until its
+  first suspension instead of being enqueued; `Task.immediateDetached` adds
+  detached semantics. Use it where the enqueue delay is visible to the user,
+  for example `Task.immediate { await search.apply(query) }`.
+- `Observations { }` (SE-0475) turns reads of `@Observable` properties into an
+  `AsyncSequence` with transactional updates:
+  `for await elapsed in Observations({ player.elapsed }) { scrubber.move(to: elapsed) }`.
+- Isolated conformances let a main-actor type conform to a protocol whose
+  requirements it can only meet on the main actor. The compiler allows the
+  conformance only where that isolation holds.
+- SE-0473 adds `.epoch` to `ContinuousClock` and `SuspendingClock`, but the
+  iOS 26.4 SDK does not ship it yet ("value of type 'ContinuousClock' has no
+  member 'epoch'"); check your SDK before relying on it.

package/pipeline/skills/shared/external/swift-formatstyle/SKILL.md

@@ -107,46 +107,14 @@ passRate.formatted(.percent)                                     // "42%"
 
 Build exactly the fields you want; the locale decides order and punctuation.
 
-```swift
-let launch = Date.now
-launch.formatted(.dateTime.day().month().year())            // "Mar 3, 2026" (order comes from the locale)
-launch.formatted(.dateTime.minute().hour())                 // "4:05 PM"
-let spelledOut = Date.FormatStyle.dateTime.day().month(.wide).weekday(.wide)
-launch.formatted(spelledOut)                                // "Tuesday, March 3"
-```
-
-Predefined combinations:
-
-```swift
-launch.formatted(date: .long, time: .shortened)     // "March 3, 2026 at 4:05 PM"
-launch.formatted(date: .abbreviated, time: .omitted) // "Mar 3, 2026"
-launch.formatted(.iso8601)                           // "2026-03-03T13:05:00Z"
-```
-
-Relative to now:
-
-```swift
-let dayBefore = Date.now.addingTimeInterval(-86_400)
-dayBefore.formatted(.relative(presentation: .named))    // "yesterday"
-let numericAgo = Date.RelativeFormatStyle(presentation: .numeric)
-dayBefore.formatted(numericAgo)                         // "1 day ago"
-```
-
-Ranges and countdowns:
-
-```swift
-let slot = launch..<launch.addingTimeInterval(5_400)
-let meetingSpan = Date.IntervalFormatStyle().day().month().minute().hour()
-slot.formatted(meetingSpan)   // "Mar 3, 4:05 - 5:35 PM" (ICU prints an en dash)
-
-let untilDeparture = Date.now..<Date.now.addingTimeInterval(190_800)
-let countdown = Date.ComponentsFormatStyle(style: .wide, fields: [.hour, .day])
-untilDeparture.formatted(countdown)   // "2 days, 5 hours"
-```
+The reference shows predefined combinations, relative-to-now formatting, and
+ranges and countdowns.
 
 Related types: `Date.FormatStyle`, `Date.RelativeFormatStyle`,
 `Date.IntervalFormatStyle`, `Date.ComponentsFormatStyle`.
 
+Code for this section: [FormatStyle examples](references/formatstyle-examples.md).
+
 ### Relative to a chosen reference (iOS 18+)
 
 `Date.AnchoredRelativeFormatStyle` describes one fixed date, the anchor,
@@ -166,28 +134,10 @@ style.format(meetup.addingTimeInterval(-3_600))   // "in 1 hour"
 A `Duration` (iOS 16+) can be shown as a clock reading with
 `Duration.TimeFormatStyle` or as labeled units with `Duration.UnitsFormatStyle`.
 
-```swift
-let ride = Duration.seconds(7_384)                  // 2 h 3 min 4 s
-ride.formatted(.time(pattern: .hourMinuteSecond))   // "2:03:04"
-ride.formatted(.time(pattern: .hourMinute))         // "2:03"
-ride.formatted(.time(pattern: .minuteSecond))       // "123:04" (minutes are not wrapped into hours)
-
-let stopwatch = Duration.TimeFormatStyle.Pattern.minuteSecond(padMinuteToLength: 2, fractionalSecondsLength: 2)
-Duration.milliseconds(3_750).formatted(.time(pattern: stopwatch))   // "00:03.75"
-```
-
-```swift
-let clock: Set<Duration.UnitsFormatStyle.Unit> = [.hours, .minutes, .seconds]
-ride.formatted(.units(allowed: clock, width: .abbreviated))                      // "2 hr, 3 min, 4 sec"
-ride.formatted(.units(allowed: clock, width: .wide, maximumUnitCount: 1))        // "2 hours"
-
-let rest = Duration.seconds(150)
-rest.formatted(.units(allowed: [.minutes, .seconds], width: .wide))     // "2 minutes, 30 seconds"
-rest.formatted(.units(allowed: [.minutes, .seconds], width: .narrow))   // "2m 30s"
-```
-
 `maximumUnitCount` caps how many units appear.
 
+Code for this section: [FormatStyle examples](references/formatstyle-examples.md).
+
 ## Measurements
 
 ```swift
@@ -297,33 +247,13 @@ Conform to `FormatStyle` and implement `format(_:)`. Add `ParseableFormatStyle`
 if the text must also be read back. `FormatStyle` inherits `Codable` and
 `Hashable`, so keep stored properties simple value types.
 
-```swift
-struct CompactCountStyle: FormatStyle {
-    func format(_ count: Int) -> String {
-        switch abs(count) {
-        case 1_000_000...: scaled(count, by: 1_000_000) + "M"
-        case 1_000...:     scaled(count, by: 1_000) + "K"
-        default:           count.formatted()
-        }
-    }
-
-    private func scaled(_ count: Int, by divisor: Double) -> String {
-        (Double(count) / divisor).formatted(.number.precision(.fractionLength(0...1)))
-    }
-}
-
-extension FormatStyle where Self == CompactCountStyle {
-    static var compactCount: CompactCountStyle { CompactCountStyle() }
-}
-
-let followers = 48_700.formatted(.compactCount)   // "48.7K"
-```
-
 The static member in the constrained extension is what enables the
 `.compactCount` dot syntax at call sites. (For real apps, `.notation(.compactName)`
 already does this with localized suffixes; a custom style earns its place when
 the rule is your own.)
 
+Code for this section: [FormatStyle examples](references/formatstyle-examples.md).
+
 ## Common mistakes
 
 | Mistake | Fix |
@@ -349,6 +279,7 @@ the rule is your own.)
 
 ## References
 
+- [FormatStyle examples](references/formatstyle-examples.md): open when formatting dates or durations beyond the quick reference, or when writing a custom FormatStyle.
 - [FormatStyle](https://developer.apple.com/documentation/foundation/formatstyle)
 - [IntegerFormatStyle](https://developer.apple.com/documentation/foundation/integerformatstyle)
 - [FloatingPointFormatStyle](https://developer.apple.com/documentation/foundation/floatingpointformatstyle)

package/pipeline/skills/shared/external/swift-formatstyle/references/formatstyle-examples.md

@@ -0,0 +1,113 @@
+# FormatStyle examples
+
+<!-- toc -->
+- [Dates](#dates)
+- [Durations](#durations)
+- [Custom FormatStyle](#custom-formatstyle)
+<!-- /toc -->
+
+Code for date, duration and custom FormatStyle formatting. SKILL.md keeps the quick reference and the locale rules.
+
+## Dates
+
+Build exactly the fields you want; the locale decides order and punctuation.
+
+```swift
+let launch = Date.now
+launch.formatted(.dateTime.day().month().year())            // "Mar 3, 2026" (order comes from the locale)
+launch.formatted(.dateTime.minute().hour())                 // "4:05 PM"
+let spelledOut = Date.FormatStyle.dateTime.day().month(.wide).weekday(.wide)
+launch.formatted(spelledOut)                                // "Tuesday, March 3"
+```
+
+Predefined combinations:
+
+```swift
+launch.formatted(date: .long, time: .shortened)     // "March 3, 2026 at 4:05 PM"
+launch.formatted(date: .abbreviated, time: .omitted) // "Mar 3, 2026"
+launch.formatted(.iso8601)                           // "2026-03-03T13:05:00Z"
+```
+
+Relative to now:
+
+```swift
+let dayBefore = Date.now.addingTimeInterval(-86_400)
+dayBefore.formatted(.relative(presentation: .named))    // "yesterday"
+let numericAgo = Date.RelativeFormatStyle(presentation: .numeric)
+dayBefore.formatted(numericAgo)                         // "1 day ago"
+```
+
+Ranges and countdowns:
+
+```swift
+let slot = launch..<launch.addingTimeInterval(5_400)
+let meetingSpan = Date.IntervalFormatStyle().day().month().minute().hour()
+slot.formatted(meetingSpan)   // "Mar 3, 4:05 - 5:35 PM" (ICU prints an en dash)
+
+let untilDeparture = Date.now..<Date.now.addingTimeInterval(190_800)
+let countdown = Date.ComponentsFormatStyle(style: .wide, fields: [.hour, .day])
+untilDeparture.formatted(countdown)   // "2 days, 5 hours"
+```
+
+Related types: `Date.FormatStyle`, `Date.RelativeFormatStyle`,
+`Date.IntervalFormatStyle`, `Date.ComponentsFormatStyle`.
+
+## Durations
+
+A `Duration` (iOS 16+) can be shown as a clock reading with
+`Duration.TimeFormatStyle` or as labeled units with `Duration.UnitsFormatStyle`.
+
+```swift
+let ride = Duration.seconds(7_384)                  // 2 h 3 min 4 s
+ride.formatted(.time(pattern: .hourMinuteSecond))   // "2:03:04"
+ride.formatted(.time(pattern: .hourMinute))         // "2:03"
+ride.formatted(.time(pattern: .minuteSecond))       // "123:04" (minutes are not wrapped into hours)
+
+let stopwatch = Duration.TimeFormatStyle.Pattern.minuteSecond(padMinuteToLength: 2, fractionalSecondsLength: 2)
+Duration.milliseconds(3_750).formatted(.time(pattern: stopwatch))   // "00:03.75"
+```
+
+```swift
+let clock: Set<Duration.UnitsFormatStyle.Unit> = [.hours, .minutes, .seconds]
+ride.formatted(.units(allowed: clock, width: .abbreviated))                      // "2 hr, 3 min, 4 sec"
+ride.formatted(.units(allowed: clock, width: .wide, maximumUnitCount: 1))        // "2 hours"
+
+let rest = Duration.seconds(150)
+rest.formatted(.units(allowed: [.minutes, .seconds], width: .wide))     // "2 minutes, 30 seconds"
+rest.formatted(.units(allowed: [.minutes, .seconds], width: .narrow))   // "2m 30s"
+```
+
+`maximumUnitCount` caps how many units appear.
+
+## Custom FormatStyle
+
+Conform to `FormatStyle` and implement `format(_:)`. Add `ParseableFormatStyle`
+if the text must also be read back. `FormatStyle` inherits `Codable` and
+`Hashable`, so keep stored properties simple value types.
+
+```swift
+struct CompactCountStyle: FormatStyle {
+    func format(_ count: Int) -> String {
+        switch abs(count) {
+        case 1_000_000...: scaled(count, by: 1_000_000) + "M"
+        case 1_000...:     scaled(count, by: 1_000) + "K"
+        default:           count.formatted()
+        }
+    }
+
+    private func scaled(_ count: Int, by divisor: Double) -> String {
+        (Double(count) / divisor).formatted(.number.precision(.fractionLength(0...1)))
+    }
+}
+
+extension FormatStyle where Self == CompactCountStyle {
+    static var compactCount: CompactCountStyle { CompactCountStyle() }
+}
+
+let followers = 48_700.formatted(.compactCount)   // "48.7K"
+```
+
+The static member in the constrained extension is what enables the
+`.compactCount` dot syntax at call sites. (For real apps, `.notation(.compactName)`
+already does this with localized suffixes; a custom style earns its place when
+the rule is your own.)

package/pipeline/skills/shared/external/swift-language/SKILL.md

@@ -299,41 +299,7 @@ can be dropped into a builder where that helps. More in
 
 ## Codable basics
 
-```swift
-struct Venue: Codable {
-    var venueName: String
-    var seatCount: Int
-    var isOutdoor: Bool
-    var city: String
-
-    enum CodingKeys: String, CodingKey {
-        case venueName = "venue_name", seatCount = "seat_count", isOutdoor = "is_outdoor", location
-    }
-    enum LocationKeys: String, CodingKey { case city }
-
-    init(from decoder: Decoder) throws {
-        let c = try decoder.container(keyedBy: CodingKeys.self)
-        venueName = try c.decode(String.self, forKey: .venueName)
-        seatCount = try c.decodeIfPresent(Int.self, forKey: .seatCount) ?? 0
-        if let flag = try? c.decode(Bool.self, forKey: .isOutdoor) {
-            isOutdoor = flag
-        } else {
-            isOutdoor = (try c.decodeIfPresent(String.self, forKey: .isOutdoor)) == "true"
-        }
-        let place = try c.nestedContainer(keyedBy: LocationKeys.self, forKey: .location)
-        city = try place.decode(String.self, forKey: .city)
-    }
-
-    func encode(to encoder: Encoder) throws {
-        var c = encoder.container(keyedBy: CodingKeys.self)
-        try c.encode(venueName, forKey: .venueName)
-        try c.encode(seatCount, forKey: .seatCount)
-        try c.encode(isOutdoor, forKey: .isOutdoor)
-        var place = c.nestedContainer(keyedBy: LocationKeys.self, forKey: .location)
-        try place.encode(city, forKey: .city)
-    }
-}
-```
+Code: [Codable basics](references/code-examples.md#codable-basics).
 
 - A `CodingKeys: String, CodingKey` enum renames snake_case keys without a
   custom decoder.
@@ -379,27 +345,7 @@ let tagCounts = allTags.reduce(into: [:]) { tally, tag in tally[tag, default: 0]
 Prefer `.formatted()` to `DateFormatter` and `NumberFormatter`: it is typed,
 localized and short.
 
-```swift
-import Foundation
-
-let now = Date()
-now.formatted()
-now.formatted(date: .abbreviated, time: .shortened)
-now.formatted(.dateTime.year().month().day())
-now.addingTimeInterval(-3600).formatted(.relative(presentation: .named))
-
-19.99.formatted(.currency(code: "EUR"))
-0.425.formatted(.percent)
-42.5.formatted(.percent)
-2_400_000.formatted(.number.notation(.compactName))
-Measurement(value: 12, unit: UnitLength.kilometers).formatted(.measurement(width: .abbreviated))
-Duration.seconds(4000).formatted(.time(pattern: .hourMinuteSecond))
-Int64(5_300_000).formatted(.byteCount(style: .file))
-["oat", "rye", "spelt"].formatted(.list(type: .and))
-
-let cost = try Decimal("EUR 42.50", format: .currency(code: "EUR"))
-let day = try Date("Mar 4, 2026", strategy: .dateTime.month().day().year())
-```
+Code: [Formatting basics](references/code-examples.md#formatting-basics).
 
 `.percent` multiplies by 100, so `42.5` prints as `4,250%`; pass `0.425` for
 42.5%. `.compactName` turns 2,400,000 into `2.4M`. `Duration.formatted` needs
@@ -457,3 +403,4 @@ delimiter, so align the closing quotes with the text you want flush left.
 - [references/swift-attributes-interop.md](references/swift-attributes-interop.md):
   `@c`, module selectors, `@specialized`, `@inline(always)`, `@export`,
   `@section` and `@used`.
+- [Code examples](references/code-examples.md): open for the full code behind Codable basics, Formatting basics.

package/pipeline/skills/shared/external/swift-language/references/code-examples.md

@@ -0,0 +1,65 @@
+# Swift Language Code Examples
+
+Full code samples for the SKILL.md sections that link here. The rules and the decision guidance stay in SKILL.md; each heading below matches the SKILL.md section the code belongs to.
+
+## Codable basics
+
+```swift
+struct Venue: Codable {
+    var venueName: String
+    var seatCount: Int
+    var isOutdoor: Bool
+    var city: String
+
+    enum CodingKeys: String, CodingKey {
+        case venueName = "venue_name", seatCount = "seat_count", isOutdoor = "is_outdoor", location
+    }
+    enum LocationKeys: String, CodingKey { case city }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        venueName = try c.decode(String.self, forKey: .venueName)
+        seatCount = try c.decodeIfPresent(Int.self, forKey: .seatCount) ?? 0
+        if let flag = try? c.decode(Bool.self, forKey: .isOutdoor) {
+            isOutdoor = flag
+        } else {
+            isOutdoor = (try c.decodeIfPresent(String.self, forKey: .isOutdoor)) == "true"
+        }
+        let place = try c.nestedContainer(keyedBy: LocationKeys.self, forKey: .location)
+        city = try place.decode(String.self, forKey: .city)
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var c = encoder.container(keyedBy: CodingKeys.self)
+        try c.encode(venueName, forKey: .venueName)
+        try c.encode(seatCount, forKey: .seatCount)
+        try c.encode(isOutdoor, forKey: .isOutdoor)
+        var place = c.nestedContainer(keyedBy: LocationKeys.self, forKey: .location)
+        try place.encode(city, forKey: .city)
+    }
+}
+```
+
+## Formatting basics
+
+```swift
+import Foundation
+
+let now = Date()
+now.formatted()
+now.formatted(date: .abbreviated, time: .shortened)
+now.formatted(.dateTime.year().month().day())
+now.addingTimeInterval(-3600).formatted(.relative(presentation: .named))
+
+19.99.formatted(.currency(code: "EUR"))
+0.425.formatted(.percent)
+42.5.formatted(.percent)
+2_400_000.formatted(.number.notation(.compactName))
+Measurement(value: 12, unit: UnitLength.kilometers).formatted(.measurement(width: .abbreviated))
+Duration.seconds(4000).formatted(.time(pattern: .hourMinuteSecond))
+Int64(5_300_000).formatted(.byteCount(style: .file))
+["oat", "rye", "spelt"].formatted(.list(type: .and))
+
+let cost = try Decimal("EUR 42.50", format: .currency(code: "EUR"))
+let day = try Date("Mar 4, 2026", strategy: .dateTime.month().day().year())
+```

package/pipeline/skills/shared/external/swift-testing-pro/SKILL.md

@@ -6,6 +6,7 @@ metadata:
   source: "twostraws/Swift-Testing-Agent-Skill (MIT)"
   author: Paul Hudson
   version: "1.0"
+  not-for: swiftdata-pro
 ---
 
 Write and review Swift Testing code for correctness, modern API usage, and adherence to project conventions. Report only genuine problems - do not nitpick or invent issues.

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

@@ -41,47 +41,7 @@ reference semantics and a designated initializer. Model instances are not
 `Sendable`: to hand a model to another actor, pass its `PersistentIdentifier`
 (which is `Sendable`) and fetch it again from that actor's context.
 
-```swift
-import SwiftData
-import Foundation
-
-@Model
-class Plant {
-    var commonName: String
-    var acquiredOn: Date
-    var needsRepotting: Bool = false
-    @Attribute(.externalStorage) var photo: Data?
-    @Relationship(deleteRule: .cascade, inverse: \CareEvent.plant)
-    var careEvents: [CareEvent] = []
-    var bed: GardenBed?
-    @Transient var isHighlighted: Bool = false
-
-    init(commonName: String, acquiredOn: Date = .now) {
-        self.commonName = commonName
-        self.acquiredOn = acquiredOn
-    }
-}
-
-@Model
-final class GardenBed {
-    var label: String
-    @Relationship(deleteRule: .nullify, inverse: \Plant.bed)
-    var plants: [Plant] = []
-    init(label: String) { self.label = label }
-}
-
-@Model
-final class CareEvent {
-    var kind: String
-    var loggedAt: Date
-    var plant: Plant?
-
-    init(kind: String, loggedAt: Date) {
-        self.kind = kind
-        self.loggedAt = loggedAt
-    }
-}
-```
+Code: [Defining models](references/code-examples.md#defining-models).
 
 Rules that follow from the macro:
 
@@ -129,31 +89,9 @@ Indexes (`#Index`, iOS 18+) are covered in
 
 ## Container setup
 
-```swift
-// Every model type the app stores, listed once.
-let simple = try ModelContainer(for: Plant.self, CareEvent.self, GardenBed.self)
-
-// Named store, shared with extensions, synced to a private CloudKit database.
-let config = ModelConfiguration(
-    "Garden",
-    isStoredInMemoryOnly: false,
-    groupContainer: .identifier("group.example.garden"),
-    cloudKitDatabase: .private("iCloud.example.garden")
-)
-let configured = try ModelContainer(for: Plant.self, configurations: config)
-
-// Versioned schema with a migration plan.
-let migrating = try ModelContainer(
-    for: GardenSchemaV3.Plant.self,
-    migrationPlan: GardenMigrationPlan.self
-)
-
-// Tests and previews: nothing touches disk.
-let scratch = try ModelContainer(
-    for: Plant.self,
-    configurations: ModelConfiguration(isStoredInMemoryOnly: true)
-)
-```
+List every stored model type once. Use a `ModelConfiguration` for a named, app-group or CloudKit-synced store, pass the versioned schema and migration plan when one exists, and use `isStoredInMemoryOnly: true` for tests and previews.
+
+Code: [Container setup](references/code-examples.md#container-setup).
 
 ## CloudKit sync
 
@@ -312,62 +250,7 @@ try context.enumerate(sweep, batchSize: 1_000) { plant in
 Each shipped schema is an enum that conforms to `VersionedSchema` and nests its
 own model classes. The plan lists them oldest first and the stages between them.
 
-```swift
-enum GardenSchemaV1: VersionedSchema {
-    static let versionIdentifier = Schema.Version(1, 0, 0)
-    static var models: [any PersistentModel.Type] { [Plant.self] }
-
-    @Model final class Plant {
-        var name: String
-        init(name: String) { self.name = name }
-    }
-}
-
-enum GardenSchemaV2: VersionedSchema {
-    static let versionIdentifier = Schema.Version(2, 0, 0)
-    static var models: [any PersistentModel.Type] { [Plant.self] }
-
-    @Model final class Plant {
-        @Attribute(originalName: "name") var commonName: String
-        var sunlight: String = "partial"
-        init(commonName: String) { self.commonName = commonName }
-    }
-}
-
-enum GardenSchemaV3: VersionedSchema {
-    static let versionIdentifier = Schema.Version(3, 0, 0)
-    static var models: [any PersistentModel.Type] { [Plant.self] }
-
-    @Model final class Plant {
-        var commonName: String
-        var sunlight: String = "partial"
-        var sunlightHours: Int = 4
-        init(commonName: String) { self.commonName = commonName }
-    }
-}
-
-enum GardenMigrationPlan: SchemaMigrationPlan {
-    static var schemas: [any VersionedSchema.Type] {
-        [GardenSchemaV1.self, GardenSchemaV2.self, GardenSchemaV3.self]
-    }
-    static var stages: [MigrationStage] {
-        [
-            .lightweight(fromVersion: GardenSchemaV1.self, toVersion: GardenSchemaV2.self),
-            .custom(
-                fromVersion: GardenSchemaV2.self, toVersion: GardenSchemaV3.self,
-                willMigrate: nil,
-                didMigrate: { context in
-                    let plants = try context.fetch(FetchDescriptor<GardenSchemaV3.Plant>())
-                    for plant in plants {
-                        plant.sunlightHours = plant.sunlight == "full" ? 8 : 4
-                    }
-                    try context.save()
-                }
-            )
-        ]
-    }
-}
-```
+Code: [Schema versions and migration](references/code-examples.md#schema-versions-and-migration).
 
 A lightweight stage covers: new optional or defaulted properties, renames
 through `originalName`, removed properties, and new model types. Anything that
@@ -493,3 +376,4 @@ the main context. Shared preview containers and `PreviewModifier` traits are in
   predicate failures, what is supported, safe capture, debugging.
 - [references/indexing.md](references/indexing.md): `#Index`, compound indexes,
   when an index pays off, migration and verification.
+- [Code examples](references/code-examples.md): open for the full code behind Defining models, Container setup, Schema versions and migration.