@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

package/pipeline/skills/shared/external/swift-codable/evals/evals.json

@@ -0,0 +1,43 @@
+{
+  "skill_name": "swift-codable",
+  "evals": [
+    {
+      "id": 0,
+      "prompt": "Review and correct this Codable API plan for an iOS 26 app: the team made every response model Codable, uses JSONDecoder().decode before checking HTTP status, configures .convertFromSnakeCase and expects image_url to populate imageURL automatically, decodes ISO 8601 timestamps with the default Date strategy, and decodes a wrapped response with `decoder` outside the function where it was declared. Give concise corrected Swift examples where useful. Explicitly correct every read-only API response model to Decodable, not Codable; state that image_url maps to imageUrl, not imageURL; and note that the envelope helper needs its own decoder because another function's decoder is out of scope.",
+      "expected_output": "A correction-focused Codable review that uses Decodable, not Codable, for read-only responses, validates HTTP status before decoding, configures date and key strategies in scope, handles imageURL with CodingKeys because image_url maps to imageUrl, and decodes a generic API envelope with a decoder declared in the same helper.",
+      "files": [],
+      "assertions": [
+        "Uses `Decodable` rather than `Codable` for read-only API response models.",
+        "Validates `HTTPURLResponse` status before attempting to decode the body.",
+        "Configures `JSONDecoder.dateDecodingStrategy = .iso8601` for ISO 8601 date strings.",
+        "Explains that `.convertFromSnakeCase` maps `image_url` to `imageUrl`, not `imageURL`, and uses `CodingKeys` for that field.",
+        "Shows the generic envelope decode with a decoder variable that is declared in the same helper where it is used."
+      ]
+    },
+    {
+      "id": 1,
+      "prompt": "A teammate says we can delete all CodingKeys because `decoder.keyDecodingStrategy = .convertFromSnakeCase` will handle `user_id`, `image_url`, `base_uri`, and `display_name`. Review that claim and show the model code you would keep.",
+      "expected_output": "A key-strategy review that keeps automatic snake_case conversion for simple lower-camel properties while retaining CodingKeys for URL, URI, and ID initialism spellings that conversion cannot infer.",
+      "files": [],
+      "assertions": [
+        "States that `.convertFromSnakeCase` is suitable for simple snake_case to lower-camel mappings such as `display_name` to `displayName`.",
+        "States that `.convertFromSnakeCase` cannot infer initialism capitalization such as URL, URI, or ID.",
+        "Uses explicit `CodingKeys` for fields like `imageURL`, `baseURI`, or `userID`.",
+        "Avoids recommending manual CodingKeys for every simple snake_case property when a decoder strategy is enough."
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "Review this storage plan: a SwiftData `@Model` has an optional `Address` struct that conforms to Codable, and a SwiftUI settings screen stores a `UserPreferences` Codable struct in `@AppStorage`. The draft says Codable value types only work in SwiftData on iOS 18+ and proposes transformable/blob workarounds. The @AppStorage type can rely on synthesized Codable defaults if the stored JSON is `{}`. Give corrected boundary-aware guidance. State clearly that SwiftData persists compatible noncomputed stored properties declared on @Model types, including Codable structs and enums when they are part of the durable model schema. Do not propose @Attribute(.transformable), encoded Data, or encoded String blob storage as a fallback; use typed SwiftData properties and a complete RawRepresentable JSON String bridge for @AppStorage, including init?(rawValue:) and rawValue self-encoding/decoding.",
+      "expected_output": "A boundary-aware Codable storage review that uses source-backed SwiftData compatibility wording for compatible noncomputed @Model properties, avoids unsupported iOS 18+/transformable/blob fallback claims, stores @AppStorage values through a complete RawRepresentable JSON String raw-value bridge, and explains missing-key defaults need custom decoding or tolerant rawValue handling.",
+      "files": [],
+      "assertions": [
+        "States that @Model types can persist compatible noncomputed stored properties and explicitly includes Codable structs or enums, without asserting an unsupported iOS 18+ threshold.",
+        "Does not propose `@Attribute(.transformable)`, encoded `Data`, or encoded `String` blob storage as a fallback for the SwiftData Codable value property.",
+        "Uses a complete `RawRepresentable` JSON `String` raw-value bridge for storing a Codable value with `@AppStorage`.",
+        "Explains that synthesized `Decodable` does not use stored property default values when a nonoptional key is missing, so `{}` needs custom decoding or fallback handling.",
+        "Keeps the answer focused on Codable integration boundaries rather than expanding into full SwiftData schema design or SwiftUI state management."
+      ]
+    }
+  ]
+}

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

@@ -1,11 +1,11 @@
 ---
 name: swift-concurrency
-description: "Resolve Swift concurrency compiler errors, adopt Swift 6.2 approachable concurrency (SE-0466), and write data-race-safe async code. Use when fixing Sendable conformance errors, actor isolation warnings, or strict concurrency diagnostics; when adopting default MainActor isolation, @concurrent, nonisolated(nonsending), or Task.immediate; when designing actor-based architectures, structured concurrency with TaskGroup, or background work offloading; or when migrating from @preconcurrency to full Swift 6 strict concurrency."
+description: "Resolve Swift concurrency compiler errors, adopt approachable concurrency (SE-0466), and write data-race-safe async code. Use when fixing Sendable conformance errors, actor isolation warnings, or strict concurrency diagnostics; when adopting default MainActor isolation, @concurrent, nonisolated(nonsending), or Task.immediate; when designing actor-based architectures, structured concurrency with TaskGroup, or background work offloading; or when migrating from @preconcurrency to full Swift 6 strict concurrency."
 ---
 
-# Swift 6.2 Concurrency
+# Swift Concurrency
 
-Review, fix, and write concurrent Swift code targeting Swift 6.2+. Apply actor
+Review, fix, and write concurrent Swift code targeting Swift 6.3+. Apply actor
 isolation, Sendable safety, and modern concurrency patterns with minimal
 behavior changes.
 
@@ -19,7 +19,7 @@ behavior changes.
 - [Task Cancellation](#task-cancellation)
 - [Actor Reentrancy](#actor-reentrancy)
 - [AsyncSequence and AsyncStream](#asyncsequence-and-asyncstream)
-- [@Observable and Concurrency](#observable-and-concurrency)
+- [`@Observable and Concurrency`](#observable-and-concurrency)
 - [Synchronization Primitives](#synchronization-primitives)
 - [Common Mistakes](#common-mistakes)
 - [Review Checklist](#review-checklist)
@@ -34,8 +34,10 @@ When diagnosing a concurrency issue, follow this sequence:
 - Copy the exact compiler diagnostic(s) and the offending symbol(s).
 - Identify the project's concurrency settings:
   - Swift language version (must be 6.2+).
-  - Whether approachable concurrency (default MainActor isolation) is enabled.
-  - Strict concurrency checking level (Complete / Targeted / Minimal).
+  - Whether Approachable Concurrency is enabled.
+  - Whether Default Actor Isolation is set to `MainActor`.
+  - Swift 6 strict concurrency status: complete/errors in Swift 6 language mode;
+    Complete / Targeted / Minimal only when auditing Swift 5 migration settings.
 - Determine the current actor context of the code (`@MainActor`, custom `actor`,
   `nonisolated`) and whether a default isolation mode is active.
 - Confirm whether the code is UI-bound or intended to run off the main actor.
@@ -63,12 +65,17 @@ Prefer edits that preserve existing behavior while satisfying data-race safety.
 
 Swift 6.2 introduces "approachable concurrency" -- a set of language changes
 that make concurrent code safer by default while reducing annotation burden.
+In Xcode, Approachable Concurrency and Default Actor Isolation are separate
+build settings: use Approachable Concurrency for the bundled upcoming-feature
+flags, and set Default Actor Isolation to `MainActor` when you want unannotated
+code inferred as `@MainActor`.
 
 ### SE-0466: Default MainActor Isolation
 
-With the `-default-isolation MainActor` compiler flag (or the Xcode 26
-"Approachable Concurrency" build setting), all code in a module runs on
-`@MainActor` by default unless explicitly opted out.
+With the `-default-isolation MainActor` compiler flag, SwiftPM
+`.defaultIsolation(MainActor.self)`, or Xcode's `Default Actor Isolation`
+setting set to `MainActor`, unannotated declarations in the module are inferred
+as `@MainActor` unless explicitly opted out.
 
 **Effect:** Eliminates most data-race safety errors for UI-bound code and
 global/static state without writing `@MainActor` everywhere.
@@ -106,7 +113,7 @@ of hopping to the global concurrent executor. This is the
 ```swift
 class PhotoProcessor {
     func extractSticker(data: Data, with id: String?) async -> Sticker? {
-        // In Swift 6.2, this runs on the caller's actor (e.g., MainActor)
+        // In Swift 6.2+, this runs on the caller's actor (e.g., MainActor)
         // instead of hopping to a background thread.
         // ...
     }
@@ -128,7 +135,7 @@ final class StickerModel {
 
 Use `@concurrent` to explicitly request background execution when needed.
 
-### @concurrent Attribute
+### `@concurrent` Attribute
 
 `@concurrent` ensures a function always runs on the concurrent thread pool,
 freeing the calling actor to run other tasks.
@@ -192,12 +199,6 @@ for await _ in Observations { model.count } {
 }
 ```
 
-### SE-0481: weak let (Proposed — Swift 6.2+)
-
-Immutable weak references (`weak let`) that enable `Sendable` conformance for
-types holding weak references. Proposed in SE-0481; may not yet be available in
-shipping toolchains.
-
 ### Isolated Conformances
 
 A conformance that needs MainActor state is called an *isolated conformance*.
@@ -229,6 +230,15 @@ If `ImageExporter` were `nonisolated`, adding a `StickerModel` would fail:
 "Main actor-isolated conformance of 'StickerModel' to 'Exportable' cannot be
 used in nonisolated context."
 
+### Clock Epochs
+
+`ContinuousClock` and `SuspendingClock` now expose `.epoch` (SE-0473), enabling instant comparison and conversion between clock types.
+
+```swift
+let continuous = ContinuousClock()
+let elapsed = continuous.now - continuous.epoch  // Duration since system boot
+```
+
 ## Actor Isolation Rules
 
 1. All mutable shared state MUST be protected by an actor or global actor.
@@ -257,6 +267,18 @@ used in nonisolated context."
 
 ## Structured Concurrency Patterns
 
+### Async Defer
+
+`defer` blocks can now contain `await` (SE-0493). Use for async cleanup  -  closing connections, flushing buffers, or releasing resources that require an async call.
+
+```swift
+func fetchData() async throws -> Data {
+    let connection = try await openConnection()
+    defer { await connection.close() }
+    return try await connection.read()
+}
+```
+
 **Task:** Unstructured, inherits caller context.
 ```swift
 Task { await doWork() }
@@ -335,7 +357,7 @@ let stream = AsyncStream<Location> { continuation in
 Use `withCheckedContinuation` / `withCheckedThrowingContinuation` for
 single-value callbacks. Resume exactly once.
 
-## @Observable and Concurrency
+## `@Observable` and Concurrency
 
 - `@Observable` classes should be `@MainActor` for view models.
 - Use `@State` to own an `@Observable` instance (replaces `@StateObject`).
@@ -344,8 +366,8 @@ single-value callbacks. Resume exactly once.
 
 ## Synchronization Primitives
 
-When actors are not the right fit — synchronous access, performance-critical
-paths, or bridging C/ObjC — use low-level synchronization primitives:
+When actors are not the right fit  -  synchronous access, performance-critical
+paths, or bridging C/ObjC  -  use low-level synchronization primitives:
 
 - **`Mutex<Value>`** (iOS 18+, `Synchronization` module): Preferred lock for
   new code. Stores protected state inside the lock. `withLock { }` pattern.
@@ -356,7 +378,7 @@ paths, or bridging C/ObjC — use low-level synchronization primitives:
 
 **Key rule:** Never put locks inside actors (double synchronization), and never
 hold a lock across `await` (deadlock risk). See
-`references/synchronization-primitives.md` for full API details, code examples,
+[references/synchronization-primitives.md](references/synchronization-primitives.md) for full API details, code examples,
 and a decision guide for choosing locks vs actors.
 
 ## Common Mistakes
@@ -397,12 +419,10 @@ and a decision guide for choosing locks vs actors.
 
 ## References
 
-- See `references/swift-6-2-concurrency.md` for detailed Swift 6.2 changes,
-  patterns, and migration examples.
-- See `references/approachable-concurrency.md` for the approachable concurrency
-  mode quick-reference guide.
-- See `references/swiftui-concurrency.md` for SwiftUI-specific concurrency
-  guidance.
-- See `references/synchronization-primitives.md` for Mutex, OSAllocatedUnfairLock,
-  and guidance on choosing locks vs actors.
-
+- [references/concurrency-patterns.md](references/concurrency-patterns.md)  -  detailed concurrency patterns and migration examples
+- [references/approachable-concurrency.md](references/approachable-concurrency.md)  -  approachable concurrency mode quick-reference
+- [references/swiftui-concurrency.md](references/swiftui-concurrency.md)  -  SwiftUI-specific concurrency guidance
+- [references/synchronization-primitives.md](references/synchronization-primitives.md)  -  Mutex, OSAllocatedUnfairLock, locks vs actors
+- [references/bridging-interop.md](references/bridging-interop.md)  -  checked continuations, delegate bridging, GCD migration table
+- [references/diagnostics.md](references/diagnostics.md)  -  compiler diagnostic → fix reference, strict concurrency adoption
+- [references/async-algorithms.md](references/async-algorithms.md)  -  swift-async-algorithms: debounce, throttle, merge, combineLatest, chunks

package/pipeline/skills/shared/external/swift-concurrency/evals/evals.json

@@ -0,0 +1,44 @@
+{
+  "skill_name": "swift-concurrency",
+  "evals": [
+    {
+      "id": 0,
+      "prompt": "Review this Swift 6.3/Xcode 26 concurrency build-settings plan: the team says Approachable Concurrency alone makes the whole module MainActor, strict concurrency should start at Targeted in Swift 6 mode, and CPU-heavy image decoding can stay on MainActor because nonisolated async functions now hop to a background executor. Correct the plan and give the smallest build-setting and code-level recommendations.",
+      "expected_output": "A source-grounded settings review that separates Approachable Concurrency from Default Actor Isolation, states that Swift 6 mode uses complete strict concurrency with errors, and recommends @concurrent/nonisolated offloading for CPU-heavy work instead of blocking MainActor.",
+      "files": [],
+      "assertions": [
+        "Separates Xcode's Approachable Concurrency setting from Default Actor Isolation and says MainActor-by-default requires Default Actor Isolation = MainActor.",
+        "States that Swift 6 / 6.3 language mode uses complete strict concurrency and emits errors, while Targeted or Minimal are Swift 5 migration settings.",
+        "Explains that nonisolated async functions stay on the caller's actor with nonisolated(nonsending) behavior unless @concurrent is used.",
+        "Recommends offloading CPU-heavy work with @concurrent and a nonisolated context rather than leaving it on MainActor.",
+        "Avoids broad architecture or SwiftUI state-management redesign beyond the concurrency settings and code-level fix."
+      ]
+    },
+    {
+      "id": 1,
+      "prompt": "A SwiftUI app with Default Actor Isolation set to MainActor has errors around a @Observable StickerModel conforming to Exportable, a PhotoProcessor async method, and a legacy SDK imported with @preconcurrency. Give a diagnostic remediation plan that preserves behavior, avoids unchecked Sendable unless truly justified, and explains which fixes belong in swift-concurrency rather than architecture or navigation skills.",
+      "expected_output": "A diagnostic remediation plan that uses @MainActor or isolated conformances for UI-bound state, explains nonisolated(nonsending) and @concurrent tradeoffs for PhotoProcessor work, treats @preconcurrency as temporary, and keeps architecture/navigation details as sibling handoffs.",
+      "files": [],
+      "assertions": [
+        "Uses @MainActor isolation or an isolated conformance such as extension StickerModel: @MainActor Exportable for UI-bound protocol conformance errors.",
+        "Explains when PhotoProcessor can stay on the caller's actor and when CPU-heavy work should move to @concurrent/nonisolated async code.",
+        "Prefers value immutability, actor isolation, or synchronization over adding @unchecked Sendable by default.",
+        "Treats @preconcurrency import as a temporary bridge for third-party modules with a documented removal plan.",
+        "Routes module architecture, navigation implementation, and detailed SwiftUI state ownership to sibling skills instead of expanding this skill's scope."
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "Review this synchronization plan for a Swift 6.3 app: use an actor for a synchronous metrics counter called from C callbacks, put NSLock inside an actor for cache mutation, hold a Mutex while awaiting a network fetch, and ban NSLock because it is not Sendable. Replace it with a modern concurrency-safe plan for iOS 16 through iOS 26.",
+      "expected_output": "A synchronization review that chooses actors for async shared state, Mutex or OSAllocatedUnfairLock for synchronous state depending on deployment target, Atomic for simple counters or flags, avoids locks inside actors or across await, and corrects the NSLock Sendable claim without recommending it first.",
+      "files": [],
+      "assertions": [
+        "Uses an actor for shared mutable state when asynchronous access and actor hops are acceptable.",
+        "Uses Mutex for new code targeting iOS 18+ and OSAllocatedUnfairLock for iOS 16-17 support or ownership-assertion needs.",
+        "Uses Atomic for simple scalar counters or flags rather than an actor or full lock when appropriate.",
+        "Rejects locks inside actors and rejects holding any lock across await suspension points.",
+        "Corrects the claim that NSLock is not Sendable while still preferring modern state-protecting primitives for new Swift concurrency code."
+      ]
+    }
+  ]
+}

package/pipeline/skills/shared/external/swift-concurrency/references/approachable-concurrency.md

@@ -1,14 +1,20 @@
 # Approachable Concurrency Quick Reference
 
 Use this reference when the project has opted into the Swift 6.2 approachable
-concurrency settings (default MainActor isolation / main-actor-by-default).
+concurrency settings and, when appropriate, default MainActor isolation.
 
 ## Detecting the Mode
 
 **Xcode 26:** Check build settings under Swift Compiler > Concurrency:
 - Swift language version: 6.2+
-- Default Actor Isolation / Main Actor by Default: enabled
-- Strict Concurrency Checking: Complete / Targeted / Minimal
+- Approachable Concurrency: enabled when using the bundled upcoming-feature flags
+  (`NonisolatedNonsendingByDefault`, isolated-conformance inference, inferred
+  Sendable captures, and related usability flags).
+- Default Actor Isolation: `MainActor` when unannotated code should infer
+  `@MainActor` isolation.
+- Strict Concurrency Checking: Swift 6 language mode is complete and emits
+  errors; Complete / Targeted / Minimal are migration settings for earlier
+  language modes.
 
 **SwiftPM:** Inspect `Package.swift` `swiftSettings` for the corresponding flags.
 
@@ -22,7 +28,8 @@ many "sending X risks causing data races" errors.
 
 ### Default MainActor isolation
 
-With SE-0466 enabled, all declarations in the module are implicitly `@MainActor`.
+With Default Actor Isolation set to `MainActor`, unannotated declarations in the
+module are inferred as `@MainActor`.
 This means:
 - Global and static variables are protected by default.
 - Protocol conformances are implicitly isolated.

package/pipeline/skills/shared/external/swift-concurrency/references/async-algorithms.md

@@ -0,0 +1,113 @@
+# Swift Async Algorithms
+
+[swift-async-algorithms](https://github.com/apple/swift-async-algorithms) is an Apple open-source package providing `AsyncSequence` algorithms modeled after the standard library's `Sequence` algorithms.
+
+## Contents
+
+- [Key Algorithms](#key-algorithms)
+- [Common Patterns](#common-patterns)
+
+Add to Package.swift:
+
+```swift
+.package(url: "https://github.com/apple/swift-async-algorithms", from: "1.0.0")
+```
+
+## Key Algorithms
+
+### Combining
+
+```swift
+import AsyncAlgorithms
+
+// Merge multiple sequences into one (interleaved by arrival time)
+for await value in merge(streamA, streamB) {
+    handle(value)
+}
+
+// Combine latest values from two sequences (emits when either updates)
+for await (a, b) in combineLatest(streamA, streamB) {
+    handle(a, b)
+}
+
+// Zip  -  pairs elements 1:1 (waits for both)
+for await (a, b) in zip(streamA, streamB) {
+    handle(a, b)
+}
+
+// Chain  -  concatenate sequences end-to-end
+for await value in chain(streamA, streamB) {
+    handle(value)
+}
+```
+
+### Temporal
+
+```swift
+// Debounce  -  emit after a quiet period (e.g., search-as-you-type)
+let searchResults = searchTerms
+    .debounce(for: .milliseconds(300))
+
+for await term in searchResults {
+    await performSearch(term)
+}
+
+// Throttle  -  emit at most once per interval
+let throttled = sensorReadings
+    .throttle(for: .seconds(1))
+
+for await reading in throttled {
+    updateDisplay(reading)
+}
+
+// Chunks  -  collect elements into arrays by count or time
+for await batch in events.chunks(ofCount: 10) {
+    await processBatch(batch) // [Event] with up to 10 elements
+}
+
+for await batch in events.chunked(by: .repeating(every: .seconds(1))) {
+    await processBatch(batch)
+}
+```
+
+### Filtering and Transformation
+
+```swift
+// Remove consecutive duplicates
+for await value in stream.removeDuplicates() {
+    handle(value)
+}
+
+// Compacted  -  remove nils (like compactMap without transform)
+let values: AsyncStream<Int?> = ...
+for await value in values.compacted() {
+    // value is non-optional Int
+}
+```
+
+## Common Patterns
+
+### Search-as-you-type
+
+```swift
+func searchResults(for terms: AsyncStream<String>) -> AsyncStream<[Result]> {
+    AsyncStream { continuation in
+        Task {
+            for await term in terms.debounce(for: .milliseconds(300)) {
+                guard !Task.isCancelled else { break }
+                let results = try? await searchService.search(term)
+                continuation.yield(results ?? [])
+            }
+            continuation.finish()
+        }
+    }
+}
+```
+
+### Rate-limited API calls
+
+```swift
+for await batch in requestStream.chunks(ofCount: 50).throttle(for: .seconds(1)) {
+    await api.sendBatch(batch)
+}
+```

package/pipeline/skills/shared/external/swift-concurrency/references/bridging-interop.md

@@ -0,0 +1,150 @@
+# Bridging and Interop
+
+Patterns for bridging callback-based, delegate-based, and GCD code into Swift Concurrency.
+
+## Contents
+
+- [Checked Continuations](#checked-continuations)
+- [AsyncStream from Callbacks](#asyncstream-from-callbacks)
+- [GCD Migration](#gcd-migration)
+
+## Checked Continuations
+
+Use `withCheckedContinuation` (non-throwing) or `withCheckedThrowingContinuation` (throwing) to bridge completion-handler APIs into async/await. Available iOS 13+.
+
+Docs: [withCheckedContinuation](https://sosumi.ai/documentation/swift/withcheckedcontinuation(isolation:function:_:)) · [withCheckedThrowingContinuation](https://sosumi.ai/documentation/swift/withcheckedthrowingcontinuation(isolation:function:_:))
+
+### Basic Pattern
+
+```swift
+func fetchData() async throws -> Data {
+    try await withCheckedThrowingContinuation { continuation in
+        legacyFetch { result in
+            switch result {
+            case .success(let data):
+                continuation.resume(returning: data)
+            case .failure(let error):
+                continuation.resume(throwing: error)
+            }
+        }
+    }
+}
+```
+
+### Rules
+
+- **Resume exactly once.** Missing resume suspends the task forever (leak). Double resume crashes at runtime.
+- **Prefer checked over unsafe.** `withCheckedContinuation` detects misuse at runtime with diagnostics. Use `withUnsafeContinuation` only in performance-critical paths after correctness is proven.
+- **Capture continuation carefully.** The continuation escapes the closure  -  ensure all code paths resume it, including error and cancellation paths.
+
+### Delegate Bridging
+
+```swift
+class LocationBridge: NSObject, CLLocationManagerDelegate {
+    private var continuation: CheckedContinuation<CLLocation, any Error>?
+    private let manager = CLLocationManager()
+
+    func requestLocation() async throws -> CLLocation {
+        try await withCheckedThrowingContinuation { continuation in
+            self.continuation = continuation
+            manager.delegate = self
+            manager.requestLocation()
+        }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        continuation?.resume(returning: locations[0])
+        continuation = nil
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        continuation?.resume(throwing: error)
+        continuation = nil
+    }
+}
+```
+
+### Cancellation Support
+
+```swift
+func fetchWithCancellation() async throws -> Data {
+    try await withTaskCancellationHandler {
+        try await withCheckedThrowingContinuation { continuation in
+            let task = legacyFetch { result in
+                switch result {
+                case .success(let data): continuation.resume(returning: data)
+                case .failure(let error): continuation.resume(throwing: error)
+                }
+            }
+            // Store task for cancellation
+        }
+    } onCancel: {
+        // Cancel the underlying work
+    }
+}
+```
+
+## AsyncStream from Callbacks
+
+For APIs that deliver multiple values over time (delegates, NotificationCenter), use `AsyncStream`:
+
+```swift
+func locationUpdates() -> AsyncStream<CLLocation> {
+    AsyncStream { continuation in
+        let delegate = StreamingLocationDelegate(continuation: continuation)
+        continuation.onTermination = { _ in
+            delegate.stop()
+        }
+        delegate.start()
+    }
+}
+```
+
+## GCD Migration
+
+| GCD Pattern | Swift Concurrency Replacement |
+| --- | --- |
+| `DispatchQueue.main.async { }` | `@MainActor` isolation or `MainActor.run { }` |
+| `DispatchQueue.global().async { }` | `Task { }` or `Task.detached { }` (Swift 6.2: `@concurrent`) |
+| `DispatchGroup` | `async let` or `TaskGroup` |
+| `DispatchSemaphore` | Actor isolation or `AsyncStream` |
+| `DispatchWorkItem` with cancel | `Task` with `task.cancel()` |
+| `DispatchQueue` serial queue | `actor` |
+| `DispatchQueue.concurrentPerform` | `withTaskGroup` |
+| `DispatchSource.makeTimerSource` | `Task.sleep(for:)` in a loop, or `Clock` |
+
+### DispatchGroup → TaskGroup
+
+```swift
+// Before (GCD)
+let group = DispatchGroup()
+for url in urls {
+    group.enter()
+    fetch(url) { _ in group.leave() }
+}
+group.notify(queue: .main) { updateUI() }
+
+// After (Swift Concurrency)
+let results = await withTaskGroup(of: Data?.self) { group in
+    for url in urls {
+        group.addTask { try? await fetch(url) }
+    }
+    return await group.reduce(into: [Data]()) { if let d = $1 { $0.append(d) } }
+}
+updateUI(results)
+```
+
+### Serial Queue → Actor
+
+```swift
+// Before
+let serialQueue = DispatchQueue(label: "com.app.cache")
+serialQueue.async { self.cache[key] = value }
+
+// After
+actor Cache {
+    private var storage: [String: Data] = [:]
+    func set(_ key: String, _ value: Data) { storage[key] = value }
+    func get(_ key: String) -> Data? { storage[key] }
+}
+```

package/pipeline/skills/shared/external/swift-concurrency/references/{swift-6-2-concurrency.md → concurrency-patterns.md}

@@ -1,6 +1,6 @@
-# Swift 6.2 Concurrency Changes
+# Concurrency Patterns
 
-Swift 6.2 introduces "approachable concurrency" -- a philosophy shift where
+Approachable concurrency patterns introduced in Swift 6.2+  -  a philosophy shift where
 code stays single-threaded by default until you choose to introduce concurrency.
 
 ## Contents
@@ -8,10 +8,10 @@ code stays single-threaded by default until you choose to introduce concurrency.
 - [Core Problem Solved](#core-problem-solved)
 - [SE-0466: Default MainActor Isolation](#se-0466-default-mainactor-isolation)
 - [SE-0461: nonisolated(nonsending)](#se-0461-nonisolatednonsending)
-- [@concurrent Attribute](#concurrent-attribute)
+- [`@concurrent Attribute`](#concurrent-attribute)
 - [SE-0472: Task.immediate](#se-0472-taskimmediate)
 - [Isolated Conformances](#isolated-conformances)
-- [SE-0481: weak let (Proposed)](#se-0481-weak-let-proposed--swift-62)
+- [SE-0481: weak let](#se-0481-weak-let)
 - [SE-0475: Transactional Observation (Observations)](#se-0475-transactional-observation-observations)
 - [Global and Static State](#global-and-static-state)
 - [Migration and Build Settings](#migration-and-build-settings)
@@ -62,11 +62,18 @@ final class StickerModel {
 
 ## SE-0466: Default MainActor Isolation
 
-Enable with the `-default-isolation MainActor` compiler flag or the Xcode 26
-"Approachable Concurrency" build setting.
+Enable with the `-default-isolation MainActor` compiler flag, SwiftPM
+`.defaultIsolation(MainActor.self)`, or Xcode's separate `Default Actor
+Isolation` build setting set to `MainActor`.
+
+Do not confuse this with Xcode's `Approachable Concurrency` build setting, which
+enables a bundle of upcoming-feature flags such as nonisolated-nonsending by
+default, isolated-conformance inference, inferred Sendable captures, and related
+global-actor usability changes.
 
 **What it does:**
-- All declarations in the module are implicitly `@MainActor` unless opted out.
+- Unannotated declarations in the module are inferred as `@MainActor` unless
+  opted out.
 - Global and static variables are protected by the main actor by default.
 - Protocol conformances are implicitly isolated to `@MainActor`.
 - Eliminates most annotation burden for single-threaded UI code.
@@ -101,7 +108,7 @@ the actor, eliminating data races without annotation.
 
 To explicitly opt into background execution, use `@concurrent`.
 
-## @concurrent Attribute
+## `@concurrent` Attribute
 
 Ensures a function always runs on the concurrent thread pool, freeing the
 calling actor for other work.
@@ -185,11 +192,11 @@ nonisolated struct GenericExporter {
 }
 ```
 
-## SE-0481: weak let (Proposed — Swift 6.2+)
+## SE-0481: weak let
 
 Immutable weak references (`weak let`) enable `Sendable` conformance for types
-that hold weak references, since immutability guarantees thread safety. Proposed
-in SE-0481; may not yet be available in shipping toolchains.
+that hold weak references, since immutability guarantees thread safety.
+SE-0481 is implemented in Swift 6.3.
 
 ## SE-0475: Transactional Observation (Observations)
 
@@ -222,6 +229,10 @@ All approachable concurrency features are opt-in via:
 - **Xcode 26:** Swift Compiler > Concurrency section in build settings.
 - **SwiftPM:** `swiftSettings` in Package.swift using the `SwiftSetting` API.
 
+For Swift 6 language mode, strict concurrency checking is complete and
+data-race diagnostics are errors. Use Targeted or Minimal only as Swift 5
+migration settings while preparing code for Swift 6.
+
 Swift 6.2 includes migration tooling to help make necessary code changes
 automatically. See swift.org/migration for details.