infinicode 2.8.96 → 2.8.98

package/dist/robopark/python-env.d.ts

@@ -3,6 +3,7 @@ export declare const VISION_REQUIRED_MODULES: string[];
 export declare function findSchedulerPath(): Promise<string | null>;
 export declare function findVisionPath(): Promise<string | null>;
 export declare function findVisionAudioPath(): Promise<string | null>;
+export declare function findVisionMotorPath(): Promise<string | null>;
 export declare function findPython(): string;
 /**
  * Ensure a robot-side script's Python deps are importable, installing them

package/dist/robopark/python-env.js

@@ -42,6 +42,9 @@ export async function findVisionPath() {
 export async function findVisionAudioPath() {
     return findPackageScript('vision/audio_server_pi.py');
 }
+export async function findVisionMotorPath() {
+    return findPackageScript('vision/motor_server.py');
+}
 export function findPython() {
     const names = process.platform === 'win32'
         ? ['python', 'python3', 'py']

package/dist/robopark/robot-runtime.js

@@ -265,7 +265,7 @@ export async function roboparkRobotRuntime(opts) {
     console.log(`  robot:     ${chalk.cyan(opts.name)}`);
     console.log(`  scheduler: ${chalk.cyan(opts.schedulerUrl)}`);
     console.log(`  network:   ${chalk.cyan(network)}`);
-    console.log(`  services:  ${opts.vision === false ? 'mesh + preview' : 'mesh + RoboVision + preview'}`);
+    console.log(`  services:  ${opts.vision === false ? 'mesh + preview' : 'mesh + RoboVision camera/audio/motors + preview'}`);
     console.log();
     if (opts.enrollmentToken) {
         console.log(chalk.dim('  clearing stale device identity for fresh enrollment…'));

package/dist/robopark/vision-agent-launcher.js

@@ -7,7 +7,7 @@
  */
 import { spawn } from 'node:child_process';
 import chalk from 'chalk';
