plugin.ts

import type { Plugin, PluginInput } from "@opencode-ai/plugin"
import { tool } from "@opencode-ai/plugin/tool"

const z = tool.schema
import { homedir } from "os"
import { join, dirname } from "path"
import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs"
import { execSync } from "child_process"
import { fileURLToPath } from "url"
import { loadThemes, getThemeNames, getTheme, reloadThemes, resolveSoundPath, type SoundTheme } from "./lib/themes.js"
import { playSound as playSoundLib, isDebugMode, isTestMode } from "./lib/sound-player.js"
import {
  PLUGIN_DIR,
  USER_THEMES_DIR,
  BUNDLED_THEMES_DIR,
} from "./lib/paths.js"

// =============================================================================
// CONFIGURATION
// =============================================================================

// State directory for instance tracking and TTY profiles
const STATE_DIR = join(homedir(), ".config/opencode/.opencode-sfx")
const INSTANCE_ID = process.pid.toString()

// Environment variable for explicit profile selection
const ENV_PROFILE = "OCSFX_THEME"
// Per-directory profile file (optional, for per-project explicit config)
const PROFILE_FILE = ".ocsfx"
// TTY-to-profile mapping stored in home directory
const TTY_PROFILES_FILE = join(STATE_DIR, "tty-profiles.json")

// =============================================================================
// WINDOW FOCUS DETECTION & TMUX COMPLETION MARKER
// =============================================================================

// Cached window info captured at startup
let cachedWeztermPaneId: number | null = null

// Capture our window info at startup (call this once during plugin init)
function captureWindowInfo(): void {
  // Capture WezTerm pane ID from environment
  if (process.env.WEZTERM_PANE !== undefined) {
    cachedWeztermPaneId = parseInt(process.env.WEZTERM_PANE, 10)
    if (isNaN(cachedWeztermPaneId)) cachedWeztermPaneId = null
  }
}

// Write a completion marker file for the tmux agent status system.
// The marker signals "recently completed" to agent-scan.sh, which renders
// the window tab in pink with a check-decagram glyph for a configurable decay period.
function writeCompletionMarker(): void {
  if (!process.env.TMUX || !process.env.TMUX_PANE) return

  try {
    const windowId = execSync(
      `tmux display-message -t "${process.env.TMUX_PANE}" -p '#{window_id}'`,
      { encoding: "utf-8", timeout: 1000 }
    ).trim().replace(/^@/, "")

    writeFileSync(
      `/tmp/tmux-agent-completed-${windowId}`,
      String(Math.floor(Date.now() / 1000))
    )
  } catch {
    // Ignore errors
  }
}

// Check if this specific pane/window is active
// Returns true if user is looking at this instance, false if they should be notified
function isPaneActive(): boolean {
  // If we have a WezTerm pane ID, use focused_pane_id from wezterm cli
  if (cachedWeztermPaneId !== null) {
    // Stage 1: Is WezTerm even the frontmost app?
    if (!isWezTermFrontmost()) {
      return false
    }

    // Stage 2: Is our WezTerm pane the focused one?
    if (!isOurWezTermPaneFocused()) {
      return false
    }

    // Stage 3: If inside tmux, check if our tmux pane is active
    if (process.env.TMUX) {
      return isTmuxPaneActive()
    }

    // Our WezTerm pane is focused and no tmux — user is looking at us
    return true
  }

  // Fallback: just check tmux if available
  if (process.env.TMUX) {
    return isTmuxPaneActive()
  }

  // Last resort: check if any terminal is focused
  return isTerminalAppFocused()
}

// Check if WezTerm is the frontmost application
function isWezTermFrontmost(): boolean {
  try {
    const frontApp = execSync(
      `osascript -e 'tell application "System Events" to get name of first application process whose frontmost is true'`,
      { encoding: "utf-8", timeout: 1000 }
    ).trim()
    return frontApp.toLowerCase().includes("wezterm")
  } catch {
    return true // Assume frontmost on error
  }
}

