Closes #3602: Suppress ignored Claude notifications

CLI/cmux.swift

@@ -332,6 +332,7 @@ private struct ClaudeHookParsedInput {
     let rawObject: [String: Any]?
     let object: [String: Any]?
     let rawFallback: String?
+    let rawFallbackNotificationTypeValues: [String]
     let sessionId: String?
     let turnId: String?
     let cwd: String?
@@ -16696,6 +16697,16 @@ struct CMUXCLI {
 
         case "notification", "notify":
             telemetry.breadcrumb("claude-hook.notification")
+            let notificationTypes = Self.claudeNotificationTypes(parsedInput: parsedInput)
+            let suppressedNotificationTypes = Self.suppressedClaudeNotificationTypes(for: notificationTypes)
+            if !suppressedNotificationTypes.isEmpty {
+                telemetry.breadcrumb(
+                    "claude-hook.notification.suppressed",
+                    data: ["types": suppressedNotificationTypes.sorted().joined(separator: ",")]
+                )
+                print("OK")
+                return
+            }
             var summary = summarizeClaudeHookNotification(parsedInput: parsedInput)
 
             let mappedSession = parsedInput.sessionId.flatMap { try? sessionStore.lookup(sessionId: $0) }
@@ -17312,7 +17323,7 @@ struct CMUXCLI {
         guard !trimmed.isEmpty,
               let data = trimmed.data(using: .utf8),
               let json = try? JSONSerialization.jsonObject(with: data, options: []),
-              let object = json as? [String: Any] else {
+              let object = Self.claudeHookObject(fromJSONValue: json) else {
             let fallback = trimmed.isEmpty ? nil : truncate(
                 normalizedSingleLine(redactClaudeSensitiveSpans(trimmed)),
                 maxLength: 180
@@ -17321,6 +17332,7 @@ struct CMUXCLI {
                 rawObject: nil,
                 object: nil,
                 rawFallback: fallback,
+                rawFallbackNotificationTypeValues: Self.claudeNotificationTypeValues(inRawFallback: trimmed),
                 sessionId: nil,
                 turnId: nil,
                 cwd: nil,
@@ -17337,13 +17349,27 @@ struct CMUXCLI {
             rawObject: object,
             object: compactObject,
             rawFallback: nil,
+            rawFallbackNotificationTypeValues: [],
             sessionId: sessionId,
             turnId: turnId,
             cwd: cwd,
             transcriptPath: transcriptPath
         )
     }
 
+    private static func claudeHookObject(fromJSONValue value: Any) -> [String: Any]? {
+        if let object = value as? [String: Any] {
+            return object
+        }
+        guard let string = value as? String,
+              let data = string.trimmingCharacters(in: .whitespacesAndNewlines).data(using: .utf8),
+              let nested = try? JSONSerialization.jsonObject(with: data, options: []),
+              let object = nested as? [String: Any] else {
+            return nil
+        }
+        return object
+    }
+
     private func compactClaudeHookObject(_ object: [String: Any]) -> [String: Any] {
         var compact: [String: Any] = [:]
 
@@ -18722,6 +18748,109 @@ struct CMUXCLI {
         return ("Attention", "Claude needs your attention")
     }
 
+    private static let claudeIgnoredNotificationTypesDefaultsKey =
+        ClaudeNotificationTypeNormalization.ignoredTypesDefaultsKey
+    private static let claudeIgnoredNotificationTypesEnvKey =
+        ClaudeNotificationTypeNormalization.ignoredTypesEnvironmentKey
+
+    private static func suppressedClaudeNotificationTypes(for types: Set<String>) -> Set<String> {
+        let ignoredTypes = ignoredClaudeNotificationTypes()
+        guard !ignoredTypes.isEmpty, !types.isEmpty else {
+            return []
+        }
+        return ignoredTypes.intersection(types)
+    }
+
+    private static func ignoredClaudeNotificationTypes() -> Set<String> {
+        if let env = ProcessInfo.processInfo.environment[claudeIgnoredNotificationTypesEnvKey] {
+            return normalizedClaudeNotificationTypes(
+                env.components(separatedBy: CharacterSet(charactersIn: ", \n\t"))
+            )
+        }
+
+        if let stored = UserDefaults.standard.array(forKey: claudeIgnoredNotificationTypesDefaultsKey) as? [String] {
+            return normalizedClaudeNotificationTypes(stored)
+        }
+        if let stored = UserDefaults.standard.string(forKey: claudeIgnoredNotificationTypesDefaultsKey) {
+            return normalizedClaudeNotificationTypes(
+                stored.components(separatedBy: CharacterSet(charactersIn: ", \n\t"))
+            )
+        }
+        return []
+    }
+
+    private static func claudeNotificationTypes(parsedInput: ClaudeHookParsedInput) -> Set<String> {
+        var rawValues: [String] = []
+        if let object = parsedInput.rawObject ?? parsedInput.object {
+            rawValues.append(contentsOf: claudeNotificationTypeValues(inJSONValue: object))
+        }
+        rawValues.append(contentsOf: parsedInput.rawFallbackNotificationTypeValues)
+        return normalizedClaudeNotificationTypes(rawValues)
+    }
+
+    private enum ClaudeNotificationTypeExtractionScope {
+        case root
+        case notificationPayload
+    }
+
+    private static func claudeNotificationTypeValues(
+        inRawFallback fallback: String,
+        scope: ClaudeNotificationTypeExtractionScope = .root
+    ) -> [String] {
+        let trimmed = fallback.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty,
+              let data = trimmed.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data, options: []) else {
+            return []
+        }
+        return claudeNotificationTypeValues(inJSONValue: json, scope: scope)
+    }
+
+    private static func claudeNotificationTypeValues(
+        inJSONValue value: Any,
+        scope: ClaudeNotificationTypeExtractionScope = .root
+    ) -> [String] {
+        if let object = value as? [String: Any] {
+            var values = claudeNotificationTypeValues(in: object, scope: scope)
+            for key in ["notification", "data"] {
+                if let nested = object[key] {
+                    values.append(contentsOf: claudeNotificationTypeValues(
+                        inJSONValue: nested,
+                        scope: .notificationPayload
+                    ))
+                }
+            }
+            return values
+        }
+        if let values = value as? [Any] {
+            return values.flatMap { claudeNotificationTypeValues(inJSONValue: $0, scope: scope) }
+        }
+        if let string = value as? String {
+            return claudeNotificationTypeValues(inRawFallback: string, scope: scope)
+        }
+        return []
+    }
+
+    private static func claudeNotificationTypeValues(
+        in object: [String: Any],
+        scope: ClaudeNotificationTypeExtractionScope
+    ) -> [String] {
+        let keys: [String]
+        switch scope {
+        case .root:
+            keys = ["notification_type", "matcher", "reason"]
+        case .notificationPayload:
+            keys = ["notification_type", "matcher", "reason", "type", "kind"]
+        }
+        return keys.compactMap { key in
+            object[key] as? String
+        }
+    }
+
+    private static func normalizedClaudeNotificationTypes(_ values: [String]) -> Set<String> {
+        ClaudeNotificationTypeNormalization.normalizedSet(values)
+    }
+
     private func firstString(in object: [String: Any], keys: [String]) -> String? {
         for key in keys {
             guard let value = object[key] else { continue }

Sources/ClaudeNotificationTypeNormalization.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+enum ClaudeNotificationTypeNormalization {
+    static let ignoredTypesDefaultsKey = "claudeCodeIgnoredNotificationTypes"
+    static let ignoredTypesEnvironmentKey = "CMUX_CLAUDE_IGNORED_NOTIFICATION_TYPES"
+    static let defaultIgnoredTypes: [String] = []
+
+    static func normalized(_ raw: String) -> String? {
+        let collapsedWhitespace = raw
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .components(separatedBy: .whitespacesAndNewlines)
+            .filter { !$0.isEmpty }
+            .joined(separator: "_")
+        let normalized = collapsedWhitespace
+            .replacingOccurrences(of: "-", with: "_")
+            .lowercased()
+        return normalized.isEmpty ? nil : normalized
+    }
+
+    static func normalizedSet(_ values: [String]) -> Set<String> {
+        Set(values.compactMap(normalized))
+    }
+
+    static func normalizedUniqueList(_ values: [String]) -> [String] {
+        var seen = Set<String>()
+        return values.compactMap { raw in
+            guard let normalized = normalized(raw),
+                  seen.insert(normalized).inserted else {
+                return nil
+            }
+            return normalized
+        }
+    }
+}

Sources/CmuxSettingsJSONPathSupport.swift

@@ -70,6 +70,7 @@ extension CmuxSettingsFileStore {
         "notifications.sound",
         "notifications.customSoundFilePath",
         "notifications.command",
+        "notifications.ignoredClaudeNotificationTypes",
         "notifications.hooks",
         "notifications.hooksMode",
         "sidebar.hideAllDetails",

Sources/GhosttyTerminalView.swift

@@ -5515,6 +5515,10 @@ final class TerminalSurface: Identifiable, ObservableObject {
         if !claudeHooksEnabled {
             setManagedEnvironmentValue("CMUX_CLAUDE_HOOKS_DISABLED", "1")
         }
+        setManagedEnvironmentValue(
+            ClaudeNotificationTypeNormalization.ignoredTypesEnvironmentKey,
+            ClaudeCodeIntegrationSettings.ignoredNotificationTypes().joined(separator: ",")
+        )
         if let customClaudePath = ClaudeCodeIntegrationSettings.customClaudePath() {
             setManagedEnvironmentValue("CMUX_CUSTOM_CLAUDE_PATH", customClaudePath)
         }

Sources/KeyboardShortcutSettingsFileStore+Template.swift

@@ -92,6 +92,7 @@ extension CmuxSettingsFileStore {
                     "sound": NotificationSoundSettings.defaultValue,
                     "customSoundFilePath": NotificationSoundSettings.defaultCustomFilePath,
                     "command": NotificationSoundSettings.defaultCustomCommand,
+                    "ignoredClaudeNotificationTypes": ClaudeCodeIntegrationSettings.defaultIgnoredNotificationTypes,
                     "hooksMode": "append",
                     "hooks": [],
                 ],

Sources/KeyboardShortcutSettingsFileStore.swift

@@ -452,6 +452,13 @@ final class CmuxSettingsFileStore {
         if let raw = jsonString(section["command"]) {
             snapshot.managedUserDefaults[NotificationSoundSettings.customCommandKey] = .string(raw)
         }
+        if let values = jsonStringArray(section["ignoredClaudeNotificationTypes"]) {
+            snapshot.managedUserDefaults[ClaudeCodeIntegrationSettings.ignoredNotificationTypesKey] = .stringArray(
+                ClaudeCodeIntegrationSettings.normalizedIgnoredNotificationTypes(values)
+            )
+        } else if section.keys.contains("ignoredClaudeNotificationTypes") {
+            logInvalid("notifications.ignoredClaudeNotificationTypes", sourcePath: sourcePath)
+        }
     }
 
     private func parseTerminalSection(

Sources/cmuxApp.swift

@@ -4666,6 +4666,8 @@ enum ClaudeCodeIntegrationSettings {
     static let hooksEnabledKey = "claudeCodeHooksEnabled"
     static let defaultHooksEnabled = true
     static let customClaudePathKey = "claudeCodeCustomClaudePath"
+    static let ignoredNotificationTypesKey = ClaudeNotificationTypeNormalization.ignoredTypesDefaultsKey
+    static let defaultIgnoredNotificationTypes = ClaudeNotificationTypeNormalization.defaultIgnoredTypes
 
     static func hooksEnabled(defaults: UserDefaults = .standard) -> Bool {
         if defaults.object(forKey: hooksEnabledKey) == nil {
@@ -4679,6 +4681,17 @@ enum ClaudeCodeIntegrationSettings {
             .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
         return value.isEmpty ? nil : value
     }
+
+    static func ignoredNotificationTypes(defaults: UserDefaults = .standard) -> [String] {
+        guard let stored = defaults.array(forKey: ignoredNotificationTypesKey) as? [String] else {
+            return defaultIgnoredNotificationTypes
+        }
+        return normalizedIgnoredNotificationTypes(stored)
+    }
+
+    static func normalizedIgnoredNotificationTypes(_ values: [String]) -> [String] {
+        ClaudeNotificationTypeNormalization.normalizedUniqueList(values)
+    }
 }
 
 enum CursorIntegrationSettings {

cmux.xcodeproj/project.pbxproj

@@ -49,6 +49,8 @@
 		C0DEF0A30000000000000001 /* SidebarPortDisplayText.swift in Sources */ = {isa = PBXBuildFile; fileRef = C0DEF0A30000000000000002 /* SidebarPortDisplayText.swift */; };
 		C0DEF0B10000000000000001 /* JSONCParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = C0DEF0B10000000000000002 /* JSONCParser.swift */; };
 		C0DEF0B10000000000000003 /* JSONCParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = C0DEF0B10000000000000002 /* JSONCParser.swift */; };
+		3C0EFC65E21A473783BA8A71 /* ClaudeNotificationTypeNormalization.swift in Sources */ = {isa = PBXBuildFile; fileRef = D0265CE28BC54BD683AC48A8 /* ClaudeNotificationTypeNormalization.swift */; };
+		49F3FB1408664E65A47CF04F /* ClaudeNotificationTypeNormalization.swift in Sources */ = {isa = PBXBuildFile; fileRef = D0265CE28BC54BD683AC48A8 /* ClaudeNotificationTypeNormalization.swift */; };
 		C0DEF0B30000000000000001 /* KeyboardShortcutSettingsFileStoreMigrationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C0DEF0B30000000000000002 /* KeyboardShortcutSettingsFileStoreMigrationTests.swift */; };
 		E3337001E3337001E3337001 /* KeyboardShortcutSettingsFileStoreStartupTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = E3337002E3337002E3337002 /* KeyboardShortcutSettingsFileStoreStartupTests.swift */; };
 		C34670010000000000000001 /* AppDelegateRenameShortcutContextTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C34670010000000000000002 /* AppDelegateRenameShortcutContextTests.swift */; };
@@ -893,6 +895,7 @@
 		C34670030000000000000002 /* KeyboardShortcutContext.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = KeyboardShortcutContext.swift; sourceTree = "<group>"; };
 		C2B6A97D1F2E4C71A8B9D002 /* BrowserOmnibarPerformanceSupportTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BrowserOmnibarPerformanceSupportTests.swift; sourceTree = "<group>"; };
 		C0DEF0B10000000000000002 /* JSONCParser.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JSONCParser.swift; sourceTree = "<group>"; };
+		D0265CE28BC54BD683AC48A8 /* ClaudeNotificationTypeNormalization.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ClaudeNotificationTypeNormalization.swift; sourceTree = "<group>"; };
 		AA1B2C3D4E5F60719 /* BonsplitTabDragUITests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BonsplitTabDragUITests.swift; sourceTree = "<group>"; };
 		AA1B2C3D4E5F60721 /* RightSidebarChromeHeightUITests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RightSidebarChromeHeightUITests.swift; sourceTree = "<group>"; };
 		B09C007F42697761B5F1A2AB /* OmnibarAndToolsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OmnibarAndToolsTests.swift; sourceTree = "<group>"; };
@@ -1254,6 +1257,7 @@
 				A5F10010A1B2C3D4E5F60719 /* KeyboardShortcutSettingsFileStore.swift */,
 				A5F10012A1B2C3D4E5F60719 /* KeyboardShortcutSettingsFileStore+Template.swift */,
 				C0DEF0B10000000000000002 /* JSONCParser.swift */,
+				D0265CE28BC54BD683AC48A8 /* ClaudeNotificationTypeNormalization.swift */,
 					A50012F4 /* KeyboardLayout.swift */,
 					A5001013 /* TabManager.swift */,
 					C3677003000000000000002 /* TabManager+CompatibilityTypes.swift */,
@@ -1982,6 +1986,7 @@
 				A5F10011A1B2C3D4E5F60719 /* KeyboardShortcutSettingsFileStore.swift in Sources */,
 				A5F10013A1B2C3D4E5F60719 /* KeyboardShortcutSettingsFileStore+Template.swift in Sources */,
 				C0DEF0B10000000000000001 /* JSONCParser.swift in Sources */,
+				3C0EFC65E21A473783BA8A71 /* ClaudeNotificationTypeNormalization.swift in Sources */,
 				D35110010000000000000001 /* CmuxApplicationSupportDirectories.swift in Sources */,
 					A50012F5 /* KeyboardLayout.swift in Sources */,
 					A5001003 /* TabManager.swift in Sources */,
@@ -2218,6 +2223,7 @@
 				B9000064A1B2C3D4E5F60719 /* CMUXCLI+Events.swift in Sources */,
 				B9000054A1B2C3D4E5F60719 /* CMUXCLI+Process.swift in Sources */,
 				C0DEF0B10000000000000003 /* JSONCParser.swift in Sources */,
+				49F3FB1408664E65A47CF04F /* ClaudeNotificationTypeNormalization.swift in Sources */,
 				D35110010000000000000003 /* CmuxApplicationSupportDirectories.swift in Sources */,
 				B9000027A1B2C3D4E5F60719 /* RemoteRelayZshBootstrap.swift in Sources */,
 			);

cmuxTests/KeyboardShortcutSettingsFileStoreStartupTests.swift

@@ -200,6 +200,61 @@ final class KeyboardShortcutSettingsFileStoreStartupTests: XCTestCase {
         XCTAssertEqual(dockTileNotificationCount, 0)
     }
 
+    func testSettingsFileStoreAppliesIgnoredClaudeNotificationTypes() throws {
+        let defaults = UserDefaults.standard
+        let key = ClaudeCodeIntegrationSettings.ignoredNotificationTypesKey
+        let previousValue = defaults.object(forKey: key)
+        let previousBackups = defaults.data(forKey: settingsFileBackupsDefaultsKey)
+        let previousImportedDefaults = defaults.data(forKey: importedManagedDefaultsKey)
+        defer {
+            if let previousValue {
+                defaults.set(previousValue, forKey: key)
+            } else {
+                defaults.removeObject(forKey: key)
+            }
+            if let previousBackups {
+                defaults.set(previousBackups, forKey: settingsFileBackupsDefaultsKey)
+            } else {
+                defaults.removeObject(forKey: settingsFileBackupsDefaultsKey)
+            }
+            if let previousImportedDefaults {
+                defaults.set(previousImportedDefaults, forKey: importedManagedDefaultsKey)
+            } else {
+                defaults.removeObject(forKey: importedManagedDefaultsKey)
+            }
+        }
+
+        defaults.removeObject(forKey: key)
+        defaults.removeObject(forKey: settingsFileBackupsDefaultsKey)
+        defaults.removeObject(forKey: importedManagedDefaultsKey)
+
+        let directoryURL = try makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: directoryURL) }
+
+        let settingsURL = directoryURL.appendingPathComponent("settings.json", isDirectory: false)
+        try writeSettingsFile(
+            """
+            {
+              "notifications": {
+                "ignoredClaudeNotificationTypes": ["idle_prompt", "idle-prompt", " permission_prompt ", ""]
+              }
+            }
+            """,
+            to: settingsURL
+        )
+
+        _ = KeyboardShortcutSettingsFileStore(
+            primaryPath: settingsURL.path,
+            fallbackPath: nil,
+            startWatching: false
+        )
+
+        XCTAssertEqual(
+            ClaudeCodeIntegrationSettings.ignoredNotificationTypes(defaults: defaults),
+            ["idle_prompt", "permission_prompt"]
+        )
+    }
+
     func testSidebarMatchTerminalBackgroundUserDefaultSurvivesSettingsFileReapply() throws {
         let defaults = UserDefaults.standard
         let key = SidebarMatchTerminalBackgroundSettings.userDefaultsKey