ai-notify 0.1.1 → 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.1",
+  "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": {

package/src/cli.mjs

@@ -3,6 +3,7 @@
 // One mute switch for all of them, across every terminal. No daemon.
 
 import { readFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
 import { providers, byId } from './providers/index.mjs';
 import { emit } from './notify.mjs';
 import { deriveLabel, cliInvocation, isEphemeralInstall } from './util.mjs';
@@ -10,9 +11,23 @@ import { curatedVoices, resolveVoice, previewVoice } from './voices.mjs';
 import * as menubar from './menubar.mjs';
 import { translate } from './translate.mjs';
 import { diagnose as highlightDiagnose, clearHighlight } from './highlight.mjs';
-import { isMuted, setMuted, toggleMuted, readConfig, writeConfig, paths, DEFAULT_CONFIG } from './state.mjs';
-
-const VERSION = '0.1.1';
+import * as voicevox from './voicevox.mjs';
+import {
+  isMuted,
+  setMuted,
+  toggleMuted,
+  readConfig,
+  writeConfig,
+  paths,
+  DEFAULT_CONFIG,
+  readVolume,
+  setVolume,
+  readPanes,
+  readPaneSetting,
+  updatePaneSetting,
+} from './state.mjs';
+
+const VERSION = '0.2.0';
 
 const args = process.argv.slice(2);
 const cmd = args[0];
@@ -75,6 +90,26 @@ const lastAssistantText = (transcriptPath) => {
   return '';
 };
 
+// Terminals (ttys) currently running a wired agent — so all open panes can be
+// assigned a voice from the menu bar without first firing a notification.
+const livePanes = () => {
+  try {
+    const out = execSync('ps -Ao tty=,command=', { encoding: 'utf8', maxBuffer: 1 << 22 });
+    const ttys = new Set();
+    for (const line of out.split('\n')) {
+      const m = line.match(/^(\S+)\s+(.*)$/);
+      if (!m) continue;
+      const [, tty, cmd] = m;
+      if (tty === '??' || tty === '?') continue;
+      if (/ai-notify|menubar/.test(cmd)) continue; // skip our own hook/agent
+      if (/\bclaude\b|\bcodex\b|\bgemini\b/i.test(cmd)) ttys.add(`/dev/${tty}`);
+    }
+    return [...ttys];
+  } catch {
+    return [];
+  }
+};
+
 const cmds = {
   init() {
     const dryRun = !!opt('dry-run');
@@ -162,6 +197,7 @@ const cmds = {
 
     const setVoice = (name) => {
       config.voice = name; // '' = OS default
+      config.tts = 'say'; // choosing a system voice switches the backend off VOICEVOX
       // Global voice wins only if no per-provider override; clear them so the
       // single switch actually takes effect everywhere.
       for (const k of Object.keys(config.providers || {})) {
@@ -211,6 +247,152 @@ const cmds = {
     log('  Reset:    ai-notify voice default');
   },
 
+  // Speak in VOICEVOX character voices (local engine, free, offline).
+  voicevox() {
+    const sub = positionals[0] || 'status';
+    const config = readConfig();
+    const url = config.voicevox?.url || voicevox.DEFAULT_URL;
+
+    if (sub === 'speakers') {
+      const list = voicevox.listSpeakers(url);
+      if (!list.length) return log(`No speakers (is VOICEVOX running at ${url}?).`);
+      list.forEach((s) => log(`  ${String(s.id).padStart(3)}  ${s.name}`));
+      log(`\nUse one:  ai-notify voicevox on <id>`);
+      return;
+    }
+    if (sub === 'on') {
+      if (!voicevox.isAvailable(url)) {
+        console.error(`VOICEVOX engine not reachable at ${url}. Start the VOICEVOX app first.`);
+        process.exit(1);
+      }
+      const speaker = Number(positionals[1] || config.voicevox?.speaker || 3);
+      config.tts = 'voicevox';
+      config.voicevox = { ...(config.voicevox || {}), url, speaker };
+      writeConfig(config);
+      log(`✓ VOICEVOX on (speaker ${speaker}). Testing…`);
+      voicevox.speak('ボイスボックスで読み上げます。', speaker, url);
+      return;
+    }
+    if (sub === 'off') {
+      config.tts = 'say';
+      writeConfig(config);
+      return log('VOICEVOX off — using the OS voice.');
+    }
+    if (sub === 'test') {
+      const speaker = Number(positionals[1] || config.voicevox?.speaker || 3);
+      const ok = voicevox.speak('これはテスト読み上げです。完了しました。', speaker, url);
+      return log(ok ? `spoke with speaker ${speaker}` : `⚠ failed (is VOICEVOX running at ${url}?)`);
+    }
+    // status
+    log(`VOICEVOX: ${config.tts === 'voicevox' ? `on (speaker ${config.voicevox?.speaker})` : 'off'}`);
+    log(`  engine ${url}: ${voicevox.isAvailable(url) ? '✓ reachable' : '✗ not running'}`);
+    if (config.tts !== 'voicevox') log('\nEnable:  ai-notify voicevox on    (list voices: ai-notify voicevox speakers)');
+  },
+
+  // Output volume 0.0–2.0 (1.0 = normal). Written to a state file the menu bar
+  // slider also drives; $AI_NOTIFY_VOLUME overrides per window.
+  volume() {
+    const arg = positionals[0];
+    if (arg === undefined) {
+      const config = readConfig();
+      const v = readVolume();
+      return log(`volume: ${v != null ? v : typeof config.volume === 'number' ? config.volume : 1}`);
+    }
+    const n = setVolume(arg);
+    log(`🔊 volume → ${n}`);
+  },
+
+  // Assign a voice to a specific pane (by tty), from the menu bar.
+  //   voice-pane <tty> voicevox <id> | say <name> | clear
+  'voice-pane'() {
+    const [tty, kind, ref] = positionals;
+    if (!tty) {
+      console.error('usage: voice-pane <tty> voicevox <id> | say <name> | clear');
+      process.exit(1);
+    }
+    if (!kind || kind === 'clear') {
+      updatePaneSetting(tty, { tts: null, speaker: null, voice: null });
+      return log(`pane ${tty}: voice reset to default`);
+    }
+    if (kind === 'voicevox') updatePaneSetting(tty, { tts: 'voicevox', speaker: Number(ref), voice: null });
+    else if (kind === 'say') updatePaneSetting(tty, { tts: 'say', voice: ref, speaker: null });
+    else {
+      console.error(`unknown kind: ${kind}`);
+      process.exit(1);
+    }
+    log(`pane ${tty}: ${kind} ${ref}`);
+  },
+
+  // Set a specific pane's output volume (0.0–2.0), or `clear` to follow global.
+  //   volume-pane <tty> <0.0-2.0|clear>
+  'volume-pane'() {
+    const [tty, arg] = positionals;
+    if (!tty || arg === undefined) {
+      console.error('usage: volume-pane <tty> <0.0-2.0|clear>');
+      process.exit(1);
+    }
+    if (arg === 'clear') {
+      updatePaneSetting(tty, { volume: null });
+      return log(`pane ${tty}: volume reset to global`);
+    }
+    const v = Math.min(2, Math.max(0, Number(arg)));
+    updatePaneSetting(tty, { volume: v });
+    log(`pane ${tty}: volume ${v}`);
+  },
+
+  // Machine-readable state for the menu bar agent: mute, volume, the selectable
+  // voices, and the recently-active panes (for per-pane assignment). Not human.
+  'menu-json'() {
+    const config = readConfig();
+    const url = config.voicevox?.url || voicevox.DEFAULT_URL;
+    const chars = voicevox.isAvailable(url) ? voicevox.listCharacters(url) : [];
+    const idName = new Map(chars.map((c) => [c.id, c.name]));
+    const voices = [];
+    for (const c of chars)
+      voices.push({
+        section: 'VOICEVOX',
+        label: c.name,
+        kind: 'voicevox',
+        ref: String(c.id),
+        currentGlobal: config.tts === 'voicevox' && Number(config.voicevox?.speaker) === c.id,
+      });
+    for (const n of curatedVoices(10))
+      voices.push({
+        section: 'System',
+        label: n,
+        kind: 'say',
+        ref: n,
+        currentGlobal: config.tts !== 'voicevox' && config.voice === n,
+      });
+    const labelFor = (pv) => {
+      if (!pv) return null;
+      return pv.tts === 'voicevox' ? idName.get(Number(pv.speaker)) || `VOICEVOX ${pv.speaker}` : pv.voice || 'system';
+    };
+    // Panes = live terminals currently running an agent (so they show up before
+    // they ever fire a notification) merged with previously-recorded ones.
+    const globalVol = readVolume() != null ? readVolume() : typeof config.volume === 'number' ? config.volume : 1;
+    const recorded = new Map(readPanes().map((p) => [p.tty, p.label]));
+    const ttys = new Set([...livePanes(), ...recorded.keys()]);
+    const panes = [...ttys].map((tty) => {
+      const s = readPaneSetting(tty);
+      return {
+        tty,
+        label: recorded.get(tty) || tty.replace('/dev/', ''),
+        current: labelFor(s.tts ? s : null),
+        volume: typeof s.volume === 'number' ? s.volume : globalVol,
+        volumeSet: typeof s.volume === 'number',
+      };
+    });
+    log(
+      JSON.stringify({
+        muted: isMuted(),
+        volume: readVolume() != null ? readVolume() : typeof config.volume === 'number' ? config.volume : 1,
+        voices,
+        panes,
+      })
+    );
+  },
+
   // Native menu bar bell (macOS). Self-contained — no Hammerspoon/SwiftBar.
   menubar() {
     const sub = positionals[0] || 'status';
@@ -222,7 +404,7 @@ const cmds = {
       const r = menubar.install();
       log(`  ✓ app:   ${r.app}`);
       log(`  ✓ agent: ${r.plist} (starts at login)`);
-      log('A 🔔 should now be in your menu bar. Left-click toggles, right-click for a menu.');
+      log('A 🔔 is now in your menu bar. Left-click for the menu (volume, voices), right-click to mute.');
       return;
     }
     if (sub === 'uninstall') {
@@ -340,7 +522,9 @@ Usage:
   ai-notify init [--dry-run] [--only claude,codex]   wire detected agents
   ai-notify uninstall [--only ...]                   remove wiring
   ai-notify toggle | on | off | status               control 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 character voices
   ai-notify menubar [install|uninstall|status]       native menu bar bell (macOS)
   ai-notify translate [on <lang>|off|test]           speak agent text in your language
   ai-notify doctor                                    check deps & wiring

package/src/menubar.mjs

@@ -10,8 +10,10 @@
 import { homedir, platform } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { existsSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, rmSync, chmodSync } from 'node:fs';
 import { execFileSync, spawnSync } from 'node:child_process';
+import { cliInvocation } from './util.mjs';
+import { stateDir } from './state.mjs';
 
 export const LABEL = 'com.ai-notify.menubar';
 
@@ -81,9 +83,21 @@ const unload = () => {
   return r;
 };
 
+// A tiny launcher the menu bar app shells out to for data/actions, so it works
+// regardless of PATH (embeds the resolved node + cli path).
+const writeCliWrapper = () => {
+  const { node, cliPath } = cliInvocation();
+  const p = join(stateDir(), 'cli');
+  mkdirSync(stateDir(), { recursive: true });
+  writeFileSync(p, `#!/bin/sh\nexec "${node}" "${cliPath}" "$@"\n`);
+  chmodSync(p, 0o755);
+  return p;
+};
+
 export const install = () => {
   if (!isMac()) throw new Error('the menu bar agent is macOS-only');
   if (!isBuilt()) build();
+  writeCliWrapper();
   writePlist();
   load();
   return { app: appPath(), plist: plistPath() };

package/src/notify.mjs

@@ -4,11 +4,15 @@
 // so a Linux box without `notify-send` (or a Mac without `terminal-notifier`)
 // never errors — it just does what it can.
 
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { isMuted, readConfig } from './state.mjs';
+import { spawn, execFileSync } from 'node:child_process';
+import { existsSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { isMuted, readConfig, readVolume, recordPane, readPaneSetting, setPaneWaiting } from './state.mjs';
+import { controllingTty } from './util.mjs';
 import { translate } from './translate.mjs';
 import { highlightWaiting, clearHighlight } from './highlight.mjs';
+import * as voicevox from './voicevox.mjs';
 
 const platform = process.platform; // 'darwin' | 'linux' | 'win32'
 
@@ -34,13 +38,14 @@ const resolveSound = (name) => {
   return name; // linux/win: treated as a freedesktop event id / ignored
 };
 
-const playSound = (name) => {
+const playSound = (name, vol = 1) => {
   const sound = resolveSound(name);
   if (platform === 'darwin') {
     if (sound && existsSync(sound)) {
       // play twice, a touch louder, so it is hard to miss
-      run('afplay', ['-v', '2', sound]);
-      run('afplay', ['-v', '2', sound]);
+      const v = String(2 * vol);
+      run('afplay', ['-v', v, sound]);
+      run('afplay', ['-v', v, sound]);
     }
   } else if (platform === 'linux') {
     if (which('paplay') && existsSync('/usr/share/sounds/freedesktop/stereo/complete.oga')) {
@@ -55,9 +60,23 @@ const playSound = (name) => {
   }
 };
 
-const speak = (text, voice) => {
+// `say` has no per-call volume, so when a non-default volume is set we render to
+// a file and play it through afplay at the requested level.
+const sayWithVolume = (text, voice, vol) => {
+  try {
+    const tmp = join(tmpdir(), `ai-notify-say-${process.pid}.aiff`);
+    execFileSync('say', voice ? ['-v', voice, '-o', tmp, text] : ['-o', tmp, text], { timeout: 30000 });
+    execFileSync('afplay', ['-v', String(vol), tmp], { timeout: 30000 });
+    rmSync(tmp, { force: true });
+  } catch {
+    /* ignore */
+  }
+};
+
+const speak = (text, voice, vol = 1) => {
   if (!text) return;
   if (platform === 'darwin') {
+    if (vol !== 1) return sayWithVolume(text, voice, vol);
     run('say', voice ? ['-v', voice, text] : [text]);
   } else if (platform === 'linux') {
     if (which('spd-say')) run('spd-say', [text]);
@@ -93,6 +112,18 @@ const banner = (title, subtitle, message, { activate, urgent } = {}) => {
   // win32: skipped (no dependency-free toast); sound/voice still fire.
 };
 
+// A short, speakable gist of a summary: the first sentence, capped at `max`
+// characters on a clause boundary — enough to tell which task, not a monologue.
+const shortenForSpeech = (text, max = 40) => {
+  let s = String(text).replace(/\s+/g, ' ').trim();
+  s = (s.split(/[。.!?！？\n]/)[0] || s).trim(); // first sentence
+  if (s.length <= max) return s.replace(/[、,\s]+$/, '');
+  const cut = s.slice(0, max);
+  const ten = cut.lastIndexOf('、'); // prefer a clause boundary
+  const sep = ten > max * 0.4 ? ten : cut.lastIndexOf(' ');
+  return (sep > 0 ? cut.slice(0, sep) : cut).replace(/[、,\s]+$/, '').trim();
+};
+
 // Public entry. Called by the hook handler with already-parsed fields.
 export const emit = ({ provider = 'default', event = 'done', label = '', message = '' }) => {
   const config = readConfig();
@@ -110,29 +141,61 @@ export const emit = ({ provider = 'default', event = 'done', label = '', message
   //                               (falling back to the template on failure).
   //   default                  -> speak the raw message as-is.
   // The desktop banner always shows the full original message visually.
-  // coreBody = WHAT happened, in the user's language, without the label.
-  let coreBody;
-  if (config.speakAgentMessage === false) {
-    coreBody = fromTemplate || fallback;
-  } else if (message) {
-    const translated = config.translateTo ? translate(message, config.translateTo) : message;
-    coreBody = translated || fromTemplate || fallback;
+  // Full text for the desktop banner — the translated summary / message. Length
+  // is fine here: a banner never gets cut off and you read it at a glance.
+  let fullBody;
+  if (message) {
+    fullBody = (config.translateTo ? translate(message, config.translateTo) : message) || fromTemplate || fallback;
   } else {
-    coreBody = fromTemplate || fallback;
+    fullBody = fromTemplate || fallback;
   }
-  // Prefix the window label for the spoken read-out so you can tell which of
-  // many terminals is asking (set a short per-window name with $AI_NOTIFY_LABEL).
-  const speakText = config.speakLabel !== false && label ? `${label}、${coreBody}` : coreBody;
+  // Spoken read-out — short enough not to get cut off, but enough to identify
+  // WHICH task: the window label + a short gist of what happened (the first
+  // clause of the summary). speakAgentMessage:true reads the whole thing.
+  let spokenBody;
+  if (!message) spokenBody = fromTemplate || fallback;
+  else if (config.speakAgentMessage) spokenBody = fullBody;
+  else spokenBody = shortenForSpeech(fullBody, config.speakMaxChars || 40);
+  // The task gist already tells you which pane; the label (often the working
+  // dir) is just slow filler. Prefix it only if explicitly enabled.
+  const speakText = config.speakLabel === true && label ? `${label}、${spokenBody}` : spokenBody;
+
+  // Per-pane voice: remember this pane (so the menu bar can list it) and apply
+  // any voice assigned to it. Precedence (most specific first):
+  //   $AI_NOTIFY_* env  — set in the pane's shell
+  //   this pane's pick  — assigned from the menu bar (keyed by tty)
+  //   provider / global — config defaults
+  const tty = controllingTty();
+  recordPane(tty, label);
+  setPaneWaiting(tty, event === 'waiting'); // waiting -> yellow menu bar status; done clears it
+  const pane = readPaneSetting(tty);
+  const tts = pane.tts || config.tts;
+  const voice = process.env.AI_NOTIFY_VOICE || pane.voice || p.voice || config.voice;
+  const speaker = process.env.AI_NOTIFY_VOICEVOX_SPEAKER || pane.speaker || config.voicevox?.speaker;
 
-  // Voice precedence (most specific first):
-  //   $AI_NOTIFY_VOICE  — set per terminal window/pane to give each its own voice
-  //   provider voice    — per agent (Claude vs Codex)
-  //   global voice      — the single `ai-notify voice` switch
-  const voice = process.env.AI_NOTIFY_VOICE || p.voice || config.voice;
+  // Volume (0–2): per-window env > this pane's slider > the global slider /
+  // `ai-notify volume` > config.
+  const envVol = parseFloat(process.env.AI_NOTIFY_VOLUME);
+  const fileVol = readVolume();
+  const vol = Number.isFinite(envVol)
+    ? Math.min(2, Math.max(0, envVol))
+    : typeof pane.volume === 'number'
+      ? pane.volume
+      : fileVol != null
+        ? fileVol
+        : typeof config.volume === 'number'
+          ? config.volume
+          : 1;
 
   if (!muted) {
-    playSound(soundName);
-    if (config.speak) speak(speakText, voice);
+    playSound(soundName, vol);
+    if (config.speak && vol > 0) {
+      let spoken = false;
+      if (tts === 'voicevox') {
+        spoken = voicevox.speak(speakText, speaker, config.voicevox?.url, vol);
+      }
+      if (!spoken) speak(speakText, voice, vol); // OS `say` (also the VOICEVOX fallback)
+    }
   }
 
   if (!muted || config.bannerWhenMuted) {
@@ -140,7 +203,7 @@ export const emit = ({ provider = 'default', event = 'done', label = '', message
     banner(
       waiting ? `⏳ ${label || 'input'}` : `✓ ${label || 'done'}`,
       waiting ? 'waiting for input' : '',
-      coreBody,
+      fullBody,
       {
         // Click the notification to bring the waiting app (e.g. the IDE) forward.
         activate: config.notifyActivate !== false ? process.env.__CFBundleIdentifier : undefined,

package/src/state.mjs

@@ -45,6 +45,90 @@ export const setMuted = (muted) => {
 
 export const toggleMuted = () => setMuted(!isMuted());
 
+// --- Volume ----------------------------------------------------------------
+// A single number (0.0–2.0) in a state file, written by the menu bar slider or
+// `ai-notify volume`, read at fire time — just like the mute flag.
+
+const volumeFlagPath = () => join(stateDir(), 'volume');
+
+export const readVolume = () => {
+  try {
+    const v = parseFloat(readFileSync(volumeFlagPath(), 'utf8'));
+    return Number.isFinite(v) ? Math.min(2, Math.max(0, v)) : null;
+  } catch {
+    return null;
+  }
+};
+
+export const setVolume = (v) => {
+  const n = Math.min(2, Math.max(0, Number(v)));
+  ensureDir(stateDir());
+  writeFileSync(volumeFlagPath(), String(n));
+  return n;
+};
+
+// --- Per-pane state --------------------------------------------------------
+// Recently-active terminal panes (so the menu bar can offer per-pane voices),
+// and a per-tty voice override. Both are small JSON files in the state dir.
+
+const readJson = (p, fallback) => {
+  try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return fallback;
+  }
+};
+const writeJson = (p, obj) => {
+  ensureDir(stateDir());
+  writeFileSync(p, JSON.stringify(obj));
+};
+
+const panesPath = () => join(stateDir(), 'panes.json');
+const paneVoicesPath = () => join(stateDir(), 'pane-voices.json');
+const waitingPath = () => join(stateDir(), 'waiting.json');
+
+// Track which panes are waiting for input, so the menu bar icon can show a
+// status color (yellow) when any agent needs you.
+export const setPaneWaiting = (tty, waiting) => {
+  if (!tty) return;
+  const all = readJson(waitingPath(), {});
+  if (waiting) all[tty] = Date.now();
+  else delete all[tty];
+  writeJson(waitingPath(), all);
+};
+export const anyWaiting = () => Object.keys(readJson(waitingPath(), {})).length > 0;
+
+// Record this pane as active (keyed by tty). Keeps the 16 most-recent.
+export const recordPane = (tty, label) => {
+  if (!tty) return;
+  const all = readJson(panesPath(), {});
+  all[tty] = { label: label || '', ts: Date.now() };
+  const trimmed = Object.entries(all)
+    .sort((a, b) => b[1].ts - a[1].ts)
+    .slice(0, 16);
+  writeJson(panesPath(), Object.fromEntries(trimmed));
+};
+
+export const readPanes = () =>
+  Object.entries(readJson(panesPath(), {}))
+    .map(([tty, v]) => ({ tty, label: v.label || '', ts: v.ts || 0 }))
+    .sort((a, b) => b.ts - a.ts);
+
+// Per-pane settings: { tts, speaker, voice, volume }. Any subset may be set.
+export const readPaneSetting = (tty) => (tty ? readJson(paneVoicesPath(), {})[tty] || {} : {});
+
+// Merge `patch` into the pane's settings; keys set to null are removed; an empty
+// entry is deleted entirely.
+export const updatePaneSetting = (tty, patch) => {
+  if (!tty) return;
+  const all = readJson(paneVoicesPath(), {});
+  const next = { ...(all[tty] || {}), ...patch };
+  for (const k of Object.keys(next)) if (next[k] == null) delete next[k];
+  if (Object.keys(next).length === 0) delete all[tty];
+  else all[tty] = next;
+  writeJson(paneVoicesPath(), all);
+};
+
 // --- Config ----------------------------------------------------------------
 
 // Sounds default to OS built-ins so we ship no audio assets (clean repo, no
@@ -55,19 +139,27 @@ export const DEFAULT_CONFIG = {
   bannerWhenMuted: true,
   // Spoken read-out of which terminal finished (helps tell tabs apart).
   speak: true,
-  // Prefix the window label to the spoken message so you can tell which of many
-  // terminals is asking (set a short per-window name with $AI_NOTIFY_LABEL).
-  speakLabel: true,
+  // Output volume 0.0–2.0 (1.0 = normal). The menu bar slider / `ai-notify
+  // volume` write a state file that overrides this; $AI_NOTIFY_VOLUME overrides
+  // per window. Applies to sounds, the spoken voice, and VOICEVOX.
+  volume: 1.0,
+  // Prefix the window label to the SPOKEN read-out. Off by default — the task
+  // gist already identifies the pane, and the label (often the working dir) just
+  // adds slow filler. Turn on if you set a short $AI_NOTIFY_LABEL per window.
+  // (The desktop banner is always titled with the label regardless.)
+  speakLabel: false,
   // Visually highlight the waiting terminal window/pane (best-effort, by tty).
   // Off by default; the color is yellow / orange / red / green / #RRGGBB.
   highlightWaiting: false,
   highlightColor: 'yellow',
   // Make the desktop notification click bring the terminal/IDE forward.
   notifyActivate: true,
-  // Whether to speak the agent's own text (Codex's reply, a Claude prompt).
-  // That text is in the agent's language — set this false to keep every spoken
-  // read-out in your own language via doneMessage / waitingMessage instead.
-  speakAgentMessage: true,
+  // Speak the agent's full message aloud (Codex's reply, a Claude prompt, the
+  // done-summary)? Default false = read only a short gist (first clause, capped
+  // at speakMaxChars) — enough to tell which task, never cut off. The full text
+  // still shows in the desktop banner. Set true to read the whole thing.
+  speakAgentMessage: false,
+  speakMaxChars: 40,
   // Optional: translate the agent's message into this language before speaking
   // it (e.g. 'ja'). Empty = off. Key-less, no cost; makes a network request.
   // Toggle with `ai-notify translate on ja` / `off`.
@@ -79,6 +171,11 @@ export const DEFAULT_CONFIG = {
   // 'Kyoko'). Empty = OS default voice. Switch it with `ai-notify voice`. A
   // per-provider `voice` below, if set, overrides this for that agent.
   voice: '',
+  // TTS backend: 'say' (OS voice) or 'voicevox' (local VOICEVOX engine — speak
+  // in character voices). Falls back to 'say' if the engine isn't running.
+  // Per window: $AI_NOTIFY_VOICEVOX_SPEAKER overrides the speaker id.
+  tts: 'say',
+  voicevox: { url: 'http://127.0.0.1:50021', speaker: 3 },
   // Spoken read-out templates for agent events. The window label is added
   // separately (speakLabel), so leave {label} out here to avoid doubling it.
   // Override per language (e.g. Japanese) in config.json. An agent that supplies
@@ -108,4 +205,4 @@ export const writeConfig = (config) => {
   return configPath();
 };
 
-export const paths = { muteFlagPath, configPath, stateDir, configDir };
+export const paths = { muteFlagPath, configPath, stateDir, configDir, volumeFlagPath };

package/src/util.mjs

@@ -39,3 +39,19 @@ export const cliInvocation = () => ({
 export const isEphemeralInstall = (cliPath) => /[/\\]_npx[/\\]/.test(cliPath);
 
 export const MARKER = 'ai-notify'; // substring used to detect our own wiring
+
+// The controlling terminal of this process (e.g. "/dev/ttys010"), which is
+// stable per terminal pane — used to scope per-pane settings. null if none.
+export const controllingTty = () => {
+  try {
+    const t = execFileSync('ps', ['-o', 'tty=', '-p', String(process.pid)], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+      .toString()
+      .trim();
+    if (!t || t === '??' || t === '?') return null;
+    return t.startsWith('/dev/') ? t : `/dev/${t}`;
+  } catch {
+    return null;
+  }
+};

package/src/voicevox.mjs

@@ -0,0 +1,120 @@
+// VOICEVOX read-out: synthesize the spoken notification with a local VOICEVOX
+// engine (free, offline, no API key) so each terminal can speak in a distinct
+// character voice (ずんだもん, 四国めたん, …).
+//
+// The engine exposes an HTTP API on 127.0.0.1:50021. We use `curl` (zero deps):
+//   POST /audio_query?speaker=ID&text=...   -> query JSON
+//   POST /synthesis?speaker=ID  (query body) -> WAV
+// then play the WAV. Everything is best-effort: if the engine isn't running we
+// return false and the caller falls back to the OS `say` voice.
+
+import { execSync, execFileSync } from 'node:child_process';
+import { existsSync, statSync, mkdtempSync, rmSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { stateDir } from './state.mjs';
+
+export const DEFAULT_URL = 'http://127.0.0.1:50021';
+
+const platform = process.platform;
+
+// Record why a synthesis fell back to the OS voice, so intermittent fallbacks
+// are diagnosable instead of silent. Best-effort.
+const logFail = (reason) => {
+  try {
+    appendFileSync(join(stateDir(), 'voicevox.log'), `${new Date().toISOString()} ${reason}\n`);
+  } catch {
+    /* ignore */
+  }
+};
+
+export const isAvailable = (url = DEFAULT_URL, timeoutMs = 1500) => {
+  try {
+    const out = execFileSync('curl', ['-s', '-m', String(Math.ceil(timeoutMs / 1000)), `${url}/version`], {
+      encoding: 'utf8',
+      timeout: timeoutMs + 500,
+    });
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+};
+
+// Flatten /speakers into [{ id, name }] (character + style).
+export const listSpeakers = (url = DEFAULT_URL) => {
+  try {
+    const out = execFileSync('curl', ['-s', '-m', '4', `${url}/speakers`], { encoding: 'utf8', timeout: 5000 });
+    const data = JSON.parse(out);
+    const rows = [];
+    for (const sp of data) {
+      for (const st of sp.styles || []) rows.push({ id: st.id, name: `${sp.name}（${st.name}）` });
+    }
+    return rows;
+  } catch {
+    return [];
+  }
+};
+
+// One entry per character (preferring the ノーマル style) — a short, pickable
+// list for the menu bar, vs the full style list from listSpeakers.
+export const listCharacters = (url = DEFAULT_URL) => {
+  try {
+    const out = execFileSync('curl', ['-s', '-m', '4', `${url}/speakers`], { encoding: 'utf8', timeout: 5000 });
+    const data = JSON.parse(out);
+    const rows = [];
+    for (const sp of data) {
+      const styles = sp.styles || [];
+      const pick = styles.find((s) => s.name === 'ノーマル') || styles[0];
+      if (pick) rows.push({ id: pick.id, name: sp.name });
+    }
+    return rows;
+  } catch {
+    return [];
+  }
+};
+
+const playWav = (wav, vol = 1) => {
+  if (platform === 'darwin') execFileSync('afplay', ['-v', String(vol), wav], { timeout: 30000 });
+  else if (platform === 'linux') {
+    try {
+      execFileSync('aplay', ['-q', wav], { timeout: 30000 });
+    } catch {
+      execFileSync('paplay', [wav], { timeout: 30000 });
+    }
+  }
+};
+
+// Synthesize and play. Returns true if it spoke, false to fall back to `say`.
+export const speak = (text, speaker = 3, url = DEFAULT_URL, vol = 1, timeoutMs = 15000) => {
+  if (!text) return false;
+  let dir;
+  try {
+    dir = mkdtempSync(join(tmpdir(), 'ai-notify-vv-'));
+    const wav = join(dir, 'v.wav');
+    const sec = String(Math.max(2, Math.ceil(timeoutMs / 1000)));
+    const enc = encodeURIComponent(text); // URL-encoded -> no shell metacharacters
+    // Pipe audio_query straight into synthesis. execSync uses /bin/sh for the pipe.
+    const cmd =
+      `curl -s -m ${sec} -X POST "${url}/audio_query?speaker=${speaker}&text=${enc}" | ` +
+      `curl -s -m ${sec} -X POST -H "Content-Type: application/json" -d @- ` +
+      `"${url}/synthesis?speaker=${speaker}" -o "${wav}"`;
+    execSync(cmd, { timeout: timeoutMs + 1000, stdio: 'ignore' });
+    if (!existsSync(wav) || statSync(wav).size < 1000) {
+      logFail(`empty/short wav (speaker ${speaker}, ${text.length} chars)`);
+      return false;
+    }
+    playWav(wav, vol);
+    return true;
+  } catch (e) {
+    logFail(`error (speaker ${speaker}): ${(e && e.message) || e}`);
+    return false;
+  } finally {
+    if (dir) {
+      try {
+        rmSync(dir, { recursive: true, force: true });
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+};