infinicode 2.8.54 → 2.8.57

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

@@ -1324,9 +1324,21 @@ button.act:disabled{opacity:0.5;cursor:default;}
       var rows = data[0], devices = data[1];
       var deviceById = {}, deviceByName = {};
       function norm(v){ return String(v||'').trim().toLowerCase(); }
+      // A stale re-enrollment can leave more than one row with the same
+      // display name. Keep the live/fresh device, never whichever SQLite
+      // happened to return last, because all operator routes are id-keyed.
+      function deviceScore(device){
+        var status=norm(device&&device.status), at=Date.parse(device&&device.last_heartbeat||''), score=0;
+        if(status==='online'||status==='running'||status==='detecting'||status==='connecting') score+=10000;
+        if(Number.isFinite(at)) score+=Math.max(0, Math.floor(at/1000));
+        return score;
+      }
       (Array.isArray(devices)?devices:[]).forEach(function(device){
         deviceById[device.id] = device;
-        if(device.name) deviceByName[norm(device.name)] = device;
+        if(device.name){
+          var key=norm(device.name), current=deviceByName[key];
+          if(!current || deviceScore(device)>deviceScore(current)) deviceByName[key] = device;
+        }
       });
       schedulerDevicesById = deviceById;
       schedulerDevicesByName = deviceByName;
@@ -1336,7 +1348,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
       // legacy robots table has not been populated for that device yet.
       (Array.isArray(devices)?devices:[]).forEach(function(device){
         var already = candidates.some(function(row){
-          return norm(row.id||row.robot_id)===norm(device.id) || norm(row.name)===norm(device.name);
+          return norm(row.id||row.robot_id)===norm(device.id);
         });
         if(!already) candidates.push({id:device.id, name:device.name});
       });
@@ -5313,8 +5325,9 @@ button.act:disabled{opacity:0.5;cursor:default;}
     // name, which is not necessarily the scheduler's robots.id (e.g. an
     // enrolled device's id is a generated dev_xxxx, distinct from its name).
     // Falls back to n.name if telemetry hasn't matched a row yet.
