@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.0

package/pipeline/skills/shared/external/contacts-framework/evals/evals.json

@@ -3,38 +3,36 @@
   "evals": [
     {
       "id": 1,
-      "prompt": "I'm updating an iOS 26 SwiftUI contacts screen. It currently treats only CNAuthorizationStatus.authorized as usable and hides the list for .limited. Review the approach and show the authorization handling I should use, including how someone can add more contacts later.",
-      "expected_output": "Guidance that treats .authorized and .limited as usable Contacts API states, explains limited-access restrictions, and uses ContactsUI limited-access controls.",
-      "files": [],
+      "prompt": "Our iOS 26 carpool app shows the user's contacts so they can invite riders. Some testers chose to share only a handful of contacts and now say the list is nearly empty and there is no way to add more. How should the app treat this permission state and let them share more?",
+      "expected_output": "Identifies the .limited authorization state, treats it like .authorized for proceeding, explains that the app sees and edits just the shared contacts plus any it created itself, and offers ContactAccessButton or the contactAccessPicker modifier so people can share more. Distinguishes managing limited access from picking a contact with CNContactPickerViewController.",
       "assertions": [
-        "Treats both .authorized and .limited as states where Contacts API fetch/save code can proceed.",
-        "Explains that .limited exposes only user-granted or app-created contacts, not the whole address book.",
-        "Recommends ContactAccessButton or contactAccessPicker for expanding limited access.",
-        "Distinguishes limited-access management from CNContactPickerViewController selection."
+        "Lets the app continue in the .limited state just as in .authorized",
+        "Explains that .limited reaches shared contacts and contacts the app itself created, nothing else",
+        "Offers ContactAccessButton or contactAccessPicker to expand access",
+        "Separates limited-access management from one-off selection with the contact picker"
       ]
     },
     {
       "id": 2,
-      "prompt": "Review this Contacts fetch plan: use CNContactCompleteNameKey for the displayed name, include CNContactImageDataKey by default for avatars, and fetch CNContactNoteKey so the app can show notes. What should change before I ship?",
-      "expected_output": "A source-grounded correction that uses valid name descriptors, avoids over-fetching images, and narrows the notes entitlement requirement.",
-      "files": [],
+      "prompt": "Here is our plan for a CRM contact list: fetch CNContactCompleteNameKey for names, CNContactImageDataKey for the round avatars, and CNContactNoteKey to show a note preview in each row. Anything wrong?",
+      "expected_output": "Rejects CNContactCompleteNameKey in favour of CNContactFormatter.descriptorForRequiredKeys(for: .fullName) or individual name keys, swaps the full image for CNContactThumbnailImageDataKey in list avatars, and points out that reading notes (CNContactNoteKey) is gated by an Apple-approved entitlement, com.apple.developer.contacts.notes, granted before App Store distribution.",
       "assertions": [
-        "Rejects CNContactCompleteNameKey and uses CNContactFormatter.descriptorForRequiredKeys(for:) or valid individual name keys instead.",
-        "Recommends fetching only displayed fields and using thumbnail image data for list avatars instead of full image data by default.",
-        "States that CNContactNoteKey / CNContact.note requires the com.apple.developer.contacts.notes entitlement on modern Apple platforms.",
-        "Mentions that the contacts notes entitlement requires Apple approval before public App Store distribution."
+        "Replaces CNContactCompleteNameKey with the formatter descriptor or individual name keys",
+        "Uses thumbnail image data rather than full-resolution image data for list avatars",
+        "Ties CNContactNoteKey to the com.apple.developer.contacts.notes entitlement",
+        "Notes that the notes entitlement needs Apple approval before public distribution"
       ]
     },
     {
       "id": 3,
-      "prompt": "I want a no-permission contact picker for email selection and an incremental Contacts sync. The draft uses CNContactPickerViewController plus store.enumerateChanges(matching: CNChangeHistoryFetchRequest()). Review the API boundaries and give iOS Swift-safe guidance.",
-      "expected_output": "Guidance that keeps picker selection scoped to the user's final choice and rejects unsupported Swift change-history examples.",
-      "files": [],
+      "prompt": "We want users to pick one email address from their contacts without granting us Contacts access, and we also want to sync incrementally by calling store.enumerateChanges(matching:) when the address book changes. Sketch both parts.",
+      "expected_output": "Uses CNContactPickerViewController, which works without any Contacts permission and hands back just the chosen item, configuring predicateForEnablingContact and predicateForSelectionOfProperty (and displayedPropertyKeys) before presenting it. Rejects enumerateChanges(matching:) as nonexistent, explains the change-history enumerator is an Objective-C selector unavailable in Swift, and recommends refetching on CNContactStoreDidChange or wrapping an Objective-C bridge.",
       "assertions": [
-        "States that CNContactPickerViewController does not require full Contacts authorization and returns only the user's final selection.",
-        "Mentions picker predicates such as predicateForEnablingContact or predicateForSelectionOfProperty must be configured before presentation.",
-        "Rejects store.enumerateChanges(matching:) as a nonexistent Contacts Swift API.",
-        "Explains that the change-history enumerator is Objective-C-only / unavailable in Swift and recommends CNContactStoreDidChange refetching or an explicit Objective-C bridge for true incremental history."
+        "States that the picker needs no Contacts authorization and returns only what was selected",
+        "Sets predicateForEnablingContact and predicateForSelectionOfProperty before presentation",
+        "Rejects enumerateChanges(matching:) as an API that does not exist",
+        "Says change history comes from an Objective-C selector that Swift cannot call",
+        "Recommends refetching on CNContactStoreDidChange or an isolated Objective-C bridge"
       ]
     }
   ]

