@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.1

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

@@ -3,41 +3,44 @@
   "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.",
+      "name": "settings-plan-review",
+      "prompt": "Check this plan for our podcast app on Swift 6.3 and Xcode 26: (1) turning on Approachable Concurrency is enough to make the whole app target main-actor isolated; (2) we will begin the Swift 6 migration at the Targeted strict-concurrency level; (3) waveform rendering is CPU heavy but can stay on the main actor, because nonisolated async functions hop to a background thread anyway. Correct what is wrong and say what we should do instead.",
+      "expected_output": "Separates the two settings: Approachable Concurrency enables upcoming features, whereas inferring @MainActor everywhere needs the Default Actor Isolation build setting set to MainActor. Notes that the Swift 6 language mode (6.3 included) is complete checking with errors and that Targeted and Minimal are Swift 5 staging levels. Explains that with NonisolatedNonsendingByDefault a nonisolated async function keeps executing on whichever actor called it, so the rendering must be moved with @concurrent on a nonisolated function. Stays at the level of settings and code-level fixes.",
       "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."
+      "expectations": [
+        "Treats Approachable Concurrency and Default Actor Isolation as two separate settings, and only the latter, set to MainActor, gives main-actor-by-default",
+        "States that in Swift 6 (and 6.3) mode checking is always complete and reports errors, while the Targeted and Minimal levels belong to Swift 5 staging",
+        "Says a nonisolated async function inherits the calling actor, the nonisolated(nonsending) behavior, until @concurrent is added",
+        "Moves the CPU-heavy rendering off the main actor with @concurrent in a nonisolated context",
+        "Limits the answer to build settings and code-level changes, with no broader redesign of architecture or SwiftUI state"
       ]
     },
     {
       "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.",
+      "name": "default-isolation-remediation",
+      "prompt": "Our app target uses Default Actor Isolation = MainActor. We get errors on an @Observable PlaylistModel that conforms to our Archivable protocol, on an async render method of a plain WaveformRenderer class, and around a vendor analytics SDK we import with @preconcurrency. Give a remediation plan that keeps behavior the same, and tell us what is out of scope for this pass.",
+      "expected_output": "Keeps PlaylistModel on the main actor and meets the protocol through a main-actor isolated conformance, written extension PlaylistModel: @MainActor Archivable. Explains that WaveformRenderer.render executes on its caller's actor under nonisolated(nonsending), so only CPU-heavy parts should move to a @concurrent nonisolated function. Prefers immutable values, actor isolation or locks over @unchecked Sendable. Treats the @preconcurrency import as temporary with a written removal plan, and leaves module layout, navigation and who owns which SwiftUI state to sibling skills.",
       "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."
+      "expectations": [
+        "Fixes the conformance with @MainActor on the type or the isolated form extension PlaylistModel: @MainActor Archivable",
+        "Separates the case where WaveformRenderer may keep running on the calling actor from CPU-bound work that belongs in a @concurrent nonisolated function",
+        "Reaches for immutable values, an actor or a lock before any @unchecked Sendable",
+        "Keeps the @preconcurrency import only temporarily and asks for a written plan to drop it",
+        "Hands module layout, navigation and fine-grained SwiftUI state ownership over to sibling skills"
       ]
     },
     {
       "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.",
+      "name": "locks-versus-actors",
+      "prompt": "Review this plan; the app's deployment range is iOS 16 up to iOS 26: an actor holds the frame-drop counter that a C audio callback increments synchronously; another actor guards its dictionary with an NSLock as extra protection; a Mutex stays locked while we await the network refresh; and NSLock is banned because it is not Sendable. What should change?",
+      "expected_output": "Keeps actors for shared mutable state reached asynchronously where hops are acceptable, and replaces the counter with Atomic on iOS 18 or a lock for iOS 16-17 because the C callback is synchronous. Picks Mutex where iOS 18 is the floor and OSAllocatedUnfairLock for the iOS 16 and 17 range or when lock ownership should be asserted. Removes the NSLock from inside the actor and never holds a lock across await. Points out that NSLock does conform to Sendable, yet still favors the newer primitives that own their state.",
       "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."
+      "expectations": [
+        "Keeps an actor where every caller can await and the hop cost does not matter",
+        "Chooses Mutex when iOS 18 is the minimum, OSAllocatedUnfairLock for iOS 16 and 17 or for ownership preconditions",
+        "Uses Atomic for a simple scalar counter or flag instead of an actor or a full lock",
+        "Rejects locks inside actors and any lock held across await",
+        "Fixes the false statement that NSLock lacks Sendable, but still prefers the newer lock types that hold their state"
       ]
     }
   ]

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

@@ -1,87 +1,72 @@
 # Approachable Concurrency Quick Reference
 
