ai-notify 0.1.0 → 0.2.0

package/README.md

@@ -2,18 +2,26 @@
 
 **Know the moment your terminal AI agent needs you** — a sound, a spoken read-out, and a desktop banner the instant Claude Code, Codex, or another agent finishes a turn or asks for input. One mute switch covers **all of them, across every terminal**. No daemon, no background process.
 
-Long-running agents leave you staring at a quiet terminal. `ai-notify` wires a tiny notification hook into each agent CLI you have installed, so you can look away and get pulled back exactly when there's something to do. And when you're in a meeting, **one tap silences every agent at once** — because they all read the same shared switch.
+![ai-notify demo](https://raw.githubusercontent.com/unoryota/ai-notify/main/assets/demo.gif)
 
 ```sh
 npm i -g ai-notify
 ai-notify init        # auto-detects your agents and wires them
 ```
 
-## Why
+## What makes it different
 
-- **Get notified even if you never set it up.** The point is to *add* notifications. Muting is just a bonus feature on top.
-- **All your agents, one switch.** Use only Claude Code? Only Codex? Both? Plus others? Same experience. The mute flag is shared, so flipping it once is global.
-- **Zero friction.** No daemon. Re-run `init` anytime — it only wires what's newly detected and never clobbers your existing config.
+Plenty of agents go quiet for minutes. ai-notify pulls you back at the right moment — and is built for **running many agents at once**:
+
+- 🎙️ **A different voice per terminal.** Give each pane its own spoken voice, so you know *which* window finished just by listening — `export AI_NOTIFY_VOICE=Eddy` (or a [VOICEVOX](#-voicevox-character-voices) character).
+- 🌐 **Read out in your language.** An agent's English reply or prompt is translated before it's spoken/shown (key-less, no cost) — great for non-English speakers.
+- 📝 **It tells you *what* was done.** The "done" notification summarizes the agent's last reply (from the transcript), not just "finished".
+- 🔕 **One switch mutes everything.** Every agent in every terminal reads the same flag — one tap silences them all for a meeting.
+- 🔔 **A real menu bar bell, built in.** `ai-notify menubar install` — no Hammerspoon/SwiftBar required.
+
+> ### 日本語
+> 複数のAIエージェント（Claude Code / Codex …）を**並列で動かすと、どのターミナルの通知か分からない**——を解決する通知ツール。
+> **ペインごとに声を変えられる**（VOICEVOXのキャラ声も）／**英語の出力を日本語に翻訳して読み上げ**／**完了通知に作業内容の要約**／**1タップで全部ミュート**（MTG用）／**メニューバーのベルも内蔵**。
 
 ## Supported agents
 
@@ -21,63 +29,90 @@ ai-notify init        # auto-detects your agents and wires them
 | ----- | ------ | -------------- |
 | Claude Code | ✅ | `Notification` + `Stop` hooks in `~/.claude/settings.json` |
 | Codex CLI | ✅ | `notify` in `~/.codex/config.toml` (`agent-turn-complete`) |
-| Gemini CLI | 🧪 detected, hook WIP | see [CONTRIBUTING](CONTRIBUTING.md) — PRs welcome |
+| Gemini CLI | 🧪 detected, hook WIP | PRs welcome |
 
-Adding another agent (aider, opencode, amp, ...) is a small PR: drop a file in `src/providers/`. See [CONTRIBUTING](CONTRIBUTING.md).
+Adding another agent (aider, opencode, amp, …) is a small PR: drop a file in `src/providers/`. See [CONTRIBUTING](CONTRIBUTING.md).
 
-## Usage
+## Commands
 
 ```sh
 ai-notify init [--dry-run] [--only claude,codex]   # wire detected agents
-ai-notify uninstall [--only ...]                   # cleanly remove wiring
-ai-notify toggle | on | off | status              # the mute switch
+ai-notify toggle | on | off | status               # the mute switch
+ai-notify volume [0.0-2.0]                          # get/set output volume
+ai-notify voice [number|name|preview|default]      # pick the spoken voice
+ai-notify voicevox [on <id>|off|speakers|test]     # speak in VOICEVOX voices
+ai-notify translate [on <lang>|off|test]           # speak agent text in your language
+ai-notify menubar [install|uninstall|status]       # native menu bar app (macOS)
 ai-notify doctor                                   # check deps & wiring
-ai-notify config [init]                            # print / write config
+ai-notify uninstall                                # cleanly remove wiring
+```
+
+Per-window overrides — `export` these in a terminal *before* launching the agent:
+
+```sh
+AI_NOTIFY_LABEL=api               # name this window in the read-out / notification
+AI_NOTIFY_VOICE=Eddy              # this window's `say` voice
+AI_NOTIFY_VOICEVOX_SPEAKER=3      # this window's VOICEVOX speaker id
+AI_NOTIFY_VOLUME=0.5              # this window's volume (0.0–2.0)
+```
+
+## 🎛️ 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**:
+
+```sh
+ai-notify menubar install   # native menu bar app, starts at login
 ```
 
-> After `init`, restart any already-running Codex session so it re-reads its config.
+A monochrome waveform icon shows status by color (Adobe-style): plain when idle, a **yellow** dot when an agent is waiting for you, **red + slash** when muted.
 
-## Mute everything — without touching a busy terminal
+- **Left-click** → menu: a **volume slider**, the **voice list** (system + VOICEVOX), and **per-pane** controls — each open terminal gets its own voice *and* volume.
+- **Right-click** → instant mute toggle.
 
-You can't type a command into the terminal that's running an agent, and you want
-the current state visible at a glance. So don't drive this from a prompt — drive
-it from the **menu bar / a hotkey**, and show the state where you can always see it.
+No third-party app needed. Prefer something else? There are drop-in recipes for **Hammerspoon**, **SwiftBar/xbar**, **Raycast**, and the built-in **macOS Shortcuts** in [`recipes/`](recipes/). `ai-notify status --icon` prints just `🔔`/`🔕` to embed in tmux / your prompt / Claude Code's status line.
 
-> Toggling works mid-run: the flag is read the next time an agent fires a
-> notification, so flipping it instantly affects every running agent. A hotkey
-> runs in its own process — it never types into your busy terminal.
+> Toggling works mid-run: the flag is read the next time an agent fires, so flipping it instantly affects every running agent.
 
-**Recommended — always-visible menu bar toggle** (pick one):
+## 🎙️ VOICEVOX character voices
 
-- **Hammerspoon** — menu bar icon **and** a global hotkey (⌃⌥M) in ~20 lines. [recipes/hammerspoon](recipes/hammerspoon/).
-- **SwiftBar / xbar** — a 🔔/🔕 menu bar item you click to toggle. [recipes/swiftbar](recipes/swiftbar/).
-- **macOS Shortcuts** — `ai-notify toggle` pinned to the menu bar / a hotkey / iPhone. [recipes/macos-shortcut](recipes/macos-shortcut/).
-- **Raycast** — drop-in script command + hotkey. [recipes/raycast](recipes/raycast/).
+Speak your notifications in [VOICEVOX](https://voicevox.hiroshiba.jp/) character voices (free, local, offline). Run the VOICEVOX app, then:
 
-**Always-visible state** — `ai-notify status --icon` prints just `🔔`/`🔕`, ready to embed:
+```sh
+ai-notify voicevox speakers     # list available characters + ids
+ai-notify voicevox on 3         # use speaker 3 (e.g. ずんだもん)
+```
+
+Give every pane its own character with `AI_NOTIFY_VOICEVOX_SPEAKER`. If the engine isn't running, ai-notify silently falls back to the OS voice.
+*VOICEVOX characters have their own terms of use — credit them per [VOICEVOX's guidelines](https://voicevox.hiroshiba.jp/term/) if you share recordings.*
 
-- **Inside Claude Code's own status line** (the busy terminal shows its own state). [recipes/claude-statusline](recipes/claude-statusline/).
-- **tmux status bar / shell prompt / Starship.** [recipes/tmux](recipes/tmux/).
+## 🌐 Read out in your language
+
+```sh
+ai-notify translate on ja       # translate the agent's message, then speak it
+ai-notify translate test "I fixed the auth bug and added 3 tests."
+```
+
+Key-less and no cost (one HTTP request; falls back to a localized template offline). The desktop banner still shows the original text.
+
+## ⏳ Which window, and what it's asking
+
+Each notification is titled with the window label — `⏳ <label>` when an agent is waiting, `✓ <label>` when it's done — and the body says **what** (the translated prompt, or a summary of what was done). Set a short `AI_NOTIFY_LABEL` per pane and you can tell ten terminals apart at a glance.
 
 ## How it works
 
-`ai-notify` keeps a single mute flag and config under XDG paths:
+A single mute flag and config under XDG paths — no daemon, no coordination:
 
 ```
 ${XDG_STATE_HOME:-~/.local/state}/ai-notify/muted     # presence = muted
 ${XDG_CONFIG_HOME:-~/.config}/ai-notify/config.json   # sounds, voice, options
 ```
 
-Each agent's hook calls `ai-notify hook --source <agent>`, which reads that one flag at fire time. That's why every agent and every terminal stay in sync with no coordination.
-
-### Configuration
-
-`ai-notify config init` writes a config you can edit — per-agent sounds and voice, whether the desktop banner still shows while muted, and whether to speak a read-out. Sounds default to OS built-ins, so nothing is bundled.
+Each agent's hook calls `ai-notify hook --source <agent>`, which reads that one flag at fire time. `ai-notify config init` writes an editable config (per-agent sounds, voice, TTS backend, translation, templates).
 
 ## Platforms
 
-macOS is fully supported (`afplay` / `say` / `terminal-notifier` or `osascript`). Linux is best-effort (`paplay`/`canberra`, `notify-send`, `spd-say`/`espeak`). Windows plays a beep and speaks via PowerShell. Missing backends degrade silently — they never error.
+macOS is fully supported (`afplay` / `say` / VOICEVOX / `terminal-notifier` / native menu bar). Linux is best-effort (`paplay`/`canberra`, `notify-send`, `spd-say`/`espeak`, VOICEVOX). Windows plays a beep and speaks via PowerShell. Missing backends degrade silently — they never error.
 
 ## License
 
-[MIT](LICENSE).
+[MIT](LICENSE). Zero runtime dependencies.

package/menubar/AiNotifyMenuBar.swift

@@ -1,122 +1,251 @@
-// ai-notify menu bar agent — a tiny native NSStatusItem that mirrors the one
-// shared mute flag and toggles it on click. No third-party app required.
+// ai-notify menu bar agent — native NSStatusItem, no third-party app.
 //
-// Single source of truth: the same file the CLI and every wired agent read,
-//   ${XDG_STATE_HOME:-~/.local/state}/ai-notify/muted
-// Present = muted (🔕). Absent = on (🔔).
+// Shared state (same files the CLI and every agent read), under
+//   ${XDG_STATE_HOME:-~/.local/state}/ai-notify/ :
+//     muted   present = muted
+//     volume  0.0–2.0 (1.0 = normal)
+//     cli     launcher -> `ai-notify`
 //
-// Left click  : toggle mute/unmute (one tap)
-// Right click : menu (toggle / quit)
+// Left click  : menu — volume slider, voice list (flat), per-pane voices, quit
+// Right click : toggle mute (one tap)
 //
 // Builds with the system `swiftc` — no Xcode project, no dependencies.
 
 import Cocoa
 
-// MARK: - Shared state (must match src/state.mjs)
-
 enum State {
-    static func stateDir() -> String {
+    static func dir() -> String {
         let env = ProcessInfo.processInfo.environment
         let base = env["XDG_STATE_HOME"]
             ?? (NSHomeDirectory() as NSString).appendingPathComponent(".local/state")
         return (base as NSString).appendingPathComponent("ai-notify")
     }
+    static func file(_ name: String) -> String { (dir() as NSString).appendingPathComponent(name) }
 
-    static func flagPath() -> String {
-        (stateDir() as NSString).appendingPathComponent("muted")
+    static var isMuted: Bool { FileManager.default.fileExists(atPath: file("muted")) }
+    static func setMuted(_ m: Bool) {
+        let p = file("muted"), fm = FileManager.default
+        if m { try? fm.createDirectory(atPath: dir(), withIntermediateDirectories: true); fm.createFile(atPath: p, contents: Data()) }
+        else { try? fm.removeItem(atPath: p) }
     }
 
-    static var isMuted: Bool {
-        FileManager.default.fileExists(atPath: flagPath())
+    static var volume: Double {
+        guard let s = try? String(contentsOfFile: file("volume"), encoding: .utf8),
+              let v = Double(s.trimmingCharacters(in: .whitespacesAndNewlines)) else { return 1.0 }
+        return min(2, max(0, v))
     }
 
-    static func setMuted(_ muted: Bool) {
-        let path = flagPath()
-        let fm = FileManager.default
-        if muted {
-            try? fm.createDirectory(atPath: stateDir(), withIntermediateDirectories: true)
-            fm.createFile(atPath: path, contents: Data())
-        } else {
-            try? fm.removeItem(atPath: path)
+    // Any pane waiting for input -> the icon shows a yellow status.
+    static var hasWaiting: Bool {
+        guard let s = try? String(contentsOfFile: file("waiting.json"), encoding: .utf8) else { return false }
+        let t = s.trimmingCharacters(in: .whitespacesAndNewlines)
+        return !t.isEmpty && t != "{}" && t != "[]"
+    }
+    static func setVolume(_ v: Double) {
+        try? FileManager.default.createDirectory(atPath: dir(), withIntermediateDirectories: true)
+        try? String(format: "%.2f", v).write(toFile: file("volume"), atomically: true, encoding: .utf8)
+    }
+
+    @discardableResult
+    static func cli(_ args: [String], capture: Bool = false) -> String? {
+        let launcher = file("cli")
+        guard FileManager.default.isExecutableFile(atPath: launcher) else { return nil }
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: launcher)
+        task.arguments = args
+        let pipe = Pipe()
+        if capture { task.standardOutput = pipe; task.standardError = Pipe() }
+        do { try task.run() } catch { return nil }
+        if capture {
+            let data = pipe.fileHandleForReading.readDataToEndOfFile()
+            task.waitUntilExit()
+            return String(data: data, encoding: .utf8)
         }
+        return nil
     }
 }
 
-// MARK: - App
-
 final class AppDelegate: NSObject, NSApplicationDelegate {
     private var statusItem: NSStatusItem!
     private var timer: Timer?
 
     func applicationDidFinishLaunching(_ notification: Notification) {
         statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
-        if let button = statusItem.button {
-            button.action = #selector(handleClick(_:))
-            button.target = self
-            button.sendAction(on: [.leftMouseUp, .rightMouseUp])
+        if let b = statusItem.button {
+            b.action = #selector(handleClick(_:))
+            b.target = self
+            b.sendAction(on: [.leftMouseUp, .rightMouseUp])
         }
         render()
-        // Reconcile every second so external changes (CLI `ai-notify on/off`,
-        // another tool) are reflected without any IPC.
-        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
-            self?.render()
+        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in self?.render() }
+    }
+
+    // Black/white waveform silhouette (template, auto-adapting) when idle; a
+    // composite with a colored status dot when waiting (yellow) or muted (red +
+    // slash) — Adobe-style status-by-color.
+    private func statusImage(muted: Bool, waiting: Bool) -> NSImage {
+        let cfg = NSImage.SymbolConfiguration(pointSize: 15, weight: .regular)
+        let sym = (NSImage(systemSymbolName: "waveform", accessibilityDescription: "ai-notify")?
+            .withSymbolConfiguration(cfg)) ?? NSImage()
+
+        if !muted && !waiting {
+            sym.isTemplate = true // system tints to the menu bar color
+            return sym
+        }
+
+        let dark = (statusItem.button?.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua)
+        let fg: NSColor = muted ? .tertiaryLabelColor : (dark ? .white : .black)
+        let size = sym.size
+        let img = NSImage(size: size)
+        img.lockFocus()
+        let rect = NSRect(origin: .zero, size: size)
+        sym.draw(in: rect)
+        fg.set(); rect.fill(using: .sourceAtop) // tint the silhouette
+        // status dot, top-right
+        let d: CGFloat = 6
+        (muted ? NSColor.systemRed : NSColor.systemYellow).set()
+        NSBezierPath(ovalIn: NSRect(x: size.width - d, y: size.height - d, width: d, height: d)).fill()
+        if muted { // red slash
+            let s = NSBezierPath(); s.lineWidth = 1.6
+            s.move(to: NSPoint(x: 1.5, y: 1.5)); s.line(to: NSPoint(x: size.width - 1.5, y: size.height - 1.5))
+            NSColor.systemRed.set(); s.stroke()
         }
+        img.unlockFocus()
+        img.isTemplate = false
+        return img
     }
 
     private func render() {
-        statusItem.button?.title = State.isMuted ? "🔕" : "🔔"
+        guard let b = statusItem.button else { return }
+        b.title = ""
+        b.image = statusImage(muted: State.isMuted, waiting: State.hasWaiting)
     }
 
     @objc private func handleClick(_ sender: Any?) {
-        guard let event = NSApp.currentEvent else { toggle(); return }
-        if event.type == .rightMouseUp {
-            showMenu()
-        } else {
-            toggle()
-        }
+        guard let e = NSApp.currentEvent else { showMenu(); return }
+        if e.type == .rightMouseUp { toggle() } else { showMenu() }
     }
 
-    private func toggle() {
-        let nowMuted = !State.isMuted
-        State.setMuted(nowMuted)
-        render()
-        if !nowMuted { chime() } // brief confirmation on un-mute
+    private func toggle() { State.setMuted(!State.isMuted); render() }
+    @objc private func quit() { NSApp.terminate(nil) }
+
+    @objc private func volumeChanged(_ s: NSSlider) { State.setVolume(s.doubleValue) }
+    @objc private func paneVolumeChanged(_ s: NSSlider) {
+        if let tty = s.identifier?.rawValue { State.cli(["volume-pane", tty, String(format: "%.2f", s.doubleValue)]) }
     }
 
-    @objc private func toggleFromMenu() { toggle() }
+    // A 🔊 + slider row. identifier == nil => global (live); otherwise a pane tty
+    // (applied on release to avoid a subprocess per drag tick).
+    private func sliderRow(value: Double, action: Selector, identifier: String?) -> NSMenuItem {
+        let row = NSView(frame: NSRect(x: 0, y: 0, width: 220, height: 26))
+        let icon = NSTextField(labelWithString: "🔊"); icon.frame = NSRect(x: 12, y: 4, width: 20, height: 18)
+        let slider = NSSlider(value: value, minValue: 0, maxValue: 2, target: self, action: action)
+        slider.frame = NSRect(x: 36, y: 3, width: 170, height: 20)
+        slider.isContinuous = (identifier == nil)
+        if let id = identifier { slider.identifier = NSUserInterfaceItemIdentifier(id) }
+        row.addSubview(icon); row.addSubview(slider)
+        let item = NSMenuItem(); item.view = row
+        return item
+    }
 
-    @objc private func quit() { NSApp.terminate(nil) }
+    // representedObject is the full CLI arg array to run.
+    @objc private func runItem(_ item: NSMenuItem) {
+        if let cmd = item.representedObject as? [String] { State.cli(cmd) }
+    }
+
+    private func disabledHeader(_ title: String) -> NSMenuItem {
+        let it = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        it.isEnabled = false
+        return it
+    }
 
     private func showMenu() {
-        let muted = State.isMuted
         let menu = NSMenu()
-        let toggleItem = NSMenuItem(
-            title: muted ? "通知をオンにする" : "ミュート",
-            action: #selector(toggleFromMenu), keyEquivalent: "")
-        toggleItem.target = self
-        menu.addItem(toggleItem)
+
+        // Global volume slider.
+        menu.addItem(sliderRow(value: State.volume, action: #selector(volumeChanged(_:)), identifier: nil))
+        menu.addItem(.separator())
+
+        // Parse menu-json once.
+        let json = (State.cli(["menu-json"], capture: true)?.data(using: .utf8))
+            .flatMap { try? JSONSerialization.jsonObject(with: $0) as? [String: Any] }
+        let voices = (json?["voices"] as? [[String: Any]]) ?? []
+        let panes = (json?["panes"] as? [[String: Any]]) ?? []
+
+        if voices.isEmpty {
+            menu.addItem(disabledHeader("(声の一覧を取得できません)"))
+        } else {
+            // Global voice list — flat, at the top level.
+            menu.addItem(disabledHeader("ボイス（全体）"))
+            addVoiceItems(voices, to: menu, paneTty: nil, currentPaneLabel: nil)
+        }
+
+        // Per-pane voices: one submenu per recently-active pane.
+        if !panes.isEmpty {
+            menu.addItem(.separator())
+            menu.addItem(disabledHeader("ペイン別"))
+            for p in panes {
+                guard let tty = p["tty"] as? String else { continue }
+                let label = p["label"] as? String ?? tty
+                let cur = p["current"] as? String
+                let item = NSMenuItem(title: cur != nil ? "\(label) — \(cur!)" : label, action: nil, keyEquivalent: "")
+                let sub = NSMenu()
+                // Per-pane volume.
+                let pv = (p["volume"] as? Double) ?? State.volume
+                sub.addItem(disabledHeader("音量"))
+                sub.addItem(sliderRow(value: pv, action: #selector(paneVolumeChanged(_:)), identifier: tty))
+                let volDef = NSMenuItem(title: "音量を全体に従う", action: #selector(runItem(_:)), keyEquivalent: "")
+                volDef.target = self; volDef.representedObject = ["volume-pane", tty, "clear"]
+                volDef.state = (p["volumeSet"] as? Bool ?? false) ? .off : .on
+                sub.addItem(volDef)
+                sub.addItem(.separator())
+                // Per-pane voice.
+                sub.addItem(disabledHeader("声"))
+                let def = NSMenuItem(title: "デフォルト（全体に従う）", action: #selector(runItem(_:)), keyEquivalent: "")
+                def.target = self; def.representedObject = ["voice-pane", tty, "clear"]; def.state = (cur == nil) ? .on : .off
+                sub.addItem(def)
+                addVoiceItems(voices, to: sub, paneTty: tty, currentPaneLabel: cur)
+                item.submenu = sub
+                menu.addItem(item)
+            }
+        }
+
         menu.addItem(.separator())
         let quitItem = NSMenuItem(title: "ai-notify を終了", action: #selector(quit), keyEquivalent: "q")
         quitItem.target = self
         menu.addItem(quitItem)
 
-        statusItem.menu = menu
-        statusItem.button?.performClick(nil)
-        statusItem.menu = nil // restore left-click-to-toggle
+        if let button = statusItem.button {
+            menu.popUp(positioning: nil, at: NSPoint(x: 0, y: button.bounds.height + 4), in: button)
+        }
     }
 
-    private func chime() {
-        let sound = "/System/Library/Sounds/Glass.aiff"
-        guard FileManager.default.fileExists(atPath: sound) else { return }
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: "/usr/bin/afplay")
-        task.arguments = ["-v", "2", sound]
-        try? task.run()
+    // Add the voice list to `menu`. paneTty == nil => sets the global voice;
+    // otherwise assigns the voice to that pane.
+    private func addVoiceItems(_ voices: [[String: Any]], to menu: NSMenu, paneTty: String?, currentPaneLabel: String?) {
+        var lastSection = ""
+        for v in voices {
+            let section = v["section"] as? String ?? ""
+            let label = v["label"] as? String ?? "?"
+            let kind = v["kind"] as? String ?? "say"
+            let ref = v["ref"] as? String ?? ""
+            if section != lastSection { menu.addItem(disabledHeader("— \(section) —")); lastSection = section }
+            let it = NSMenuItem(title: label, action: #selector(runItem(_:)), keyEquivalent: "")
+            it.target = self
+            if let tty = paneTty {
+                it.representedObject = ["voice-pane", tty, kind, ref]
+                it.state = (currentPaneLabel == label) ? .on : .off
+            } else {
+                it.representedObject = kind == "voicevox" ? ["voicevox", "on", ref] : ["voice", ref]
+                it.state = (v["currentGlobal"] as? Bool ?? false) ? .on : .off
+            }
+            menu.addItem(it)
+        }
     }
 }
 
 let app = NSApplication.shared
-app.setActivationPolicy(.accessory) // no Dock icon, menu bar only
+app.setActivationPolicy(.accessory)
 let delegate = AppDelegate()
 app.delegate = delegate
 app.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-notify",
-  "version": "0.1.0",
+  "version": "0.2.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": {