pi-smart-voice-notify 0.3.4 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.4.0] - 2026-04-30
+
+### Added
+- Detect agent turn failures reported at `agent_end` and send error notifications instead of completion alerts.
+
+### Changed
+- Renamed bundled notification sound assets to stable lowercase filenames and migrate legacy bundled sound paths automatically.
+- Updated `@mariozechner/pi-*` peer dependency ranges to `^0.70.6` and synchronized package lock metadata.
+
+## [0.3.5] - 2026-04-27
+
+### Fixed
+- Permission notifications now require an authoritative `pi-permission-system:permission-request` waiting event before alerts or reminders are queued, preventing permission-looking `tool_call` and `tool_result` payloads from producing false permission alerts.
+- Forwarded permission notifications now watch only the active session's scoped request/response directories, require matching `targetSessionId`, and ignore unscoped legacy paths, stale requests, resolved requests, malformed files, and mismatched request filenames.
+
 ## [0.3.4] - 2026-04-25
 
 ### Added

package/README.md

@@ -19,7 +19,7 @@ Windows-optimized smart notification extension for the Pi coding agent.
 
 - **Intelligent event detection**
   - Task completion (idle)
-  - Direct permission blocks plus forwarded subagent permission requests
+  - Authoritative permission-system wait events plus current-session forwarded subagent permission requests
   - Questions requiring input (when custom `question` tool is loaded)
   - Errors
 
@@ -125,17 +125,17 @@ A starter template is provided in `config/config.example.json`. On startup, the
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `enableIdleNotification` | boolean | `true` | Notify when agent finishes a task |
-| `enablePermissionNotification` | boolean | `true` | Notify on permission blocks |
-| `enableForwardedPermissionWatcher` | boolean | `true` | Watch forwarded permission request files and notify when new requests arrive |
+| `enablePermissionNotification` | boolean | `true` | Notify when the permission system reports requests waiting for approval |
+| `enableForwardedPermissionWatcher` | boolean | `true` | Watch current-session forwarded permission request/response files and notify when new requests arrive |
 | `includeForwardedPermissionAgentName` | boolean | `true` | Include sanitized requester agent name in forwarded permission notification text |
-| `watchLegacyForwardedPermissionPath` | boolean | `true` | Also watch the legacy forwarded-permission directory (default: `~/.pi/agent/permission-forwarding/requests`, respects `PI_CODING_AGENT_DIR`) when present |
+| `watchLegacyForwardedPermissionPath` | boolean | `true` | Retained for config compatibility; unscoped legacy forwarded-permission paths are ignored because they cannot prove the current target session |
 | `enableQuestionNotification` | boolean | `true` | Notify when agent asks a question* |
 | `enableErrorNotification` | boolean | `true` | Notify on errors |
 | `suppressIdleAfterError` | boolean | `true` | Skip idle notification if turn had errors |
 
 *Question notifications only work when a custom `question` tool is loaded.
 
-Forwarded permission watcher notifications use privacy-safe text and never include raw forwarded `message` content.
+Forwarded permission watcher notifications use privacy-safe text, require the request `targetSessionId` to match the active Pi session, and never include raw forwarded `message` content.
 
 ### Reminder Settings
 
@@ -166,10 +166,10 @@ Forwarded permission watcher notifications use privacy-safe text and never inclu
 
 | Option | Type | Default |
 |--------|------|---------|
-| `idleSoundFile` | string | `"assets/Soft-high-tech-notification-sound-effect.mp3"` |
-| `permissionSoundFile` | string | `"assets/Machine-alert-beep-sound-effect.mp3"` |
-| `questionSoundFile` | string | `"assets/Machine-alert-beep-sound-effect.mp3"` |
-| `errorSoundFile` | string | `"assets/Machine-alert-beep-sound-effect.mp3"` |
+| `idleSoundFile` | string | `"assets/soft-notification.mp3"` |
+| `permissionSoundFile` | string | `"assets/attention-alert.mp3"` |
+| `questionSoundFile` | string | `"assets/attention-alert.mp3"` |
+| `errorSoundFile` | string | `"assets/attention-alert.mp3"` |
 
 Paths can be absolute or relative to the extension directory.
 

package/config/config.example.json

@@ -94,10 +94,10 @@
   "openaiTtsSpeed": 1,
 
   "_comment_sounds": "Direct sound file fallbacks.",
