infinicode 2.8.86 → 2.8.88

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

@@ -0,0 +1,119 @@
+# 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.
+
+### Camera Relay With Multiple Viewers
+
+RoboVision must have exactly one OpenCV camera reader. Preview, dashboard, and
+motion detection consume a shared latest-frame stream. Starting one
+`generate_frames()` camera loop per MJPEG client causes concurrent
+`VideoCapture.read()` calls, which can block the second client and make the hub
+relay time out with zero bytes.
+
+### 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.86",
+  "version": "2.8.88",
   "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/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,8 +1227,18 @@ 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()))
@@ -1557,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()
@@ -1573,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

package/packages/robopark/vision/app_pi_clean.py

@@ -18,6 +18,11 @@ CORS(app)
 # Camera management
 current_camera_index = 0
 camera = None
+camera_lock = threading.Lock()
+frame_condition = threading.Condition()
+latest_frame_bytes = None
+latest_frame_sequence = 0
+camera_worker_started = False
 audio_input_device = "default"
 audio_output_device = "default"
 ROBOVISION_AUDIO_URL = os.getenv("ROBOVISION_AUDIO_URL", "http://127.0.0.1:8000")
@@ -224,22 +229,25 @@ def send_webhook(frame_data):
     except Exception as e:
         print(f"Error preparing webhook: {e}")
 
-def generate_frames():
-    global latest_detections, motion_detection_active, motion_detected_state
-    global last_motion_time, motion_frame_buffer
-
-    prev_gray = None
-
-    while True:
-        cam = get_camera()
-        if cam is None or not cam.isOpened():
-            time.sleep(1)
-            continue
-
-        success, frame = cam.read()
-        if not success:
-            time.sleep(0.1)
-            continue
+def camera_worker():
+    global latest_detections, motion_detection_active, motion_detected_state
+    global last_motion_time, motion_frame_buffer
+    global latest_frame_bytes, latest_frame_sequence
+
+    prev_gray = None
+
+    while True:
+        with camera_lock:
+            cam = get_camera()
+        if cam is None or not cam.isOpened():
+            time.sleep(1)
+            continue
+
+        with camera_lock:
+            success, frame = cam.read()
+        if not success:
+            time.sleep(0.1)
+            continue
 
         # Run object detection
         processed_frame, detections = detect_objects(frame, conf_threshold=0.5)
@@ -288,11 +296,40 @@ def generate_frames():
 
             prev_gray = gray
 
-        ret, buffer = cv2.imencode('.jpg', processed_frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
-        frame_bytes = buffer.tobytes()
-
-        yield (b'--frame\r\n'
-               b'Content-Type: image/jpeg\r\n\r\n' + frame_bytes + b'\r\n')
+        ret, buffer = cv2.imencode('.jpg', processed_frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
+        if not ret:
+            continue
+        with frame_condition:
+            latest_frame_bytes = buffer.tobytes()
+            latest_frame_sequence += 1
+            frame_condition.notify_all()
+
+
+def _ensure_camera_worker():
+    global camera_worker_started
+    with frame_condition:
+        if camera_worker_started:
+            return
+        camera_worker_started = True
+    threading.Thread(target=camera_worker, name='robovision-camera', daemon=True).start()
+
+
+def generate_frames():
+    _ensure_camera_worker()
+    sequence = -1
+    while True:
+        with frame_condition:
+            frame_condition.wait_for(
+                lambda: latest_frame_bytes is not None and latest_frame_sequence != sequence,
+                timeout=5.0,
+            )
+            if latest_frame_bytes is None or latest_frame_sequence == sequence:
+                continue
+            frame_bytes = latest_frame_bytes
+            sequence = latest_frame_sequence
+
+        yield (b'--frame\r\n'
+               b'Content-Type: image/jpeg\r\n\r\n' + frame_bytes + b'\r\n')
 
 @app.route('/')
 def index():
@@ -379,11 +416,11 @@ def switch_camera():
     if isinstance(new_index, str) and new_index.isdigit():
         new_index = int(new_index)
 
-    if camera:
-        camera.release()
-
-    current_camera_index = new_index
-    camera = None
+    with camera_lock:
+        if camera:
+            camera.release()
+        current_camera_index = new_index
+        camera = None
 
     return jsonify({"status": "ok", "camera_index": current_camera_index})