ai-notify 0.5.2 → 0.7.0

package/README.ja.md

@@ -87,6 +87,28 @@ AI_NOTIFY_VOLUME=0.5              # この窓の音量（0.0〜2.0）
 AI_NOTIFY_TSUNDERE_LEVEL=0.8     # この窓のツンデレ既定値（0=デレ〜1=ツン）
 ```
 
+## 🔔 どの種類で通知するか
+
+すべての出来事に音とバナーが要るわけではありません。ai-notify は各イベントを（Claude Code の `notification_type`・サブエージェント判定で）**種類**に分類し、どの種類で通知するかを選べます：
+
+```sh
+ai-notify notify                       # 一覧を表示
+ai-notify notify done off              # ターン完了では鳴らさない
+ai-notify notify subagent-done on      # サブエージェント完了で鳴らす
+```
+
+| 種類 | いつ | 既定 |
+| ---- | ---- | ---- |
+| `input` | **あなたの入力**待ち（`idle_prompt`） | 🔔 ON |
+| `permission` | **許可**プロンプト | 🔔 ON |
+| `info` | 認証 / MCP elicitation（情報通知） | 🔕 OFF |
+| `done` | ターン**完了**（Stop） | 🔔 ON |
+| `subagent-done` | **サブエージェント**完了（SubagentStop） | 🔕 OFF |
+
+OFF の種類は完全に無音（音・バナー・読み上げ・ポップアップなし）。ただし待ち状態は正しく保たれます（無音化した `done` でもポップアップは消えます）。同じ切替はメニューバーの **通知する種類** にもあります。（`subagent-done` は SubagentStop フック配線のため一度 `ai-notify init` が必要）
+
+> 注意：Claude は「サブエージェントの実行を待っているだけ」では通知を出しません（`Notification` は**あなたが必要なとき**だけ発火）。つまり「入力待ち」と「サブエージェントで作業中」は別々の通知ではなく、上の種類が実際に区別できる単位です。
+
 ## 🎛️ ネイティブのメニューバー — ミュート・音量・声
 
 エージェントが走っているターミナルにはコマンドを打てないので、**メニューバー**から全部操作します：
@@ -124,7 +146,13 @@ ai-notify popup image ~/zundamon.png    # 好きなキャラ画像（PNG/JPG）
 ai-notify popup off
 ```
 
-全アプリ・全スペースの上に浮かび、`<ペイン名> は応答待ち！` を表示。複数同時もまとめて表示します。クリックで消えます。macOS 専用（メニューバーアプリの導入が必要）。
+全アプリ・全スペースの上に浮かびます。**待っているペインごとに1枚のカード**が右下に積み重なり、各カードはそのペインの **VOICEVOX のボイスのキャラ立ち絵**を表示します（ずんだもんの声のペインはずんだもん、春日部つむぎの声はつむぎ）。カードをクリックで個別に消せます。macOS 専用（メニューバーアプリの導入が必要）。
+
+```sh
+ai-notify popup portraits   # 各VOICEVOXキャラの公式立ち絵をキャッシュ（初回のみ・エンジン起動が必要）
+```
+
+ここの設定はすべてメニューバーからも操作できます：**応答待ちポップアップ** →「有効にする／待ち時間／無視ワード／ボイスの立ち絵を取得」。
 
 **出す条件を設定できます。** すべての「待ち」で割り込まれたくない人向け。サブエージェントの一瞬の待ちは黙ってほしいが、本当の「入力待ち」は気づきたい——を出し分けられます：
 

package/README.md

@@ -88,6 +88,28 @@ AI_NOTIFY_TSUNDERE_LEVEL=0.8      # this window's tsundere baseline (0=デレ
 AI_NOTIFY_VOLUME=0.5              # this window's volume (0.0–2.0)
 ```
 
+## 🔔 Which events alert
+
+Not every agent event deserves a sound and a banner. ai-notify classifies each one (using Claude Code's `notification_type` / sub-agent markers) into a **kind**, and you choose which kinds alert:
+
+```sh
+ai-notify notify                       # show the matrix
+ai-notify notify done off              # finished a turn → stay silent
+ai-notify notify subagent-done on      # a sub-agent finished → alert
+```
+
+| kind | when | default |
+| ---- | ---- | ------- |
+| `input` | Claude is waiting for **your input** (`idle_prompt`) | 🔔 on |
+| `permission` | a **permission** prompt | 🔔 on |
+| `info` | auth / MCP elicitation (informational) | 🔕 off |
+| `done` | a turn **finished** (Stop) | 🔔 on |
+| `subagent-done` | a **sub-agent** finished (SubagentStop) | 🔕 off |
+
+A disabled kind is fully silent — no sound, banner, voice, or popup — but still keeps the waiting state correct (a suppressed `done` still clears a popup). Same toggles live in the menu bar under **通知する種類**. (`subagent-done` needs `ai-notify init` once to wire the SubagentStop hook.)
+
+> Note: Claude does **not** emit a notification while merely waiting on a sub-agent to run — `Notification` fires only when *you* are needed. So "waiting for input" and "busy with a sub-agent" aren't separate notifications; the kinds above are what's actually distinguishable.
+
 ## 🎛️ Native menu bar app — mute, volume, and voices
 
 You can't type into the terminal that's running an agent, so drive everything from the **menu bar**:
@@ -125,7 +147,13 @@ ai-notify popup image ~/zundamon.png    # your own character (PNG/JPG); default
 ai-notify popup off
 ```
 
