feat(agent): add actionable task notifications (#1322)

Author: batonogov

Pine/AccessibilityIdentifiers.swift

@@ -12,6 +12,9 @@ nonisolated enum AccessibilityID {
     static let agentHandoffReadOnlyContextToggle =
         "agentHandoffReadOnlyContextToggle"
     static let agentHandoffStatus = "agentHandoffStatus"
+    static let agentNotificationSettings = "agentNotificationSettings"
+    static let agentNotificationEnableButton = "agentNotificationEnableButton"
+    static let agentNotificationMainToggle = "agentNotificationMainToggle"
     static let generalFontSizeSlider = "generalFontSizeSlider"
     static let generalSettingsPane = "generalSettingsPane"
     static let keyBindingsSettingsPane = "keyBindingsSettingsPane"

Pine/Agent/AgentHandoffSettingsView.swift

@@ -6,11 +6,14 @@
 //
 
 import SwiftUI
+import AppKit
 
 @MainActor
 struct PineSettingsView: View {
     let lspSettings: LSPSettings
     let handoffSettings: AgentHandoffSettings
+    let notificationController: AgentNotificationController
+    let agentTasks: AgentTaskRegistry
     let shellSettings: ShellSettings
     let editorSettings: EditorSettings
     let terminalThemeSettings: TerminalThemeSettings
@@ -22,13 +25,17 @@ struct PineSettingsView: View {
     init(
         lspSettings: LSPSettings,
         handoffSettings: AgentHandoffSettings,
+        notificationController: AgentNotificationController,
+        agentTasks: AgentTaskRegistry,
         shellSettings: ShellSettings,
         editorSettings: EditorSettings,
         terminalThemeSettings: TerminalThemeSettings = .shared,
         quickTerminalSettings: QuickTerminalSettings = .shared
     ) {
         self.lspSettings = lspSettings
         self.handoffSettings = handoffSettings
+        self.notificationController = notificationController
+        self.agentTasks = agentTasks
         self.shellSettings = shellSettings
         self.editorSettings = editorSettings
         self.terminalThemeSettings = terminalThemeSettings
@@ -65,7 +72,11 @@ struct PineSettingsView: View {
                 }
                 .tag(SettingsPane.SettingsPaneID.languages)
 
-            AgentHandoffSettingsView(settings: handoffSettings)
+            AgentSettingsView(
+                handoffSettings: handoffSettings,
+                notificationController: notificationController,
+                agentTasks: agentTasks
+            )
                 .tabItem {
                     Label(
                         Strings.settingsAgentHandoffTab,
@@ -89,6 +100,203 @@ struct PineSettingsView: View {
     nonisolated static let selectedPaneKey = "settings.selectedPane"
 }
 
+@MainActor
+private struct AgentSettingsView: View {
+    let handoffSettings: AgentHandoffSettings
+    let notificationController: AgentNotificationController
+    let agentTasks: AgentTaskRegistry
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 22) {
+                AgentNotificationSettingsView(
+                    controller: notificationController,
+                    agentTasks: agentTasks
+                )
+                Divider()
+                AgentHandoffSettingsView(settings: handoffSettings)
+                    .frame(height: 380)
+            }
+            .padding(20)
+        }
+        .frame(width: 720, height: 500)
+    }
+}
+
+@MainActor
+private struct AgentNotificationSettingsView: View {
+    let controller: AgentNotificationController
+    let agentTasks: AgentTaskRegistry
+
+    private var agentOptions: [(String, String)] {
+        let values = agentTasks.tasks.map {
+            ($0.descriptor.typeIdentifier, $0.descriptor.agentType.displayName)
+        }
+        return Dictionary(values, uniquingKeysWith: { current, _ in current })
+            .sorted { $0.value.localizedStandardCompare($1.value) == .orderedAscending }
+    }
+
+    private var projectOptions: [(String, String)] {
+        let values = agentTasks.tasks.map {
+            ($0.project.canonicalProjectPath, URL(fileURLWithPath: $0.project.canonicalProjectPath).lastPathComponent)
+        }
+        return Dictionary(values, uniquingKeysWith: { current, _ in current })
+            .sorted { $0.value.localizedStandardCompare($1.value) == .orderedAscending }
+    }
+
+    private var taskOptions: [(UUID, String)] {
+        agentTasks.tasks
+            .filter { $0.lifecycle != .dismissed }
+            .map { task in
+                let fallback = task.descriptor.agentType.displayName
+                return (task.id, task.title ?? fallback)
+            }
+            .sorted { $0.1.localizedStandardCompare($1.1) == .orderedAscending }
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 14) {
+            Text(Strings.agentNotificationsSettingsTitle)
+                .font(.title2.weight(.semibold))
+            Text(Strings.agentNotificationsPermissionExplanation)
+                .font(.callout)
+                .foregroundStyle(.secondary)
+
+            permissionControl
+
+            GroupBox(Strings.agentNotificationsEvents) {
+                VStack(alignment: .leading, spacing: 10) {
+                    eventToggle(.waitingInput, Strings.agentNotificationsWaiting)
+                    eventToggle(.failed, Strings.agentNotificationsFailed)
+                    eventToggle(.completed, Strings.agentNotificationsCompleted)
+                    eventToggle(.processEnded, Strings.agentNotificationsProcessEnded)
+                }
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .padding(.vertical, 4)
+            }
+            .disabled(!controller.settings.isEnabled)
+
+            if !agentOptions.isEmpty {
+                preferenceGroup(
+                    Strings.agentNotificationsAgents,
+                    options: agentOptions,
+                    isEnabled: { !controller.settings.disabledAgentIDs.contains($0) },
+                    setEnabled: controller.settings.setAgent
+                )
+            }
+            if !projectOptions.isEmpty {
+                preferenceGroup(
+                    Strings.agentNotificationsProjects,
+                    options: projectOptions,
+                    isEnabled: { !controller.settings.disabledProjectPaths.contains($0) },
+                    setEnabled: controller.settings.setProject
+                )
+            }
+            if !taskOptions.isEmpty {
+                GroupBox(Strings.agentNotificationsTasks) {
+                    VStack(alignment: .leading, spacing: 8) {
+                        ForEach(taskOptions, id: \.0) { taskID, displayName in
+                            Toggle(
+                                displayName,
+                                isOn: Binding(
+                                    get: {
+                                        !controller.settings.mutedTaskIDs.contains(taskID)
+                                    },
+                                    set: {
+                                        controller.settings.setTask(taskID, enabled: $0)
+                                    }
+                                )
+                            )
+                        }
+                    }
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .padding(.vertical, 4)
+                }
+                .disabled(!controller.settings.isEnabled)
+            }
+
+            Text(Strings.agentNotificationsFocusHelp)
+                .font(.caption)
+                .foregroundStyle(.secondary)
+        }
+        .accessibilityIdentifier(AccessibilityID.agentNotificationSettings)
+        .task { await controller.refreshAuthorizationStatus() }
+    }
+
+    @ViewBuilder
+    private var permissionControl: some View {
+        switch controller.authorizationStatus {
+        case .notDetermined:
+            Button(Strings.agentNotificationsEnable) {
+                Task { await controller.requestAuthorization() }
+            }
+            .accessibilityIdentifier(AccessibilityID.agentNotificationEnableButton)
+        case .denied:
+            HStack {
+                Label(Strings.agentNotificationsDenied, systemImage: "bell.slash")
+                    .foregroundStyle(.secondary)
+                Spacer()
+                Button(Strings.agentNotificationsOpenSystemSettings) {
+                    guard let url = URL(string: "x-apple.systempreferences:com.apple.Notifications-Settings.extension") else { return }
+                    NSWorkspace.shared.open(url)
+                }
+            }
+        case .authorized:
+            Toggle(
+                Strings.agentNotificationsMainToggle,
+                isOn: Binding(
+                    get: { controller.settings.isEnabled },
+                    set: {
+                        if $0 {
+                            controller.settings.setEnabled(true)
+                        } else {
+                            controller.disable()
+                        }
+                    }
+                )
+            )
+            .accessibilityIdentifier(AccessibilityID.agentNotificationMainToggle)
+        }
+    }
+
+    private func eventToggle(
+        _ kind: AgentNotificationEventKind,
+        _ title: LocalizedStringKey
+    ) -> some View {
+        Toggle(
+            title,
+            isOn: Binding(
+                get: { controller.settings.enabledEvents.contains(kind) },
+                set: { controller.settings.setEvent(kind, enabled: $0) }
+            )
+        )
+    }
+
+    private func preferenceGroup(
+        _ title: LocalizedStringKey,
+        options: [(String, String)],
+        isEnabled: @escaping (String) -> Bool,
+        setEnabled: @escaping (String, Bool) -> Void
+    ) -> some View {
+        GroupBox(title) {
+            VStack(alignment: .leading, spacing: 8) {
+                ForEach(options, id: \.0) { identifier, displayName in
+                    Toggle(
+                        displayName,
+                        isOn: Binding(
+                            get: { isEnabled(identifier) },
+                            set: { setEnabled(identifier, $0) }
+                        )
+                    )
+                }
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.vertical, 4)
+        }
+        .disabled(!controller.settings.isEnabled)
+    }
+}
+
 /// Identifiers for the Settings scene panes (issue #337). The raw value is
 /// persisted so the last-selected pane is restored on reopen.
 enum SettingsPane {
@@ -169,7 +377,6 @@ struct AgentHandoffSettingsView: View {
             Spacer(minLength: 0)
         }
         .padding(20)
-        .frame(width: 720, height: 500)
     }
 
     private func handoffGuarantee(