infinicode 2.8.98 → 2.8.100

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

@@ -4079,25 +4079,24 @@ button.act:disabled{opacity:0.5;cursor:default;}
     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), and an "oncoming" flag so the car sprite can face the right way
-    // (headlight forward, taillight rear). y is one of two lane bands
-    // (≈ -0.78 for outbound, ≈ -1.02 for inbound) so cars don't overlap.
-    // When a car crosses either end of the road (x < -0.5 or x > PARK_W+0.5)
-    // it wraps to the opposite side with a small y jitter so the flow
-    // doesn't visibly reset.
+    // 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.
     var ROAD_Y0=-1.5, ROAD_Y1=-0.35;
     var CARS=[
-      {x:2.2,  y:-0.78, color:'#f2c14e', speed:1.6, dir:+1},
-      {x:5.6,  y:-1.02, color:'#7fb4ff', speed:1.8, dir:-1},
-      {x:7.4,  y:-0.78, color:'#e0a23c', speed:1.4, dir:+1},
-      {x:10.2, y:-1.02, color:'#ff7e6e', speed:2.0, dir:-1},
-      {x:11.8, y:-0.78, color:'#d8d8e0', speed:1.5, dir:+1},
-      {x:1.0,  y:-1.02, color:'#5b8bd6', speed:1.7, dir:-1},
-      {x:13.6, y:-0.78, color:'#c87ed4', speed:1.3, dir:+1},
-      {x:8.4,  y:-1.02, color:'#f2c14e', speed:1.9, dir:-1},
+      {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},
     ];
-    // Per-car phase offsets so the headlights / taillights don't all blink
-    // in lockstep — gives a natural "moving at different speeds" feel.
+    // Per-car phase offsets so headlights / taillights / wheels don't all
+    // blink in lockstep — gives a natural "different cars, different
+    // speeds" feel.
     var _carPhase = CARS.map(function(_, i){ return i * 0.7; });
     // ── Walking people — looping sprites that stroll along fixed plaza paths.
     // Each walker is a small canvas-drawn figure (head + body + two
@@ -4497,37 +4496,24 @@ button.act:disabled{opacity:0.5;cursor:default;}
       if(typeof now !== 'number') now = performance.now();
       var _now = now;
       var z=cam.z;
-      // ── grass base — multi-stop radial sun-lit gradient on a slightly larger field ──
-      // Field is now sized to the plaza footprint + a small margin. The previous
-      // version extended from x=-0.5..PARK_W+0.5, which left a wide empty green
-      // strip on either side of the plaza; trimmed here to remove that overhang.
+      // ── grass base — single uniform mid-green, no radial brightening ──
+      // Park sits on a floating island now, so we want a flat, calm
+      // grass tone across the whole field. The previous radial gradient
+      // pushed a lighter green toward the center which read as a "spot"
+      // — replaced with a single soft fill so the island feels like a
+      // single piece of turf.
       var parkCx=PARK_W/2, parkCy=PARK_D/2;
       var gCent=iso(parkCx,parkCy);
       var gRad=X.createRadialGradient(gCent.x,gCent.y,12*z,gCent.x,gCent.y,Math.max(W,H)*0.62);
-      gRad.addColorStop(0,'rgba(154,196,108,0.95)');
-      gRad.addColorStop(0.45,'rgba(86,142,80,0.95)');
-      gRad.addColorStop(1,'rgba(44,98,52,0.95)');
+      gRad.addColorStop(0,'rgba(94,150,84,0.95)');
+      gRad.addColorStop(0.5,'rgba(86,140,76,0.95)');
+      gRad.addColorStop(1,'rgba(78,128,68,0.95)');
       // grass field — tight margin around the plaza + lot, NOT covering the road or the beach
       var GF_X0=0.0, GF_X1=PARK_W, GF_Y0=-0.32, GF_Y1=PARK_D-0.55;
       poly([[GF_X0,GF_Y0],[GF_X1,GF_Y0],[GF_X1,GF_Y1],[GF_X0,GF_Y1]], gRad, 'rgba(140,200,150,0.10)',1);
