@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.0

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

@@ -3,42 +3,45 @@
   "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 an appointment. 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.",
+      "name": "calendar-access-levels",
+      "prompt": "Our event-ticket app targets iOS 16 and later. It calls requestAccess(to: .event) on every launch, only has NSCalendarsUsageDescription in Info.plist, asks for write-only access so it can add concerts, and then checks the user's calendar for clashes. Some people just want to add a concert through the system editor. What should change?",
+      "expected_output": "Adds the iOS 17 full-access and write-only keys alongside the legacy key, uses the granular request methods with requestAccess(to:) only in a pre-17 availability branch, explains write-only cannot read or fetch so the clash check needs full access, and notes EKEventEditViewController needs no permission on iOS 17+ but its saved result cannot be inspected.",
       "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."
+        "Adds NSCalendarsFullAccessUsageDescription and NSCalendarsWriteOnlyAccessUsageDescription, not only the legacy key",
+        "Uses requestFullAccessToEvents or requestWriteOnlyAccessToEvents on iOS 17+, with requestAccess(to:) only as an availability-guarded fallback",
+        "States write-only access cannot read calendars or fetch events",
+        "Requires full access for the conflict check",
+        "Says EKEventEditViewController works without authorization on iOS 17+ and the app cannot inspect what was saved"
       ]
     },
     {
       "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.",
+      "name": "location-reminder",
+      "prompt": "Build a 'remind me when I get to the hardware store' feature. We have the store's coordinates from our own database. Our draft saves an EKReminder straight away without a calendar, puts the coordinate in the notes field, and asks for Always location permission at launch.",
+      "expected_output": "Requests full reminders access, checks the default reminder list is not nil and sets title and calendar before saving, builds an EKStructuredLocation with geoLocation and a radius in meters, attaches it to an EKAlarm with proximity .enter, and adds a location usage key only if the app uses the person's current location.",
       "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."
+        "Calls requestFullAccessToReminders before creating the reminder",
+        "Guards defaultCalendarForNewReminders against nil and sets title and calendar before saving",
+        "Creates an EKStructuredLocation with geoLocation and a radius in meters",
+        "Adds an EKAlarm with the structured location and a proximity of .enter or .leave",
+        "Adds a location usage description and Core Location request only when the person's current location is used"
       ]
     },
     {
       "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.",
+      "name": "alarms-vs-app-notifications",
+      "prompt": "Our study planner adds exam events to the user's calendar and wants alerts 1 day and 1 hour before. We also want the app itself to send a motivational notification each morning. Do we need notification permission for the calendar alerts, and how should both parts be built?",
+      "expected_output": "Uses EKAlarm with relative offsets (or absolute dates) added through addAlarm(_:) for the calendar alerts, mentions structured-location alarms for reminders, routes the app's own morning notification to UNUserNotificationCenter and the push-notifications skill, and does not claim EventKit alarms need notification authorization.",
       "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."
+        "Uses EKAlarm for the exam alerts",
+        "Shows relative or absolute alarms added with addAlarm(_:)",
+        "Mentions location-based alarms on reminders through EKStructuredLocation",
+        "Sends the app-owned morning notification through UNUserNotificationCenter or the push-notifications skill",
+        "Does not say EventKit alarms require notification permission"
       ]
     }
   ]
-}
+}

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

@@ -1,376 +1,273 @@
-# EventKit Extended Patterns
+# EventKit Patterns
 
-Overflow reference for the `eventkit` skill. Contains advanced patterns that exceed the main skill file's scope.
+Extended recipes for the `eventkit-calendar` skill.
 
-## Contents
+## A SwiftUI week view
 