package/pipeline/skills/shared/external/contacts-framework/references/contacts-patterns.md

@@ -1,409 +1,270 @@
-# Contacts Framework Extended Patterns
+# Contacts patterns
 
-Overflow reference for the `contacts-framework` skill. Contains advanced patterns that exceed the main skill file's scope.
+Longer examples for the `contacts-framework` skill ([../SKILL.md](../SKILL.md)).
 
-## Contents
+## SwiftUI integration
 
-- [Contacts SwiftUI Integration](#contacts-swiftui-integration)
-- [Multi-Select Contact Picker](#multi-select-contact-picker)
-- [Search and Filtering](#search-and-filtering)
-- [vCard Import and Export](#vcard-import-and-export)
-- [Contact Groups](#contact-groups)
-- [Change Notifications and Swift Boundaries](#change-notifications-and-swift-boundaries)
-
-## Contacts SwiftUI Integration
-
-### Contact Manager with `@Observable`
+### An observable address-book model
 
 ```swift
 @preconcurrency import Contacts
-import ContactsUI
-import SwiftUI
-import UIKit
+import Observation
 
 @Observable
 @MainActor
-final class ContactManager {
-    let store = CNContactStore()
-
-    var contacts: [CNContact] = []
-    var canAccessContacts = false
-    var hasLimitedAccess = false
-    var authorizationStatus: CNAuthorizationStatus = .notDetermined
-
-    func checkAuthorization() {
-        updateAuthorization(CNContactStore.authorizationStatus(for: .contacts))
+final class AddressBookModel {
+    @ObservationIgnored let book = CNContactStore()
+    private(set) var people: [CNContact] = []
+    private(set) var canRead = false
+    private(set) var isLimited = false
+    private(set) var status = CNContactStore.authorizationStatus(for: .contacts)
+
+    func refreshStatus() {
+        status = CNContactStore.authorizationStatus(for: .contacts)
+        canRead = status == .authorized || status == .limited
+        isLimited = status == .limited
     }
 
-    func requestAccess() async throws {
-        _ = try await store.requestAccess(for: .contacts)
-        updateAuthorization(CNContactStore.authorizationStatus(for: .contacts))
+    func askForAccess() async {
+        _ = try? await book.requestAccess(for: .contacts)
+        refreshStatus()                     // the status is the source of truth, not the Bool
     }
 
-    func updateAuthorization(_ status: CNAuthorizationStatus) {
-        authorizationStatus = status
-        canAccessContacts = status == .authorized || status == .limited
-        hasLimitedAccess = status == .limited
-    }
-
-    func loadContacts() async throws {
-        guard canAccessContacts else { return }
-
+    func reload() async {
+        guard canRead else { return }
         let keys: [CNKeyDescriptor] = [
-            CNContactGivenNameKey as CNKeyDescriptor,
-            CNContactFamilyNameKey as CNKeyDescriptor,
+            CNContactFormatter.descriptorForRequiredKeys(for: .fullName),
             CNContactPhoneNumbersKey as CNKeyDescriptor,
             CNContactEmailAddressesKey as CNKeyDescriptor,
-            CNContactThumbnailImageDataKey as CNKeyDescriptor,
-            CNContactFormatter.descriptorForRequiredKeys(for: .fullName)
+            CNContactThumbnailImageDataKey as CNKeyDescriptor
         ]
-
-        contacts = try await Task.detached { [store] in
+        let loaded = try? await Task.detached { [book] in
             let request = CNContactFetchRequest(keysToFetch: keys)
-            request.sortOrder = .givenName
-            var results: [CNContact] = []
-            try store.enumerateContacts(with: request) { contact, _ in
-                results.append(contact)
-            }
-            return results
+            request.sortOrder = .userDefault
+            var rows: [CNContact] = []
+            try book.enumerateContacts(with: request) { person, _ in rows.append(person) }
+            return rows
         }.value
+        people = loaded ?? []
     }
 
-    func formattedName(for contact: CNContact) -> String {
-        CNContactFormatter.string(from: contact, style: .fullName)
-            ?? "\(contact.givenName) \(contact.familyName)"
+    func label(for person: CNContact) -> String {
+        CNContactFormatter.string(from: person, style: .fullName)
+            ?? "\(person.givenName) \(person.familyName)"
     }
 }
 ```
 
-### Contact List View
+### A list that respects limited access
 
 ```swift
-struct ContactListView: View {
-    @Environment(ContactManager.self) private var manager
+import ContactsUI
+import SwiftUI
+
+struct PeopleList: View {
+    @Environment(AddressBookModel.self) private var model
+    @State private var managingAccess = false
+    private let avatarSide: CGFloat = 40
 
     var body: some View {
-        NavigationStack {
-            Group {
-                if !manager.canAccessContacts {
-                    ContentUnavailableView {
-                        Label("Contacts Access", systemImage: "person.crop.circle.badge.questionmark")
-                    } description: {
-                        Text("Grant access to view your contacts.")
-                    } actions: {
-                        Button("Allow Access") {
-                            Task { try? await manager.requestAccess() }
+        Group {
+            if model.canRead {
+                List(model.people, id: \.identifier) { person in
+                    HStack {
+                        avatar(for: person)
+                        VStack(alignment: .leading) {
+                            Text(model.label(for: person))
+                            if let phone = person.phoneNumbers.first?.value.stringValue {
+                                Text(phone)
+                                    .font(.footnote)
+                                    .foregroundStyle(.tertiary)
+                            }
                         }
-                        .buttonStyle(.borderedProminent)
                     }
-                } else {
-                    contactList
-                    if manager.hasLimitedAccess {
-                        limitedAccessControls
+                }
+                .toolbar {
+                    if model.isLimited {
+                        Button("Share More Contacts") { managingAccess = true }
                     }
                 }
-            }
-            .navigationTitle("Contacts")
-            .task {
-                manager.checkAuthorization()
-                if manager.canAccessContacts {
-                    try? await manager.loadContacts()
+                .contactAccessPicker(isPresented: $managingAccess) { newlyShared in
+                    if !newlyShared.isEmpty { Task { await model.reload() } }
                 }
-            }
-        }
-    }
-
-    private var contactList: some View {
-        List(manager.contacts, id: \.identifier) { contact in
-            HStack {
-                contactAvatar(contact)
-                VStack(alignment: .leading) {
-                    Text(manager.formattedName(for: contact))
-                        .font(.body)
-                    if let phone = contact.phoneNumbers.first?.value.stringValue {
-                        Text(phone)
-                            .font(.caption)
-                            .foregroundStyle(.secondary)
-                    }
+            } else {
+                ContentUnavailableView {
+                    Label("Contacts Unavailable", systemImage: "person.crop.circle.badge.xmark")
+                } actions: {
+                    Button("Allow Access") { Task { await model.askForAccess() } }
+                        .buttonStyle(.borderedProminent)
                 }
             }
         }
+        .task {
+            model.refreshStatus()
+            await model.reload()
+        }
     }
 
     @ViewBuilder
-    private func contactAvatar(_ contact: CNContact) -> some View {
-        if let imageData = contact.thumbnailImageData,
-           let uiImage = UIImage(data: imageData) {
-            Image(uiImage: uiImage)
+    private func avatar(for person: CNContact) -> some View {
+        if let data = person.thumbnailImageData, let image = UIImage(data: data) {
+            Image(uiImage: image)
                 .resizable()
                 .scaledToFill()
-                .frame(width: 40, height: 40)
-                .clipShape(Circle())
+                .frame(width: avatarSide, height: avatarSide)
+                .clipShape(.circle)
         } else {
-            Image(systemName: "person.circle.fill")
+            Image(systemName: "person.circle")
                 .resizable()
-                .frame(width: 40, height: 40)
-                .foregroundStyle(.secondary)
-        }
-    }
-
-    @State private var isPresentingContactAccessPicker = false
-
-    private var limitedAccessControls: some View {
-        Button {
-            isPresentingContactAccessPicker = true
-        } label: {
-            Label("Add Contacts", systemImage: "person.crop.circle.badge.plus")
-        }
-        .contactAccessPicker(isPresented: $isPresentingContactAccessPicker) { identifiers in
-            guard !identifiers.isEmpty else { return }
-            Task { try? await manager.loadContacts() }
+                .frame(width: avatarSide, height: avatarSide)
+                .foregroundStyle(.gray)
         }
     }
 }
 ```
 
-Under `.limited`, the app can still use Contacts APIs, but only for contacts the
-user has granted or the app created. `ContactAccessButton` works well beside a
-search field; `contactAccessPicker(isPresented:completionHandler:)` presents a
-management sheet and returns identifiers for newly granted contacts only.
-
-## Multi-Select Contact Picker
+Two ways to widen limited access:
 
-### SwiftUI Wrapper for Multi-Selection
+- `ContactAccessButton` fits inline, for example next to a search field, and
+  offers matching contacts the app cannot see yet.
+- `contactAccessPicker(isPresented:completionHandler:)` opens a management
+  sheet; its completion receives only the identifiers granted in that
+  session.
 
-```swift
-import SwiftUI
-import ContactsUI
+## Selecting several contacts
 
-struct MultiContactPicker: UIViewControllerRepresentable {
-    @Binding var selectedContacts: [CNContact]
+Implementing the array variant of the delegate method switches the picker
+into multi-select mode:
 
-    func makeUIViewController(context: Context) -> CNContactPickerViewController {
-        let picker = CNContactPickerViewController()
-        picker.delegate = context.coordinator
-        return picker
-    }
-
-    func updateUIViewController(_ uiViewController: CNContactPickerViewController, context: Context) {}
-
-    func makeCoordinator() -> Coordinator {
-        Coordinator(self)
-    }
-
-    final class Coordinator: NSObject, CNContactPickerDelegate {
-        let parent: MultiContactPicker
-
-        init(_ parent: MultiContactPicker) {
-            self.parent = parent
-        }
-
-        func contactPicker(_ picker: CNContactPickerViewController, didSelect contacts: [CNContact]) {
-            parent.selectedContacts = contacts
-        }
+```swift
+final class GuestListCoordinator: NSObject, CNContactPickerDelegate {
+    var onChoose: ([CNContact]) -> Void = { _ in }
 
-        func contactPickerDidCancel(_ picker: CNContactPickerViewController) {}
+    func contactPicker(_ picker: CNContactPickerViewController, didSelect contacts: [CNContact]) {
+        onChoose(contacts)   // the array overload is what turns on multi-select
     }
 }
 ```
 
-### Email-Only Picker
-
-Configure the picker to only return email addresses.
+### Picking just an email address
 
 ```swift
-struct EmailPicker: UIViewControllerRepresentable {
-    @Binding var selectedEmail: String?
-
-    func makeUIViewController(context: Context) -> CNContactPickerViewController {
-        let picker = CNContactPickerViewController()
-        picker.delegate = context.coordinator
-        // Only show contacts with emails
-        picker.predicateForEnablingContact = NSPredicate(format: "emailAddresses.@count > 0")
-        // Show contact detail so user can pick a specific email
-        picker.predicateForSelectionOfProperty = NSPredicate(
-            format: "key == 'emailAddresses'"
-        )
-        picker.displayedPropertyKeys = [CNContactEmailAddressesKey]
-        return picker
-    }
-
-    func updateUIViewController(_ uiViewController: CNContactPickerViewController, context: Context) {}
-
-    func makeCoordinator() -> Coordinator {
-        Coordinator(self)
-    }
-
-    final class Coordinator: NSObject, CNContactPickerDelegate {
-        let parent: EmailPicker
+@MainActor
+func makeEmailPicker(delegate: CNContactPickerDelegate) -> CNContactPickerViewController {
+    let picker = CNContactPickerViewController()
+    picker.delegate = delegate
+    let hasEmail = NSPredicate(format: "emailAddresses.@count >= 1")
+    let emailRowOnly = NSPredicate(format: "key == %@", CNContactEmailAddressesKey)
+    picker.predicateForEnablingContact = hasEmail
+    picker.predicateForSelectionOfProperty = emailRowOnly
+    picker.displayedPropertyKeys = [CNContactEmailAddressesKey]
+    return picker
+}
 
-        init(_ parent: EmailPicker) {
-            self.parent = parent
-        }
+final class InviteCoordinator: NSObject, CNContactPickerDelegate {
+    var onAddress: (String) -> Void = { _ in }
 
-        func contactPicker(
-            _ picker: CNContactPickerViewController,
-            didSelect contactProperty: CNContactProperty
-        ) {
-            parent.selectedEmail = contactProperty.value as? String
-        }
+    func contactPicker(_ picker: CNContactPickerViewController,
+                       didSelect contactProperty: CNContactProperty) {
+        if let address = contactProperty.value as? String { onAddress(address) }
     }
 }
 ```
 
-## Search and Filtering
+## Searching
 
-### Predicate-Based Search
+### Built-in predicates
 
 ```swift
-// By name
-let namePredicate = CNContact.predicateForContacts(matchingName: "John")
-
-// By email address
-let emailPredicate = CNContact.predicateForContacts(matchingEmailAddress: "john@example.com")
-
-// By phone number
-let phonePredicate = CNContact.predicateForContacts(
-    matching: CNPhoneNumber(stringValue: "+1234567890")
-)
-
-// By identifiers (batch fetch)
-let idsPredicate = CNContact.predicateForContacts(withIdentifiers: ["id1", "id2", "id3"])
-
-// By group
-let groupPredicate = CNContact.predicateForContactsInGroup(withIdentifier: groupId)
-
-// By container
-let containerPredicate = CNContact.predicateForContactsInContainer(
-    withIdentifier: containerId
-)
+let named = CNContact.predicateForContacts(matchingName: "Lindqvist")
+let byEmail = CNContact.predicateForContacts(matchingEmailAddress: "ops@harbor.example")
+let byPhone = CNContact.predicateForContacts(matching: CNPhoneNumber(stringValue: "+1 415 555 0100"))
+let byIDs = CNContact.predicateForContacts(withIdentifiers: pinnedIDs)
+let inGroup = CNContact.predicateForContactsInGroup(withIdentifier: teamGroupID)
+let inContainer = CNContact.predicateForContactsInContainer(withIdentifier: book.defaultContainerIdentifier())
 ```
 
-### Custom Filtering After Fetch
+### Filtering in memory
 
-For complex filtering not supported by predicates, enumerate and filter in memory.
+When no predicate fits, enumerate with the needed key and filter yourself:
 
 ```swift
-func fetchContactsWithBirthday(in month: Int) throws -> [CNContact] {
-    let keys: [CNKeyDescriptor] = [
+func birthdaysThisMonth(in book: CNContactStore) throws -> [CNContact] {
+    let month = Calendar.current.component(.month, from: .now)
+    let request = CNContactFetchRequest(keysToFetch: [
         CNContactGivenNameKey as CNKeyDescriptor,
-        CNContactFamilyNameKey as CNKeyDescriptor,
         CNContactBirthdayKey as CNKeyDescriptor
-    ]
-    let request = CNContactFetchRequest(keysToFetch: keys)
-
-    var contacts: [CNContact] = []
-    try store.enumerateContacts(with: request) { contact, _ in
-        if let birthday = contact.birthday, birthday.month == month {
-            contacts.append(contact)
-        }
+    ])
+    var matches: [CNContact] = []
+    try book.enumerateContacts(with: request) { person, _ in
+        if person.birthday?.month == month { matches.append(person) }
     }
-    return contacts
+    return matches
 }
 ```
 
-## vCard Import and Export
-
-### Exporting Contacts to vCard
+## vCard
 
 ```swift
-func exportToVCard(contacts: [CNContact]) throws -> Data {
-    return try CNContactVCardSerialization.data(with: contacts)
+func exportCards(_ people: [CNContact], to file: URL) throws {
+    let cards = try CNContactVCardSerialization.data(with: people)
+    try cards.write(to: file)
 }
 
-// Save to file
-func saveVCard(contacts: [CNContact], to url: URL) throws {
-    let data = try CNContactVCardSerialization.data(with: contacts)
-    try data.write(to: url)
+func importCards(from file: URL, into book: CNContactStore) throws {
+    let parsed = try CNContactVCardSerialization.contacts(with: Data(contentsOf: file))
+    let batch = CNSaveRequest()
+    for card in parsed {
+        if let copy = card.mutableCopy() as? CNMutableContact {
+            batch.add(copy, toContainerWithIdentifier: nil)
+        }
+    }
+    try book.execute(batch)
 }
 ```
 
-### Importing Contacts from vCard
+## Groups
 
 ```swift
-func importFromVCard(data: Data) throws -> [CNContact] {
-    return try CNContactVCardSerialization.contacts(with: data)
+let allGroups = try book.groups(matching: nil)
+if let crew = allGroups.first(where: { $0.name == "Sailing Crew" }) {
+    let members = try book.unifiedContacts(
+        matching: CNContact.predicateForContactsInGroup(withIdentifier: crew.identifier),
+        keysToFetch: [CNContactGivenNameKey as CNKeyDescriptor]
+    )
+    print(members.count)
 }
 
-// Save imported contacts to the store
-func importAndSave(data: Data) throws {
-    let contacts = try CNContactVCardSerialization.contacts(with: data)
-    let saveRequest = CNSaveRequest()
-
-    for contact in contacts {
-        guard let mutable = contact.mutableCopy() as? CNMutableContact else { continue }
-        saveRequest.add(mutable, toContainerWithIdentifier: nil)
-    }
+let club = CNMutableGroup()
+club.name = "Book Club"
+let makeGroup = CNSaveRequest()
+makeGroup.add(club, toContainerWithIdentifier: nil)
+try book.execute(makeGroup)
 
-    try store.execute(saveRequest)
-}
+let membership = CNSaveRequest()
+membership.addMember(newMember, to: club)
+membership.removeMember(formerMember, from: club)
+try book.execute(membership)
 ```
 
-## Contact Groups
+## Change notifications and what Swift can do
 
-### Fetching Groups
+In Swift, `CNContactStoreDidChange` is the tool: drop cached contacts and
+fetch again whatever the current authorization allows.
 
 ```swift
-func fetchGroups() throws -> [CNGroup] {
-    return try store.groups(matching: nil) // nil returns all groups
-}
-
-func fetchContactsInGroup(_ group: CNGroup) throws -> [CNContact] {
-    let predicate = CNContact.predicateForContactsInGroup(withIdentifier: group.identifier)
-    let keys: [CNKeyDescriptor] = [
-        CNContactGivenNameKey as CNKeyDescriptor,
-        CNContactFamilyNameKey as CNKeyDescriptor
-    ]
-    return try store.unifiedContacts(matching: predicate, keysToFetch: keys)
+func observeAddressBook(_ onChange: @escaping @Sendable () -> Void) -> NSObjectProtocol {
+    NotificationCenter.default.addObserver(forName: .CNContactStoreDidChange,
+                                           object: nil,
+                                           queue: .main) { _ in onChange() }
 }
 ```
 
-### Creating and Managing Groups
-
-```swift
-func createGroup(name: String) throws {
-    let group = CNMutableGroup()
-    group.name = name
-
-    let saveRequest = CNSaveRequest()
-    saveRequest.add(group, toContainerWithIdentifier: nil)
-    try store.execute(saveRequest)
-}
-
-func addContactToGroup(contact: CNContact, group: CNGroup) throws {
-    let saveRequest = CNSaveRequest()
-    saveRequest.addMember(contact, to: group)
-    try store.execute(saveRequest)
-}
+Keep the returned token and pass it to `removeObserver(_:)` when done.
 
-func removeContactFromGroup(contact: CNContact, group: CNGroup) throws {
-    let saveRequest = CNSaveRequest()
-    saveRequest.removeMember(contact, from: group)
-    try store.execute(saveRequest)
-}
-```
-
-## Change Notifications and Swift Boundaries
-
-For Swift-first apps, use `CNContactStoreDidChange` to invalidate caches and
-refetch the contacts your authorization status allows. Do not write Swift code
-that calls `store.enumerateChanges(matching:)`; that method does not exist.
-Apple's change-history fetch entry point is the Objective-C
-`enumeratorForChangeHistoryFetchRequest:error:` selector, while the Swift
-`enumerator(for:)` overlay is marked unavailable. If a product truly needs
-incremental history tokens, isolate that bridge in Objective-C and expose a
-small Swift wrapper; otherwise, refetch on change notifications.
-
-### Watching for Real-Time Changes
-
-```swift
-func observeChanges(handler: @escaping () -> Void) -> NSObjectProtocol {
-    NotificationCenter.default.addObserver(
-        forName: .CNContactStoreDidChange,
-        object: nil,
-        queue: .main
-    ) { _ in
-        handler()
-    }
-}
-```
+There is no `store.enumerateChanges(matching:)` method; code that calls it
+will not compile. Change history is exposed only through the Objective-C
+selector `enumeratorForChangeHistoryFetchRequest:error:`, which the SDK marks
+unavailable in Swift. If the app truly needs incremental history tokens,
+isolate an Objective-C bridge behind a small Swift wrapper. Otherwise,
+refetch when the notification arrives.