-      // ── "mowed stripes" effect — wide diagonal bands of alternating green tones ──
-      // Drawn as full-width rectangles in world space, slightly rotated via a parallelogram skew.
-      X.save();
-      var stripeColors=['rgba(108,162,90,0.45)','rgba(86,140,72,0.35)'];
-      var stripeCount=5;
-      var stripeW=(GF_X1-GF_X0+GF_Y1-GF_Y0+2)/stripeCount;
-      for(var si=0;si<stripeCount;si++){
-        var off=si*stripeW - ((GF_X1-GF_X0)+(GF_Y1-GF_Y0))*0.5;
-        // Build a parallelogram in world coords that runs from left-bottom to right-top
-        // at a slight angle (skewed +X, -Y direction) — looks like a stadium mowed lawn.
-        // Tightly fitted to the grass field bounds.
-        var p1=[GF_X0 + off, GF_Y1];
-        var p2=[GF_X0 + off + 1.0, GF_Y0];
-        var p3=[GF_X0 + off + 1.0 + (GF_X1-GF_X0), GF_Y0];
-        var p4=[GF_X0 + off + (GF_X1-GF_X0), GF_Y1];
-        poly([p1,p2,p3,p4], stripeColors[si%2], null, 0);
-      }
-      X.restore();
+      // (mowed-stripe effect removed — was the lighter green alternating
+      // bands on the sides of the park. Keeping the lawn as a single
+      // uniform tone so the park reads as a clean floating island.)
       // ── outer hedge / foliage border just inside the grass field ──
       // Slightly ragged inner edge: extra points along each side to break the straight line.
       // The hedge wraps the grass field, which now hugs the plaza footprint (no side overhang).
@@ -4598,16 +4584,197 @@ button.act:disabled{opacity:0.5;cursor:default;}
       X.closePath();
       X.strokeStyle='rgba(96,148,86,0.7)'; X.lineWidth=0.8*z; X.stroke();
       X.restore();
-      // grass noise — scattered lighter tufts to add texture (warm bright-green tints)
+      // grass noise — scattered darker tufts for texture (no lighter
+      // tufts, so the field stays a single uniform mid-green)
       X.save();
