infinicode 2.8.85 → 2.8.87

package/dist/robopark/agent-ctl.js

@@ -18,7 +18,7 @@
  * registration mechanics is reimplemented here.
  */
 import { spawn, execFile } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { hostname, networkInterfaces } from 'node:os';
 import { join } from 'node:path';
 import chalk from 'chalk';
@@ -103,6 +103,48 @@ function validateComposePath(path) {
     throw new Error(`no docker-compose.yaml/.yml found in '${path}'. Pass --path pointing at a ROBOVOICE checkout ` +
         `(the directory containing docker-compose.yaml), not this repo.`);
 }
+/** Persist the single-track greeting fix in a ROBOVOICE checkout. */
+function ensureRobovoiceSingleAudioTrack(path) {
+    const candidates = [
+        join(path, 'voice_agent.py'),
+        join(path, 'app', 'voice_agent.py'),
+        join(path, 'src', 'voice_agent.py'),
+    ];
+    const file = candidates.find((candidate) => existsSync(candidate));
+    if (!file) {
+        return { patched: false, warning: 'voice_agent.py was not found; skipping RoboPark greeting compatibility patch' };
+    }
+    const source = readFileSync(file, 'utf8');
+    if (source.includes('Initial greeting completed through AgentSession audio track')) {
+        return { patched: false, file };
+    }
+    const startMarker = '            # Synthesize the greeting first';
+    const endMarker = '        except Exception as e:';
+    const start = source.indexOf(startMarker);
+    const end = start >= 0 ? source.indexOf(endMarker, start) : -1;
+    if (start < 0 || end < 0) {
+        return {
+            patched: false,
+            file,
+            warning: 'voice_agent.py does not contain the known duplicate greeting-track block; no automatic patch applied',
+        };
+    }
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    const replacement = [
+        '            # Use the existing conversation track. A dedicated greeting',
+        '            # track makes Linux robots compete for the same ALSA device.',
+        '            import inspect as _inspect',
+        '            speech = session.say(greeting, allow_interruptions=False)',
+        '            if _inspect.isawaitable(speech):',
+        '                await speech',
+        "            elif hasattr(speech, 'wait_for_playout'):",
+        '                await speech.wait_for_playout()',
+        "            logger.info('Initial greeting completed through AgentSession audio track')",
+        '',
+    ].join(newline);
+    writeFileSync(file, source.slice(0, start) + replacement + source.slice(end), 'utf8');
+    return { patched: true, file };
+}
 export async function roboparkAgentUp(opts) {
     console.log(chalk.bold('\n  robopark agent up'));
     console.log(chalk.dim('  ' + '─'.repeat(52)));
@@ -125,8 +167,18 @@ export async function roboparkAgentUp(opts) {
     console.log(chalk.dim(`  using: ${compose.cmd} ${compose.baseArgs.join(' ')}`.trimEnd()));
     console.log(`  path:  ${chalk.cyan(opts.path)}`);
     console.log();
+    const greetingPatch = ensureRobovoiceSingleAudioTrack(opts.path);
+    if (greetingPatch.patched) {
+        console.log(chalk.green(`  ✓ persisted single-track RoboPark greeting in ${greetingPatch.file}`));
+    }
+    else if (greetingPatch.warning) {
+        console.log(chalk.yellow(`  ⚠ ${greetingPatch.warning}`));
+    }
     console.log(chalk.bold('  1. starting ROBOVOICE docker stack (docker compose up -d)…'));
-    const upCode = await runCompose(compose, ['up', '-d'], opts.path);
+    // Rebuild only when compatibility source changed, making the fix survive
+    // container recreation without slowing normal restarts.
+    const upArgs = greetingPatch.patched ? ['up', '-d', '--build'] : ['up', '-d'];
+    const upCode = await runCompose(compose, upArgs, opts.path);
     if (upCode !== 0) {
         console.log(chalk.red(`\n  ✗ docker compose up -d exited with code ${upCode}`));
         process.exit(upCode);

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/docs/ROBOPARK_PRODUCTION_MEMORY.md

@@ -0,0 +1,111 @@
+# RoboPark Production Memory
+
+Last verified: 2026-07-16
+
+This records production facts future operators and coding agents must
+preserve. Never add enrollment tokens, mesh tokens, API keys, or device tokens.
+
+## Verified Architecture
+
+- `livekit-1` is the Windows hub.
+- Mesh/dashboard: TCP `47913`.
+- RoboPark scheduler: TCP `8080`, proxied under `/robopark`.
+- LiveKit: TCP `7880`.
+- Production voice worker container: `caal-agent`.
+- BMW maps to device `dev_0422e545` and character `vixen` / `VIXEN (BMW)`.
+- Robots publish camera and microphone tracks to LiveKit. Park camera preview
+  uses the RoboVision relay rather than LiveKit video.
+
+## BMW Launch Device Lock
+
+- Camera: `/dev/video0` (`H65 USB CAMERA`).
+- Microphone: scheduler ID `2`, `Usb Audio Device: USB Audio (hw:3,0)`.
+- Speaker: scheduler ID `1`, `USB Audio Device: - (hw:2,0)`.
+- Linux live playback must use ALSA `plughw:2,0` through `aplay`.
+- Production mic gain defaults to `ROBOPARK_MIC_GAIN=4.0` and is bounded to
+  `1.0..12.0` before PCM frames enter LiveKit.
+- RoboVision/sounddevice numeric IDs are not PyAudio numeric IDs.
+- Do not use HDMI or metadata-only `/dev/video*` devices as launch defaults.
+
+## Verified Production Flow
+
+BMW passed these measured stages in one production session:
+
+1. `scheduler_session`
+2. `livekit_join`
+3. `tts_subscribed`
+4. `playback_started`
+5. `camera_published`
+6. `microphone_published`
+7. `robot_online`
+8. `camera_ready`
+9. `microphone_ready`
+10. `speaker_ready`
+
+`playback_started` means the first remote TTS frame reached the robot. Never
+report end-to-end audio delivery without this event.
+
+## Root Causes Fixed
+
+### Silent Greeting
+
+The old ROBOVOICE greeting published a second dedicated LiveKit audio track.
+The Pi subscribed to both tracks and attempted to open the same speaker twice.
+ROBOVOICE must call `session.say(...)` so greeting and conversation share one
+track. `robopark agent-up` now detects the old source block, patches the
+ROBOVOICE checkout, and rebuilds Compose once.
+
+### Linux Speaker Playback
+
+The preview agent previously used PyAudio for the selected speaker. BMW's
+proven output is ALSA `aplay -D plughw:2,0`. Infinicode `2.8.86` uses that
+same endpoint for live TTS whenever a Linux output selection contains `hw:`.
+
+### Silent Conversation After Greeting
+
+Publishing a LiveKit microphone track does not prove that PCM capture started.
+On Linux the production capture path is `arecord -D plughw:3,0 -f S16_LE -r
+48000 -c 1`; it must work even when PyAudio is unavailable. The Pi now waits
+for actual PCM frames before reporting `microphone_published`, reports a blocked
+stage when capture does not start within five seconds, and applies bounded mic
+gain before publication.
+
+### Duplicate Speaker Tests
+
+Only one robot process may claim a scheduler `speaker_test`. The scheduler
+uses an atomic lease, and supervisor-status queries exclude speaker-test rows.
+
+### BMW Alias Configuration
+
+Scheduler routes canonicalize alias `bmw` to `dev_0422e545` before reading
+character, voice-stack, and greeting configuration.
+
+## Operational Rules
+
+- Run one unified robot runtime per robot. Do not manually start preview,
+  vision, or mesh beside the systemd runtime.
+- Do not run audio diagnostics during a live conversation.
+- A direct ALSA test does not validate production if production uses another
+  API, index space, sample format, or opens the device twice.
+- After a hub reboot, verify `47913`, `8080`, and `7880` before robot media.
+- `tts_subscribed` alone is insufficient; require `playback_started`.
+- Greeting `playback_started` alone does not prove conversation. A complete
+  turn also requires a user/STT event, an LLM response, and response playback.
+- Container-local changes are temporary. Persist voice changes in the
+  ROBOVOICE checkout/image or use `robopark agent-up --path <checkout>`.
+
+## Minimal Verification
+
+Run from the hub:
+
+```powershell
+try { Invoke-RestMethod -Method Post http://127.0.0.1:8080/api/robots/bmw/pipeline-test/stop | Out-Null } catch {}
+Start-Sleep 3
+Invoke-RestMethod -Method Post http://127.0.0.1:8080/api/robots/bmw/pipeline-test/start | Out-Null
+Start-Sleep 30
+$s = Invoke-RestMethod http://127.0.0.1:8080/api/robots/bmw/pipeline-status
+$id = $s.latest_session.id
+$s.events | Where-Object session_id -eq $id | Select-Object timestamp,stage,status,message
+```
+
+Required result: `playback_started  ok`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.85",
+  "version": "2.8.87",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",
@@ -29,8 +29,9 @@
     "static",
     "packages/robopark/scheduler",
     "packages/robopark/pi-client",
-    "packages/robopark/vision",
-    ".opencode/plugins",
+    "packages/robopark/vision",
+    "docs/ROBOPARK_PRODUCTION_MEMORY.md",
+    ".opencode/plugins",
     ".opencode/themes",
     ".opencode/tui.json",
     "README.md"

package/packages/robopark/README.md

@@ -1,4 +1,7 @@
-# robopark
+# robopark
+
+Production architecture, device locks, verified stages, and incident memory
+are recorded in [`../../docs/ROBOPARK_PRODUCTION_MEMORY.md`](../../docs/ROBOPARK_PRODUCTION_MEMORY.md).
 
 The **RoboPark fleet control CLI** — set up, watch, and drive a room full of
 talking robots from one command. `robopark` is the operator front-end; it rides

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}")
@@ -3317,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()]
@@ -3696,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}
 
 
@@ -4171,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:
@@ -4204,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

