infinicode 2.8.64 → 2.8.66

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

@@ -14,10 +14,9 @@
  *             for its cam / mic / speaker / hardware drawer)
  *   Sessions & Telemetry — RoboPark scheduler stats + production_mode + controls
  *
- * The Park cam panel targets a LiveKit video track: it fetches a per-robot stream
- * token from /robopark/api/robots/:id/stream and, when the livekit-client SDK and
- * a published track are present, subscribes; otherwise it shows a styled preview.
- * That token/track is produced by the robot-side RoboPark plugin.
+ * The Park cam panel relays RoboVisionAI_PI's existing MJPEG feed through the
+ * authenticated mesh. LiveKit remains the voice transport but is deliberately
+ * not used for dashboard video, avoiding camera ownership conflicts on robots.
  *
  * Kept free of backticks and ${...} so the whole page fits inside this TS
  * template literal without escaping; the client JS uses string concatenation.
@@ -318,7 +317,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 +3287,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 +5377,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;
     }
@@ -5433,7 +5445,12 @@ button.act:disabled{opacity:0.5;cursor:default;}
     // ── on-demand operator preview: open the robot's cam without a scene-detection session ──
     function updateGoLive(){ var b=$('pk-golive'); if(b){ b.textContent = previewOn?'■ Stop live':'▶ Go live'; b.classList.toggle('danger', previewOn); } }
     function goLive(n){ if(previewOn) stopPreview(n); else startPreview(n); }
-    function startPreview(n){
+    function startPreview(n){
+      previewOn=true; updateGoLive();
+      if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }
+      idleCam('connecting');
+      tryVisionOverlay(n, true);
+      return;
       previewOn=true; updateGoLive();
       var note=$('pk-golivenote'); if(note) note.textContent='requesting preview…';
       if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }  // drop any session cam first
@@ -5450,7 +5467,14 @@ button.act:disabled{opacity:0.5;cursor:default;}
         })
         .catch(function(e){ idleCam('unreachable'); if(note) note.textContent='preview request failed'; if(window.console) console.error('RoboPark preview request failed',e); previewOn=false; updateGoLive(); });
     }