-      for(var ni=0;ni<60;ni++){
+      for(var ni=0;ni<40;ni++){
         var gnx=GF_X0 + ((ni*37)%100)/100*(GF_X1-GF_X0);
         var gny=GF_Y0 + ((ni*53)%100)/100*(GF_Y1-GF_Y0);
         var gp=iso(gnx,gny);
-        X.fillStyle=(ni%2)?'rgba(150,200,110,0.20)':'rgba(56,112,62,0.22)';
+        X.fillStyle='rgba(56,112,62,0.22)';
         X.beginPath(); X.arc(gp.x+((ni*7)%13-6)*z,gp.y+((ni*11)%9-4)*z,1.6*z,0,7); X.fill();
       }
       X.restore();
+      // ── GOLD BORDER + FLOATING ISLAND DEPTH ──
+      // The whole park now reads as a single floating slab of turf in
+      // the sky. We render (in world space, around the grass field):
+      //   1. a soft drop-shadow ellipse on the sky below the island
+      //   2. a tapered rocky underside (darker, hanging from the edge)
+      //   3. a thick gold rim tracing the grass perimeter
+      //   4. a thin warm-glow outer ring (sells the gold as "lit by
+      //      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
+      function grassPerim(offset){
+        // Use the same world corners as the grass field, offset outward.
+        var o = offset;
+        return [
+          [GF_X0-o, GF_Y0-o],
+          [GF_X1+o, GF_Y0-o],
+          [GF_X1+o, GF_Y1+o],
+          [GF_X0-o, GF_Y1+o]
+        ];
+      }
+      // 1. drop shadow on the sky — a wide soft ellipse below the
+      //    island's bottom edge (in screen space, large + soft).
+      var botL = iso(GF_X0,    GF_Y1);
+      var botR = iso(GF_X1,    GF_Y1);
+      var botM = { x:(botL.x+botR.x)/2, y:(botL.y+botR.y)/2 };
+      var islandWidth = Math.abs(botR.x - botL.x);
+      var shadowCx = botM.x;
+      var shadowCy = botM.y + 28*z;
+      var shadowRX = islandWidth * 0.55;
+      var shadowRY = 22 * z;
+      var dropShadow = X.createRadialGradient(shadowCx, shadowCy, 0, shadowCx, shadowCy, shadowRX);
+      dropShadow.addColorStop(0,   'rgba(20, 24, 36, 0.55)');
+      dropShadow.addColorStop(0.5, 'rgba(20, 24, 36, 0.25)');
+      dropShadow.addColorStop(1,   'rgba(20, 24, 36, 0)');
+      X.fillStyle = dropShadow;
+      X.beginPath();
+      X.ellipse(shadowCx, shadowCy, shadowRX, shadowRY, 0, 0, Math.PI*2);
+      X.fill();
+      // 2. rocky underside — draw the grass field polygon again, but
+      //    offset down by ~14*z and slightly darker, then close it into
+      //    a wedge. We do this with two filled paths:
+      //      - the bottom face: same perimeter polygon shifted down
+      //      - the side rim: a band that traces from the top of the
+      //        bottom face up to the top of the island (so the side
+      //        of the slab reads as dirt/rock)
+      var UNDERSIDE_LIFT = 16 * z;
+      var topPerim = grassPerim(0);
+      var botPerim = topPerim.map(function(p){ return [p[0], p[1] + UNDERSIDE_LIFT / (TH*z) * (1/22)]; });
+      // Convert botPerim into screen-space points (slightly down from top).
+      var topScreen = topPerim.map(function(p){ return iso(p[0], p[1]); });
+      var botScreen = topPerim.map(function(p){ return iso(p[0], p[1] + 1.0); });
+      // right side face
+      X.save();
+      X.fillStyle = 'rgba(38, 50, 36, 0.92)';
+      X.beginPath();
+      X.moveTo(topScreen[1].x, topScreen[1].y);
+      X.lineTo(topScreen[2].x, topScreen[2].y);
+      X.lineTo(botScreen[2].x, botScreen[2].y + UNDERSIDE_LIFT);
+      X.lineTo(botScreen[1].x, botScreen[1].y + UNDERSIDE_LIFT);
+      X.closePath();
+      X.fill();
+      // bottom-right edge highlight (slight bevel)
+      X.strokeStyle = 'rgba(80, 96, 60, 0.55)';
+      X.lineWidth = 1.0*z;
+      X.beginPath();
+      X.moveTo(topScreen[2].x, topScreen[2].y);
+      X.lineTo(botScreen[2].x, botScreen[2].y + UNDERSIDE_LIFT);
+      X.stroke();
+      // left side face
+      X.fillStyle = 'rgba(28, 38, 26, 0.95)';
+      X.beginPath();
+      X.moveTo(topScreen[0].x, topScreen[0].y);
+      X.lineTo(topScreen[1].x, topScreen[1].y);
+      X.lineTo(botScreen[1].x, botScreen[1].y + UNDERSIDE_LIFT);
+      X.lineTo(botScreen[0].x, botScreen[0].y + UNDERSIDE_LIFT);
+      X.closePath();
+      X.fill();
+      // bottom-left edge highlight
+      X.strokeStyle = 'rgba(70, 84, 52, 0.45)';
+      X.beginPath();
+      X.moveTo(topScreen[0].x, topScreen[0].y);
+      X.lineTo(botScreen[0].x, botScreen[0].y + UNDERSIDE_LIFT);
+      X.stroke();
+      // bottom face — slightly tapered into a rough point so the slab
+      // doesn't look like a flat box. We taper the bottom by ~25%.
+      var tapered = topScreen.map(function(s, i){
+        if(i === 0) return { x: s.x + 40*z, y: s.y + UNDERSIDE_LIFT*0.95 };
+        if(i === 1) return { x: s.x - 40*z, y: s.y + UNDERSIDE_LIFT*0.95 };
+        if(i === 2) return { x: s.x - 60*z, y: s.y + UNDERSIDE_LIFT*0.85 };
+        if(i === 3) return { x: s.x + 60*z, y: s.y + UNDERSIDE_LIFT*0.85 };
+        return { x: s.x, y: s.y + UNDERSIDE_LIFT };
+      });
+      X.fillStyle = 'rgba(20, 28, 20, 0.92)';
+      X.beginPath();
+      X.moveTo(topScreen[0].x, topScreen[0].y);
+      X.lineTo(topScreen[1].x, topScreen[1].y);
+      X.lineTo(tapered[1].x, tapered[1].y);
+      X.lineTo(tapered[2].x, tapered[2].y);
+      X.lineTo(tapered[3].x, tapered[3].y);
+      X.lineTo(tapered[0].x, tapered[0].y);
+      X.closePath();
+      X.fill();
+      // a few rocky stalactite bumps hanging from the underside so it
+      // doesn't look like a perfect box either
+      var bumpSpots = [
+        { px: 0.18, len: 0.65 },
+        { px: 0.34, len: 0.85 },
+        { px: 0.52, len: 0.55 },
+        { px: 0.68, len: 0.95 },
+        { px: 0.86, len: 0.70 }
+      ];
+      for(var bpi=0; bpi<bumpSpots.length; bpi++){
+        var bx = GF_X0 + bumpSpots[bpi].px * (GF_X1-GF_X0);
+        var by = GF_Y1;
+        var bp = iso(bx, by);
+        var bpLen = bumpSpots[bpi].len * UNDERSIDE_LIFT;
+        X.fillStyle = 'rgba(24, 32, 22, 0.88)';
+        X.beginPath();
+        X.moveTo(bp.x - 14*z, bp.y + 2*z);
+        // 2-sided stalactite that tapers to a point
+        X.quadraticCurveTo(bp.x, bp.y + bpLen*0.5, bp.x, bp.y + bpLen);
+        X.quadraticCurveTo(bp.x, bp.y + bpLen*0.5, bp.x + 14*z, bp.y + 2*z);
+        X.closePath();
+        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);
+      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]); });
+      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
+      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.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;
+      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.closePath();
+      X.stroke();
+      // inner highlight (thinner, brighter)
+      X.strokeStyle = 'rgba(255, 232, 158, 0.95)';
+      X.lineWidth = 1.4*z;
+      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.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;
+      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.closePath();
+      X.stroke();
+      X.restore();
       // ── flower spots — deterministic small dots in 3 colors, scattered in the lawn only ──
       X.save();
       var flowerColors=['rgba(232,124,164,0.85)','rgba(248,220,96,0.88)','rgba(248,248,240,0.85)'];