package/packages/robopark/scheduler/preview_agent.py

@@ -1134,6 +1134,7 @@ class LiveKitPublisher:
         self._tasks: list[asyncio.Task] = []
         self._capture: Optional["VideoCapture"] = None
         self._mic_capture: Optional["AudioCapture"] = None
+        self._mic_streaming = asyncio.Event()
         # Motion sampling state belongs to the publisher instance.  Keeping it
         # initialized here prevents shutdown/reopen paths from raising while
         # the camera is being handed between preview and voice sessions.
@@ -1212,13 +1213,12 @@ class LiveKitPublisher:
             self.video_source.capture_frame(first_frame)
             await self.agent._report_pipeline("camera_published", "ok", "Camera track published")
 
-        if audio_enabled:
-            self.audio_source = self.rtc.AudioSource(48000, 1)
-            self.audio_track = self.rtc.LocalAudioTrack.create_audio_track("microphone", self.audio_source)
-            aopts = self.rtc.TrackPublishOptions()
-            aopts.source = self.rtc.TrackSource.SOURCE_MICROPHONE
+        if audio_enabled:
+            self.audio_source = self.rtc.AudioSource(48000, 1)
+            self.audio_track = self.rtc.LocalAudioTrack.create_audio_track("microphone", self.audio_source)
+            aopts = self.rtc.TrackPublishOptions()
+            aopts.source = self.rtc.TrackSource.SOURCE_MICROPHONE
             await self.room.local_participant.publish_track(self.audio_track, aopts)