-It floats over every app and Space, shows `<pane name> は応答待ち！`, and lists multiple waiting panes at once. Click it to dismiss. macOS-only (needs the menu bar app installed).
+Each waiting pane gets **its own card** at the bottom-right (they stack), and the card shows the pane's **VOICEVOX voice character** — a pane speaking as ずんだもん shows ずんだもん, one as 春日部つむぎ shows つむぎ. Click a card to dismiss it. macOS-only (needs the menu bar app installed).
+
+```sh
+ai-notify popup portraits   # cache every VOICEVOX character's official portrait (run once; engine must be on)
+```
+
+Everything here is also in the menu bar: **応答待ちポップアップ** → enable, 待ち時間 (delay), 無視ワード (ignore), and ボイスの立ち絵を取得 (portraits).
 
 **Control when it pops up.** Not every wait deserves your attention — a quick sub-agent turnaround isn't worth interrupting you, but a real "needs your input" is. Two knobs:
 

package/menubar/AiNotifyMenuBar.swift

@@ -91,24 +91,38 @@ enum State {
         return max(0, v) * 1000
     }
     static var popupIgnoreWords: [String] {
-        guard let s = try? String(contentsOfFile: file("popup-ignore"), encoding: .utf8) else { return [] }
-        return s.lowercased().split(whereSeparator: { $0 == "," || $0 == "\n" })
+        popupIgnoreRaw.lowercased().split(whereSeparator: { $0 == "," || $0 == "\n" })
             .map { $0.trimmingCharacters(in: .whitespaces) }.filter { !$0.isEmpty }
     }
+    static var popupIgnoreRaw: String {
+        (try? String(contentsOfFile: file("popup-ignore"), encoding: .utf8))?
+            .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+    }
+    static var popupDelaySec: Int { Int((popupDelayMs / 1000).rounded()) }
 
