@mmerterden/multi-agent-pipeline 20.36.0 → 20.37.0

package/pipeline/skills/shared/external/push-notifications/SKILL.md

@@ -132,28 +132,7 @@ A SwiftUI app still needs an app delegate for this: the device token is only
 delivered to `UIApplicationDelegate` callbacks. Attach one with
 `@UIApplicationDelegateAdaptor`.
 
-```swift
-final class AppDelegate: NSObject, UIApplicationDelegate {
-    func application(
-        _ application: UIApplication,
-        didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey: Any]? = nil
-    ) -> Bool {
-        UNUserNotificationCenter.current().delegate = InboxNotificationDelegate.shared
-        return true
-    }
-
-    func application(_ application: UIApplication,
-                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
-        let hex = deviceToken.reduce(into: "") { $0 += String(format: "%02x", $1) }
-        Task { await DeviceTokenUploader.shared.send(hex) }
-    }
-
-    func application(_ application: UIApplication,
-                     didFailToRegisterForRemoteNotificationsWithError error: Error) {
-        // Expected on Simulator: it can show simulated pushes but never gets an APNs token.
-    }
-}
-```
+Code for this section: [Notification code](references/notification-code.md).
 
 ### Order of calls
 
@@ -201,41 +180,11 @@ content.threadIdentifier = "garden"   // groups these together in Notification C
 
 ### Triggers
 
-```swift
-// Once, 15 minutes from now. A repeating interval must be at least 60 seconds.
-let soon = UNTimeIntervalNotificationTrigger(timeInterval: 900, repeats: false)
-
-// Every day at 07:30.
-var morning = DateComponents()
-morning.hour = 7
-morning.minute = 30
-let daily = UNCalendarNotificationTrigger(dateMatching: morning, repeats: true)
-
-// On arriving at a place. Needs at least When In Use location permission.
-let gym = CLCircularRegion(
-    center: CLLocationCoordinate2D(latitude: 52.37, longitude: 4.89),
-    radius: 150,
-    identifier: "gym"
-)
-gym.notifyOnEntry = true
-gym.notifyOnExit = false
-let arrival = UNLocationNotificationTrigger(region: gym, repeats: false)
-```
+Code for this section: [Notification code](references/notification-code.md).
 
 ### Scheduling and cleanup
 
-```swift
-let center = UNUserNotificationCenter.current()
-let request = UNNotificationRequest(identifier: "water-basil", content: content, trigger: daily)
-try await center.add(request)
-
-let waiting = await center.pendingNotificationRequests()
-
-center.removePendingNotificationRequests(withIdentifiers: ["water-basil"])
-center.removeAllPendingNotificationRequests()
-center.removeDeliveredNotifications(withIdentifiers: ["water-basil"])
-center.removeAllDeliveredNotifications()
-```
+Code for this section: [Notification code](references/notification-code.md).
 
 ## Remote Payloads
 
@@ -321,38 +270,6 @@ Let the device pick the language by sending keys instead of text:
 Install `UNUserNotificationCenter.current().delegate` before launch finishes,
 from `App.init` or from `application(_:didFinishLaunchingWithOptions:)`.
 
-```swift
-@MainActor
-final class InboxNotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
-    static let shared = InboxNotificationDelegate()
-
-    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter,
-                                            willPresent notification: UNNotification) async
-        -> UNNotificationPresentationOptions {
-        [.banner, .sound, .badge]
-    }
-
-    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter,
-                                            didReceive response: UNNotificationResponse) async {
-        let action = response.actionIdentifier
-        let threadID = response.notification.request.content.userInfo["threadID"] as? String
-        let typed = (response as? UNTextInputNotificationResponse)?.userText
-        await route(action: action, threadID: threadID, typed: typed)
-    }
-
-    private func route(action: String, threadID: String?, typed: String?) async {
-        switch action {
-        case UNNotificationDefaultActionIdentifier:
-            AppRouter.shared.openThread(threadID)       // tapped the notification
-        case UNNotificationDismissActionIdentifier:
-            break                                       // swiped away
-        default:
-            await handleChatAction(action, threadID: threadID, typed: typed)
-        }
-    }
-}
-```
-
 The system does not promise to call these methods on the main thread, and
 `UNNotification` and `UNNotificationResponse` are not `Sendable`. Mark the
 protocol methods `nonisolated`, copy the plain values you need out of the