-    function schedRow(n){
-      var row=roboparkByName[String(n.name||'').toLowerCase()] || roboparkByName[n.name], exact=row, keys=(n.telemKeys||[]).concat([String(n.name||'').toLowerCase()]);
+    function schedRow(n){
+      var preferred=schedulerDevice(n), preferredId=preferred&&preferred.id;
+      var row=(preferredId&&roboparkByName[String(preferredId).toLowerCase()]) || roboparkByName[String(n.name||'').toLowerCase()] || roboparkByName[n.name], exact=row, keys=(n.telemKeys||[]).concat([String(n.name||'').toLowerCase(),String(preferredId||'').toLowerCase()]);
       var seen={}, candidates=[];
       for(var rk in roboparkByName){
         var candidate=roboparkByName[rk], cid=candidate&&(candidate.robot_id||candidate.id);
@@ -5324,8 +5337,9 @@ button.act:disabled{opacity:0.5;cursor:default;}
         for(var ki=0;ki<keys.length;ki++){ var key=String(keys[ki]||'').toLowerCase(); if(key&&(label===key||idlabel===key||label.indexOf(key)>-1||key.indexOf(label)>-1)){ matches=true; break; } }
         if(matches) candidates.push(candidate);
       }
-      function readyScore(candidate){
-        var device=schedulerDevicesById[candidate.robot_id||candidate.id]||{}, status=String(candidate.device_status||device.status||'').toLowerCase(), score=0;
+      function readyScore(candidate){
+        var device=schedulerDevicesById[candidate.robot_id||candidate.id]||{}, status=String(candidate.device_status||device.status||'').toLowerCase(), score=0;
+        if(preferredId && String(candidate.robot_id||candidate.id||'')===String(preferredId)) score+=100000;
         if(candidate.production_mode===true||device.production_mode===true) score+=1000;
         if(status==='online'||status==='running'||status==='detecting') score+=500;
         if(candidate.readiness_code==='ready') score+=250;
@@ -5335,12 +5349,14 @@ button.act:disabled{opacity:0.5;cursor:default;}
       candidates.sort(function(a,b){ return readyScore(b)-readyScore(a); });
       return candidates[0]||row;
     }
-    function schedId(n){
-      var row=schedRow(n); if(row&&(row.id||row.robot_id)) return row.id||row.robot_id;
-      if(n.schedulerRobotId) return n.schedulerRobotId;
-      var byName=schedulerDevicesByName[String(n.name||'').toLowerCase()]; if(byName&&byName.id) return byName.id;
-      return n.name;
-    }
+    function schedId(n){
+      // Device ids are authoritative. A legacy robots row may share the
+      // name but have no preview, heartbeat, or hardware inventory.
+      var device=schedulerDevice(n); if(device&&device.id) return device.id;
+      var row=schedRow(n); if(row&&(row.id||row.robot_id)) return row.id||row.robot_id;
+      if(n.schedulerRobotId) return n.schedulerRobotId;
+      return n.name;
+    }
     function closeDrawer(){
       // tell the scheduler to end any live preview so the robot stops its cam
       if(previewOn && drawerId){ var pn=byId[drawerId]; if(pn){ try{ fetch('/robopark/api/robots/'+encodeURIComponent(schedId(pn))+'/preview/stop'+QS,{method:'POST',keepalive:true}); }catch(e){} } }
@@ -5474,10 +5490,18 @@ button.act:disabled{opacity:0.5;cursor:default;}
         refreshDrawer();
       }).catch(function(){});
     }
-    function schedulerDevice(n){
-      var row=schedRow(n), id=row&&(row.robot_id||row.id);
-      return (id&&schedulerDevicesById[id]) || schedulerDevicesById[n.schedulerDeviceId] || schedulerDevicesById[n.schedulerRobotId] || schedulerDevicesByName[String(n.name||'').toLowerCase()] || schedulerDevicesById[n.name] || null;
-    }
+    function schedulerDevice(n){
+      // Deliberately does not call schedRow: telemetry can contain a legacy
+      // robot name, while this lookup must choose the current enrolled device.
+      var ids=[n.schedulerDeviceId,n.schedulerRobotId,n.id,n.nodeId];
+      for(var i=0;i<ids.length;i++) if(ids[i]&&schedulerDevicesById[ids[i]]) return schedulerDevicesById[ids[i]];
+      var names=[n.name,n.displayName,n.label];
+      for(var j=0;j<names.length;j++){
+        var key=String(names[j]||'').toLowerCase();
+        if(key&&schedulerDevicesByName[key]) return schedulerDevicesByName[key];
+      }
+      return null;
+    }
     function deviceList(inv, key, fallback){
       var list=inv&&Array.isArray(inv[key])?inv[key]:[];
       return list.length?list:fallback.map(function(id){ return {id:id,name:id}; });

package/dist/kernel/federation/federation.d.ts

@@ -54,6 +54,8 @@ export interface FederationOptions {
     /** Base URLs of peers to connect to on start (static seeds). */
     seeds?: string[];
     autoUpdate?: boolean;
+    /** Hub/relay npm-release polling interval. Defaults to one minute. */
+    updatePollMs?: number;
     /** Satellite: how to apply an incoming shared config (register providers etc.). */
     applyConfig?: (cfg: SharedConfig) => void | Promise<void>;
     /** Satellite: auto-pull shared config from any hub/relay we connect to. */
@@ -133,6 +135,7 @@ export declare class Federation {
     /** nodeIds we're currently dialing back after an inbound heartbeat/hello. */
     private inboundConnecting;
     private configPullTimer?;
+    private updatePollTimer?;
     readonly configSync: ConfigSync;
     readonly autoUpdate: AutoUpdate;
     readonly compute: ComputeRouter;
@@ -259,6 +262,8 @@ export declare class Federation {
     private maybeAutoPull;
     /** Satellite: re-pull from the first connected hub/relay (periodic refresh). */
     private autoPullFromHub;
+    /** Fetch npm's latest tag, announce it to satellites, then update this hub. */
+    private pollNpmRelease;
     /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
     discoverAndConnect(tag?: string): Promise<number>;
     /**

package/dist/kernel/federation/federation.js

@@ -3,7 +3,7 @@ import { DASHBOARD_HTML } from './dashboard-html.js';
 import { PeerMesh } from './peer-mesh.js';
 import { EventBridge } from './event-bridge.js';
 import { ConfigSync } from './config-sync.js';
-import { AutoUpdate } from './auto-update.js';
+import { AutoUpdate, compareVersions } from './auto-update.js';
 import { performSelfUpdate } from './self-update.js';
 import { ComputeRouter } from './compute-router.js';
 import { TelemetryCollector, loadFromSnapshot, selfNodeStatus, nodeStatusFromPeer } from './telemetry.js';
@@ -32,6 +32,7 @@ export class Federation {
     /** nodeIds we're currently dialing back after an inbound heartbeat/hello. */
     inboundConnecting = new Set();
     configPullTimer;
+    updatePollTimer;
     configSync;
     autoUpdate;
     compute = new ComputeRouter();
@@ -134,6 +135,15 @@ export class Federation {
         if (options.autoPullConfig && options.configPullMs !== 0) {
             this.configPullTimer = setInterval(() => void this.autoPullFromHub(), options.configPullMs ?? 30_000);
         }
+        // The hub owns release discovery. Satellites never poll npm: they only
+        // trust signed mesh announcements from a hub/relay. This makes npm publish
+        // -> fleet update a real loop, while retaining the --auto-update opt-in.
+        if (options.autoUpdate && (identity.role === 'hub' || identity.role === 'relay')) {
+            const pollMs = Math.max(30_000, options.updatePollMs ?? 60_000);
+            void this.pollNpmRelease();
+            this.updatePollTimer = setInterval(() => void this.pollNpmRelease(), pollMs);
+            logger.info(`[federation] npm release watcher enabled (every ${Math.round(pollMs / 1000)}s)`);
+        }
         logger.info(`[federation] node ${identity.displayName} (${identity.role}) online on :${port}`);
     }
     // ── Inbound RPC ────────────────────────────────────────────────────────────
@@ -172,7 +182,10 @@ export class Federation {
                 return reply(env, 'ack', self);
             case 'update.announce': {
                 const peer = this.mesh?.get(env.from);
-                await this.autoUpdate.onAnnounce(env.data, peer?.role ?? 'peer');
+                // Acknowledge immediately. npm can take minutes on a Pi, while the
+                // sender's RPC timeout is intentionally short; the update continues
+                // in the background and exits the supervised mesh process on success.
+                void this.autoUpdate.onAnnounce(env.data, peer?.role ?? 'peer');
                 return reply(env, 'ack', self);
             }
             case 'role.get':
@@ -625,6 +638,30 @@ export class Federation {
         if (hub)
             await this.maybeAutoPull(hub);
     }
+    /** Fetch npm's latest tag, announce it to satellites, then update this hub. */
+    async pollNpmRelease() {
+        try {
+            const response = await fetch('https://registry.npmjs.org/infinicode/latest', {
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok)
+                throw new Error(`npm registry ${response.status}`);
+            const payload = await response.json();
+            const version = typeof payload.version === 'string' ? payload.version.trim() : '';
+            if (!/^\d+(?:\.\d+){1,3}(?:[-+][A-Za-z0-9.-]+)?$/.test(version)) {
+                throw new Error('npm registry returned an invalid version');
+            }
+            await this.mesh?.announceUpdate({ version, channel: 'npm' });
+            const current = this.autoUpdate.currentVersion();
+            if (compareVersions(version, current) > 0) {
+                this.deps.logger.info(`[federation] npm release ${version} announced to fleet; updating ${current} -> ${version}`);
+                await this.autoUpdate.onAnnounce({ version, channel: 'npm' }, this.deps.identity.role);
+            }
+        }
+        catch (err) {
+            this.deps.logger.warn(`[federation] npm release check failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
     async discoverAndConnect(tag) {
         const port = this.deps.options.port ?? DEFAULT_MESH_PORT;
@@ -752,6 +789,8 @@ export class Federation {
         this.lan?.stop();
         if (this.configPullTimer)
             clearInterval(this.configPullTimer);
+        if (this.updatePollTimer)
+            clearInterval(this.updatePollTimer);
         if (this.telemetryTimer)
             clearInterval(this.telemetryTimer);
         this.mesh?.stop();

package/dist/kernel/federation/peer-mesh.d.ts

@@ -10,7 +10,7 @@
  * manage (satellites are accept-only). A satellite never dials us.
  */
 import type { Logger } from '../types.js';
-import type { FederationEnvelope, NodeIdentity, PeerInfo, StreamFrame } from './types.js';
+import type { FederationEnvelope, NodeIdentity, PeerInfo, StreamFrame, UpdateAnnounce } from './types.js';
 import { MeshClient } from './transport-http.js';
 export interface PeerMeshOptions {
     self: NodeIdentity;
@@ -38,6 +38,8 @@ export declare class PeerMesh {
     connected(): PeerInfo[];
     /** Discover + attach a peer at a base URL (manifest probe + open its stream). */
     connect(url: string): Promise<PeerInfo | null>;
+    /** Send a hub/relay version announcement to every currently connected peer. */
+    announceUpdate(announce: UpdateAnnounce): Promise<void>;
     private openStream;
     start(): void;
     private tick;

package/dist/kernel/federation/peer-mesh.js

@@ -22,6 +22,11 @@ export class PeerMesh {
     async connect(url) {
         try {
             const manifest = await this.opts.client.fetchManifest(url);
+            // A hub may discover or seed its own advertised address. Never add self
+            // as a peer: it duplicates the hub in fleet status and can create a
+            // pointless self-stream/update loop.
+            if (manifest.nodeId === this.opts.self.nodeId)
+                return null;
             const peer = {
                 nodeId: manifest.nodeId,
                 displayName: manifest.displayName,
@@ -48,6 +53,17 @@ export class PeerMesh {
             return null;
         }
     }
+    /** Send a hub/relay version announcement to every currently connected peer. */
+    async announceUpdate(announce) {
+        await Promise.all(this.connected().map(async (peer) => {
+            try {
+                await this.opts.client.rpc(peer.url, envelope('update.announce', this.opts.self.nodeId, announce, { to: peer.nodeId }));
+            }
+            catch (err) {
+                this.opts.logger.warn(`[federation] update announce to ${peer.displayName} failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }));
+    }
     openStream(peer) {
         this.streams.get(peer.nodeId)?.(); // close any prior
         const stop = this.opts.client.openStream(peer.url, f => {

package/dist/robopark/auto-start.d.ts

@@ -1,5 +1,5 @@
 export interface ServiceArgs {
-    role: 'hub' | 'robot' | 'control' | 'hub-scheduler' | 'robot-preview-agent' | 'robot-vision-agent';
+    role: 'hub' | 'robot' | 'control' | 'hub-scheduler' | 'robot-runtime' | 'robot-preview-agent' | 'robot-vision-agent';
     name: string;
     command: string;
     args: string[];

package/dist/robopark/auto-start.js

@@ -8,10 +8,10 @@
  *
  * This is used by `robopark setup --auto-start`.
  */
-import { writeFileSync, mkdirSync } from 'node:fs';
+import { existsSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 function shellQuote(s) {
     if (!/[^a-zA-Z0-9_./:=,-]/.test(s))
         return s;
@@ -138,5 +138,31 @@ export function unregisterAutoStart(role, name) {
             return { ok: false, message: `failed: ${e instanceof Error ? e.message : String(e)}` };
         }
     }
-    return { ok: false, message: `unregister not implemented for ${platform}` };
+    if (platform === 'linux') {
+        const unitName = `robopark-${role}-${name.toLowerCase().replace(/[^a-z0-9]+/g, '-')}.service`;
+        const unitPath = `/etc/systemd/system/${unitName}`;
+        const stopped = spawnSync('systemctl', ['disable', '--now', unitName], { encoding: 'utf8' });
+        try {
+            if (existsSync(unitPath))
+                rmSync(unitPath);
+        }
+        catch { /* systemd output is more useful below */ }
+        spawnSync('systemctl', ['daemon-reload'], { stdio: 'ignore' });
+        return {
+            ok: stopped.status === 0 || !existsSync(unitPath),
+            message: `removed systemd unit ${unitName}`,
+        };
+    }
+    if (platform === 'darwin') {
+        const label = `ai.robopark.${role}.${name}`;
+        const plistPath = join(homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+        spawnSync('launchctl', ['unload', plistPath], { stdio: 'ignore' });
+        try {
+            if (existsSync(plistPath))
+                rmSync(plistPath);
+        }
+        catch { /* ignore */ }
+        return { ok: true, message: `removed launchd plist ${plistPath}` };
+    }
+    return { ok: false, message: `unregister not supported on ${platform}` };
 }

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

@@ -0,0 +1,14 @@
+export interface RobotRuntimeOptions {
+    name: string;
+    hubUrl: string;
+    schedulerUrl: string;
+    token: string;
+    port?: string;
+    network?: 'lan' | 'tailscale';
+    enrollmentToken?: string;
+    videoDevice?: string;
+    audioDevice?: string;
+    vision?: boolean;
+    foreground?: boolean;
+}
+export declare function roboparkRobotRuntime(opts: RobotRuntimeOptions): Promise<void>;

package/dist/robopark/robot-runtime.js

@@ -0,0 +1,219 @@
+/**
+ * RoboPark robot runtime.
+ *
+ * One long-lived parent for a robot's mesh satellite, RoboVision camera/audio
+ * service, and preview agent. Starting these as unrelated detached commands
+ * allowed a healthy-looking mesh node with no motion service or no device
+ * inventory. The runtime starts dependencies in order and restarts a child if
+ * it exits unexpectedly.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import { resolveInfinicodeBin } from './serve.js';
+const VISION_URL = 'http://127.0.0.1:5000/api/media/inventory';
+const RESTART_DELAY_MS = 5_000;
+function resetStaleEnrollment() {
+    const configDir = join(homedir(), '.robopark');
+    const tokenPath = join(configDir, 'device_token');
+    const configPath = join(configDir, 'preview_agent.json');
+    try {
+        if (existsSync(tokenPath))
+            rmSync(tokenPath);
+    }
+    catch { /* enrollment will report a real error */ }
+    if (!existsSync(configPath))
+        return;
+    try {
+        const config = JSON.parse(readFileSync(configPath, 'utf8'));
+        delete config.device_id;
+        delete config.device_token;
+        writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    catch {
+        // A malformed optional config must not block first boot.
+    }
+}
+function roboparkCliPath() {
+    // dist/robopark/robot-runtime.js -> package root -> dist/robopark-cli.js
+    const packageRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+    const compiledCli = join(packageRoot, 'dist', 'robopark-cli.js');
+    return existsSync(compiledCli) ? compiledCli : process.argv[1];
+}
+function runtimeLog(label, foreground) {
+    if (foreground)
+        return 'inherit';
+    const logDir = join(homedir(), '.robopark', 'logs');
+    mkdirSync(logDir, { recursive: true });
+    return [
+        'ignore',
+        // spawn() accepts file descriptors, but not WriteStreams before their
+        // asynchronous open event. openSync makes detached startup reliable.
+        openSync(join(logDir, `${label}.log`), 'a'),
+        openSync(join(logDir, `${label}.err.log`), 'a'),
+    ];
+}
+async function waitForVision() {
+    const deadline = Date.now() + 120_000;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(VISION_URL, { signal: AbortSignal.timeout(1_500) });
+            if (response.ok)
+                return true;
+        }
+        catch {
+            // Dependency installation on a fresh Pi can take a little while.
+        }
+        await new Promise(resolve => setTimeout(resolve, 1_000));
+    }
+    return false;
+}
+export async function roboparkRobotRuntime(opts) {
+    const port = opts.port ?? '47913';
+    const network = opts.network ?? 'lan';
+    const foreground = opts.foreground === true;
+    const cli = roboparkCliPath();
+    const children = [];
+    let stopping = false;
+    let recycling = false;
+    const infinicode = await resolveInfinicodeBin();
+    if (!infinicode)
+        throw new Error('could not resolve infinicode CLI');
+    children.push({
+        label: 'mesh',
+        command: infinicode.node,
+        args: [infinicode.script, 'serve', '--role', 'satellite', '--name', opts.name,
+            '--port', port, '--token', opts.token, '--seed', opts.hubUrl,
+            network === 'tailscale' ? '--tailscale' : '--lan', '--auto-update', '--supervised'],
+    });
+    if (opts.vision !== false) {
+        children.push({
+            label: 'vision',
+            command: process.execPath,
+            args: [cli, 'vision-agent', '--foreground', '--port', '5000',
+                '--motion-webhook-url', 'http://127.0.0.1:5057/'],
+        });
+    }
+    const previewArgs = [cli, 'preview-agent', '--foreground',
+        '--scheduler-url', opts.schedulerUrl, '--robot-id', opts.name,
+        '--video-device', opts.videoDevice ?? 'auto', '--audio-device', opts.audioDevice ?? 'default',
+        '--save-config'];
+    if (opts.vision !== false)
+        previewArgs.push('--robovision-url', 'http://127.0.0.1:5000');
+    if (opts.enrollmentToken)
+        previewArgs.push('--enrollment-token', opts.enrollmentToken);
+    const preview = { label: 'preview', command: process.execPath, args: previewArgs };
+    const start = (entry) => {
+        const child = spawn(entry.command, entry.args, {
+            env: { ...process.env, ...entry.env, ROBOPARK_ROBOT_RUNTIME: '1' },
+            stdio: runtimeLog(`robot-${opts.name}-${entry.label}`, foreground),
+        });
+        entry.child = child;
+        child.on('error', error => console.error(chalk.red(`  ${entry.label} failed to start: ${error.message}`)));
+        child.on('exit', (code, signal) => {
+            entry.child = undefined;
+            if (stopping)
+                return;
+            // A clean mesh exit is how /update signals that npm replaced this
+            // package. Reload every child so the robot runs one coherent release.
+            if (entry.label === 'mesh' && code === 0) {
+                void recycleAfterMeshUpdate();
+                return;
+            }
+            if (recycling)
+                return;
+            console.error(chalk.yellow(`  ${entry.label} exited (${signal ?? code ?? 'unknown'}); restarting in 5s`));
+            setTimeout(() => { if (!stopping)
+                start(entry); }, RESTART_DELAY_MS);
+        });
+    };
+    const stopChild = async (entry) => {
+        const child = entry.child;
+        if (!child)
+            return;
+        await new Promise(resolve => {
+            const timer = setTimeout(resolve, 5_000);
+            child.once('exit', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                clearTimeout(timer);
+                resolve();
+            }
+        });
+    };
+    const recycleAfterMeshUpdate = async () => {
+        if (stopping || recycling)
+            return;
+        recycling = true;
+        console.log(chalk.dim('  mesh updated; restarting RoboVision and preview on the new package...'));
+        await Promise.all([...children.filter(entry => entry.label !== 'mesh'), preview].map(stopChild));
+        if (stopping)
+            return;
+        start(children[0]);
+        if (opts.vision !== false) {
+            start(children[1]);
+            if (!await waitForVision()) {
+                console.error(chalk.red('  RoboVision did not recover after the mesh update; retrying in 5s'));
+                // Stop the partially restarted stack before retrying. Otherwise a
+                // second mesh child would collide with the existing listener.
+                await Promise.all([...children, preview].map(stopChild));
+                recycling = false;
+                setTimeout(() => { if (!stopping)
+                    void recycleAfterMeshUpdate(); }, RESTART_DELAY_MS);
+                return;
+            }
+        }
+        start(preview);
+        recycling = false;
+        console.log(chalk.green('  robot runtime updated and healthy'));
+    };
+    console.log(chalk.bold('\n  robopark robot up'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  robot:     ${chalk.cyan(opts.name)}`);
+    console.log(`  scheduler: ${chalk.cyan(opts.schedulerUrl)}`);
+    console.log(`  network:   ${chalk.cyan(network)}`);
+    console.log(`  services:  ${opts.vision === false ? 'mesh + preview' : 'mesh + RoboVision + preview'}`);
+    console.log();
+    if (opts.enrollmentToken) {
+        console.log(chalk.dim('  clearing stale device identity for fresh enrollment…'));
+        resetStaleEnrollment();
+    }
+    // The mesh can reconnect independently; camera/audio must be healthy before
+    // preview sends its first inventory heartbeat or opens the motion webhook.
+    start(children[0]);
+    if (opts.vision !== false) {
+        start(children[1]);
+        console.log(chalk.dim('  waiting for RoboVision camera/audio inventory…'));
+        if (!await waitForVision()) {
+            stopping = true;
+            for (const entry of children)
+                entry.child?.kill('SIGTERM');
+            throw new Error('RoboVision did not become healthy at http://127.0.0.1:5000 within 120s');
+        }
+        console.log(chalk.green('  ✓ RoboVision ready; starting preview agent'));
+    }
+    start(preview);
+    const shutdown = () => {
+        stopping = true;
+        for (const entry of [...children, preview])
+            entry.child?.kill('SIGTERM');
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+    await new Promise(resolve => {
+        const check = setInterval(() => {
+            if (stopping && ![...children, preview].some(entry => entry.child)) {
+                clearInterval(check);
+                resolve();
+            }
+        }, 250);
+    });
+}