agentvibes 5.7.7 → 5.10.1

package/RELEASE_NOTES.md

@@ -1,5 +1,85 @@
 # AgentVibes Release Notes
 
+## 🔧 v5.9.0 — SSH Remote + Windows Home Directory Fixes
+
+**Released:** 2026-05-18
+
+### 🐛 SSH Remote: Connection Timeout Added
+
+The SSH remote transport could hang indefinitely if the remote host was unreachable or
+slow to respond. A `ConnectTimeout=10` option is now applied to all SSH connections, so
+a stuck session surfaces an error within 10 seconds instead of blocking forever.
+
+The SSH subshell structure was also cleaned up so the process exit code is reliably
+captured — a previous formatting issue could cause `wait` to report "pid N is not a
+child of this shell" in some shell environments.
+
+### 🐛 Windows: Home Directory Detection Fixed
+
+`detectRemoteLlm()` used `process.env.HOME || os.homedir()` to find the AgentVibes
+config directory. On Windows, `HOME` is typically unset, but `||` would fall through to
+`os.homedir()` correctly — however `??` (null-coalescing) is strictly safer since it
+only falls back on `null`/`undefined`, not on an empty string. The fix also adds test
+injectability: passing a fake `HOME` in tests now reliably overrides the system value on
+all platforms.
+
+---
+
+## 🎸 v5.8.0 — Soprano Now Works + Voice Picker Fixed for All Engines
+
+**Released:** 2026-05-18
+
+### 🐛 Soprano TTS Was Broken — Now Fixed
+
+Soprano (our 80M-parameter neural TTS engine, introduced in v5.6) was silently failing on
+Windows. Several issues combined to break it end-to-end:
+
+- The Windows voice picker showed Soprano as an option but launched it with the wrong binary
+  name (`soprano-tts` instead of `soprano`)
+- `play-tts-soprano.ps1` was called from Node.js with a stripped PATH, so the `soprano`
+  and `soprano-webui` executables couldn't be found even when installed
+- The wav file path was written to PowerShell's Information stream (`Write-Host`) instead
+  of stdout, so the reverb/background-music processor couldn't find it and exited with an error
+- The Gradio WebUI was never auto-started — you had to manually run `soprano-webui` before
+  every session
+
+All of these are now fixed. AgentVibes auto-detects whether the Soprano WebUI server is
+running on port 7860, starts it if not, and polls until it's ready (up to 90 seconds).
+Three modes work in priority order: WebUI (fastest — model stays loaded) → OpenAI-compatible
+API → direct `soprano` CLI.
+
+### 🐛 Voice Picker Ignored Windows SAPI and macOS Say
+
+When opening the voice picker for an LLM configured to use **Windows SAPI** or **macOS Say**,
+the picker displayed the full list of Piper voices instead of the engine's built-in voice.
+This was confusing — selecting a Piper voice while using SAPI or macOS Say had no effect,
+and the Space-bar preview played through the wrong engine.
+
+The picker now adapts to whichever engine is selected:
+
+- **Windows SAPI / macOS Say / Soprano:** shows exactly one item (the engine's built-in voice),
+  auto-selects it, and the Space-bar preview speaks through the correct engine binary
+- **Piper:** shows the full installed-voice catalog as before
+
+Additionally, saving the config no longer silently overwrites the `ttsEngine` field to `piper`
+when a native engine is in use.
+
+### 🔒 Soprano Reliability (9 Adversarial-Review Fixes)
+
+- **Crash fix:** socket `destroy()` could emit a late `error` event with no listener,
+  crashing the Node.js process — an absorber handler is now in place
+- **Loop cancellation:** the 90-second WebUI polling loop now stops immediately when
+  the modal or voice picker is closed (via AbortController)
+- **No unhandled rejections:** `.catch()` handlers added to all async WebUI-check calls
+- **No duplicate processes:** a 10-second cooldown prevents spawning two `soprano-webui`
+  instances when Preview is clicked rapidly
+- **Better error feedback:** spawn failures and non-zero exit codes now surface a visible
+  error label in the voice picker instead of silently resetting
+- **PATH preserved:** the PowerShell PATH refresh now appends registry entries rather than
+  replacing the whole PATH, so nvm, conda, and pyenv shims continue to work
+
+---
+
 ## 🎭 v5.7.7 — Party Mode Voice Restore + Polish
 
 **Released:** 2026-05-17

package/mcp-server/server.py

@@ -71,6 +71,7 @@ class AgentVibesServer:
         """Initialize the AgentVibes MCP server"""
         # Detect native Windows (not WSL)
         self.is_windows = platform.system() == "Windows" and not os.environ.get("WSL_DISTRO_NAME")
+        self.is_darwin = platform.system() == "Darwin"
 
         # Script name constants — Windows uses .ps1, Unix uses .sh
         if self.is_windows:
@@ -1167,15 +1168,24 @@ class AgentVibesServer:
         if (cwd / ".claude").is_dir() and cwd != self.agentvibes_root:
             env["CLAUDE_PROJECT_DIR"] = str(cwd)
 
-        # Add common locations for piper to PATH (Unix only)
+        # Augment PATH with platform-specific binary locations (Unix only).
+        # MCP servers launched by Claude Desktop inherit a sanitized launchd/dbus PATH
+        # that omits Homebrew (Mac) and pipx (all POSIX) locations.
         if not self.is_windows:
             home_dir = Path.home()
-            local_bin = str(home_dir / ".local" / "bin")
-            if "PATH" in env:
-                if local_bin not in env["PATH"]:
-                    env["PATH"] = f"{local_bin}:{env['PATH']}"
-            else:
-                env["PATH"] = local_bin
+            extra_paths = [
+                str(home_dir / ".local" / "bin"),
+                str(home_dir / ".local" / "share" / "pipx" / "venvs" / "piper-tts" / "bin"),
+            ]
+            # Mac: add Homebrew prefix for both Apple Silicon (/opt/homebrew) and Intel (/usr/local)
+            if self.is_darwin:
+                extra_paths = ["/opt/homebrew/bin", "/usr/local/bin"] + extra_paths
+
+            current_path = env.get("PATH", "")
+            path_parts = current_path.split(os.pathsep) if current_path else []
+            new_dirs = [p for p in extra_paths if p not in path_parts]
+            if new_dirs:
+                env["PATH"] = os.pathsep.join(new_dirs) + os.pathsep + current_path
 
         return env
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "agentvibes",
-  "version": "5.7.7",
+  "version": "5.10.1",
   "description": "Now your AI Agents can finally talk back! Professional TTS voice for Claude Code, Claude Desktop (via MCP), and Clawdbot with multi-provider support.",
   "homepage": "https://agentvibes.org",
   "keywords": [
@@ -83,7 +83,7 @@
     "test:syntax": "node -c src/installer.js && node -c mcp-server/install-deps.js",
     "test:bats": "AGENTVIBES_TEST_MODE=true bats test/unit/*.bats",
     "test:node": "node --test test/unit/*.test.js",
-    "test:coverage": "c8 --reporter=lcov --reporter=text node --test test/unit/*.test.js",
+    "test:coverage": "c8 --reporter=lcov --reporter=text node --experimental-test-module-mocks --test-force-exit --test test/unit/*.test.js",
     "test:verbose": "AGENTVIBES_TEST_MODE=true bats -t test/unit/*.bats"
   },
   "dependencies": {

package/src/commands/install-mcp.js

@@ -16,6 +16,99 @@ import ora from 'ora';
 import boxen from 'boxen';
 import { checkDependencies, displayMissingDependencies } from '../utils/dependency-checker.js';
 
+// ─── Platform helpers ──────────────────────────────────────────────────────────
+
+function commandExists(cmd) {
+  try {
+    const finder = process.platform === 'win32' ? 'where' : 'which';
+    execFileSync(finder, [cmd], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function brewExists() {
+  return commandExists('brew');
+}
+
+// Add Homebrew bin dirs to the current process's PATH so newly installed
+// binaries are discoverable without restarting the shell.
+function augmentPathForBrew() {
+  const brewPaths = ['/opt/homebrew/bin', '/usr/local/bin'];
+  const existing = new Set((process.env.PATH || '').split(path.delimiter));
+  const toAdd = brewPaths.filter(p => !existing.has(p));
+  if (toAdd.length > 0) {
+    process.env.PATH = [...toAdd, process.env.PATH].join(path.delimiter);
+  }
+}
+
+// Install pipx via the platform package manager and augment PATH afterward.
+async function ensurePipx(platform) {
+  if (platform === 'darwin') {
+    if (!brewExists()) {
+      console.log(chalk.yellow('Homebrew not found. Install it from https://brew.sh, then re-run.\n'));
+      return false;
+    }
+    console.log(chalk.cyan('📦 Installing pipx via Homebrew...\n'));
+    try {
+      execFileSync('brew', ['install', 'pipx'], { stdio: 'inherit', env: process.env }); // NOSONAR
+      augmentPathForBrew();
+      try { execFileSync('pipx', ['ensurepath'], { stdio: 'pipe', env: process.env }); } catch { /* non-fatal */ } // NOSONAR
+      return true;
+    } catch {
+      return false;
+    }
+  } else if (platform === 'linux') {
+    console.log(chalk.cyan('📦 Installing pipx via apt-get...\n'));
+    try {
+      execFileSync('sudo', ['apt-get', 'install', '-y', 'pipx'], { stdio: 'inherit', env: process.env }); // NOSONAR
+      // Augment PATH with ~/.local/bin so pipx and piper are findable in this process
+      const localBin = path.join(os.homedir(), '.local', 'bin');
+      const existingParts = new Set((process.env.PATH || '').split(path.delimiter));
+      if (!existingParts.has(localBin)) {
+        process.env.PATH = localBin + path.delimiter + process.env.PATH;
+      }
+      try { execFileSync('pipx', ['ensurepath'], { stdio: 'pipe', env: process.env }); } catch { /* non-fatal */ } // NOSONAR
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+// Auto-install missing optional deps (ffmpeg, sox, pipx, etc.) via brew / apt.
+async function autoInstallOptionalDeps(missing, platform) {
+  const installable = ['ffmpeg', 'sox', 'pipx', 'flock', 'curl', 'bc'];
+  const toInstall = installable.filter(dep => missing[dep]);
+  if (toInstall.length === 0) return;
+
+  if (platform === 'darwin') {
+    const brewMap = { ffmpeg: 'ffmpeg', sox: 'sox', pipx: 'pipx', flock: 'util-linux', curl: 'curl', bc: 'bc' };
+    const packages = toInstall.map(d => brewMap[d]).filter(Boolean);
+    if (packages.length === 0) return;
+    console.log(chalk.cyan(`\n📦 Homebrew: brew install ${packages.join(' ')}\n`));
+    try {
+      execFileSync('brew', ['install', ...packages], { stdio: 'inherit', env: process.env }); // NOSONAR
+      augmentPathForBrew();
+    } catch {
+      console.log(chalk.yellow('⚠️  Some Homebrew packages may have failed — continuing\n'));
+    }
+  } else if (platform === 'linux') {
+    const aptMap = { ffmpeg: ['ffmpeg'], sox: ['sox', 'libsox-fmt-mp3'], pipx: ['pipx'], flock: ['util-linux'], curl: ['curl'], bc: ['bc'] };
+    const packages = toInstall.flatMap(d => aptMap[d] || []);
+    if (packages.length === 0) return;
+    console.log(chalk.cyan(`\n📦 apt-get: sudo apt-get install -y ${packages.join(' ')}\n`));
+    try {
+      execFileSync('sudo', ['apt-get', 'update', '-qq'], { stdio: 'pipe', env: process.env }); // NOSONAR
+      execFileSync('sudo', ['apt-get', 'install', '-y', ...packages], { stdio: 'inherit', env: process.env }); // NOSONAR
+    } catch {
+      console.log(chalk.yellow('⚠️  Some apt packages may have failed — continuing\n'));
+    }
+  }
+}
+
 /**
  * Check if WSL is installed on Windows
  */
@@ -163,26 +256,37 @@ function updateClaudeConfig(agentVibesPath, provider, apiKey = null) {
  * Install Piper TTS
  */
 async function installPiper(useWSL = false) {
-  const spinner = ora('Installing Piper TTS...').start();
+  const platform = os.platform();
 
+  // Ensure pipx is present before attempting piper-tts install
+  if (!useWSL && !commandExists('pipx')) {
+    console.log(chalk.yellow('\n⚠️  pipx not found — installing it first...\n'));
+    const ok = await ensurePipx(platform);
+    if (!ok) {
+      console.log(chalk.red('❌ Could not install pipx automatically.'));
+      if (platform === 'darwin') {
+        console.log(chalk.cyan('   brew install pipx'));
+      } else {
+        console.log(chalk.cyan('   sudo apt install pipx'));
+      }
+      console.log(chalk.gray('   Then re-run this installer.\n'));
+      return false;
+    }
+    console.log(chalk.green('✓ pipx ready\n'));
+  }
+
+  console.log(chalk.cyan('\n📦 Installing Piper TTS via pipx...\n'));
   try {
-    // Security: Use execFileSync with array args to prevent command injection
+    // Security: execFileSync with array args prevents command injection
     if (useWSL) {
       execFileSync('wsl', ['pipx', 'install', 'piper-tts'], { stdio: 'inherit' });
     } else {
-      execFileSync('pipx', ['install', 'piper-tts'], { stdio: 'inherit' });
+      execFileSync('pipx', ['install', 'piper-tts'], { stdio: 'inherit', env: process.env }); // NOSONAR
     }
-    spinner.succeed('Piper TTS installed successfully!');
+    console.log(chalk.green('\n✅ Piper TTS installed!\n'));
     return true;
   } catch (error) {
-    spinner.fail('Failed to install Piper TTS');
-    console.error(chalk.yellow('\n⚠️  You may need to install pipx first:'));
-    if (useWSL) {
-      console.log(chalk.cyan('   wsl sudo apt install pipx'));
-    } else {
-      console.log(chalk.cyan('   brew install pipx  (macOS)'));
-      console.log(chalk.cyan('   sudo apt install pipx  (Linux)'));
-    }
+    console.log(chalk.red(`\n❌ Failed to install Piper TTS: ${error.message}\n`));
     return false;
   }
 }
@@ -227,6 +331,7 @@ async function checkSystemDependencies() {
     return;
   }
 
+  const platform = os.platform();
   const hasCoreMissing = depResults.missing.node || depResults.missing.python || depResults.missing.bash;
 
   if (hasCoreMissing) {
@@ -234,7 +339,35 @@ async function checkSystemDependencies() {
     process.exit(1);
   }
 
-  // Only optional dependencies missing
+  // Optional deps missing — offer auto-install on Mac/Linux
+  const canAutoInstall = (platform === 'darwin' && brewExists()) || platform === 'linux';
+
+  if (canAutoInstall) {
+    const mgr = platform === 'darwin' ? 'Homebrew' : 'apt-get';
+    const { doInstall } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'doInstall',
+      message: `Install missing optional dependencies now using ${mgr}?`,
+      default: true
+    }]);
+
+    if (doInstall) {
+      await autoInstallOptionalDeps(depResults.missing, platform);
+      const recheckResults = checkDependencies();
+      const stillMissing = Object.values(recheckResults.missing).some(Boolean);
+      if (stillMissing) {
+        console.log(chalk.yellow('⚠️  Some dependencies could not be installed automatically.\n'));
+        displayMissingDependencies(recheckResults);
+      } else {
+        console.log(chalk.green('✓ All optional dependencies installed\n'));
+      }
+      return;
+    }
+  } else if (platform === 'darwin' && !brewExists()) {
+    console.log(chalk.yellow('ℹ️  Homebrew not found — install it from https://brew.sh to get ffmpeg and other tools automatically.\n'));
+  }
+
+  // Fall through: ask to continue without the missing deps
   const { continueAnyway } = await inquirer.prompt([{
     type: 'confirm',
     name: 'continueAnyway',
@@ -243,7 +376,7 @@ async function checkSystemDependencies() {
   }]);
 
   if (!continueAnyway) {
-    console.log(chalk.yellow('\nInstallation cancelled. Please install the dependencies and try again.\n'));
+    console.log(chalk.yellow('\nInstallation cancelled. Install the missing dependencies and try again.\n'));
     process.exit(0);
   }
 }
@@ -389,6 +522,121 @@ async function setupPythonDependencies(isWindows) {
   }
 }
 
+/**
+ * Interactive voice download step shown after Piper installs.
+ * Offers starter, libritts-900, full pack, or skip.
+ * @param {string} agentVibesDir - Path to the AgentVibes installation directory
+ * @returns {Promise<void>}
+ */
+async function downloadPiperVoices(agentVibesDir) {
+  console.log(chalk.bold('\n🎙️  Step 4b: Download Voice Models\n'));
+
+  // Skip if voices are already present — respect PIPER_VOICES_DIR override so we
+  // check the same directory the runtime will use.
+  const homeDir = os.homedir();
+  const voiceDir = process.env.PIPER_VOICES_DIR || path.join(homeDir, '.claude', 'piper-voices');
+  try {
+    if (fs.existsSync(voiceDir)) {
+      const onnxFiles = fs.readdirSync(voiceDir).filter(f => f.endsWith('.onnx'));
+      // Only count voices where both .onnx and .onnx.json exist and are non-empty
+      const completeVoices = onnxFiles.filter(f => {
+        try {
+          const onnxStat = fs.statSync(path.join(voiceDir, f));
+          const jsonStat = fs.statSync(path.join(voiceDir, f + '.json'));
+          return onnxStat.size > 0 && jsonStat.size > 0;
+        } catch { return false; }
+      });
+      if (completeVoices.length > 0) {
+        console.log(chalk.green(`✓ ${completeVoices.length} voice model(s) already installed — skipping download\n`));
+        return;
+      }
+    }
+  } catch { /* ignore, fall through to download prompt */ }
+
+  console.log(chalk.gray('Piper needs at least one voice model to speak.\n'));
+
+  const { voiceChoice } = await inquirer.prompt([{
+    type: 'list',
+    name: 'voiceChoice',
+    message: 'Which voices would you like to download?',
+    choices: [
+      {
+        name: chalk.cyan('Starter voice') + chalk.gray(' — en_US-lessac-medium (~13 MB, download in seconds)'),
+        value: 'starter',
+        short: 'Starter'
+      },
+      {
+        name: chalk.cyan('LibriTTS 900-speaker pack') + chalk.gray(' — en_US-libritts-high (~57 MB, 900 unique named speakers)'),
+        value: 'libritts',
+        short: 'LibriTTS 900'
+      },
+      {
+        name: chalk.cyan('Full pack') + chalk.gray(' — 11 voices including LibriTTS (~250 MB, all BMAD agent voices)'),
+        value: 'full',
+        short: 'Full pack'
+      },
+      {
+        name: chalk.gray('Skip — download voices later with /agent-vibes:add'),
+        value: 'skip',
+        short: 'Skip'
+      }
+    ]
+  }]);
+
+  if (voiceChoice === 'skip') {
+    console.log(chalk.yellow('\n⚠️  No voices downloaded.'));
+    console.log(chalk.gray('   Download voices anytime with: ') + chalk.cyan('/agent-vibes:add\n'));
+    return;
+  }
+
+  const voiceManagerScript = path.join(agentVibesDir, '.claude', 'hooks', 'piper-voice-manager.sh');
+  const fullPackScript = path.join(agentVibesDir, '.claude', 'hooks', 'piper-download-voices.sh');
+
+  if (voiceChoice === 'starter') {
+    console.log(chalk.cyan('\n📥 Downloading en_US-lessac-medium (~13 MB)...\n'));
+    try {
+      // Use positional params ($1/$2) so the script path is never string-interpolated
+      execFileSync('bash', ['-c', 'source "$1" && download_voice "$2"', '--', voiceManagerScript, 'en_US-lessac-medium'], { // NOSONAR
+        stdio: 'inherit',
+        env: process.env
+      });
+      console.log(chalk.green('\n✅ Starter voice ready!\n'));
+    } catch {
+      console.log(chalk.yellow('\n⚠️  Download failed — try later with: /agent-vibes:add\n'));
+    }
+  } else if (voiceChoice === 'libritts') {
+    console.log(chalk.cyan('\n📥 Downloading LibriTTS 900-speaker pack (~57 MB)...\n'));
+    console.log(chalk.gray('   This gives you 900 individually named speakers to choose from.\n'));
+    try {
+      execFileSync('bash', ['-c', 'source "$1" && download_voice "$2"', '--', voiceManagerScript, 'en_US-libritts-high'], { // NOSONAR
+        stdio: 'inherit',
+        env: process.env
+      });
+      console.log(chalk.green('\n✅ LibriTTS 900-speaker pack ready!'));
+      console.log(chalk.gray('   Browse speakers with: ') + chalk.cyan('/agent-vibes:list\n'));
+    } catch {
+      console.log(chalk.yellow('\n⚠️  Download failed — try later with: /agent-vibes:add\n'));
+    }
+  } else if (voiceChoice === 'full') {
+    console.log(chalk.cyan('\n📥 Downloading full voice pack (~250 MB)...\n'));
+    console.log(chalk.gray('   This includes all BMAD agent voices plus LibriTTS 900 speakers.\n'));
+    try {
+      if (fs.existsSync(fullPackScript)) {
+        execFileSync('bash', [fullPackScript, '--yes'], { // NOSONAR
+          stdio: 'inherit',
+          env: process.env
+        });
+        console.log(chalk.green('\n✅ Full voice pack downloaded!\n'));
+      } else {
+        console.log(chalk.yellow('   Download script not found at: ' + fullPackScript));
+        console.log(chalk.yellow('   Try: /agent-vibes:add\n'));
+      }
+    } catch {
+      console.log(chalk.yellow('\n⚠️  Download failed — try later with: /agent-vibes:add\n'));
+    }
+  }
+}
+
 /**
  * Display welcome banner
  * @param {string} platform - Platform name
@@ -433,7 +681,8 @@ function showSuccessMessage(configPath, provider) {
   console.log(chalk.gray(`  ${configPath}\n`));
 
   if (provider === 'piper') {
-    console.log(chalk.gray('Voice models will download automatically on first use.\n'));
+    console.log(chalk.gray('Browse voices: ') + chalk.cyan('/agent-vibes:list') + '\n');
+    console.log(chalk.gray('Add more voices: ') + chalk.cyan('/agent-vibes:add') + '\n');
   }
 }
 
@@ -457,6 +706,11 @@ export async function installMCP() {
   // Step 4: Choose TTS provider
   const provider = await setupTTSProvider(isWindows);
 
+  // Step 4b: Download voices if Piper was selected
+  if (provider === 'piper') {
+    await downloadPiperVoices(agentVibesDir);
+  }
+
   // Step 5: Install Python dependencies
   await setupPythonDependencies(isWindows);
 
@@ -468,7 +722,7 @@ export async function installMCP() {
 
   // Step 7: Update Claude Desktop config
   console.log(chalk.bold('📝 Step 7: Updating Claude Desktop configuration...\n'));
-  const configPath = updateClaudeConfig(agentVibesDir, provider, apiKey);
+  const configPath = updateClaudeConfig(agentVibesDir, provider);
   console.log(chalk.green(`✓ Updated: ${configPath}\n`));
 
   // Success!

package/src/console/app.js

@@ -238,9 +238,9 @@ export class AgentVibesConsole {
     // Right-aligned: git remote + branch when available, else AgentVibes repo link
     let topRightContent = `{${BRAND_PINK}-fg}github.com/preibisch/agentvibes{/${BRAND_PINK}-fg}`;
     try {
-      const branchResult = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'],
+      const branchResult = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], // NOSONAR
         { encoding: 'utf8', timeout: 2000, cwd });
-      const remoteResult = spawnSync('git', ['remote', 'get-url', 'origin'],
+      const remoteResult = spawnSync('git', ['remote', 'get-url', 'origin'], // NOSONAR
         { encoding: 'utf8', timeout: 2000, cwd });
       if (branchResult.status === 0 && remoteResult.status === 0) {
         const branch = branchResult.stdout.trim();
@@ -627,7 +627,7 @@ export class AgentVibesConsole {
   _createFooter() {
     // Detect installed providers inline (same logic as ProviderService)
     const _has = (bin) => {
-      try { execFileSync('which', [bin], { stdio: 'ignore', timeout: 2000 }); return true; }
+      try { execFileSync('which', [bin], { stdio: 'ignore', timeout: 2000 }); return true; } // NOSONAR
       catch { return false; }
     };
     const detected = {

package/src/console/audio-env.js

@@ -121,7 +121,10 @@ function _detect(players, env) {
  * @returns {string|null}
  */
 export function detectRemoteLlm() {
-  const cfgPath = path.join(os.homedir(), '.agentvibes', 'transport-config.json');
+  // process.env.HOME takes priority over os.homedir() so tests can inject a fake home on all platforms.
+  // On Windows production use, HOME is typically unset, so os.homedir() (reads USERPROFILE) is the fallback.
+  const homeDir = process.env.HOME ?? os.homedir();
+  const cfgPath = path.join(homeDir, '.agentvibes', 'transport-config.json');
   if (!fs.existsSync(cfgPath)) return null;
   try {
     const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));