infinicode 2.8.99 → 2.8.102

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

@@ -790,7 +790,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
       <h3><span>Live activity</span><span style="color:var(--muted)" id="pk-src">/fed/stream</span></h3>
       <div class="rows" id="pk-rows"></div>
     </aside>
-    <div class="pk-hint">drag to pan · scroll to zoom · <b>click a robot</b> for cam / mic / speaker</div>
+    <div class="pk-hint">drag to pan · scroll to zoom · <b>click a robot</b> for cam / mic / speaker · <b>ctrl+drag a robot</b> to reposition (persists)</div>
   </div>
   <div class="pk-drawer" id="pk-drawer">
     <div class="pk-dh">
@@ -4078,21 +4078,27 @@ button.act:disabled{opacity:0.5;cursor:default;}
     // Pond / curved water feature at the lower-left of the plaza.
     var POND={cx:0.18*15, cy:0.84*8, rx:2.4, ry:1.1};
     // Street traffic along the top road. Each car has x, y (world), color,
-    // a per-car speed (world units / second), a direction (+1 = right, -1 =
-    // left). y is one of two lane bands (≈ -0.65 for outbound, ≈ -1.18 for
-    // inbound) so cars don't overlap. Speeds are deliberately varied and
-    // fast enough to read as movement at 60fps — the road is short, so
-    // a 4-7s pass across the screen feels natural.
+    // a per-car base speed (world units / second), a direction (+1 = right,
+    // -1 = left), and a per-frame jitter range so cars never settle into
+    // a stable cluster. y is one of two lane bands (≈ -0.65 for outbound,
+    // ≈ -1.18 for inbound) so cars don't overlap.
+    //
+    // Stability fix: the previous version always re-spawned a wrapped car
+    // at x = -0.5 (or PARK_W + 0.5) — every car in the same lane teleported
+    // to the same spot, so the slowest car instantly caught the fastest
+    // one and the whole lane collapsed into a clump. We now (a) spawn
+    // each car at a random x within the visible road, and (b) add a
+    // ±5% per-frame speed jitter so cars gradually drift apart. Speeds
+    // are also more spread (2.2 → 4.6) so the natural ordering stays
+    // stable long enough to look like real traffic.
     var ROAD_Y0=-1.5, ROAD_Y1=-0.35;
     var CARS=[
-      {x:1.5,  y:-0.65, color:'#f2c14e', speed:3.2, dir:+1},
-      {x:4.0,  y:-1.18, color:'#7fb4ff', speed:3.6, dir:-1},
-      {x:6.5,  y:-0.65, color:'#e0a23c', speed:2.8, dir:+1},
-      {x:9.0,  y:-1.18, color:'#ff7e6e', speed:4.0, dir:-1},
-      {x:11.5, y:-0.65, color:'#d8d8e0', speed:3.0, dir:+1},
-      {x:0.5,  y:-1.18, color:'#5b8bd6', speed:3.4, dir:-1},
-      {x:13.0, y:-0.65, color:'#c87ed4', speed:2.6, dir:+1},
-      {x:7.0,  y:-1.18, color:'#f2c14e', speed:3.8, dir:-1},
+      {x:1.5,  y:-0.65, color:'#f2c14e', speed:2.4, dir:+1},
+      {x:6.5,  y:-0.65, color:'#e0a23c', speed:3.6, dir:+1},
+      {x:11.5, y:-0.65, color:'#d8d8e0', speed:4.4, dir:+1},
+      {x:4.0,  y:-1.18, color:'#7fb4ff', speed:2.6, dir:-1},
+      {x:9.0,  y:-1.18, color:'#ff7e6e', speed:3.4, dir:-1},
+      {x:0.5,  y:-1.18, color:'#5b8bd6', speed:4.2, dir:-1},
     ];
     // Per-car phase offsets so headlights / taillights / wheels don't all
     // blink in lockstep — gives a natural "different cars, different
@@ -4369,12 +4375,16 @@ button.act:disabled{opacity:0.5;cursor:default;}
           connected: match?!!match.connected:false,
           load: (match&&match.load!=null)?match.load:0,
           platform: match?(match.platform||''):'', version: match?(match.version||'?'):'—',
-          site: match?(match.site||''):'', caps: match?(match.capabilities||[]):[],
-          schedulerRobotId: match?(match.schedulerRobotId||match.schedulerDeviceId||''):'',
-          schedulerDeviceId: match?(match.schedulerDeviceId||match.schedulerRobotId||''):'',
+          site: match?(match.site||''):'', caps: match?(match.capabilities||[]):[],
+          schedulerRobotId: match?(match.schedulerRobotId||match.schedulerDeviceId||''):'',
+          schedulerDeviceId: match?(match.schedulerDeviceId||match.schedulerRobotId||''):'',
           telemKeys: [slot.label.toLowerCase()].concat(slot.keys||[]).concat(match?[(match.displayName||'').toLowerCase()]:[]),