-  "idleSoundFile": "assets/Soft-high-tech-notification-sound-effect.mp3",
-  "permissionSoundFile": "assets/Machine-alert-beep-sound-effect.mp3",
-  "questionSoundFile": "assets/Machine-alert-beep-sound-effect.mp3",
-  "errorSoundFile": "assets/Machine-alert-beep-sound-effect.mp3",
+  "idleSoundFile": "assets/soft-notification.mp3",
+  "permissionSoundFile": "assets/attention-alert.mp3",
+  "questionSoundFile": "assets/attention-alert.mp3",
+  "errorSoundFile": "assets/attention-alert.mp3",
 
   "_comment_sound_theme": "Sound theme settings.",
   "themePath": "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-smart-voice-notify",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Windows-optimized smart voice, sound, and desktop notifications for Pi coding agent.",
   "type": "module",
   "main": "./index.ts",
@@ -19,7 +19,7 @@
   "scripts": {
     "build": "npx --yes -p typescript@5.7.3 -p @types/node@20.17.57 tsc -p tsconfig.json --noEmit",
     "lint": "npm run build",
-    "test": "node --experimental-strip-types --test src/abortable-command.test.ts src/reminder-playback.test.ts src/index.test.ts",
+    "test": "node --experimental-strip-types --test src/abortable-command.test.ts src/reminder-playback.test.ts src/permission-forwarding-watcher.test.ts src/index.test.ts",
     "check": "npm run build && npm run test"
   },
   "keywords": [
@@ -61,8 +61,8 @@
     ]
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "^0.70.2",
-    "@mariozechner/pi-tui": "^0.70.2"
+    "@mariozechner/pi-coding-agent": "^0.70.6",
+    "@mariozechner/pi-tui": "^0.70.6"
   },
   "dependencies": {
     "node-notifier": "^10.0.1"

package/src/ai-messages.ts

@@ -70,7 +70,7 @@ const DEFAULT_TEMPLATES: Record<CoreAIEventType, string[]> = {
 	permission: [
 		"Permission needed for {projectName}. Please approve in the terminal.",
 		"I need your approval to continue {projectName}.",
-		"Action blocked. Please confirm the pending permission request.",
+		"Permission approval is pending. Please confirm the request.",
 	],
 	question: [
 		"I need your input for {projectName}. Please check the terminal.",

package/src/config-store.ts

@@ -45,7 +45,7 @@ const DEFAULT_WEBHOOK_EVENTS: NotificationType[] = [...NOTIFICATION_TYPE_VALUES]
 
 export const INLINE_NOTIFY_TEXT: Record<NotificationType, string> = {
 	idle: "✅ Agent finished its current task.",
-	permission: "⚠️ Action blocked by permission policy.",
+	permission: "⚠️ Permission approval is pending.",
 	question: "❓ Agent needs your input.",
 	error: "❌ Agent encountered an error.",
 };
@@ -108,15 +108,6 @@ export const MESSAGE_LIBRARY: Record<NotificationType, MessageSet> = {
 	},
 };
 
-export const PERMISSION_HINTS = [
-	"permission",
-	"not permitted",
-	"requires approval",
-	"approval",
-	"user denied",
-	"blocked by",
-];
-
 export const QUESTION_HINTS = ["question", "need your input", "please answer", "requires your input"];
 
 export const DEFAULT_CONFIG: VoiceNotifyConfig = {
@@ -183,10 +174,10 @@ export const DEFAULT_CONFIG: VoiceNotifyConfig = {
 	openaiTtsFormat: "mp3",
 	openaiTtsSpeed: 1,
 
-	idleSoundFile: "assets/Soft-high-tech-notification-sound-effect.mp3",
-	permissionSoundFile: "assets/Machine-alert-beep-sound-effect.mp3",
-	questionSoundFile: "assets/Machine-alert-beep-sound-effect.mp3",
-	errorSoundFile: "assets/Machine-alert-beep-sound-effect.mp3",
+	idleSoundFile: "assets/soft-notification.mp3",
+	permissionSoundFile: "assets/attention-alert.mp3",
+	questionSoundFile: "assets/attention-alert.mp3",
+	errorSoundFile: "assets/attention-alert.mp3",
 	themePath: "",
 	themeName: "default",
 	themesRootPath: "",
@@ -353,6 +344,34 @@ function stringOrDefault(value: unknown, fallback: string): string {
 	return fallback;
 }
 
+const LEGACY_BUNDLED_SOUND_FILES: Record<string, string> = {
+	"assets/machine-alert-beep-sound-effect.mp3": "assets/attention-alert.mp3",
+	"assets/soft-high-tech-notification-sound-effect.mp3": "assets/soft-notification.mp3",
+};
+
+function normalizeSoundFileLookup(value: string): string {
+	return value.replaceAll("\\", "/").replace(/^\.\//, "").toLowerCase();
+}
+
+function soundFileExists(value: string): boolean {
+	return existsSync(isAbsolute(value) ? value : join(CONFIG_DIR, value));
+}
+
+function normalizeSoundFile(value: unknown, fallback: string): string {
+	const selected = stringOrDefault(value, fallback);
+	const lookup = normalizeSoundFileLookup(selected);
+	const migrated = LEGACY_BUNDLED_SOUND_FILES[lookup];
+	if (migrated) {
+		return migrated;
+	}
+
+	if (lookup.startsWith("assets/") && !soundFileExists(selected) && soundFileExists(fallback)) {
+		return fallback;
+	}
+
+	return selected;
+}
+
 function stringOrEmpty(value: unknown): string {
 	if (typeof value === "string") {
 		return value.trim();
@@ -755,13 +774,13 @@ export function normalizeConfig(raw: unknown): VoiceNotifyConfig {
 		openaiTtsFormat: stringOrDefault(record.openaiTtsFormat, DEFAULT_CONFIG.openaiTtsFormat),
 		openaiTtsSpeed: clampNumber(record.openaiTtsSpeed, DEFAULT_CONFIG.openaiTtsSpeed, 0.25, 4),
 
-		idleSoundFile: stringOrDefault(record.idleSoundFile ?? record.idleSound, DEFAULT_CONFIG.idleSoundFile),
-		permissionSoundFile: stringOrDefault(
+		idleSoundFile: normalizeSoundFile(record.idleSoundFile ?? record.idleSound, DEFAULT_CONFIG.idleSoundFile),
+		permissionSoundFile: normalizeSoundFile(
 			record.permissionSoundFile ?? record.permissionSound,
 			DEFAULT_CONFIG.permissionSoundFile,
 		),
-		questionSoundFile: stringOrDefault(record.questionSoundFile ?? record.questionSound, DEFAULT_CONFIG.questionSoundFile),
-		errorSoundFile: stringOrDefault(record.errorSoundFile ?? record.errorSound, DEFAULT_CONFIG.errorSoundFile),
+		questionSoundFile: normalizeSoundFile(record.questionSoundFile ?? record.questionSound, DEFAULT_CONFIG.questionSoundFile),
+		errorSoundFile: normalizeSoundFile(record.errorSoundFile ?? record.errorSound, DEFAULT_CONFIG.errorSoundFile),
 		themePath: stringOrEmpty(record.themePath ?? record.soundThemeDir ?? record.themeDirectory),
 		themeName: stringOrDefault(record.themeName, DEFAULT_CONFIG.themeName),
 		themesRootPath: stringOrEmpty(record.themesRootPath ?? record.themesRootDirectory),
@@ -998,7 +1017,7 @@ export function isWindows(): boolean {
 
 export function resolveSoundFile(config: VoiceNotifyConfig, type: NotificationType): string | null {
 	const field = SOUND_FILE_FIELD[type];
-	const value = config[field];
+	const value = normalizeSoundFile(config[field], DEFAULT_CONFIG[field]);
 	if (!value.trim()) {
 		return null;
 	}

package/src/index.test.ts

@@ -61,6 +61,7 @@ class FakeEventBus {
 
 class FakePi {
 	private readonly handlers = new Map<string, EventHandler[]>();
+	private tools: Array<{ name: string }> = [];
 
 	public readonly events = new FakeEventBus();
 
@@ -73,8 +74,12 @@ class FakePi {
 	public registerCommand(): void {
 	}
 
+	public setAvailableTools(tools: Array<{ name: string }>): void {
+		this.tools = [...tools];
+	}
+
 	public getAllTools(): Array<{ name: string }> {
-		return [];
+		return [...this.tools];
 	}
 
 	public sendMessage(): void {
@@ -397,7 +402,13 @@ test("skipWhenFocused=false still notifies even when the terminal is focused", a
 
 	await pi.emit("session_start", {}, ctx);
 	await flushAsyncWork();
-	await pi.emit("tool_call", permissionEvent("call-focus-disabled"), ctx);
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-focus-disabled", {
+			toolCallId: "call-focus-disabled",
+			toolName: "write_file",
+		}),
+	);
 	await flushAsyncWork();
 	await tickAndFlush(PERMISSION_BATCH_WINDOW_MS);
 
@@ -425,7 +436,13 @@ test("skipWhenFocused=true suppresses focused notifications and uses config focu
 
 	await pi.emit("session_start", {}, ctx);
 	await flushAsyncWork();
-	await pi.emit("tool_call", permissionEvent("call-focus-enabled"), ctx);
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-focus-enabled", {
+			toolCallId: "call-focus-enabled",
+			toolName: "write_file",
+		}),
+	);
 	await flushAsyncWork();
 	await tickAndFlush(PERMISSION_BATCH_WINDOW_MS);
 
@@ -525,7 +542,13 @@ test("permission reminders use the permission-specific reminder interval", async
 
 	await pi.emit("session_start", {}, ctx);
 	await flushAsyncWork();
-	await pi.emit("tool_call", permissionEvent("call-permission-reminder-delay"), ctx);
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-reminder-delay", {
+			toolCallId: "call-permission-reminder-delay",
+			toolName: "write_file",
+		}),
+	);
 	await flushAsyncWork();
 	await tickAndFlush(PERMISSION_BATCH_WINDOW_MS);
 
@@ -539,6 +562,47 @@ test("permission reminders use the permission-specific reminder interval", async
 	assert.equal(countReminderCalls(ttsCalls), 1);
 });
 
+test("blocked tool_call events do not trigger permission notifications without permission-system waiting state", async (t) => {
+	disableFocusDetection(t);
+	useMockClock(t);
+
+	const { ctx, pi, ttsCalls } = createHarness();
+
+	await pi.emit("session_start", {}, ctx);
+	await flushAsyncWork();
+	await pi.emit("tool_call", permissionEvent("call-no-authoritative-wait"), ctx);
+	await flushAsyncWork();
+	await tickAndFlush(PERMISSION_BATCH_WINDOW_MS);
+
+	assert.equal(immediateNotificationCalls(ttsCalls).length, 0);
+	assert.equal(countReminderCalls(ttsCalls), 0);
+});
+
+test("permission-looking tool_result errors do not trigger permission notifications without permission-system waiting state", async (t) => {
+	disableFocusDetection(t);
+	useMockClock(t);
+
+	const { ctx, pi, ttsCalls } = createHarness();
+
+	await pi.emit("session_start", {}, ctx);
+	await flushAsyncWork();
+	await pi.emit(
+		"tool_result",
+		{
+			toolCallId: "result-no-authoritative-wait",
+			toolName: "permission_guard",
+			isError: true,
+			content: [{ type: "text", text: "Requires approval from the user before continuing." }],
+		},
+		ctx,
+	);
+	await flushAsyncWork();
+	await tickAndFlush(PERMISSION_BATCH_WINDOW_MS);
+
+	assert.equal(immediateNotificationCalls(ttsCalls).length, 0);
+	assert.equal(countReminderCalls(ttsCalls), 0);
+});
+
 test("permission-system waiting events trigger a permission notification and cancel on resolution", async (t) => {
 	disableFocusDetection(t);
 	useMockClock(t);
@@ -605,9 +669,21 @@ test("tool_execution_start only cancels the resolved permission reminder flow",
 
 	await pi.emit("session_start", {}, ctx);
 	await flushAsyncWork();
-	await pi.emit("tool_call", permissionEvent("call-a"), ctx);
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-call-a", {
+			toolCallId: "call-a",
+			toolName: "write_file",
+		}),
+	);
 	await flushAsyncWork();
-	await pi.emit("tool_call", permissionEvent("call-b"), ctx);
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-call-b", {
+			toolCallId: "call-b",
+			toolName: "write_file",
+		}),
+	);
 	await flushAsyncWork();
 
 	assert.equal(countReminderCalls(ttsCalls), 0);
@@ -640,9 +716,21 @@ test("tool_result resolution keeps another permission reminder active while drop
 
 	await pi.emit("session_start", {}, ctx);
 	await flushAsyncWork();
-	await pi.emit("tool_call", permissionEvent("call-a"), ctx);
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-result-call-a", {
+			toolCallId: "call-a",
+			toolName: "write_file",
+		}),
+	);
 	await flushAsyncWork();
-	await pi.emit("tool_call", permissionEvent("call-b"), ctx);
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-result-call-b", {
+			toolCallId: "call-b",
+			toolName: "write_file",
+		}),
+	);
 	await flushAsyncWork();
 	await tickAndFlush(PERMISSION_BATCH_WINDOW_MS);
 	await tickAndFlush(1_000);