@@ -6095,21 +6262,21 @@ 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.
+      // per second, dt is milliseconds. cdt is the already-clamped dt.
       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);
-        // Wrap the car around the road. Add a small y-jitter so the
-        // re-entry point doesn't visibly snap.
+        // 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.
         if(car.dir > 0 && car.x > PARK_W + 0.5){
           car.x = -0.5;
-          // bounce across the centerline by switching y + dir
-          car.y = (car.y < -0.9) ? -0.78 : -1.02;
+          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.y = (car.y < -0.9) ? -0.78 : -1.02;
+          car.y = (car.y < -0.9) ? -0.65 : -1.18;
           car.dir = (car.y < -0.9) ? +1 : -1;
         }
       }
@@ -7025,7 +7192,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
           + buildShellSection(schedId(n))
           + sect('🎭 character / voice','<div class="pk-note" id="pk-eff-note" style="margin-bottom:0.45rem;">loading effective config…</div><div class="rp-field"><label>Character preset</label><select class="rp-char" id="pk-eff-char" data-robot="'+esc(schedId(n))+'">'+effPresetOptions+'</select></div><div class="rp-field"><label>Voice stack</label><select class="rp-voice" id="pk-eff-voice" data-robot="'+esc(schedId(n))+'">'+effVoiceOptions+'</select></div><div class="rp-config-actions" style="margin-top:.45rem"><button class="rp-btn primary" id="pk-eff-save" data-robot="'+esc(schedId(n))+'">Apply to robot</button><button class="rp-btn" id="pk-edit-character">Edit character</button><button class="rp-btn" id="pk-edit-stack">Edit stack</button><button class="rp-btn" id="pk-new-stack">New stack</button></div>');
          b.innerHTML += sect('Microphone setup suite','<div class="pk-mic-suite"><div class="pk-mic-health" id="pk-mic-health"><div class="pk-mic-check"><div class="k">Hardware lock</div><div class="v">USB mic hw:3,0</div></div><div class="pk-mic-check"><div class="k">PCM capture</div><div class="v">not tested</div></div><div class="pk-mic-check"><div class="k">Production track</div><div class="v">waiting</div></div></div><div class="rp-form" style="grid-template-columns:1fr 1fr;gap:.4rem"><div class="rp-field"><label>Ground-truth capture</label><select id="pk-mic-duration"><option value="2">2 seconds</option><option value="4" selected>4 seconds</option><option value="8">8 seconds</option></select></div><div class="rp-field"><label>Locked input</label><div class="pk-note" style="margin:.45rem 0 0">USB microphone (plughw:3,0)</div></div></div><div class="pk-ctl"><button class="rp-btn primary" id="pk-mic-groundtruth">Run raw mic capture</button><button class="rp-btn" id="pk-mic-roundtrip">Run speaker + mic test</button><button class="rp-btn" id="pk-mic-apply">Reapply production profile</button></div><div class="pk-note" id="pk-mic-test-state">Raw capture bypasses LiveKit and tests the exact ALSA path. Round-trip then verifies the physical speaker-to-mic path.</div><div id="pk-mic-test-result"></div></div>');
