@mmerterden/multi-agent-pipeline 8.6.2 → 10.0.6

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

@@ -13,7 +13,9 @@ Rich notifications enhance the standard notification banner with images, video,
 
 ## Notification Service Extension
 
-A Notification Service Extension runs when a notification with `mutable-content: 1` arrives. It has approximately 30 seconds to modify the notification content before the system displays it. If the extension does not call the content handler in time, the system displays the original notification.
+A Notification Service Extension runs for an alerting remote notification whose payload has `mutable-content: 1` and an `alert` dictionary with title, subtitle, or body content. It has approximately 30 seconds to modify the notification content before the system displays it. Call the content handler on every path: success, partial failure, invalid payload, and `serviceExtensionTimeWillExpire()`. If the extension does not call the handler in time, the system displays the original notification.
+
+When reviewing a flawed rich-notification design, explicitly correct four contracts: silent pushes do not trigger service extensions; attachments must be supported files on disk and are validated and stored by the system; communication notifications require the capability, `NSUserActivityTypes`, `INInteraction` donation, and `content.updating(from:)`; every service-extension path, including download/decryption failures and `serviceExtensionTimeWillExpire()`, must call the content handler exactly once with original, best-attempt, or updated content.
 
 ### Creating the Extension
 
@@ -25,6 +27,7 @@ import UserNotifications
 class NotificationService: UNNotificationServiceExtension {
     private var contentHandler: ((UNNotificationContent) -> Void)?
     private var bestAttemptContent: UNMutableNotificationContent?
+    private var didComplete = false
 
     override func didReceive(
         _ request: UNNotificationRequest,
@@ -127,8 +130,8 @@ extension NotificationService {
             return "New notification"  // fallback
         }
         // Use your encryption library (CryptoKit, etc.) to decrypt
-        // The decryption key should be stored in the shared Keychain
-        // accessible to both the main app and the extension via App Groups.
+        // Store notification decryption keys in a Keychain access group shared
+        // by the app and extension, not in UserDefaults or the APNs payload.
         do {
             let decrypted = try EncryptionService.shared.decrypt(data)
             return String(data: decrypted, encoding: .utf8) ?? "New notification"
@@ -139,12 +142,13 @@ extension NotificationService {
 }
 ```
 
-### App Groups for Data Sharing
+### Sharing Data with Extensions
 
-The service extension runs in a separate process from the main app. Use App Groups to share data (Keychain items, UserDefaults, files) between them.
+The service extension runs in a separate process from the main app. Use App Groups for shared files and `UserDefaults`; use Keychain Sharing for secrets or tokens.
 
 1. Enable "App Groups" capability on both the main app target and the extension target.
 2. Use the same group identifier (e.g., `group.com.example.myapp`).
+3. Enable "Keychain Sharing" on both targets for shared keychain items. The `kSecAttrAccessGroup` value must be one of the target's keychain access groups, not the App Group container identifier.
 
 ```swift
 // Shared UserDefaults
@@ -155,11 +159,11 @@ let sharedContainer = FileManager.default.containerURL(
     forSecurityApplicationGroupIdentifier: "group.com.example.myapp"
 )
 
-// Shared Keychain: set kSecAttrAccessGroup to your App Group identifier
-// when storing/retrieving Keychain items.
+// Shared Keychain: set kSecAttrAccessGroup to a Keychain Sharing access group
+// that both targets include in their entitlements.
 ```
 
-**Extension memory limit:** Notification Service Extensions have a strict memory limit (approximately 24 MB). Do not load large frameworks or perform memory-intensive operations. If the extension exceeds memory limits, the system terminates it and shows the original notification.
+**Extension memory:** Notification Service Extensions are memory-constrained. Do not load large frameworks or perform memory-intensive operations. If the system terminates the extension, it shows the original notification.
 
 ## Notification Attachments
 
@@ -198,7 +202,7 @@ let attachment = try UNNotificationAttachment(
 content.attachments = [attachment]
 ```
 
-**Important:** The file URL must point to a file that the notification system can access. For service extensions, write to the extension's temporary directory. For local notifications, write to a location accessible by the notification system (not the app's sandbox). The system moves the file after attachment creation, so the original URL becomes invalid.
+**Important:** The file URL must point to a supported audio, image, or video file on disk. For service extensions, write downloads to the extension's temporary directory before creating `UNNotificationAttachment`; do not attach arbitrary remote URLs or unsupported file types. For local notifications, create the attachment from a file the app can read when scheduling. The system validates attachments and moves them into its attachment data store; it copies attachments located inside the app bundle.
 
 ### Multiple Attachments
 
@@ -211,7 +215,7 @@ content.attachments = [imageAttachment, audioAttachment]
 
 ### GIF Animations
 
-GIFs animate automatically in the expanded notification view. No special handling needed -- attach the GIF file as any other image.
+GIF files are supported image attachments and may contain an animated image sequence. Test the expanded notification UI for the actual presentation you need.
 
 ```swift
 let gifURL = tempDir.appendingPathComponent("animation.gif")
@@ -241,9 +245,7 @@ The extension's `Info.plist` must declare which notification categories it handl
     <key>NSExtensionAttributes</key>
     <dict>
         <key>UNNotificationExtensionCategory</key>
-        <!-- Single category -->
-        <string>MESSAGE_CATEGORY</string>
-        <!-- Or multiple categories -->
+        <!-- Use a string for one category, or an array for multiple. -->
         <array>
             <string>MESSAGE_CATEGORY</string>
             <string>PHOTO_CATEGORY</string>
@@ -428,12 +430,14 @@ class InteractiveNotificationViewController: UIViewController, UNNotificationCon
 
 ## Communication Notifications
 
-Communication notifications display the sender's avatar and name prominently. They use SiriKit intents (`INSendMessageIntent`) to provide sender information.
+Communication notifications display the sender's avatar and name prominently. They use SiriKit intents (`INSendMessageIntent` or `INStartCallIntent`) to provide participant information and can have different Focus and summary behavior, so use them only for real person-to-person communication.
 
 ### Setup
 
-1. Add the `Intents` framework to the Notification Service Extension target.
-2. Configure `INSendMessageIntent` in the service extension before delivery.
+1. Enable the Communication Notifications capability on the app target.
+2. Add supported intent class names, such as `INSendMessageIntent`, to `NSUserActivityTypes` in `Info.plist`.
+3. Add the `Intents` framework to the Notification Service Extension target.
+4. Configure an `INSendMessageIntent`, create an `INInteraction`, set `direction = .incoming`, donate the interaction, then call `content.updating(from:)` before passing the updated content to the content handler.
 
 ```swift
 import Intents
@@ -445,7 +449,7 @@ extension NotificationService {
         senderName: String,
         senderImageURL: String?,
         conversationId: String
-    ) async {
+    ) async -> UNNotificationContent? {
         // Create the sender identity
         let handle = INPersonHandle(value: conversationId, type: .unknown)
         var avatar: INImage? = nil
@@ -458,9 +462,12 @@ extension NotificationService {
             }
         }
 
+        let nameComponents = PersonNameComponentsFormatter()
+            .personNameComponents(from: senderName)
+
         let sender = INPerson(
             personHandle: handle,
-            nameComponents: try? PersonNameComponents(senderName),
+            nameComponents: nameComponents,
             displayName: senderName,
             image: avatar,
             contactIdentifier: nil,
@@ -484,15 +491,11 @@ extension NotificationService {
         interaction.direction = .incoming
         try? await interaction.donate()
 
-        // Update the notification content with the intent
         do {
-            let updatedContent = try content.updating(from: intent)
-            // Copy updated properties back to mutable content
-            // The updating(from:) method returns a new UNNotificationContent,
-            // so we need to use the content handler with the updated version.
-            // In practice, call the content handler with updatedContent directly.
+            return try content.updating(from: intent)
         } catch {
             print("Failed to update content with intent: \(error)")
+            return nil
         }
     }
 }
@@ -531,9 +534,12 @@ override func didReceive(
                 avatar = INImage(imageData: data)
             }
 
+            let nameComponents = PersonNameComponentsFormatter()
+                .personNameComponents(from: senderName)
+
             let sender = INPerson(
                 personHandle: handle,
-                nameComponents: try? PersonNameComponents(senderName),
+                nameComponents: nameComponents,
                 displayName: senderName,
                 image: avatar,
                 contactIdentifier: nil,
@@ -571,8 +577,8 @@ override func didReceive(
 **Service extension not running:**
 - Verify `mutable-content: 1` is set in the APNs payload.
 - The notification must have an alert (title or body). Silent pushes do not trigger the service extension.
-- Check that the extension's bundle identifier is `<main-app-bundle-id>.NotificationServiceExtension`.
-- Confirm the extension is included in the same App Group as the main app if sharing data.
+- Confirm the service extension target is embedded in the containing app and its bundle identifier/provisioning profile are valid.
+- Confirm both targets include the same App Group or Keychain Sharing entitlements if they share data.
 
 **Content extension not showing:**
 - Verify the `UNNotificationExtensionCategory` in Info.plist matches the `categoryIdentifier` in the notification.
@@ -580,11 +586,15 @@ override func didReceive(
 - Ensure `UNNotificationExtensionInitialContentSizeRatio` is set to a reasonable value.
 
 **Memory pressure:**
-- Service extensions have approximately 24 MB of memory.
-- Content extensions have more memory but should still be conservative.
+- Extensions are memory-constrained and can be terminated under pressure.
 - Avoid loading large frameworks (no SwiftUI, no heavy networking libraries).
 - Use `URLSession` directly for network requests in extensions.
 
+**Fallback handling:**
+- Always call the content handler exactly once on every path.
+- On download, decryption, donation, or `content.updating(from:)` failure, return the original or best-attempt content rather than dropping the notification.
+- In `serviceExtensionTimeWillExpire()`, stop waiting for in-flight work and call the content handler immediately with the best content available.
+
 **Network access in extensions:**
 - Extensions can make network requests. Use `URLSession` with the `.default` configuration.
 - Keep requests fast -- the service extension has approximately 30 seconds total.
@@ -641,28 +651,34 @@ class NotificationService: UNNotificationServiceExtension {
                     senderImageURL: content.userInfo["senderImage"] as? String,
                     conversationId: convId
                 ) {
-                    contentHandler(updated)
+                    finish(with: updated)
                     return
                 }
             }
 
-            contentHandler(content)
+            finish(with: content)
         }
     }
 
     override func serviceExtensionTimeWillExpire() {
-        if let handler = contentHandler, let content = bestAttemptContent {
-            handler(content)
+        if let content = bestAttemptContent {
+            finish(with: content)
         }
     }
 
     // MARK: - Private
 
+    private func finish(with content: UNNotificationContent) {
+        guard !didComplete, let handler = contentHandler else { return }
+        didComplete = true
+        handler(content)
+    }
+
     private func decryptBody(_ base64: String) -> String? {
         guard let data = Data(base64Encoded: base64) else { return nil }
-        // Use shared Keychain via App Group to retrieve encryption key
-        let defaults = UserDefaults(suiteName: "group.com.example.myapp")
-        guard let keyData = defaults?.data(forKey: "encryptionKey") else { return nil }
+        guard let keyData = SharedKeychain.loadData(
+            account: "notificationEncryptionKey"
+        ) else { return nil }
         // Decrypt using CryptoKit or similar
         return try? Decryptor.decrypt(data, key: keyData)
     }
@@ -704,9 +720,12 @@ class NotificationService: UNNotificationServiceExtension {
             avatar = INImage(imageData: data)
         }
 
+        let nameComponents = PersonNameComponentsFormatter()
+            .personNameComponents(from: senderName)
+
         let sender = INPerson(
             personHandle: handle,
-            nameComponents: try? PersonNameComponents(senderName),
+            nameComponents: nameComponents,
             displayName: senderName,
             image: avatar,
             contactIdentifier: nil,

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

@@ -1,4 +1,5 @@
 ---
+name: python-patterns
 description: "Modern Python 3.12+: type hints, dataclasses, Pydantic v2, async/await, context managers, generators, pattern matching"
 tags: [python, type-hints, pydantic, asyncio, dataclasses, backend]
 version: "2025.1"
@@ -28,7 +29,7 @@ def process(value: str | int | None) -> str:
         return "empty"
     return str(value)
 
-# Generic functions (Python 3.12+ syntax — PEP 695)
+# Generic functions (Python 3.12+ syntax  -  PEP 695)
 type NumberList[T: (int, float)] = list[T]
 
 def first[T](items: Sequence[T]) -> T | None:
@@ -292,7 +293,7 @@ def filter_active(records: Iterator[dict[str, str]]) -> Iterator[dict[str, str]]
         if record.get("status") == "active":
             yield record
 
-# Compose the pipeline (lazy — processes one record at a time)
+# Compose the pipeline (lazy  -  processes one record at a time)
 active_users = filter_active(parse_csv(read_lines("users.csv")))
 ```
 
@@ -363,7 +364,7 @@ def process_command(command: list[str]) -> None:
 ## Don'ts
 
 - Do not use `Any` type annotation unless absolutely necessary
-- Do not use bare `except:` — always specify exception types
+- Do not use bare `except:`  -  always specify exception types
 - Do not use mutable default arguments (`def f(items=[])`)
 - Do not use `global` variables for state management
 - Do not use `asyncio.run()` inside an already-running event loop

package/pipeline/skills/shared/external/react-best-practices/SKILL.md

@@ -1,4 +1,5 @@
 ---
+name: react-best-practices
 description: "React 19+ best practices: Server Components, use() hook, Actions, hooks patterns, state management, and performance optimization"
 tags: [react, frontend, javascript, typescript, hooks, state-management]
 version: "2025.1"

package/pipeline/skills/shared/external/realitykit-ar/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: realitykit-ar
-description: "Build augmented reality experiences with RealityKit and ARKit on iOS. Use when adding 3D content with RealityView, loading entities and models, placing objects via raycasting, configuring AR camera sessions, handling world tracking, scene understanding, or implementing entity interactions and gestures."
+description: "Build iOS augmented reality and 3D experiences with RealityKit and ARKit. Use when adding RealityView content, loading entities or USDZ models, anchoring objects to planes or world positions, distinguishing entity hit tests from ARKit real-world raycasts, handling AR camera availability, world tracking, scene updates, or RealityKit entity gestures and interactions."
 ---
 
-# RealityKit + ARKit
+# RealityKit
 
 Build AR experiences on iOS using RealityKit for rendering and ARKit for world
 tracking. Covers `RealityView`, entity management, raycasting, scene
-understanding, and gesture-based interactions. Targets Swift 6.2 / iOS 26+.
+understanding, and gesture-based interactions. Targets Swift 6.3 / iOS 26+.
 
 ## Contents
 
@@ -27,13 +27,13 @@ understanding, and gesture-based interactions. Targets Swift 6.2 / iOS 26+.
 ### Project Configuration
 
 1. Add `NSCameraUsageDescription` to Info.plist
-2. For iOS, RealityKit uses the device camera by default via `RealityViewCameraContent` (iOS 18+, macOS 15+)
-3. No additional capabilities required for basic AR on iOS
+2. On iOS, `RealityViewCameraContent` displays an AR camera view by default (iOS 18+, macOS 15+); use `.virtual` camera mode for explicit non-AR fallback
+3. No entitlement is required for basic AR. If AR is core to the app, add the `arkit` required-device capability; otherwise gate AR UI with `isSupported`.
 
 ### Device Requirements
 
-AR features require devices with an A9 chip or later. Always verify support
-before presenting AR UI.
+AR features require devices with an A9 chip or later. Always check
+`ARWorldTrackingConfiguration.isSupported` before presenting AR UI.
 
 ```swift
 import ARKit
@@ -49,24 +49,30 @@ guard ARWorldTrackingConfiguration.isSupported else {
 | Type | Platform | Role |
 |---|---|---|
 | `RealityView` | iOS 18+, visionOS 1+ | SwiftUI view that hosts RealityKit content |
-| `RealityViewCameraContent` | iOS 18+, macOS 15+ | Content displayed through the device camera |
+| `RealityViewCameraContent` | iOS 18+, macOS 15+ | Content displayed through an AR camera view on iOS, non-AR on macOS |
 | `Entity` | All | Base class for all scene objects |
 | `ModelEntity` | All | Entity with a visible 3D model |
 | `AnchorEntity` | All | Tethers entities to a real-world anchor |
 
 ## RealityView Basics
 
-`RealityView` is the SwiftUI entry point for RealityKit. On iOS, it provides
-`RealityViewCameraContent` which renders through the device camera for AR.
+`RealityView` is the SwiftUI entry point for RealityKit.
+`RealityViewCameraContent` is the iOS/macOS content type. On iOS, it uses an AR
+camera view by default and can use `content.camera = .virtual` for non-AR mode
+when requested or when AR/camera access is unavailable.
 
 ```swift
+import ARKit
 import SwiftUI
 import RealityKit
 
 struct ARExperienceView: View {
     var body: some View {
-        RealityView { content in
-            // content is RealityViewCameraContent on iOS
+        RealityView { (content: RealityViewCameraContent) in
+            if !ARWorldTrackingConfiguration.isSupported {
+                content.camera = .virtual
+            }
+
             let sphere = ModelEntity(
                 mesh: .generateSphere(radius: 0.05),
                 materials: [SimpleMaterial(
@@ -135,28 +141,6 @@ RealityView { content in
 }
 ```
 
-### Programmatic Mesh Generation
-
-```swift
-// Box
-let box = ModelEntity(
-    mesh: .generateBox(size: [0.1, 0.2, 0.1], cornerRadius: 0.005),
-    materials: [SimpleMaterial(color: .gray, isMetallic: true)]
-)
-
-// Sphere
-let sphere = ModelEntity(
-    mesh: .generateSphere(radius: 0.05),
-    materials: [SimpleMaterial(color: .blue, roughness: 0.2, isMetallic: true)]
-)
-
-// Plane
-let plane = ModelEntity(
-    mesh: .generatePlane(width: 0.3, depth: 0.3),
-    materials: [SimpleMaterial(color: .green, isMetallic: false)]
-)
-```
-
 ### Adding Components
 
 Entities use an ECS (Entity Component System) architecture. Add components
@@ -219,12 +203,37 @@ RealityView { content in
 
 ## Raycasting
 
-Use `RealityViewCameraContent` to convert between SwiftUI view coordinates
-and RealityKit world space. Pair with `SpatialTapGesture` to place objects
-where the user taps on a detected surface.
+Keep RealityKit scene queries separate from ARKit real-world raycasts:
+
+- `RealityViewCameraContent.ray(through:in:to:)` returns a camera ray in
+  RealityKit coordinate spaces. It projects a screen point into the virtual
+  scene; it is not proof of a detected physical surface.
+- `RealityViewCameraContent.hitTest(point:in:query:mask:)` hits virtual
+  entities made hittable by `CollisionComponent` shapes. Use those shapes for
+  entity picking and targeted gestures, not ARKit plane detection.
+- Use `AnchorEntity(.plane(...))` for simple placement on detected planes.
+- Use ARKit `ARRaycastQuery` plus `ARSession.raycast(_:)` when the task needs
+  a one-shot intersection with real-world surfaces, then anchor with
+  `AnchorEntity(raycastResult:)`.
+
+```swift
+let results = session.raycast(query)
+if let result = results.first {
+    let anchor = AnchorEntity(raycastResult: result)
+    anchor.addChild(model)
+    content.add(anchor)
+}
+```
+
+Do not treat entity hit tests as substitutes for ARKit surface raycasts.
 
 ## Gestures and Interaction
 
+For gesture-based entity interaction, add `CollisionComponent` for the hittable
+shape and `InputTargetComponent` for input targeting. Use
+`AccessibilityComponent` for entity labels/actions. Hand detailed SwiftUI gesture
+composition and VoiceOver/Switch Control policy to sibling skills.
+
 ### Drag Gesture on Entities
 
 ```swift
@@ -260,18 +269,10 @@ struct DraggableARView: View {
 }
 ```
 
-### Tap to Select
-
-```swift
-.gesture(
-    SpatialTapGesture()
-        .targetedToAnyEntity()
-        .onEnded { value in
-            let tappedEntity = value.entity
-            highlightEntity(tappedEntity)
-        }
-)
-```
+For selection, `CollisionComponent` is the mechanism that makes an entity
+hittable by `RealityViewCameraContent.hitTest`, `SpatialTapGesture`, or
+`targetedToAnyEntity()`. Pair it with `InputTargetComponent`; this enables
+virtual entity picking, not ARKit surface detection.
 
 ## Scene Understanding
 
@@ -295,13 +296,26 @@ RealityView { content in
 }
 ```
 
-### visionOS Note
+### Platform Boundaries
 
 On visionOS, ARKit provides a different API surface with `ARKitSession`,
 `WorldTrackingProvider`, and `PlaneDetectionProvider`. These visionOS-specific
 types are not available on iOS. On iOS, RealityKit handles world tracking
 automatically through `RealityViewCameraContent`.
 
+For iOS architecture or migration notes, explicitly name the iOS RealityKit path and handoffs:
+
+- Gate AR with `ARWorldTrackingConfiguration.isSupported`.
+- Host content with `RealityViewCameraContent`.
+- Build scenes from `Entity`/`ModelEntity` and place with `AnchorEntity`.
+- Include a compact `Handoffs` line in architecture/review notes:
+  `CollisionComponent` + `InputTargetComponent` handle RealityKit interaction;
+  `AccessibilityComponent` handles RealityKit entity accessibility metadata;
+  detailed SwiftUI gestures and VoiceOver/Switch Control policy belong to siblings.
+
+Treat existing `SCNView`/`SCNNode` work as either a separate SceneKit path or an
+explicit migration to RealityKit, not a mixed scene graph.
+
 ## Common Mistakes
 
 ### DON'T: Skip AR capability checks
@@ -455,10 +469,13 @@ struct ARContainerView: View {
 - [ ] `NSCameraUsageDescription` set in Info.plist
 - [ ] AR device capability checked before presenting AR views
 - [ ] Camera permission requested and denial handled with a fallback UI
+- [ ] `arkit` required-device capability added when AR is the app's core purpose
 - [ ] 3D models loaded asynchronously in the `make` closure
 - [ ] Entities created in `make`, modified in `update` (not created in `update`)
-- [ ] Interactive entities have both `CollisionComponent` and `InputTargetComponent`
-- [ ] Collision shapes match the visual size of the entity
+- [ ] Interaction notes say `CollisionComponent` makes entities hittable/pickable and pairs with `InputTargetComponent`
+- [ ] Boundary/review notes include a `Handoffs` line naming `AccessibilityComponent` and routing detailed SwiftUI/accessibility policy to siblings
+- [ ] Entity hit tests, `RealityViewCameraContent.ray(...)`, and ARKit real-world surface raycasts are not conflated
+- [ ] ARKit surface raycast placements use `ARSession.raycast(_:)` and `AnchorEntity(raycastResult:)`
 - [ ] `SceneEvents.Update` subscriptions used for per-frame logic (not SwiftUI timers)
 - [ ] Large scenes use `ModelEntity(named:)` async loading, not `Entity.load(named:)`
 - [ ] Anchor entities target appropriate surface types for the use case
@@ -466,14 +483,18 @@ struct ARContainerView: View {
 
 ## References
 
-- Extended patterns (physics, animations, lighting, ECS): `references/realitykit-patterns.md`
+- Read [references/realitykit-patterns.md](references/realitykit-patterns.md) for physics, animations, lighting, ECS, accessibility, and performance patterns.
 - [RealityKit framework](https://sosumi.ai/documentation/realitykit)
 - [RealityView](https://sosumi.ai/documentation/realitykit/realityview)
 - [RealityViewCameraContent](https://sosumi.ai/documentation/realitykit/realityviewcameracontent)
+- [RealityViewCamera](https://sosumi.ai/documentation/realitykit/realityviewcamera)
 - [Entity](https://sosumi.ai/documentation/realitykit/entity)
 - [ModelEntity](https://sosumi.ai/documentation/realitykit/modelentity)
 - [AnchorEntity](https://sosumi.ai/documentation/realitykit/anchorentity)
 - [ARKit framework](https://sosumi.ai/documentation/arkit)
 - [ARKit in iOS](https://sosumi.ai/documentation/arkit/arkit-in-ios)
+- [Verifying Device Support and User Permission](https://sosumi.ai/documentation/arkit/verifying-device-support-and-user-permission)
 - [ARWorldTrackingConfiguration](https://sosumi.ai/documentation/arkit/arworldtrackingconfiguration)
+- [ARRaycastQuery](https://sosumi.ai/documentation/arkit/arraycastquery)
+- [ARSession.raycast(_:)](https://sosumi.ai/documentation/arkit/arsession/raycast(_:))
 - [Loading entities from a file](https://sosumi.ai/documentation/realitykit/loading-entities-from-a-file)

package/pipeline/skills/shared/external/realitykit-ar/evals/evals.json

@@ -0,0 +1,47 @@
+{
+  "skill_name": "realitykit",
+  "evals": [
+    {
+      "id": 1,
+      "name": "ar-camera-setup-review",
+      "prompt": "Review this SwiftUI AR setup: it presents RealityView on every iPhone, has no NSCameraUsageDescription, assumes a black camera view means the model failed to load, and says there is never a device capability setting for RealityKit because RealityKit handles AR automatically. What should change?",
+      "expected_output": "A correction-focused review that covers camera privacy, runtime AR support checks, user-facing fallback handling, required-device capability tradeoffs, and RealityViewCameraContent's AR/non-AR behavior.",
+      "files": [],
+      "assertions": [
+        "Requires NSCameraUsageDescription for camera-based AR.",
+        "Checks ARWorldTrackingConfiguration.isSupported or the relevant ARConfiguration.isSupported before presenting AR-only UI.",
+        "Handles denied camera permission or unavailable AR with a fallback instead of treating a black view as only a model-loading failure.",
+        "Explains that arkit in UIRequiredDeviceCapabilities is appropriate only when AR is core required functionality; otherwise use runtime gating.",
+        "Mentions that RealityViewCameraContent uses an AR camera view by default on iOS and can fall back to non-AR mode when AR or camera access is unavailable."
+      ]
+    },
+    {
+      "id": 2,
+      "name": "surface-raycast-placement-review",
+      "prompt": "A developer wants tap-to-place on a physical table. Their plan is to use SpatialTapGesture with RealityViewCameraContent.hitTest, assume any hit is a detected table surface, and create a world anchor at that point. Review the plan and give the correct RealityKit/ARKit placement approach.",
+      "expected_output": "A source-grounded review that distinguishes RealityKit entity hit testing from ARKit real-world surface raycasts, then recommends plane anchors or ARKit raycast results for physical-surface placement.",
+      "files": [],
+      "assertions": [
+        "Explains that RealityViewCameraContent.hitTest intersects RealityKit entity collision shapes, not arbitrary detected physical surfaces.",
+        "States that RealityViewCameraContent.ray produces a camera ray in RealityKit coordinates and is not by itself proof of a real-world surface hit.",
+        "Recommends AnchorEntity(.plane(...)) for simple placement on detected horizontal or vertical planes.",
+        "Recommends ARRaycastQuery with ARSession.raycast(_:) and AnchorEntity(raycastResult:) when a one-shot real-world surface intersection is needed.",
+        "Requires CollisionComponent shapes only for interactive entity hit testing and gestures, not as a substitute for ARKit surface detection."
+      ]
+    },
+    {
+      "id": 3,
+      "name": "ios-visionos-boundary-review",
+      "prompt": "A team found a visionOS sample using ARKitSession, WorldTrackingProvider, and PlaneDetectionProvider. They want to copy those APIs into an iOS RealityView app and also migrate an older SCNView/SCNNode scene in the same pass. Write a short architecture note about what belongs in the RealityKit iOS path and what should be treated as a boundary or migration.",
+      "expected_output": "A boundary-aware note that keeps iOS RealityKit guidance centered on RealityViewCameraContent, ARKit iOS configuration/support checks, and entities/anchors, while treating visionOS provider APIs and SceneKit node APIs as separate domains or migration concerns.",
+      "files": [],
+      "assertions": [
+        "States that ARKitSession, WorldTrackingProvider, and PlaneDetectionProvider are visionOS-specific and are not the iOS RealityKit path.",
+        "Uses RealityViewCameraContent, ARWorldTrackingConfiguration.isSupported, entities, and AnchorEntity patterns for the iOS RealityKit path.",
+        "Avoids claiming that SceneKit SCNView, SCNNode, or SCNPhysicsBody APIs can be patched directly with RealityKit entity APIs.",
+        "Frames SceneKit work as a separate maintenance path or an explicit migration to RealityKit, not as mixed API usage in the same scene graph.",
+        "Keeps detailed SwiftUI gesture composition or accessibility policy as handoff topics while still naming RealityKit requirements such as InputTargetComponent, CollisionComponent, and AccessibilityComponent when relevant."
+      ]
+    }
+  ]
+}

package/pipeline/skills/shared/external/realitykit-ar/references/realitykit-patterns.md

@@ -1,6 +1,6 @@
 # RealityKit + ARKit Extended Patterns
 
-Overflow reference for the `realitykit-ar` skill. Contains advanced patterns that exceed the main skill file's scope.
+Overflow reference for the `realitykit` skill. Contains advanced patterns that exceed the main skill file's scope.
 
 ## Contents
 
@@ -384,7 +384,7 @@ struct ARModelViewer: View {
     }
 
     private var controlsPanel: some View {
-        VStack(spacing: 12) {
+        VStack {
             Picker("Model", selection: $viewModel.selectedModelName) {
                 Text("Robot").tag("robot")
                 Text("Chair").tag("chair")
@@ -402,7 +402,7 @@ struct ARModelViewer: View {
         }
         .padding()
         .background(.ultraThinMaterial)
-        .clipShape(RoundedRectangle(cornerRadius: 16))
+        .clipShape(.rect(cornerRadius: 16))
         .padding()
     }
 }
@@ -417,13 +417,13 @@ let model = ModelEntity(
     mesh: .generateBox(size: 0.1),
     materials: [SimpleMaterial(color: .blue, isMetallic: false)]
 )
-model.components.set(AccessibilityComponent(
-    label: "Blue cube",
-    value: "Interactive 3D object",
-    isAccessibilityElement: true,
-    traits: [.button],
-    systemActions: [.activate]
-))
+var accessibility = AccessibilityComponent()
+accessibility.isAccessibilityElement = true
+accessibility.label = "Blue cube"
+accessibility.value = "Interactive 3D object"
+accessibility.traits = [.button]
+accessibility.systemActions = [.activate]
+model.components.set(accessibility)
 ```
 
 ## Performance Tips