@mmerterden/multi-agent-pipeline 8.6.2 → 10.0.6

package/pipeline/skills/shared/external/ios-security/references/file-storage-patterns.md

@@ -30,12 +30,12 @@ hardcode paths.
 ```swift
 import Foundation
 
-// Documents/ — user-generated content, backed up by iCloud/iTunes
+// Documents/  -  user-generated content, backed up by iCloud/iTunes
 let documentsURL = FileManager.default.urls(
     for: .documentDirectory, in: .userDomainMask
 ).first!
 
-// Library/Application Support/ — app-generated supporting data, backed up
+// Library/Application Support/  -  app-generated supporting data, backed up
 let appSupportURL = FileManager.default.urls(
     for: .applicationSupportDirectory, in: .userDomainMask
 ).first!
@@ -44,29 +44,29 @@ try FileManager.default.createDirectory(
     at: appSupportURL, withIntermediateDirectories: true
 )
 
-// Library/Caches/ — re-creatable data, not backed up, may be purged
+// Library/Caches/  -  re-creatable data, not backed up, may be purged
 let cachesURL = FileManager.default.urls(
     for: .cachesDirectory, in: .userDomainMask
 ).first!
 
-// tmp/ — temporary files, purged by system periodically
+// tmp/  -  temporary files, purged by system periodically
 let tmpURL = FileManager.default.temporaryDirectory
 ```
 
 ### Choosing the Right Directory
 
 ```swift
-// User's exported PDF — Documents/
+// User's exported PDF  -  Documents/
 let exportURL = documentsURL.appendingPathComponent("Report.pdf")
 try pdfData.write(to: exportURL)
 
-// App's SQLite database — Library/Application Support/
+// App's SQLite database  -  Library/Application Support/
 let dbURL = appSupportURL.appendingPathComponent("AppData.sqlite")
 
-// Downloaded thumbnail cache — Library/Caches/
+// Downloaded thumbnail cache  -  Library/Caches/
 let thumbURL = cachesURL.appendingPathComponent("thumbnails/\(imageID).jpg")
 
-// In-progress upload — tmp/
+// In-progress upload  -  tmp/
 let uploadURL = tmpURL.appendingPathComponent(UUID().uuidString + ".tmp")
 ```
 

package/pipeline/skills/shared/external/ios-simulator/SKILL.md