@@ -362,6 +279,8 @@ actor.
 Leave out `willPresent` and anything that arrives while your app is frontmost
 is dropped without a banner.
 
+Code for this section: [Notification code](references/notification-code.md).
+
 ### Deep links from a tap
 
 Keep a single `@Observable @MainActor` router with an optional
@@ -374,29 +293,6 @@ it back to `nil`. A version that also switches tabs lives in the
 
 Register categories at launch, before any notification can arrive.
 
-```swift
-let reply = UNTextInputNotificationAction(
-    identifier: "REPLY",
-    title: "Reply",
-    options: [],
-    textInputButtonTitle: "Send",
-    textInputPlaceholder: "Message"
-)
-let archive = UNNotificationAction(identifier: "ARCHIVE", title: "Archive", options: [.destructive])
-let open = UNNotificationAction(identifier: "OPEN", title: "Open", options: [.foreground])
-let approve = UNNotificationAction(identifier: "APPROVE", title: "Approve", options: [.authenticationRequired])
-
-let chat = UNNotificationCategory(
-    identifier: "CHAT",
-    actions: [reply, archive],
-    intentIdentifiers: [],
-    options: [.customDismissAction]    // dismissal also reaches didReceive
-)
-let request = UNNotificationCategory(identifier: "EXPENSE", actions: [approve, open], intentIdentifiers: [])
-
-UNUserNotificationCenter.current().setNotificationCategories([chat, request])
-```
-
 | Option | Effect |
 |--------|--------|
 | `.authenticationRequired` | Runs only after the device is unlocked |
@@ -404,23 +300,9 @@ UNUserNotificationCenter.current().setNotificationCategories([chat, request])
 | `.foreground` | Tapping it opens the app |
 
 A text action's response arrives as a `UNTextInputNotificationResponse`; its
-`userText` is what the delegate above passes on as `typed`:
+`userText` is what the delegate passes on as `typed`.
 
-```swift
-@MainActor
-func handleChatAction(_ action: String, threadID: String?, typed: String?) async {
-    guard let threadID else { return }
-    switch action {
-    case "REPLY":
-        guard let typed, !typed.isEmpty else { return }
-        await ChatService.shared.send(typed, to: threadID)
-    case "ARCHIVE":
-        await ChatService.shared.archive(threadID)
-    default:
-        break
-    }
-}
-```
+Code for this section: [Notification code](references/notification-code.md).
 
 ## Grouping
 
