pi-smart-voice-notify 0.3.3 → 0.3.5

package/CHANGELOG.md

@@ -1,16 +1,21 @@
 # Changelog
 
-## [Unreleased]
+## [0.3.5] - 2026-04-27
 
-## [0.3.3] - 2026-04-22
+### 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.
 
-### Changed
-- Updated README and example config documentation to reflect `PI_CODING_AGENT_DIR`-aware global extension paths and `session_start` lifecycle reasons
-- Resolved extension config/debug paths and forwarded permission watcher paths from `getAgentDir()`
-- Updated `@mariozechner/pi-coding-agent` and `@mariozechner/pi-tui` peer dependencies to ^0.68.1
+## [0.3.4] - 2026-04-25
 
-### Fixed
-- Prevented reminders, notification playback, and webhook queue flushing/retry waits from continuing after session shutdown
+### Added
+- Added shutdown-aware notification lifecycle handling so pending reminders and queued playback stop cleanly during session shutdown
+- Added `session_start.reason` handling for startup, reload, new, resume, and fork session transitions
+
+### Changed
+- Updated global extension path documentation to account for `PI_CODING_AGENT_DIR`-aware configuration and debug paths
+- Synchronized package metadata and lockfile for the 0.3.4 patch release while preserving `@mariozechner/pi-*` peer dependency range `^0.70.2`
+- Release note context: `v0.3.2` is not on `main`; no tag or history repair is included in this release prep
 
 ## [0.3.2] - 2026-04-01
 
@@ -91,7 +96,7 @@
 - Rewrote README.md with professional documentation standards
 - Added comprehensive feature documentation, configuration reference, and usage examples
 
-## [0.1.0] - 2026-03-02
+## 0.1.0
 
 - Standardized repository structure to `index.ts` shim + `src/` implementation.
 - Added config template and package metadata/scripts aligned with Pi extension conventions.

package/README.md

@@ -1,5 +1,7 @@
 # 🔔 pi-smart-voice-notify
 
+[![npm version](https://img.shields.io/npm/v/pi-smart-voice-notify?style=flat-square)](https://www.npmjs.com/package/pi-smart-voice-notify) [![License](https://img.shields.io/github/license/MasuRii/pi-smart-voice-notify?style=flat-square)](LICENSE)
+
 Windows-optimized smart notification extension for the Pi coding agent.
 
 **pi-smart-voice-notify** monitors Pi session and tool events to alert you via **multi-engine TTS**, **sound playback**, **desktop toast notifications**, and optional **webhook/AI-assisted messaging** when the agent requires your attention.
@@ -17,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
 
@@ -123,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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-smart-voice-notify",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "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.68.1",
-    "@mariozechner/pi-tui": "^0.68.1"
+    "@mariozechner/pi-coding-agent": "^0.70.2",
+    "@mariozechner/pi-tui": "^0.70.2"
   },
   "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 = {

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);

package/src/index.ts

@@ -19,7 +19,6 @@ import {
 	isWindows,
 	MESSAGE_LIBRARY,
 	normalizeConfig,
-	PERMISSION_HINTS,
 	QUESTION_HINTS,
 	readConfigFromDisk,
 	SOUND_LOOPS,
@@ -125,45 +124,9 @@ function classifyToolResult(
 		return "question";
 	}
 
-	if (normalizedTool.includes("permission") || PERMISSION_HINTS.some((hint) => normalizedText.includes(hint))) {
-		return "permission";
-	}
-
 	return "error";
 }
 