// Check if our WezTerm pane is the focused pane via wezterm cli list-clients
function isOurWezTermPaneFocused(): boolean {
  try {
    const clientInfo = execSync(`wezterm cli list-clients --format json`, {
      encoding: "utf-8",
      timeout: 1000,
    })
    const clients = JSON.parse(clientInfo)
    if (clients.length === 0) return true // No client info, assume focused

    // Check if any client has our pane focused
    return clients.some(
      (c: any) => c.focused_pane_id === cachedWeztermPaneId
    )
  } catch {
    return true // Assume focused on error
  }
}

// Check if this specific tmux pane is active
// Must check: session is attached AND window is active AND pane is active
function isTmuxPaneActive(): boolean {
  try {
    const tmuxPane = process.env.TMUX_PANE
    if (!tmuxPane) return true // No pane ID, assume active

    // Query the specific pane using its ID
    const result = execSync(
      `tmux display-message -t "${tmuxPane}" -p '#{session_attached} #{window_active} #{pane_active}'`,
      { encoding: "utf-8", timeout: 1000 }
    ).trim()
    const [sessionAttached, windowActive, paneActive] = result.split(" ")

    // All three must be true for this pane to be "active" (user looking at it)
    return sessionAttached === "1" && windowActive === "1" && paneActive === "1"
  } catch {
    return true // Assume active on error
  }
}

// Terminal app names to detect (fallback when not in wezterm)
const TERMINAL_APPS = [
  "wezterm-gui",
  "WezTerm",
  "Terminal",
  "iTerm2",
  "iTerm",
  "Alacritty",
  "kitty",
  "Ghostty",
  "Hyper",
]

// Check if a terminal app is currently focused (fallback)
function isTerminalAppFocused(): boolean {
  try {
    const result = execSync(
      `osascript -e 'tell application "System Events" to get name of first application process whose frontmost is true'`,
      { encoding: "utf-8", timeout: 1000 }
    ).trim()
    return TERMINAL_APPS.some((app) =>
      result.toLowerCase().includes(app.toLowerCase())
    )
  } catch {
    return true
  }
}

// Current theme info for logging (set during plugin init)
let currentThemeForLogging: string = ""

// Fire-and-forget sound playback (non-blocking)
// Only plays if this pane is NOT active, also writes tmux completion marker
function playSound(soundPath: string, event?: string, reason?: string): void {
  if (isPaneActive()) {
    return // Don't play sound if this pane is active
  }
  // Write completion marker for tmux agent status system
  writeCompletionMarker()
  playSoundLib(soundPath, {
    theme: currentThemeForLogging,
    event,
    reason,
  })
}

// Always play sound regardless of focus
function playSoundAlways(soundPath: string, event?: string, reason?: string): void {
  playSoundLib(soundPath, {
    theme: currentThemeForLogging,
    event,
    reason,
    force: true,
  })
}

// =============================================================================
// TTY IDENTIFICATION
// =============================================================================