-         b.innerHTML += sect('Motor registry + sequence canvas','<div class="rp-field"><label>Robot-local motor server</label><input id="pk-motor-url" value="http://127.0.0.1:8001" placeholder="http://127.0.0.1:8001"></div><div class="pk-motor-registry" id="pk-motor-registry"></div><button class="rp-btn" id="pk-motor-add" style="margin-top:.4rem">Add registered motor</button><div class="rp-form" style="grid-template-columns:1fr 1fr;margin-top:.7rem"><div class="rp-field"><label>Saved sequence</label><select id="pk-motor-sequence"></select></div><div class="rp-field"><label>Sequence name</label><input id="pk-motor-sequence-name" placeholder="Greeting motion"></div></div><div class="pk-motor-canvas" id="pk-motor-canvas"></div><div class="pk-ctl"><button class="rp-btn" id="pk-motor-step-add">Add timed node</button><button class="rp-btn primary" id="pk-motor-save">Save motor profile</button><button class="rp-btn" id="pk-motor-run">Run selected sequence</button></div><label class="pk-prodtoggle"><input type="checkbox" id="pk-motor-greeting"><span>Run this sequence automatically with the greeting pipeline</span></label><div class="pk-motor-status" id="pk-motor-status">Loading motor profile...</div>');
+         b.innerHTML += sect('Motor registry + sequence canvas','<div class="rp-field"><label>Robot-local motor server</label><input id="pk-motor-url" value="http://127.0.0.1:8001" placeholder="http://127.0.0.1:8001"></div><div class="pk-motor-registry" id="pk-motor-registry"></div><button class="rp-btn" id="pk-motor-add" style="margin-top:.4rem">Add registered motor</button><div class="rp-form" style="grid-template-columns:1fr 1fr;margin-top:.7rem"><div class="rp-field"><label>Saved sequence</label><select id="pk-motor-sequence"></select></div><div class="rp-field"><label>Sequence name</label><input id="pk-motor-sequence-name" placeholder="Greeting motion"></div></div><div class="pk-motor-canvas" id="pk-motor-canvas"></div><div class="pk-ctl"><button class="rp-btn" id="pk-motor-step-add">Add timed node</button><button class="rp-btn primary" id="pk-motor-save">Save motor profile</button><button class="rp-btn" id="pk-motor-run">Run selected sequence</button><button class="rp-btn danger" id="pk-motor-test-all">Test all registered GPIO</button></div><label class="pk-prodtoggle"><input type="checkbox" id="pk-motor-greeting"><span>Run this sequence automatically with the greeting pipeline</span></label><div class="pk-note">Full GPIO test pulses registered relays only: 300 ms on, 200 ms pause, one at a time.</div><div class="pk-motor-status" id="pk-motor-status">Loading motor profile...</div>');
          b.innerHTML += sect('Production camera + audio','<div class="pk-note" id="pk-device-search" style="margin-bottom:.55rem">Hardware locked for launch. Camera, microphone, and speaker cannot drift between restarts.</div><div class="rp-field"><label>Camera input</label><select id="pk-video-device" disabled></select></div><div class="rp-field"><label>Microphone input</label><select id="pk-audio-input" disabled></select></div><div class="rp-field"><label>Speaker output</label><select id="pk-audio-output" disabled></select></div><button class="rp-btn primary" id="pk-device-test-speaker" style="margin-top:0.35rem">Test USB speaker now</button><div class="rp-field"><label>Preset greeting phrases <span class="pk-note">one per line, cached per voice</span></label><textarea id="pk-greeting-phrases" rows="3" placeholder="Hi, I am Jaguar! / Welcome to RoboPark."></textarea></div><button class="rp-btn" id="pk-device-save" style="margin-top:0.35rem">Save greetings + enforce hardware</button><div class="pk-note" id="pk-device-note">waiting for robot heartbeat inventory</div>');
           // Put live hardware selection beside the camera and audio tests,
           // ahead of persona and service administration in the Park drawer.
