infinicode 2.8.64 → 2.8.65

package/dist/kernel/federation/dashboard-html.js

@@ -318,7 +318,19 @@ button.act:disabled{opacity:0.5;cursor:default;}
 .pk-kv .v.warn{color:var(--warn);} .pk-kv .v.bad{color:var(--bad);} .pk-kv .v.ok{color:var(--ok);}
 .pk-kv .l{font-size:0.56rem;text-transform:uppercase;letter-spacing:0.05em;color:var(--muted);}
 .pk-ctl{display:flex;gap:0.45rem;flex-wrap:wrap;}
-.pk-note{font-family:var(--mono);font-size:0.58rem;color:var(--gold);opacity:0.85;margin-top:0.4rem;}
+.pk-note{font-family:var(--mono);font-size:0.58rem;color:var(--gold);opacity:0.85;margin-top:0.4rem;}
+.pk-pipeline{display:grid;gap:0.32rem;margin-top:0.6rem;}
+.pk-pipe-step{display:grid;grid-template-columns:0.55rem 8.2rem 1fr;gap:0.45rem;align-items:start;padding:0.32rem 0.4rem;border-radius:7px;background:rgba(255,255,255,0.025);font-family:var(--mono);font-size:0.56rem;color:var(--muted);}
+.pk-pipe-step i{width:0.48rem;height:0.48rem;border-radius:50%;margin-top:0.08rem;background:var(--muted);box-shadow:0 0 0 2px rgba(255,255,255,0.04);}
+.pk-pipe-step.running i{background:var(--warn);box-shadow:0 0 8px var(--warn);animation:pulse 1s infinite;}
+.pk-pipe-step.ok i{background:var(--ok);box-shadow:0 0 7px rgba(70,220,150,.45);}
+.pk-pipe-step.failed i,.pk-pipe-step.blocked i{background:var(--bad);box-shadow:0 0 7px rgba(255,90,90,.45);}
+.pk-pipe-step .stage{color:var(--text);text-transform:uppercase;letter-spacing:.04em;}
+.pk-pipe-step .detail{text-align:right;overflow-wrap:anywhere;}
+.pk-pipeline-summary{padding:0.5rem 0.6rem;border:1px solid var(--glass-border);border-radius:8px;font-family:var(--mono);font-size:0.6rem;color:var(--muted);}
+.pk-pipeline-summary.ready{color:var(--ok);border-color:rgba(70,220,150,.35);}
+.pk-pipeline-summary.running{color:var(--warn);border-color:rgba(255,196,70,.35);}
+.pk-pipeline-summary.blocked{color:var(--bad);border-color:rgba(255,90,90,.4);}
 .pk-prodtoggle{display:flex;align-items:center;gap:0.5rem;margin-top:0.6rem;padding:0.45rem 0.6rem;border-radius:8px;border:1px solid var(--border-strong);background:var(--panel-2);cursor:pointer;}
 .pk-prodtoggle input{width:15px;height:15px;accent-color:var(--gold-bright,var(--gold));cursor:pointer;}
 .pk-prodtoggle span{font-family:var(--mono);font-size:0.66rem;color:var(--ink);}
@@ -3276,7 +3288,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
     // so the "ended" ring can fade out for ~4s after a session ends,
     // and the "live/talking" status can persist briefly across polls.
     var _statusMem = {};   // name -> { lastActiveAt, lastEndedAt, prevReadiness }
-    var drawerId=null, camRAF=null, meterRAF=null, camAbort=null, drawerTimer=null, deviceSelectorsReady=false;
+    var drawerId=null, camRAF=null, meterRAF=null, camAbort=null, drawerTimer=null, pipelineTimer=null, deviceSelectorsReady=false;
     var previewOn=false, previewTimer=null;   // on-demand operator camera preview
     var visionOn=false;   // RoboVisionAI_PI overlay feed (direct MJPEG, not LiveKit)
     var lkRoom=null, micAnalyser=null, audioCtx=null, lkAudioEls=[];
@@ -5366,7 +5378,8 @@ button.act:disabled{opacity:0.5;cursor:default;}
       if(camRAF)cancelAnimationFrame(camRAF); camRAF=null;
       if(meterRAF)cancelAnimationFrame(meterRAF); meterRAF=null;
       if(camAbort){ try{camAbort.abort();}catch(e){} camAbort=null; }
-      if(drawerTimer){ clearInterval(drawerTimer); drawerTimer=null; }
+      if(drawerTimer){ clearInterval(drawerTimer); drawerTimer=null; }
+      if(pipelineTimer){ clearInterval(pipelineTimer); pipelineTimer=null; }
       if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }
       micAnalyser=null;
     }
