opencode-plugin-boops 2.6.1 → 2.7.0

package/README.md

@@ -5,7 +5,7 @@ Sound notifications for OpenCode - plays pleasant "boop" sounds when tasks compl
 ## Features
 
 - 🎵 Soft, friendly notification sounds when AI completes tasks
-- 📡 Gentle alert when AI needs your permission or input
+- 📡 Gentle alert when AI needs your permission, input, or asks a question
 - 🌐 Works out of the box with online sounds (auto-downloaded and cached)
 - 🔄 Fully configurable - use URLs or local files
 - 🐧 Works on Linux (with `paplay` or `aplay`)
@@ -67,6 +67,7 @@ The plugin listens to OpenCode events and plays sounds based on your configurati
 
 - **`session.idle`** - AI finishes responding → soft "pristine" notification
 - **`permission.asked`** - AI needs permission → gentle "relax" chime
+- **`question.asked`** - AI asks a question → gentle "relax" chime
 - **`session.error`** - An error occurs → friendly "magic" alert
 
 **Instant config reload:** The config is reloaded on every event, so changes take effect immediately without restarting OpenCode! Edit your config, trigger an event, and hear the new sound instantly.
@@ -147,6 +148,10 @@ You can configure sounds for any of the 28 OpenCode events:
 - `permission.asked` - AI needs permission
 - `permission.replied` - Permission response given
 
+**Question events (2):**
+- `question.asked` - AI asks a multiple-choice question
+- `question.replied` - User answers a question
+
 **File events (2):**
 - `file.edited` - File is edited
 - `file.watcher.updated` - File watcher detects change

package/boops.default.toml

@@ -5,8 +5,9 @@
 
 [sounds]
 "session.idle" = "pristine"  # AI completes response
+"session.error" = "exclamation"  # Error occurs
 "permission.asked" = "relax"  # AI needs permission
-"session.error" = "magic"  # Error occurs
+"question.asked" = "relax"  # AI asks a question (falls back to permission.asked if not set)
 
 # You can use:
 # - Sound names: "pristine" (searches sounds.json by name)

package/cli/browse

@@ -22,17 +22,45 @@ const sounds = JSON.parse(readFileSync(soundsPath, "utf-8"));
 
 // Available OpenCode events
 const availableEvents = [
-  "session.idle", "permission.asked", "session.error",
-  "command.executed", "file.edited", "file.watcher.updated",
-  "installation.updated", "lsp.client.diagnostics", "lsp.updated",
-  "message.part.removed", "message.part.updated", "message.removed", "message.updated",
-  "permission.replied", "server.connected",
-  "session.created", "session.compacted", "session.deleted", "session.diff", "session.status", "session.updated",
+  "command.executed",
+  "file.edited",
+  "file.watcher.updated",
+  "installation.updated",
+  "lsp.client.diagnostics",
+  "lsp.updated",
+  "message.part.removed",
+  "message.part.updated",
+  "message.removed",
+  "message.updated",
+  "permission.asked",
+  "permission.replied",
+  "question.asked",
+  "question.replied",
+  "server.connected",
+  "session.compacted",
+  "session.created",
+  "session.deleted",
+  "session.diff",
+  "session.error",
+  "session.idle",
+  "session.status",
+  "session.updated",
   "todo.updated",
-  "tool.execute.before", "tool.execute.after",
-  "tui.prompt.append", "tui.command.execute", "tui.toast.show"
+  "tool.execute.after",
+  "tool.execute.before",
+  "tui.command.execute",
+  "tui.prompt.append",
+  "tui.toast.show"
 ];
 
+// System/custom events (separate section)
+const systemEvents = [
+  "__fallback"
+];
+
+// Combined array for the picker (system events at the end)
+const allEvents = [...availableEvents, ...systemEvents];
+
 // Cache directory
 const CACHE_DIR = "/tmp/opencode-boops/cache";
 