@@ -662,7 +750,7 @@ test("tool_result resolution keeps another permission reminder active while drop
 	assert.equal(countReminderCalls(ttsCalls), 1);
 });
 
-test("tool_result with the same toolCallId still classifies after a permission-blocked tool_call", async (t) => {
+test("tool_result with the same toolCallId still classifies after a permission-system waiting event", async (t) => {
 	disableFocusDetection(t);
 	useMockClock(t);
 
@@ -672,7 +760,13 @@ test("tool_result with the same toolCallId still classifies after a permission-b
 
 	await pi.emit("session_start", {}, ctx);
 	await flushAsyncWork();
-	await pi.emit("tool_call", permissionEvent("call-shared"), ctx);
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-shared", {
+			toolCallId: "call-shared",
+			toolName: "write_file",
+		}),
+	);
 	await flushAsyncWork();
 	await tickAndFlush(PERMISSION_BATCH_WINDOW_MS);
 	assert.equal(immediateNotificationCalls(ttsCalls).length, 1);
@@ -692,6 +786,79 @@ test("tool_result with the same toolCallId still classifies after a permission-b
 	assert.equal(immediateNotificationCalls(ttsCalls).length, 2);
 });
 
+test("agent_end triggers an idle notification when idle notifications are enabled", async (t) => {
+	disableFocusDetection(t);
+	useMockClock(t);
+
+	const { ctx, pi, ttsCalls } = createHarness({
+		enableIdleNotification: true,
+		reminderEnabled: false,
+	});
+
+	await pi.emit("session_start", {}, ctx);
+	await flushAsyncWork();
+	await pi.emit("agent_end", {}, ctx);
+	await flushAsyncWork();
+
+	assert.equal(immediateNotificationCalls(ttsCalls).length, 1);
+	assert.equal(countReminderCalls(ttsCalls), 0);
+});
+
+test("question-classified tool_result triggers a question notification when the question tool is available", async (t) => {
+	disableFocusDetection(t);
+	useMockClock(t);
+
+	const { ctx, pi, ttsCalls } = createHarness({
+		enableQuestionNotification: true,
+		reminderEnabled: false,
+	});
+	pi.setAvailableTools([{ name: "question" }]);
+
+	await pi.emit("session_start", {}, ctx);
+	await flushAsyncWork();
+	await pi.emit(
+		"tool_result",
+		{
+			toolCallId: "call-question-available",
+			toolName: "custom_tool",
+			isError: false,
+			content: [{ type: "text", text: "This request requires your input before continuing." }],
+		},
+		ctx,
+	);
+	await flushAsyncWork();
+
+	assert.equal(immediateNotificationCalls(ttsCalls).length, 1);
+	assert.equal(countReminderCalls(ttsCalls), 0);
+});
+
+test("question-classified tool_result does not notify when the question tool is unavailable", async (t) => {
+	disableFocusDetection(t);
+	useMockClock(t);
+
+	const { ctx, pi, ttsCalls } = createHarness({
+		enableQuestionNotification: true,
+		reminderEnabled: false,
+	});
+
+	await pi.emit("session_start", {}, ctx);
+	await flushAsyncWork();
+	await pi.emit(
+		"tool_result",
+		{
+			toolCallId: "call-question-unavailable",
+			toolName: "custom_tool",
+			isError: false,
+			content: [{ type: "text", text: "This request requires your input before continuing." }],
+		},
+		ctx,
+	);
+	await flushAsyncWork();
+
+	assert.equal(immediateNotificationCalls(ttsCalls).length, 0);
+	assert.equal(countReminderCalls(ttsCalls), 0);
+});
+
 test("forwarded permission resolution cancels a queued reminder before it fires", async (t) => {
 	disableFocusDetection(t);
 	useMockClock(t);