-- [SwiftUI Calendar Integration](#swiftui-calendar-integration)
-- [Advanced Predicate Queries](#advanced-predicate-queries)
-- [Batch Operations](#batch-operations)
-- [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
+Reading events needs full access. Write-only access cannot read anything,
+including events the app saved itself. If the app still supports iOS 16 or
+earlier, put the iOS 17 request methods behind availability checks.
 
 ```swift
-import EventKit
 import SwiftUI
+import EventKit
 
-@Observable
-@MainActor
-final class CalendarManager {
-    let eventStore = EKEventStore()
-    var events: [EKEvent] = []
-    var authorizationStatus: EKAuthorizationStatus = .notDetermined
-
-    func requestAccess() async {
-        do {
-            let granted = try await eventStore.requestFullAccessToEvents()
-            authorizationStatus = granted ? .fullAccess : .denied
-            if granted { fetchThisWeekEvents() }
-        } catch {
-            authorizationStatus = .denied
+@MainActor @Observable
+final class WeekAgenda {
+    private(set) var items: [EKEvent] = []
+    private(set) var status = EKEventStore.authorizationStatus(for: .event)
+
+    @ObservationIgnored private let store = EKEventStore()
+    @ObservationIgnored private var changeToken: (any NSObjectProtocol)?
+
+    func connect() async {
+        let granted = (try? await store.requestFullAccessToEvents()) ?? false
+        status = granted ? .fullAccess : .denied
+        guard granted else { return }
+        reload()
+        let center = NotificationCenter.default
+        changeToken = center.addObserver(forName: .EKEventStoreChanged, object: store, queue: .main) { [weak self] _ in
+            Task { @MainActor in self?.reload() }
         }
     }
 
-    func fetchThisWeekEvents() {
-        let calendar = Calendar.current
-        let start = calendar.startOfDay(for: Date())
-        let end = calendar.date(byAdding: .day, value: 7, to: start)!
-
-        let predicate = eventStore.predicateForEvents(
-            withStart: start,
-            end: end,
+    func reload() {
+        let monday = Calendar.current.startOfDay(for: .now)
+        let week = store.predicateForEvents(
+            withStart: monday,
+            end: monday.addingTimeInterval(7 * 86_400),
             calendars: nil
         )
-        events = eventStore.events(matching: predicate)
-            .sorted { $0.startDate < $1.startDate }
-    }
-
-    func observeChanges() {
-        NotificationCenter.default.addObserver(
-            forName: .EKEventStoreChanged,
-            object: eventStore,
-            queue: .main
-        ) { [weak self] _ in
-            self?.fetchThisWeekEvents()
-        }
+        items = store.events(matching: week).sorted { $0.startDate < $1.startDate }
     }
 }
-```
 
-### SwiftUI View with Calendar Events
-
-```swift
-struct CalendarEventsView: View {
-    @State private var manager = CalendarManager()
+struct WeekAgendaView: View {
+    @State private var agenda = WeekAgenda()
 
     var body: some View {
-        List(manager.events, id: \.eventIdentifier) { event in
-            VStack(alignment: .leading) {
-                Text(event.title)
-                    .font(.headline)
+        List(agenda.items, id: \.eventIdentifier) { event in
+            LabeledContent {
                 Text(event.startDate, style: .date)
-                    .font(.caption)
-                    .foregroundStyle(.secondary)
+            } label: {
+                Text(event.title)
             }
         }
-        .task {
-            await manager.requestAccess()
-            manager.observeChanges()
-        }
         .overlay {
-            if manager.events.isEmpty {
-                ContentUnavailableView(
-                    "No Events",
-                    systemImage: "calendar",
-                    description: Text("No events this week.")
-                )
+            if agenda.items.isEmpty {
+                ContentUnavailableView("Nothing This Week", systemImage: "calendar")
             }
         }
+        .task { await agenda.connect() }
     }
 }
 ```
 
-## Advanced Predicate Queries
+## 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.
+Keep these limits in mind:
 
-### Events in a Specific Calendar
+- A predicate covers at most four years.
+- Fetches are synchronous and see only committed data, so commit a batch
+  before querying it.
+- Large reads block the caller; run them away from the main actor.
+
+### One calendar, one interval
 
 ```swift
-func fetchEvents(in calendar: EKCalendar, range: DateInterval) -> [EKEvent] {
-    let predicate = eventStore.predicateForEvents(
-        withStart: range.start,
-        end: range.end,
-        calendars: [calendar]
-    )
-    return eventStore.events(matching: predicate)
+func events(in calendar: EKCalendar, during span: DateInterval) -> [EKEvent] {
+    let query = store.predicateForEvents(withStart: span.start, end: span.end, calendars: [calendar])
+    return store.events(matching: query)
 }
 ```
 
-### Completed Reminders in a Date Range
+### Completed reminders
+
+As in the main skill, only `Sendable` values leave the callback; here that is
+the identifiers.
 
 ```swift
-func fetchCompletedReminders(from start: Date, to end: Date) async -> [EKReminder] {
-    let predicate = eventStore.predicateForCompletedReminders(
-        withCompletionDateStarting: start,
-        ending: end,
-        calendars: nil
+func finishedReminders(since start: Date) async -> [String] {
+    let query = store.predicateForCompletedReminders(
+        withCompletionDateStarting: start, ending: .now, calendars: nil
     )
-
-    return await withCheckedContinuation { continuation in
-        eventStore.fetchReminders(matching: predicate) { reminders in
-            continuation.resume(returning: reminders ?? [])
+    return await withCheckedContinuation { resume in
+        store.fetchReminders(matching: query) { found in
+            resume.resume(returning: (found ?? []).map(\.calendarItemIdentifier))
         }
     }
 }
 ```
 
-### Enumerating Events Efficiently
-
-For large date ranges, use `enumerateEvents` to process events one at a time
-without loading all into memory.
+### Walking a long range
 
 ```swift
-func processAllEvents(from start: Date, to end: Date) {
-    let predicate = eventStore.predicateForEvents(
-        withStart: start,
-        end: end,
-        calendars: nil
-    )
-
-    eventStore.enumerateEvents(matching: predicate) { event, stop in
-        // Process each event
-        if event.title.contains("Cancel") {
-            stop.pointee = true // Stop enumeration early
-        }
+var firstClash: EKEvent?
+store.enumerateEvents(matching: query) { event, stop in
+    if event.availability == .busy, event.startDate < proposedEnd, event.endDate > proposedStart {
+        firstClash = event
+        stop.pointee = true
     }
 }
 ```
 
-## Batch Operations
+`enumerateEvents` hands over one event at a time instead of building an array,
+and setting `stop.pointee = true` ends the walk early.
 
-### Creating Multiple Events Efficiently
-
-Use `commit: false` for individual saves, then commit once at the end.
+## Batches
 
 ```swift
-func createEvents(from entries: [(String, Date, Date)]) throws {
-    for (title, start, end) in entries {
-        let event = EKEvent(eventStore: eventStore)
-        event.title = title
-        event.startDate = start
-        event.endDate = end
-        event.calendar = eventStore.defaultCalendarForNewEvents
-        try eventStore.save(event, span: .thisEvent, commit: false)
+func importSessions(_ sessions: [ConferenceSession], into calendar: EKCalendar) throws {
+    for session in sessions {
+        let event = EKEvent(eventStore: store)
+        event.title = session.title
+        event.startDate = session.start
+        event.endDate = session.end
+        event.calendar = calendar
+        try store.save(event, span: .thisEvent, commit: false)
     }
-    try eventStore.commit()
+    try store.commit()
 }
-```
 
-### Deleting Events in Bulk
-
-```swift
-func deleteEvents(_ events: [EKEvent]) throws {
-    for event in events {
-        try eventStore.remove(event, span: .thisEvent, commit: false)
+func cancelAll(_ doomed: [EKEvent]) throws {
+    for item in doomed {
+        try store.remove(item, span: .thisEvent, commit: false)
     }
-    try eventStore.commit()
+    try store.commit()
 }
 ```
 
-### Resetting Unsaved Changes
-
-```swift
-// Discard all uncommitted changes
-eventStore.reset()
-```
+One `commit()` at the end writes the whole batch. `store.reset()` throws away
+everything not yet committed.
 
-## Calendar Management
-
-### Creating a Custom Calendar
+## Managing calendars
 
 ```swift
-func createCalendar(name: String, color: CGColor) throws -> EKCalendar {
-    let calendar = EKCalendar(for: .event, eventStore: eventStore)
-    calendar.title = name
-    calendar.cgColor = color
-
-    // Find a local source (iCloud, local, etc.)
-    if let localSource = eventStore.sources.first(where: {
-        $0.sourceType == .local
-    }) {
-        calendar.source = localSource
-    } else if let defaultSource = eventStore.defaultCalendarForNewEvents?.source {
-        calendar.source = defaultSource
-    }
-
-    try eventStore.saveCalendar(calendar, commit: true)
-    return calendar
+func makeTripCalendar() throws -> EKCalendar {
+    let trips = EKCalendar(for: .event, eventStore: store)
+    trips.title = "Trips"
+    trips.cgColor = UIColor.systemTeal.cgColor
+    trips.source = store.sources.first { $0.sourceType == .local }
+        ?? store.defaultCalendarForNewEvents?.source
+    try store.saveCalendar(trips, commit: true)
+    return trips
 }
 ```
 
-### Listing Calendars by Type
-
-```swift
-// All event calendars
-let eventCalendars = eventStore.calendars(for: .event)
-
-// All reminder calendars
-let reminderCalendars = eventStore.calendars(for: .reminder)
-
-// Only writable calendars
-let writableCalendars = eventCalendars.filter { $0.allowsContentModifications }
-```
+A local source is preferred; otherwise the new calendar joins the default
+calendar's source. List calendars with `store.calendars(for: .event)` or
+`.reminder`, and keep only those with `allowsContentModifications` when you
+need a writable one.
 
-## Reminder Workflows
+## Reminder recipes
 
-### Reminder with Location-Based Alarm
+### Location-triggered reminder
 
 ```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
+func remindOnArrival(at place: CLLocation, named title: String) throws {
+    let access = EKEventStore.authorizationStatus(for: .reminder)
+    guard access == .fullAccess else { throw PlannerError.remindersNotAllowed }
+    guard let list = store.defaultCalendarForNewReminders() else {
+        throw PlannerError.noReminderList
     }
-    guard let reminderCalendar = eventStore.defaultCalendarForNewReminders() else {
-        throw CalendarError.missingDefaultReminderList
-    }
-
-    let reminder = EKReminder(eventStore: eventStore)
+    let reminder = EKReminder(eventStore: store)
     reminder.title = title
-    reminder.calendar = reminderCalendar
+    reminder.calendar = list
 
-    let location = EKStructuredLocation(title: "Target Location")
-    location.geoLocation = CLLocation(latitude: latitude, longitude: longitude)
-    location.radius = 200 // meters
+    let spot = EKStructuredLocation(title: "Garden Centre")
+    spot.geoLocation = place
+    spot.radius = 150
 
-    let alarm = EKAlarm(relativeOffset: 0)
-    alarm.structuredLocation = location
-    alarm.proximity = .enter  // .enter or .leave
-    reminder.addAlarm(alarm)
+    let trigger = EKAlarm(relativeOffset: 0)
+    trigger.structuredLocation = spot
+    trigger.proximity = .enter
+    reminder.addAlarm(trigger)
 
-    try eventStore.save(reminder, commit: true)
+    try store.save(reminder, commit: true)
 }
 ```
 
-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.
+`radius` is in meters. Use `.leave` instead of `.enter` for departure alerts.
+The reminder needs a title and a calendar before it is saved. Coordinates from your own data need no
+location permission. Only when `place` comes from where the person is right
+now does the app add `NSLocationWhenInUseUsageDescription` and ask Core
+Location.
 
-### Reminder with Priority
+### Priority
 
-```swift
-let reminder = EKReminder(eventStore: eventStore)
-reminder.title = "Important Task"
-reminder.priority = 1  // 1-4: High, 5: Medium, 6-9: Low, 0: None
-reminder.calendar = eventStore.defaultCalendarForNewReminders()
-```
-
-## EventKitUI in SwiftUI
+| `priority` | Meaning |
+|------------|---------|
+| 0 | None |
+| 1 to 4 | High |
+| 5 | Medium |
+| 6 to 9 | Low |
 
-### UIViewControllerRepresentable for Event Editor
+## The event editor in SwiftUI
 
 ```swift
-import SwiftUI
 import EventKitUI
 
-struct EventEditView: UIViewControllerRepresentable {
-    let eventStore: EKEventStore
+struct EventEditorSheet: UIViewControllerRepresentable {
+    let store: EKEventStore
     @Binding var isPresented: Bool
 
+    func makeCoordinator() -> Coordinator { Coordinator(isPresented: $isPresented) }
+
     func makeUIViewController(context: Context) -> EKEventEditViewController {
-        let editor = EKEventEditViewController()
-        editor.eventStore = eventStore
-        editor.editViewDelegate = context.coordinator
-        return editor
+        let sheet = EKEventEditViewController()
+        sheet.editViewDelegate = context.coordinator
+        sheet.eventStore = store
+        return sheet
     }
 
-    func updateUIViewController(
-        _ uiViewController: EKEventEditViewController,
-        context: Context
-    ) {}
+    func updateUIViewController(_ sheet: EKEventEditViewController, context: Context) {}
 
-    func makeCoordinator() -> Coordinator {
-        Coordinator(self)
-    }
-
-    class Coordinator: NSObject, EKEventEditViewDelegate {
-        let parent: EventEditView
+    final class Coordinator: NSObject, EKEventEditViewDelegate {
+        @Binding var isPresented: Bool
 
-        init(_ parent: EventEditView) {
-            self.parent = parent
-        }
+        init(isPresented: Binding<Bool>) { _isPresented = isPresented }
 
-        func eventEditViewController(
-            _ controller: EKEventEditViewController,
-            didCompleteWith action: EKEventEditViewAction
-        ) {
-            parent.isPresented = false
+        func eventEditViewController(_ sheet: EKEventEditViewController,
+                                     didCompleteWith outcome: EKEventEditViewAction) {
+            isPresented = false
         }
     }
 }
-```
-
-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
-struct CalendarView: View {
-    @State private var showEditor = false
-    let eventStore = EKEventStore()
+struct AddToCalendarButton: View {
+    let store: EKEventStore
+    @State private var editing = false
 
     var body: some View {
-        Button("Add Event") { showEditor = true }
-            .sheet(isPresented: $showEditor) {
-                EventEditView(
-                    eventStore: eventStore,
-                    isPresented: $showEditor
-                )
+        Button("Add to Calendar", systemImage: "calendar.badge.plus") { editing = true }
+            .sheet(isPresented: $editing) {
+                EventEditorSheet(store: store, isPresented: $editing)
             }
     }
 }
 ```
 
-## Typed Change Notifications
+From iOS 17 this needs no calendar permission at all: the editor lives in
+another process. The app does not learn what was saved; it can see
+the result only with full access and a fresh fetch.
 
-Use `.EKEventStoreChanged` for broad compatibility. On iOS 26+, the typed
-notification message is available when you want Foundation's message API:
+## Change notifications, old and new
+
+`.EKEventStoreChanged` works on every supported version. On iOS 26 the typed
+message can be used through Foundation's message-based observer API:
 
 ```swift
-if #available(iOS 26.0, *) {
-    let observation = NotificationCenter.default.addObserver(
-        of: eventStore,
-        for: .changed
-    ) { _ in
-        fetchThisWeekEvents()
+if #available(iOS 26, *) {
+    storeObservation = NotificationCenter.default.addObserver(of: store, for: .changed) { _ in
+        agenda.reload()
+    }
+} else {
+    let center = NotificationCenter.default
+    storeObservation = center.addObserver(forName: .EKEventStoreChanged, object: store, queue: nil) { _ in
+        Task { @MainActor in agenda.reload() }
     }
 }
 ```
+
+Keep the returned token alive for as long as updates are wanted. The two APIs
+return different token types, so `storeObservation` is declared as `Any?`.