@@ -59,9 +87,6 @@ const PLUGIN_INSTALLED = isPluginInstalled();
 
 // Event descriptions for the picker
 const eventDescriptions = {
-  "session.idle": "AI completes response",
-  "permission.asked": "AI needs permission",
-  "session.error": "Error occurs",
   "command.executed": "Command executed",
   "file.edited": "File edited",
   "file.watcher.updated": "File watcher detected change",
@@ -72,20 +97,24 @@ const eventDescriptions = {
   "message.part.updated": "Message part updated",
   "message.removed": "Message removed",
   "message.updated": "Message updated",
+  "permission.asked": "AI needs permission",
   "permission.replied": "Permission response given",
   "server.connected": "Connected to server",
-  "session.created": "New session created",
   "session.compacted": "Session compacted",
+  "session.created": "New session created",
   "session.deleted": "Session deleted",
   "session.diff": "Session diff generated",
+  "session.error": "Error occurs",
+  "session.idle": "AI completes response",
   "session.status": "Session status changed",
   "session.updated": "Session updated",
   "todo.updated": "Todo list updated",
-  "tool.execute.before": "Before tool execution",
   "tool.execute.after": "After tool execution",
-  "tui.prompt.append": "Text appended to prompt",
+  "tool.execute.before": "Before tool execution",
   "tui.command.execute": "TUI command executed",
-  "tui.toast.show": "Toast notification shown"
+  "tui.prompt.append": "Text appended to prompt",
+  "tui.toast.show": "Toast notification shown",
+  "__fallback": "Fallback sound when primary fails"
 };
 
 // Load current boops.toml config
@@ -124,6 +153,14 @@ function saveConfig(config) {
     }
   }
   
+  // Add fallbacks section if there are any
+  if (config.fallbacks && Object.keys(config.fallbacks).length > 0) {
+    content += "\n[fallbacks]\n";
+    for (const [key, sound] of Object.entries(config.fallbacks).sort()) {
+      content += `${key} = "${sound}"\n`;
+    }
+  }
+  
   writeFileSync(configPath, content);
   return true;
 }