-import { findPython, findVisionPath, findVisionAudioPath, prepareRobotPython, VISION_REQUIRED_MODULES } from './python-env.js';
+import { findPython, findVisionPath, findVisionAudioPath, findVisionMotorPath, prepareRobotPython, VISION_REQUIRED_MODULES } from './python-env.js';
 const DEFAULT_VISION_PORT = 5000;
 const DEFAULT_MOTION_WEBHOOK_PORT = 5057; // must match preview-agent's --vision-webhook-port default
 function isPiArm() {
@@ -24,7 +24,7 @@ export async function roboparkVisionAgent(opts) {
     // requirements_pi_unified.txt) — pip-installing it here would fight the
     // ARM-optimized system build. Everywhere else: plain pip install works.
     const reqFile = isPiArm() ? 'requirements_vision_agent.txt' : 'requirements-demo.txt';
-    const requiredModules = isPiArm() ? [...VISION_REQUIRED_MODULES, 'fastapi', 'uvicorn', 'sounddevice', 'soundfile', 'groq'] : VISION_REQUIRED_MODULES;
+    const requiredModules = isPiArm() ? [...VISION_REQUIRED_MODULES, 'fastapi', 'uvicorn', 'sounddevice', 'soundfile', 'groq', 'lgpio'] : VISION_REQUIRED_MODULES;
     const python = prepareRobotPython(basePython, script, requiredModules, reqFile);
     if (!python)
         process.exit(1);
@@ -38,8 +38,11 @@ export async function roboparkVisionAgent(opts) {
     // Start it beside the camera service on real Pi robots so /devices and
     // /set-device remain the authoritative source for Park dropdowns.
     let audioScript = null;
-    if (isPiArm())
+    let motorScript = null;
+    if (isPiArm()) {
         audioScript = await findVisionAudioPath();
+        motorScript = await findVisionMotorPath();
+    }
     console.log(chalk.bold('\n  robopark vision-agent'));
     console.log(chalk.dim('  ' + '─'.repeat(52)));
     console.log(`  port:    ${chalk.cyan(port)}`);
@@ -47,11 +50,16 @@ export async function roboparkVisionAgent(opts) {
     console.log(`  motion:  ${motionActive ? chalk.green('armed') : chalk.dim('off')}`);
     if (audioScript)
         console.log(`  audio:   ${chalk.green('RoboVision audio server :8000')}`);
+    if (motorScript)
+        console.log(`  motors:  ${chalk.green('robot-local relay server :8001')}`);
     console.log();
     if (opts.foreground) {
         const audio = audioScript
             ? spawn(python, [audioScript], { stdio: 'inherit', env: { ...process.env, ROBOPARK_AUDIO_SERVER: '1' } })
             : null;
+        const motor = motorScript
+            ? spawn(python, [motorScript], { stdio: 'inherit', env: { ...process.env, ROBOPARK_MOTOR_HOST: '127.0.0.1' } })
+            : null;
         const camera = spawn(python, args, { stdio: 'inherit' });
         let stopping = false;
         const stopChildren = () => {
@@ -60,6 +68,7 @@ export async function roboparkVisionAgent(opts) {
             stopping = true;
             camera.kill('SIGTERM');
             audio?.kill('SIGTERM');
+            motor?.kill('SIGTERM');
         };
         process.once('SIGINT', stopChildren);
         process.once('SIGTERM', stopChildren);
@@ -77,6 +86,7 @@ export async function roboparkVisionAgent(opts) {
             };
             camera.once('close', finish);
             audio?.once('close', finish);
+            motor?.once('close', finish);
         });
         return;
     }
@@ -86,6 +96,12 @@ export async function roboparkVisionAgent(opts) {
         });
         audio.unref();
     }
+    if (motorScript) {
+        const motor = spawn(python, [motorScript], {
+            stdio: 'ignore', detached: true, env: { ...process.env, ROBOPARK_MOTOR_HOST: '127.0.0.1' },
+        });
+        motor.unref();
+    }
     const proc = spawn(python, args, {
         stdio: 'ignore',
         detached: true,

package/docs/ROBOPARK_PRODUCTION_MEMORY.md

@@ -172,3 +172,28 @@ Required result: `playback_started  ok`.
   resampling, and releases the microphone lock after every failed attempt.
 - Pipeline failures include the selected device and exact ALSA startup error.
   A flat browser meter means missing PCM, not a quiet room.
+- Remote `speaker-test` requests support `mode=mic_groundtruth`, which captures
+  through the same `arecord -D plughw:X,Y -f S16_LE -r 48000 -c 1` command
+  proven onsite and returns bytes, RMS, peak, and nonzero sample counts.
+- Python 3.13 removed `audioop`. Version 2.8.97 replaces microphone gain, peak
+  measurement, and fallback resampling with internal PCM16 helpers; production
+  capture must not import `audioop`.
+
+## Motor and Relay Contract (2.8.98+)
+
+- Each robot persists its own motor registry, timed sequences, local motor API
+  URL, and optional greeting sequence in the scheduler database.
+- The Park robot drawer is the control surface for registry edits, BCM relay
+  tests, sequence authoring, manual runs, and greeting assignment.
+- Greeting motion queues only after the robot reports `playback_started`, so
+  movement aligns with audible TTS instead of session allocation.
+- Voice agents may invoke only saved sequences for their active LiveKit room
+  through the authenticated room-scoped scheduler endpoint. They cannot submit
+  raw GPIO numbers or arbitrary shell commands.
+- The robot supervisor accepts only `127.0.0.1` or `localhost` motor APIs,
+  synchronizes the saved registry, executes nodes serially, and verifies that
+  every pulse returns to idle before advancing.
+- The motor API uses `lgpio`, accepts only registered BCM pins 2 through 27,
+  rejects duplicate assignments, limits pulses to 10 seconds, serializes all
+  actuation, and de-energizes every registered relay on errors and shutdown.
+- A missing or busy GPIO driver is a failed test, never a simulated success.

package/package.json

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

@@ -178,7 +178,10 @@ class Device(BaseModel):
     video_device: Optional[str] = None
     audio_device: Optional[str] = None
     audio_output_device: Optional[str] = None
-    greeting_phrases: List[str] = []
+    greeting_phrases: List[str] = []
+    motor_registry: List[dict] = []
+    motor_sequences: List[dict] = []
+    greeting_motor_sequence_id: Optional[str] = None
     device_inventory: Optional[dict] = None
     production_mode: bool = False
     supervisor_status: Optional[List[ServiceStatus]] = None
@@ -579,7 +582,10 @@ async def init_db():
             ("devices", "audio_device", "TEXT"),
             ("devices", "device_inventory", "TEXT"),
             ("devices", "audio_output_device", "TEXT"),
-            ("devices", "greeting_phrases", "TEXT DEFAULT '[]'"),
+            ("devices", "greeting_phrases", "TEXT DEFAULT '[]'"),
+            ("devices", "motor_registry", "TEXT DEFAULT '[]'"),
+            ("devices", "motor_sequences", "TEXT DEFAULT '[]'"),
+            ("devices", "greeting_motor_sequence_id", "TEXT"),
             # Per-robot production mode: an additional, more specific gate on
             # top of the global settings.production_mode switch. When on for
             # a given device, that robot keeps re-arming its motion-triggered
@@ -1029,9 +1035,8 @@ async def request_session(robot_id: str,
             WHERE id = ?
         """, (session_id, server["id"], robot_id))
 
-        await db.commit()
-    
-    await broadcast("session_requested", {
+        await db.commit()
+    await broadcast("session_requested", {
         "robot_id": robot_id,
         "server_id": server["id"],
         "session_id": session_id
@@ -2642,8 +2647,17 @@ def _device_row_to_model(row) -> Device:
             d["greeting_phrases"] = [str(p) for p in json.loads(greetings) if str(p).strip()]
         except (json.JSONDecodeError, TypeError):
             d["greeting_phrases"] = []
-    elif not isinstance(greetings, list):
-        d["greeting_phrases"] = []
+    elif not isinstance(greetings, list):
+        d["greeting_phrases"] = []
+    for field in ("motor_registry", "motor_sequences"):
+        value = d.get(field)
+        if isinstance(value, str):
+            try:
+                d[field] = json.loads(value)
+            except (json.JSONDecodeError, TypeError):
+                d[field] = []
+        elif not isinstance(value, list):
+            d[field] = []
     sup = d.get("supervisor_status")
     if isinstance(sup, str):
         try:
@@ -2701,7 +2715,7 @@ async def get_device(device_id: str):
                 raise HTTPException(404, "Device not found")
             return _device_row_to_model(row)
 
-class DeviceUpdate(BaseModel):
+class DeviceUpdate(BaseModel):
     name: Optional[str] = None
     character_id: Optional[str] = None
     motor_server_url: Optional[str] = None
@@ -2709,7 +2723,10 @@ class DeviceUpdate(BaseModel):
     video_device: Optional[str] = None
     audio_device: Optional[str] = None
     audio_output_device: Optional[str] = None
-    greeting_phrases: Optional[List[str]] = None
+    greeting_phrases: Optional[List[str]] = None
+    motor_registry: Optional[List[dict]] = None
+    motor_sequences: Optional[List[dict]] = None
+    greeting_motor_sequence_id: Optional[str] = None
     tailscale_ip: Optional[str] = None
     lan_ip: Optional[str] = None
     notes: Optional[str] = None
@@ -2720,7 +2737,7 @@ class DeviceUpdate(BaseModel):
 async def update_device(device_id: str, payload: DeviceUpdate):
     """Partial update for a device (character binding, addresses, notes, status)."""
     fields = {k: v for k, v in payload.model_dump(exclude_none=True).items()}
-    if "greeting_phrases" in fields:
+    if "greeting_phrases" in fields:
         fields["greeting_phrases"] = json.dumps(
             [str(p).strip() for p in fields["greeting_phrases"] if str(p).strip()][:20]
         )
@@ -2973,6 +2990,9 @@ async def bootstrap_device(
             "INSERT OR IGNORE INTO robots (id, name, status) VALUES (?, ?, 'idle')",
             (device_id, name),
         )
+    for field in ("motor_registry", "motor_sequences"):
+        if field in fields:
+            fields[field] = json.dumps(fields[field], separators=(",", ":"))
         await db.execute("UPDATE robots SET name = ? WHERE id = ?", (name, device_id))
         await db.commit()
 
@@ -3168,7 +3188,7 @@ PIPELINE_STAGES = (
     "robot_online", "camera_ready", "microphone_ready", "speaker_ready",
     "motion_detected", "scheduler_session", "livekit_join", "camera_published",
     "microphone_published", "voice_worker", "stt_listening", "llm_response",
-    "tts_subscribed", "playback_started", "session_ended",
+    "tts_subscribed", "playback_started", "motor_sequence", "session_ended",
 )
 PIPELINE_STATUSES = {"pending", "running", "ok", "failed", "blocked", "skipped"}
 
@@ -3198,7 +3218,10 @@ async def device_pipeline_event(device_id: str, payload: PipelineEventPayload,
     """Receive real pipeline stage transitions from the enrolled robot."""
     if not await _authorize_device(device_id, authorization):
         raise HTTPException(401, "Invalid device token")
-    return {"status": "ok", **(await _insert_pipeline_event(device_id, payload))}
+    result = await _insert_pipeline_event(device_id, payload)
+    if payload.stage == "playback_started" and payload.status == "ok" and payload.session_id:
+        await _queue_configured_greeting_sequence(device_id, payload.session_id)
+    return {"status": "ok", **result}
 
 @app.get("/api/robots/{robot_id}/pipeline-status")
 async def robot_pipeline_status(robot_id: str, limit: int = 80):
@@ -3275,6 +3298,72 @@ async def robot_pipeline_status(robot_id: str, limit: int = 80):
         "stages": list(PIPELINE_STAGES),
     }
 
+@app.get("/api/robots/{robot_id}/pipeline-history")
+async def robot_pipeline_history(robot_id: str, page: int = 1, page_size: int = 6):
+    """Return persistent, paged production runs for one robot."""
+    page = max(1, page)
+    page_size = max(1, min(page_size, 25))
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT id, name FROM devices WHERE id = ? OR lower(name) = lower(?) "
+            "ORDER BY last_heartbeat DESC LIMIT 1",
+            (robot_id, robot_id),
+        ) as cursor:
+            device = await cursor.fetchone()
+        if not device:
+            raise HTTPException(404, "Robot device not found")
+
+        device_id = device["id"]
+        async with db.execute(
+            "SELECT COUNT(*) FROM sessions WHERE robot_id = ?", (device_id,)
+        ) as cursor:
+            total = int((await cursor.fetchone())[0])
+        pages = max(1, (total + page_size - 1) // page_size)
+        page = min(page, pages)
+        offset = (page - 1) * page_size
+        async with db.execute(
+            """SELECT s.*, s.id AS session_id,
+                      (SELECT COUNT(*) FROM session_transcripts t
+                       WHERE t.session_id = s.id AND t.is_final = 1) AS transcript_count,
+                      (SELECT COUNT(*) FROM pipeline_events p
+                       WHERE p.session_id = s.id) AS pipeline_event_count,
+                      (SELECT COUNT(*) FROM pipeline_events p
+                       WHERE p.session_id = s.id AND p.status IN ('failed','blocked')) AS error_count
+               FROM sessions s WHERE s.robot_id = ?
+               ORDER BY s.started_at DESC LIMIT ? OFFSET ?""",
+            (device_id, page_size, offset),
+        ) as cursor:
+            sessions = [dict(row) for row in await cursor.fetchall()]
+
+        events_by_session = {item["session_id"]: [] for item in sessions}
+        session_ids = list(events_by_session)
+        if session_ids:
+            placeholders = ",".join("?" for _ in session_ids)
+            async with db.execute(
+                f"SELECT * FROM pipeline_events WHERE session_id IN ({placeholders}) ORDER BY timestamp, id",
+                session_ids,
+            ) as cursor:
+                for row in await cursor.fetchall():
+                    event = dict(row)
+                    try:
+                        event["details"] = json.loads(event.get("details") or "{}")
+                    except (TypeError, ValueError):
+                        event["details"] = {}
+                    events_by_session[event["session_id"]].append(event)
+
+    for session in sessions:
+        session["events"] = events_by_session.get(session["session_id"], [])
+    return {
+        "robot_id": device_id,
+        "robot_name": device["name"],
+        "items": sessions,
+        "page": page,
+        "page_size": page_size,
+        "pages": pages,
+        "total": total,
+    }
+
 @app.post("/api/robots/{robot_id}/pipeline-test/start")
 async def start_pipeline_test(robot_id: str):
     snapshot = await robot_pipeline_status(robot_id)
@@ -3531,9 +3620,17 @@ async def device_supervisor_output(device_id: str, payload: dict, authorization:
         await db.commit()
     kind = payload.get("kind") or "shell"
     service = payload.get("service") or ""
-    await _log_history("device", "device", device_id, f"shell_{kind}_completed", "operator",
-                       f"service={service}, request_id={request_id}, ok={bool(ok)}")
-    return {"status": "ok"}
+    await _log_history("device", "device", device_id, f"shell_{kind}_completed", "operator",
+                       f"service={service}, request_id={request_id}, ok={bool(ok)}")
+    if kind == "motor_sequence" and result_payload.get("session_id"):
+        await _insert_pipeline_event(device_id, PipelineEventPayload(
+            stage="motor_sequence", status="ok" if ok else "failed",
+            message=(f"Motor sequence {result_payload.get('sequence_id')} completed" if ok
+                     else f"Motor sequence failed: {result_payload.get('error', 'unknown error')}")[:500],
+            session_id=result_payload.get("session_id"), source="robot_supervisor",
+            details={"request_id": request_id, "duration_ms": result_payload.get("duration_ms")},
+        ))
+    return {"status": "ok"}
 
 
 # Endpoint the dashboard uses to list the available shell commands
@@ -3754,7 +3851,7 @@ async def device_config(device_id: str, authorization: Optional[str] = Header(de
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
         async with db.execute(
-            "SELECT id, name, character_id, motor_server_url, livekit_url, video_device, audio_device, audio_output_device, device_inventory, greeting_phrases FROM devices WHERE id = ?",
+            "SELECT id, name, character_id, motor_server_url, livekit_url, video_device, audio_device, audio_output_device, device_inventory, greeting_phrases, motor_registry, motor_sequences, greeting_motor_sequence_id FROM devices WHERE id = ?",
             (device_id,),
         ) as c:
             row = await c.fetchone()
@@ -3770,10 +3867,169 @@ async def device_config(device_id: str, authorization: Optional[str] = Header(de
         "video_device": row["video_device"],
         "audio_device": row["audio_device"],
         "audio_output_device": row["audio_output_device"],
-        "greeting_phrases": _device_row_to_model(row).greeting_phrases,
+        "greeting_phrases": _device_row_to_model(row).greeting_phrases,
+        "motor_registry": _device_row_to_model(row).motor_registry,
+        "motor_sequences": _device_row_to_model(row).motor_sequences,
+        "greeting_motor_sequence_id": row["greeting_motor_sequence_id"],
         "device_inventory": json.loads(row["device_inventory"]) if row["device_inventory"] else None,
         "production_mode": effective_pm,
-    }
+    }
+
+class MotorProfilePayload(BaseModel):
+    registry: List[dict] = []
+    sequences: List[dict] = []
+    greeting_sequence_id: Optional[str] = None
+
+async def _resolve_device_by_id_or_name(robot_id: str):
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT * 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 cursor:
+            device = await cursor.fetchone()
+    if not device:
+        raise HTTPException(404, "Robot device not found")
+    return device
+
+def _sanitize_motor_profile(payload: MotorProfilePayload) -> tuple[list, list, Optional[str]]:
+    import re
+    registry, ids, gpios = [], set(), set()
+    for raw in payload.registry[:32]:
+        motor_id = str(raw.get("id") or raw.get("name") or "").strip().lower()
+        if not re.fullmatch(r"[a-z0-9][a-z0-9_-]{0,31}", motor_id):
+            raise HTTPException(422, f"Invalid motor id: {motor_id!r}")
+        gpio = int(raw.get("gpio", -1))
+        if gpio < 2 or gpio > 27:
+            raise HTTPException(422, f"GPIO {gpio} is outside BCM 2..27")
+        if motor_id in ids or gpio in gpios:
+            raise HTTPException(422, "Motor ids and GPIO assignments must be unique")
+        ids.add(motor_id); gpios.add(gpio)
+        registry.append({"id": motor_id, "name": str(raw.get("name") or motor_id)[:60], "gpio": gpio,
+                         "active_high": bool(raw.get("active_high", True)),
+                         "max_duration_ms": max(50, min(10000, int(raw.get("max_duration_ms", 3000))))})
+    sequences, sequence_ids = [], set()
+    for raw in payload.sequences[:32]:
+        sequence_id = str(raw.get("id") or raw.get("name") or "").strip().lower()
+        if not re.fullmatch(r"[a-z0-9][a-z0-9_-]{0,31}", sequence_id) or sequence_id in sequence_ids:
+            raise HTTPException(422, f"Invalid or duplicate sequence id: {sequence_id!r}")
+        sequence_ids.add(sequence_id)
+        steps = []
+        for step in (raw.get("steps") or [])[:40]:
+            motor_id = str(step.get("motor_id") or "")
+            if motor_id not in ids:
+                raise HTTPException(422, f"Sequence {sequence_id} references unknown motor {motor_id}")
+            motor = next(item for item in registry if item["id"] == motor_id)
+            duration = max(50, min(motor["max_duration_ms"], int(step.get("duration_ms", 500))))
+            steps.append({"motor_id": motor_id, "delay_ms": max(0, min(30000, int(step.get("delay_ms", 0)))), "duration_ms": duration})
+        sequences.append({"id": sequence_id, "name": str(raw.get("name") or sequence_id)[:80], "steps": steps})
+    greeting = payload.greeting_sequence_id or None
+    if greeting and greeting not in sequence_ids:
+        raise HTTPException(422, "Greeting sequence does not exist")
+    return registry, sequences, greeting
+
+@app.get("/api/robots/{robot_id}/motor-profile")
+async def robot_motor_profile(robot_id: str):
+    device = await _resolve_device_by_id_or_name(robot_id)
+    model = _device_row_to_model(device)
+    return {"robot_id": model.id, "motor_server_url": model.motor_server_url,
+            "registry": model.motor_registry, "sequences": model.motor_sequences,
+            "greeting_sequence_id": model.greeting_motor_sequence_id}
+
+@app.put("/api/robots/{robot_id}/motor-profile")
+async def save_robot_motor_profile(robot_id: str, payload: MotorProfilePayload):
+    device = await _resolve_device_by_id_or_name(robot_id)
+    registry, sequences, greeting = _sanitize_motor_profile(payload)
+    async with aiosqlite.connect(DB_PATH) as db:
+        await db.execute("UPDATE devices SET motor_registry=?, motor_sequences=?, greeting_motor_sequence_id=? WHERE id=?",
+                         (json.dumps(registry), json.dumps(sequences), greeting, device["id"]))
+        await db.commit()
+    await _log_history("motor", "device", device["id"], "profile_saved", "operator", f"motors={len(registry)}, sequences={len(sequences)}")
+    return {"status": "ok", "robot_id": device["id"], "registry": registry, "sequences": sequences, "greeting_sequence_id": greeting}
+
+async def _queue_motor_sequence(device_id: str, sequence_id: str, session_id: Optional[str] = None) -> dict:
+    device = await _resolve_device_by_id_or_name(device_id)
+    model = _device_row_to_model(device)
+    sequence = next((item for item in model.motor_sequences if item.get("id") == sequence_id), None)
+    if not sequence:
+        raise HTTPException(404, "Motor sequence not found")
+    if not model.motor_server_url:
+        raise HTTPException(409, "Robot has no motor_server_url")
+    request_id = await _queue_shell_request_async(model.id, "motor_sequence", "motor_server", {
+        "motor_server_url": model.motor_server_url, "sequence_id": sequence_id,
+        "steps": sequence.get("steps") or [], "registry": model.motor_registry, "session_id": session_id,
+    })
+    if session_id:
+        await _insert_pipeline_event(model.id, PipelineEventPayload(stage="motor_sequence", status="running", message=f"Motor sequence {sequence_id} queued", session_id=session_id, source="scheduler"))
+    return {"queued": True, "request_id": request_id, "device_id": model.id, "sequence_id": sequence_id}
+
+async def _queue_configured_greeting_sequence(device_id: str, session_id: str) -> None:
+    try:
+        device = await _resolve_device_by_id_or_name(device_id)
+        sequence_id = device["greeting_motor_sequence_id"]
+        async with aiosqlite.connect(DB_PATH) as db:
+            async with db.execute(
+                "SELECT 1 FROM pipeline_events WHERE robot_id=? AND session_id=? "
+                "AND stage='motor_sequence' LIMIT 1",
+                (device["id"], session_id),
+            ) as cursor:
+                if await cursor.fetchone():
+                    return
+        if sequence_id:
+            await _queue_motor_sequence(device["id"], sequence_id, session_id)
+        else:
+            await _insert_pipeline_event(device["id"], PipelineEventPayload(
+                stage="motor_sequence", status="skipped",
+                message="No greeting motor sequence assigned",
+                session_id=session_id, source="scheduler",
+            ))
+    except Exception as exc:
+        logger.warning("Greeting motor sequence was not queued for %s: %s", device_id, exc)
+
+@app.post("/api/robots/{robot_id}/motor-sequences/{sequence_id}/run")
+async def run_robot_motor_sequence(robot_id: str, sequence_id: str):
+    return await _queue_motor_sequence(robot_id, sequence_id)
+
+@app.post("/api/devices/by-room/{room_name}/motor-sequences/{sequence_id}/run")
+async def run_room_motor_sequence(
+    room_name: str,
+    sequence_id: str,
+    authorization: Optional[str] = Header(default=None),
+    agent_token: Optional[str] = Header(default=None, alias="X-RoboPark-Agent-Token"),
+):
+    """Allow the active voice worker to invoke a saved robot sequence by room."""
+    fleet_authorized = await _authorize_fleet(authorization)
+    agent_authorized = bool(
+        ROBOPARK_AGENT_TOKEN and agent_token
+        and hmac.compare_digest(agent_token.strip(), ROBOPARK_AGENT_TOKEN)
+    )
+    if not fleet_authorized and not agent_authorized:
+        raise HTTPException(401, "Invalid or missing agent token")
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT id, robot_id FROM sessions WHERE room_name=? AND ended_at IS NULL "
+            "ORDER BY started_at DESC LIMIT 1",
+            (room_name,),
+        ) as cursor:
+            session = await cursor.fetchone()
+    if not session:
+        raise HTTPException(404, "No active session bound to this room")
+    return await _queue_motor_sequence(session["robot_id"], sequence_id, session["id"])
+
+@app.post("/api/robots/{robot_id}/motors/{motor_id}/test")
+async def test_robot_motor(robot_id: str, motor_id: str, duration_ms: int = 300):
+    device = await _resolve_device_by_id_or_name(robot_id)
+    model = _device_row_to_model(device)
+    motor = next((item for item in model.motor_registry if item.get("id") == motor_id), None)
+    if not motor or not model.motor_server_url:
+        raise HTTPException(404, "Motor or motor server not configured")
+    duration_ms = max(50, min(int(motor.get("max_duration_ms", 3000)), duration_ms))
+    request_id = await _queue_shell_request_async(model.id, "motor_sequence", "motor_server", {
+        "motor_server_url": model.motor_server_url, "sequence_id": f"test-{motor_id}", "registry": model.motor_registry,
+        "steps": [{"motor_id": motor_id, "delay_ms": 0, "duration_ms": duration_ms}],
+    })
+    return {"queued": True, "request_id": request_id, "device_id": model.id}
 
 @app.post("/api/devices/{device_id}/request-session")
 async def device_request_session(device_id: str,
@@ -3878,10 +4134,10 @@ async def device_request_session(device_id: str,
             WHERE id = ?
         """, (session_id, server["id"], device_id))
 
-        await db.commit()
-
-    await broadcast("session_requested", {
-        "robot_id": device_id,
+        await db.commit()
+
+    await broadcast("session_requested", {
+        "robot_id": device_id,
         "device_id": device_id,
         "server_id": server["id"],
         "session_id": session_id,