// Get a unique identifier for the current terminal session
// Combines multiple identifiers to be unique per terminal instance
function getTtyIdentifier(): string | null {
  const parts: string[] = []

  // TERM_SESSION_ID - UUID set by macOS Terminal.app and iTerm2
  // This is unique per terminal tab/session and doesn't get recycled
  if (process.env.TERM_SESSION_ID) {
    parts.push(`term:${process.env.TERM_SESSION_ID}`)
  }

  // iTerm2 session ID (also a UUID)
  if (process.env.ITERM_SESSION_ID) {
    parts.push(`iterm:${process.env.ITERM_SESSION_ID}`)
  }

  // TMUX - format is "socket_path,server_pid,window_index"
  // Combined with TMUX_PANE and server start time, this uniquely identifies a tmux pane
  // The server_pid + start_time ensures uniqueness across tmux server restarts
  if (process.env.TMUX && process.env.TMUX_PANE) {
    // Extract server PID from TMUX
    const tmuxParts = process.env.TMUX.split(",")
    const serverPid = tmuxParts.length >= 2 ? tmuxParts[1] : "unknown"

    // Get tmux server start time for extra uniqueness
    let startTime = ""
    try {
      startTime = execSync("tmux display-message -p '#{start_time}'", {
        encoding: "utf-8",
        timeout: 1000,
      }).trim()
    } catch {
      // Ignore errors, PID alone is usually sufficient
    }

    if (startTime) {
      parts.push(`tmux:${serverPid}:${startTime}:${process.env.TMUX_PANE}`)
    } else {
      parts.push(`tmux:${serverPid}:${process.env.TMUX_PANE}`)
    }
  }

  // WEZTERM_PANE - unique within WezTerm process
  // Combine with WEZTERM_UNIX_SOCKET if available for uniqueness across restarts
  if (process.env.WEZTERM_PANE) {
    const socket = process.env.WEZTERM_UNIX_SOCKET || ""
    // Extract a unique part from socket path (contains pid or timestamp)
    const socketId = socket.split("/").pop() || ""
    parts.push(`wezterm:${socketId}:${process.env.WEZTERM_PANE}`)
  }

  // If we have any identifiers, join them
  if (parts.length > 0) {
    return parts.join("+")
  }

  // Fallback: try tty device path (less reliable, gets recycled)
  try {
    if (process.stdin.isTTY) {
      const ttyPath = execSync("tty", {
        encoding: "utf-8",
        timeout: 1000,
      }).trim()
      if (ttyPath && ttyPath !== "not a tty") {
        return `tty:${ttyPath}`
      }
    }
  } catch {
    // Ignore errors
  }

  // Last resort fallbacks
  if (process.env.WINDOWID) {
    return `x11:${process.env.WINDOWID}`
  }

  return null
}

// =============================================================================
// TTY PROFILE MANAGEMENT
// =============================================================================

interface TtyProfiles {
  profiles: Record<string, string> // tty identifier -> profile name
}

function ensureStateDir(): void {
  if (!existsSync(STATE_DIR)) {
    mkdirSync(STATE_DIR, { recursive: true })
  }
}

function loadTtyProfiles(): TtyProfiles {
  ensureStateDir()
  if (existsSync(TTY_PROFILES_FILE)) {
    try {
      return JSON.parse(readFileSync(TTY_PROFILES_FILE, "utf-8"))
    } catch {
      return { profiles: {} }
    }
  }
  return { profiles: {} }
}

function saveTtyProfiles(data: TtyProfiles): void {
  ensureStateDir()
  writeFileSync(TTY_PROFILES_FILE, JSON.stringify(data, null, 2))
}

function getTtyProfile(tty: string): string | null {
  const data = loadTtyProfiles()
  return data.profiles[tty] || null
}

function setTtyProfile(tty: string, profile: string): void {
  const data = loadTtyProfiles()
  data.profiles[tty] = profile
  saveTtyProfiles(data)
}

// Read optional per-directory .ocsfx (just a profile name, no JSON needed)
function readDirectoryProfile(): string | null {
  const profilePath = join(process.cwd(), PROFILE_FILE)
  if (existsSync(profilePath)) {
    try {
      return readFileSync(profilePath, "utf-8").trim()
    } catch {
      return null
    }
  }
  return null
}

// =============================================================================
// INSTANCE STATE MANAGEMENT
// =============================================================================

interface InstanceState {
  instances: Record<string, { theme: string; startedAt: string }>
}

const INSTANCES_FILE = join(STATE_DIR, "instances.json")

function loadState(): InstanceState {
  ensureStateDir()
  if (existsSync(INSTANCES_FILE)) {
    try {
      return JSON.parse(readFileSync(INSTANCES_FILE, "utf-8"))
    } catch {
      return { instances: {} }
    }
  }
  return { instances: {} }
}

function saveState(state: InstanceState): void {
  ensureStateDir()
  writeFileSync(INSTANCES_FILE, JSON.stringify(state, null, 2))
}

function cleanupStaleInstances(state: InstanceState): void {
  // Remove instances older than 24 hours (likely stale)
  const now = Date.now()
  const maxAge = 24 * 60 * 60 * 1000
  for (const [pid, info] of Object.entries(state.instances)) {
    const startedAt = new Date(info.startedAt).getTime()
    if (now - startedAt > maxAge) {
      delete state.instances[pid]
    }
  }
}

