@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

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

@@ -5,12 +5,17 @@ description: "Create child communication safety experiences using PermissionKit
 
 # PermissionKit
 
-> **Note:** PermissionKit is new in iOS 26. Method signatures should be verified against the latest Xcode 26 beta SDK.
+> **Note:** PermissionKit APIs span multiple 26.x releases. Verify signatures
+> and availability against the current Xcode 26 SDK before shipping.
 
 Request permission from a parent or guardian to modify a child's communication
 rules. PermissionKit creates communication safety experiences that let children
 ask for exceptions to communication limits set by their parents. Targets
-Swift 6.2 / iOS 26+.
+Swift 6.3 / iOS 26+.
+
+PermissionKit communication experiences are available only through iMessage.
+Use it for parent/guardian approval flows, not as a general in-app contact
+permission, moderation, or chat-safety framework.
 
 ## Contents
 
@@ -28,13 +33,27 @@ Swift 6.2 / iOS 26+.
 
 ## Setup
 
-Import `PermissionKit`. No special entitlements are required.
+Import `PermissionKit`. Do not invent PermissionKit entitlement keys; verify
+current Apple documentation and Xcode capabilities before adding signing
+requirements.
 
 ```swift
 import PermissionKit
 ```
 
-**Platform availability:** iOS 26+, iPadOS 26+, macOS 26+.
+**Platform availability:**
+
+When reviewing or correcting code, state these exact tiers instead of collapsing
+PermissionKit to "iOS 26+":
+
+- Core topic, handle, question, response, choice, and `CommunicationLimits`
+  APIs: iOS 26.0+, iPadOS 26.0+, Mac Catalyst 26.0+, macOS 26.0+,
+  visionOS 26.0+.
+- `AskError`: iOS 26.1+, iPadOS 26.1+, Mac Catalyst 26.1+, macOS 26.1+,
+  visionOS 26.1+.
+- `AskCenter`, `AskCenter.ask(_:in:)`, `AskCenter.responses(for:)`,
+  `PermissionButton`, and `SignificantAppUpdateTopic`: iOS/iPadOS/
+  Mac Catalyst/macOS/visionOS 26.2+.
 
 ## Core Concepts
 
@@ -57,25 +76,33 @@ PermissionKit manages a flow where:
 | `PermissionButton` | SwiftUI button that triggers the permission flow |
 | `CommunicationTopic` | Topic for communication-related permission requests |
 | `CommunicationHandle` | A phone number, email, or custom identifier |
-| `CommunicationLimits` | Checks whether communication limits apply |
+| `CommunicationLimits` | Checks which communication handles are known to the system |
 | `SignificantAppUpdateTopic` | Topic for significant app update permission requests |
 
 ## Checking Communication Limits
 
-Before presenting a permission request, check if communication limits are
-enabled and whether the handle is known.
+Use `CommunicationLimits.current` to check whether the system already knows a
+communication handle for your app. This is not an "are communication limits
+enabled?" probe. If limits are not enabled, `AskCenter.shared.ask(_:in:)`
+throws `AskError.communicationLimitsNotEnabled`; handle that path when asking.
+
+`knownHandles(in:)` also requires the calling app to have a non-nil, nonempty
+bundle identifier. Corrected code should guard `Bundle.main.bundleIdentifier`
+before calling it.
 
 ```swift
 import PermissionKit
 
-func checkCommunicationStatus(for handle: CommunicationHandle) async -> Bool {
+func needsPermissionPrompt(for handle: CommunicationHandle) async -> Bool {
     let limits = CommunicationLimits.current
     let isKnown = await limits.isKnownHandle(handle)
-    return isKnown
+    return !isKnown
 }
 
-// Check multiple handles at once
+// Check multiple handles at once.
 func filterKnownHandles(_ handles: Set<CommunicationHandle>) async -> Set<CommunicationHandle> {
+    guard Bundle.main.bundleIdentifier?.isEmpty == false else { return [] }
+
     let limits = CommunicationLimits.current
     return await limits.knownHandles(in: handles)
 }
@@ -159,7 +186,10 @@ let question = PermissionQuestion<CommunicationTopic>(communicationTopic: topic)
 
 ## Requesting Permission with AskCenter
 
-Use `AskCenter.shared` to present the permission request to the child.
+Use `AskCenter.shared` to request that the child send the permission question
+to their parent or guardian. The async `ask` call starts the send flow; parent
+decisions arrive later through `responses(for:)`. If the child cancels the send
+flow, the system does not deliver a `PermissionResponse` for that question.
 
 ```swift
 import PermissionKit