-            await self.agent._report_pipeline("microphone_published", "ok", "Microphone track published")
 
         # Register speaker playback (subscribe to the voice agent's TTS audio
         # track) BEFORE opening the camera. Camera open is a slow/occasionally
@@ -1227,50 +1227,111 @@ class LiveKitPublisher:
         # entire event loop — including receiving the agent's greeting audio
         # — until it finished, so a short "Hello friend!" greeting could be
         # over and gone before we ever got a chance to subscribe to it.
-        if has_audio() and audio_enabled:
-            self._tasks.append(asyncio.create_task(self._audio_loop()))
+        if audio_enabled:
+            self._tasks.append(asyncio.create_task(self._audio_loop()))
+            try:
+                await asyncio.wait_for(self._mic_streaming.wait(), timeout=5.0)
+                await self.agent._report_pipeline(
+                    "microphone_published", "ok", "Microphone track published with live PCM frames"
+                )
+            except asyncio.TimeoutError:
+                await self.agent._report_pipeline(
+                    "microphone_published", "blocked", "Microphone track published but PCM capture did not start"
+                )
+                raise RuntimeError(f"microphone capture did not start for {self.agent.audio_capture_device}")
 
         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 +1470,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()
@@ -1505,7 +1567,8 @@ class LiveKitPublisher:
         samples_per_frame = int(48000 * frame_ms / 1000)
         samples_per_batch = int(48000 * BATCH_MS / 1000)
         bytes_per_frame = samples_per_frame * 2  # int16 mono
-        import audioop
+        import audioop
+        mic_gain = max(1.0, min(float(os.getenv("ROBOPARK_MIC_GAIN", "4.0")), 12.0))
         _diag_peak = 0
         _diag_count = 0
         _diag_last_log = time.monotonic()
@@ -1521,11 +1584,14 @@ class LiveKitPublisher:
                 data = bytes(batch.data)
                 _pub_start = time.monotonic()
                 for off in range(0, len(data) - bytes_per_frame + 1, bytes_per_frame):
-                    chunk = data[off:off + bytes_per_frame]
-                    frame = self.rtc.AudioFrame(
+                    chunk = data[off:off + bytes_per_frame]
+                    if mic_gain != 1.0:
+                        chunk = audioop.mul(chunk, 2, mic_gain)
+                    frame = self.rtc.AudioFrame(
                         data=chunk, sample_rate=48000, num_channels=1, samples_per_channel=samples_per_frame,
                     )
-                    await self.audio_source.capture_frame(frame)
+                    await self.audio_source.capture_frame(frame)
+                    self._mic_streaming.set()
                     p = audioop.max(chunk, 2)
                     _diag_peak = max(_diag_peak, p)
                     _diag_count += 1