infinicode 2.8.84 → 2.8.86

package/dist/robopark/serve.js

@@ -9,7 +9,8 @@
  */
 import chalk from 'chalk';
 import { spawn, execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 function pkgDir() {
@@ -68,6 +69,33 @@ function findPython() {
     // ENOENT/"not found" error from the OS rather than a silent fallback.
     return process.platform === 'win32' ? 'python' : 'python3';
 }
+function resolveSchedulerDataDir(explicit) {
+    if (explicit)
+        return explicit;
+    if (process.env.SCHEDULER_DATA_DIR)
+        return process.env.SCHEDULER_DATA_DIR;
+    const stable = join(homedir(), '.robopark', 'scheduler');
+    const stableDb = join(stable, 'scheduler.db');
+    if (existsSync(stableDb))
+        return stable;
+    // Older releases stored data beside whichever npm installation launched
+    // the scheduler. Local, global and npx installs therefore created separate
+    // databases. Migrate the largest existing DB once into stable user storage.
+    const legacyCandidates = [join(pkgDir(), '..', 'data')];
+    if (process.platform === 'win32' && process.env.APPDATA) {
+        legacyCandidates.push(join(process.env.APPDATA, 'npm', 'node_modules', 'data'));
+    }
+    const legacy = legacyCandidates
+        .filter((candidate, index, all) => all.indexOf(candidate) === index)
+        .filter(candidate => existsSync(join(candidate, 'scheduler.db')))
+        .sort((a, b) => statSync(join(b, 'scheduler.db')).size - statSync(join(a, 'scheduler.db')).size)[0];
+    mkdirSync(stable, { recursive: true });
+    if (legacy) {
+        cpSync(legacy, stable, { recursive: true, force: false, errorOnExist: false });
+        console.log(chalk.yellow(`  migrated scheduler data: ${legacy} -> ${stable}`));
+    }
+    return stable;
+}
 /** Resolve the actual infinicode CLI entry point so `robopark setup --start`
  *  works even when global bins are not on PATH.
  *
@@ -110,6 +138,7 @@ export async function roboparkServe(opts) {
     const python = findPython();
     const schedulerDir = dirname(schedulerPath);
     const requirements = join(schedulerDir, 'requirements.txt');
+    const dataDir = resolveSchedulerDataDir(opts.dataDir);
     // Ensure scheduler Python dependencies are installed before starting.
     if (existsSync(requirements)) {
         console.log(chalk.dim('  ensuring scheduler Python deps…'));
@@ -125,7 +154,7 @@ export async function roboparkServe(opts) {
         ...process.env,
         SCHEDULER_HOST: host,
         SCHEDULER_PORT: String(port),
-        SCHEDULER_DATA_DIR: opts.dataDir ?? join(pkgDir(), '..', 'data'),
+        SCHEDULER_DATA_DIR: dataDir,
     };
     if (opts.gateway)
         env.INFINIBOT_GATEWAY_URL = opts.gateway;
@@ -138,6 +167,7 @@ export async function roboparkServe(opts) {
     console.log(`  scheduler: ${chalk.cyan(schedulerPath)}`);
     console.log(`  python:    ${chalk.cyan(python)}`);
     console.log(`  listen:    ${chalk.cyan(`${host}:${port}`)}`);
+    console.log(`  data:      ${chalk.cyan(dataDir)}`);
     if (opts.gateway)
         console.log(`  gateway:   ${chalk.cyan(opts.gateway)}`);
     console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.84",
+  "version": "2.8.86",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/main.py

@@ -604,6 +604,9 @@ async def init_db():
             ("sessions", "voice_stack_id", "TEXT"),
             ("sessions", "initiated_by", "TEXT"),
             ("sessions", "event_token_hash", "TEXT"),
+            # Speaker tests are executed only by preview_agent, which can
+            # release and restore the active media publisher around ALSA I/O.
+            ("shell_requests", "claimed_at", "TEXT"),
         ):
             try:
                 await db.execute(f"ALTER TABLE {_table} ADD COLUMN {_column} {_coldef}")
@@ -839,10 +842,70 @@ async def broadcast(event_type: str, data: dict):
             ws_clients.remove(client)
 
 # =============================================================================
-# ROBOT ENDPOINTS
-# =============================================================================
-
-@app.get("/api/robots", response_model=List[Robot])
+# ROBOT ENDPOINTS
+# =============================================================================
+
+CONNECTING_SESSION_LEASE_SECONDS = max(
+    15, int(os.getenv("ROBOPARK_CONNECTING_SESSION_LEASE_SECONDS", "45"))
+)
+ACTIVE_SESSION_LEASE_SECONDS = max(
+    CONNECTING_SESSION_LEASE_SECONDS,
+    int(os.getenv("ROBOPARK_ACTIVE_SESSION_LEASE_SECONDS", "180")),
+)
+
+
+async def _reap_robot_session_if_stale(db, robot_id: str, current_session_id: Optional[str],
+                                       robot_status: Optional[str] = None) -> Optional[str]:
+    """Release an invalid or expired session pointer without operator action."""
+    if not current_session_id:
+        return None
+
+    async with db.execute(
+        "SELECT id, started_at, last_activity_at, ended_at FROM sessions WHERE id = ?",
+        (current_session_id,),
+    ) as cursor:
+        session = await cursor.fetchone()
+
+    reason = None
+    if not session:
+        reason = "missing_session"
+    elif session["ended_at"]:
+        reason = "ended_session"
+    else:
+        timestamp = session["last_activity_at"] or session["started_at"]
+        try:
+            activity_age = (datetime.utcnow() - datetime.fromisoformat(timestamp)).total_seconds()
+        except (TypeError, ValueError):
+            activity_age = ACTIVE_SESSION_LEASE_SECONDS + 1
+        lease = (
+            CONNECTING_SESSION_LEASE_SECONDS
+            if robot_status == "connecting"
+            else ACTIVE_SESSION_LEASE_SECONDS
+        )
+        if activity_age >= lease:
+            reason = "stale_connecting" if robot_status == "connecting" else "stale_activity"
+
+    if not reason:
+        return None
+
+    now = datetime.utcnow().isoformat()
+    if session and not session["ended_at"]:
+        await db.execute(
+            "UPDATE sessions SET ended_at = ?, end_reason = ? WHERE id = ? AND ended_at IS NULL",
+            (now, reason, current_session_id),
+        )
+    await db.execute(
+        "UPDATE robots SET status = 'idle', current_session_id = NULL, connected_server_id = NULL "
+        "WHERE id = ? AND current_session_id = ?",
+        (robot_id, current_session_id),
+    )
+    logger.warning(
+        "Automatically released %s session %s for robot %s",
+        reason, current_session_id, robot_id,
+    )
+    return reason
+
+@app.get("/api/robots", response_model=List[Robot])
 async def list_robots():
     """List all robots"""
     async with aiosqlite.connect(DB_PATH) as db:
@@ -909,11 +972,23 @@ async def request_session(robot_id: str,
                     (robot_id, device_row["name"]),
                 )
                 await db.commit()
-                robot = {"id": robot_id, "name": device_row["name"], "status": "idle"}
-            else:
-                raise HTTPException(404, "Robot not found")
-            if robot["status"] != "idle":
-                raise HTTPException(400, f"Robot is {robot['status']}, not idle")
+                robot = {
+                    "id": robot_id,
+                    "name": device_row["name"],
+                    "status": "idle",
+                    "current_session_id": None,
+                }
+            else:
+                raise HTTPException(404, "Robot not found")
+        stale_reason = await _reap_robot_session_if_stale(
+            db, robot_id, robot["current_session_id"], robot["status"]
+        )
+        if stale_reason:
+            await db.commit()
+            async with db.execute("SELECT * FROM robots WHERE id = ?", (robot_id,)) as cursor:
+                robot = await cursor.fetchone()
+        if robot["current_session_id"] or robot["status"] != "idle":
+            raise HTTPException(409, f"Robot is {robot['status']}, not idle")
         
         # Find least-loaded online server
         async with db.execute("""
@@ -1046,7 +1121,7 @@ async def simulate_trigger(robot_id: str):
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
         async with db.execute(
-            "SELECT id, current_session_id FROM robots WHERE id = ?", (robot_id,)
+            "SELECT id, current_session_id, status FROM robots WHERE id = ?", (robot_id,)
         ) as c:
             robot = await c.fetchone()
         if not robot:
@@ -1059,11 +1134,14 @@ async def simulate_trigger(robot_id: str):
                 (device["id"], device["name"], device["character_id"]),
             )
             await db.commit()
-            robot = {"id": device["id"], "current_session_id": None}
+            robot = {"id": device["id"], "current_session_id": None, "status": "idle"}
         if not await _effective_device_production_mode(db, robot_id):
             return {"queued": False, "reason": "device_production_mode_off"}
-        if robot["current_session_id"]:
-            return {"queued": False, "reason": "session_active"}
+        stale_reason = await _reap_robot_session_if_stale(
+            db, robot_id, robot["current_session_id"], robot["status"]
+        )
+        if robot["current_session_id"] and not stale_reason:
+            return {"queued": False, "reason": "session_active"}
         await db.execute(
             "INSERT INTO trigger_commands (robot_id, source, requested_at) VALUES (?, ?, ?) "
             "ON CONFLICT(robot_id) DO UPDATE SET source = excluded.source, requested_at = excluded.requested_at",
@@ -1072,7 +1150,12 @@ async def simulate_trigger(robot_id: str):
         await db.commit()
     await broadcast("robot_triggered", {"robot_id": robot_id, "source": "dashboard"})
     await _log_history("robot", "robot", robot_id, "simulate_trigger", "operator")
-    return {"queued": True, "source": "dashboard"}
+    return {
+        "queued": True,
+        "source": "dashboard",
+        "recovered_stale_session": bool(stale_reason),
+        "recovery_reason": stale_reason,
+    }
 
 @app.post("/api/robots/{robot_id}/simulate-stop")
 async def simulate_stop(robot_id: str):
@@ -1487,14 +1570,31 @@ async def session_joined(session_id: str,
             session = await c.fetchone()
         if not session:
             raise HTTPException(404, "Session not found")
-        if session["joined_at"]:
-            return {
-                "status": "already_joined",
-                "joined_at": session["joined_at"],
-                "latency_ms": _session_latency_ms(session["started_at"], session["joined_at"]),
-            }
-        await db.execute("UPDATE sessions SET joined_at = ? WHERE id = ?", (now, session_id))
-        await db.commit()
+        if session["joined_at"]:
+            if not session["ended_at"]:
+                await db.execute(
+                    "UPDATE sessions SET last_activity_at = ? WHERE id = ?",
+                    (now, session_id),
+                )
+                await db.execute(
+                    "UPDATE robots SET status = 'running' WHERE id = ? AND current_session_id = ?",
+                    (session["robot_id"], session_id),
+                )
+                await db.commit()
+            return {
+                "status": "already_joined",
+                "joined_at": session["joined_at"],
+                "latency_ms": _session_latency_ms(session["started_at"], session["joined_at"]),
+            }
+        await db.execute(
+            "UPDATE sessions SET joined_at = ?, last_activity_at = ? WHERE id = ?",
+            (now, now, session_id),
+        )
+        await db.execute(
+            "UPDATE robots SET status = 'running' WHERE id = ? AND current_session_id = ?",
+            (session["robot_id"], session_id),
+        )
+        await db.commit()
     latency_ms = _session_latency_ms(session["started_at"], now)
     await broadcast("session_joined", {"session_id": session_id, "latency_ms": latency_ms})
     await _log_history("session", "session", session_id, "joined", "robot", f"latency_ms={latency_ms}")
@@ -1955,19 +2055,38 @@ async def health_checker():
                     await db.execute("UPDATE devices SET status = 'offline' WHERE id = ?", (did,))
                     await broadcast("device_status_changed", {"device_id": did, "status": "offline"})
 
-                # Reap sessions leaked by a crashed worker or broken LiveKit
-                # disconnect. Normal sessions are closed by the worker, but
-                # this prevents stale rooms consuming server capacity forever.
-                session_cutoff = (datetime.utcnow() - timedelta(seconds=120)).isoformat()
-                async with db.execute(
-                    "SELECT id, robot_id FROM sessions "
-                    "WHERE ended_at IS NULL AND COALESCE(last_activity_at, started_at) < ?",
-                    (session_cutoff,),
-                ) as c:
+                # Release stale robot session pointers with the same lease rules
+                # used by the trigger path. Failed joins cannot require manual
+                # operator recovery or block an unattended robot indefinitely.
+                async with db.execute(
+                    "SELECT id, status, current_session_id FROM robots WHERE current_session_id IS NOT NULL"
+                ) as c:
+                    session_owners = await c.fetchall()
+                for owner in session_owners:
+                    reason = await _reap_robot_session_if_stale(
+                        db, owner["id"], owner["current_session_id"], owner["status"]
+                    )
+                    if reason:
+                        await broadcast("session_expired", {
+                            "session_id": owner["current_session_id"],
+                            "robot_id": owner["id"],
+                            "reason": reason,
+                        })
+
+                # Reap old orphan rows that are no longer owned by a robot.
+                session_cutoff = (
+                    datetime.utcnow() - timedelta(seconds=ACTIVE_SESSION_LEASE_SECONDS)
+                ).isoformat()
+                async with db.execute(
+                    "SELECT id, robot_id FROM sessions "
+                    "WHERE ended_at IS NULL AND COALESCE(last_activity_at, started_at) < ? "
+                    "AND NOT EXISTS (SELECT 1 FROM robots r WHERE r.current_session_id = sessions.id)",
+                    (session_cutoff,),
+                ) as c:
                     stale_sessions = await c.fetchall()
                 for session in stale_sessions:
                     await db.execute(
-                        "UPDATE sessions SET ended_at = ?, end_reason = 'silence' "
+                        "UPDATE sessions SET ended_at = ?, end_reason = 'stale_orphan' "
                         "WHERE id = ? AND ended_at IS NULL",
                         (datetime.utcnow().isoformat(), session["id"]),
                     )
@@ -1979,7 +2098,7 @@ async def health_checker():
                     await broadcast("session_expired", {
                         "session_id": session["id"],
                         "robot_id": session["robot_id"],
-                        "reason": "silence",
+                            "reason": "stale_orphan",
                     })
 
                 await db.commit()
@@ -3201,8 +3320,9 @@ async def device_supervisor_status(device_id: str, payload: SupervisorStatusRepo
         pending = []
         try:
             async with db.execute(
-                "SELECT service_name, action, kind, params, id FROM shell_requests "
-                "WHERE device_id = ? AND completed_at IS NULL ORDER BY requested_at",
+                "SELECT service_name, action, kind, params, id FROM shell_requests "
+                "WHERE device_id = ? AND completed_at IS NULL AND kind != 'speaker_test' "
+                "ORDER BY requested_at",
                 (device_id,),
             ) as c:
                 shell_rows = [dict(r) for r in await c.fetchall()]
@@ -3580,13 +3700,26 @@ async def next_device_speaker_test(device_id: str, authorization: Optional[str]
     """Allow the always-running preview agent to execute audio tests."""
     if not await _authorize_device(device_id, authorization):
         raise HTTPException(401, "Invalid device token")
+    now = datetime.utcnow()
+    stale_before = (now - timedelta(seconds=45)).isoformat()
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
+        await db.execute("BEGIN IMMEDIATE")
         async with db.execute(
             "SELECT id, params FROM shell_requests WHERE device_id = ? AND kind = 'speaker_test' "
-            "AND completed_at IS NULL ORDER BY requested_at LIMIT 1", (device_id,),
+            "AND completed_at IS NULL AND (claimed_at IS NULL OR claimed_at < ?) "
+            "ORDER BY requested_at LIMIT 1", (device_id, stale_before),
         ) as cursor:
             row = await cursor.fetchone()
+        if row:
+            claimed = await db.execute(
+                "UPDATE shell_requests SET claimed_at = ? WHERE id = ? AND completed_at IS NULL "
+                "AND (claimed_at IS NULL OR claimed_at < ?)",
+                (now.isoformat(), row["id"], stale_before),
+            )
+            if claimed.rowcount != 1:
+                row = None
+        await db.commit()
     return {"request": {"id": row["id"], "params": json.loads(row["params"] or "{}")} if row else None}
 
 
@@ -4055,25 +4188,35 @@ async def _auto_elevenlabs_voice(robot_name: Optional[str], current: Optional[st
 
 
 async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
-    """Public helper to resolve the effective voice config for a robot id."""
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        stack_dict = await _resolve_voice_stack_for_robot(db, robot_id)
+    """Public helper to resolve the effective voice config for a robot id."""
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        # Dashboard routes commonly use the human robot name ("bmw"), while
+        # assignments are persisted against the enrolled device id. Resolve
+        # that alias once so character, stack and greetings use one identity.
+        async with db.execute(
+            "SELECT id FROM devices WHERE id = ? OR lower(name) = lower(?) "
+            "ORDER BY CASE WHEN id = ? THEN 0 ELSE 1 END LIMIT 1",
+            (robot_id, robot_id, robot_id),
+        ) as c:
+            canonical_device = await c.fetchone()
+        canonical_id = canonical_device["id"] if canonical_device else robot_id
+        stack_dict = await _resolve_voice_stack_for_robot(db, canonical_id)
 
         # Determine character preset + name
         character_id = None
         character_name = None
         system_prompt = None
         async with db.execute(
-            "SELECT character_preset_id FROM robot_voice_configs WHERE robot_id = ?", (robot_id,)
+            "SELECT character_preset_id FROM robot_voice_configs WHERE robot_id = ?", (canonical_id,)
         ) as c:
             rvc = await c.fetchone()
         if rvc and rvc["character_preset_id"]:
             character_id = rvc["character_preset_id"]
         else:
             async with db.execute(
-                "SELECT character_id FROM robots WHERE id = ? UNION ALL SELECT character_id FROM devices WHERE id = ?",
-                (robot_id, robot_id),
+                "SELECT character_id FROM robots WHERE id = ? UNION ALL SELECT character_id FROM devices WHERE id = ?",
+                (canonical_id, canonical_id),
             ) as c:
                 row = await c.fetchone()
                 if row:
@@ -4088,21 +4231,23 @@ async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
                     system_prompt = row["system_prompt"]
             if not character_name:
                 async with db.execute(
-                    "SELECT name FROM robots WHERE id = ? UNION ALL SELECT name FROM devices WHERE id = ?",
-                    (robot_id, robot_id),
+                    "SELECT name FROM robots WHERE id = ? UNION ALL SELECT name FROM devices WHERE id = ?",
+                    (canonical_id, canonical_id),
                 ) as c:
                     row = await c.fetchone()
                     if row:
                         character_name = row["name"]
 
-        async with db.execute("SELECT greeting_phrases FROM devices WHERE id = ?", (robot_id,)) as c:
+        async with db.execute("SELECT greeting_phrases FROM devices WHERE id = ?", (canonical_id,)) as c:
             device_row = await c.fetchone()
         greeting_phrases = []
         if device_row and device_row["greeting_phrases"]:
             try:
                 greeting_phrases = [str(p) for p in _json.loads(device_row["greeting_phrases"]) if str(p).strip()]
-            except Exception:
-                greeting_phrases = []
+            except Exception:
+                greeting_phrases = []
+        if not greeting_phrases and (character_name or character_id):
+            greeting_phrases = [f"Hello, I am {character_name or character_id}. How can I help you?"]
         if stack_dict:
             stack_dict["tts_voice"] = await _auto_elevenlabs_voice(character_name or character_id, stack_dict.get("tts_voice"))
         voice_stack = VoiceStack(**stack_dict) if stack_dict else None
@@ -4748,10 +4893,10 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         readiness_code, readiness_message = "server_unavailable", f"LiveKit server {robot['connected_server_id']} is {server_status or 'missing'}"
     elif not robot["current_session_id"]:
         readiness_code, readiness_message = "ready", "ready for motion trigger"
-    elif robot["status"] == "connecting" and session_age is not None and session_age > 30:
-        readiness_code, readiness_message = "stuck_session", f"joining LiveKit for {session_age}s; recover robot"
-    elif activity_age is not None and activity_age > 180:
-        readiness_code, readiness_message = "stale_session", f"no session activity for {activity_age}s; recover robot"
+    elif robot["status"] == "connecting" and session_age is not None and session_age > CONNECTING_SESSION_LEASE_SECONDS:
+        readiness_code, readiness_message = "stuck_session", f"joining LiveKit for {session_age}s; automatic recovery pending"
+    elif activity_age is not None and activity_age > ACTIVE_SESSION_LEASE_SECONDS:
+        readiness_code, readiness_message = "stale_session", f"no session activity for {activity_age}s; automatic recovery pending"
     else:
         readiness_code, readiness_message = "in_session", "conversation session is active"
 

package/packages/robopark/scheduler/preview_agent.py

@@ -1233,44 +1233,95 @@ class LiveKitPublisher:
         if self._capture and self.video_source:
             self._tasks.append(asyncio.create_task(self._video_loop()))
 
-    async def _play_remote_audio(self, track, sid: str) -> None:
-        try:
-            import pyaudio
-        except Exception as e:
-            logger.warning(f"pyaudio unavailable for playback: {e}")
-            return
-        OUT_RATE = 48000
-        OUT_CHANNELS = 2
-        pa = pyaudio.PyAudio()
-        # Same MME-vs-WASAPI gotcha as mic capture (see PyAudioCapture._resolve_device):
-        # PyAudio's global default output device resolves through MME, which on this
-        # machine will accept writes and report success with zero exceptions while
-        # never actually reaching the real speakers. Prefer WASAPI's default output,
-        # which is what Windows' own volume mixer/meter is backed by.
-        output_device_index = None
+    async def _play_remote_audio(self, track, sid: str) -> None:
+        OUT_RATE = 48000
+        OUT_CHANNELS = 2
         selected_output = str(self.agent.audio_playback_device or "default")
-        if selected_output.strip().isdigit():
-            output_device_index = int(selected_output.strip())
-        try:
-            if selected_output.lower() == "default":
-                wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI)
-                idx = wasapi.get("defaultOutputDevice")
-                if idx is not None and idx >= 0:
-                    output_device_index = idx
-            elif output_device_index is None:
-                needle = selected_output.lower()
-                for i in range(pa.get_device_count()):
-                    info = pa.get_device_info_by_index(i)
-                    if info.get("maxOutputChannels", 0) > 0 and needle in str(info.get("name", "")).lower():
-                        output_device_index = i
-                        break
-        except Exception as e:
-            logger.debug(f"audio out: WASAPI default output lookup failed, using PyAudio default: {e}")
-        out = pa.open(
-            format=pyaudio.paInt16, channels=OUT_CHANNELS, rate=OUT_RATE, output=True,
-            output_device_index=output_device_index,
-            frames_per_buffer=960,
-        )
+        pa = None
+        output_device_index = None
+
+        # RoboVision inventories Linux devices through sounddevice/PortAudio,
+        # but the numeric indices are not stable across PyAudio builds. More
+        # importantly, BMW's production USB adapter is already proven through
+        # ALSA's plughw conversion path. Use that exact endpoint for live TTS
+        # instead of reopening the unrelated PyAudio index.
+        if sys.platform.startswith("linux") and "hw:" in selected_output:
+            import re
+            import subprocess
+
+            match = re.search(r"\b(hw:\d+,\d+)\b", selected_output)
+            if not match:
+                logger.warning(f"audio out: no ALSA hardware address in {selected_output!r}")
+                return
+            alsa_device = f"plug{match.group(1)}"
+            process = subprocess.Popen(
+                [
+                    "aplay", "-q", "-D", alsa_device, "-t", "raw",
+                    "-f", "S16_LE", "-r", str(OUT_RATE), "-c", str(OUT_CHANNELS),
+                ],
+                stdin=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            if process.stdin is None:
+                logger.warning(f"audio out: aplay did not expose stdin for {alsa_device}")
+                process.kill()
+                return
+
+            class _AplayOutput:
+                def write(self, chunk: bytes) -> None:
+                    if process.poll() is not None:
+                        detail = ""
+                        if process.stderr is not None:
+                            detail = process.stderr.read().decode("utf-8", errors="replace").strip()
+                        raise OSError(detail or f"aplay exited {process.returncode}")
+                    process.stdin.write(chunk)
+                    process.stdin.flush()
+
+                def stop_stream(self) -> None:
+                    if process.stdin and not process.stdin.closed:
+                        process.stdin.close()
+                    try:
+                        process.wait(timeout=2)
+                    except subprocess.TimeoutExpired:
+                        process.terminate()
+
+                def close(self) -> None:
+                    return
+
+            out = _AplayOutput()
+            output_device_index = alsa_device
+        else:
+            try:
+                import pyaudio
+            except Exception as e:
+                logger.warning(f"pyaudio unavailable for playback: {e}")
+                return
+            pa = pyaudio.PyAudio()
+            # Same MME-vs-WASAPI gotcha as mic capture (see
+            # PyAudioCapture._resolve_device): prefer the endpoint backing the
+            # Windows volume mixer instead of the silent MME default.
+            if selected_output.strip().isdigit():
+                output_device_index = int(selected_output.strip())
+            try:
+                if selected_output.lower() == "default":
+                    wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI)
+                    idx = wasapi.get("defaultOutputDevice")
+                    if idx is not None and idx >= 0:
+                        output_device_index = idx
+                elif output_device_index is None:
+                    needle = selected_output.lower()
+                    for i in range(pa.get_device_count()):
+                        info = pa.get_device_info_by_index(i)
+                        if info.get("maxOutputChannels", 0) > 0 and needle in str(info.get("name", "")).lower():
+                            output_device_index = i
+                            break
+            except Exception as e:
+                logger.debug(f"audio out: WASAPI default output lookup failed, using PyAudio default: {e}")
+            out = pa.open(
+                format=pyaudio.paInt16, channels=OUT_CHANNELS, rate=OUT_RATE, output=True,
+                output_device_index=output_device_index,
+                frames_per_buffer=960,
+            )
         logger.info(f"audio out: opened playback stream for {sid} (device_index={output_device_index})")
         frame_count = 0
         mismatch_logged = False
@@ -1409,9 +1460,10 @@ class LiveKitPublisher:
                 f"audio out: {sid} received {frame_count} frames, "
                 f"writer wrote {written_frames[0]} chunks, queue backlog at close={write_queue.qsize()}"
             )
-            out.stop_stream()
-            out.close()
-            pa.terminate()
+            out.stop_stream()
+            out.close()
+            if pa is not None:
+                pa.terminate()
 
     async def stop(self) -> None:
         self._stop_event.set()