@@ -170,11 +200,11 @@ func requestPermission(
 ) async {
     do {
         try await AskCenter.shared.ask(question, in: viewController)
-        // Question was presented to the child
+        // Question send flow was started; wait for responses(for:) separately.
     } catch let error as AskError {
         switch error {
         case .communicationLimitsNotEnabled:
-            // Communication limits not active -- no permission needed
+            // Communication limits not active -- continue with normal app flow.
             break
         case .contactSyncNotSetup:
             // Contact sync not configured
@@ -198,8 +228,10 @@ func requestPermission(
 
 ## SwiftUI Integration with PermissionButton
 
-`PermissionButton` is a SwiftUI view that triggers the permission flow
-when tapped.
+`PermissionButton` is a SwiftUI view that triggers the permission flow when
+tapped. It uses the same response model as `AskCenter`: observe responses and
+model a pending/canceled state instead of assuming every tap produces a parent
+decision.
 
 ```swift
 import SwiftUI
@@ -218,36 +250,30 @@ struct ContactPermissionView: View {
 }
 ```
 
-### PermissionButton with Custom Topic
+For richer SwiftUI flows, custom topics, and long-lived managers, read
+[references/permissionkit-patterns.md](references/permissionkit-patterns.md).
 
-```swift
-struct CustomPermissionView: View {
-    var body: some View {
-        let personInfo = CommunicationTopic.PersonInformation(
-            handle: CommunicationHandle(value: "user456", kind: .custom),
-            nameComponents: nil,
-            avatarImage: nil
-        )
-        let topic = CommunicationTopic(
-            personInformation: [personInfo],
-            actions: [.follow]
-        )
-        let question = PermissionQuestion<CommunicationTopic>(
-            communicationTopic: topic
-        )
+## Handling Responses
 
-        PermissionButton(question: question) {
-            Text("Ask to Follow")
-        }
-    }
+Listen for permission responses asynchronously. Track pending questions by
+`question.id`, and give the UI a retry or expiration path because a child can
+cancel the iMessage send flow without producing a response.
+When combining known-handle checks with response handling, carry forward the
+bundle-identifier guard from `knownHandles(in:)`.
+
+```swift
+enum PermissionRequestState {
+    case pending, approved, denied, expired
 }
-```
 
-## Handling Responses
+var requestStates: [UUID: PermissionRequestState] = [:]
 
-Listen for permission responses asynchronously.
+func expireIfStillPending(_ id: UUID) {
+    guard requestStates[id] == .pending else { return }
+    requestStates[id] = .expired
+    // Re-enable asking or show retry/canceled UI.
+}
 
-```swift
 func observeResponses() async {
     let responses = AskCenter.shared.responses(for: CommunicationTopic.self)
 
@@ -258,9 +284,11 @@ func observeResponses() async {
         switch choice.answer {
         case .approval:
             // Parent approved -- enable communication
+            requestStates[question.id] = .approved
             print("Approved for topic: \(question.topic)")
         case .denial:
             // Parent denied -- keep restriction
+            requestStates[question.id] = .denied
             print("Denied")
         @unknown default:
             break
@@ -285,6 +313,10 @@ let declined = PermissionChoice.decline
 ## Significant App Update Topic
 
 Request permission for significant app updates that require parental approval.
+Your app determines what counts as significant based on applicable regulations
+and should consult qualified legal counsel for compliance interpretation.
+Use concise, understandable descriptions that state the concrete change parents
+are approving.
 
 ```swift
 let updateTopic = SignificantAppUpdateTopic(
@@ -297,38 +329,46 @@ let question = PermissionQuestion<SignificantAppUpdateTopic>(
 
 // Present the question
 try await AskCenter.shared.ask(question, in: viewController)
+requestStates[question.id] = .pending
+scheduleExpiration(for: question.id)
 
 // Listen for responses
 for await response in AskCenter.shared.responses(for: SignificantAppUpdateTopic.self) {
     switch response.choice.answer {
     case .approval:
         // Proceed with update
-        break
+        requestStates[response.question.id] = .approved
     case .denial:
         // Skip update
-        break
+        requestStates[response.question.id] = .denied
     @unknown default:
         break
     }
 }
+
+// If no response arrives before your pending window expires, keep the update
+// blocked or offer a retry. Child cancellation produces no denial response.
 ```
 
 ## Common Mistakes
 
-### DON'T: Skip checking if communication limits are enabled
+### DON'T: Treat known-handle checks as enabled-limits checks
 
-If communication limits are not enabled, calling `ask` throws
-`.communicationLimitsNotEnabled`. Check first or handle the error.
+`isKnownHandle(_:)` and `knownHandles(in:)` only classify handles. They do not
+replace handling `.communicationLimitsNotEnabled` from `ask(_:in:)`.
 
 ```swift
-// WRONG: Assuming limits are always active
-try await AskCenter.shared.ask(question, in: viewController)
+// WRONG: Assuming a handle lookup proves active limits
+let isKnown = await CommunicationLimits.current.isKnownHandle(handle)
+if !isKnown {
+    try await AskCenter.shared.ask(question, in: viewController)
+}
 
 // CORRECT: Handle the case where limits are not enabled
 do {
     try await AskCenter.shared.ask(question, in: viewController)
 } catch AskError.communicationLimitsNotEnabled {
-    // Communication limits not active -- allow communication directly
+    // Communication limits not active -- continue with normal app flow.
     allowCommunication()
 } catch {
     handleError(error)
@@ -383,10 +423,11 @@ let handle = CommunicationHandle(value: "+1234567890", kind: .phoneNumber)
 let question = PermissionQuestion<CommunicationTopic>(handle: handle)
 ```
 
-### DON'T: Forget to observe responses
+### DON'T: Forget to observe responses and pending states
 
-Presenting a question without listening for the response means you never
-know if the parent approved.
+Presenting a question without listening for the response means you never know
+if the parent approved. A child can also cancel the send flow, so do not wait
+forever for a response to every question.
 
 ```swift
 // WRONG: Fire and forget
@@ -419,20 +460,28 @@ PermissionButton(question: question) {
 
 ## Review Checklist
 
+- [ ] iMessage-only routing understood before choosing PermissionKit
+- [ ] Corrected guidance states exact availability tiers: core communication
+  types/limits 26.0+, `AskError` 26.1+, and `AskCenter`/`PermissionButton`/
+  responses/significant-update topics 26.2+
 - [ ] `AskError.communicationLimitsNotEnabled` handled to allow fallback
 - [ ] `AskError` cases handled individually with appropriate user feedback
 - [ ] `CommunicationHandle` created with correct `Kind` (phone, email, custom)
+- [ ] Known-handle examples guard a non-nil, nonempty bundle identifier before
+  `knownHandles(in:)`
+- [ ] Known-handle checks are not treated as active-limits checks
 - [ ] `PermissionQuestion` includes at least one handle or person information
 - [ ] `AskCenter.shared.responses(for:)` observed to receive parent decisions
 - [ ] `PermissionButton` used instead of deprecated `CommunicationLimitsButton`
 - [ ] Person information includes name components for a clear permission prompt
 - [ ] Communication actions match the app's actual communication capabilities
+- [ ] Pending/canceled/expired question states handled when no response arrives
 - [ ] Response handling updates UI on the main actor
 - [ ] Error states provide clear guidance to the user
 
 ## References
 
-- Extended patterns (response handling, multi-topic, UIKit): `references/permissionkit-patterns.md`
+- Extended patterns (response handling, multi-topic, UIKit): [references/permissionkit-patterns.md](references/permissionkit-patterns.md)
 - [PermissionKit framework](https://sosumi.ai/documentation/permissionkit)
 - [AskCenter](https://sosumi.ai/documentation/permissionkit/askcenter)
 - [PermissionQuestion](https://sosumi.ai/documentation/permissionkit/permissionquestion)

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

@@ -0,0 +1,47 @@
+{
+  "skill_name": "permissionkit",
+  "evals": [
+    {
+      "id": 0,
+      "name": "availability-imessage-review",
+      "prompt": "Review this PermissionKit setup for an app that supports iOS 26.0 and iPadOS 26.0: the team uses PermissionButton and AskCenter everywhere without availability checks, says PermissionKit can route child approval through our own in-app DM system, and wants to add a made-up PermissionKit entitlement. Write the corrected implementation guidance.",
+      "expected_output": "A concise PermissionKit setup review that distinguishes 26.0/26.1/26.2 API availability, preserves the iMessage-only communication-experience limitation, and avoids invented entitlement requirements.",
+      "files": [],
+      "assertions": [
+        "States that core PermissionKit topic, handle, question, response, choice, and CommunicationLimits APIs are available starting in iOS/iPadOS 26.0.",
+        "States that AskError starts in iOS/iPadOS 26.1 and AskCenter, AskCenter ask/responses APIs, PermissionButton, and SignificantAppUpdateTopic require iOS/iPadOS 26.2 or appropriate availability checks.",
+        "Says PermissionKit communication experiences are available only through iMessage and should not be presented as an arbitrary in-app DM routing framework.",
+        "Rejects inventing a PermissionKit entitlement key and says to verify current Apple docs/Xcode capabilities before adding signing requirements.",
+        "Keeps the answer focused on PermissionKit rather than turning it into a general chat moderation or family-account architecture."
+      ]
+    },
+    {
+      "id": 1,
+      "name": "known-handle-response-flow",
+      "prompt": "Fix this PermissionKit flow: before showing an Ask button we call `isKnownHandle(_:)` and treat `false` as proof that communication limits are enabled, then call `AskCenter.shared.ask` without handling `communicationLimitsNotEnabled`, and our UI waits forever for a PermissionResponse after every tap. Give corrected Swift-level guidance and pseudocode.",
+      "expected_output": "A corrected PermissionKit communication flow that separates known-handle lookup from enabled-limits handling, catches AskError cases, tracks pending questions, and accounts for child cancellation.",
+      "files": [],
+      "assertions": [
+        "Explains that isKnownHandle(_:) and knownHandles(in:) classify system-known handles and do not prove communication limits are enabled.",
+        "Mentions that knownHandles(in:) requires a non-nil, nonempty app bundle identifier.",
+        "Handles AskError.communicationLimitsNotEnabled from AskCenter.shared.ask as the normal fallback when communication limits are not active.",
+        "Uses AskCenter.shared.responses(for: CommunicationTopic.self) to observe parent decisions rather than deprecated CommunicationLimits ask/update APIs.",
+        "Models pending, retry, cancellation, or expiration because child cancellation of the iMessage send flow may produce no PermissionResponse."
+      ]
+    },
+    {
+      "id": 2,
+      "name": "significant-update-boundary",
+      "prompt": "A children’s app wants to use `SignificantAppUpdateTopic(description: \"We improved the app\")` on devices running iOS 26.0, skip response observation, and use the same flow for every terms-of-service wording tweak. Review the plan and provide the minimal corrected PermissionKit guidance.",
+      "expected_output": "A significant-app-update PermissionKit review that guards iOS/iPadOS 26.2 APIs, requires concrete descriptions, explains the developer/regulatory significance decision, and observes responses.",
+      "files": [],
+      "assertions": [
+        "States that SignificantAppUpdateTopic and the matching AskCenter ask/responses flow require iOS/iPadOS 26.2+ availability.",
+        "Says the app developer determines whether an update is significant based on applicable regulations rather than using the topic for every small wording tweak.",
+        "Replaces vague descriptions like \"We improved the app\" with concise, understandable text describing concrete user-visible changes.",
+        "Observes AskCenter.shared.responses(for: SignificantAppUpdateTopic.self) and handles approval, denial, and missing response states.",
+        "Keeps legal/regulatory discussion at the boundary and does not provide jurisdiction-specific legal advice."
+      ]
+    }
+  ]
+}

package/pipeline/skills/shared/external/permissionkit/references/permissionkit-patterns.md

@@ -16,6 +16,8 @@ that exceed the main skill file's scope.
 ## Full UIKit Integration
 
 Complete UIKit view controller with permission request and response handling.
+Keep the pending state explicit: if the child cancels the iMessage send flow,
+PermissionKit does not deliver a `PermissionResponse` for that question.
 
 ```swift
 import UIKit
@@ -56,6 +58,7 @@ class ContactViewController: UIViewController {
             do {
                 try await AskCenter.shared.ask(question, in: self)
                 showPendingState(for: contact)
+                schedulePendingExpiration(for: question.id)
             } catch AskError.communicationLimitsNotEnabled {
                 enableMessaging(for: contact)
             } catch AskError.notAvailable {
@@ -100,6 +103,7 @@ class ContactViewController: UIViewController {
     }
 
     private func showPendingState(for contact: Contact) { }
+    private func schedulePendingExpiration(for id: UUID) { }
     private func enableMessaging(for contact: Contact) { }
     private func enableCommunication(for handle: CommunicationHandle) { }
     private func showDeniedState(for handle: CommunicationHandle) { }
@@ -122,6 +126,7 @@ final class PermissionManager {
 
     var approvedHandles: Set<String> = []
     var deniedHandles: Set<String> = []
+    var pendingHandleValues: Set<String> = []
     var pendingQuestionIDs: Set<UUID> = []
 
     private var observerTask: Task<Void, Never>?
@@ -157,7 +162,13 @@ final class PermissionManager {
         )
 
         try await AskCenter.shared.ask(question, in: viewController)
+        let handleValues = handles.map(\.value)
         pendingQuestionIDs.insert(question.id)
+        pendingHandleValues.formUnion(handleValues)
+        schedulePendingExpiration(
+            for: question.id,
+            handleValues: handleValues
+        )
     }
 
     func isApproved(_ handleValue: String) -> Bool {
@@ -168,6 +179,10 @@ final class PermissionManager {
         deniedHandles.contains(handleValue)
     }
 
+    func isPending(_ handleValue: String) -> Bool {
+        pendingHandleValues.contains(handleValue)
+    }
+
     private func startObserving() {
         observerTask = Task { [weak self] in
             let responses = AskCenter.shared.responses(
@@ -188,6 +203,9 @@ final class PermissionManager {
 
         let handleValues = response.question.topic.personInformation
             .map(\.handle.value)
+        for value in handleValues {
+            pendingHandleValues.remove(value)
+        }
 
         switch response.choice.answer {
         case .approval:
@@ -203,6 +221,14 @@ final class PermissionManager {
             break
         }
     }
+
+    private func schedulePendingExpiration(
+        for id: UUID,
+        handleValues: [String]
+    ) {
+        // Expire or offer retry if no response arrives after your product's
+        // chosen pending window. Child cancellation produces no response.
+    }
 }
 ```
 
@@ -250,7 +276,10 @@ func requestGroupPermission(
 
 ## Communication Limits Checking Pattern
 
-Check handles before building the permission UI.
+Check which handles are already known to the system before building the
+permission UI. This does not prove communication limits are enabled; still
+handle `AskError.communicationLimitsNotEnabled` when asking. `knownHandles(in:)`
+requires a non-nil, nonempty app bundle identifier.
 
 ```swift
 @Observable
@@ -262,18 +291,22 @@ final class ContactListViewModel {
         let id: String
         let name: String
         let handle: CommunicationHandle
-        var isKnown: Bool = false
-        var needsPermission: Bool = false
+        var isKnownBySystem: Bool = false
+        var needsPermissionPrompt: Bool = false
     }
 
     func refreshContactStatus() async {
+        guard Bundle.main.bundleIdentifier?.isEmpty == false else { return }
+
         let limits = CommunicationLimits.current
         let allHandles = Set(contacts.map(\.handle))
         let knownHandles = await limits.knownHandles(in: allHandles)
 
         for i in contacts.indices {
-            contacts[i].isKnown = knownHandles.contains(contacts[i].handle)
-            contacts[i].needsPermission = !contacts[i].isKnown
+            contacts[i].isKnownBySystem = knownHandles.contains(
+                contacts[i].handle
+            )
+            contacts[i].needsPermissionPrompt = !contacts[i].isKnownBySystem
         }
     }
 }
@@ -293,11 +326,12 @@ struct ContactDetailView: View {
     @Environment(PermissionManager.self) private var permissionManager
 
     enum PermissionState {
-        case unknown, checking, needsPermission, approved, denied, error(String)
+        case unknown, checking, needsPermission, approved, denied
+        case pending, error(String)
     }
 
     var body: some View {
-        VStack(spacing: 20) {
+        VStack {
             Text(contact.name)
                 .font(.title)
 
@@ -323,6 +357,10 @@ struct ContactDetailView: View {
                     .buttonStyle(.borderedProminent)
                 }
 
+            case .pending:
+                Label("Waiting for parent response", systemImage: "clock")
+                    .foregroundStyle(.secondary)
+
             case .approved:
                 Label("Messaging enabled", systemImage: "checkmark.circle.fill")
                     .foregroundStyle(.green)
@@ -356,6 +394,8 @@ struct ContactDetailView: View {
             permissionState = .approved
         } else if permissionManager.isDenied(contact.phoneNumber) {
             permissionState = .denied
+        } else if permissionManager.isPending(contact.phoneNumber) {
+            permissionState = .pending
         } else {
             permissionState = .needsPermission
         }
@@ -365,7 +405,7 @@ struct ContactDetailView: View {
 
 ## macOS Integration
 
-On macOS, pass an `NSWindow` instead of `UIViewController`.
+On macOS 26.2+, pass an `NSWindow` instead of `UIViewController`.
 
 ```swift
 #if os(macOS)

package/pipeline/skills/shared/external/photos-camera-media/SKILL.md

@@ -1,13 +1,11 @@
 ---
 name: photos-camera-media
-description: "Implement, review, or improve photo picking, camera capture, and media handling in iOS apps. Use when working with PhotosPicker, PHPickerViewController, camera capture sessions (AVCaptureSession), photo library access, image loading and display, video recording, or media permissions. Also use when selecting photos from the library, taking pictures, recording video, processing images, or handling photo/camera privacy permissions in Swift apps."
+description: "Implement, review, or improve photo picking, camera capture, and media handling in iOS apps using PhotoKit and AVFoundation. Use when working with PhotosPicker, PHPickerViewController, camera capture sessions (AVCaptureSession), photo library access, image loading and display, video recording, or media permissions. Also use when selecting photos from the library, taking pictures, recording video, processing images, or handling photo/camera privacy permissions in Swift apps."
 ---
 
-# Photos, Camera & Media
+# PhotoKit
 
-Modern patterns for photo picking, camera capture, image loading, and media permissions targeting iOS 26+ with Swift 6.2. Patterns are backward-compatible to iOS 16 unless noted.
-
-See `references/photospicker-patterns.md` for complete picker recipes and `references/camera-capture.md` for AVCaptureSession patterns.
+Modern patterns for photo picking, camera capture, image loading, and media permissions targeting iOS 26+ with Swift 6.3. Patterns are backward-compatible to iOS 16 unless noted. See [references/photokit-patterns.md](references/photokit-patterns.md) for complete picker recipes and [references/camera-capture.md](references/camera-capture.md) for AVCaptureSession patterns.
 
 ## Contents
 
@@ -72,7 +70,7 @@ struct MultiPhotoPicker: View {
                             .resizable()
                             .scaledToFill()
                             .frame(width: 100, height: 100)
-                            .clipShape(RoundedRectangle(cornerRadius: 8))
+                            .clipShape(.rect(cornerRadius: 8))
                     }
                 }
             }
@@ -249,7 +247,7 @@ Omitting a required key causes a runtime crash when the permission dialog would
 
 ## Camera Capture Basics
 
-Manage camera sessions in a dedicated `@Observable` model. The representable view only displays the preview. See `references/camera-capture.md` for complete patterns.
+Manage camera sessions in a dedicated `@Observable` model. The representable view only displays the preview. See [references/camera-capture.md](references/camera-capture.md) for complete patterns.
 
 ### Minimal Camera Manager
 
@@ -368,7 +366,7 @@ struct CameraScreen: View {
                     .frame(width: 72, height: 72)
                     .overlay(Circle().stroke(.gray, lineWidth: 3))
             }
-            .padding(.bottom, 32)
+            .padding(.bottom)
         }
         .task {
             await cameraManager.configure()
@@ -404,10 +402,10 @@ AsyncImage(url: imageURL) { phase in
     }
 }
 .frame(width: 200, height: 200)
-.clipShape(RoundedRectangle(cornerRadius: 12))
+.clipShape(.rect(cornerRadius: 12))
 ```
 
-`AsyncImage` does not cache images across view redraws. For production apps with many images, use a dedicated image loading library or implement `URLCache`-based caching.
+`AsyncImage` does not cache images across view redraws. For production apps with many images, use a dedicated image loading library or `URLCache`-based caching.
 
 ### Downsampling Large Images
 
@@ -491,11 +489,11 @@ Use `.original` for photos and artwork. Use `.template` for icons that should ad
 - [ ] Camera session started on background thread; stopped in `onDisappear`
 - [ ] Permission denial handled with Settings deep link
 - [ ] `AVCaptureSession` owned by model, not created inside `UIViewRepresentable`
-- [ ] Media asset types and picker results are `Sendable` when passed across concurrency boundaries
+- [ ] Media asset types and picker results are `Sendable` across concurrency boundaries
 
 ## References
 
-- `references/photospicker-patterns.md` — Picker patterns, media loading, HEIC handling
-- `references/camera-capture.md` — AVCaptureSession, photo/video capture, QR scanning
-- `references/image-loading-caching.md` — AsyncImage, caching, downsampling
-- `references/av-playback.md` — AVPlayer, streaming, audio session, background audio
+- [references/photokit-patterns.md](references/photokit-patterns.md)  -  Picker patterns, media loading, HEIC handling
+- [references/camera-capture.md](references/camera-capture.md)  -  AVCaptureSession, photo/video capture, QR scanning
+- [references/image-loading-caching.md](references/image-loading-caching.md)  -  AsyncImage, caching, downsampling
+- [references/av-playback.md](references/av-playback.md)  -  AVPlayer, streaming, audio

package/pipeline/skills/shared/external/photos-camera-media/references/camera-capture.md

@@ -264,7 +264,7 @@ struct CameraScreen: View {
                                 .resizable()
                                 .scaledToFill()
                                 .frame(width: 50, height: 50)
-                                .clipShape(RoundedRectangle(cornerRadius: 8))
+                                .clipShape(.rect(cornerRadius: 8))
                         }
                     } else {
                         Color.clear.frame(width: 50, height: 50)
@@ -286,8 +286,8 @@ struct CameraScreen: View {
 
                     Color.clear.frame(width: 50, height: 50)
                 }
-                .padding(.horizontal, 24)
-                .padding(.bottom, 32)
+                .padding(.horizontal)
+                .padding(.bottom)
             }
         }
         .task {
@@ -637,7 +637,7 @@ struct QRScannerView: View {
                         .font(.headline)
                         .padding()
                         .background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 12))
-                        .padding(.bottom, 60)
+                        .padding(.bottom)
                 }
             }
         }

package/pipeline/skills/shared/external/photos-camera-media/references/image-loading-caching.md

@@ -1,6 +1,6 @@
 # Image Loading and Caching Patterns
 
-Complete patterns for efficient image handling in iOS apps, from basic AsyncImage usage through production-ready caching and loading pipelines. All patterns use modern Swift async/await and target iOS 26 with Swift 6.2, backward-compatible to iOS 16 unless noted.
+Complete patterns for efficient image handling in iOS apps, from basic AsyncImage usage through production-ready caching and loading pipelines. All patterns use modern Swift async/await and target iOS 26 with Swift 6.3, backward-compatible to iOS 16 unless noted.
 
 ## Contents
 - AsyncImage Patterns
@@ -63,7 +63,7 @@ AsyncImage(url: imageURL, transaction: Transaction(animation: .easeIn(duration:
     }
 }
 .frame(width: 200, height: 200)
-.clipShape(RoundedRectangle(cornerRadius: 12))
+.clipShape(.rect(cornerRadius: 12))
 ```
 
 ### Limitations

package/pipeline/skills/shared/external/photos-camera-media/references/{photospicker-patterns.md → photokit-patterns.md}

@@ -104,13 +104,13 @@ struct MultiPhotoLoader: View {
             }
 
             ScrollView(.horizontal) {
-                LazyHStack(spacing: 8) {
+                LazyHStack {
                     ForEach(loadedImages.indices, id: \.self) { index in
                         Image(uiImage: loadedImages[index])
                             .resizable()
                             .scaledToFill()
                             .frame(width: 100, height: 100)
-                            .clipShape(RoundedRectangle(cornerRadius: 8))
+                            .clipShape(.rect(cornerRadius: 8))
                     }
                 }
                 .padding(.horizontal)
@@ -478,7 +478,7 @@ struct PhotoGridItem: View {
             }
         }
         .frame(width: 100, height: 100)
-        .clipShape(RoundedRectangle(cornerRadius: 6))
+        .clipShape(.rect(cornerRadius: 6))
         .task {
             thumbnail = downsample(data: imageData, to: thumbnailSize)
         }