infinicode 2.8.63 → 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/dist/kernel/federation/federation.js

@@ -400,6 +400,28 @@ export class Federation {
      * until the run finishes (short tasks).
      */
     async dispatch(task, need, opts) {
+        const self = this.deps.identity;
+        const requestedSelf = need?.preferNodeId === self.nodeId ||
+            need?.preferName?.toLowerCase() === self.displayName.toLowerCase();
+        if (requestedSelf) {
+            const localCaps = new Set(this.describeWithBackends().capabilities);
+            if (!task.capabilities.every(capability => localCaps.has(capability))) {
+                this.deps.logger.warn('[federation] local node lacks a required dispatch capability');
+                return null;
+            }
+            const runId = newId();
+            this.runs.set(runId, {
+                runId,
+                status: 'running',
+                description: task.description,
+                startedAt: Date.now(),
+            });
+            void this.runTaskAsync(runId, task);
+            const record = opts?.wait
+                ? await this.awaitRun(runId, opts.timeoutMs ?? 120_000)
+                : this.runs.get(runId);
+            return { peerId: self.nodeId, runId, record };
+        }
         if (!this.mesh)
             return null;
         const peers = this.mesh.connected();

package/dist/robopark/discovery.d.ts

@@ -56,7 +56,9 @@ export declare function readInfinicodeFederation(): {
     port?: number;
 };
 /** Build the full discovered context for this environment. */
-export declare function discoverContext(): Promise<DiscoveredContext>;
+export declare function discoverContext(options?: {
+    lan?: boolean;
+}): Promise<DiscoveredContext>;
 /** Generate a random token for mesh auth or scheduler enrollment. */
 export declare function generateToken(length?: number): string;
 export {};

package/dist/robopark/discovery.js

@@ -8,6 +8,7 @@
  *   - Running infinicode nodes → reuse mesh identity + token
  */
 import { execa } from 'execa';
+import dgram from 'node:dgram';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir, hostname } from 'node:os';
 import { join } from 'node:path';
@@ -45,11 +46,42 @@ export async function discoverTailscale() {
         .filter(p => p.ip !== 'unknown');
 }
 /** Scan LAN UDP beacons on the default mesh discovery port. */
-export async function discoverLan(port = 47915, timeoutMs = 3000) {
-    // LAN discovery currently relies on the infinicode beacon protocol.
-    // For auto-setup we reuse Tailscale when available; LAN fallback is a TODO
-    // once the beacon protocol is stable enough to parse here.
-    return [];
+export async function discoverLan(port = 47915, timeoutMs = 6000) {
+    return new Promise(resolve => {
+        const peers = new Map();
+        const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                socket.close();
+            }
+            catch { /* already closed */ }
+            resolve([...peers.values()]);
+        };
+        socket.on('message', (buffer, remote) => {
+            try {
+                const beacon = JSON.parse(buffer.toString('utf8'));
+                if (beacon.t !== 'ICMESH1' || !beacon.nodeId || !Number.isInteger(beacon.meshPort))
+                    return;
+                peers.set(beacon.nodeId, {
+                    name: beacon.name ?? beacon.nodeId,
+                    ip: remote.address,
+                    tags: beacon.tag ? [beacon.tag] : undefined,
+                    online: true,
+                    source: 'lan',
+                });
+            }
+            catch {
+                // Ignore unrelated UDP traffic on the discovery port.
+            }
+        });
+        socket.once('error', finish);
+        socket.bind({ port, exclusive: false });
+        setTimeout(finish, timeoutMs).unref();
+    });
 }
 /** Read a Tailscale auth key from common locations. */
 export function findTailscaleAuthKey() {
@@ -115,8 +147,12 @@ export function readInfinicodeFederation() {
     return {};
 }
 /** Build the full discovered context for this environment. */
-export async function discoverContext() {
-    const peers = await discoverTailscale();
+export async function discoverContext(options = {}) {
+    const [tailnetPeers, lanPeers] = await Promise.all([
+        discoverTailscale(),
+        options.lan ? discoverLan() : Promise.resolve([]),
+    ]);
+    const peers = [...lanPeers, ...tailnetPeers];
     // Exclude this machine from the fleet tables.
     const selfName = hostname();
     const others = peers.filter(p => p.name !== selfName && p.online);

package/dist/robopark/setup.js

@@ -50,8 +50,8 @@ function commandString(argv) {
     return argv.map(a => /[^a-zA-Z0-9_./:=,-]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a).join(' ');
 }
 export async function roboparkSetup(config, opts) {
-    const ctx = await discoverContext();
     const role = opts.role ?? 'control';
+    const ctx = await discoverContext({ lan: role === 'robot' && !opts.tailscale });
     const token = opts.token ?? ctx.meshToken ?? generateToken();
     const port = opts.port ? parseInt(opts.port, 10) : DEFAULT_MESH_PORT;
     const name = opts.name ?? ctx.localName;
@@ -140,11 +140,37 @@ async function setupRobot(config, opts, ctx, internal) {
     }
     const network = opts.tailscale ? 'tailscale' : 'lan';
     const networkFlag = network === 'tailscale' ? '--tailscale' : '--lan';
-    const hubUrl = opts.hub ?? (ctx.hub ? `http://${ctx.hub.ip}:${internal.port}` : undefined);
+    let hubUrl = opts.hub ?? (ctx.hub ? `http://${ctx.hub.ip}:${internal.port}` : undefined);
     if (!hubUrl) {
         console.log(chalk.red('  ✗ no hub discovered. Pass --hub http://HUB_IP:47913'));
         return;
     }
+    if (network === 'lan') {
+        const reachable = async (url) => {
+            try {
+                const response = await fetch(`${url.replace(/\/+$/, '')}/fed/status`, {
+                    headers: { Authorization: `Bearer ${internal.token}` },
+                    signal: AbortSignal.timeout(2500),
+                });
+                return response.ok;
+            }
+            catch {
+                return false;
+            }
+        };
+        if (!await reachable(hubUrl)) {
+            const discovered = ctx.hub?.source === 'lan'
+                ? `http://${ctx.hub.ip}:${internal.port}`
+                : undefined;
+            if (!discovered || !await reachable(discovered)) {
+                console.log(chalk.red(`  ✗ hub is unreachable from this robot: ${hubUrl}`));
+                console.log(chalk.dim('  verify the hub is running with --lan, then rerun setup'));
+                return;
+            }
+            console.log(chalk.yellow(`  âš  supplied hub unreachable; using LAN-discovered hub ${discovered}`));
+            hubUrl = discovered;
+        }
+    }
     const fed = {
         ...(config.get('federation') ?? {}),
         enabled: true,

package/dist/robopark/stop-all.js

@@ -119,8 +119,9 @@ function stopAllUnix() {
         const fuser = spawnSync('fuser', ['-n', 'tcp', String(port)], { encoding: 'utf8' });
         const pids = [...new Set(`${lsof.stdout ?? ''} ${fuser.stdout ?? ''}`
                 .split(/\s+/)
+                .filter(Boolean)
                 .map(s => Number(s.trim()))
-                .filter(Number.isFinite))];
+                .filter(pid => Number.isFinite(pid) && pid > 1))];
         for (const pid of pids) {
             if (pid === self || killedPids.includes(pid))
                 continue;

package/package.json

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