@@ -810,9 +847,9 @@ async function browse() {
     
     // Instructions
     if (PLUGIN_INSTALLED) {
-      console.log('  \x1b[38;5;240m↑/↓ navigate  Enter play current  Ctrl+S save & exit  ESC cancel\x1b[0m');
+      console.log('  \x1b[38;5;240m\x1b[38;5;67m↑/↓\x1b[38;5;240m navigate  \x1b[38;5;67mEnter\x1b[38;5;240m play current  \x1b[38;5;67mCtrl+S\x1b[38;5;240m save & exit  \x1b[38;5;67mESC\x1b[38;5;240m cancel\x1b[0m');
     } else {
-      console.log('  \x1b[38;5;240m↑/↓ navigate  Enter play current  ESC cancel  \x1b[38;5;208m(save disabled - plugin not installed)\x1b[0m');
+      console.log('  \x1b[38;5;240m\x1b[38;5;67m↑/↓\x1b[38;5;240m navigate  \x1b[38;5;67mEnter\x1b[38;5;240m play current  \x1b[38;5;67mESC\x1b[38;5;240m cancel  \x1b[38;5;208m(save disabled - plugin not installed)\x1b[0m');
     }
     console.log('');
     
@@ -821,13 +858,25 @@ async function browse() {
     // Fixed lines: 4 (top) + 2 (bottom) = 6
     const fixedLines = 6;
     const maxVisibleEvents = Math.max(1, termHeight - fixedLines);
-    const scrollOffset = Math.max(0, Math.min(state.pickerSelectedEvent - Math.floor(maxVisibleEvents / 2), availableEvents.length - maxVisibleEvents));
-    const endIndex = Math.min(scrollOffset + maxVisibleEvents, availableEvents.length);
+    const scrollOffset = Math.max(0, Math.min(state.pickerSelectedEvent - Math.floor(maxVisibleEvents / 2), allEvents.length - maxVisibleEvents));
+    const endIndex = Math.min(scrollOffset + maxVisibleEvents, allEvents.length);
     
     for (let i = scrollOffset; i < endIndex; i++) {
-      const event = availableEvents[i];
+      const event = allEvents[i];
       const isSelected = i === state.pickerSelectedEvent;
-      const currentSound = config.sounds ? config.sounds[event] : null;
+      
+      // Add separator before system events
+      if (i === availableEvents.length && i >= scrollOffset) {
+        console.log(`  ${'─'.repeat(Math.min(60, termWidth - 4))}`);
+      }
+      
+      // Get current sound from appropriate config section
+      let currentSound = null;
+      if (event === '__fallback') {
+        currentSound = config.fallbacks ? config.fallbacks.default : null;
+      } else {
+        currentSound = config.sounds ? config.sounds[event] : null;
+      }
       
       const selectionBg = isSelected ? '\x1b[48;5;235m' : '';
       const reset = '\x1b[0m';
@@ -1085,15 +1134,15 @@ async function browse() {
       const config = loadCurrentConfig();
       const boxX = termWidth - pickerWidth;
       const boxStartY = stickyNavbar ? (topBlankLine + 4) : (topBlankLine + 1); // Start below header in sticky mode, else near top
-      const boxHeight = Math.min(availableEvents.length + 4, termHeight - boxStartY - fixedFooterLines);
+      const boxHeight = Math.min(allEvents.length + 5, termHeight - boxStartY - fixedFooterLines); // +5 for separator line
       
       // Calculate scroll offset for event list
       const maxVisibleEvents = boxHeight - 6; // Reserve space for header(2) + description(2) + footer(2)
-      const eventScrollOffset = Math.max(0, Math.min(state.pickerSelectedEvent - Math.floor(maxVisibleEvents / 2), availableEvents.length - maxVisibleEvents));
-      const eventEndIndex = Math.min(eventScrollOffset + maxVisibleEvents, availableEvents.length);
+      const eventScrollOffset = Math.max(0, Math.min(state.pickerSelectedEvent - Math.floor(maxVisibleEvents / 2), allEvents.length - maxVisibleEvents));
+      const eventEndIndex = Math.min(eventScrollOffset + maxVisibleEvents, allEvents.length);
       
       // Get selected event info
-      const selectedEvent = availableEvents[state.pickerSelectedEvent];
+      const selectedEvent = allEvents[state.pickerSelectedEvent];
       const eventDesc = eventDescriptions[selectedEvent] || "No description available";
       
       // Draw each line of the picker box
@@ -1101,6 +1150,11 @@ async function browse() {
         const screenY = boxStartY + row;
         process.stdout.write(`\x1b[${screenY};${boxX}H`); // Position cursor
         
+        // Clear the area where we'll draw the picker (from cursor to end of line)
+        // Draw a solid background to cover anything underneath
+        process.stdout.write(' '.repeat(pickerWidth));
+        process.stdout.write(`\x1b[${screenY};${boxX}H`); // Reposition cursor
+        
         if (row === 0) {
           // Top border with title
           const title = ` Assign to Event `;
@@ -1132,10 +1186,23 @@ async function browse() {
         } else {
           // Event list item
           const eventIndex = eventScrollOffset + (row - 3);
+          
           if (eventIndex < eventEndIndex) {
-            const event = availableEvents[eventIndex];
+            const event = allEvents[eventIndex];
             const isSelected = eventIndex === state.pickerSelectedEvent;
-            const currentSound = config.sounds ? config.sounds[event] : null;
+            
+            // Show separator before system events
+            if (eventIndex === availableEvents.length) {
+              process.stdout.write(`\x1b[38;5;240m│ ${'─'.repeat(pickerWidth - 4)} │\x1b[0m`);
+            } else {
+            
+            // Get current sound from appropriate config section
+            let currentSound = null;
+            if (event === '__fallback') {
+              currentSound = config.fallbacks ? config.fallbacks.default : null;
+            } else {
+              currentSound = config.sounds ? config.sounds[event] : null;
+            }
             
             const bg = isSelected ? '\x1b[48;5;235m' : '';
             
@@ -1153,10 +1220,11 @@ async function browse() {
                 : event.padEnd(pickerWidth - 6);
             }
             
-            const indicator = currentSound ? '•' : ' ';
-            const indicatorColor = currentSound ? '\x1b[38;5;76m' : '';
-            
-            process.stdout.write(`\x1b[38;5;240m│\x1b[0m${bg}${indicatorColor}${indicator}\x1b[0m${bg} ${eventText} \x1b[0m\x1b[38;5;240m│\x1b[0m`);
+              const indicator = currentSound ? '•' : ' ';
+              const indicatorColor = currentSound ? '\x1b[38;5;76m' : '';
+              
+              process.stdout.write(`\x1b[38;5;240m│\x1b[0m${bg}${indicatorColor}${indicator}\x1b[0m${bg} ${eventText} \x1b[0m\x1b[38;5;240m│\x1b[0m`);
+            }
           } else {
             // Empty line
             process.stdout.write(`\x1b[38;5;240m│${' '.repeat(pickerWidth - 2)}│\x1b[0m`);
@@ -1176,7 +1244,7 @@ async function browse() {
     if (state.searchQuery || state.searchMode) {
       // Search mode: show search box on left, hints on right
       const searchBox = ` /${state.searchQuery}`;
-      const searchHint = '\x1b[38;5;240m/ to refine  esc to clear\x1b[0m';
+      const searchHint = '\x1b[38;5;240m\x1b[38;5;67m/\x1b[38;5;240m to refine  \x1b[38;5;67mesc\x1b[38;5;240m to clear\x1b[0m';
       const searchBoxVisible = 2 + state.searchQuery.length; // " /" + query
       const hintVisible = getVisibleLength(searchHint);
       
@@ -1216,10 +1284,10 @@ async function browse() {
       let controls;
       if (state.pickerMode) {
         controls = PLUGIN_INSTALLED 
-          ? ' \x1b[38;5;240m↑/↓ select  enter play  a assign  d unassign  ←/esc close\x1b[0m'
-          : ' \x1b[38;5;240m↑/↓ select event  enter play  ←/esc close  \x1b[38;5;208m(save disabled)\x1b[0m';
+          ? ' \x1b[38;5;240m\x1b[38;5;67m↑/↓\x1b[38;5;240m select  \x1b[38;5;67menter\x1b[38;5;240m play  \x1b[38;5;67ma\x1b[38;5;240m assign  \x1b[38;5;67md\x1b[38;5;240m unassign  \x1b[38;5;67m←/esc\x1b[38;5;240m close\x1b[0m'
+          : ' \x1b[38;5;240m\x1b[38;5;67m↑/↓\x1b[38;5;240m select event  \x1b[38;5;67menter\x1b[38;5;240m play  \x1b[38;5;67m←/esc\x1b[38;5;240m close  \x1b[38;5;208m(save disabled)\x1b[0m';
       } else {
-        controls = ' \x1b[38;5;240m↑/↓ navigate  ←/→ tags  / search  s assign  enter play  q quit\x1b[0m';
+        controls = ' \x1b[38;5;240m\x1b[38;5;67m↑/↓\x1b[38;5;240m navigate  \x1b[38;5;67m←/→\x1b[38;5;240m tags  \x1b[38;5;67m/\x1b[38;5;240m search  \x1b[38;5;67ms\x1b[38;5;240m assign  \x1b[38;5;67menter\x1b[38;5;240m play  \x1b[38;5;67mq\x1b[38;5;240m quit\x1b[0m';
       }
       
       // Attribution with manual hover/click
@@ -1845,7 +1913,7 @@ async function browse() {
         return;
       } else if (key === '\u001b[B' || key === 'j') {
         // Down arrow
-        if (state.pickerSelectedEvent < availableEvents.length - 1) {
+        if (state.pickerSelectedEvent < allEvents.length - 1) {
           state.pickerSelectedEvent++;
         }
         render();
@@ -1853,8 +1921,15 @@ async function browse() {
       } else if (key === '\r' || key === ' ') {
         // Enter/Space - play current sound for selected event
         const config = loadCurrentConfig();
-        const event = availableEvents[state.pickerSelectedEvent];
-        const currentSound = config.sounds ? config.sounds[event] : null;
+        const event = allEvents[state.pickerSelectedEvent];
+        
+        // Get current sound from appropriate config section
+        let currentSound = null;
+        if (event === '__fallback') {
+          currentSound = config.fallbacks ? config.fallbacks.default : null;
+        } else {
+          currentSound = config.sounds ? config.sounds[event] : null;
+        }
         if (currentSound) {
           const soundEntry = sounds.find(s => s.id === currentSound || s.name === currentSound);
           if (soundEntry) {
@@ -1870,10 +1945,16 @@ async function browse() {
       } else if (key === 'a') {
         // 'a' - assign sound to selected event (auto-saves)
         const config = loadCurrentConfig();
-        const event = availableEvents[state.pickerSelectedEvent];
+        const event = allEvents[state.pickerSelectedEvent];
         
-        if (!config.sounds) config.sounds = {};
-        config.sounds[event] = state.pickerSound.name; // Save friendly name, not ID
+        // Check if this is a system event
+        if (event === '__fallback') {
+          if (!config.fallbacks) config.fallbacks = {};
+          config.fallbacks.default = state.pickerSound.name; // Save friendly name
+        } else {
+          if (!config.sounds) config.sounds = {};
+          config.sounds[event] = state.pickerSound.name; // Save friendly name, not ID
+        }
         
         // Auto-save to config file
         saveConfig(config);
@@ -1884,11 +1965,19 @@ async function browse() {
       } else if (key === 'd') {
         // 'd' - unassign/delete sound from selected event
         const config = loadCurrentConfig();
-        const event = availableEvents[state.pickerSelectedEvent];
+        const event = allEvents[state.pickerSelectedEvent];
         
-        if (config.sounds && config.sounds[event]) {
-          delete config.sounds[event];
-          saveConfig(config);
+        // Check if this is a system event
+        if (event === '__fallback') {
+          if (config.fallbacks && config.fallbacks.default) {
+            delete config.fallbacks.default;
+            saveConfig(config);
+          }
+        } else {
+          if (config.sounds && config.sounds[event]) {
+            delete config.sounds[event];
+            saveConfig(config);
+          }
         }
         
         // Stay in picker mode
@@ -1985,6 +2074,7 @@ async function browse() {
         
       case '\u001b[A': // Up arrow
       case 'k':
+        if (state.pickerMode) break; // Picker handles its own navigation
         if (state.selectedLine > 0) {
           state.selectedLine--;
           // Skip non-interactive lines
@@ -2026,6 +2116,7 @@ async function browse() {
         
       case '\u001b[B': // Down arrow
       case 'j':
+        if (state.pickerMode) break; // Picker handles its own navigation
         if (state.selectedLine < lines.length - 1) {
           state.selectedLine++;
           // Skip non-interactive lines
@@ -2050,6 +2141,7 @@ async function browse() {
         
       case '\u001b[C': // Right arrow
       case 'l':
+        if (state.pickerMode) break; // Picker doesn't use right arrow
         // Navigate tags right, maintaining sound position
         if (state.selectedTagIndex < allTags.length - 1) {
           state.selectedTagIndex++;
@@ -2072,6 +2164,8 @@ async function browse() {
         
       case '\u001b[D': // Left arrow
       case 'h':
+        // Picker mode: left arrow exits (handled earlier in picker section)
+        if (state.pickerMode) break; // Already handled in picker mode section
         // Navigate tags left, maintaining sound position
         if (state.selectedTagIndex > -1) {
           state.selectedTagIndex--;
@@ -2093,6 +2187,7 @@ async function browse() {
         break;
         
       case '/':
+        if (state.pickerMode) break; // Block search when picker is open
         // Enter search mode (or re-enter if results are showing)
         state.searchMode = true;
         if (!state.searchQuery) {
@@ -2104,6 +2199,7 @@ async function browse() {
         break;
         
       case 's':
+        if (state.pickerMode) break; // Block opening another picker
         // Open event picker for selected sound
         {
           const selectedLine = lines[state.selectedLine];
@@ -2119,6 +2215,7 @@ async function browse() {
       case 'p':
       case '\r': // Enter key
       case ' ':  // Space key
+        if (state.pickerMode) break; // Picker handles these keys
         {
           const selectedLine = lines[state.selectedLine];
         

package/index.ts

@@ -52,6 +52,17 @@ export const BoopsPlugin: Plugin = async ({ client }) => {
     })
   }
 
+  // Track last error time to debounce idle sounds after errors
+  let lastErrorTime = 0
+  const ERROR_DEBOUNCE_MS = 2000
+
+  // Track pending sounds that can be cancelled
+  let pendingSoundTimeout: ReturnType<typeof setTimeout> | null = null
+  let pendingSoundCancelled = false
+
+  // Track which sessions are subagents (have parentID)
+  const subagentSessions = new Set<string>()
+
   // Cache directory for downloaded sounds
   const cacheDir = join(homedir(), ".cache", "opencode", "boops")
   
@@ -249,33 +260,54 @@ export const BoopsPlugin: Plugin = async ({ client }) => {
     return null
   }
 
-  // Play sound with fallback mechanism
-  const playSound = async (soundFile: string, eventName: string) => {
+  // Play sound with fallback mechanism (supports cancellation)
+  const playSound = async (soundFile: string, eventName: string, canCancel = false) => {
     if (player === "echo") return // Skip if no player
 
-    try {
-      // Resolve the sound file (download if URL, check if local path exists)
-      const resolvedPath = await resolveSoundPath(soundFile, eventName)
-      
-      if (resolvedPath) {
-        await Bun.$`${player} ${resolvedPath}`.quiet()
-        return
-      }
-
-      // Try fallback
-      const fallback = config.fallbacks?.default
-      if (fallback) {
-        const fallbackPath = await resolveSoundPath(fallback, "fallback")
-        if (fallbackPath) {
-          await Bun.$`${player} ${fallbackPath}`.quiet()
+    const play = async () => {
+      try {
+        // Resolve the sound file (download if URL, check if local path exists)
+        const resolvedPath = await resolveSoundPath(soundFile, eventName)
+        
+        if (resolvedPath) {
+          await Bun.$`${player} ${resolvedPath}`.quiet()
           return
         }
+
+        // Try fallback
+        const fallback = config.fallbacks?.default
+        if (fallback) {
+          const fallbackPath = await resolveSoundPath(fallback, "fallback")
+          if (fallbackPath) {
+            await Bun.$`${player} ${fallbackPath}`.quiet()
+            return
+          }
+        }
+
+        // Last resort: terminal bell
+        await Bun.$`echo -e "\a"`.quiet()
+      } catch (error) {
+        // Silently fail - don't spam logs for sound errors
       }
+    }
 
-      // Last resort: terminal bell
-      await Bun.$`echo -e "\a"`.quiet()
-    } catch (error) {
-      // Silently fail - don't spam logs for sound errors
+    if (canCancel) {
+      // Clear any pending sound
+      if (pendingSoundTimeout) {
+        clearTimeout(pendingSoundTimeout)
+        pendingSoundTimeout = null
+      }
+      pendingSoundCancelled = false
+      
+      // Delay slightly to allow error to cancel it
+      pendingSoundTimeout = setTimeout(() => {
+        pendingSoundTimeout = null
+        if (!pendingSoundCancelled) {
+          play()
+        }
+      }, 100)
+    } else {
+      await play()
     }
   }
 
@@ -312,12 +344,41 @@ export const BoopsPlugin: Plugin = async ({ client }) => {
       // Reload config on every event for instant updates (no restart needed!)
       config = await loadConfig()
       
-      // Log session.idle events for debugging (helpful for users configuring filters)
-      if (event.type === "session.idle") {
-        await log(`session.idle event received`, { 
-          properties: event,
-          configuredSound: config.sounds["session.idle"]
-        })
+      // Track subagent sessions (sessions with parentID)
+      if (event.type === "session.updated") {
+        const sessionInfo = event.properties?.info
+        if (sessionInfo?.parentID) {
+          subagentSessions.add(sessionInfo.id)
+        }
+      }
+      
+      // Cancel any pending sounds on error
+      if (event.type === "session.error") {
+        lastErrorTime = Date.now()
+        if (pendingSoundTimeout) {
+          pendingSoundCancelled = true
+          clearTimeout(pendingSoundTimeout)
+          pendingSoundTimeout = null
+        }
+      }
+       
+      // Skip idle sound if error recently fired (for events that bypass cancellation)
+      if (event.type === "session.idle" && Date.now() - lastErrorTime < ERROR_DEBOUNCE_MS) {
+        return // Don't play idle sound after error
+      }
+      
+      // Skip idle for subagent sessions
+      const sessionID = event.properties?.sessionID
+      if ((event.type === "session.idle" || event.type === "session.status") && sessionID && subagentSessions.has(sessionID)) {
+        return // Don't play sound for subagent completions
+      }
+      
+      // Handle question.asked -> play permission sound as a fallback
+      if (event.type === "question.asked") {
+        const questionSound = config.sounds["question.asked"] || config.sounds["permission.asked"]
+        if (questionSound) {
+          await playSound(questionSound, "question.asked")
+        }
       }
 
       const soundConfig = config.sounds[event.type]
@@ -325,13 +386,16 @@ export const BoopsPlugin: Plugin = async ({ client }) => {
 
       // Handle simple string (just a sound file path/URL)
       if (typeof soundConfig === "string") {
-        await playSound(soundConfig, event.type)
+        // Use cancellable sound for idle
+        const canCancel = event.type === "session.idle" || event.type === "session.error"
+        await playSound(soundConfig, event.type, canCancel)
         return
       }
 
       // Handle filter object
       if (matchesFilter(event, soundConfig)) {
-        await playSound(soundConfig.sound, event.type)
+        const canCancel = event.type === "session.idle" || event.type === "session.error"
+        await playSound(soundConfig.sound, event.type, canCancel)
       }
     },
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-plugin-boops",
-  "version": "2.6.1",
+  "version": "2.7.0",
   "description": "Sound notifications for OpenCode - plays pleasant sounds when tasks complete or input is needed",
   "main": "index.ts",
   "type": "module",