function hasUserThemes(): boolean {
  try {
    return existsSync(USER_THEMES_DIR) && readdirSync(USER_THEMES_DIR).length > 0
  } catch {
    return false
  }
}

function getAvailableThemes(state: InstanceState): string[] {
  const usedThemes = new Set(Object.values(state.instances).map((i) => i.theme))
  const allThemes = getThemeNames()
  // Exclude "test" and "default" from random rotation when user has custom themes
  // (default is the fallback for users without custom themes; test is for development)
  const userHasThemes = hasUserThemes()
  const candidateThemes = userHasThemes
    ? allThemes.filter((t) => t !== "test" && t !== "default")
    : allThemes.filter((t) => t !== "test")
  const available = candidateThemes.filter((t) => !usedThemes.has(t))
  // If all candidate themes are used, return all candidates (will pick randomly)
  return available.length > 0 ? available : candidateThemes.length > 0 ? candidateThemes : allThemes
}

// Determine the profile using priority:
// 1. OCSFX_THEME env var (explicit selection, highest priority)
// 2. .ocsfx file in cwd (explicit per-project config)
// 3. TTY-to-profile mapping in home dir (persists across directories in same terminal)
// 4. Random selection (saves to TTY mapping for persistence)
function determineProfile(): { profile: string; source: string } {
  const allThemes = getThemeNames()

  // 1. Check environment variable first
  const envProfile = process.env[ENV_PROFILE]
  if (envProfile && allThemes.includes(envProfile)) {
    return { profile: envProfile, source: "env" }
  }

  // 2. Check .ocsfx in current directory
  const dirProfile = readDirectoryProfile()
  if (dirProfile && allThemes.includes(dirProfile)) {
    return { profile: dirProfile, source: "file" }
  }

  // 3. Check TTY-to-profile mapping
  const currentTty = getTtyIdentifier()
  if (currentTty) {
    const ttyProfile = getTtyProfile(currentTty)
    if (ttyProfile && allThemes.includes(ttyProfile)) {
      return { profile: ttyProfile, source: "tty" }
    }
  }

  // 4. Random selection - try to avoid duplicates with other instances
  const state = loadState()
  cleanupStaleInstances(state)
  const availableThemes = getAvailableThemes(state)

  // If the user has no custom themes, prefer the "default" theme
  // (its bundled sounds ship with the plugin and work out of the box)
  let randomProfile: string
  if (!hasUserThemes() && availableThemes.includes("default")) {
    randomProfile = "default"
  } else {
    randomProfile =
      availableThemes[Math.floor(Math.random() * availableThemes.length)]
  }

  // Save to TTY mapping for persistence (if we have a TTY identifier)
  if (currentTty) {
    setTtyProfile(currentTty, randomProfile)
  }

  return { profile: randomProfile, source: "random" }
}

function assignThemeToInstance(): { theme: string; source: string } {
  const state = loadState()
  cleanupStaleInstances(state)

  // Check if this instance already has a theme (same PID reusing)
  if (state.instances[INSTANCE_ID]) {
    return { theme: state.instances[INSTANCE_ID].theme, source: "instance" }
  }

  // Determine profile using priority: env > file > tty > random
  const { profile, source } = determineProfile()

  // Register this instance with the selected theme
  state.instances[INSTANCE_ID] = {
    theme: profile,
    startedAt: new Date().toISOString(),
  }
  saveState(state)

  return { theme: profile, source }
}

function removeInstance(): void {
  const state = loadState()
  delete state.instances[INSTANCE_ID]
  saveState(state)
}

// =============================================================================
// SOUND PLAYBACK HELPERS
// =============================================================================

function randomSound(sounds: string[]): string | null {
  if (!sounds || sounds.length === 0) {
    return null
  }
  return sounds[Math.floor(Math.random() * sounds.length)]
}

/**
 * Check if a session is a sub-agent (has a parentID).
 * Returns true if it's a sub-agent, false if it's a top-level session.
 * On failure (e.g. session not found), returns false (fail-open: play the sound).
 */