-function readBlockedReason(value: unknown): string | null {
-	const record = toRecord(value);
-	const blockValue = record.block;
-	const isBlocked = blockValue === true || blockValue === "true";
-	if (!isBlocked) {
-		return null;
-	}
-
-	const reason = record.reason;
-	if (typeof reason !== "string") {
-		return null;
-	}
-
-	const normalizedReason = reason.trim();
-	return normalizedReason.length > 0 ? normalizedReason : null;
-}
-
-function extractToolCallBlockReason(event: unknown): string | null {
-	const directReason = readBlockedReason(event);
-	if (directReason) {
-		return directReason;
-	}
-
-	const record = toRecord(event);
-	return readBlockedReason(record.result);
-}
-
-function isPermissionReason(reason: string): boolean {
-	const normalizedReason = reason.toLowerCase();
-	return PERMISSION_HINTS.some((hint) => normalizedReason.includes(hint));
-}
-
 function statusLine(config: VoiceNotifyConfig): string | undefined {
 	if (!config.enabled) {
 		return "voice:off";
@@ -215,6 +178,28 @@ function envInteger(defaultValue: number, ...keys: string[]): number {
 	return Number.isFinite(parsed) ? parsed : defaultValue;
 }
 
+function normalizePermissionForwardingSessionId(value: unknown): string | null {
+	if (typeof value !== "string") {
+		return null;
+	}
+	const trimmed = value.trim();
+	if (!trimmed || trimmed.toLowerCase() === "unknown") {
+		return null;
+	}
+	return trimmed;
+}
+
+function getPermissionForwardingSessionId(ctx: ExtensionContext): string | null {
+	try {
+		const sessionManager = "sessionManager" in ctx
+			? ctx.sessionManager as { getSessionId?: () => unknown }
+			: null;
+		return normalizePermissionForwardingSessionId(sessionManager?.getSessionId?.());
+	} catch {
+		return null;
+	}
+}
+
 function sanitizeAgentName(value: string | null): string | null {
 	if (!value) {
 		return null;
@@ -362,7 +347,6 @@ export default function smartVoiceNotifyExtension(
 	const pendingReminders = new Map<ReminderKey, ReminderState>();
 	const reminderPlayback = new ReminderPlaybackController();
 	const pendingPermissionToolCallIds = new Set<string>();
-	const blockedPermissionToolCallIds = new Set<string>();
 	const processedToolResultToolCallIds = new Set<string>();
 	const lastNotificationAt = new Map<NotificationType, number>();
 
@@ -590,6 +574,7 @@ export default function smartVoiceNotifyExtension(
 		permissionForwardingWatcher.start({
 			enabled: config.enabled && config.enablePermissionNotification && config.enableForwardedPermissionWatcher,
 			watchLegacyPath: config.watchLegacyForwardedPermissionPath,
+			targetSessionId: getPermissionForwardingSessionId(activeSessionContext),
 		});
 	};
 
@@ -1415,7 +1400,6 @@ export default function smartVoiceNotifyExtension(
 		if (event.state === "waiting") {
 			if (event.toolCallId) {
 				pendingPermissionToolCallIds.add(event.toolCallId);
-				rememberScopedToolCallId(event.toolCallId, blockedPermissionToolCallIds);
 			}
 			logger.debug("permission_system.wait_detected", {
 				requestId: event.requestId,
@@ -1687,7 +1671,6 @@ export default function smartVoiceNotifyExtension(
 		hadErrorInTurn = false;
 		warnedDesktopUnsupported = false;
 		pendingPermissionToolCallIds.clear();
-		blockedPermissionToolCallIds.clear();
 		processedToolResultToolCallIds.clear();
 		lastNotificationAt.clear();
 
@@ -1730,7 +1713,6 @@ export default function smartVoiceNotifyExtension(
 			activeSessionContext = null;
 			permissionForwardingWatcher.stop();
 			pendingPermissionToolCallIds.clear();
-			blockedPermissionToolCallIds.clear();
 			processedToolResultToolCallIds.clear();
 			resetPermissionBatch("session_shutdown");
 			cancelReminderActivity("session_shutdown");
@@ -1766,37 +1748,13 @@ export default function smartVoiceNotifyExtension(
 	pi.on("agent_start", async () => {
 		hadErrorInTurn = false;
 		pendingPermissionToolCallIds.clear();
-		blockedPermissionToolCallIds.clear();
 		processedToolResultToolCallIds.clear();
 		resetPermissionBatch("agent_start");
 		logger.debug("agent.start", {});
 	});
 
-	pi.on("tool_call", async (event, ctx) => {
+	pi.on("tool_call", async (_event, ctx) => {
 		activeSessionContext = ctx;
-		if (!config.enabled || !config.enablePermissionNotification) {
-			return {};
-		}
-
-		const reason = extractToolCallBlockReason(event);
-		if (!reason || !isPermissionReason(reason)) {
-			return {};
-		}
-
-		if (!rememberScopedToolCallId(event.toolCallId, blockedPermissionToolCallIds)) {
-			return {};
-		}
-
-		pendingPermissionToolCallIds.add(event.toolCallId);
-		logger.debug("tool_call.permission_blocked", {
-			toolCallId: event.toolCallId,
-			toolName: event.toolName,
-			reason,
-		});
-		queuePermissionNotification(ctx, {
-			reminderKey: permissionReminderKey(event.toolCallId),
-			reason,
-		});
 		return {};
 	});
 

package/src/logging.ts

@@ -59,14 +59,13 @@ export function createExtensionLogger(options: LoggerOptions): ExtensionLogger {
 				...details,
 			});
 			appendFileSync(debugLogPath, `${line}\n`, "utf-8");
-		} catch (error) {
-			console.error(`[${extensionId}] Failed to write debug log: ${getErrorMessage(error)}`);
+		} catch {
+			// Debug logging must never write to stdout/stderr from extension code.
 		}
 	};
 
 	const error = (cause: unknown): void => {
 		debug("runtime.error", { error: cause });
-		console.error(`[${extensionId}] ${getErrorMessage(cause)}`);
 	};
 
 	return { debug, error };