@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

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

@@ -60,15 +60,11 @@ final class EnergyManager {
 
             do {
                 for try await guidance in service.guidance(using: query, at: venueID) {
-                    await MainActor.run {
-                        self?.currentGuidance = guidance
-                        self?.guidanceValues = guidance.values
-                    }
+                    self?.currentGuidance = guidance
+                    self?.guidanceValues = guidance.values
                 }
             } catch {
-                await MainActor.run {
-                    self?.errorMessage = error.localizedDescription
-                }
+                self?.errorMessage = error.localizedDescription
             }
         }
     }
@@ -90,7 +86,7 @@ final class EnergyManager {
         currentGuidance?.options.contains(.guidanceIncorporatesRatePlan) ?? false
     }
 
-    // EnergyKitError cases -- verify against Xcode 26 SDK
+    // EnergyKitError cases
     private func handleError(_ error: EnergyKitError) -> String {
         switch error {
         case .unsupportedRegion:
@@ -121,6 +117,8 @@ final class EnergyManager {
 ## EV Charging Session Manager
 
 Manage the full lifecycle of an EV charging session with guidance tracking.
+Use only a `guidanceToken` returned by EnergyKit for the venue and device that
+requested guidance. Do not synthesize placeholder tokens.
 
 ```swift
 import EnergyKit
@@ -137,6 +135,7 @@ final class EVChargingManager {
     private let deviceID: String
     private var venue: EnergyVenue?
     private var guidanceToken: UUID?
+    private var pendingEvents: [ElectricVehicleLoadEvent] = []
 
     init(deviceID: String) {
         self.deviceID = deviceID
@@ -158,13 +157,13 @@ final class EVChargingManager {
         self.stateOfCharge = stateOfCharge
         isCharging = true
 
-        let event = makeEvent(
+        let event = try makeEvent(
             sessionState: .begin,
             stateOfCharge: stateOfCharge,
             power: 0,
             energy: 0
         )
-        try await venue.submitEvents([event])
+        pendingEvents = [event]
     }
 
     func updateCharging(
@@ -178,43 +177,59 @@ final class EVChargingManager {
         self.currentPower = power
         self.totalEnergy = energy
 
-        let event = makeEvent(
+        let event = try makeEvent(
             sessionState: .active,
             stateOfCharge: stateOfCharge,
             power: power,
             energy: energy
         )
-        try await venue.submitEvents([event])
+        pendingEvents.append(event)
+
+        if pendingEvents.count >= 4 {
+            try await flushPendingEvents()
+        }
     }
 
     func stopCharging() async throws {
         guard let venue, isCharging else { return }
 
-        let event = makeEvent(
+        let event = try makeEvent(
             sessionState: .end,
             stateOfCharge: stateOfCharge,
             power: 0,
             energy: totalEnergy
         )
-        try await venue.submitEvents([event])
+        pendingEvents.append(event)
+        try await flushPendingEvents()
 
         isCharging = false
         currentSessionID = nil
     }
 
+    func flushPendingEvents() async throws {
+        guard let venue, !pendingEvents.isEmpty else { return }
+
+        let events = pendingEvents
+        pendingEvents.removeAll()
+        try await venue.submitEvents(events)
+    }
+
     private func makeEvent(
         sessionState: ElectricVehicleLoadEvent.Session.State,
         stateOfCharge: Int,
         power: Double,
         energy: Double
-    ) -> ElectricVehicleLoadEvent {
+    ) throws -> ElectricVehicleLoadEvent {
+        guard let guidanceToken else { throw EVError.missingGuidanceToken }
+        guard let currentSessionID else { throw EVError.noActiveSession }
+
         let guidanceState = ElectricVehicleLoadEvent.Session.GuidanceState(
-            wasFollowingGuidance: guidanceToken != nil,
-            guidanceToken: guidanceToken ?? UUID()
+            wasFollowingGuidance: true,
+            guidanceToken: guidanceToken
         )
 
         let session = ElectricVehicleLoadEvent.Session(
-            id: currentSessionID ?? UUID(),
+            id: currentSessionID,
             state: sessionState,
             guidanceState: guidanceState
         )
@@ -236,6 +251,8 @@ final class EVChargingManager {
 
     enum EVError: Error {
         case noVenue
+        case missingGuidanceToken
+        case noActiveSession
     }
 }
 ```
@@ -243,6 +260,13 @@ final class EVChargingManager {
 ## HVAC Control Manager
 
 Track HVAC load events with guidance compliance.
+Submit events when the heating or cooling stage changes, and use the real
+guidance token that was in effect for that venue.
+Treat heat stage 1 -> heat stage 2, heat -> cooling, cooling -> idle, and
+equipment stop as distinct load events instead of one summarized session row.
+For devices that emit frequent stage/runtime samples, buffer events and submit
+periodically or at the end of a session, while still recording significant state
+changes as they occur.
 
 ```swift
 import EnergyKit
@@ -262,7 +286,7 @@ final class HVACManager {
         self.deviceID = deviceID
     }
 
-    func configure(venue: EnergyVenue, guidanceToken: UUID?) {
+    func configure(venue: EnergyVenue, guidanceToken: UUID) {
         self.venue = venue
         self.guidanceToken = guidanceToken
     }
@@ -273,7 +297,7 @@ final class HVACManager {
         currentStage = stage
         isRunning = true
 
-        let event = makeEvent(state: .begin, stage: stage)
+        let event = try makeEvent(state: .begin, stage: stage)
         try await venue.submitEvents([event])
     }
 
@@ -281,14 +305,14 @@ final class HVACManager {
         guard let venue, isRunning else { return }
         currentStage = stage
 
-        let event = makeEvent(state: .active, stage: stage)
+        let event = try makeEvent(state: .active, stage: stage)
         try await venue.submitEvents([event])
     }
 
     func stop() async throws {
         guard let venue, isRunning else { return }
 
-        let event = makeEvent(state: .end, stage: 0)
+        let event = try makeEvent(state: .end, stage: 0)
         try await venue.submitEvents([event])
 
         isRunning = false
@@ -298,14 +322,17 @@ final class HVACManager {
     private func makeEvent(
         state: ElectricHVACLoadEvent.Session.State,
         stage: Int
-    ) -> ElectricHVACLoadEvent {
+    ) throws -> ElectricHVACLoadEvent {
+        guard let guidanceToken else { throw HVACError.missingGuidanceToken }
+        guard let sessionID else { throw HVACError.noActiveSession }
+
         let guidanceState = ElectricHVACLoadEvent.Session.GuidanceState(
-            wasFollowingGuidance: guidanceToken != nil,
-            guidanceToken: guidanceToken ?? UUID()
+            wasFollowingGuidance: true,
+            guidanceToken: guidanceToken
         )
 
         let session = ElectricHVACLoadEvent.Session(
-            id: sessionID ?? UUID(),
+            id: sessionID,
             state: state,
             guidanceState: guidanceState
         )
@@ -319,6 +346,11 @@ final class HVACManager {
             deviceID: deviceID
         )
     }
+
+    enum HVACError: Error {
+        case missingGuidanceToken
+        case noActiveSession
+    }
 }
 ```
 
@@ -414,8 +446,8 @@ struct EnergyDashboardView: View {
         return Text(label)
             .font(.caption)
             .fontWeight(.medium)
-            .padding(.horizontal, 8)
-            .padding(.vertical, 4)
+            .padding(.horizontal)
+            .padding(.vertical)
             .background(color.opacity(0.15))
             .foregroundStyle(color)
             .clipShape(Capsule())
@@ -426,6 +458,8 @@ struct EnergyDashboardView: View {
 ## Insight Data Visualization
 
 Prepare insight records for chart display.
+`dataByGridCleanliness` is iOS/iPadOS 26.1+, so keep the chart model optional
+and guard access when supporting 26.0.
 
 ```swift
 struct InsightDataPoint: Identifiable {
@@ -442,13 +476,23 @@ func processInsightRecords(
     records.compactMap { record in
         guard let total = record.totalEnergy else { return nil }
 
+        let cleanliness: (cleaner: Double?, lessClean: Double?)
+        if #available(iOS 26.1, iPadOS 26.1, *) {
+            cleanliness = (
+                record.dataByGridCleanliness?.cleaner?
+                    .converted(to: .kilowattHours).value,
+                record.dataByGridCleanliness?.lessClean?
+                    .converted(to: .kilowattHours).value
+            )
+        } else {
+            cleanliness = (nil, nil)
+        }
+
         return InsightDataPoint(
             date: record.range.start,
             energy: total.converted(to: .kilowattHours).value,
-            cleanerEnergy: record.dataByGridCleanliness?.cleaner?
-                .converted(to: .kilowattHours).value,
-            lessCleanEnergy: record.dataByGridCleanliness?.lessClean?
-                .converted(to: .kilowattHours).value
+            cleanerEnergy: cleanliness.cleaner,
+            lessCleanEnergy: cleanliness.lessClean
         )
     }
 }
@@ -462,25 +506,23 @@ Comprehensive error handling with retry logic.
 @Observable
 @MainActor
 final class ResilientEnergyService {
-    private var retryCount = 0
     private let maxRetries = 3
 
     func fetchGuidanceWithRetry(venueID: UUID) async throws -> ElectricityGuidance? {
         let query = ElectricityGuidance.Query(suggestedAction: .shift)
         let service = ElectricityGuidance.sharedService
 
-        while retryCount < maxRetries {
+        for attempt in 0..<maxRetries {
             do {
                 for try await guidance in service.guidance(using: query, at: venueID) {
-                    retryCount = 0
                     return guidance
                 }
             } catch let error as EnergyKitError {
                 switch error {
                 case .serviceUnavailable, .rateLimitExceeded:
-                    retryCount += 1
-                    let delay = UInt64(pow(2.0, Double(retryCount))) * 1_000_000_000
-                    try await Task.sleep(nanoseconds: delay)
+                    if attempt < maxRetries - 1 {
+                        try await Task.sleep(for: .seconds(pow(2.0, Double(attempt + 1))))
+                    }
                 case .unsupportedRegion, .permissionDenied, .venueUnavailable:
                     throw error  // Do not retry permanent failures
                 default:

package/pipeline/skills/shared/external/eventkit-calendar/SKILL.md

@@ -3,11 +3,11 @@ name: eventkit-calendar
 description: "Create, read, and manage calendar events and reminders using EventKit and EventKitUI. Use when adding events to the user's calendar, creating reminders, setting recurrence rules, requesting calendar or reminders access, presenting event editors, choosing calendars, handling alarms, observing calendar changes, or working with EKEventStore, EKEvent, EKReminder, EKCalendar, EKRecurrenceRule, EKEventEditViewController, EKCalendarChooser, or EventKitUI views."
 ---
 
-# EventKit — Calendar & Reminders
+# EventKit
 
 Create, read, and manage calendar events and reminders. Covers authorization,
 event and reminder CRUD, recurrence rules, alarms, and EventKitUI editors.
-Targets Swift 6.2 / iOS 26+.
+Targets Swift 6.3 / iOS 26+.
 
 ## Contents
 
@@ -33,10 +33,18 @@ Add the required usage description strings based on what access level you need:
 | Key | Access Level |
 |---|---|
 | `NSCalendarsFullAccessUsageDescription` | Read + write events |
-| `NSCalendarsWriteOnlyAccessUsageDescription` | Write-only events (iOS 17+) |
+| `NSCalendarsWriteOnlyAccessUsageDescription` | Direct write-only event creation |
 | `NSRemindersFullAccessUsageDescription` | Read + write reminders |
 
-> For apps also targeting iOS 16 or earlier, also include the legacy `NSCalendarsUsageDescription` / `NSRemindersUsageDescription` keys.
+On iOS 17+, an app that only presents `EKEventEditViewController` to let the
+person create an event does not need calendar authorization or calendar usage
+strings. Direct EventKit writes need write-only or full calendar access; any
+event read/fetch needs full calendar access. Reminders have only full access.
+
+> For apps also running on iOS 10 through iOS 16, include the legacy
+> `NSCalendarsUsageDescription` / `NSRemindersUsageDescription` keys. If using
+> EventKitUI on those systems, also include `NSContactsUsageDescription` when the
+> UI may need contact display names or avatars.
 
 ### Event Store
 
@@ -51,63 +59,41 @@ let eventStore = EKEventStore()
 
 ## Authorization
 
-iOS 17+ introduced granular access levels. Use the modern async methods.
+iOS 17+ introduced granular access levels. Request the narrowest access that
+matches the feature. If the deployment target includes earlier OS versions,
+availability-guard the iOS 17+ methods and fall back to `requestAccess(to:)`
+only before iOS 17.
 
 ### Full Access to Events
 
-```swift
-func requestCalendarAccess() async throws -> Bool {
-    let granted = try await eventStore.requestFullAccessToEvents()
-    return granted
-}
-```
+Call `try await eventStore.requestFullAccessToEvents()` when the app needs to
+read, edit, delete, or fetch calendar events.
 
 ### Write-Only Access to Events
 
 Use when your app only creates events (e.g., saving a booking) and does not
 need to read existing events.
 
-```swift
-func requestWriteAccess() async throws -> Bool {
-    let granted = try await eventStore.requestWriteOnlyAccessToEvents()
-    return granted
-}
-```
+Call `try await eventStore.requestWriteOnlyAccessToEvents()` before direct
+EventKit writes that do not use `EKEventEditViewController`.
+
+With write-only access, EventKit can create events but cannot read calendars or
+events, including events the app created. Calendar reads return a virtual
+calendar and event fetches return no events.
+
+Use full access instead of write-only if the app must later query, verify,
+modify, or sync saved events.
 
 ### Full Access to Reminders
 
-```swift
-func requestRemindersAccess() async throws -> Bool {
-    let granted = try await eventStore.requestFullAccessToReminders()
-    return granted
-}
-```
+Call `try await eventStore.requestFullAccessToReminders()` before reading,
+creating, editing, or deleting reminders.
 
 ### Checking Authorization Status
 
-```swift
-let status = EKEventStore.authorizationStatus(for: .event)
-
-switch status {
-case .notDetermined:
-    // Request access
-    break
-case .fullAccess:
-    // Read and write allowed
-    break
-case .writeOnly:
-    // Write-only access granted (iOS 17+)
-    break
-case .restricted:
-    // Parental controls or MDM restriction
-    break
-case .denied:
-    // User denied -- direct to Settings
-    break
-@unknown default:
-    break
-}
-```
+Use `EKEventStore.authorizationStatus(for: .event)` or `.reminder` before work.
+Handle `.notDetermined`, `.fullAccess`, `.writeOnly`, `.restricted`, `.denied`,
+and `@unknown default`; only `.fullAccess` supports event/reminder reads.
 
 ## Creating Events
 
@@ -153,7 +139,11 @@ event.structuredLocation = location
 ## Fetching Events
 
 Use a date-range predicate to query events. The `events(matching:)` method
-returns occurrences of recurring events expanded within the range.
+returns occurrences of recurring events expanded within the range. Fetching
+events requires full calendar access; write-only access returns no events.
+Event predicates are capped to a four-year span, and `events(matching:)` /
+`enumerateEvents(matching:using:)` are synchronous and return only committed
+events.
 
 ```swift
 func fetchEvents(from start: Date, to end: Date) -> [EKEvent] {
@@ -303,12 +293,22 @@ let absoluteAlarm = EKAlarm(absoluteDate: alertDate)
 event.addAlarm(absoluteAlarm)
 ```
 
+For reminder geofences, put an `EKStructuredLocation` and `.enter` / `.leave`
+proximity on an `EKAlarm`, then add it to the reminder. See
+[references/eventkit-patterns.md](references/eventkit-patterns.md) for the full
+location-based reminder pattern.
+
 ## EventKitUI Controllers
 
-### EKEventEditViewController — Create/Edit Events
+### EKEventEditViewController  -  Create/Edit Events
 
 Present the system event editor for creating or editing events.
 
+On iOS 17+, `EKEventEditViewController` can let someone create an event without
+the app requesting calendar access. The editor runs out of process with its own
+calendar access, so do not inspect the dismissed controller to learn what was
+saved; refetch only if the app separately has full access.
+
 ```swift
 import EventKitUI
 
@@ -342,7 +342,7 @@ class EventEditorCoordinator: NSObject, EKEventEditViewDelegate {
 }
 ```
 
-### EKEventViewController — View an Event
+### EKEventViewController  -  View an Event
 
 ```swift
 import EventKitUI
@@ -353,7 +353,11 @@ viewer.allowsEditing = true
 navigationController?.pushViewController(viewer, animated: true)
 ```
 
-### EKCalendarChooser — Select Calendars
+### EKCalendarChooser  -  Select Calendars
+
+`EKCalendarChooser` requires write-only or full calendar access. In write-only
+apps, the chooser behaves as writable-calendars-only and only allows a single
+writable calendar selection.
 
 ```swift
 let chooser = EKCalendarChooser(
@@ -384,7 +388,11 @@ NotificationCenter.default.addObserver(
 ```
 
 Always re-fetch events after receiving this notification. Previously fetched
-`EKEvent` objects may be stale.
+`EKEvent`, `EKReminder`, and `EKCalendar` objects may be stale. The notification
+is posted on the main actor.
+
+On iOS 26+, you can also use the typed `EKEventStore.EventStoreChanged` /
+`.changed` notification message behind availability checks.
 
 ## Common Mistakes
 
@@ -398,6 +406,9 @@ eventStore.requestAccess(to: .event) { granted, error in }
 let granted = try await eventStore.requestFullAccessToEvents()
 ```
 
+On iOS 17+, `requestAccess(to: .event)` does not prompt and throws. Keep it only
+as an availability-guarded fallback for apps that still run on earlier systems.
+
 ### DON'T: Save events to a read-only calendar
 
 ```swift
@@ -456,20 +467,23 @@ try eventStore.save(event, span: .thisEvent)
 ## Review Checklist
 
 - [ ] Correct `Info.plist` usage description keys added for calendars and/or reminders
-- [ ] Authorization requested with iOS 17+ granular methods (`requestFullAccessToEvents`, `requestWriteOnlyAccessToEvents`, `requestFullAccessToReminders`)
+- [ ] Authorization requested with iOS 17+ granular methods, with `requestAccess(to:)` only as a pre-iOS 17 fallback
+- [ ] Write-only calendar access used only for direct event creation, not event/calendar reads
 - [ ] Authorization status checked before fetching or saving
+- [ ] Full access required before any event or reminder fetch
 - [ ] Single `EKEventStore` instance reused across the app
 - [ ] Events saved to a writable calendar (`allowsContentModifications` checked)
 - [ ] Recurring event saves specify correct `EKSpan` (`.thisEvent` vs `.futureEvents`)
 - [ ] Batched saves followed by explicit `commit()`
 - [ ] `EKEventStoreChanged` notification observed to refresh stale data
+- [ ] iOS 26 typed `.changed` notification used only behind availability checks
 - [ ] Timezone set explicitly for location-specific events
 - [ ] EKObjects not shared across different event store instances
 - [ ] EventKitUI delegates dismiss controllers in completion callbacks
 
 ## References
 
-- Extended patterns (SwiftUI wrappers, predicate queries, batch operations): `references/eventkit-patterns.md`
+- Extended patterns (SwiftUI wrappers, predicate queries, batch operations): [references/eventkit-patterns.md](references/eventkit-patterns.md)
 - [EventKit framework](https://sosumi.ai/documentation/eventkit)
 - [EKEventStore](https://sosumi.ai/documentation/eventkit/ekeventstore)
 - [EKEvent](https://sosumi.ai/documentation/eventkit/ekevent)

package/pipeline/skills/shared/external/eventkit-calendar/evals/evals.json

@@ -0,0 +1,44 @@
+{
+  "skill_name": "eventkit",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Review this iOS 26 calendar integration plan: the app asks for `NSCalendarsUsageDescription`, calls `requestAccess(to: .event)`, requests write-only access, then fetches the user's existing events to avoid conflicts before saving a booking. The team also wants an Add to Calendar button where the user can edit the event in the system sheet. Give corrected guidance with Swift API names where useful.",
+      "expected_output": "A review that fixes iOS 17+ calendar authorization, Info.plist keys, write-only read limitations, full-access requirements for fetching, and EventKitUI no-authorization creation.",
+      "files": [],
+      "assertions": [
+        "States that iOS 17+ direct EventKit access needs `NSCalendarsWriteOnlyAccessUsageDescription` or `NSCalendarsFullAccessUsageDescription`, not only `NSCalendarsUsageDescription`.",
+        "States that `requestAccess(to: .event)` is only a pre-iOS 17 fallback and should be availability-guarded when supporting older systems.",
+        "Explains that write-only event access can create events but cannot read calendars or fetch existing events, including app-created events.",
+        "Requires full calendar access for fetching existing events to detect conflicts.",
+        "States that `EKEventEditViewController` can let the user create/edit an event without the app requesting calendar authorization, with the limitation that the app cannot inspect the saved result afterward."
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "We need to create reminders when someone enters a job site. The draft code creates an `EKReminder`, assigns a `CLLocation` to `EKStructuredLocation`, adds a blank `EKAlarm()`, skips reminder authorization, and assumes `defaultCalendarForNewReminders()` is always non-nil. What should be fixed?",
+      "expected_output": "A correction that covers reminder full access, required title/calendar/default-list handling, location-based alarm setup, save behavior, and Core Location privacy only when current location is used.",
+      "files": [],
+      "assertions": [
+        "Requires full reminders access through `requestFullAccessToReminders()` before creating or reading reminders.",
+        "Checks that `defaultCalendarForNewReminders()` returns a calendar and states that reminder `title` and `calendar` must be set before save.",
+        "Uses `EKStructuredLocation` with `geoLocation` and a radius in meters for the geofence.",
+        "Configures an `EKAlarm` with a structured location and `.enter` or `.leave` proximity before adding it to the reminder.",
+        "Mentions `NSLocationWhenInUseUsageDescription` only if the app accesses the person's current location, not merely for fixed coordinates."
+      ]
+    },
+    {
+      "id": 3,
+      "prompt": "A teammate wants to use the push notifications layer for all calendar alerts: every event and reminder should schedule a `UNNotificationRequest`, and EventKit should only store title/start/end dates. Review the boundary and recommend the right approach.",
+      "expected_output": "A boundary answer that keeps Calendar/Reminders alarms in EventKit, hands app-owned notification workflows to push notifications, and avoids expanding EventKit into APNs guidance.",
+      "files": [],
+      "assertions": [
+        "Recommends `EKAlarm` for Calendar event or Reminders alarms that should live with the calendar/reminder item.",
+        "Mentions relative or absolute event alarms using `EKAlarm(relativeOffset:)` or `EKAlarm(absoluteDate:)` and `addAlarm(_:)`.",
+        "Mentions structured-location reminders as an EventKit reminder alarm case when location is part of the reminder.",
+        "Hands off app-owned local/remote notification delivery to `UNUserNotificationCenter` or the push-notifications skill instead of turning EventKit into APNs guidance.",
+        "Does not claim EventKit calendar/reminder alarms require push notification authorization from the app."
+      ]
+    }
+  ]
+}

package/pipeline/skills/shared/external/eventkit-calendar/references/eventkit-patterns.md

@@ -1,6 +1,6 @@
 # EventKit Extended Patterns
 
-Overflow reference for the `eventkit-calendar` skill. Contains advanced patterns that exceed the main skill file's scope.
+Overflow reference for the `eventkit` skill. Contains advanced patterns that exceed the main skill file's scope.
 
 ## Contents
 
@@ -10,9 +10,15 @@ Overflow reference for the `eventkit-calendar` skill. Contains advanced patterns
 - [Calendar Management](#calendar-management)
 - [Reminder Workflows](#reminder-workflows)
 - [EventKitUI in SwiftUI](#eventkitui-in-swiftui)
+- [Typed Change Notifications](#typed-change-notifications)
 
 ## SwiftUI Calendar Integration
 
+Read event data only after full calendar access. Write-only access can create
+events but cannot read calendars or events, including events the app created.
+When supporting iOS 16 or earlier, availability-guard iOS 17+ access requests
+and use `requestAccess(to:)` only on the older path.
+
 ### Observable Event Manager
 
 ```swift
@@ -97,6 +103,11 @@ struct CalendarEventsView: View {
 
 ## Advanced Predicate Queries
 
+Event predicates search at most a four-year span. `events(matching:)` and
+`enumerateEvents(matching:using:)` are synchronous and include only committed
+events, so commit batched changes before querying and move large reads off the
+main actor when needed.
+
 ### Events in a Specific Calendar
 
 ```swift
@@ -230,20 +241,35 @@ let writableCalendars = eventCalendars.filter { $0.allowsContentModifications }
 ### Reminder with Location-Based Alarm
 
 ```swift
+import CoreLocation
+import EventKit
+
+enum CalendarError: Error {
+    case remindersAccessRequired
+    case missingDefaultReminderList
+}
+
 func createLocationReminder(
     title: String,
     latitude: Double,
     longitude: Double
 ) throws {
+    guard EKEventStore.authorizationStatus(for: .reminder) == .fullAccess else {
+        throw CalendarError.remindersAccessRequired
+    }
+    guard let reminderCalendar = eventStore.defaultCalendarForNewReminders() else {
+        throw CalendarError.missingDefaultReminderList
+    }
+
     let reminder = EKReminder(eventStore: eventStore)
     reminder.title = title
-    reminder.calendar = eventStore.defaultCalendarForNewReminders()
+    reminder.calendar = reminderCalendar
 
     let location = EKStructuredLocation(title: "Target Location")
     location.geoLocation = CLLocation(latitude: latitude, longitude: longitude)
     location.radius = 200 // meters
 
-    let alarm = EKAlarm()
+    let alarm = EKAlarm(relativeOffset: 0)
     alarm.structuredLocation = location
     alarm.proximity = .enter  // .enter or .leave
     reminder.addAlarm(alarm)
@@ -252,6 +278,10 @@ func createLocationReminder(
 }
 ```
 
+If the app uses the person's current location while creating location-based
+reminders, add `NSLocationWhenInUseUsageDescription` and request Core Location
+authorization in the location layer.
+
 ### Reminder with Priority
 
 ```swift
@@ -306,6 +336,10 @@ struct EventEditView: UIViewControllerRepresentable {
 }
 ```
 
+On iOS 17+, the editor can create events without app calendar authorization. It
+runs out of process, so the app cannot inspect the dismissed controller to learn
+what the person saved unless the app separately has full access and refetches.
+
 ### Usage in SwiftUI
 
 ```swift
@@ -324,3 +358,19 @@ struct CalendarView: View {
     }
 }
 ```
+
+## Typed Change Notifications
+
+Use `.EKEventStoreChanged` for broad compatibility. On iOS 26+, the typed
+notification message is available when you want Foundation's message API:
+
+```swift
+if #available(iOS 26.0, *) {
+    let observation = NotificationCenter.default.addObserver(
+        of: eventStore,
+        for: .changed
+    ) { _ in
+        fetchThisWeekEvents()
+    }
+}
+```