infinicode 2.8.100 → 2.8.103

package/dist/robopark/add-robot.d.ts

@@ -4,6 +4,8 @@ import { type ExplicitContextOpts } from './profile.js';
 export interface AddRobotOptions extends ExplicitContextOpts {
     name: string;
     start?: boolean;
+    autoStart?: boolean;
+    yes?: boolean;
     /** Force a specific park-map pad/character preset id instead of the
      * fuzzy name-based match below — e.g. `--character jaguar`. */
     character?: string;

package/dist/robopark/add-robot.js

@@ -24,8 +24,32 @@
 import chalk from 'chalk';
 import { resolveContext } from './profile.js';
 import { roboparkSetup } from './setup.js';
-async function mintEnrollmentToken(schedulerUrl, name, characterId) {
-    const url = `${schedulerUrl.replace(/\/$/, '')}/api/devices`;
+function robotReachableSchedulerUrl(schedulerUrl, hubUrl) {
+    if (!hubUrl)
+        return schedulerUrl;
+    try {
+        // Port 8080 is intentionally private to the hub. Enrollment, character
+        // lookup, heartbeats, and robot sessions must all use the authenticated
+        // mesh proxy, whether the hidden scheduler is loopback or a 192.168.x.x
+        // address that is only meaningful on the hub's own LAN.
+        new URL(schedulerUrl);
+        new URL(hubUrl);
+        return `${hubUrl.replace(/\/+$/, '')}/robopark`;
+    }
+    catch {
+        // Keep the original value so the existing request reports a useful error.
+    }
+    return schedulerUrl;
+}
+function schedulerApiUrl(schedulerUrl, path, token) {
+    const url = new URL(`${schedulerUrl.replace(/\/+$/, '')}${path}`);
+    if (token && url.pathname.startsWith('/robopark/')) {
+        url.searchParams.set('token', token);
+    }
+    return url.toString();
+}
+async function mintEnrollmentToken(schedulerUrl, name, characterId, token) {
+    const url = schedulerApiUrl(schedulerUrl, '/api/devices', token);
     const res = await fetch(url, {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
@@ -37,10 +61,10 @@ async function mintEnrollmentToken(schedulerUrl, name, characterId) {
     }
     return (await res.json());
 }
-async function pickCharacterPreset(schedulerUrl, name) {
+async function pickCharacterPreset(schedulerUrl, name, token) {
     const lower = name.toLowerCase();
     try {
-        const res = await fetch(`${schedulerUrl.replace(/\/$/, '')}/api/character-presets`);
+        const res = await fetch(schedulerApiUrl(schedulerUrl, '/api/character-presets', token));
         if (!res.ok)
             return undefined;
         const presets = (await res.json());
@@ -83,11 +107,16 @@ export async function roboparkAddRobot(config, opts) {
         console.log(chalk.red('  ✗ no scheduler URL resolved. Pass --scheduler-url/--hub-url, run `robopark hub-use` first, or run this on/near the hub.'));
         process.exit(1);
     }
-    console.log(`  scheduler: ${chalk.cyan(ctx.schedulerUrl)}`);
+    const schedulerUrl = robotReachableSchedulerUrl(ctx.schedulerUrl, ctx.hubUrl);
+    if (schedulerUrl.endsWith('/robopark') && !ctx.token) {
+        console.log(chalk.red('  ✗ hub mesh token is required to use the scheduler proxy. Pass --token or run `robopark hub-use` first.'));
+        process.exit(1);
+    }
+    console.log(`  scheduler: ${chalk.cyan(schedulerUrl)}`);
     console.log(`  name:      ${chalk.cyan(opts.name)}${ctx.site ? chalk.dim('  @ ' + ctx.site) : ''}`);
     console.log(`  network:   ${chalk.cyan(network)}`);
     console.log();
-    const characterId = opts.character?.trim() || await pickCharacterPreset(ctx.schedulerUrl, opts.name);
+    const characterId = opts.character?.trim() || await pickCharacterPreset(schedulerUrl, opts.name, ctx.token);
     if (characterId) {
         console.log(`  character: ${chalk.cyan(characterId)}${opts.character ? chalk.dim(' (forced via --character)') : chalk.dim(' (auto-matched)')}`);
     }
@@ -96,7 +125,7 @@ export async function roboparkAddRobot(config, opts) {
     }
     let minted;
     try {
-        minted = await mintEnrollmentToken(ctx.schedulerUrl, opts.name, characterId);
+        minted = await mintEnrollmentToken(schedulerUrl, opts.name, characterId, ctx.token);
     }
     catch (e) {
         console.log(chalk.red(`  ✗ failed to mint enrollment token: ${e.message}`));
@@ -120,6 +149,8 @@ export async function roboparkAddRobot(config, opts) {
             schedulerPort: ctx.schedulerUrl ? String(new URL(ctx.schedulerUrl).port || '8080') : undefined,
             enrollmentToken: minted.enrollment_token,
             start: true,
+            autoStart: opts.autoStart !== false,
+            yes: opts.yes !== false,
             lan: opts.lan,
             tailscale: opts.tailscale,
         });
@@ -140,7 +171,7 @@ export async function roboparkAddRobot(config, opts) {
         argv.push('--scheduler-port', schedulerPort);
     }
     argv.push(network === 'tailscale' ? '--tailscale' : '--lan');
-    argv.push('--enrollment-token', minted.enrollment_token, '--start', '--auto-start');
+    argv.push('--enrollment-token', minted.enrollment_token, '--start', '--auto-start', '--yes');
     console.log(chalk.dim(`  run this ON THE ROBOT${characterId ? ` (binds to pad: ${characterId})` : ''}:`));
     console.log('  ' + chalk.cyan(commandString(argv)));
     if (!ctx.hubUrl) {

package/dist/robopark/agent-ctl.js

@@ -115,35 +115,51 @@ function ensureRobovoiceSingleAudioTrack(path) {
         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 };
-    }
+    let updated = source;
+    let patched = false;
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    const singleTrackMarker = 'Initial greeting completed through AgentSession audio track';
     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',
-        };
+    if (!updated.includes(singleTrackMarker)) {
+        const start = updated.indexOf(startMarker);
+        const end = start >= 0 ? updated.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 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);
+        updated = updated.slice(0, start) + replacement + updated.slice(end);
+        patched = true;
     }
-    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 };
+    // The job is dispatched after the robot participant joins. Waiting for its
+    // camera adds camera startup to voice latency even though audio is ready.
+    const cameraGate = /            await asyncio\.wait_for\(robot_camera_ready\.wait\(\), timeout\s*=\s*[0-9.]+\)/;
+    if (cameraGate.test(updated)) {
+        updated = updated.replace(cameraGate, [
+            '            # The robot is already in the room when this job is dispatched.',
+            '            # Yield once for subscription signalling; do not gate voice on camera.',
+            '            await asyncio.sleep(0)',
+        ].join(newline));
+        patched = true;
+    }
+    if (patched)
+        writeFileSync(file, updated, 'utf8');
+    return { patched, file };
 }
 export async function roboparkAgentUp(opts) {
     console.log(chalk.bold('\n  robopark agent up'));

package/dist/robopark/robot-runtime.js

@@ -135,6 +135,9 @@ export async function roboparkRobotRuntime(opts) {
             // Motion remains enabled, but it reads RoboVision's shared stream. Only
             // RoboVision may open the physical V4L2 device.
             LOCAL_CAMERA_MOTION: 'true',
+            // The first production sound is the greeting. A beep would occupy the
+            // same exclusive ALSA device and delay or clip TTS.
+            ROBOPARK_MOTION_CUE: 'false',
             // Fleet hardware profile: resolve volatile ALSA hw:X,Y coordinates
             // from these USB product labels on every inventory refresh.
             ROBOPARK_AUDIO_INPUT_MATCH: 'Usb Audio Device: USB Audio',
@@ -143,8 +146,14 @@ export async function roboparkRobotRuntime(opts) {
             // only while audible robot speech is playing, then hold briefly for
             // room echo decay so VAD cannot interrupt the robot with its own voice.
             ROBOPARK_HALF_DUPLEX: 'true',
-            ROBOPARK_ECHO_TAIL_MS: '700',
+            ROBOPARK_ECHO_TAIL_MS: '350',
             ROBOPARK_ECHO_GATE_PEAK: '96',
+            // Keep ordinary speaker echo muted but reopen the microphone when a
+            // nearby voice rises decisively above the learned acoustic echo floor.
+            ROBOPARK_ADAPTIVE_BARGE_IN: 'true',
+            ROBOPARK_BARGE_IN_MIN_PEAK: '2200',
+            ROBOPARK_BARGE_IN_ECHO_RATIO: '2.4',
+            ROBOPARK_BARGE_IN_HOLD_MS: '1400',
             // Inventory changes should reach the Control Center promptly.
             HEARTBEAT_INTERVAL: '5',
         },

package/dist/robopark-cli.js

@@ -284,6 +284,8 @@ program
     .option('--lan', 'generate a robot command for the same local network (default)')
     .option('--tailscale', 'generate a robot command for a Tailscale-reachable hub')
     .option('--start', 'start the robot node on this machine now, instead of printing the one-liner')
+    .option('--auto-start', 'register the robot runtime to start on boot')
+    .option('--yes', 'non-interactive production setup')
     .action(async (name, opts) => {
     await roboparkAddRobot(config, { name, ...opts });
 });

package/docs/ROBOPARK_PRODUCTION_MEMORY.md

@@ -212,3 +212,29 @@ Required result: `playback_started  ok`.
 - `ROBOPARK_HALF_DUPLEX`, `ROBOPARK_ECHO_TAIL_MS`, and
   `ROBOPARK_ECHO_GATE_PEAK` are explicit runtime controls. Disable half-duplex
   only after deploying real acoustic echo cancellation.
+
+## Instant Greeting Contract (2.8.101+)
+
+- Motion reporting is asynchronous and never delays session allocation.
+- RoboVision's shared camera stream is not stopped or reopened on a trigger.
+- The old fixed 500 ms trigger delay is removed.
+- The local motion beep is disabled by default because it occupies the same
+  exclusive ALSA speaker as TTS. `ROBOPARK_MOTION_CUE=true` is diagnostics only.
+- The voice worker uses the persistent AgentSession audio track and starts the
+  greeting after robot join; it does not wait for camera subscription.
+- Network, scheduler, LiveKit, and TTS synthesis still impose real latency, but
+  RoboPark adds no intentional serial delay before greeting generation.
+
+## Adaptive Interruption Contract (2.8.102+)
+
+- The preset greeting remains non-interruptible so ambient startup noise cannot
+  cancel it before the first audible frame.
+- Normal responses retain LiveKit AgentSession interruption handling.
+- Robot half-duplex suppression learns the microphone's active speaker-echo
+  floor. Three consecutive near-field peaks above both the absolute threshold
+  and the adaptive echo ratio reopen microphone PCM for the VAD.
+- The barge-in window remains open for 1.4 seconds, allowing LiveKit to cancel
+  TTS; ordinary speaker echo remains suppressed with the existing decay tail.
+- Vision responses inherit the selected voice-stack output language. With an
+  automatic profile, the original user transcript language is authoritative,
+  including direct terminal vision-tool responses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.100",
+  "version": "2.8.103",
   "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

@@ -3192,6 +3192,93 @@ PIPELINE_STAGES = (
 )
 PIPELINE_STATUSES = {"pending", "running", "ok", "failed", "blocked", "skipped"}
 
+PIPELINE_STAGE_LABELS = {
+    "robot_online": "Robot online",
+    "camera_ready": "Camera detected",
+    "microphone_ready": "Microphone detected",
+    "speaker_ready": "Speaker detected",
+    "motion_detected": "Waiting for motion",
+    "scheduler_session": "Allocating session",
+    "livekit_join": "Joining LiveKit",
+    "camera_published": "Publishing camera",
+    "microphone_published": "Publishing microphone",
+    "voice_worker": "Starting voice worker",
+    "stt_listening": "Listening to visitor",
+    "llm_response": "Preparing response",
+    "tts_subscribed": "Preparing robot voice",
+    "playback_started": "Speaking through robot",
+    "motor_sequence": "Running motor sequence",
+    "session_ended": "Closing session",
+}
+
+
+def _pipeline_current_state(events: list[dict], *, active: bool,
+                            production_mode: bool, online: bool) -> dict:
+    """Derive one operator-facing live stage from persistent pipeline events."""
+    if not online:
+        return {
+            "stage": "robot_online", "status": "blocked",
+            "label": PIPELINE_STAGE_LABELS["robot_online"],
+            "message": "Robot heartbeat is stale or missing", "since": None,
+        }
+    if not active:
+        return {
+            "stage": "motion_detected",
+            "status": "waiting" if production_mode else "paused",
+            "label": "Armed - waiting for motion" if production_mode else "Production paused",
+            "message": "Motion detection is armed" if production_mode else "Enable production mode to arm this robot",
+            "since": None,
+        }
+
+    scoped = [event for event in events if event.get("session_id")]
+    for event in reversed(scoped):
+        if event.get("status") in {"failed", "blocked"}:
+            return {
+                "stage": event["stage"], "status": event["status"],
+                "label": PIPELINE_STAGE_LABELS.get(event["stage"], event["stage"]),
+                "message": event.get("message") or "Pipeline requires attention",
+                "since": event.get("timestamp"),
+            }
+
+    conversational = {
+        "voice_worker", "stt_listening", "llm_response", "tts_subscribed",
+        "playback_started", "motor_sequence",
+    }
+    latest = next((event for event in reversed(scoped) if event.get("stage") in conversational), None)
+    if latest:
+        stage = latest["stage"]
+        status = latest.get("status") or "running"
+        if status in {"ok", "skipped"}:
+            stage = {
+                "voice_worker": "stt_listening",
+                "stt_listening": "llm_response",
+                "llm_response": "tts_subscribed",
+                "tts_subscribed": "playback_started",
+                "playback_started": "stt_listening",
+                "motor_sequence": "stt_listening",
+            }.get(stage, stage)
+            status = "active"
+        return {
+            "stage": stage, "status": status,
+            "label": PIPELINE_STAGE_LABELS.get(stage, stage),
+            "message": latest.get("message") or PIPELINE_STAGE_LABELS.get(stage, stage),
+            "since": latest.get("timestamp"),
+        }
+
+    startup = (
+        "scheduler_session", "livekit_join", "camera_published",
+        "microphone_published", "voice_worker",
+    )
+    completed = {event.get("stage") for event in scoped if event.get("status") in {"ok", "skipped"}}
+    stage = next((candidate for candidate in startup if candidate not in completed), "voice_worker")
+    latest_startup = next((event for event in reversed(scoped) if event.get("stage") in startup), None)
+    return {
+        "stage": stage, "status": "active",
+        "label": PIPELINE_STAGE_LABELS.get(stage, stage),
+        "message": (latest_startup or {}).get("message") or "Production conversation is starting",
+        "since": (latest_startup or {}).get("timestamp"),
+    }
+
 async def _insert_pipeline_event(device_id: str, payload: PipelineEventPayload) -> dict:
     if payload.stage not in PIPELINE_STAGES:
         raise HTTPException(422, f"Unknown pipeline stage: {payload.stage}")
@@ -3286,16 +3373,29 @@ async def robot_pipeline_status(robot_id: str, limit: int = 80):
         blockers.append("Microphone inventory has not been reported")
     if not prereqs["speaker_ready"]:
         blockers.append("Speaker inventory has not been reported")
+    active = bool(latest_session and not latest_session["ended_at"])
+    active_session_id = latest_session["id"] if active else None
+    current_events = [
+        event for event in events
+        if not active_session_id or event.get("session_id") == active_session_id
+    ]
+    current_stage = _pipeline_current_state(
+        current_events,
+        active=active,
+        production_mode=bool(device["production_mode"]),
+        online=prereqs["robot_online"],
+    )
     return {
         "robot_id": device_id,
         "robot_name": device["name"],
-        "overall": "blocked" if blockers else ("running" if latest_session and not latest_session["ended_at"] else "ready"),
+        "overall": "blocked" if blockers else ("running" if active else "ready"),
         "blockers": list(dict.fromkeys(blockers)),
         "prerequisites": prereqs,
         "telemetry": telemetry,
         "latest_session": dict(latest_session) if latest_session else None,
         "events": events,
         "stages": list(PIPELINE_STAGES),
+        "current_stage": current_stage,
     }
 
 @app.get("/api/robots/{robot_id}/pipeline-history")
@@ -5019,6 +5119,53 @@ async def delete_character_preset(preset_id: str):
     return {"ok": True}
 
 
+class PresetPosition(BaseModel):
+    id: str
+    nx: float
+    ny: float
+
+
+class PresetPositionBatch(BaseModel):
+    positions: List[PresetPosition]
+
+
+@app.put("/api/character-presets/positions")
+async def update_preset_positions(payload: PresetPositionBatch):
+    """Batch-update (id, nx, ny) for the Park map. nx/ny are the
+    normalized [0,1] pad coordinates the dashboard uses to place each
+    robot on the iso park. Bounded + persisted so an operator can
+    Ctrl+drag a robot on the Park map and have its position survive
+    a refresh, server restart, or robot reconnect.
+
+    Designed for small, infrequent updates (a single drag releases
+    one robot, plus an occasional "reset all" tool). The endpoint
+    intentionally ignores all other preset fields — only the
+    coordinates move; voice stack, name, system prompt, etc. are
+    owned by the character-preset editor and are not touched here.
+    """
+    if not payload.positions:
+        return {"updated": 0}
+    now = datetime.utcnow().isoformat()
+    updated = 0
+    async with aiosqlite.connect(DB_PATH) as db:
+        for p in payload.positions:
+            if not p.id:
+                continue
+            # Clamp nx/ny to the visible pad rectangle so a stray
+            # drag can't park a robot off the island. A small inner
+            # margin (0.04) keeps the avatar fully on the grass and
+            # clear of the gold wall on the perimeter.
+            nx = max(0.04, min(0.96, float(p.nx)))
+            ny = max(0.04, min(0.96, float(p.ny)))
+            cur = await db.execute(
+                "UPDATE character_presets SET nx = ?, ny = ?, updated_at = ? WHERE id = ?",
+                (nx, ny, now, p.id),
+            )
+            updated += cur.rowcount or 0
+        await db.commit()
+    return {"updated": updated}
+
+
 class RobotVoiceConfigUpdate(BaseModel):
     character_preset_id: Optional[str] = None
     voice_stack_id: Optional[str] = None
@@ -5123,13 +5270,20 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
 
     device_inventory = parse_json_field(device["device_inventory"], {}) if device else {}
     supervisor_status = parse_json_field(device["supervisor_status"], []) if device else []
-    session = None
-    if robot["current_session_id"]:
+    session = None
+    current_pipeline_events = []
+    if robot["current_session_id"]:
         async with db.execute(
             "SELECT started_at, last_activity_at, ended_at FROM sessions WHERE id = ?",
             (robot["current_session_id"],),
-        ) as c:
-            session = await c.fetchone()
+        ) as c:
+            session = await c.fetchone()
+        async with db.execute(
+            "SELECT * FROM pipeline_events WHERE robot_id = ? AND session_id = ? "
+            "ORDER BY timestamp, id",
+            (robot_id, robot["current_session_id"]),
+        ) as c:
+            current_pipeline_events = [dict(row) for row in await c.fetchall()]
 
     now = datetime.utcnow()
     session_age = None
@@ -5212,8 +5366,14 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         (robot_id,),
     ) as c:
         end_reasons = {r["end_reason"]: r["n"] for r in await c.fetchall()}
-    drops = sum(n for reason, n in end_reasons.items() if reason in ABNORMAL_END_REASONS)
-    drop_rate = round(drops / sessions_total, 4) if sessions_total else 0.0
+    drops = sum(n for reason, n in end_reasons.items() if reason in ABNORMAL_END_REASONS)
+    drop_rate = round(drops / sessions_total, 4) if sessions_total else 0.0
+    current_stage = _pipeline_current_state(
+        current_pipeline_events,
+        active=bool(robot["current_session_id"] and session and not session["ended_at"]),
+        production_mode=bool(device["production_mode"]) if device else False,
+        online=heartbeat_age is not None and heartbeat_age <= 30,
+    )
 
     return {
         "robot_id": robot_id,
@@ -5244,9 +5404,13 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         "supervisor_status": supervisor_status,
         "supervisor_status_at": device["supervisor_status_at"] if device else None,
         "production_mode": bool(device["production_mode"]) if device else False,
-        "readiness_code": readiness_code,
-        "readiness_message": readiness_message,
-    }
+        "readiness_code": readiness_code,
+        "readiness_message": readiness_message,
+        "current_stage": current_stage,
+        "current_stage_id": current_stage["stage"],
+        "current_stage_label": current_stage["label"],
+        "current_stage_status": current_stage["status"],
+    }
 
 @app.get("/api/robots/{robot_id}/telemetry")
 async def robot_telemetry(robot_id: str):

package/packages/robopark/scheduler/preview_agent.py

@@ -541,12 +541,17 @@ class PreviewAgent:
         self.vision_trigger_cooldown = float(cfg.get("vision_trigger_cooldown", os.getenv("VISION_TRIGGER_COOLDOWN", DEFAULT_VISION_TRIGGER_COOLDOWN)))
         self.vision_session_seconds = float(cfg.get("vision_session_seconds", os.getenv("VISION_SESSION_SECONDS", DEFAULT_VISION_SESSION_SECONDS)))
         self.vision_silence_timeout = float(cfg.get("vision_silence_timeout", os.getenv("VISION_SILENCE_TIMEOUT", DEFAULT_VISION_SILENCE_TIMEOUT)))
-        self.local_camera_motion = str(
+        self.local_camera_motion = str(
             # Production needs an always-on detector. The preview publisher
             # remains the single camera owner when a session starts, so this
             # does not require the separate OpenCV vision server.
             cfg.get("local_camera_motion", os.getenv("LOCAL_CAMERA_MOTION", "true"))
-        ).lower() in ("1", "true", "yes", "on")
+        ).lower() in ("1", "true", "yes", "on")
+        # The character greeting is the production acknowledgement. A local
+        # motion beep serializes on the same ALSA output and delays allocation.
+        self.motion_cue_enabled = str(
+            cfg.get("motion_cue_enabled", os.getenv("ROBOPARK_MOTION_CUE", "false"))
+        ).lower() in ("1", "true", "yes", "on")
 
         self._shutdown = asyncio.Event()
         self._task: Optional[asyncio.Task] = None
@@ -1178,20 +1183,19 @@ class PreviewAgent:
             logger.warning("vision motion event received but not enrolled yet — ignoring")
             return
         self._vision_trigger_in_flight = True
-        await self._report_pipeline("motion_detected", "ok", f"Motion received from {payload.get('source', 'camera')}", once=False)
+        # Observability must not add a scheduler round trip before the actual
+        # session request. The reporter handles and logs its own errors.
+        asyncio.create_task(self._report_pipeline(
+            "motion_detected", "ok",
+            f"Motion received from {payload.get('source', 'camera')}", once=False,
+        ))
         logger.info("motion detected by RoboVisionAI_PI — requesting a session")
-        # The cue is feedback only; never block session allocation on speaker
-        await self._stop_motion_capture()
-        # DirectShow can return a stale handle for a short interval after
-        # release. Give the driver time to finish teardown before reopening it
-        # for the LiveKit publisher.
-        await asyncio.sleep(0.5)
-        # I/O. Camera/mic join and the preset greeting are the critical path.
-        # The cue and TTS share one physical ALSA output. Finish and release
-        # the cue before LiveKit can deliver the greeting; background playback
-        # races aplay and makes greeting delivery intermittently fail busy.
-        async with self._speaker_operation_lock:
-            await asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "motion")
+        # RoboVision owns the physical camera and exposes a shared stream, so
+        # there is no capture handle to tear down and no reason to sleep here.
+        if self.motion_cue_enabled:
+            logger.warning("ROBOPARK_MOTION_CUE is enabled; the diagnostic cue adds greeting latency")
+            async with self._speaker_operation_lock:
+                await asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "motion")
         try:
             r = await self._session.post(
                 f"{self.scheduler_url.rstrip('/')}/api/devices/{self.device_id}/request-session",
@@ -1294,8 +1298,24 @@ class LiveKitPublisher:
         )
         self._speaker_playback_active = threading.Event()
         self._speaker_gate_until = 0.0