-    // Panes currently waiting for input (most-recent first), each with a display
-    // name, the wait-start time, and the reason message. Name = spoken name,
-    // else recorded label, else tty. Handles both the old (number) and new
-    // ({ts,msg}) waiting.json value shapes.
-    static func waitingPanes() -> [(tty: String, name: String, ts: Double, msg: String)] {
-        func obj(_ name: String) -> [String: Any] {
-            (try? Data(contentsOf: URL(fileURLWithPath: file(name))))
-                .flatMap { try? JSONSerialization.jsonObject(with: $0) as? [String: Any] } ?? [:]
-        }
-        let waiting = obj("waiting.json")
+    static func json(_ name: String) -> [String: Any] {
+        (try? Data(contentsOf: URL(fileURLWithPath: file(name))))
+            .flatMap { try? JSONSerialization.jsonObject(with: $0) as? [String: Any] } ?? [:]
+    }
+
+    // The cached portrait file for a pane's VOICEVOX voice, if it has one and the
+    // portrait was synced (`ai-notify popup portraits`). nil => no voice portrait.
+    static func voicePortrait(_ tty: String) -> String? {
+        guard let pv = json("pane-voices.json")[tty] as? [String: Any],
+              (pv["tts"] as? String) == "voicevox",
+              let sp = pv["speaker"] as? NSNumber else { return nil }
+        let p = file("portraits/\(sp.intValue).png")
+        return FileManager.default.fileExists(atPath: p) ? p : nil
+    }
+
+    // Panes currently waiting for input (most-recent first): name, start time,
+    // reason message, and its voice's portrait path (if any). Handles both the
+    // old (number) and new ({ts,msg}) waiting.json value shapes.
+    static func waitingPanes() -> [(tty: String, name: String, ts: Double, msg: String, portrait: String?)] {
+        let waiting = json("waiting.json")
         if waiting.isEmpty { return [] }
-        let voices = obj("pane-voices.json")
-        let panes = obj("panes.json")
+        let voices = json("pane-voices.json")
+        let panes = json("panes.json")
         func tsmsg(_ v: Any) -> (Double, String) {
             if let n = v as? NSNumber { return (n.doubleValue, "") }
             if let d = v as? [String: Any] { return (((d["ts"] as? NSNumber)?.doubleValue) ?? 0, (d["msg"] as? String) ?? "") }
@@ -122,10 +136,20 @@ enum State {
                 let name = ((voices[item.tty] as? [String: Any])?["speakName"] as? String)
                     ?? ((panes[item.tty] as? [String: Any])?["label"] as? String)
                     ?? short
-                return (item.tty, name.isEmpty ? short : name, item.tm.0, item.tm.1)
+                return (item.tty, name.isEmpty ? short : name, item.tm.0, item.tm.1, voicePortrait(item.tty))
             }
     }
 
+    // Per-kind notification toggles (must mirror state.mjs defaults).
+    static func notifyKinds() -> [(key: String, label: String, on: Bool)] {
+        let defaults: [String: Bool] = ["input": true, "permission": true, "info": false, "done": true, "subagent-done": false]
+        let labels = ["input": "入力待ち", "permission": "許可待ち", "info": "その他の通知", "done": "完了", "subagent-done": "サブエージェント完了"]
+        let saved = json("notify-kinds.json")
+        return ["input", "permission", "info", "done", "subagent-done"].map { k in
+            (k, labels[k] ?? k, (saved[k] as? Bool) ?? defaults[k] ?? true)
+        }
+    }
+
     // Tsundere baseline level 0.0 (デレ) – 1.0 (ツン). Same file the CLI reads.
     static func setTsundereLevel(_ v: Double) {
         try? FileManager.default.createDirectory(atPath: dir(), withIntermediateDirectories: true)
@@ -151,17 +175,105 @@ enum State {
     }
 }
 
+// A card view that reliably dismisses on click even when its window isn't the
+// active app (a gesture recognizer on a non-key floating window is unreliable;
+// acceptsFirstMouse + mouseDown is not).
+final class ClickableCardView: NSView {
+    var onClick: () -> Void = {}
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
+    override func mouseDown(with event: NSEvent) { onClick() }
+}
+
+// One floating "応答待ち" card, built once and updated in place.
+final class PopupCard: NSObject {
+    let window: NSWindow
+    private let imageView = NSImageView()
+    private let face = NSTextField(labelWithString: "(｡･ω･｡)ﾉ")
+    private let label = NSTextField(wrappingLabelWithString: "")
+    var onClick: () -> Void = {}
+
+    override init() {
+        window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 300, height: 96),
+                          styleMask: [.borderless], backing: .buffered, defer: false)
+        super.init()
+        window.isOpaque = false
+        window.backgroundColor = .clear
+        window.level = .floating
+        window.hasShadow = true
+        window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
+        window.ignoresMouseEvents = false
+
+        let card = ClickableCardView(frame: NSRect(x: 0, y: 0, width: 300, height: 96))
+        card.onClick = { [weak self] in self?.onClick() }
+        card.wantsLayer = true
+        card.layer?.cornerRadius = 16
+        card.layer?.backgroundColor = NSColor(calibratedWhite: 0.10, alpha: 0.95).cgColor
+        card.layer?.borderWidth = 2
+        card.layer?.borderColor = NSColor.systemYellow.withAlphaComponent(0.9).cgColor
+
+        imageView.frame = NSRect(x: 12, y: 12, width: 72, height: 72)
+        imageView.imageScaling = .scaleProportionallyUpOrDown
+        imageView.isHidden = true
+        card.addSubview(imageView)
+
+        face.frame = NSRect(x: 8, y: 30, width: 80, height: 36)
+        face.alignment = .center
+        face.font = .systemFont(ofSize: 17, weight: .semibold)
+        face.textColor = .systemYellow
+        card.addSubview(face)
+
+        let badge = NSTextField(labelWithString: "🟡 応答待ち")
+        badge.frame = NSRect(x: 96, y: 56, width: 150, height: 22)
+        badge.font = .systemFont(ofSize: 13, weight: .bold)
+        badge.textColor = .systemYellow
+        badge.isBordered = false
+        badge.backgroundColor = .clear
+        card.addSubview(badge)
+
+        label.frame = NSRect(x: 96, y: 12, width: 196, height: 44)
+        label.font = .systemFont(ofSize: 15, weight: .semibold)
+        label.textColor = .white
+        label.maximumNumberOfLines = 2
+        label.isBordered = false
+        label.backgroundColor = .clear
+        card.addSubview(label)
+
+        // Visible close button (✕) at the top-right.
+        let close = NSButton(frame: NSRect(x: 272, y: 70, width: 20, height: 20))
+        close.title = "✕"
+        close.font = .systemFont(ofSize: 11, weight: .bold)
+        close.isBordered = false
+        close.contentTintColor = .secondaryLabelColor
+        close.setButtonType(.momentaryChange)
+        close.target = self
+        close.action = #selector(clicked)
+        card.addSubview(close)
+
+        window.contentView = card
+    }
+
+    @objc private func clicked() { onClick() }
+
+    func update(text: String, image: NSImage?) {
+        label.stringValue = text
+        if let img = image {
+            imageView.image = img
+            imageView.isHidden = false
+            face.isHidden = true
+        } else {
+            imageView.isHidden = true
+            face.isHidden = false
+        }
+    }
+}
+
 final class AppDelegate: NSObject, NSApplicationDelegate {
     private var statusItem: NSStatusItem!
     private var timer: Timer?
 
-    // The "waiting for input" character popup.
-    private var waitingWindow: NSWindow?
-    private var waitingImageView: NSImageView?
-    private var waitingFace: NSTextField?
-    private var waitingLabel: NSTextField?
-    private var waitingSig = ""        // current panes signature, to avoid needless redraws
-    private var waitingDismissedSig = "" // a signature the user clicked away; don't reshow it
+    // The "waiting for input" popup — one floating card per waiting pane.
+    private var waitingCards: [String: PopupCard] = [:] // keyed by tty
+    private var dismissedTtys: Set<String> = []          // clicked away; reshow on the next wait
 
     func applicationDidFinishLaunching(_ notification: Notification) {
         statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
@@ -230,12 +342,13 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         if e.type == .rightMouseUp { toggle() } else { showMenu() }
     }
 
-    // --- "Waiting for input" character popup ------------------------------
-    // Driven off the 1s timer: when popup is enabled and a pane is waiting, show
-    // an always-on-top window with a character + "<name> は応答待ち！". It hides
-    // itself the moment nothing is waiting (or the user clicks it away).
+    // --- "Waiting for input" popup (one card per waiting pane) ------------
+    // Driven off the 1s timer. Each waiting pane gets its own floating card,
+    // showing its name and — when the pane's voice is a VOICEVOX character —
+    // that character's portrait. Cards stack at the bottom-right and disappear
+    // the moment their pane stops waiting (or you click one away).
     private func updateWaitingPopup() {
-        var panes: [(tty: String, name: String, ts: Double, msg: String)] = []
+        var panes: [(tty: String, name: String, ts: Double, msg: String, portrait: String?)] = []
         if State.popupEnabled {
             let now = Date().timeIntervalSince1970 * 1000
             let delayMs = State.popupDelayMs
@@ -249,109 +362,56 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
                 return true
             }
         }
-        if panes.isEmpty {
-            waitingDismissedSig = "" // reset; the next wait shows again
-            hideWaitingPopup()
-            return
-        }
-        let names = panes.map { $0.name }
-        let sig = names.joined(separator: "\u{1}")
-        if sig == waitingDismissedSig { return } // user dismissed exactly this set
-        if sig != waitingSig { waitingSig = sig; refreshWaitingPopup(names: names) }
-        waitingWindow?.orderFront(nil)
-    }
-
-    private func refreshWaitingPopup(names: [String]) {
-        if waitingWindow == nil { buildWaitingWindow() }
-        guard let win = waitingWindow else { return }
-        let line = names.count == 1
-            ? "\(names[0]) は応答待ち！"
-            : "\(names.count)件 応答待ち：\(names.joined(separator: "、"))"
-        waitingLabel?.stringValue = line
-
-        // Custom character image, or a friendly default kaomoji.
-        if let p = State.popupImage, let img = NSImage(contentsOfFile: p) {
-            waitingImageView?.image = img
-            waitingImageView?.isHidden = false
-            waitingFace?.isHidden = true // the image stands in for the default face
-        } else {
-            waitingImageView?.isHidden = true
-            waitingFace?.isHidden = false
+        let activeTtys = Set(panes.map { $0.tty })
+        dismissedTtys.formIntersection(activeTtys) // a pane that re-enters waiting shows again
+
+        let visible = panes.filter { !dismissedTtys.contains($0.tty) }
+        let visibleTtys = Set(visible.map { $0.tty })
+        // Tear down cards for panes that are no longer shown.
+        for (tty, card) in waitingCards where !visibleTtys.contains(tty) {
+            card.window.orderOut(nil)
+            waitingCards.removeValue(forKey: tty)
         }
-
-        if let scr = NSScreen.main {
-            let m: CGFloat = 24
-            let f = win.frame
-            win.setFrameOrigin(NSPoint(x: scr.visibleFrame.maxX - f.width - m,
-                                       y: scr.visibleFrame.minY + m))
+        // NSScreen.main is nil for a background app with no focused window — fall
+        // back to the first screen so the cards always have somewhere to land.
+        guard let scr = NSScreen.main ?? NSScreen.screens.first else { return }
+        let margin: CGFloat = 24, gap: CGFloat = 12, h: CGFloat = 96, w: CGFloat = 300
+        for (i, p) in visible.prefix(6).enumerated() {
+            let card: PopupCard
+            if let existing = waitingCards[p.tty] {
+                card = existing
+            } else {
+                let c = PopupCard()
+                let tty = p.tty
+                c.onClick = { [weak self] in
+                    self?.dismissedTtys.insert(tty)
+                    self?.waitingCards[tty]?.window.orderOut(nil)
+                    self?.waitingCards.removeValue(forKey: tty)
+                }
+                waitingCards[p.tty] = c
+                card = c
+            }
+            // Image priority: the voice's portrait (head-cropped) > a global popup
+            // image > the default kaomoji (image == nil).
+            var img: NSImage?
+            if let pp = p.portrait { img = faceCrop(path: pp) }
+            else if let gp = State.popupImage { img = NSImage(contentsOfFile: gp) }
+            card.update(text: "\(p.name) は応答待ち！", image: img)
+            card.window.setFrameOrigin(NSPoint(x: scr.visibleFrame.maxX - w - margin,
+                                               y: scr.visibleFrame.minY + margin + CGFloat(i) * (h + gap)))
+            card.window.orderFront(nil)
         }
     }
 
-    private func hideWaitingPopup() {
-        guard let w = waitingWindow else { return }
-        w.orderOut(nil)
-        waitingSig = ""
-    }
-
-    @objc private func waitingClicked() {
-        waitingDismissedSig = waitingSig // don't reshow this exact set
-        hideWaitingPopup()
-    }
-
-    private func buildWaitingWindow() {
-        let w = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 300, height: 96),
-                         styleMask: [.borderless], backing: .buffered, defer: false)
-        w.isOpaque = false
-        w.backgroundColor = .clear
-        w.level = .floating
-        w.hasShadow = true
-        w.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
-        w.ignoresMouseEvents = false
-
-        let card = NSView(frame: NSRect(x: 0, y: 0, width: 300, height: 96))
-        card.wantsLayer = true
-        card.layer?.cornerRadius = 16
-        card.layer?.backgroundColor = NSColor(calibratedWhite: 0.10, alpha: 0.95).cgColor
-        card.layer?.borderWidth = 2
-        card.layer?.borderColor = NSColor.systemYellow.withAlphaComponent(0.9).cgColor
-
-        let iv = NSImageView(frame: NSRect(x: 12, y: 12, width: 72, height: 72))
-        iv.imageScaling = .scaleProportionallyUpOrDown
-        iv.isHidden = true
-        card.addSubview(iv)
-        waitingImageView = iv
-
-        // A friendly default "character" — a kaomoji — sits behind the image slot
-        // so there's always a face even without a custom image.
-        let face = NSTextField(labelWithString: "(｡･ω･｡)ﾉ")
-        face.frame = NSRect(x: 8, y: 30, width: 80, height: 36)
-        face.alignment = .center
-        face.font = .systemFont(ofSize: 17, weight: .semibold)
-        face.textColor = .systemYellow
-        card.addSubview(face, positioned: .below, relativeTo: iv)
-        waitingFace = face
-
-        let badge = NSTextField(labelWithString: "🟡 応答待ち")
-        badge.frame = NSRect(x: 96, y: 56, width: 196, height: 22)
-        badge.font = .systemFont(ofSize: 13, weight: .bold)
-        badge.textColor = .systemYellow
-        badge.backgroundColor = .clear
-        badge.isBordered = false
-        card.addSubview(badge)
-
-        let label = NSTextField(wrappingLabelWithString: "")
-        label.frame = NSRect(x: 96, y: 12, width: 196, height: 44)
-        label.font = .systemFont(ofSize: 15, weight: .semibold)
-        label.textColor = .white
-        label.maximumNumberOfLines = 2
-        label.backgroundColor = .clear
-        label.isBordered = false
-        card.addSubview(label)
-        waitingLabel = label
-
-        card.addGestureRecognizer(NSClickGestureRecognizer(target: self, action: #selector(waitingClicked)))
-        w.contentView = card
-        waitingWindow = w
+    // Crop a full-body VOICEVOX portrait down to the head (top-center) so it
+    // reads at card size. Heuristic fractions that fit the standard 立ち絵.
+    private func faceCrop(path: String) -> NSImage? {
+        guard let src = NSImage(contentsOfFile: path),
+              let cg = src.cgImage(forProposedRect: nil, context: nil, hints: nil) else { return nil }
+        let W = CGFloat(cg.width), H = CGFloat(cg.height)
+        let rect = CGRect(x: W * 0.18, y: H * 0.03, width: W * 0.64, height: H * 0.30)
+        guard let cropped = cg.cropping(to: rect) else { return src }
+        return NSImage(cgImage: cropped, size: NSSize(width: rect.width, height: rect.height))
     }
 
     private func toggle() { State.setMuted(!State.isMuted); render() }
@@ -372,6 +432,25 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     // loop swallows the keystrokes. So naming a pane opens a normal modal dialog
     // (NSAlert with a text field), which takes keyboard focus properly. Empty =>
     // clear (the pane falls back to its label / the speakLabel default).
+    // Edit the popup "ignore" reason-keywords from the menu (a modal text field,
+    // since menus can't host an editable field). Empty clears the filter.
+    @objc private func promptPopupIgnore() {
+        let alert = NSAlert()
+        alert.messageText = "無視ワード"
+        alert.informativeText = "待ち理由メッセージにこの語を含む通知はポップアップしません（カンマ区切り・空欄で解除）"
+        let field = NSTextField(frame: NSRect(x: 0, y: 0, width: 260, height: 24))
+        field.stringValue = State.popupIgnoreRaw
+        field.placeholderString = "例: subagent,task"
+        alert.accessoryView = field
+        alert.addButton(withTitle: "保存")
+        alert.addButton(withTitle: "キャンセル")
+        NSApp.activate(ignoringOtherApps: true)
+        alert.window.initialFirstResponder = field
+        guard alert.runModal() == .alertFirstButtonReturn else { return }
+        let v = field.stringValue.trimmingCharacters(in: .whitespacesAndNewlines)
+        State.cli(["popup", "ignore", v.isEmpty ? "clear" : v])
+    }
+
     @objc private func promptPaneName(_ sender: NSMenuItem) {
         guard let info = sender.representedObject as? [String], let tty = info.first else { return }
         let current = info.count > 1 ? info[1] : ""
@@ -592,13 +671,51 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         }
 
         menu.addItem(.separator())
-        // Waiting-for-input character popup: on/off (set the character image with
-        // `ai-notify popup image <path>`).
-        let popupItem = NSMenuItem(title: "応答待ちポップアップ", action: #selector(runItem(_:)), keyEquivalent: "")
-        popupItem.target = self
-        popupItem.representedObject = ["popup", "toggle"]
-        popupItem.state = State.popupEnabled ? .on : .off
-        menu.addItem(popupItem)
+        // Waiting-for-input popup: enable + when-to-show settings, all in a submenu.
+        let popupParent = NSMenuItem(title: "応答待ちポップアップ", action: nil, keyEquivalent: "")
+        let popupSub = NSMenu()
+        let onItem = NSMenuItem(title: "有効にする", action: #selector(runItem(_:)), keyEquivalent: "")
+        onItem.target = self
+        onItem.representedObject = ["popup", "toggle"]
+        onItem.state = State.popupEnabled ? .on : .off
+        popupSub.addItem(onItem)
+        popupSub.addItem(.separator())
+        // Threshold: only show after waiting this long.
+        popupSub.addItem(disabledHeader("出すまでの待ち時間"))
+        let curDelay = State.popupDelaySec
+        for (sec, title) in [(0, "即時"), (5, "5秒"), (10, "10秒"), (15, "15秒"), (30, "30秒"), (60, "60秒")] {
+            let it = NSMenuItem(title: title, action: #selector(runItem(_:)), keyEquivalent: "")
+            it.target = self
+            it.representedObject = ["popup", "delay", String(sec)]
+            it.state = (curDelay == sec) ? .on : .off
+            popupSub.addItem(it)
+        }
+        popupSub.addItem(.separator())
+        // Reason filter + portrait sync.
+        let ig = State.popupIgnoreRaw
+        let ignoreItem = NSMenuItem(title: ig.isEmpty ? "無視ワードを設定…" : "無視ワード: \(ig)", action: #selector(promptPopupIgnore), keyEquivalent: "")
+        ignoreItem.target = self
+        popupSub.addItem(ignoreItem)
+        let portItem = NSMenuItem(title: "ボイスの立ち絵を取得（VOICEVOX）", action: #selector(runItem(_:)), keyEquivalent: "")
+        portItem.target = self
+        portItem.representedObject = ["popup", "portraits"]
+        popupSub.addItem(portItem)
+        popupParent.submenu = popupSub
+        menu.addItem(popupParent)
+
+        // Which kinds of event actually alert (sound / banner / popup).
+        let notifyParent = NSMenuItem(title: "通知する種類", action: nil, keyEquivalent: "")
+        let notifySub = NSMenu()
+        notifySub.addItem(disabledHeader("チェック＝音・バナーを出す"))
+        for kind in State.notifyKinds() {
+            let it = NSMenuItem(title: kind.label, action: #selector(runItem(_:)), keyEquivalent: "")
+            it.target = self
+            it.representedObject = ["notify", kind.key, "toggle"]
+            it.state = kind.on ? .on : .off
+            notifySub.addItem(it)
+        }
+        notifyParent.submenu = notifySub
+        menu.addItem(notifyParent)
 
         menu.addItem(.separator())
         let quitItem = NSMenuItem(title: "ai-notify を終了", action: #selector(quit), keyEquivalent: "q")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-notify",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "description": "Desktop, sound, and spoken notifications for terminal AI coding agents (Claude Code, Codex, Gemini, ...) — with one mute switch that covers all of them, across every terminal.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -2,7 +2,7 @@
 // ai-notify — desktop/sound notifications for terminal AI coding agents.
 // One mute switch for all of them, across every terminal. No daemon.
 
-import { readFileSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { execSync, execFileSync } from 'node:child_process';
 import { providers, byId } from './providers/index.mjs';
 import { emit } from './notify.mjs';
@@ -41,8 +41,12 @@ import {
   setPopupDelay,
   getPopupIgnore,
   setPopupIgnore,
+  NOTIFY_KINDS,
+  getNotifyKinds,
+  setNotifyKind,
+  isNotifyKindEnabled,
 } from './state.mjs';
-import { resolve as resolvePath } from 'node:path';
+import { resolve as resolvePath, join as pathJoin } from 'node:path';
 
 // Single source of truth: read the version from package.json so `--version`
 // (and the Homebrew formula test that checks it) always matches the release.
@@ -598,6 +602,38 @@ const cmds = {
     log(`✓ ${bits.join('  ·  ')}`);
   },
 
+  // Per-kind notification toggles: which kinds of agent event actually alert
+  // (sound / banner / voice / popup). Lets you, e.g., keep input-waiting but
+  // silence "done", or turn on sub-agent completions.
+  //   notify [<kind> on|off|toggle]
+  notify() {
+    const KIND_LABELS = {
+      input: '入力待ち  (Claude is waiting for your input)',
+      permission: '許可待ち  (a permission prompt)',
+      info: 'その他  (auth / MCP elicitation — informational)',
+      done: '完了  (a turn finished)',
+      'subagent-done': 'サブエージェント完了  (a sub-agent finished)',
+    };
+    const [kind, action] = positionals;
+    if (kind) {
+      if (!NOTIFY_KINDS.includes(kind)) {
+        console.error(`unknown kind: ${kind}\n  kinds: ${NOTIFY_KINDS.join(', ')}`);
+        process.exit(1);
+      }
+      const cur = !!getNotifyKinds()[kind];
+      const on = action === 'toggle' ? !cur : action !== 'off';
+      setNotifyKind(kind, on);
+      if (kind === 'subagent-done' && on) {
+        log('subagent-done: ON — run `ai-notify init` once so the SubagentStop hook is wired.');
+      }
+      return log(`${kind}: ${on ? '🔔 ON (notify)' : '🔕 OFF (silent)'}`);
+    }
+    const k = getNotifyKinds();
+    log('Notify on these events:\n');
+    for (const key of NOTIFY_KINDS) log(`  ${k[key] ? '🔔' : '🔕'} ${key.padEnd(14)} ${KIND_LABELS[key]}`);
+    log('\nToggle:  ai-notify notify done off    ·    ai-notify notify subagent-done on');
+  },
+
   // The "waiting" character popup (menu bar app): an always-on-top window that
   // shows a character saying which pane is waiting for input. macOS-only effect.
   //   popup [on|off|toggle|image <path>|delay <sec>|ignore <kw,kw>|status]
@@ -625,6 +661,45 @@ const cmds = {
       setPopupDelay(Math.max(0, v));
       return log(v > 0 ? `popup delay → ${Math.max(0, v)}s (waits shorter than this are ignored)` : 'popup delay → 0s (immediate)');
     }
+    // Cache each VOICEVOX character's official portrait so the popup can show a
+    // pane in its own voice's character. Saved per style id: portraits/<id>.png.
+    if (sub === 'portraits') {
+      const url = readConfig().voicevox?.url || voicevox.DEFAULT_URL;
+      if (!voicevox.isAvailable(url)) {
+        console.error('VOICEVOX engine not running — start it, then: ai-notify popup portraits');
+        process.exit(1);
+      }
+      const dir = pathJoin(paths.stateDir(), 'portraits');
+      mkdirSync(dir, { recursive: true });
+      let speakers;
+      try {
+        speakers = JSON.parse(execSync(`curl -s -m 6 "${url}/speakers"`, { encoding: 'utf8', maxBuffer: 1 << 24 }));
+      } catch {
+        console.error('could not reach the VOICEVOX engine.');
+        process.exit(1);
+      }
+      let n = 0;
+      for (const sp of speakers) {
+        let info;
+        try {
+          const raw = execSync(`curl -s -m 8 "${url}/speaker_info?speaker_uuid=${sp.speaker_uuid}"`, {
+            encoding: 'utf8',
+            maxBuffer: 1 << 26,
+          });
+          info = JSON.parse(raw);
+        } catch {
+          continue;
+        }
+        if (!info.portrait) continue;
+        const buf = Buffer.from(info.portrait, 'base64');
+        for (const st of sp.styles || []) {
+          writeFileSync(pathJoin(dir, `${st.id}.png`), buf);
+          n++;
+        }
+      }
+      return log(`synced ${n} voice portrait(s) → ${dir}`);
+    }
+
     // Suppress the popup when the waiting reason contains any of these keywords.
     if (sub === 'ignore') {
       const kw = positionals.slice(1).join(' ').trim();
@@ -806,6 +881,8 @@ const cmds = {
     let event = opt('event', 'done');
     let cwd = '';
     let message = '';
+    let ntype = '';
+    let isSubagent = false;
 
     if (source === 'codex') {
       // Codex passes a single JSON argument.
@@ -820,16 +897,24 @@ const cmds = {
       const data = readStdinJson();
       cwd = data.cwd || '';
       message = data.message || '';
+      ntype = data.notification_type || ''; // idle_prompt | permission_prompt | ...
+      isSubagent = !!data.agent_id; // present => fired from inside a sub-agent
       // The Stop hook has no message, so "done" would only say "finished".
       // Pull the agent's last reply from the transcript so the notification
       // says WHAT was done.
-      if (!message && event === 'done' && data.transcript_path) {
+      if (!message && (event === 'done' || event === 'subagent-done') && data.transcript_path) {
         message = lastAssistantText(data.transcript_path);
       }
     }
 
+    // Classify the event into a kind and honor the per-kind notification toggle.
+    // A disabled kind still calls emit (to keep the waiting state correct), but
+    // silently. SubagentStop arrives as event "subagent-done" → emit as "done".
+    const kind = classifyKind(event, ntype, isSubagent);
+    const alert = isNotifyKindEnabled(kind);
     const label = deriveLabel(cwd);
-    emit({ provider: byId(source) ? source : 'default', event, label, message });
+    const emitEvent = event === 'subagent-done' ? 'done' : event;
+    emit({ provider: byId(source) ? source : 'default', event: emitEvent, label, message, alert });
   },
 
   version() { log(VERSION); },
@@ -840,6 +925,17 @@ function emitConfirm() {
   emit({ provider: 'default', event: 'done', label: 'ai-notify', message: readConfig().onMessage });
 }
 
+// Map a raw hook event + Claude's notification_type/agent_id to a notify "kind"
+// the user can toggle. See state.mjs NOTIFY_KINDS.
+function classifyKind(event, ntype, isSubagent) {
+  if (event === 'subagent-done' || (event === 'done' && isSubagent)) return 'subagent-done';
+  if (event === 'done') return 'done';
+  // waiting (Claude Notification): the type tells us *why*.
+  if (ntype === 'permission_prompt') return 'permission';
+  if (ntype === 'idle_prompt' || ntype === 'elicitation_dialog' || ntype === '') return 'input';
+  return 'info'; // auth_success, elicitation_complete/response, anything else
+}
+
 function printHelp() {
   log(`ai-notify ${VERSION} — notifications for terminal AI coding agents
 
@@ -854,7 +950,8 @@ Usage:
   ai-notify tsundere [on|off|level <0-1>|test|status]   tsundere persona (ツン⇄デレ by urgency)
   ai-notify voice-prosody [speed|pitch|intonation <v>|reset]  VOICEVOX read-out tuning
   ai-notify menubar [install|uninstall|status]       native menu bar bell (macOS)
-  ai-notify popup [on|off|image <p>|delay <s>|ignore <kw>]  "waiting for input" popup + when it shows (macOS)
+  ai-notify notify [<kind> on|off]                   which events alert: input|permission|info|done|subagent-done
+  ai-notify popup [on|off|image <p>|delay <s>|ignore <kw>|portraits]  per-pane "waiting" popup, in the pane's voice (macOS)
   ai-notify translate [on <lang>|off|test]           speak agent text in your language
   ai-notify doctor                                    check deps & wiring
   ai-notify config [init]                             print (or write) config

package/src/notify.mjs

@@ -145,7 +145,12 @@ const shortenForSpeech = (text, max = 40) => {
 };
 
 // Public entry. Called by the hook handler with already-parsed fields.
-export const emit = ({ provider = 'default', event = 'done', label = '', message = '' }) => {
+// `alert` (default true) gates whether this event actually makes noise — sound,
+// spoken read-out, banner, highlight, and the waiting popup. When false the call
+// still keeps the pane/waiting state correct (so a suppressed "done" still clears
+// a popup), it just stays silent. The hook decides `alert` from the per-kind
+// notification toggles.
+export const emit = ({ provider = 'default', event = 'done', label = '', message = '', alert = true }) => {
   const config = readConfig();
   const muted = isMuted();
   const p = config.providers[provider] || config.providers.default;
@@ -181,9 +186,10 @@ export const emit = ({ provider = 'default', event = 'done', label = '', message
   // pane's assigned name. Also remember the pane so the menu bar can list it.
   const tty = controllingTty();
   recordPane(tty, label);
-  // waiting -> yellow menu bar status (+ the popup); done clears it. Pass the
-  // reason text so the popup can filter by it (e.g. ignore sub-agent waits).
-  setPaneWaiting(tty, event === 'waiting', event === 'waiting' ? message || fromTemplate : '');
+  // waiting -> yellow menu bar status (+ the popup); done clears it. A suppressed
+  // (alert=false) waiting must NOT light up the popup, so only set it when alert.
+  // "done" always clears regardless of alert. Pass the reason text for filtering.
+  setPaneWaiting(tty, event === 'waiting' && alert, event === 'waiting' ? message || fromTemplate : '');
   const pane = readPaneSetting(tty);
 
   // Name this pane in the read-out, most-reliable identity first:
@@ -254,7 +260,7 @@ export const emit = ({ provider = 'default', event = 'done', label = '', message
     }
   }
 
-  if (!muted) {
+  if (alert && !muted) {
     playSound(soundName, outVol);
     if (config.speak && outVol > 0) {
       let spoken = false;
@@ -266,7 +272,7 @@ export const emit = ({ provider = 'default', event = 'done', label = '', message
     }
   }
 
-  if (!muted || config.bannerWhenMuted) {
+  if (alert && (!muted || config.bannerWhenMuted)) {
     const waiting = event === 'waiting';
     banner(
       waiting ? `⏳ ${label || 'input'}` : `✓ ${label || 'done'}`,
@@ -283,7 +289,7 @@ export const emit = ({ provider = 'default', event = 'done', label = '', message
   // Visual highlight of *this* terminal window so a waiting pane stands out
   // among many. Always best-effort, and applied even when muted (you still want
   // to see which window needs you during a meeting).
-  if (config.highlightWaiting) {
+  if (alert && config.highlightWaiting) {
     try {
       if (event === 'waiting') highlightWaiting(label, config.highlightColor);
       else if (event === 'done') clearHighlight();

package/src/providers/claude.mjs

@@ -44,13 +44,17 @@ const entry = (node, cliPath, event) => ({
   ],
 });
 
-const EVENTS = { Notification: 'waiting', Stop: 'done' };
+// SubagentStop lets the user (optionally) be alerted when a sub-agent finishes,
+// distinctly from the main turn's Stop. Off by default (see notify kinds), but
+// wired so the toggle works. Only the CORE events count toward "wired" status.
+const EVENTS = { Notification: 'waiting', Stop: 'done', SubagentStop: 'subagent-done' };
+const CORE_EVENTS = ['Notification', 'Stop'];
 
 export const status = () => {
   if (!detect()) return { installed: false, wired: false };
   const data = load();
   const hooks = data.hooks || {};
-  const wired = Object.keys(EVENTS).every((k) =>
+  const wired = CORE_EVENTS.every((k) =>
     (hooks[k] || []).some((g) => (g.hooks || []).some((h) => isOurs(h.command)))
   );
   return { installed: true, wired };

package/src/state.mjs

@@ -234,6 +234,24 @@ export const setPopupImage = (p) => {
   else rmSync(popupImagePath(), { force: true });
 };
 
+// Per-kind notification toggles — which kinds of agent event actually alert
+// (sound / banner / voice / popup). Lets you, e.g., keep "input waiting" but
+// silence "done", or enable "sub-agent done". Disabled kinds still update the
+// waiting state correctly (so a suppressed "done" still clears a popup).
+export const NOTIFY_KINDS = ['input', 'permission', 'info', 'done', 'subagent-done'];
+const NOTIFY_KIND_DEFAULTS = { input: true, permission: true, info: false, done: true, 'subagent-done': false };
+const notifyKindsPath = () => join(stateDir(), 'notify-kinds.json');
+export const getNotifyKinds = () => ({ ...NOTIFY_KIND_DEFAULTS, ...readJson(notifyKindsPath(), {}) });
+export const isNotifyKindEnabled = (kind) => {
+  const k = getNotifyKinds();
+  return kind in k ? !!k[kind] : true; // unknown kinds default to alerting
+};
+export const setNotifyKind = (kind, on) => {
+  const all = readJson(notifyKindsPath(), {});
+  all[kind] = !!on;
+  writeJson(notifyKindsPath(), all);
+};
+
 // Popup notify threshold: only show the popup once a pane has been waiting this
 // many seconds (0 = immediately) — so transient / sub-agent waits don't nag.
 const popupDelayPath = () => join(stateDir(), 'popup-delay');