-Use this reference when the project has opted into the Swift 6.2 approachable
-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+
-- 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.
-
-## Behavior Changes
-
-### Async functions stay on the caller's actor
-
-In Swift 6.2, nonisolated async functions no longer hop to the global
-concurrent executor. They stay on whichever actor called them. This eliminates
-many "sending X risks causing data races" errors.
-
-### Default MainActor isolation
-
-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.
-- Mutable state is safe without explicit annotation.
-
-### Isolated conformances
-
-Protocol conformances can be explicitly isolated:
-`extension Foo: @MainActor SomeProtocol`. The compiler prevents using the
-conformance outside the matching isolation context.
-
-## Applying Fixes in This Mode
-
-- **Prefer minimal annotations.** Let default MainActor isolation do the work
-  for UI-bound code.
-- **Use isolated conformances** instead of `nonisolated` workarounds for
-  protocol conformances.
-- **Keep global/shared mutable state on MainActor** unless there is a clear
-  performance need to offload.
-- **Remove redundant `@MainActor` annotations** that are now implied by the
-  default isolation mode.
-
-## Offloading Work
-
-- Use `@concurrent` on async functions that must run on the concurrent pool.
-- Make types or members `nonisolated` only when they are truly thread-safe and
-  used off the main actor.
-- Continue to respect `Sendable` boundaries when values cross actors or tasks.
-
-## Common Pitfalls
-
-| Pitfall | Why it happens | Fix |
+## Which mode is this target in?
+
+- **Xcode 26:** open Build Settings and read the Swift Compiler - Concurrency
+  group.
+- **Language version:** approachable concurrency needs Swift 6.2 or later.
+- **Approachable Concurrency = Yes:** the upcoming features
+  `NonisolatedNonsendingByDefault`, isolated-conformance inference, inferred
+  `Sendable` for captures and related global-actor usability changes are on.
+- **Default Actor Isolation = MainActor:** declarations without an isolation
+  annotation are inferred `@MainActor`.
+- **Strict Concurrency Checking:** Swift 6 language mode is always complete and
+  reports errors. Complete, Targeted and Minimal are choices for Swift 5 mode.
+- **SwiftPM:** the same switches appear as entries in each target's
+  `swiftSettings` in `Package.swift`.
+
+## What changes
+
+- A `nonisolated` async function keeps running on the actor that called it
+  instead of moving to the global concurrent executor, as long as
+  `NonisolatedNonsendingByDefault` is on. Many "sending 'x' risks causing data
+  races" errors go away as a result.
+- With default MainActor isolation, globals and statics are protected,
+  conformances are isolated to the main actor, and ordinary mutable state is
+  safe without annotation.
+- A conformance can also be isolated by hand:
+  `extension Timeline: @MainActor Refreshable`. The compiler rejects any use
+  of it outside main-actor code.
+
+## Fixing code in this mode
+
+- Add as few annotations as possible; let the default isolate UI code.
+- For protocol conformances, reach for an isolated conformance before a
+  `nonisolated` workaround.
+- Keep shared mutable state on the main actor unless profiling gives a reason
+  to move it.
+- Delete `@MainActor` attributes the default already implies.
+
+### Moving work off the main actor
+
+- Put `@concurrent` on async functions that must run on the thread pool.
+- Mark a type or member `nonisolated` only if it really is safe to use from
+  several threads and actually runs off the main actor.
+- Values crossing between actors or tasks still have to be `Sendable`.
+
+## Pitfalls
+
+| Symptom | Cause | Fix |
 |---|---|---|
-| CPU-heavy work on MainActor | Default isolation hides the problem | Move to `@concurrent` async function |
-| `Task.detached` breaking isolation | Ignores inherited actor context | Use `Task { }` unless you truly need detachment |
-| Redundant `@MainActor` everywhere | Default isolation already provides it | Remove explicit annotations |
-| `nonisolated` on mutable state | Breaks the safety guarantee | Keep mutable state isolated |
+| UI stutters after enabling the mode | CPU-heavy work now inferred onto the main actor | Move it into a `@concurrent` async function |
+| Isolation errors inside a new task | `Task.detached` drops the inherited actor | Use `Task { }` unless detachment is the point |
+| `@MainActor` on nearly every declaration | Annotations from before the default was on | Remove the redundant ones |
+| Races reappear | `nonisolated` placed on mutable state | Keep mutable state isolated |
 
-## Concurrency Keywords
+## Keywords
 
-| Keyword | What it does |
+| Keyword | Meaning |
 |---|---|