+        self._speaker_started_at = 0.0
+        self._barge_in_until = 0.0
+        self._echo_mic_floor = 0.0
+        self._barge_in_candidate_frames = 0
         self._speaker_echo_tail = max(
-            0.1, min(float(os.getenv("ROBOPARK_ECHO_TAIL_MS", "700")) / 1000.0, 2.0)
+            0.1, min(float(os.getenv("ROBOPARK_ECHO_TAIL_MS", "350")) / 1000.0, 2.0)
+        )
+        self._adaptive_barge_in = str(
+            os.getenv("ROBOPARK_ADAPTIVE_BARGE_IN", "true")
+        ).lower() in ("1", "true", "yes", "on")
+        self._barge_in_min_peak = max(
+            256, min(int(os.getenv("ROBOPARK_BARGE_IN_MIN_PEAK", "2200")), 20000)
+        )
+        self._barge_in_ratio = max(
+            1.25, min(float(os.getenv("ROBOPARK_BARGE_IN_ECHO_RATIO", "2.4")), 8.0)
+        )
+        self._barge_in_hold = max(
+            0.4, min(float(os.getenv("ROBOPARK_BARGE_IN_HOLD_MS", "1400")) / 1000.0, 3.0)
         )
         # Motion sampling state belongs to the publisher instance.  Keeping it
         # initialized here prevents shutdown/reopen paths from raising while