-    function stopPreview(n){
+    function stopPreview(n){
+      previewOn=false; updateGoLive();
+      if(previewTimer){ clearInterval(previewTimer); previewTimer=null; }
+      if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }
+      stopVision();
+      var directNote=$('pk-golivenote'); if(directNote) directNote.textContent='';
+      idleCam('idle');
+      return;
       previewOn=false; updateGoLive();
       if(previewTimer){ clearInterval(previewTimer); previewTimer=null; }
       if(lkRoom){ try{ lkRoom.disconnect(); }catch(e){} lkRoom=null; }
@@ -5465,6 +5489,15 @@ button.act:disabled{opacity:0.5;cursor:default;}
     // server is opt-in because running it beside preview_agent would open the
     // same Windows camera twice and make both feeds unreliable.
     function tryVisionOverlay(n, force){
+      var directImg=$('pk-vision-img'); if(!directImg) return;
+      var directRef=n.nodeId||n.id||n.name;
+      if(!directRef){ visionOn=false; directImg.src=''; directImg.style.display='none'; return; }
+      var directCamNote=$('pk-camnote'), directLiveNote=$('pk-golivenote'), directRes=$('pk-camres');
+      visionOn=true;
+      directImg.onerror=function(){ visionOn=false; directImg.style.display='none'; directImg.src=''; if(directCamNote) directCamNote.textContent='RoboVision feed unavailable on robot'; if(directLiveNote) directLiveNote.textContent='camera unavailable'; if(directRes) directRes.textContent='OFFLINE'; };
+      directImg.onload=function(){ directImg.style.display='block'; if(directCamNote) directCamNote.textContent='live camera via RoboVision mesh relay'; if(directLiveNote) directLiveNote.textContent='live'; if(directRes) directRes.textContent='LIVE'; };
+      directImg.src='/fed/media/robots/'+encodeURIComponent(directRef)+'/video_feed'+QS+(QS?'&':'?')+'_='+Date.now();
+      return;
       var img=$('pk-vision-img'); if(!img) return;
       if(!force && String(window.localStorage.getItem('robopark.visionOverlay')||'').toLowerCase()!=='true'){
         visionOn=false; img.src=''; img.style.display='none'; return;
@@ -5909,9 +5942,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 +5974,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 +5995,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 +6008,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);
@@ -6003,7 +6104,10 @@ button.act:disabled{opacity:0.5;cursor:default;}
     function setFill(id,pct){ var e=$(id); if(!e||pct==null) return; e.style.width=Math.max(2,Math.min(100,pct))+'%'; e.style.background=pct>=75?'var(--bad)':pct>=45?'var(--warn)':'var(--gold-bright)'; }
 
     // ── cam: target a LiveKit track; fall back to a styled preview ──
-    function startCam(n){
+    function startCam(n){
+      idleCam('connecting');
+      tryVisionOverlay(n, true);
+      return;
       var note=$('pk-camnote');
       camAbort = ('AbortController' in window)?new AbortController():null;
       idleCam('connecting');

package/dist/kernel/federation/federation.js

@@ -86,6 +86,7 @@ export class Federation {
             logger,
             getManifest: () => buildManifest(identity, this.describeWithBackends()),
             getNodes: () => this.nodeStatuses(),
+            getPeers: () => this.peers(),
             getStatus: () => this.statusSnapshot(),
             runCommand: (input) => this.deps.kernel.command(input),
             commandGate: options.commandGate,

package/dist/kernel/federation/transport-http.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from '../types.js';
-import type { FederationEnvelope, NodeManifest, StreamFrame } from './types.js';
+import type { FederationEnvelope, NodeManifest, PeerInfo, StreamFrame } from './types.js';
 export type RpcHandler = (env: FederationEnvelope, remote: string) => Promise<FederationEnvelope | void>;
 export interface MeshServerOptions {
     host?: string;
@@ -9,6 +9,8 @@ export interface MeshServerOptions {
     getManifest: () => NodeManifest;
     /** Optional: full mesh view (self + peers) for the GET /fed/nodes probe. */
     getNodes?: () => unknown;
+    /** Connected peers and their reachable mesh URLs. */
+    getPeers?: () => PeerInfo[];
     /** Optional: consolidated fleet snapshot (self + nodes + hardware + roles +
      *  runs + recent activity) for the dashboard and `robopark fleet` (GET /fed/status). */
     getStatus?: () => unknown;
@@ -50,6 +52,9 @@ export declare class MeshServer {
     private seq;
     constructor(opts: MeshServerOptions);
     get streamCount(): number;
+    private streamHttp;
+    private streamLocalRoboVision;
+    private streamPeerRoboVision;
     start(): Promise<void>;
     /** Proxy a dashboard request to the RoboPark scheduler (product data). */
     private proxyToScheduler;

package/dist/kernel/federation/transport-http.js

@@ -20,6 +20,7 @@ import { promisify } from 'node:util';
 import { timingSafeEqual } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import { once } from 'node:events';
 import { frameToSSE, parseSSE } from './protocol.js';
 const execFileAsync = promisify(execFile);
 /** Read the livekit-client UMD bundle from the installed dependency, once.
@@ -82,6 +83,68 @@ export class MeshServer {
     get streamCount() {
         return this.sse.size;
     }
+    async streamHttp(req, res, target, headers = {}) {
+        const ctrl = new AbortController();
+        req.once('close', () => ctrl.abort());
+        try {
+            const upstream = await fetch(target, { headers, signal: ctrl.signal });
+            if (!upstream.ok || !upstream.body) {
+                const detail = await upstream.text().catch(() => '');
+                res.writeHead(upstream.status, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' });
+                res.end(detail || `media upstream returned ${upstream.status}`);
+                return;
+            }
+            res.writeHead(200, {
+                'content-type': upstream.headers.get('content-type') ?? 'multipart/x-mixed-replace; boundary=frame',
+                'cache-control': 'no-store, no-cache, must-revalidate',
+                pragma: 'no-cache',
+                connection: 'keep-alive',
+            });
+            const reader = upstream.body.getReader();
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done || res.writableEnded)
+                    break;
+                if (!res.write(Buffer.from(value)))
+                    await once(res, 'drain');
+            }
+            if (!res.writableEnded)
+                res.end();
+        }
+        catch (err) {
+            if (ctrl.signal.aborted)
+                return;
+            if (!res.headersSent) {
+                res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' });
+                res.end(`robot camera unavailable: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            else if (!res.writableEnded) {
+                res.end();
+            }
+        }
+    }
+    streamLocalRoboVision(req, res) {
+        void this.streamHttp(req, res, 'http://127.0.0.1:5000/video_feed');
+    }
+    streamPeerRoboVision(req, res, nodeRef) {
+        const ref = decodeURIComponent(nodeRef).toLowerCase();
+        const self = this.opts.getManifest();
+        if (self.nodeId.toLowerCase() === ref || self.displayName.toLowerCase() === ref) {
+            this.streamLocalRoboVision(req, res);
+            return;
+        }
+        const peer = (this.opts.getPeers?.() ?? []).find(candidate => candidate.connected &&
+            (candidate.nodeId.toLowerCase() === ref || candidate.displayName.toLowerCase() === ref));
+        if (!peer) {
+            res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' });
+            res.end(`connected robot mesh node not found: ${nodeRef}`);
+            return;
+        }
+        const headers = {};
+        if (this.opts.token)
+            headers.authorization = `Bearer ${this.opts.token}`;
+        void this.streamHttp(req, res, `${peer.url.replace(/\/+$/, '')}/fed/media/video_feed`, headers);
+    }
     async start() {
         const handler = (req, res) => this.handle(req, res);
         this.server = this.opts.tls
@@ -344,6 +407,18 @@ export class MeshServer {
             res.end(js);
             return;
         }
+        // RoboVision owns the robot camera. Satellites expose the existing local
+        // MJPEG feed, while the hub relays it over the authenticated mesh. This
+        // avoids opening /dev/video0 again in LiveKit and works across private LANs.
+        if (req.method === 'GET' && path === '/fed/media/video_feed') {
+            this.streamLocalRoboVision(req, res);
+            return;
+        }
+        const robotVideo = path.match(/^\/fed\/media\/robots\/([^/]+)\/video_feed$/);
+        if (req.method === 'GET' && robotVideo) {
+            this.streamPeerRoboVision(req, res, robotVideo[1]);
+            return;
+        }
         if (req.method === 'GET' && path === '/fed/status') {
             res.writeHead(200, { 'content-type': 'application/json' });
             res.end(JSON.stringify(this.opts.getStatus?.() ?? {}));

package/package.json

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