@@ -5909,9 +5922,13 @@ button.act:disabled{opacity:0.5;cursor:default;}
             +'<img id="pk-vision-img" style="width:100%;height:100%;object-fit:cover;position:absolute;inset:0;display:none;border-radius:inherit" alt="vision feed"/>'
             +'<div class="hud"><div class="rec"><i></i>REC · '+esc(n.name)+'</div><div class="tr" id="pk-camres">— · —</div><div class="br" id="pk-camts">--:--:--</div></div></div>'
             +'<div class="pk-note" id="pk-camnote">seeking live feed…</div>'
-            +'<div class="pk-ctl" style="margin-top:0.5rem"><button class="rp-btn" id="pk-golive" data-robot="'+esc(n.name)+'">▶ Go live</button><span class="pk-note" id="pk-golivenote" style="margin:0"></span></div>'
-            +'<label class="pk-prodtoggle"><input type="checkbox" id="pk-prodmode"'+(devForPm.production_mode?' checked':'')+'><span>Production mode — continuous motion-triggered loop, camera always live</span></label>')
-        + sect('🎙 microphone','<div class="pk-meter"><span class="lab">input</span><div class="pk-bars" id="pk-micbars"></div><span class="pk-val" id="pk-micval">—</span></div><div class="pk-note" id="pk-micstate">awaiting robot audio plugin</div>')
+            +'<div class="pk-ctl" style="margin-top:0.5rem"><button class="rp-btn" id="pk-golive" data-robot="'+esc(n.name)+'">▶ Go live</button><span class="pk-note" id="pk-golivenote" style="margin:0"></span></div>'
+            +'<label class="pk-prodtoggle"><input type="checkbox" id="pk-prodmode"'+(devForPm.production_mode?' checked':'')+'><span>Production mode — continuous motion-triggered loop, camera always live</span></label>')
+        + sect('Remote production test','<div id="pk-pipeline-summary" class="pk-pipeline-summary">Checking robot, camera, scheduler and LiveKit...</div>'
+          + '<div class="pk-ctl" style="margin-top:0.55rem"><button class="rp-btn primary" id="pk-pipeline-start">Start full test</button><button class="rp-btn danger" id="pk-pipeline-stop">Stop conversation</button></div>'
+          + '<div class="pk-note">Starts the camera, sends the same motion trigger used in production, and follows every reported stage remotely.</div>'
+          + '<div class="pk-pipeline" id="pk-pipeline"></div>')
+        + sect('🎙 microphone','<div class="pk-meter"><span class="lab">input</span><div class="pk-bars" id="pk-micbars"></div><span class="pk-val" id="pk-micval">—</span></div><div class="pk-note" id="pk-micstate">awaiting robot audio plugin</div>')
         + sect('🔊 speaker','<canvas class="pk-wave" id="pk-spkwave" width="360" height="32"></canvas><div class="pk-meter"><span class="lab">output</span><div class="pk-bars" id="pk-spkbars"></div><span class="pk-val" id="pk-spkval">—</span></div><div class="pk-note" id="pk-spkstate">TTS plays on the robot speaker — use “Test speaker” below to round-trip a tone and confirm the audio path</div>'
           + '<div class="rp-form" id="pk-spk-test" style="grid-template-columns:1fr 1fr;gap:0.4rem;margin-top:0.55rem;padding:0.55rem;border-color:var(--border-strong);">'
           +   '<div class="rp-field"><label>Frequency</label><select id="pk-spk-freq"><option value="500">500 Hz (low)</option><option value="1000" selected>1000 Hz (1 kHz reference)</option><option value="2000">2000 Hz (presence)</option><option value="3000">3000 Hz (clarity)</option></select></div>'
@@ -5937,7 +5954,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
           if(deviceSection && speakerSection) speakerSection.after(deviceSection);
           refreshDeviceSelectors(n);
          b.innerHTML += '<div class="pk-ctl" style="margin-top:0.5rem"><button class="rp-btn danger" id="pk-recover" data-robot="'+esc(n.name)+'">Recover robot</button><span class="pk-note" style="margin:0">clears stale sessions and queued triggers for this robot</span></div>';
-         var deviceSearch=$('pk-device-search'); if(deviceSearch) deviceSearch.addEventListener('input', function(){ refreshDeviceSelectors(n); });
+         var deviceSearch=$('pk-device-search'); if(deviceSearch) deviceSearch.addEventListener('input', function(){ refreshDeviceSelectors(n); });
          var deviceSave=$('pk-device-save'); if(deviceSave) deviceSave.addEventListener('click', function(){ saveDeviceSelectors(n); });
          startCam(n); startMeters(n); loadEffectiveConfig(schedId(n)); refreshSupervisorPanel(n);
         _bindShellSection(n);
@@ -5958,7 +5975,12 @@ button.act:disabled{opacity:0.5;cursor:default;}
           restartService(n, btn.dataset.svc, btn);
         });
         var eb=$('pk-end'); if(eb) eb.addEventListener('click', function(){ if(rpReadOnly){ showOut('read-only node'); return; } endSession(schedId(n)); });