@@ -1533,7 +1553,7 @@ class LiveKitPublisher:
         import threading
         write_queue: "queue.Queue[Optional[bytes]]" = queue.Queue()
         written_frames = [0]
-        PREBUFFER_CHUNKS = 5
+        PREBUFFER_CHUNKS = 3
         stream_failed = threading.Event()
         playback_reported = threading.Event()
         event_loop = asyncio.get_running_loop()
@@ -1553,6 +1573,10 @@ class LiveKitPublisher:
         def _open_echo_gate() -> None:
             if not self._half_duplex:
                 return
+            if not self._speaker_playback_active.is_set():
+                self._speaker_started_at = time.monotonic()
+                self._echo_mic_floor = 0.0
+                self._barge_in_candidate_frames = 0
             self._speaker_playback_active.set()
             self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
 
@@ -1841,11 +1865,40 @@ class LiveKitPublisher:
                 _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]
+                    now = time.monotonic()
                     echo_gate_active = self._half_duplex and (
                         self._speaker_playback_active.is_set()
-                        or time.monotonic() < self._speaker_gate_until
+                        or now < self._speaker_gate_until
                     )
-                    if echo_gate_active:
+                    # Learn the microphone's speaker-echo floor while output is
+                    # active. A nearby visitor speaking produces a fast peak well
+                    # above that floor; reopen the mic briefly so LiveKit VAD can
+                    # cancel normal TTS. The initial 300 ms remains protected.
+                    _, raw_peak = _pcm16_scale_and_peak(chunk, 1.0)
+                    if echo_gate_active and self._adaptive_barge_in:
+                        if self._echo_mic_floor <= 0:
+                            self._echo_mic_floor = float(raw_peak)
+                        else:
+                            self._echo_mic_floor = self._echo_mic_floor * 0.92 + raw_peak * 0.08
+                        threshold = max(
+                            self._barge_in_min_peak,
+                            int(self._echo_mic_floor * self._barge_in_ratio),
+                        )
+                        warmed = now - self._speaker_started_at >= 0.3
+                        if warmed and raw_peak >= threshold:
+                            self._barge_in_candidate_frames += 1
+                        else:
+                            self._barge_in_candidate_frames = 0
+                        if self._barge_in_candidate_frames >= 3:
+                            if now >= self._barge_in_until:
+                                logger.info(
+                                    "audio_loop: adaptive barge-in opened mic "
+                                    "(peak=%d threshold=%d echo_floor=%d)",
+                                    raw_peak, threshold, int(self._echo_mic_floor),
+                                )
+                            self._barge_in_until = now + self._barge_in_hold
+                    barge_in_active = self._adaptive_barge_in and now < self._barge_in_until
+                    if echo_gate_active and not barge_in_active:
                         # Preserve 20 ms frame cadence; only suppress content.
                         # Stopping publication would create gaps and destabilize
                         # VAD/endpointing when listening resumes.