+          // slotId is the stable handle we use to persist operator-
+          // chosen positions. slotNx/slotNy are the preset's default
+          // coordinates so the user can always reset back.
+          slotId: slot.id, slotNx: slot.nx, slotNy: slot.ny,
           wx:wx, wy:wy, _hit:prevHit(id)
-        };
+        };
         // Attach a status derived from the latest scheduler telemetry
         // (push-poll, so it can lag up to 3s behind /fed/status).
         if(kind === 'robot'){
@@ -4406,6 +4416,10 @@ button.act:disabled{opacity:0.5;cursor:default;}
       if(!s) return;
       nodes = layout(s.nodes||[]);
       byId={}; nodes.forEach(function(n){ byId[n.id]=n; });
+      // re-apply any persisted Ctrl+drag overrides on top of the
+      // fresh layout (the server may have also returned updated
+      // slot nx/ny — those go through the override map too)
+      _applyPosOverrides();
       // if not streaming, animate from the polled activity tail
       if(!es || es.readyState!==1){ (s.activity||[]).forEach(function(e){ ingest(e.f||e, true); }); }
     }
@@ -4450,16 +4464,187 @@ button.act:disabled{opacity:0.5;cursor:default;}
     }
 
     // ── canvas + projection ──
+    // State for Ctrl+drag robot repositioning on the park map. When
+    // the user holds Ctrl and mousedown's a robot, the canvas stops
+    // panning and instead drags that node around. On mouseup, the
+    // new (nx, ny) is written to _parkPosOverrides and pushed to
+    // the scheduler via a debounced PUT. Survives reloads because
+    // the server stores nx/ny in the character_presets table.
+    var _parkPosOverrides = {};   // presetId -> {nx, ny} (normalized 0..1)
+    var _dragNode = null;         // the robot node currently being dragged
+    var _dragOffset = {x:0, y:0}; // screen-space offset from node center
+    var _posSaveTimer = null;     // debounce timer for the server PUT
+    var _posSaveQueue = {};       // presetId -> {nx, ny} pending save
+    function _isoToWorld(sx, sy){
+      // Inverse of iso() in the same coordinate system. Given a
+      // screen point, return the (wx, wy) world point. Used by the
+      // Ctrl+drag handler to translate a mouse position back into
+      // the iso coordinate space so the robot follows the cursor.
+      var dx = (sx - (W-300)/2 - cam.x) / (TW*cam.z);
+      var dy = (sy - H*0.42 - cam.y) / (TH*cam.z);
+      // from iso(): dx = (wx-PARK_W/2) - (wy-PARK_D/2); dy = (wx-PARK_W/2) + (wy-PARK_D/2)
+      // so wx = (dx+dy)/2 + PARK_W/2; wy = (dy-dx)/2 + PARK_D/2
+      return { x: (dx+dy)*0.5 + PARK_W*0.5, y: (dy-dx)*0.5 + PARK_D*0.5 };
+    }
+    function _applyPosOverrides(){
+      // Walk nodes and override their wx/wy from _parkPosOverrides if
+      // we have a stored position. The slot's default nx/ny stays in
+      // node.slotNx/slotNy so the user can "reset" back to defaults
+      // if we ever expose that control.
+      for(var i=0; i<nodes.length; i++){
+        var n = nodes[i];
+        if(!n.slotId) continue;
+        var ov = _parkPosOverrides[n.slotId];
+        if(ov){
+          n.wx = Math.max(0, Math.min(PARK_W, ov.nx * PARK_W));
+          n.wy = Math.max(0, Math.min(PARK_D, ov.ny * PARK_D));
+          n._posOverridden = true;
+        } else if(n._posOverridden){
+          // The server just gave us a fresh layout and we don't have
+          // a local override — fall back to the slot's default position.
+          n.wx = n.slotNx * PARK_W;
+          n.wy = n.slotNy * PARK_D;
+          n._posOverridden = false;
+        }
+      }
+    }
+    function _schedulePosSave(){
+      // Debounce: collapse a flurry of drag-end events into one
+      // PUT after 350ms of quiet. Saves queue is merged so the final
+      // PUT always reflects the latest position for each preset.
+      if(_posSaveTimer) clearTimeout(_posSaveTimer);
+      _posSaveTimer = setTimeout(_flushPosSaves, 350);
+    }
+    function _flushPosSaves(){
+      var entries = [];
+      for(var id in _posSaveQueue){
+        if(Object.prototype.hasOwnProperty.call(_posSaveQueue, id)){
+          entries.push({ id: id, nx: _posSaveQueue[id].nx, ny: _posSaveQueue[id].ny });
+        }
+      }
+      _posSaveQueue = {};
+      _posSaveTimer = null;
+      if(!entries.length) return;
+      // Persist to the scheduler. We POST to the dedicated
+      // /api/character-presets/positions batch endpoint which clamps
+      // nx/ny to [0.04, 0.96] so a stray drag can't park a robot
+      // off the island.
+      var body = JSON.stringify({ positions: entries });
+      try{
+        fetch('/api/character-presets/positions'+QS, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: body,
+          keepalive: true
+        }).then(function(r){
+          if(r.ok) return r.json();
+          throw new Error('HTTP '+r.status);
+        }).then(function(j){
+          if(typeof showOut === 'function'){
+            showOut('park position saved · '+(j.updated||entries.length)+' preset'+(entries.length===1?'':'s'));
+          }
+        }).catch(function(err){
+          if(typeof showOut === 'function') showOut('park position save failed: '+err.message);
+        });
+      }catch(e){ /* offline — keep override in memory */ }
+    }
+    function _hitTestNode(mx, my){
+      // Walk all visible nodes and return the first whose hit-box
+      // contains (mx, my). Mirrors the existing click hit-test
+      // but returns the node directly (and skips early if a drag
+      // is already in progress).
+      for(var i=0; i<nodes.length; i++){
+        var n = nodes[i];
+        var hb = n._hit;
+        if(hb && mx>=hb.x && mx<=hb.x+hb.w && my>=hb.y && my<=hb.y+hb.h){
+          return n;
+        }
+      }
+      return null;
+    }
     function ensure(){
       if(C) return;
       C=$('pk-canvas'); X=C.getContext('2d'); t0=performance.now();
       DPR=Math.max(1,Math.min(2,window.devicePixelRatio||1));
-      var d=false,px,py;
-      C.addEventListener('mousedown',function(e){d=true;px=e.clientX;py=e.clientY;});
-      window.addEventListener('mouseup',function(){d=false;});
-      window.addEventListener('mousemove',function(e){ if(!d)return; cam.x+=e.clientX-px; cam.y+=e.clientY-py; px=e.clientX; py=e.clientY; });
+      // Panning: drag on the canvas (no Ctrl) pans the iso camera.
+      // Ctrl+drag on a robot reposition the robot on the park map.
+      // Each gesture is mutually exclusive — we keep one _isPanning
+      // flag and one _dragNode at a time.
+      var _isPanning = false;
+      var _px = 0, _py = 0;
+      C.addEventListener('mousedown',function(e){
+        var r = C.getBoundingClientRect();
+        var mx = e.clientX - r.left;
+        var my = e.clientY - r.top;
+        // Ctrl+drag: if a robot is under the cursor, pick it up.
+        // Only ROBOT nodes are draggable — the hub, parked cars in the
+        // lot, and ghosts for offline nodes stay locked to their slot.
+        if(e.ctrlKey){
+          var hit = _hitTestNode(mx, my);
+          if(hit && hit.slotId && hit.kind === 'robot'){
+            _dragNode = hit;
+            var p = iso(hit.wx, hit.wy);
+            _dragOffset.x = mx - p.x;
+            _dragOffset.y = my - p.y;
+            // prevent text selection while dragging
+            e.preventDefault();
+            return;
+          }
+        }
+        // otherwise: start a pan
+        _isPanning = true;
+        _px = e.clientX; _py = e.clientY;
+      });
+      window.addEventListener('mouseup',function(){
+        if(_dragNode){
+          // commit the drag: record override, schedule server save
+          var nx = _dragNode.wx / PARK_W;
+          var ny = _dragNode.wy / PARK_D;
+          var id = _dragNode.slotId;
+          if(id){
+            _parkPosOverrides[id] = { nx: nx, ny: ny };
+            _posSaveQueue[id] = { nx: nx, ny: ny };
+            _schedulePosSave();
+          }
+          _dragNode = null;
+        }
+        _isPanning = false;
+      });
+      window.addEventListener('mousemove',function(e){
+        if(_dragNode){
+          var r = C.getBoundingClientRect();
+          var mx = e.clientX - r.left;
+          var my = e.clientY - r.top;
+          // screen point = mouse minus the original grab offset, so
+          // the robot doesn't snap its center to the cursor
+          var worldPt = _isoToWorld(mx - _dragOffset.x, my - _dragOffset.y);
+          // clamp to the visible grass rectangle (with a small
+          // inner margin so the avatar doesn't get clipped by the
+          // gold wall or the hedge)
+          var MARGIN = 0.4;
+          _dragNode.wx = Math.max(MARGIN, Math.min(PARK_W - MARGIN, worldPt.x));
+          _dragNode.wy = Math.max(MARGIN, Math.min(PARK_D - MARGIN, worldPt.y));
+          return;
+        }
+        if(!_isPanning) return;
+        cam.x += e.clientX - _px;
+        cam.y += e.clientY - _py;
+        _px = e.clientX; _py = e.clientY;
+      });
+      // Escape cancels an in-progress drag without saving
+      window.addEventListener('keydown',function(e){
+        if((e.key === 'Escape' || e.key === 'Esc') && _dragNode){
+          // restore to the original override (or slot default)
+          _dragNode.wx = _dragNode.slotNx * PARK_W;
+          _dragNode.wy = _dragNode.slotNy * PARK_D;
+          _dragNode = null;
+        }
+      });
       C.addEventListener('wheel',function(e){ e.preventDefault(); var f=e.deltaY<0?1.08:0.925; cam.z=Math.max(.5,Math.min(2.4,cam.z*f)); },{passive:false});
       C.addEventListener('click',function(e){
+        // Suppress the click that fires at the end of a drag — we
+        // don't want a single drag-release to also open the drawer.
+        if(_dragNode) return;
         var r=C.getBoundingClientRect(), mx=e.clientX-r.left, my=e.clientY-r.top, hit=null;
         for(var i=0;i<nodes.length;i++){ var hb=nodes[i]._hit; if(hb&&mx>=hb.x&&mx<=hb.x+hb.w&&my>=hb.y&&my<=hb.y+hb.h) hit=nodes[i]; }
         if(hit){ openDrawer(hit.id); if(String(hit.id).indexOf('pad:')!==0) selectNode(hit.id, hit.name); }
@@ -4605,9 +4790,11 @@ button.act:disabled{opacity:0.5;cursor:default;}
       //      the warm sun")
       // The underside and drop shadow give the park real depth so it
       // doesn't look like a flat sticker on the sky.
-      // Build the grass perimeter polygon once (offset slightly outward
-      // so the gold rim sits just outside the turf edge).
-      var GRASS_RIM = 0.18; // world units of gold rim thickness
+      // Build the grass perimeter polygon once (the same corners the
+      // grass field uses, so the gold wall's top edge sits flush
+      // against the grass). We use grassPerim(0) — no offset — for
+      // the walls, and the perimeter itself is used again later for
+      // the bottom face of the floating island (see UNDERSIDE_LIFT).
       function grassPerim(offset){
         // Use the same world corners as the grass field, offset outward.
         var o = offset;
@@ -4724,39 +4911,80 @@ button.act:disabled{opacity:0.5;cursor:default;}
         X.fill();
       }
       X.restore();
-      // 3. GOLD RIM — thick gold band tracing the grass perimeter.
-      //    Drawn AFTER the underside so the top edge of the gold
-      //    sits flush with the top of the grass. Two strokes: a wide
-      //    gold core + a thin lighter inner highlight on the top edge.
-      var rimOuter = grassPerim(GRASS_RIM);
+      // 3. RAISED GOLD WALLS — proper 3D parapet around the park.
+      //    The wall follows the grass perimeter (4-corner rectangle).
+      //    Each side has a visible front face that extends downward in
+      //    screen space, plus a thin top-edge highlight that catches
+      //    the warm sun light. Drawn AFTER the underside so the top
+      //    edge of the wall sits flush with the top of the grass.
+      //
+      //    Geometry: the wall's TOP edge is the grass perimeter line.
+      //    Its BOTTOM edge is the same line shifted down by WALL_H
+      //    pixels. We draw each of the 4 sides as a quad (TL, TR,
+      //    BR, BL), then trace a thin gold line along the top of
+      //    each side for the highlight.
       var rimInner = grassPerim(0);
-      var rimOuterScreen = rimOuter.map(function(p){ return iso(p[0], p[1]); });
       var rimInnerScreen = rimInner.map(function(p){ return iso(p[0], p[1]); });
+      var WALL_H = 26 * z;   // wall height in screen pixels
+      // Build bottom-edge screen points by shifting each top point
+      // down by WALL_H.
+      var rimBotScreen = rimInnerScreen.map(function(s){
+        return { x: s.x, y: s.y + WALL_H };
+      });
+      // Front face: a single closed polygon (the grass perimeter top
+      // + the grass perimeter bottom, traversed in reverse). Drawn
+      // in two passes — first a darker base, then a lighter overlay
+      // stripe near the top to give the wall some "warm-light from
+      // above" shading.
       X.save();
-      // outer glow
-      var glowGrad = X.createLinearGradient(0, rimOuterScreen[0].y - 30, 0, rimOuterScreen[3].y + 30);
-      X.fillStyle = 'rgba(255, 200, 110, 0.0)';
-      // fill the rim band as a quad
+      // base wall (slightly darker gold)
+      X.fillStyle = 'rgba(176, 124, 44, 0.96)';
       X.beginPath();
-      X.moveTo(rimOuterScreen[0].x, rimOuterScreen[0].y);
-      X.lineTo(rimOuterScreen[1].x, rimOuterScreen[1].y);
-      X.lineTo(rimOuterScreen[2].x, rimOuterScreen[2].y);
-      X.lineTo(rimOuterScreen[3].x, rimOuterScreen[3].y);
+      X.moveTo(rimInnerScreen[0].x, rimInnerScreen[0].y);
+      X.lineTo(rimInnerScreen[1].x, rimInnerScreen[1].y);
+      X.lineTo(rimInnerScreen[2].x, rimInnerScreen[2].y);
+      X.lineTo(rimInnerScreen[3].x, rimInnerScreen[3].y);
+      X.lineTo(rimBotScreen[3].x, rimBotScreen[3].y);
+      X.lineTo(rimBotScreen[2].x, rimBotScreen[2].y);
+      X.lineTo(rimBotScreen[1].x, rimBotScreen[1].y);
+      X.lineTo(rimBotScreen[0].x, rimBotScreen[0].y);
       X.closePath();
       X.fill();
-      // gold band via two strokes: thick base + thin highlight
-      X.strokeStyle = 'rgba(255, 196, 92, 0.95)';  // base gold
-      X.lineWidth = 5.0*z;
+      // warm-light gradient overlay — fades from bright gold at the
+      // top of the wall to transparent at the bottom, so the wall
+      // reads as if the top is catching the sun and the bottom is
+      // in shadow.
+      var wallGrad = X.createLinearGradient(0, rimInnerScreen[0].y, 0, rimInnerScreen[0].y + WALL_H);
+      wallGrad.addColorStop(0,    'rgba(255, 226, 132, 0.85)');
+      wallGrad.addColorStop(0.35, 'rgba(255, 196, 92, 0.55)');
+      wallGrad.addColorStop(1,    'rgba(176, 124, 44, 0)');
+      X.fillStyle = wallGrad;
       X.beginPath();
       X.moveTo(rimInnerScreen[0].x, rimInnerScreen[0].y);
       X.lineTo(rimInnerScreen[1].x, rimInnerScreen[1].y);
       X.lineTo(rimInnerScreen[2].x, rimInnerScreen[2].y);
       X.lineTo(rimInnerScreen[3].x, rimInnerScreen[3].y);
+      X.lineTo(rimBotScreen[3].x, rimBotScreen[3].y);
+      X.lineTo(rimBotScreen[2].x, rimBotScreen[2].y);
+      X.lineTo(rimBotScreen[1].x, rimBotScreen[1].y);
+      X.lineTo(rimBotScreen[0].x, rimBotScreen[0].y);
+      X.closePath();
+      X.fill();
+      // outer dark base line at the bottom of the wall (the bottom
+      // edge against the sky) — sells the "raised" effect
+      X.strokeStyle = 'rgba(124, 84, 28, 0.95)';
+      X.lineWidth = 1.4 * z;
+      X.beginPath();
+      X.moveTo(rimBotScreen[0].x, rimBotScreen[0].y);
+      X.lineTo(rimBotScreen[1].x, rimBotScreen[1].y);
+      X.lineTo(rimBotScreen[2].x, rimBotScreen[2].y);
+      X.lineTo(rimBotScreen[3].x, rimBotScreen[3].y);
       X.closePath();
       X.stroke();
-      // inner highlight (thinner, brighter)
-      X.strokeStyle = 'rgba(255, 232, 158, 0.95)';
-      X.lineWidth = 1.4*z;
+      // top edge — gold band right at the grass line, with a thin
+      // lighter highlight on top to catch the sun.
+      X.strokeStyle = 'rgba(196, 138, 48, 0.95)';
+      X.lineWidth = 4.0 * z;
       X.beginPath();
       X.moveTo(rimInnerScreen[0].x, rimInnerScreen[0].y);
       X.lineTo(rimInnerScreen[1].x, rimInnerScreen[1].y);
@@ -4764,16 +4992,26 @@ button.act:disabled{opacity:0.5;cursor:default;}
       X.lineTo(rimInnerScreen[3].x, rimInnerScreen[3].y);
       X.closePath();
       X.stroke();
-      // outer deep-gold edge (slightly darker outer stroke for definition)
-      X.strokeStyle = 'rgba(190, 134, 48, 0.85)';
-      X.lineWidth = 1.2*z;
+      // bright top highlight (thin, hottest color)
+      X.strokeStyle = 'rgba(255, 232, 158, 0.95)';
+      X.lineWidth = 1.2 * z;
       X.beginPath();
-      X.moveTo(rimOuterScreen[0].x, rimOuterScreen[0].y);
-      X.lineTo(rimOuterScreen[1].x, rimOuterScreen[1].y);
-      X.lineTo(rimOuterScreen[2].x, rimOuterScreen[2].y);
-      X.lineTo(rimOuterScreen[3].x, rimOuterScreen[3].y);
+      X.moveTo(rimInnerScreen[0].x, rimInnerScreen[0].y);
+      X.lineTo(rimInnerScreen[1].x, rimInnerScreen[1].y);
+      X.lineTo(rimInnerScreen[2].x, rimInnerScreen[2].y);
+      X.lineTo(rimInnerScreen[3].x, rimInnerScreen[3].y);
       X.closePath();
       X.stroke();
+      // corner studs — small gold dots at each of the 4 perimeter
+      // vertices so the wall reads as constructed panels, not a
+      // single continuous block.
+      for(var sci=0; sci<rimInnerScreen.length; sci++){
+        var sPt = rimInnerScreen[sci];
+        X.fillStyle = 'rgba(255, 220, 140, 0.95)';
+        X.beginPath(); X.arc(sPt.x, sPt.y, 2.2 * z, 0, Math.PI*2); X.fill();
+        X.fillStyle = 'rgba(196, 138, 48, 0.85)';
+        X.beginPath(); X.arc(sPt.x, sPt.y, 3.4 * z, 0, Math.PI*2); X.stroke();
+      }
       X.restore();
       // ── flower spots — deterministic small dots in 3 colors, scattered in the lawn only ──
       X.save();
@@ -6263,19 +6501,27 @@ button.act:disabled{opacity:0.5;cursor:default;}
       // Cars share the same elapsed-dt clock so a tab-switch doesn't
       // catapult every car off the road at once. speed is world units
       // per second, dt is milliseconds. cdt is the already-clamped dt.
+      // Per-frame speed jitter (±5%) so the same lane never settles into
+      // a stable cluster — the fastest car gradually pulls away from the
+      // slowest one and the spread stays alive even after many wraps.
       var cdt = Math.min(64, dt);
       for(var ci=0; ci<CARS.length; ci++){
         var car = CARS[ci];
-        car.x += car.dir * car.speed * (cdt/1000);
+        // Deterministic per-car jitter based on wall-clock + index so it
+        // changes every frame but isn't pure noise (smooth-ish accel).
+        var jitter = 1 + (Math.sin(now/380 + ci*1.7) * 0.05);
+        car.x += car.dir * car.speed * jitter * (cdt/1000);
         // Wrap the car around the road. When it leaves one end, it
-        // re-enters the opposite end on the other lane so oncoming
-        // traffic feels continuous.
+        // re-enters the opposite end on the other lane — and the
+        // re-entry x is randomized across the visible road so two
+        // cars that arrived at the boundary together don't land on
+        // top of each other.
         if(car.dir > 0 && car.x > PARK_W + 0.5){
-          car.x = -0.5;
+          car.x = -0.5 - Math.random() * (PARK_W * 0.5);
           car.y = (car.y < -0.9) ? -0.65 : -1.18;
           car.dir = (car.y < -0.9) ? +1 : -1;
         } else if(car.dir < 0 && car.x < -0.5){
-          car.x = PARK_W + 0.5;
+          car.x = PARK_W + 0.5 + Math.random() * (PARK_W * 0.5);
           car.y = (car.y < -0.9) ? -0.65 : -1.18;
           car.dir = (car.y < -0.9) ? +1 : -1;
         }
@@ -6489,6 +6735,25 @@ button.act:disabled{opacity:0.5;cursor:default;}
       ensure();
       loadSDK();
       loadImages();
+      // Pull the latest operator-saved positions from the scheduler
+      // and seed the in-memory override map. Without this step the
+      // dashboard would only know about local (this-session) drags
+      // and would reset to slot defaults on every reload.
+      try{
+        getJson('/api/character-presets'+QS).then(function(list){
+          if(Array.isArray(list)){
+            for(var pi=0; pi<list.length; pi++){
+              var p = list[pi];
+              if(p && p.id && typeof p.nx === 'number' && typeof p.ny === 'number'){
+                _parkPosOverrides[p.id] = { nx: p.nx, ny: p.ny };
+              }
+            }
+          }
+          // re-apply on the live node list (if it's already populated
+          // by a prior /fed/status frame)
+          if(typeof _applyPosOverrides === 'function') _applyPosOverrides();
+        }).catch(function(){ /* offline — use slot defaults */ });
+      }catch(e){}
       if(lastStatus) onStatus(lastStatus);
       resize();
       connectStream();

package/dist/robopark/agent-ctl.js

@@ -115,35 +115,51 @@ function ensureRobovoiceSingleAudioTrack(path) {
         return { patched: false, warning: 'voice_agent.py was not found; skipping RoboPark greeting compatibility patch' };
     }
     const source = readFileSync(file, 'utf8');
-    if (source.includes('Initial greeting completed through AgentSession audio track')) {
-        return { patched: false, file };
-    }
+    let updated = source;
+    let patched = false;
+    const newline = source.includes('\r\n') ? '\r\n' : '\n';
+    const singleTrackMarker = 'Initial greeting completed through AgentSession audio track';
     const startMarker = '            # Synthesize the greeting first';
     const endMarker = '        except Exception as e:';
-    const start = source.indexOf(startMarker);
-    const end = start >= 0 ? source.indexOf(endMarker, start) : -1;
-    if (start < 0 || end < 0) {
-        return {
-            patched: false,
-            file,
-            warning: 'voice_agent.py does not contain the known duplicate greeting-track block; no automatic patch applied',
-        };
+    if (!updated.includes(singleTrackMarker)) {
+        const start = updated.indexOf(startMarker);
+        const end = start >= 0 ? updated.indexOf(endMarker, start) : -1;
+        if (start < 0 || end < 0) {
+            return {
+                patched: false,
+                file,
+                warning: 'voice_agent.py does not contain the known duplicate greeting-track block; no automatic patch applied',
+            };
+        }
+        const replacement = [
+            '            # Use the existing conversation track. A dedicated greeting',
+            '            # track makes Linux robots compete for the same ALSA device.',
+            '            import inspect as _inspect',
+            '            speech = session.say(greeting, allow_interruptions=False)',
+            '            if _inspect.isawaitable(speech):',
+            '                await speech',
+            "            elif hasattr(speech, 'wait_for_playout'):",
+            '                await speech.wait_for_playout()',
+            "            logger.info('Initial greeting completed through AgentSession audio track')",
+            '',
+        ].join(newline);
+        updated = updated.slice(0, start) + replacement + updated.slice(end);
+        patched = true;
     }
-    const newline = source.includes('\r\n') ? '\r\n' : '\n';
-    const replacement = [
-        '            # Use the existing conversation track. A dedicated greeting',
-        '            # track makes Linux robots compete for the same ALSA device.',
-        '            import inspect as _inspect',
-        '            speech = session.say(greeting, allow_interruptions=False)',
-        '            if _inspect.isawaitable(speech):',
-        '                await speech',
-        "            elif hasattr(speech, 'wait_for_playout'):",
-        '                await speech.wait_for_playout()',
-        "            logger.info('Initial greeting completed through AgentSession audio track')",
-        '',
-    ].join(newline);
-    writeFileSync(file, source.slice(0, start) + replacement + source.slice(end), 'utf8');
-    return { patched: true, file };
+    // The job is dispatched after the robot participant joins. Waiting for its
+    // camera adds camera startup to voice latency even though audio is ready.
+    const cameraGate = /            await asyncio\.wait_for\(robot_camera_ready\.wait\(\), timeout\s*=\s*[0-9.]+\)/;
+    if (cameraGate.test(updated)) {
+        updated = updated.replace(cameraGate, [
+            '            # The robot is already in the room when this job is dispatched.',
+            '            # Yield once for subscription signalling; do not gate voice on camera.',
+            '            await asyncio.sleep(0)',
+        ].join(newline));
+        patched = true;
+    }
+    if (patched)
+        writeFileSync(file, updated, 'utf8');
+    return { patched, file };
 }
 export async function roboparkAgentUp(opts) {
     console.log(chalk.bold('\n  robopark agent up'));

package/dist/robopark/robot-runtime.js

@@ -135,10 +135,25 @@ export async function roboparkRobotRuntime(opts) {
             // Motion remains enabled, but it reads RoboVision's shared stream. Only
             // RoboVision may open the physical V4L2 device.
             LOCAL_CAMERA_MOTION: 'true',
+            // The first production sound is the greeting. A beep would occupy the
+            // same exclusive ALSA device and delay or clip TTS.
+            ROBOPARK_MOTION_CUE: 'false',
             // Fleet hardware profile: resolve volatile ALSA hw:X,Y coordinates
             // from these USB product labels on every inventory refresh.
             ROBOPARK_AUDIO_INPUT_MATCH: 'Usb Audio Device: USB Audio',
             ROBOPARK_AUDIO_OUTPUT_MATCH: 'USB Audio Device: -',
+            // Launch hardware has no acoustic echo cancellation. Suppress mic PCM
+            // only while audible robot speech is playing, then hold briefly for
+            // room echo decay so VAD cannot interrupt the robot with its own voice.
+            ROBOPARK_HALF_DUPLEX: 'true',
+            ROBOPARK_ECHO_TAIL_MS: '700',
+            ROBOPARK_ECHO_GATE_PEAK: '96',
+            // Keep ordinary speaker echo muted but reopen the microphone when a
+            // nearby voice rises decisively above the learned acoustic echo floor.
+            ROBOPARK_ADAPTIVE_BARGE_IN: 'true',
+            ROBOPARK_BARGE_IN_MIN_PEAK: '2200',
+            ROBOPARK_BARGE_IN_ECHO_RATIO: '2.4',
+            ROBOPARK_BARGE_IN_HOLD_MS: '1400',
             // Inventory changes should reach the Control Center promptly.
             HEARTBEAT_INTERVAL: '5',
         },

package/docs/ROBOPARK_PRODUCTION_MEMORY.md

@@ -199,3 +199,42 @@ Required result: `playback_started  ok`.
   rejects duplicate assignments, limits pulses to 10 seconds, serializes all
   actuation, and de-energizes every registered relay on errors and shutdown.
 - A missing or busy GPIO driver is a failed test, never a simulated success.
+
+## Robot Speaker Echo Contract (2.8.100+)
+
+- The launch USB speaker/microphone stack has no hardware acoustic echo
+  cancellation, so production uses robot-side half-duplex echo suppression.
+- While outbound TTS contains audible PCM, the Pi publishes timing-correct
+  silence instead of amplified microphone PCM. The microphone track remains
+  connected and resumes after a 700 ms acoustic decay tail.
+- Silent frames on the persistent TTS track do not hold the gate open. Output
+  peak detection releases the visitor microphone between responses.
+- `ROBOPARK_HALF_DUPLEX`, `ROBOPARK_ECHO_TAIL_MS`, and
+  `ROBOPARK_ECHO_GATE_PEAK` are explicit runtime controls. Disable half-duplex
+  only after deploying real acoustic echo cancellation.
+
+## Instant Greeting Contract (2.8.101+)
+
+- Motion reporting is asynchronous and never delays session allocation.
+- RoboVision's shared camera stream is not stopped or reopened on a trigger.
+- The old fixed 500 ms trigger delay is removed.
+- The local motion beep is disabled by default because it occupies the same
+  exclusive ALSA speaker as TTS. `ROBOPARK_MOTION_CUE=true` is diagnostics only.
+- The voice worker uses the persistent AgentSession audio track and starts the
+  greeting after robot join; it does not wait for camera subscription.
+- Network, scheduler, LiveKit, and TTS synthesis still impose real latency, but
+  RoboPark adds no intentional serial delay before greeting generation.
+
+## Adaptive Interruption Contract (2.8.102+)
+
+- The preset greeting remains non-interruptible so ambient startup noise cannot
+  cancel it before the first audible frame.
+- Normal responses retain LiveKit AgentSession interruption handling.
+- Robot half-duplex suppression learns the microphone's active speaker-echo
+  floor. Three consecutive near-field peaks above both the absolute threshold
+  and the adaptive echo ratio reopen microphone PCM for the VAD.
+- The barge-in window remains open for 1.4 seconds, allowing LiveKit to cancel
+  TTS; ordinary speaker echo remains suppressed with the existing decay tail.
+- Vision responses inherit the selected voice-stack output language. With an
+  automatic profile, the original user transcript language is authoritative,
+  including direct terminal vision-tool responses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.99",
+  "version": "2.8.102",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",