let _isSubagentClient: PluginInput["client"] | null = null
async function isSubagentSession(sessionID: string): Promise<boolean> {
  if (!_isSubagentClient) return false
  try {
    const session = await _isSubagentClient.session.get({
      path: { id: sessionID },
      query: { directory: process.cwd() },
    })
    return !!session.data?.parentID
  } catch {
    // If we can't fetch session info, assume it's not a sub-agent (fail-open)
    return false
  }
}

// =============================================================================
// PLUGIN EXPORT
// =============================================================================

export const OpenCodeSFX: Plugin = async ({ $, client }) => {
  // Skip sound effects in non-interactive/headless mode (e.g., opencode run spawned by a bash tool).
  // When there's no TTY on stdin, there's no user at a terminal to hear the sounds.
  if (!process.stdin.isTTY) {
    // Fire-and-forget: awaiting client.app.log during init deadlocks opencode's
    // bootstrap — opencode serializes plugin init ahead of its request loop,
    // so the /log POST issued here would never receive a response.
    client.app.log({
      body: {
        service: "opencode-sfx",
        level: "info",
        message: "OpenCode SFX: disabled (non-interactive mode, no TTY)",
      },
    }).catch(() => {})
    return {}
  }

  // Store client reference for sub-agent session lookups
  _isSubagentClient = client

  // Capture window info at startup for focus detection
  captureWindowInfo()

  // Load themes from YAML (with caching)
  let themes = loadThemes()
  let themeNames = Object.keys(themes)

  if (themeNames.length === 0) {
    client.app.log({
      body: {
        service: "opencode-sfx",
        level: "error",
        message: "No themes found! Check that themes/*.yaml files exist.",
      },
    }).catch(() => {})
    return {}
  }

  const { theme: initialTheme, source } = assignThemeToInstance()
  let currentThemeKey = initialTheme
  let currentTheme = themes[currentThemeKey]
  currentThemeForLogging = currentThemeKey

  if (!currentTheme) {
    client.app.log({
      body: {
        service: "opencode-sfx",
        level: "error",
        message: `Theme "${currentThemeKey}" not found in loaded themes`,
        extra: { availableThemes: themeNames },
      },
    }).catch(() => {})
    return {}
  }

  // Log the assigned theme with source info
  const sourceLabel =
    source === "env"
      ? "from OCSFX_THEME"
      : source === "file"
        ? "from .ocsfx"
        : source === "tty"
          ? "from terminal session"
          : source === "instance"
            ? "existing instance"
            : "randomly selected"

  client.app.log({
    body: {
      service: "opencode-sfx",
      level: "info",
      message: `OpenCode SFX: ${currentTheme.name} (${currentTheme.description}) [${sourceLabel}]`,
      extra: { theme: currentThemeKey, source, pid: INSTANCE_ID, tty: getTtyIdentifier() },
    },
  }).catch(() => {})

  // Helper to switch themes
  const switchTheme = (newThemeKey: string): { success: boolean; message: string } => {
    const newTheme = themes[newThemeKey]
    if (!newTheme) {
      return { success: false, message: `Theme "${newThemeKey}" not found` }
    }
    currentThemeKey = newThemeKey
    currentTheme = newTheme
    currentThemeForLogging = newThemeKey
    
    // Update TTY profile for persistence
    const tty = getTtyIdentifier()
    if (tty) {
      setTtyProfile(tty, newThemeKey)
    }
    
    // Play announcement sound
    const announceFile = randomSound(currentTheme.sounds.announce)
    if (announceFile) {
      const announcePath = resolveSoundPath(currentTheme, announceFile)
      if (announcePath) {
        playSoundAlways(announcePath, "theme.switch", "theme changed")
      }
    }
    
    return { success: true, message: `Switched to ${currentTheme.name} (${currentTheme.description})` }
  }

  // Play the announcement sound on startup (always, regardless of focus)
  const announceFile = randomSound(currentTheme.sounds.announce)
  if (announceFile) {
    const announcePath = resolveSoundPath(currentTheme, announceFile)
    if (announcePath) {
      playSoundAlways(announcePath, "startup", "plugin initialized")
    }
  }

  // Cleanup on exit
  const cleanup = () => {
    removeInstance()
  }
  process.on("exit", cleanup)
  process.on("SIGINT", () => {
    cleanup()
    process.exit(0)
  })
  process.on("SIGTERM", () => {
    cleanup()
    process.exit(0)
  })

  return {
    // Tools for managing themes (used by /sfx command via AI)
    tool: {
      sfx_list_themes: {
        description: "List all available SFX sound themes",
        args: {},
        execute: async () => {
          themes = loadThemes()
          themeNames = Object.keys(themes).sort()
          
          const lines = [`Available themes (current: ${currentThemeKey}):`, ""]
          for (const key of themeNames) {
            const theme = themes[key]
            const marker = key === currentThemeKey ? "* " : "  "
            lines.push(`${marker}${key} - ${theme.name} (${theme.description})`)
          }
          lines.push("", `Total: ${themeNames.length} themes`)
          return lines.join("\n")
        },
      },

      sfx_view_theme: {
        description: "View details of a specific theme",
        args: {
          theme: z
            .string()
            .describe("Theme key to view. Defaults to current theme.")
            .optional(),
        },
        execute: async ({ theme: themeKey }: { theme?: string }) => {
          const key = themeKey || currentThemeKey
          const theme = themes[key]
          if (!theme) {
            return `Error: Theme "${key}" not found`
          }
          
          const isCurrent = key === currentThemeKey ? " (current)" : ""
          const lines = [
            `Theme: ${theme.name}${isCurrent}`,
            `Key: ${key}`,
            `Description: ${theme.description}`,
            "",
            "Sounds:",
            `  Announce (${theme.sounds.announce.length}): ${theme.sounds.announce.join(", ")}`,
            `  Question (${theme.sounds.question.length}): ${theme.sounds.question.join(", ")}`,
            `  Idle (${theme.sounds.idle.length}): ${theme.sounds.idle.join(", ")}`,
            `  Error (${theme.sounds.error.length}): ${theme.sounds.error.join(", ")}`,
          ]
          return lines.join("\n")
        },
      },

      sfx_change_theme: {
        description: "Switch to a different sound theme. Call with theme parameter set to the theme key (e.g., 'marine', 'ghost'). If no theme is specified, randomly picks a different theme than the current one.",
        args: {
          theme: z
            .string()
            .describe("Theme key to switch to. If omitted, a random different theme is selected.")
            .optional(),
        },
        execute: async ({ theme: themeKey }: { theme?: string }) => {
          if (!themeKey) {
            // Random switch: pick a different theme than the current one
            themes = loadThemes()
            themeNames = Object.keys(themes).sort()
            const candidates = themeNames.filter(t => t !== currentThemeKey && t !== "test")
            if (candidates.length === 0) {
              return "No other themes available to switch to."
            }
            const randomKey = candidates[Math.floor(Math.random() * candidates.length)]
            const result = switchTheme(randomKey)
            return result.message
          }
          const result = switchTheme(themeKey)
          return result.message
        },
      },

      sfx_reload_themes: {
        description: "Reload all themes from YAML files",
        args: {},
        execute: async () => {
          themes = reloadThemes()
          themeNames = Object.keys(themes).sort()
          
          const updatedTheme = themes[currentThemeKey]
          if (updatedTheme) {
            currentTheme = updatedTheme
          }
          
          return `Reloaded ${themeNames.length} themes: ${themeNames.join(", ")}`
        },
      },

      sfx_test_sound: {
        description: "Play the current theme's announce sound",
        args: {},
        execute: async () => {
          const soundFile = randomSound(currentTheme.sounds.announce)
          if (!soundFile) {
            return `Error: No announce sounds configured for theme ${currentThemeKey}`
          }
          const soundPath = resolveSoundPath(currentTheme, soundFile)
          if (soundPath) {
            playSoundAlways(soundPath, "test", "user requested test")
            return `Playing: ${soundFile} (theme: ${currentThemeKey})`
          }
          return `Error: Sound file not found: ${soundFile}`
        },
      },

      sfx_create_theme: {
        description: "Create a new SFX sound theme. For an interactive wizard with sound previews, tell the user to run `opencode-sfx create` in their terminal. To create a theme programmatically, provide all the sound selections as parameters. Use sfx_list_sounds first to see available files.",
        args: {
          name: z
            .string()
            .describe("Display name for the theme (e.g., 'My Custom Theme')"),
          description: z
            .string()
            .describe("Short description of the theme")
            .optional(),
          announce: z
            .string()
            .describe("Sound file for announce (played on startup)"),
          question: z
            .string()
            .describe("Sound file for question (played when waiting for input)"),
          idle: z
            .array(z.string())
            .describe("Array of sound files for idle (played when task completes)"),
          error: z
            .array(z.string())
            .describe("Array of sound files for error (played on errors)"),
        },
        execute: async ({ name: themeName, description = "Custom sound theme", announce: announceSound, question: questionSound, idle: idleSounds, error: errorSounds }: { name: string; description?: string; announce: string; question: string; idle: string[]; error: string[] }) => {
          // Validate required parameters
          if (!themeName) {
            return "Error: 'name' parameter is required"
          }
          if (!announceSound) {
            return "Error: 'announce' parameter is required"
          }
          if (!questionSound) {
            return "Error: 'question' parameter is required"
          }
          if (!idleSounds || !Array.isArray(idleSounds) || idleSounds.length === 0) {
            return "Error: 'idle' parameter must be a non-empty array of sound filenames"
          }
          if (!errorSounds || !Array.isArray(errorSounds) || errorSounds.length === 0) {
            return "Error: 'error' parameter must be a non-empty array of sound filenames"
          }
          
          const themeKey = themeName.toLowerCase().replace(/[^a-z0-9]+/g, "-")
          
          // Check if theme already exists
          if (themes[themeKey]) {
            return `Error: Theme "${themeKey}" already exists. Choose a different name.`
          }
          
          // Validate sound files exist
          const validateSound = (file: string) => resolveSoundPath(currentTheme, file) !== null
          
          if (!validateSound(announceSound)) {
            return `Error: Announce sound not found: ${announceSound}`
          }
          if (!validateSound(questionSound)) {
            return `Error: Question sound not found: ${questionSound}`
          }
          for (const s of idleSounds) {
            if (!validateSound(s)) {
              return `Error: Idle sound not found: ${s}`
            }
          }
          for (const s of errorSounds) {
            if (!validateSound(s)) {
              return `Error: Error sound not found: ${s}`
            }
          }
          
          // Generate YAML content
          const yamlContent = [
            `name: ${themeName}`,
            `description: ${description}`,
            "",
            "sounds:",
            `  announce: ${announceSound}`,
            `  question: ${questionSound}`,
            "  idle:",
            ...idleSounds.map((s: string) => `    - ${s}`),
            "  error:",
            ...errorSounds.map((s: string) => `    - ${s}`),
            "",
          ].join("\n")
          
          // Write to user themes directory (~/.ocsfx/themes/<key>/<key>.yaml)
          const themeDir = join(USER_THEMES_DIR, themeKey)
          mkdirSync(themeDir, { recursive: true })
          const themeFile = join(themeDir, `${themeKey}.yaml`)
          
          // Write the theme file
          writeFileSync(themeFile, yamlContent)
          
          // Reload themes
          themes = reloadThemes()
          themeNames = Object.keys(themes).sort()
          
          const lines = [
            `Theme "${themeName}" created successfully!`,
            `File: ${themeFile}`,
            "",
            "YAML content:",
            yamlContent,
          ]
          return lines.join("\n")
        },
      },
      
      sfx_list_sounds: {
        description: "List available sound files. Each theme is a self-contained directory with its own sounds.",
        args: {
          theme: z
            .string()
            .describe("Theme key to list sounds for. Defaults to current theme. Use '*' to list all themes.")
            .optional(),
          filter: z
            .string()
            .describe("Filter pattern to match filenames (case-insensitive substring match)")
            .optional(),
        },
        execute: async ({ theme: themeKey, filter }: { theme?: string; filter?: string }) => {
          const lines: string[] = []
          let totalFiles = 0
          const lowerFilter = filter ? filter.toLowerCase() : null

          const listThemeSounds = (key: string, t: SoundTheme) => {
            if (!existsSync(t.basePath)) return
            try {
              let files = readdirSync(t.basePath)
                .filter(f => /\.(mp3|wav|ogg|m4a|aac)$/i.test(f))
                .sort()
              if (lowerFilter) files = files.filter(f => f.toLowerCase().includes(lowerFilter))
              if (files.length === 0) return

              const marker = key === currentThemeKey ? " *" : ""
              if (lines.length > 0) lines.push("")
              lines.push(`${key}${marker} (${t.basePath}):`, "")
              files.forEach((f, i) => {
                lines.push(`  ${(totalFiles + i + 1).toString().padStart(3)}. ${f}`)
              })
              totalFiles += files.length
            } catch { /* ignore */ }
          }

          if (themeKey && themeKey !== "*") {
            const t = themes[themeKey]
            if (!t) return `Error: Theme "${themeKey}" not found`
            listThemeSounds(themeKey, t)
          } else {
            // List all themes (or just current)
            const keys = themeKey === "*" ? Object.keys(themes).sort() : [currentThemeKey]
            for (const k of keys) {
              const t = themes[k]
              if (t) listThemeSounds(k, t)
            }
          }

          if (totalFiles === 0) {
            return `No sound files found${filter ? ` (filter: ${filter})` : ""}`
          }
          
          lines.push("", `Total: ${totalFiles} files`)
          return lines.join("\n")
        },
      },
      
      sfx_preview_sound: {
        description: "Play a sound file for preview",
        args: {
          filename: z
            .string()
            .describe("Sound filename to play"),
          directory: z
            .string()
            .describe("Directory containing the sound. Defaults to configured SOUNDS_DIR.")
            .optional(),
        },
        execute: async ({ filename, directory }: { filename: string; directory?: string }) => {
          if (!filename) {
            return "Error: filename parameter is required"
          }
          
          let soundPath: string | null = null
          if (directory) {
            const dirPath = join(directory, filename)
            if (existsSync(dirPath)) soundPath = dirPath
          } else {
            soundPath = resolveSoundPath(currentTheme, filename)
          }
          
          if (!soundPath) {
            return `Error: Sound file not found: ${filename}`
          }
          
          playSoundAlways(soundPath, "preview", "user requested preview")
          return `Playing: ${filename}`
        },
      },
    },

    event: async ({ event }) => {
      let soundFile: string | null = null

      const eventType = event.type as string

      // Extract sessionID from events that carry it — used for sub-agent filtering
      const sessionID = (event as any).properties?.sessionID as string | undefined

      if (eventType === "session.idle") {
        // Skip sounds for sub-agent sessions (they have a parentID)
        if (sessionID && await isSubagentSession(sessionID)) {
          return
        }
        soundFile = randomSound(currentTheme.sounds.idle)
      } else if (eventType === "permission.asked") {
        // Skip sounds for sub-agent sessions
        if (sessionID && await isSubagentSession(sessionID)) {
          return
        }
        soundFile = randomSound(currentTheme.sounds.question)
      } else if (eventType === "session.error") {
        // Skip sounds for sub-agent sessions
        if (sessionID && await isSubagentSession(sessionID)) {
          return
        }
        soundFile = randomSound(currentTheme.sounds.error)
      } else if (eventType === "tui.command.execute" || eventType === "message.created") {
        return // Don't play sound for command execution or user messages
      }

      if (soundFile) {
        const soundPath = resolveSoundPath(currentTheme, soundFile)
        if (soundPath) {
          playSound(soundPath, eventType)
        }
      }
    },
    // Hook into tool execution to catch question tool
    "tool.execute.before": async (input, _output) => {
      if (input.tool === "mcp_question" || input.tool === "question") {
        // Skip sounds for sub-agent sessions
        if (input.sessionID && await isSubagentSession(input.sessionID)) {
          return
        }
        const questionFile = randomSound(currentTheme.sounds.question)
        if (questionFile) {
          const soundPath = resolveSoundPath(currentTheme, questionFile)
          if (soundPath) {
            playSound(soundPath, "tool.question", "question tool invoked")
          }
        }
      }
    },

  }
}

// Default export for plugin loading
export default OpenCodeSFX