@@ -470,6 +352,7 @@ let chat = UNNotificationCategory(
 
 ## Apple Documentation
 
+- [Notification code](references/notification-code.md): open for the code behind APNs registration, local triggers, the delegate and actions and categories.
 - [APNs registration](https://developer.apple.com/documentation/usernotifications/registering-your-app-with-apns)
 - [Requesting permission](https://developer.apple.com/documentation/usernotifications/asking-permission-to-use-notifications)
 - [Building a remote payload](https://developer.apple.com/documentation/usernotifications/generating-a-remote-notification)

package/pipeline/skills/shared/external/push-notifications/references/notification-code.md

@@ -0,0 +1,176 @@
+# Notification code
+
+<!-- toc -->
+- [Registering with APNs](#registering-with-apns)
+- [Triggers](#triggers)
+- [Scheduling and cleanup](#scheduling-and-cleanup)
+- [The delegate](#the-delegate)
+- [Actions and Categories](#actions-and-categories)
+<!-- /toc -->
+
+Code for APNs registration, local triggers and scheduling, the notification delegate and actions and categories. SKILL.md keeps the rules and review guidance.
+
+## Registering with APNs
+
+A SwiftUI app still needs an app delegate for this: the device token is only
+delivered to `UIApplicationDelegate` callbacks. Attach one with
+`@UIApplicationDelegateAdaptor`.
+
+```swift
+final class AppDelegate: NSObject, UIApplicationDelegate {
+    func application(
+        _ application: UIApplication,
+        didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey: Any]? = nil
+    ) -> Bool {
+        UNUserNotificationCenter.current().delegate = InboxNotificationDelegate.shared
+        return true
+    }
+
+    func application(_ application: UIApplication,
+                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+        let hex = deviceToken.reduce(into: "") { $0 += String(format: "%02x", $1) }
+        Task { await DeviceTokenUploader.shared.send(hex) }
+    }
+
+    func application(_ application: UIApplication,
+                     didFailToRegisterForRemoteNotificationsWithError error: Error) {
+        // Expected on Simulator: it can show simulated pushes but never gets an APNs token.
+    }
+}
+```
+
+### Triggers
+
+```swift
+// Once, 15 minutes from now. A repeating interval must be at least 60 seconds.
+let soon = UNTimeIntervalNotificationTrigger(timeInterval: 900, repeats: false)
+
+// Every day at 07:30.
+var morning = DateComponents()
+morning.hour = 7
+morning.minute = 30
+let daily = UNCalendarNotificationTrigger(dateMatching: morning, repeats: true)
+
+// On arriving at a place. Needs at least When In Use location permission.
+let gym = CLCircularRegion(
+    center: CLLocationCoordinate2D(latitude: 52.37, longitude: 4.89),
+    radius: 150,
+    identifier: "gym"
+)
+gym.notifyOnEntry = true
+gym.notifyOnExit = false
+let arrival = UNLocationNotificationTrigger(region: gym, repeats: false)
+```
+
+### Scheduling and cleanup
+
+```swift
+let center = UNUserNotificationCenter.current()
+let request = UNNotificationRequest(identifier: "water-basil", content: content, trigger: daily)
+try await center.add(request)
+
+let waiting = await center.pendingNotificationRequests()
+
+center.removePendingNotificationRequests(withIdentifiers: ["water-basil"])
+center.removeAllPendingNotificationRequests()
+center.removeDeliveredNotifications(withIdentifiers: ["water-basil"])
+center.removeAllDeliveredNotifications()
+```
+
+### The delegate
+
+Install `UNUserNotificationCenter.current().delegate` before launch finishes,
+from `App.init` or from `application(_:didFinishLaunchingWithOptions:)`.
+
+```swift
+@MainActor
+final class InboxNotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
+    static let shared = InboxNotificationDelegate()
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter,
+                                            willPresent notification: UNNotification) async
+        -> UNNotificationPresentationOptions {
+        [.banner, .sound, .badge]
+    }
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter,
+                                            didReceive response: UNNotificationResponse) async {
+        let action = response.actionIdentifier
+        let threadID = response.notification.request.content.userInfo["threadID"] as? String
+        let typed = (response as? UNTextInputNotificationResponse)?.userText
+        await route(action: action, threadID: threadID, typed: typed)
+    }
+
+    private func route(action: String, threadID: String?, typed: String?) async {
+        switch action {
+        case UNNotificationDefaultActionIdentifier:
+            AppRouter.shared.openThread(threadID)       // tapped the notification
+        case UNNotificationDismissActionIdentifier:
+            break                                       // swiped away
+        default:
+            await handleChatAction(action, threadID: threadID, typed: typed)
+        }
+    }
+}
+```
+
+The system does not promise to call these methods on the main thread, and
+`UNNotification` and `UNNotificationResponse` are not `Sendable`. Mark the
+protocol methods `nonisolated`, copy the plain values you need out of the
+response (all payload data sits in `content.userInfo`), then hop to the main
+actor.
+
+Leave out `willPresent` and anything that arrives while your app is frontmost
+is dropped without a banner.
+
+## Actions and Categories
+
+Register categories at launch, before any notification can arrive.
+
+```swift
+let reply = UNTextInputNotificationAction(
+    identifier: "REPLY",
+    title: "Reply",
+    options: [],
+    textInputButtonTitle: "Send",
+    textInputPlaceholder: "Message"
+)
+let archive = UNNotificationAction(identifier: "ARCHIVE", title: "Archive", options: [.destructive])
+let open = UNNotificationAction(identifier: "OPEN", title: "Open", options: [.foreground])
+let approve = UNNotificationAction(identifier: "APPROVE", title: "Approve", options: [.authenticationRequired])
+
+let chat = UNNotificationCategory(
+    identifier: "CHAT",
+    actions: [reply, archive],
+    intentIdentifiers: [],
+    options: [.customDismissAction]    // dismissal also reaches didReceive
+)
+let request = UNNotificationCategory(identifier: "EXPENSE", actions: [approve, open], intentIdentifiers: [])
+
+UNUserNotificationCenter.current().setNotificationCategories([chat, request])
+```
+
+| Option | Effect |
+|--------|--------|
+| `.authenticationRequired` | Runs only after the device is unlocked |
+| `.destructive` | Shown in red; for delete or remove |
+| `.foreground` | Tapping it opens the app |
+
+A text action's response arrives as a `UNTextInputNotificationResponse`; its
+`userText` is what the delegate above passes on as `typed`:
+
+```swift
+@MainActor
+func handleChatAction(_ action: String, threadID: String?, typed: String?) async {
+    guard let threadID else { return }
+    switch action {
+    case "REPLY":
+        guard let typed, !typed.isEmpty else { return }
+        await ChatService.shared.send(typed, to: threadID)
+    case "ARCHIVE":
+        await ChatService.shared.archive(threadID)
+    default:
+        break
+    }
+}
+```

package/pipeline/skills/shared/external/python-patterns/SKILL.md

@@ -105,117 +105,11 @@ user_set: set[User] = {user}
 
 ## Pydantic v2
 
-```python
-from pydantic import BaseModel, Field, field_validator, model_validator, ConfigDict
-from datetime import datetime
-
-class CreateUserRequest(BaseModel):
-    model_config = ConfigDict(str_strip_whitespace=True, frozen=True)
-
-    name: str = Field(min_length=1, max_length=100)
-    email: str = Field(pattern=r'^[\w.-]+@[\w.-]+\.\w+$')
-    age: int = Field(ge=0, le=150)
-    role: Role = Role.USER
-    tags: list[str] = Field(default_factory=list, max_length=10)
-
-    @field_validator('email')
-    @classmethod
-    def normalize_email(cls, v: str) -> str:
-        return v.lower()
-
-    @model_validator(mode='after')
-    def validate_admin_age(self) -> 'CreateUserRequest':
-        if self.role == Role.ADMIN and self.age < 18:
-            raise ValueError("Admin must be 18 or older")
-        return self
-
-class UserResponse(BaseModel):
-    id: str
-    name: str
-    email: str
-    role: Role
-    created_at: datetime
-
-    model_config = ConfigDict(from_attributes=True)
-
-# Validation
-try:
-    user = CreateUserRequest(name="Alice", email="ALICE@example.com", age=25)
-    print(user.email)  # "alice@example.com" (normalized)
-except ValidationError as e:
-    print(e.errors())
-
-# Serialization
-user_dict = user.model_dump()
-user_json = user.model_dump_json()
-
-# From ORM object
-db_user = db.query(UserModel).first()
-response = UserResponse.model_validate(db_user)
-```
+Code for this section: [Python pattern examples](references/python-examples.md).
 
 ## Async/Await with asyncio
 
-```python
-import asyncio
-from collections.abc import AsyncIterator
-import httpx
-
-# Async function
-async def fetch_user(user_id: str) -> dict:
-    async with httpx.AsyncClient() as client:
-        response = await client.get(f"https://api.example.com/users/{user_id}")
-        response.raise_for_status()
-        return response.json()
-
-# Parallel execution
-async def fetch_all_users(user_ids: list[str]) -> list[dict]:
-    async with httpx.AsyncClient() as client:
-        tasks = [
-            client.get(f"https://api.example.com/users/{uid}")
-            for uid in user_ids
-        ]
-        responses = await asyncio.gather(*tasks, return_exceptions=True)
-        return [
-            r.json() for r in responses
-            if not isinstance(r, Exception) and r.status_code == 200
-        ]
-
-# Async context manager
-from contextlib import asynccontextmanager
-
-@asynccontextmanager
-async def get_db_session() -> AsyncIterator[AsyncSession]:
-    session = AsyncSession(engine)
-    try:
-        yield session
-        await session.commit()
-    except Exception:
-        await session.rollback()
-        raise
-    finally:
-        await session.close()
-
-# Async generator
-async def stream_events(url: str) -> AsyncIterator[dict]:
-    async with httpx.AsyncClient() as client:
-        async with client.stream("GET", url) as response:
-            async for line in response.aiter_lines():
-                if line.startswith("data: "):
-                    yield json.loads(line[6:])
-
-# Semaphore for rate limiting
-async def fetch_with_limit(urls: list[str], max_concurrent: int = 10) -> list[str]:
-    semaphore = asyncio.Semaphore(max_concurrent)
-
-    async def fetch_one(url: str) -> str:
-        async with semaphore:
-            async with httpx.AsyncClient() as client:
-                resp = await client.get(url)
-                return resp.text
-
-    return await asyncio.gather(*[fetch_one(url) for url in urls])
-```
+Code for this section: [Python pattern examples](references/python-examples.md).
 
 ## Context Managers
 
@@ -301,56 +195,7 @@ active_users = filter_active(parse_csv(read_lines("users.csv")))
 
 ## Pattern Matching (match/case)
 
-```python
-from dataclasses import dataclass
-
-@dataclass
-class Point:
-    x: float
-    y: float
-
-def describe_point(point: Point) -> str:
-    match point:
-        case Point(x=0, y=0):
-            return "origin"
-        case Point(x=0, y=y):
-            return f"on y-axis at y={y}"
-        case Point(x=x, y=0):
-            return f"on x-axis at x={x}"
-        case Point(x=x, y=y) if x == y:
-            return f"on diagonal at {x}"
-        case _:
-            return f"at ({point.x}, {point.y})"
-
-# Matching on type and structure
-def handle_response(response: dict) -> str:
-    match response:
-        case {"status": 200, "data": data}:
-            return f"Success: {data}"
-        case {"status": 404}:
-            return "Not found"
-        case {"status": status} if 500 <= status < 600:
-            return f"Server error: {status}"
-        case {"error": str(message)}:
-            return f"Error: {message}"
-        case _:
-            return "Unknown response"
-
-# Matching sequences
-def process_command(command: list[str]) -> None:
-    match command:
-        case ["quit" | "exit"]:
-            sys.exit(0)
-        case ["go", direction]:
-            move(direction)
-        case ["pick", "up", item]:
-            pick_up(item)
-        case ["drop", *items] if items:
-            for item in items:
-                drop(item)
-        case _:
-            print(f"Unknown command: {' '.join(command)}")
-```
+Code for this section: [Python pattern examples](references/python-examples.md).
 
 ## Do's
 
@@ -384,3 +229,7 @@ def process_command(command: list[str]) -> None:
 | Type checker error with Protocol | Missing method or wrong signature | Match Protocol method signatures exactly |
 | Slow async code | Sequential awaits instead of parallel | Use `asyncio.gather()` or `asyncio.TaskGroup` for concurrency |
 | "TypeError: unhashable type" | Using mutable object as dict key | Use `frozen=True` dataclass or tuple instead |
+
+## References
+
+- [Python pattern examples](references/python-examples.md): open when writing Pydantic v2 models, asyncio concurrency or `match`/`case` code.