-        var rb=$('pk-recover'); if(rb) rb.addEventListener('click', function(){ if(rpReadOnly){ showOut('read-only node'); return; } recoverRobot(schedId(n)); });
+         var rb=$('pk-recover'); if(rb) rb.addEventListener('click', function(){ if(rpReadOnly){ showOut('read-only node'); return; } recoverRobot(schedId(n)); });
+        var pipelineStart=$('pk-pipeline-start'); if(pipelineStart) pipelineStart.addEventListener('click', function(){ if(rpReadOnly){ showOut('read-only node'); return; } startPipelineTest(n); });
+        var pipelineStop=$('pk-pipeline-stop'); if(pipelineStop) pipelineStop.addEventListener('click', function(){ if(rpReadOnly){ showOut('read-only node'); return; } stopPipelineTest(n); });
+        pollPipeline(n);
+        if(pipelineTimer) clearInterval(pipelineTimer);
+        pipelineTimer=setInterval(function(){ if(drawerId===n.id) pollPipeline(n); }, 1500);
         var fb=$('pk-follow'); if(fb) fb.addEventListener('click', function(){ selectTab('fleet'); $('cmdInput').value='/follow'; selectNode(n.id,n.name); showOut('type a runId after /follow, or run /status on '+n.name); });
       } else {
         b.innerHTML =
@@ -5966,10 +5988,69 @@ button.act:disabled{opacity:0.5;cursor:default;}
         + sect('🔌 capabilities', (n.caps.length?('<div class="caps">'+n.caps.map(function(c){return '<span class="cap">'+esc(c)+'</span>';}).join('')+'</div>'):'<div class="pk-note">none reported</div>'))
         + sect('⚙ controls','<div class="pk-ctl"><button class="rp-btn" id="pk-status">Run /status</button></div>');
         var sb=$('pk-status'); if(sb) sb.addEventListener('click', function(){ selectTab('fleet'); selectNode(n.id,n.name); $('cmdInput').value='/status'; runCommand('/status'); });
-      }
-      refreshDrawer();
-    }
-    function refreshDrawer(){
+      }
+      refreshDrawer();
+    }
+
+    var PIPELINE_LABELS={
+      robot_online:'Robot online',camera_ready:'Camera detected',microphone_ready:'Microphone detected',speaker_ready:'Speaker detected',
+      motion_detected:'Motion received',scheduler_session:'Scheduler session',livekit_join:'LiveKit joined',camera_published:'Camera published',
+      microphone_published:'Microphone published',voice_worker:'Voice worker',stt_listening:'STT listening',llm_response:'LLM response',
+      tts_subscribed:'TTS subscribed',playback_started:'Robot playback',session_ended:'Session ended'
+    };
+    function renderPipeline(data){
+      var host=$('pk-pipeline'), summary=$('pk-pipeline-summary'); if(!host||!summary) return;
+      var latest={}, prereqs=data.prerequisites||{}, session=data.latest_session||{}, sid=session.id||null;
+      (data.events||[]).forEach(function(ev){
+        if(ev.session_id && sid && ev.session_id!==sid) return;
+        latest[ev.stage]=ev;
+      });
+      ['robot_online','camera_ready','microphone_ready','speaker_ready'].forEach(function(stage){
+        if(!latest[stage]) latest[stage]={stage:stage,status:prereqs[stage]?'ok':'blocked',message:prereqs[stage]?'Ready':'Not reported'};
+      });
+      var running=data.overall==='running';
+      host.innerHTML=(data.stages||Object.keys(PIPELINE_LABELS)).map(function(stage){
+        var ev=latest[stage], status=ev&&ev.status||((running&&stage==='motion_detected')?'running':'pending');
+        var detail=ev&&(ev.message||ev.timestamp)||'waiting';
+        if(ev&&ev.timestamp) detail=detail+' · '+new Date(ev.timestamp+'Z').toLocaleTimeString();
+        return '<div class="pk-pipe-step '+esc(status)+'"><i></i><span class="stage">'+esc(PIPELINE_LABELS[stage]||stage)+'</span><span class="detail">'+esc(detail)+'</span></div>';
+      }).join('');
+      var blockers=data.blockers||[];
+      summary.className='pk-pipeline-summary '+esc(data.overall||'blocked');
+      summary.textContent=blockers.length?('BLOCKED: '+blockers[0]):(running?'TEST RUNNING: watch the live camera and stage timeline':'READY: camera-to-speaker remote test can start');
+    }
+    function pollPipeline(n){
+      fetch('/robopark/api/robots/'+encodeURIComponent(schedId(n))+'/pipeline-status'+QS,{cache:'no-store'})
+        .then(function(r){ if(!r.ok) throw new Error('scheduler '+r.status); return r.json(); })
+        .then(renderPipeline)
+        .catch(function(e){ var s=$('pk-pipeline-summary'); if(s){ s.className='pk-pipeline-summary blocked'; s.textContent='SCHEDULER UNREACHABLE: '+e.message; } });
+    }
+    function queuePipelineTest(n){
+      var start=$('pk-pipeline-start'); if(start){ start.disabled=true; start.textContent='Starting...'; }
+      if(!previewOn) startPreview(n);
+      rpAction('POST','/robopark/api/robots/'+encodeURIComponent(schedId(n))+'/pipeline-test/start',{}).then(function(result){
+        if(!result.queued) throw new Error(result.reason||'trigger was not queued');
+        showOut('full production test queued for '+(n.label||n.name));
+        pollPipeline(n);
+      }).catch(function(e){ showOut('production test: '+e.message); pollPipeline(n); }).finally(function(){ if(start){ start.disabled=false; start.textContent='Start full test'; } });
+    }
+    function startPipelineTest(n){
+      var device=schedulerDevice(n)||{};
+      if(!device.id){ showOut('Robot has no scheduler device identity'); return; }
+      if(!device.production_mode){
+        rpAction('PATCH','/robopark/api/devices/'+encodeURIComponent(device.id),{production_mode:true}).then(function(){
+          device.production_mode=true; var pm=$('pk-prodmode'); if(pm) pm.checked=true; queuePipelineTest(n);
+        }).catch(function(e){ showOut('Could not enable production mode: '+e.message); });
+        return;
+      }
+      queuePipelineTest(n);
+    }
+    function stopPipelineTest(n){
+      rpAction('POST','/robopark/api/robots/'+encodeURIComponent(schedId(n))+'/pipeline-test/stop',{}).then(function(){
+        showOut('conversation stopped for '+(n.label||n.name)); pollPipeline(n); startCam(n);
+      }).catch(function(e){ showOut('stop test: '+e.message); });
+    }
+    function refreshDrawer(){
       var n=drawerId?byId[drawerId]:null; if(!n) return;
       if(n.kind==='robot' && !deviceSelectorsReady && $('pk-video-device')){
         var devCheck=schedulerDevice(n);

package/package.json

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

@@ -216,12 +216,20 @@ class DeviceEnrollResponse(BaseModel):
     device_token: str
     scheduler_url: str
 
-class DeviceHeartbeat(BaseModel):
+class DeviceHeartbeat(BaseModel):
     status: Optional[str] = None
     ip: Optional[str] = None
     uptime_seconds: Optional[int] = None
     production_mode: Optional[bool] = None
-    device_inventory: Optional[dict] = None
+    device_inventory: Optional[dict] = None
+
+class PipelineEventPayload(BaseModel):
+    stage: str
+    status: str = "ok"
+    message: Optional[str] = None
+    session_id: Optional[str] = None
+    source: str = "robot"
+    details: Optional[dict] = None
 
 class SupervisorStatusReport(BaseModel):
     services: List[ServiceStatus] = []
@@ -439,7 +447,7 @@ async def init_db():
             );
             CREATE INDEX IF NOT EXISTS idx_shell_requests_device ON shell_requests(device_id, requested_at);
 
-            CREATE TABLE IF NOT EXISTS history_log (
+            CREATE TABLE IF NOT EXISTS history_log (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
                 category TEXT NOT NULL,
@@ -447,8 +455,22 @@ async def init_db():
                 entity_id TEXT,
                 action TEXT,
                 actor TEXT,
-                details TEXT
-            );
+                details TEXT
+            );
+
+            CREATE TABLE IF NOT EXISTS pipeline_events (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                robot_id TEXT NOT NULL,
+                session_id TEXT,
+                stage TEXT NOT NULL,
+                status TEXT NOT NULL,
+                message TEXT,
+                source TEXT NOT NULL DEFAULT 'robot',
+                details TEXT,
+                timestamp TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+            );
+            CREATE INDEX IF NOT EXISTS idx_pipeline_robot_time
+                ON pipeline_events(robot_id, timestamp DESC);
 
             -- Scheduler-managed voice stacks (STT/LLM/TTS configuration)
             CREATE TABLE IF NOT EXISTS voice_stacks (
@@ -1342,8 +1364,8 @@ async def session_joined(session_id: str,
     await _log_history("session", "session", session_id, "joined", "robot", f"latency_ms={latency_ms}")
     return {"status": "ok", "joined_at": now, "latency_ms": latency_ms}
 
-@app.post("/api/sessions/{session_id}/keepalive")
-async def session_keepalive(session_id: str,
+@app.post("/api/sessions/{session_id}/keepalive")
+async def session_keepalive(session_id: str,
                             authorization: Optional[str] = Header(default=None),
                             agent_token: Optional[str] = Header(default=None, alias="X-RoboPark-Agent-Token")):
     """Silence-based session extension signal.
@@ -1381,7 +1403,29 @@ async def session_keepalive(session_id: str,
         await db.commit()
         if cur.rowcount == 0:
             raise HTTPException(404, "Session not found or already ended")
-    return {"status": "ok", "last_activity_at": now}
+    return {"status": "ok", "last_activity_at": now}
+
+@app.post("/api/sessions/{session_id}/pipeline-events")
+async def voice_pipeline_event(session_id: str, payload: PipelineEventPayload,
+                               authorization: Optional[str] = Header(default=None),
+                               agent_token: Optional[str] = Header(default=None, alias="X-RoboPark-Agent-Token")):
+    """ROBOVOICE callback for worker, STT, LLM and TTS stage timing."""
+    device_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 device_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 robot_id FROM sessions WHERE id = ?", (session_id,)) as c:
+            session = await c.fetchone()
+    if not session:
+        raise HTTPException(404, "Session not found")
+    payload.session_id = session_id
+    payload.source = "voice_agent"
+    return {"status": "ok", **(await _insert_pipeline_event(session["robot_id"], payload))}
 
 @app.get("/api/sessions/{session_id}/status")
 async def get_session_status(session_id: str):
@@ -2654,8 +2698,8 @@ async def device_trigger_command(device_id: str,
         await db.commit()
     return {"trigger": True, "source": command["source"], "production_mode": True}
 
-@app.post("/api/devices/{device_id}/heartbeat")
-async def device_heartbeat(device_id: str, payload: DeviceHeartbeat,
+@app.post("/api/devices/{device_id}/heartbeat")
+async def device_heartbeat(device_id: str, payload: DeviceHeartbeat,
                             authorization: Optional[str] = Header(default=None)):
     if not await _authorize_device(device_id, authorization):
         raise HTTPException(401, "Invalid device token")
@@ -2689,8 +2733,133 @@ async def device_heartbeat(device_id: str, payload: DeviceHeartbeat,
     return {
         "status": "ok",
         "production_mode": effective_pm,
-        "server_time": datetime.utcnow().isoformat(),
-    }
+        "server_time": datetime.utcnow().isoformat(),
+    }
+
+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",
+)
+PIPELINE_STATUSES = {"pending", "running", "ok", "failed", "blocked", "skipped"}
+
+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}")
+    if payload.status not in PIPELINE_STATUSES:
+        raise HTTPException(422, f"Unknown pipeline status: {payload.status}")
+    message = (payload.message or "")[:500]
+    details = json.dumps(payload.details or {}, separators=(",", ":"))[:4000]
+    now = datetime.utcnow().isoformat()
+    async with aiosqlite.connect(DB_PATH) as db:
+        cur = await db.execute(
+            """INSERT INTO pipeline_events
+               (robot_id, session_id, stage, status, message, source, details, timestamp)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            (device_id, payload.session_id, payload.stage, payload.status, message,
+             (payload.source or "robot")[:40], details, now),
+        )
+        await db.commit()
+    await broadcast("pipeline_event", {"robot_id": device_id, "stage": payload.stage, "status": payload.status})
+    return {"id": cur.lastrowid, "timestamp": now}
+
+@app.post("/api/devices/{device_id}/pipeline-events")
+async def device_pipeline_event(device_id: str, payload: PipelineEventPayload,
+                                authorization: Optional[str] = Header(default=None)):
+    """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))}
+
+@app.get("/api/robots/{robot_id}/pipeline-status")
+async def robot_pipeline_status(robot_id: str, limit: int = 80):
+    """One operator-facing snapshot for remote camera-to-playback testing."""
+    limit = max(10, min(limit, 200))
+    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 last_heartbeat DESC LIMIT 1",
+            (robot_id, robot_id),
+        ) as c:
+            device = await c.fetchone()
+        if not device:
+            raise HTTPException(404, "Robot device not found")
+        device_id = device["id"]
+        telemetry = await _robot_telemetry(db, device_id)
+        async with db.execute(
+            "SELECT * FROM sessions WHERE robot_id = ? ORDER BY started_at DESC LIMIT 1", (device_id,)
+        ) as c:
+            latest_session = await c.fetchone()
+        async with db.execute(
+            "SELECT * FROM pipeline_events WHERE robot_id = ? ORDER BY timestamp DESC LIMIT ?",
+            (device_id, limit),
+        ) as c:
+            rows = await c.fetchall()
+
+    try:
+        inventory = json.loads(device["device_inventory"] or "{}")
+    except (TypeError, ValueError):
+        inventory = {}
+    cameras = inventory.get("video") or inventory.get("cameras") or []
+    inputs = inventory.get("audio_input") or inventory.get("audio_inputs") or inventory.get("inputs") or []
+    outputs = inventory.get("audio_output") or inventory.get("audio_outputs") or inventory.get("outputs") or []
+    cameras = [d for d in cameras if str(d.get("id", "")).lower() not in ("auto", "none")]
+    inputs = [d for d in inputs if str(d.get("id", "")).lower() not in ("default", "none")]
+    outputs = [d for d in outputs if str(d.get("id", "")).lower() not in ("default", "none")]
+    heartbeat_age = telemetry.get("heartbeat_age_seconds") if telemetry else None
+    prereqs = {
+        "robot_online": heartbeat_age is not None and heartbeat_age <= 30,
+        "camera_ready": bool(cameras),
+        "microphone_ready": bool(inputs),
+        "speaker_ready": bool(outputs),
+    }
+    events = []
+    for row in reversed(rows):
+        item = dict(row)
+        try:
+            item["details"] = json.loads(item.get("details") or "{}")
+        except (TypeError, ValueError):
+            item["details"] = {}
+        events.append(item)
+    blockers = []
+    if not prereqs["robot_online"]:
+        blockers.append("Robot heartbeat is stale or missing")
+    if not bool(device["production_mode"]):
+        blockers.append("Robot production mode is off")
+    if telemetry and telemetry.get("readiness_code") not in ("ready", "in_session"):
+        blockers.append(telemetry.get("readiness_message") or telemetry["readiness_code"])
+    if not prereqs["camera_ready"]:
+        blockers.append("Camera inventory has not been reported")
+    if not prereqs["microphone_ready"]:
+        blockers.append("Microphone inventory has not been reported")
+    if not prereqs["speaker_ready"]:
+        blockers.append("Speaker inventory has not been reported")
+    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"),
+        "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),
+    }
+
+@app.post("/api/robots/{robot_id}/pipeline-test/start")
+async def start_pipeline_test(robot_id: str):
+    snapshot = await robot_pipeline_status(robot_id)
+    hard_blockers = [b for b in snapshot["blockers"] if "inventory" not in b.lower()]
+    if hard_blockers:
+        return {"queued": False, "reason": hard_blockers[0], "blockers": snapshot["blockers"]}
+    result = await simulate_trigger(snapshot["robot_id"])
+    return {**result, "robot_id": snapshot["robot_id"], "blockers": snapshot["blockers"]}
+
+@app.post("/api/robots/{robot_id}/pipeline-test/stop")
+async def stop_pipeline_test(robot_id: str):
+    snapshot = await robot_pipeline_status(robot_id)
+    return await simulate_stop(snapshot["robot_id"])
 
 @app.post("/api/devices/{device_id}/supervisor-status")
 async def device_supervisor_status(device_id: str, payload: SupervisorStatusReport,
@@ -4266,11 +4435,18 @@ async def dashboard():
         <script src="https://cdn.tailwindcss.com"></script>
         <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
         <script src="https://cdn.jsdelivr.net/npm/livekit-client@1/dist/livekit-client.umd.min.js"></script>
-    </head>
-    <body class="bg-gray-900 text-white">
-        <div id="app"></div>
-        <script>
-            const { createApp, ref, computed, onMounted, onUnmounted } = Vue;
+    </head>
+    <body class="bg-gray-900 text-white">
+        <div class="bg-amber-950 border-b border-amber-600 px-4 py-3 text-sm text-amber-100">
+            <strong>Legacy scheduler view.</strong> The canonical operator UI is the full RoboPark Control Center Park view on the mesh hub at port 47913.
+            <a id="fullControlCenterLink" class="underline ml-2" href="#">Open full Park Control Center</a>
+        </div>
+        <div id="app"></div>
+        <script>
+            const fullControlCenterLink = document.getElementById('fullControlCenterLink');
+            const meshHost = window.location.hostname || 'localhost';
+            fullControlCenterLink.href = `${window.location.protocol}//${meshHost}:47913/${window.location.search}#park`;
+            const { createApp, ref, computed, onMounted, onUnmounted } = Vue;
             
             createApp({
                 setup() {

package/packages/robopark/scheduler/preview_agent.py

@@ -433,6 +433,31 @@ class PreviewAgent:
         self._motion_capture_lock = asyncio.Lock()
         self._mesh_bootstrap_ready = False
         self._next_mesh_bootstrap = 0.0
+        self._reported_pipeline: set[tuple[str, str]] = set()
+
+    async def _report_pipeline(self, stage: str, status: str = "ok", message: str = "",
+                               details: Optional[dict] = None, once: bool = True) -> None:
+        """Report a real robot-side transition for the Park test timeline."""
+        if not self._session or not self.device_id or not self.device_token:
+            return
+        session_id = self._vision_session_id or self._current_state.session_id
+        key = (session_id or "idle", stage)
+        if once and key in self._reported_pipeline:
+            return
+        try:
+            response = await self._session.post(
+                f"{self.scheduler_url.rstrip('/')}/api/devices/{self.device_id}/pipeline-events",
+                headers={"Authorization": f"Bearer {self.device_token}"},
+                json={"stage": stage, "status": status, "message": message,
+                      "session_id": session_id, "source": "preview_agent",
+                      "details": details or {}},
+                timeout=5.0,
+            )
+            response.raise_for_status()
+            if once:
+                self._reported_pipeline.add(key)
+        except Exception as exc:
+            logger.debug("pipeline event %s was not accepted: %s", stage, exc)
 
     async def _ensure_mesh_identity(self) -> bool:
         if not _mesh_proxy_headers():
@@ -744,7 +769,7 @@ class PreviewAgent:
             dt = dt.replace(tzinfo=timezone.utc)
         return dt.timestamp()
 
-    async def _end_vision_session(self) -> None:
+    async def _end_vision_session(self) -> None:
         # Tell the scheduler too, not just the local publisher/LiveKit
         # connection — otherwise the sessions row never gets ended_at set,
         # and the server's active_sessions count climbs forever until it
@@ -763,7 +788,8 @@ class PreviewAgent:
                 )
             except Exception as e:
                 logger.warning(f"failed to notify scheduler of session end: {e}")
-        self._vision_session_id = None
+        await self._report_pipeline("session_ended", "ok", "Robot conversation loop stopped")
+        self._vision_session_id = None
         self._vision_trigger_in_flight = False
         self._vision_hard_deadline = 0.0
         self._vision_last_activity = 0.0
@@ -784,8 +810,16 @@ class PreviewAgent:
                     self._mesh_bootstrap_ready = False
                     self._next_mesh_bootstrap = 0.0
                 if production_mode is not None:
-                    self.production_mode = production_mode
-                    if not production_mode and self._vision_session_id:
+                    self.production_mode = production_mode
+                    await self._report_pipeline("robot_online", message="Robot heartbeat accepted")
+                    inventory = _get_device_inventory()
+                    real_video = [d for d in inventory.get("video", []) if str(d.get("id", "")).lower() not in ("auto", "none")]
+                    real_inputs = [d for d in inventory.get("audio_input", []) if str(d.get("id", "")).lower() not in ("default", "none")]
+                    real_outputs = [d for d in inventory.get("audio_output", []) if str(d.get("id", "")).lower() not in ("default", "none")]
+                    await self._report_pipeline("camera_ready", "ok" if real_video else "blocked", f"{len(real_video)} camera device(s) detected")
+                    await self._report_pipeline("microphone_ready", "ok" if real_inputs else "blocked", f"{len(real_inputs)} microphone device(s) detected")
+                    await self._report_pipeline("speaker_ready", "ok" if real_outputs else "blocked", f"{len(real_outputs)} speaker device(s) detected")
+                    if not production_mode and self._vision_session_id:
                         await self._end_vision_session()
             try:
                 await asyncio.wait_for(self._shutdown.wait(), timeout=self.heartbeat_interval)
@@ -923,8 +957,9 @@ class PreviewAgent:
         if not self.device_id or not self.device_token or not self._session:
             logger.warning("vision motion event received but not enrolled yet — ignoring")
             return
-        self._vision_trigger_in_flight = True
-        logger.info("motion detected by RoboVisionAI_PI — requesting a session")
+        self._vision_trigger_in_flight = True
+        await 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
@@ -943,9 +978,10 @@ class PreviewAgent:
             )
             r.raise_for_status()
             data = r.json()
-        except Exception as e:
-            logger.error(f"request-session failed: {e}")
-            self._vision_trigger_in_flight = False
+        except Exception as e:
+            logger.error(f"request-session failed: {e}")
+            await self._report_pipeline("scheduler_session", "failed", f"Session request failed: {type(e).__name__}", once=False)
+            self._vision_trigger_in_flight = False
             return
         state = PreviewState(
             active=True,
@@ -960,8 +996,9 @@ class PreviewAgent:
         self._vision_trigger_in_flight = False
         self._vision_hard_deadline = now + self.vision_session_seconds
         self._vision_last_activity = now
-        self._remote_session_ended = False
-        self._current_state = state
+        self._remote_session_ended = False
+        self._current_state = state
+        await self._report_pipeline("scheduler_session", "ok", "Scheduler allocated a conversation session")
         # If the scheduler returned a voice config, let the agent know by
         # posting it to our local webhook endpoint. The preview agent itself
         # does not consume it, but this makes the config observable locally
@@ -1006,9 +1043,10 @@ class LiveKitPublisher:
         # the camera is being handed between preview and voice sessions.
         self._last_motion_sample = 0.0
 
-    async def start(self) -> None:
-        self.room = self.rtc.Room()
-        await self.room.connect(self.url, self.token)
+    async def start(self) -> None:
+        self.room = self.rtc.Room()
+        await self.room.connect(self.url, self.token)
+        await self.agent._report_pipeline("livekit_join", "ok", "Robot joined the LiveKit room")
 
         # Register after signaling. Registering during Room.connect can invoke
         # callbacks while the native LiveKit participant state is incomplete;
@@ -1019,9 +1057,10 @@ class LiveKitPublisher:
             logger.info(f"track_subscribed: kind={track.kind} from={participant.identity} sid={publication.sid}")
             if track.kind != self.rtc.TrackKind.KIND_AUDIO:
                 return
-            if participant.identity == self.room.local_participant.identity:
-                return
-            self._tasks.append(asyncio.create_task(self._play_remote_audio(track, publication.sid)))
+            if participant.identity == self.room.local_participant.identity:
+                return
+            self._tasks.append(asyncio.create_task(self.agent._report_pipeline("tts_subscribed", "ok", "Subscribed to remote voice audio")))
+            self._tasks.append(asyncio.create_task(self._play_remote_audio(track, publication.sid)))
 
         self.room.on("track_subscribed", _on_track_subscribed)
         logger.info("audio out: track_subscribed listener registered")
@@ -1073,15 +1112,17 @@ class LiveKitPublisher:
             self.video_track = self.rtc.LocalVideoTrack.create_video_track("camera", self.video_source)
             vopts = self.rtc.TrackPublishOptions()
             vopts.source = self.rtc.TrackSource.SOURCE_CAMERA
-            await self.room.local_participant.publish_track(self.video_track, vopts)
-            self.video_source.capture_frame(first_frame)
+            await self.room.local_participant.publish_track(self.video_track, vopts)
+            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
-            await self.room.local_participant.publish_track(self.audio_track, aopts)
+            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
@@ -1217,11 +1258,12 @@ class LiveKitPublisher:
             async for frame in stream:
                 af = frame.frame if hasattr(frame, "frame") else frame
                 frame_count += 1
-                if frame_count == 1:
-                    logger.info(
-                        f"audio out: first frame received for {sid} "
-                        f"(rate={af.sample_rate}, channels={getattr(af, 'num_channels', 1)})"
-                    )
+                if frame_count == 1:
+                    logger.info(
+                        f"audio out: first frame received for {sid} "
+                        f"(rate={af.sample_rate}, channels={getattr(af, 'num_channels', 1)})"
+                    )
+                    await self.agent._report_pipeline("playback_started", "ok", "First TTS audio frame reached the robot")
                 in_rate = af.sample_rate
                 in_channels = int(getattr(af, "num_channels", 1) or 1)
                 raw = bytes(af.data)