@@ -7055,6 +7222,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
          var motorStep=$('pk-motor-step-add');if(motorStep)motorStep.addEventListener('click',function(){motorEditorAddStep();});
          var motorSave=$('pk-motor-save');if(motorSave)motorSave.addEventListener('click',function(){if(rpReadOnly){showOut('read-only node');return;}saveMotorProfile(n);});
          var motorRun=$('pk-motor-run');if(motorRun)motorRun.addEventListener('click',function(){if(rpReadOnly){showOut('read-only node');return;}runMotorSequence(n);});
+         var motorTestAll=$('pk-motor-test-all');if(motorTestAll)motorTestAll.addEventListener('click',function(){if(rpReadOnly){showOut('read-only node');return;}testAllMotorRelays(n);});
          var motorSeq=$('pk-motor-sequence');if(motorSeq)motorSeq.addEventListener('change',function(){selectMotorSequence(motorSeq.value);});
          var motorRegistry=$('pk-motor-registry');if(motorRegistry)motorRegistry.addEventListener('click',function(ev){var button=ev.target.closest('[data-motor-action]');if(!button)return;var index=Number(button.dataset.index);if(button.dataset.motorAction==='remove'){motorProfile.registry.splice(index,1);renderMotorEditor();}else if(button.dataset.motorAction==='test'){testMotorRelay(n,index);}});
          var motorCanvas=$('pk-motor-canvas');if(motorCanvas)motorCanvas.addEventListener('click',function(ev){var button=ev.target.closest('[data-step-remove]');if(button){captureMotorEditor();motorEditorSequence().steps.splice(Number(button.dataset.stepRemove),1);renderMotorEditor();}});
@@ -7165,6 +7333,12 @@ button.act:disabled{opacity:0.5;cursor:default;}
       captureMotorEditor();var motor=motorProfile.registry[index];if(!motor)return;var robotId=schedId(n);motorStatus('Saving profile before safe 300 ms '+motor.name+' test...');
       saveMotorProfile(n).then(function(){return rpAction('POST','/robopark/api/robots/'+encodeURIComponent(robotId)+'/motors/'+encodeURIComponent(motor.id)+'/test?duration_ms=300',{});}).then(function(q){return _shellWaitForResult(robotId,q.request_id,q.device_id||robotId,'','motor-test');}).then(function(result){motorStatus(result.ok?motor.name+' relay test completed.':'Relay test failed: '+(result.error||'unknown error'),result.ok?'ok':'bad');}).catch(function(error){motorStatus('Relay test failed: '+error.message,'bad');});
     }
+    function testAllMotorRelays(n){
+      captureMotorEditor();if(!motorProfile.registry.length){motorStatus('Register at least one relay before running the GPIO test.','bad');return;}
+      if(!window.confirm('Pulse all '+motorProfile.registry.length+' registered relays one at a time? Ensure the motor area is clear.'))return;
+      var robotId=schedId(n);motorStatus('Saving profile and testing '+motorProfile.registry.length+' registered GPIO relay(s), one at a time...');
+      saveMotorProfile(n).then(function(){return rpAction('POST','/robopark/api/robots/'+encodeURIComponent(robotId)+'/motors/test-all?duration_ms=300&pause_ms=200',{});}).then(function(q){return _shellWaitForResult(robotId,q.request_id,q.device_id||robotId,'','gpio-test-all');}).then(function(result){motorStatus(result.ok?'Full registered GPIO test completed: '+(result.completed_steps||[]).length+' relay(s).':'GPIO test failed: '+(result.error||'unknown error'),result.ok?'ok':'bad');}).catch(function(error){motorStatus('GPIO test failed: '+error.message,'bad');});
+    }
 
     var pipelineHistoryPage=1;
     var PIPELINE_LABELS={

package/dist/robopark/robot-runtime.js

@@ -139,6 +139,12 @@ export async function roboparkRobotRuntime(opts) {
             // 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',
             // Inventory changes should reach the Control Center promptly.
             HEARTBEAT_INTERVAL: '5',
         },

package/docs/ROBOPARK_PRODUCTION_MEMORY.md

@@ -179,12 +179,14 @@ Required result: `playback_started  ok`.
   measurement, and fallback resampling with internal PCM16 helpers; production
   capture must not import `audioop`.
 
-## Motor and Relay Contract (2.8.98+)
+## Motor and Relay Contract (2.8.99+)
 
 - Each robot persists its own motor registry, timed sequences, local motor API
   URL, and optional greeting sequence in the scheduler database.
 - The Park robot drawer is the control surface for registry edits, BCM relay
   tests, sequence authoring, manual runs, and greeting assignment.
+- The full GPIO diagnostic requires operator confirmation and pulses every
+  registered relay sequentially. It never scans or energizes unregistered pins.
 - Greeting motion queues only after the robot reports `playback_started`, so
   movement aligns with audible TTS instead of session allocation.
 - Voice agents may invoke only saved sequences for their active LiveKit room
@@ -197,3 +199,16 @@ 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.

package/package.json

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

@@ -4030,6 +4030,26 @@ async def test_robot_motor(robot_id: str, motor_id: str, duration_ms: int = 300)
         "steps": [{"motor_id": motor_id, "delay_ms": 0, "duration_ms": duration_ms}],
     })
     return {"queued": True, "request_id": request_id, "device_id": model.id}
