DeviceActivityMonitor - Callbacks not trigger

Bellow I created Manager to be easier for me to handle app limits, but for some reason It never reached callbacks function, I have permission for screen time, I added the capabilities for it also, I'm sure, I send correctly the appTokens, categoriesTokens ... and the time limit and it also reach ✅ Monitoring started for..., I don't know what to do anymore:

import SwiftUI
import DeviceActivity
import FamilyControls
import ManagedSettings

@MainActor
class AppUsageManager: DeviceActivityMonitor, ObservableObject {
    static let shared = AppUsageManager()

    private let deviceActivityCenter = DeviceActivityCenter()
    private var monitoringSelections: [DeviceActivityName: (selection: FamilyActivitySelection, timeLimit: DateComponents)] = [:]
    private var resetTimer: Timer?

    private override init() {
        super.init()
        print("🟢 AppUsageManager initialized.")
    }

    // MARK: - Public Methods

    /// Configures monitoring for a selection with a specific event name and time limit.
    func configureMonitoring(
        for selection: FamilyActivitySelection,
        timeLimitInMinutes: Int,
        activityName: String,
        eventName: String
    ) {
        let activityName = DeviceActivityName(activityName)
        let eventName = DeviceActivityEvent.Name(eventName)
        
        monitoringSelections[activityName] = (selection, DateComponents(minute: timeLimitInMinutes))
        setupMonitoring(for: activityName, with: eventName)
    }

    /// Stops monitoring for a specific event.
    func stopMonitoring(for activityName: String) {
        let activityName = DeviceActivityName(activityName)
        Task {
            print("🛑 Stopping monitoring for \(activityName.rawValue).")
            deviceActivityCenter.stopMonitoring([activityName])
            monitoringSelections.removeValue(forKey: activityName)
        }
    }

    /// Stops all monitoring.
    func stopAllMonitoring() {
        print("🛑 Stopping monitoring")
        deviceActivityCenter.stopMonitoring()
    }

    // MARK: - Private Methods

    /// Sets up monitoring for a specific event.
    private func setupMonitoring(
        for activityName: DeviceActivityName,
        with eventName: DeviceActivityEvent.Name
    ) {
        stopAllMonitoring()
        
        guard let (selection, timeLimit) = monitoringSelections[activityName] else {
            print("⚠️ No selection configured for \(activityName.rawValue).")
            return
        }

        print("🛠 Setting up monitoring for \(activityName.rawValue).")
        print("📋 Monitoring Details:")
        print("- Time Limit: \(timeLimit.minute ?? 0) minutes.")

        let warningThreshold = DateComponents(minute: 3)
        let timeZone = TimeZone.current
        
        let schedule = DeviceActivitySchedule(
            intervalStart: DateComponents(timeZone: timeZone, hour: 0, minute: 0, second: 0),
            intervalEnd: DateComponents(timeZone: timeZone, hour: 23, minute: 59, second: 59),
            repeats: true,
            warningTime: warningThreshold
        )

        let events: [DeviceActivityEvent.Name: DeviceActivityEvent] = [
            eventName: DeviceActivityEvent(
                applications: selection.applicationTokens,
                categories: selection.categoryTokens,
                webDomains: selection.webDomainTokens,
                threshold: timeLimit
            )
        ]

        do {
            try deviceActivityCenter.startMonitoring(
                activityName,
                during: schedule,
                events: events
            )
           
            print("✅ Monitoring started for \(activityName.rawValue) with time limit \(timeLimit.minute ?? 0) minutes.")
        } catch {
            print("❌ Failed to start monitoring \(activityName.rawValue): \(error.localizedDescription)")
        }
    }

    // MARK: - DeviceActivityMonitor Overrides
    
    
    override func intervalDidStart(for activity: DeviceActivityName) {
        print("🟢 Interval for \(activity.rawValue) started.")
    }
    
    override func intervalWillStartWarning(for activity: DeviceActivityName) {
        print("⚠️ Warning: \(activity.rawValue) is about to start.")
    }
    
    /// Handles warnings for approaching the time limit.
    override func eventWillReachThresholdWarning(
        _ event: DeviceActivityEvent.Name,
        activity: DeviceActivityName
    ) {
        super.eventWillReachThresholdWarning(event, activity: activity)
        print("⚠️ Warning: \(activity.rawValue) is about to reach its time limit.")
        print("⚠️ Event: \(event.rawValue)")
    }
    
    /// Handles when the time limit is reached.
    override func eventDidReachThreshold(
        _ event: DeviceActivityEvent.Name,
        activity: DeviceActivityName
    ) {
        super.eventDidReachThreshold(event, activity: activity)
        print("🟢 Limit reached.")
        
        Task { @MainActor in
            print("🕒 \(activity.rawValue) has reached its time limit.")
            print("🕒 Event: \(event.rawValue)")

            guard let (selection, _) = monitoringSelections[activity] else {
                print("⚠️ No selection configured for \(activity.rawValue).")
                return
            }

            blockApps(for: selection)
        }
    }

    // MARK: - Blocking Logic

    /// Blocks the selected apps/categories.
    private func blockApps(for selection: FamilyActivitySelection) {
        print("🔒 Blocking apps/categories for selection.")
        print("- Applications: \(selection.applicationTokens)")
        print("- Categories: \(selection.categoryTokens)")
        let store = ManagedSettingsStore()
        store.shield.applications = selection.applicationTokens
        store.shield.applicationCategories = .specific(selection.categoryTokens)
        print("🔒 Apps/categories blocked successfully.")
    }
}