-| `async` | Function can suspend |
-| `await` | Suspend here until done |
-| `Task { }` | Start async work, inherits context |
-| `Task.detached { }` | Start async work, no inherited context |
-| `Task.immediate { }` | Start immediately on current actor |
-| `@MainActor` | Runs on main thread |
-| `actor` | Type with isolated mutable state |
-| `nonisolated` | Opts out of actor isolation |
+| `async` | The function may suspend |
+| `await` | A point where the caller may suspend until the call finishes |
+| `Task { }` | New unstructured work that inherits actor, priority and task-locals |
+| `Task.detached { }` | New unstructured work that inherits none of them |
+| `Task.immediate { }` | New work that starts running at once on the current actor |
+| `@MainActor` | Isolated to the main actor, which runs on the main thread |
+| `actor` | Reference type whose mutable state is isolated to itself |
+| `nonisolated` | Not isolated to any actor |
 | `Sendable` | Safe to pass between isolation domains |
-| `@concurrent` | Always run on background thread pool (Swift 6.2+) |
-| `async let` | Start parallel work (fixed count) |
-| `TaskGroup` | Dynamic parallel work |
-| `sending` | Parameter-level isolation transfer (SE-0430) |
+| `@concurrent` | Always runs on the concurrent thread pool (Swift 6.2) |
+| `async let` | Concurrent child work, fixed count |
+| `TaskGroup` | Concurrent child work, count decided at run time |
+| `sending` | Parameter or result that transfers a value to another isolation (SE-0430) |

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

@@ -1,113 +1,77 @@
 # 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-async-algorithms` is an open-source Apple package that brings the
+familiar `Sequence` algorithms, plus time-based ones, to `AsyncSequence`.
 
 ```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)
-}
+// Package.swift
+dependencies: [
+    .package(
+        url: "https://github.com/apple/swift-async-algorithms",
+        .upToNextMajor(from: "1.0.0")
+    )
+],
+targets: [
+    .target(
+        name: "Feed",
+        dependencies: [.product(name: "AsyncAlgorithms", package: "swift-async-algorithms")]
+    )
+]
 ```
 
-### Temporal
+Then `import AsyncAlgorithms` in the source files that use it.
 
-```swift
-// Debounce  -  emit after a quiet period (e.g., search-as-you-type)
-let searchResults = searchTerms
-    .debounce(for: .milliseconds(300))
+## Combining sequences
 
-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)
-}
+| Function | Result |
+|---|---|
+| `merge(first, second)` | One sequence with elements from both, in the order they arrive |
+| `combineLatest(first, second)` | The most recent pair, emitted whenever either side produces |
+| `zip(first, second)` | Elements paired one to one; waits until both sides have one |
+| `chain(first, second)` | All of `first`, then all of `second` |
 
-// 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
-}
+## Time-based operators
 
-for await batch in events.chunked(by: .repeating(every: .seconds(1))) {
-    await processBatch(batch)
-}
-```
+| Operator | Behavior | Typical use |
+|---|---|---|
+| `.debounce(for: .milliseconds(250))` | Emits only after the input goes quiet for the interval | Search fields |
+| `.chunks(ofCount: 20)` | Arrays of up to 20 elements | Batch writes |
+| `.chunked(by: .repeating(every: .seconds(5)))` | Arrays collected per time window | Periodic flushes |
+| `.chunks(ofCount: 25, or: .repeating(every: .seconds(2)))` | A batch when it is full or when the timer fires, whichever comes first | Batch uploads with a latency cap |
 
-### Filtering and Transformation
+Throttling ships in the 1.x releases only as the underscored `_throttle(for:)`,
+which is not stable public API; do not build on it.
 
-```swift
-// Remove consecutive duplicates
-for await value in stream.removeDuplicates() {
-    handle(value)
-}
+## Filtering and cleanup
 
-// Compacted  -  remove nils (like compactMap without transform)
-let values: AsyncStream<Int?> = ...
-for await value in values.compacted() {
-    // value is non-optional Int
-}
-```
+- `.removeDuplicates()` drops an element equal to the one just before it.
+- `.compacted()` removes `nil` from a sequence of optionals, the same as
+  `compactMap { $0 }`.
 
-## Common Patterns
+## Patterns
 
-### Search-as-you-type
+### Search as the user types
 
 ```swift
-func searchResults(for terms: AsyncStream<String>) -> AsyncStream<[Result]> {
+func suggestions(for queries: AsyncStream<String>) -> AsyncStream<[Place]> {
     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 ?? [])
+        let worker = Task {
+            for await query in queries.debounce(for: .milliseconds(250)).removeDuplicates() {
+                if Task.isCancelled { break }
+                let places = (try? await geocoder.search(query)) ?? []
+                continuation.yield(places)
             }
             continuation.finish()
         }
+        continuation.onTermination = { _ in worker.cancel() }
     }
 }
 ```
 
-### Rate-limited API calls
+### Batched uploads
 
 ```swift
-for await batch in requestStream.chunks(ofCount: 50).throttle(for: .seconds(1)) {
-    await api.sendBatch(batch)
+for await batch in pendingEvents.chunks(ofCount: 25, or: .repeating(every: .seconds(2))) {
+    try await analytics.upload(batch)
 }
 ```