+
+@app.post("/api/robots/{robot_id}/motors/test-all")
+async def test_all_robot_motors(robot_id: str, duration_ms: int = 300, pause_ms: int = 200):
+    device = await _resolve_device_by_id_or_name(robot_id)
+    model = _device_row_to_model(device)
+    if not model.motor_registry or not model.motor_server_url:
+        raise HTTPException(409, "Robot motor registry or motor server is not configured")
+    duration_ms = max(50, min(1000, int(duration_ms)))
+    pause_ms = max(0, min(2000, int(pause_ms)))
+    request_id = await _queue_shell_request_async(model.id, "motor_sequence", "motor_server", {
+        "motor_server_url": model.motor_server_url,
+        "sequence_id": "registered-gpio-test",
+        "registry": model.motor_registry,
+        "steps": [],
+        "test_all": True,
+        "duration_ms": duration_ms,
+        "pause_ms": pause_ms,
+    })
+    return {"queued": True, "request_id": request_id, "device_id": model.id,
+            "motor_count": len(model.motor_registry)}
 
 @app.post("/api/devices/{device_id}/request-session")
 async def device_request_session(device_id: str,

package/packages/robopark/scheduler/preview_agent.py

@@ -1284,6 +1284,19 @@ class LiveKitPublisher:
         self._mic_capture: Optional["AudioCapture"] = None
         self._mic_streaming = asyncio.Event()
         self._mic_error: Optional[str] = None
+        # The launch hardware has no acoustic echo cancellation. Publishing
+        # the amplified USB microphone while the robot speaker plays TTS makes
+        # the voice worker hear itself and trigger barge-in, truncating or
+        # chopping its own response. Keep the track alive with silence while
+        # playback is active, plus a short room-echo decay tail.
+        self._half_duplex = str(os.getenv("ROBOPARK_HALF_DUPLEX", "true")).lower() in (
+            "1", "true", "yes", "on",
+        )
+        self._speaker_playback_active = threading.Event()
+        self._speaker_gate_until = 0.0
+        self._speaker_echo_tail = max(
+            0.1, min(float(os.getenv("ROBOPARK_ECHO_TAIL_MS", "700")) / 1000.0, 2.0)
+        )
         # Motion sampling state belongs to the publisher instance.  Keeping it
         # initialized here prevents shutdown/reopen paths from raising while
         # the camera is being handed between preview and voice sessions.
@@ -1524,12 +1537,41 @@ class LiveKitPublisher:
         stream_failed = threading.Event()
         playback_reported = threading.Event()
         event_loop = asyncio.get_running_loop()
+        echo_gate_peak = max(16, min(int(os.getenv("ROBOPARK_ECHO_GATE_PEAK", "96")), 4096))
+
+        def _outbound_peak(chunk: bytes) -> int:
+            if len(chunk) < 2:
+                return 0
+            try:
+                samples = memoryview(chunk).cast("h")
+                # Stereo duplication means sampling every eighth value is
+                # sufficient and keeps the writer thread lightweight.
+                return max((abs(int(value)) for value in samples[::8]), default=0)
+            except (TypeError, ValueError):
+                return 0
+
+        def _open_echo_gate() -> None:
+            if not self._half_duplex:
+                return
+            self._speaker_playback_active.set()
+            self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
+
+        def _extend_echo_gate() -> None:
+            if self._half_duplex:
+                self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
 
-        def _safe_write(chunk: bytes) -> bool:
-            if stream_failed.is_set():
-                return False
+        def _safe_write(chunk: bytes) -> bool:
+            if stream_failed.is_set():
+                return False
             try:
+                audible = _outbound_peak(chunk) >= echo_gate_peak
+                if audible:
+                    _open_echo_gate()
+                elif time.monotonic() >= self._speaker_gate_until:
+                    self._speaker_playback_active.clear()
                 out.write(chunk)
+                if audible:
+                    _extend_echo_gate()
                 if not playback_reported.is_set():
                     playback_reported.set()
                     asyncio.run_coroutine_threadsafe(
@@ -1661,6 +1703,9 @@ class LiveKitPublisher:
                 pa.terminate()
             if speaker_guard is not None:
                 speaker_guard.release()
+            if self._half_duplex:
+                self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
+                self._speaker_playback_active.clear()
 
     async def stop(self) -> None:
         self._stop_event.set()
@@ -1783,8 +1828,9 @@ class LiveKitPublisher:
         _diag_count = 0
         _diag_last_log = time.monotonic()
         _diag_read_ms = 0.0
-        _diag_publish_ms = 0.0
-        batch_interval = BATCH_MS / 1000
+        _diag_publish_ms = 0.0
+        _echo_gate_was_active = False
+        batch_interval = BATCH_MS / 1000
         while not self._stop_event.is_set():
             _iter_start = time.monotonic()
             _t0 = time.monotonic()
@@ -1792,10 +1838,27 @@ class LiveKitPublisher:
             _t1 = time.monotonic()
             if batch is not None:
                 data = bytes(batch.data)
-                _pub_start = time.monotonic()
-                for off in range(0, len(data) - bytes_per_frame + 1, bytes_per_frame):
+                _pub_start = time.monotonic()
+                for off in range(0, len(data) - bytes_per_frame + 1, bytes_per_frame):
                     chunk = data[off:off + bytes_per_frame]
-                    chunk, p = _pcm16_scale_and_peak(chunk, mic_gain)
+                    echo_gate_active = self._half_duplex and (
+                        self._speaker_playback_active.is_set()
+                        or time.monotonic() < self._speaker_gate_until
+                    )
+                    if echo_gate_active:
+                        # Preserve 20 ms frame cadence; only suppress content.
+                        # Stopping publication would create gaps and destabilize
+                        # VAD/endpointing when listening resumes.
+                        chunk = b"\x00" * len(chunk)
+                        p = 0
+                    else:
+                        chunk, p = _pcm16_scale_and_peak(chunk, mic_gain)
+                    if echo_gate_active != _echo_gate_was_active:
+                        logger.info(
+                            "audio_loop: speaker echo gate %s",
+                            "active" if echo_gate_active else "released",
+                        )
+                        _echo_gate_was_active = echo_gate_active
                     frame = self.rtc.AudioFrame(
                         data=chunk, sample_rate=48000, num_channels=1, samples_per_channel=samples_per_frame,
                     )

package/packages/robopark/scheduler/robot_supervisor.py

@@ -453,6 +453,27 @@ def _run_motor_sequence(params: dict) -> dict:
                 response = (client.put(f"{base}/update-motor/{motor_id}", json=body)
                             if motor_id in existing_names else client.post(f"{base}/add-motor", json=body))
                 response.raise_for_status()
+            if params.get("test_all"):
+                duration_ms = max(50, min(1000, int(params.get("duration_ms", 300))))
+                pause_ms = max(0, min(2000, int(params.get("pause_ms", 200))))
+                response = client.post(f"{base}/test", json={
+                    "seconds_on": duration_ms / 1000.0,
+                    "seconds_pause": pause_ms / 1000.0,
+                    "pins": [int(motor["gpio"]) for motor in registry.values()],
+                })
+                response.raise_for_status()
+                deadline = time.monotonic() + len(registry) * ((duration_ms + pause_ms) / 1000.0) + 3.0
+                while time.monotonic() < deadline:
+                    status = client.get(f"{base}/status").json()
+                    if status.get("status") == "idle":
+                        if status.get("error"):
+                            raise RuntimeError(f"registered GPIO test failed: {status['error']}")
+                        completed = [{"motor_id": motor_id, "gpio": int(motor["gpio"])}
+                                     for motor_id, motor in registry.items()]
+                        break
+                    time.sleep(0.05)
+                else:
+                    raise TimeoutError("registered GPIO test did not return to idle")
             for index, step in enumerate(steps):
                 motor_id = str(step.get("motor_id"))
                 motor = registry.get(motor_id)