@@ -0,0 +1,485 @@
+---
+name: ios-simulator
+description: "Manages iOS Simulator devices and tests app behavior using xcrun simctl. Covers device lifecycle (create, boot, shutdown, erase, delete), app install and launch, push notification simulation, location simulation, permission grants via privacy subcommand, deep link testing via openurl, status bar overrides, screenshot and video recording, log streaming with os_log filtering, get_app_container paths, and #if targetEnvironment(simulator) compile-time checks. Use when creating or managing simulator devices, testing push notifications without APNs, simulating GPS locations, granting or resetting privacy permissions, capturing screenshots or screen recordings from the command line, streaming device logs, debugging simulator boot failures, troubleshooting CoreSimulator issues, or checking simulator hardware limitations."
+---
+
+# iOS Simulator
+
+Manage iOS Simulator devices and test app behavior from the command line using `xcrun simctl`. Covers the full device lifecycle, app deployment, push and location simulation, permission control, screenshot and video recording, log streaming, and compile-time simulator detection.
+
+For common subcommands, syntax, and examples, see [references/simctl-commands.md](references/simctl-commands.md).
+
+## Contents
+
+- [Device Lifecycle](#device-lifecycle)
+- [App Install and Launch](#app-install-and-launch)
+- [Testing Workflows](#testing-workflows)
+- [Screenshot and Video Recording](#screenshot-and-video-recording)
+- [Log Streaming](#log-streaming)
+- [Compile-Time Simulator Detection](#compile-time-simulator-detection)
+- [Simulator Limitations](#simulator-limitations)
+- [Common Mistakes](#common-mistakes)
+- [Review Checklist](#review-checklist)
+- [References](#references)
+
+## Device Lifecycle
+
+### Listing Devices and Runtimes
+
+```bash
+# List all available simulators grouped by runtime
+xcrun simctl list devices available
+
+# List installed runtimes
+xcrun simctl list runtimes
+
+# List only booted devices
+xcrun simctl list devices booted
+
+# JSON output for scripting
+xcrun simctl list -j devices available
+```
+
+Parse JSON output to find a specific device programmatically. See [references/simctl-commands.md](references/simctl-commands.md) for `jq` parsing examples.
+
+### Creating a Device
+
+```bash
+# Find available device types and runtimes
+xcrun simctl list devicetypes
+xcrun simctl list runtimes
+
+# Create a device  -  returns the new UDID
+xcrun simctl create "My Test Phone" "iPhone 16 Pro" "com.apple.CoreSimulator.SimRuntime.iOS-18-4"
+```
+
+Device types and runtime identifiers in examples throughout this skill are illustrative. Run `simctl list devicetypes` and `simctl list runtimes` to find the identifiers available on your system.
+
+The returned UDID identifies the device for all subsequent commands. Use descriptive names to distinguish devices in `simctl list` output.
+
+### Boot, Shutdown, Erase, Delete
+
+```bash
+# Boot a specific device
+xcrun simctl boot <UDID>
+
+# Boot if needed and wait until the device is ready
+xcrun simctl bootstatus <UDID> -b
+
+# Shutdown a running device
+xcrun simctl shutdown <UDID>
+
+# Factory reset  -  wipes all data, keeps the device
+xcrun simctl erase <UDID>
+
+# Delete a specific device
+xcrun simctl delete <UDID>
+
+# Delete all devices not available in the current Xcode
+xcrun simctl delete unavailable
+
+# Shutdown everything
+xcrun simctl shutdown all
+```
+
+Use `booted` as a UDID shorthand when exactly one simulator is running:
+
+```bash
+xcrun simctl shutdown booted
+```
+
+If multiple simulators are booted, `booted` picks one of them non-deterministically. Prefer explicit UDIDs when running parallel simulators.
+
+In scripts and CI, use `xcrun simctl bootstatus <UDID> -b` before install, launch, push, or location commands. If you call `simctl boot` separately, follow it with `xcrun simctl bootstatus <UDID>` before continuing.
+
+## App Install and Launch
+
+### Installing an App
+
+```bash
+# Build for simulator first
+xcodebuild build \
+    -scheme MyApp \
+    -destination 'platform=iOS Simulator,name=iPhone 16 Pro' \
+    -derivedDataPath build/
+
+# Boot and wait for SpringBoard/services before install
+xcrun simctl bootstatus <UDID> -b
+
+# Install the .app bundle
+xcrun simctl install <UDID> build/Build/Products/Debug-iphonesimulator/MyApp.app
+```
+
+The path must point to a `.app` directory built for the simulator architecture, not a `.ipa` file.
+
+### Launching and Terminating
+
+```bash
+# Launch by bundle ID
+xcrun simctl launch booted com.example.MyApp
+
+# Launch and stream stdout/stderr to the terminal
+xcrun simctl launch --console booted com.example.MyApp
+
+# Pass launch arguments
+xcrun simctl launch booted com.example.MyApp --reset-onboarding -AppleLanguages "(fr)"
+
+# Terminate a running app
+xcrun simctl terminate booted com.example.MyApp
+```
+
+`--console` is useful for debugging  -  it shows `print()` and `os_log` output directly in the terminal.
+
+### App Container Paths
+
+```bash
+# App bundle location
+xcrun simctl get_app_container booted com.example.MyApp app
+
+# Data container (Documents, Library, tmp)
+xcrun simctl get_app_container booted com.example.MyApp data
+
+# Shared app group container
+xcrun simctl get_app_container booted com.example.MyApp group.com.example.shared
+```
+
+Use these paths to inspect sandboxed files, databases, or UserDefaults during debugging.
+
+## Testing Workflows
+
+### Push Notification Simulation
+
+Create a JSON payload file:
+
+```json
+{
+    "aps": {
+        "alert": {
+            "title": "New Message",
+            "body": "You have a new message from Alice"
+        },
+        "badge": 3,
+        "sound": "default"
+    },
+    "customKey": "customValue"
+}
+```
+
+Send it to the Simulator:
+
+```bash
+# Send push payload from file
+xcrun simctl push booted com.example.MyApp payload.json
+
+# Pipe payload from stdin
+echo '{"aps":{"alert":"Quick test"}}' | xcrun simctl push booted com.example.MyApp -
+```
+
+This simulates local delivery only  -  no APNs connection is involved. Use this to test payload handling, notification display, and notification actions. Always verify on a real device before shipping to confirm APNs delivery works end to end.
+
+### Location Simulation
+
+```bash
+# Set a fixed coordinate (latitude, longitude)
+xcrun simctl location booted set 37.3349,-122.0090
+
+# List available predefined scenarios
+xcrun simctl location booted list
+
+# Run a predefined scenario
+xcrun simctl location booted run "City Run"
+
+# Follow custom command-line waypoints
+xcrun simctl location booted start --speed=15 --interval=1 \
+    37.3349,-122.0090 37.3317,-122.0307
+
+# Read waypoints from stdin, one "lat,lon" pair per line
+printf "37.3349,-122.0090\n37.3317,-122.0307\n" | \
+    xcrun simctl location booted start --distance=100 -
+
+# Clear the simulated location
+xcrun simctl location booted clear
+```
+
+Use `set` for one coordinate, `run` for predefined scenario names, and `start` for custom waypoint routes. The command boundary matters: `simctl location run` accepts built-in scenario names (e.g., "City Run", "Freeway Drive"), not GPX file paths; `simctl location start` is the command-line path for custom coordinate waypoints. Use Xcode's Debug > Simulate Location menu for GPX-based routes.
+
+Location simulation affects all apps using Core Location on the booted device. Clear the location when done to avoid unexpected test results.
+
+### Privacy Permissions
+
+```bash
+# Grant a permission
+xcrun simctl privacy booted grant photos com.example.MyApp
+
+# Revoke a permission
+xcrun simctl privacy booted revoke microphone com.example.MyApp
+
+# Reset all permissions for the app
+xcrun simctl privacy booted reset all com.example.MyApp
+```
+
+Common service names: `photos`, `microphone`, `contacts`, `calendar`, `reminders`, `location`, `location-always`, `motion`, `siri`. See [references/simctl-commands.md](references/simctl-commands.md) for the full list.
+
+Pre-granting permissions in CI avoids system permission dialogs that block automated test runs, but it can mask missing usage description keys. Keep the required Info.plist privacy strings in place and still test the normal prompt flow.
+
+### Deep Links and URLs
+
+```bash
+# Open a URL (triggers universal links or custom URL schemes)
+xcrun simctl openurl booted "https://example.com/product/123"
+
+# Custom URL scheme
+xcrun simctl openurl booted "myapp://settings/notifications"
+```
+
+For universal links, the app's associated domains entitlement must be configured. The Simulator uses the `apple-app-site-association` file from the domain.
+
+### Status Bar Overrides
+
+```bash
+# Set a clean status bar for screenshots
+xcrun simctl status_bar booted override \
+    --time "9:41" \
+    --batteryState charged \
+    --batteryLevel 100 \
+    --cellularMode active \
+    --cellularBars 4 \
+    --wifiBars 3 \
+    --operatorName ""
+
+# Clear all overrides
+xcrun simctl status_bar booted clear
+```
+
+Use status bar overrides to produce consistent App Store screenshots. Always clear overrides after capturing to avoid confusing other testing.
+
+## Screenshot and Video Recording
+
+```bash
+# Capture a screenshot
+xcrun simctl io booted screenshot screenshot.png
+
+# Record video (press Ctrl+C to stop)
+xcrun simctl io booted recordVideo recording.mov
+
+# Screenshot with specific display mask
+xcrun simctl io booted screenshot --mask black screenshot.png
+```
+
+`--mask` options: `ignored` (default, no mask), `alpha` (transparent corners), `black` (black corners). Use `alpha` or `black` when capturing screenshots that show the device shape. The `alpha` mask is only supported for screenshots  -  video recording falls back to `black`.
+
+Video recording continues until the process receives SIGINT (Ctrl+C). The recording is saved only after stopping  -  killing the process with SIGKILL loses the file.
+
+## Log Streaming
+
+### Basic Log Stream
+
+```bash
+# Stream all logs at debug level and above
+xcrun simctl spawn booted log stream --level debug
+
+# Filter by subsystem
+xcrun simctl spawn booted log stream --level debug \
+    --predicate 'subsystem == "com.example.app"'
+
+# Filter by subsystem and category
+xcrun simctl spawn booted log stream --level debug \
+    --predicate 'subsystem == "com.example.app" AND category == "networking"'
+
+# Filter by process name
+xcrun simctl spawn booted log stream \
+    --predicate 'process == "MyApp"'
+```
+
+### Combining with os.Logger
+
+Design subsystems and categories for filterability:
+
+```swift
+import os
+
+let networkLogger = Logger(subsystem: "com.example.app", category: "networking")
+let uiLogger = Logger(subsystem: "com.example.app", category: "ui")
+
+func fetchData() async throws -> Data {
+    networkLogger.debug("Starting request to /api/data")
+    let (data, response) = try await URLSession.shared.data(from: url)
+    networkLogger.info("Received \(data.count) bytes, status: \((response as? HTTPURLResponse)?.statusCode ?? 0)")
+    return data
+}
+```
+
+Then filter the log stream to see only networking output:
+
+```bash
+xcrun simctl spawn booted log stream --level debug \
+    --predicate 'subsystem == "com.example.app" AND category == "networking"'
+```
+
+## Compile-Time Simulator Detection
+
+Use `#if targetEnvironment(simulator)` to exclude code that cannot run in the Simulator:
+
+```swift
+func registerForPush() {
+    #if targetEnvironment(simulator)
+    logger.info("Skipping APNs registration  -  running in Simulator")
+    #else
+    UIApplication.shared.registerForRemoteNotifications()
+    #endif
+}
+```
+
+Runtime detection via environment variables:
+
+```swift
+var isSimulator: Bool {
+    ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nil
+}
+```
+
+Prefer compile-time checks (`#if targetEnvironment(simulator)`) over runtime checks. The compiler strips excluded code entirely, preventing linker errors from unavailable symbols.
+
+## Simulator Limitations
+
+When classifying a test as Simulator-supported or hardware-required, separate "can trigger this behavior" from "can validate real-device fidelity":
+
+- Simulator-supported triggers/proxies: local push with `simctl push`, location changes, memory warnings, Face ID or Touch ID enrollment/match/nonmatch menu actions, manual iCloud sync trigger, privacy grants/resets, status bar overrides, screenshots, and video capture.
+- Hardware-required validation: APNs delivery, BLE and NFC, real camera or microphone input, motion sensors, Secure Enclave, App Attest, automatic iCloud propagation/conflicts/background behavior, CPU throughput, general processing speed, networking throughput or latency, Metal shader correctness, GPU limits, memory bandwidth, frame timing, memory pressure, Jetsam, and thermal behavior.
+
+Do not classify "iCloud sync" as a single hardware-only item. Split it explicitly:
+
+- Simulator-supported: manual iCloud sync triggering and basic app response to sync callbacks.
+- Hardware-required: automatic iCloud propagation, multiple real devices/accounts, conflict resolution, notification-triggered sync, background delivery, and account/device state differences.
+
+| Capability | Simulator Support |
+|-----------|------------------|
+| APNs push delivery | No  -  use `simctl push` for local simulation |
+| Performance fidelity | Relative only  -  Simulator is not accurate for CPU/processing performance, networking speed, graphics/Metal, memory bandwidth, frame timing, memory pressure, Jetsam, shader correctness, or thermal behavior; verify performance-sensitive work on hardware |
+| Metal GPU family parity | Partial  -  Simulator uses the host Mac GPU, not the device GPU; some shaders and limits differ |
+| Camera hardware | No  -  use photo library injection or mock `AVCaptureSession` |
+| Audio input / microphone | No general app audio input; Siri can be activated from Simulator menus |
+| Secure Enclave | No  -  `kSecAttrTokenIDSecureEnclave` operations fail |
+| App Attest (DCAppAttestService) | No  -  `isSupported` returns `false` |
+| DockKit motor control | No  -  no physical accessory connection |
+| Accelerometer / Gyroscope | No motion sensor support; use real devices for motion-dependent behavior |
+| Barometer | No |
+| NFC (Core NFC) | No |
+| Bluetooth (Core Bluetooth) | No  -  use a real device for BLE testing |
+| CarPlay display simulation | Supported through Simulator's external display/CarPlay option; still verify in vehicle or device setups |
+| Face ID / Touch ID hardware | No hardware  -  use Features > Face ID / Touch ID menu in Simulator |
+| Memory warnings, manual iCloud sync trigger, location changes | Supported through Simulator menus or `simctl` where available |
+| Automatic iCloud sync behavior | Not fully simulated  -  validate notification-triggered sync, real account/device propagation, conflicts, and background behavior on hardware |
+| Cellular network conditions | No  -  use Network Link Conditioner on Mac |
+
+Treat Simulator performance as a functional smoke signal only. When answering performance-boundary questions, explicitly name CPU throughput/general processing speed and networking throughput/latency alongside graphics, Metal shader correctness, memory bandwidth, frame timing, memory pressure, Jetsam behavior, and thermal behavior.
+
+Use this minimum wording in release-checklist answers: "Simulator is not an accurate performance proxy for processing/CPU, graphics/Metal, memory, networking throughput/latency, Metal GPU behavior, frame timing, memory pressure/Jetsam, or thermal behavior." If a prompt only names "Metal performance," still include processing, memory, and networking in the device-verification list.
+
+## Common Mistakes
+
+### DON'T: Hardcode simulator UDIDs in scripts
+
+UDIDs change when simulators are deleted and recreated. Hardcoded values break on other machines and CI.
+
+```bash
+# WRONG  -  hardcoded UDID
+xcrun simctl boot "A1B2C3D4-E5F6-7890-ABCD-EF1234567890"
+
+# CORRECT  -  look up by name and runtime
+UDID=$(xcrun simctl list -j devices available | \
+    jq -r '.devices["com.apple.CoreSimulator.SimRuntime.iOS-18-4"][] | select(.name == "iPhone 16 Pro") | .udid')
+xcrun simctl boot "$UDID"
+
+# CORRECT  -  use "booted" when one simulator is running
+xcrun simctl install booted MyApp.app
+```
+
+### DON'T: Install or launch on a shutdown simulator
+
+`simctl install` and `simctl launch` require a booted device. They fail silently or with an unhelpful error on a shutdown device.
+
+```bash
+# WRONG  -  device is not booted
+xcrun simctl install <UDID> MyApp.app  # fails
+
+# CORRECT  -  boot first, then install
+xcrun simctl boot <UDID>
+xcrun simctl install <UDID> MyApp.app
+xcrun simctl launch <UDID> com.example.MyApp
+```
+
+### DON'T: Leave zombie simulators running in CI
+
+Each booted simulator consumes memory and CPU. CI pipelines that create simulators without cleanup accumulate zombie devices.
+
+```bash
+# WRONG  -  CI script creates and boots but never cleans up
+xcrun simctl create "CI Phone" "iPhone 16 Pro" "com.apple.CoreSimulator.SimRuntime.iOS-18-4"
+xcrun simctl boot "$UDID"
+# ... tests run, pipeline exits ...
+
+# CORRECT  -  always clean up in CI teardown
+cleanup() {
+    xcrun simctl shutdown all
+    xcrun simctl delete "$UDID"
+}
+trap cleanup EXIT
+```
+
+### DON'T: Assume simctl push validates APNs delivery
+
+`simctl push` bypasses the entire APNs infrastructure. It tests payload parsing and notification UI, not token registration, entitlements, or server-side delivery.
+
+```bash
+# WRONG  -  only testing with simctl, shipping without real device testing
+xcrun simctl push booted com.example.MyApp payload.json
+# "Push works!"  -  no, it only proves the app handles the payload
+
+# CORRECT  -  use simctl for development iteration, then verify end-to-end on a real device
+# 1. simctl push during development for fast iteration
+# 2. Real device + APNs sandbox for integration testing before release
+```
+
+### DON'T: Keep retrying boot on a stuck simulator
+
+A simulator stuck in the "Booting" state will not recover by retrying `boot`. The underlying CoreSimulator state is corrupted.
+
+```bash
+# WRONG  -  retry loop on a stuck device
+xcrun simctl boot "$UDID"  # "Unable to boot device in current state: Booting"
+xcrun simctl boot "$UDID"  # same error, forever
+
+# CORRECT  -  shut down, erase, and retry
+xcrun simctl shutdown "$UDID"
+xcrun simctl erase "$UDID"
+xcrun simctl boot "$UDID"
+
+# If that fails, reset CoreSimulator entirely
+xcrun simctl shutdown all
+xcrun simctl erase all
+# Last resort: rm -rf ~/Library/Developer/CoreSimulator/Caches
+```
+
+## Review Checklist
+
+- [ ] Simulator devices created with explicit device type and runtime identifiers
+- [ ] Scripts use `booted` or parsed UDID from JSON output, not hardcoded values
+- [ ] Push notification payloads tested via `simctl push` during development
+- [ ] Push notification delivery verified on a real device before release
+- [ ] Location simulation tested with fixed coordinates, predefined scenarios, and custom waypoints when needed
+- [ ] Privacy permissions pre-granted in CI to avoid blocking dialogs
+- [ ] `#if targetEnvironment(simulator)` guards around APIs unavailable in Simulator
+- [ ] Status bar overrides cleared after capturing screenshots
+- [ ] CI pipelines shut down and delete simulators in teardown
+- [ ] Log streaming configured with subsystem/category predicates for focused debugging
+- [ ] App container paths used for inspecting sandboxed data during debugging
+
+## References
+
+- [Running your app in Simulator or on a device](https://sosumi.ai/documentation/xcode/running-your-app-in-simulator-or-on-a-device)
+- [Downloading and installing additional Xcode components](https://sosumi.ai/documentation/xcode/installing-additional-simulator-runtimes)
+- [Testing in Simulator versus testing on hardware devices](https://sosumi.ai/documentation/xcode/testing-in-simulator-versus-testing-on-hardware-devices)
+- [Testing complex hardware device scenarios in Simulator](https://sosumi.ai/documentation/xcode/testing-complex-hardware-device-scenarios-in-simulator)
+- [Simulating an external display or CarPlay](https://sosumi.ai/documentation/xcode/simulating-an-external-display-or-carplay)
+- simctl command reference: [references/simctl-commands.md](references/simctl-commands.md)

package/pipeline/skills/shared/external/ios-simulator/evals/evals.json

@@ -0,0 +1,44 @@
+{
+  "skill_name": "ios-simulator",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "I need a command-line iOS Simulator test script for a maps feature. It should create or pick a simulator, boot it, install a simulator-built app, drive a custom route between two coordinates without using a GPX file, and clean up afterward. What simctl commands and caveats should I use?",
+      "expected_output": "A simctl-focused workflow that uses available device/runtime lookup, boots a simulator, installs a .app built for the simulator, uses simctl location start for custom command-line waypoints, clears location state, and shuts down or deletes test devices during cleanup.",
+      "files": [],
+      "assertions": [
+        "Uses `xcrun simctl location <device> start` for custom command-line waypoint routes instead of claiming only predefined scenarios are possible.",
+        "Explains that `location run` accepts predefined scenario names and does not take GPX file paths.",
+        "Boots before install or launch and installs a simulator-built `.app` rather than an `.ipa`.",
+        "Uses explicit UDID lookup or `booted` appropriately instead of hardcoding a simulator UDID.",
+        "Clears simulated location and shuts down or deletes simulator devices during cleanup."
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "Review this Simulator launch plan: pass FEATURE_FLAG=1 by running `xcrun simctl spawn booted env FEATURE_FLAG=1 /path/MyApp.app/MyApp`, use `simctl push` to prove APNs works for all notification types, and grant every privacy service in CI so we can remove usage description keys.",
+      "expected_output": "A correction-focused review that uses SIMCTL_CHILD_ environment variables with simctl launch, limits simctl push to local application remote notification simulation, preserves real-device APNs testing, and warns that simctl privacy can mask missing Info.plist usage descriptions.",
+      "files": [],
+      "assertions": [
+        "Replaces the `spawn env` app launch pattern with `SIMCTL_CHILD_FEATURE_FLAG=1 xcrun simctl launch ...` or equivalent `SIMCTL_CHILD_` guidance.",
+        "Clarifies that `simctl spawn` is for arbitrary simulator processes, not the preferred path for launching an installed app with environment variables.",
+        "States that `simctl push` simulates local application remote push delivery only and does not prove APNs token registration, entitlements, server delivery, or unsupported push types.",
+        "Includes the `simctl push` payload constraints: top-level object, valid `aps`, and 4096-byte size limit.",
+        "Warns that `simctl privacy` does not remove the need for valid Info.plist usage description keys and normal prompt-flow testing."
+      ]
+    },
+    {
+      "id": 3,
+      "prompt": "We are deciding which tests can stay in iOS Simulator for a release candidate: camera capture, BLE pairing, barometer elevation, accelerometer controls, Face ID fallback, memory warnings, iCloud sync, push notifications, and Metal performance. Give the boundary and what must move to hardware.",
+      "expected_output": "A Simulator-versus-device boundary review grounded in Apple docs: hardware-only features move to real devices, simulated scenarios stay in Simulator where supported, and performance or APNs conclusions are verified on hardware.",
+      "files": [],
+      "assertions": [
+        "Routes camera, Bluetooth/BLE, barometer, and accelerometer/gyroscope-dependent behavior to real hardware testing.",
+        "Treats Face ID/Touch ID fallback, memory warnings, and manual iCloud sync trigger as Simulator-supported scenarios.",
+        "States that Simulator is not an accurate performance proxy for processing, graphics, memory, networking, or Metal GPU behavior.",
+        "States that real APNs delivery must be verified on a device and `simctl push` is only local payload/display handling.",
+        "Keeps the answer focused on iOS Simulator boundaries instead of turning it into an Instruments, Core Motion, Core Bluetooth, or push server implementation guide."
+      ]
+    }
+  ]
+}