diff --git a/apps/overlay/electron/main.js b/apps/overlay/electron/main.js
index b6f512c..cbfa9d8 100644
--- a/apps/overlay/electron/main.js
+++ b/apps/overlay/electron/main.js
@@ -25,6 +25,7 @@ let clickThrough = false;
 // default for the single-controller window is 720×540 — a clean capture size.
 const DEFAULT_WINDOW_SIZE = { width: 720, height: 540 };
 const MULTI_WINDOW_SIZE = { width: 1100, height: 520 };
+const LOBBY_WINDOW_SIZE = { width: 820, height: 660 };
 let windowStatePath = null; // resolved once app is ready (needs userData path)
 let saveWindowSizeTimer = null;
 
@@ -114,8 +115,11 @@ function upsertHidController(d, connected) {
 function hidControllerList() { return [...hidControllers.values()]; }
 
 function broadcastHidControllers() {
-  if (inventoryWindow && !inventoryWindow.isDestroyed()) {
-    inventoryWindow.webContents.send('hid-controllers-snapshot', hidControllerList());
+  const list = hidControllerList();
+  // The inventory window and the lobby both render this (the lobby shows each
+  // seat's per-unit serial/MAC — see its Controllers panel).
+  for (const w of [inventoryWindow, mainWindow]) {
+    if (w && !w.isDestroyed()) w.webContents.send('hid-controllers-snapshot', list);
   }
 }
 
@@ -139,6 +143,8 @@ function openInventoryWindow() {
 // Which size profile this launch uses. Single source of truth so the window
 // creation and the "reset to default" handler agree on key + default size.
 function getSizeMode() {
+  const useLobby = process.env.OVERLAY_LOBBY === '1' || process.argv.includes('--lobby');
+  if (useLobby) return { stateKey: 'lobby', defaultSize: LOBBY_WINDOW_SIZE };
   const useMulti = process.env.OVERLAY_MULTI === '1' || process.argv.includes('--multi');
   return {
     stateKey: useMulti ? 'multi' : 'main',
@@ -173,7 +179,7 @@ function createWindow() {
     },
   });
 
-  const entry = stateKey === 'multi' ? 'multi.html' : 'index.html';
+  const entry = stateKey === 'lobby' ? 'lobby.html' : stateKey === 'multi' ? 'multi.html' : 'index.html';
   mainWindow.loadFile(path.join(__dirname, '..', 'src', entry));
 
   mainWindow.once('ready-to-show', () => {
@@ -354,6 +360,7 @@ app.whenReady().then(() => {
     gyro:   { file: 'gyro-window.html',        width: 260, height: 260 },
     axis:   { file: 'axis-window.html',        width: 280, height: 90 },
     roll:   { file: 'roll-window.html',        width: 240, height: 170 },
+    controllers: { file: 'controllers-window.html', width: 320, height: 460 },
   };
 
   ipcMain.handle('open-hud-window', async (_event, { kind, profile, greenScreen }) => {
@@ -420,6 +427,11 @@ app.whenReady().then(() => {
     if (w && !w.isDestroyed()) w.webContents.send('hud-state-update', state);
   });
 
+  // Controllers window → main overlay: a row was clicked; switch the shown pad.
+  ipcMain.on('controller-select', (_event, payload) => {
+    if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send('controller-select', payload);
+  });
+
   // A detached window's close button uses this to close itself (frameless
   // windows have no titlebar close affordance).
   ipcMain.on('close-this-window', (event) => {
diff --git a/apps/overlay/electron/preload.js b/apps/overlay/electron/preload.js
index b5b4d4e..269d218 100644
--- a/apps/overlay/electron/preload.js
+++ b/apps/overlay/electron/preload.js
@@ -64,4 +64,11 @@ contextBridge.exposeInMainWorld('electronAPI', {
   // Periodic snapshot of currently-present HID controllers (with serials).
   onHidControllersSnapshot: (callback) =>
     ipcRenderer.on('hid-controllers-snapshot', (_, list) => callback(list)),
+
+  // ── Controllers window → overlay selection ──
+  // The detached Controllers list sends the clicked controller's key; the main
+  // overlay receives it and switches which controller drives the visualization.
+  selectController: (payload) => ipcRenderer.send('controller-select', payload),
+  onControllerSelect: (callback) =>
+    ipcRenderer.on('controller-select', (_, payload) => callback(payload)),
 });
diff --git a/apps/overlay/package.json b/apps/overlay/package.json
index d75abd3..26011be 100644
--- a/apps/overlay/package.json
+++ b/apps/overlay/package.json
@@ -6,10 +6,12 @@
   "scripts": {
     "prestart": "node scripts/copy-three.js && node scripts/copy-workspace.js",
     "prestart:multi": "node scripts/copy-three.js && node scripts/copy-workspace.js",
+    "prestart:lobby": "node scripts/copy-three.js && node scripts/copy-workspace.js",
     "prepackage": "node scripts/copy-three.js && node scripts/copy-workspace.js",
     "premake": "node scripts/copy-three.js && node scripts/copy-workspace.js",
     "start": "electron .",
     "start:multi": "electron . --multi",
+    "start:lobby": "electron . --lobby",
     "make": "electron-forge make",
     "make:dmg": "npm run package && bash scripts/make-dmg.sh",
     "package": "electron-forge package"
diff --git a/apps/overlay/src/controllers-window.html b/apps/overlay/src/controllers-window.html
new file mode 100644
index 0000000..a84c48a
--- /dev/null
+++ b/apps/overlay/src/controllers-window.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>Controllers</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  html, body { width: 100%; height: 100%; overflow: hidden; background: transparent; user-select: none;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; color: #e7ecf5; }
+  /* Opaque panel filling the (transparent) window, rounded corners. */
+  #panel { position: fixed; inset: 0; display: flex; flex-direction: column;
+    background: rgba(12,15,20,0.98); border: 1px solid rgba(255,255,255,0.12); border-radius: 12px; overflow: hidden; }
+  #titlebar { flex: 0 0 auto; display: flex; align-items: center; gap: 8px; padding: 9px 12px;
+    border-bottom: 1px solid rgba(255,255,255,0.08); font: 700 11px/1 ui-monospace, monospace; letter-spacing: 1.4px; color: #9fb0c6; text-transform: uppercase; }
+  #count { font-weight: 400; color: #7d879a; letter-spacing: .3px; }
+  #list { flex: 1 1 auto; overflow-y: auto; padding: 8px; display: flex; flex-direction: column; gap: 6px; }
+  .row { display: flex; align-items: center; gap: 9px; padding: 8px 10px; border-radius: 9px;
+    background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.09); cursor: pointer; }
+  .row:hover { border-color: rgba(255,255,255,0.28); background: rgba(255,255,255,0.09); }
+  .row.sel { border-color: #6ce08f; box-shadow: 0 0 0 1px rgba(108,224,143,.4); }
+  .dot { flex: 0 0 auto; width: 9px; height: 9px; border-radius: 50%; background: #39404e; transition: background .08s, box-shadow .08s; }
+  .dot.on { background: #6ce08f; box-shadow: 0 0 8px 1px #6ce08f; }
+  .main { flex: 1 1 auto; min-width: 0; display: flex; flex-direction: column; }
+  .name { font-size: 13px; font-weight: 700; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .sub { font: 10px/1.3 ui-monospace, monospace; color: #8894a8; }
+  .serial { font: 9px/1.3 ui-monospace, monospace; color: #9fb0c6; word-break: break-all; margin-top: 1px; }
+  .tag { flex: 0 0 auto; font: 800 8px/1 ui-monospace, monospace; letter-spacing: .8px; padding: 3px 6px; border-radius: 5px; }
+  .tag.selected { color: #06140c; background: #6ce08f; box-shadow: 0 0 8px -2px #6ce08f; }
+  .tag.active { color: #1a1205; background: #e0b453; }
+  .tag.available { color: #c9d6ff; background: rgba(110,168,255,0.18); border: 1px solid rgba(110,168,255,0.4); }
+  .empty { font: 11px/1.5 ui-monospace, monospace; color: #6a7184; text-align: center; padding: 16px 8px; }
+  .hint { flex: 0 0 auto; padding: 7px 12px; border-top: 1px solid rgba(255,255,255,0.08); font: 9px/1.4 ui-monospace, monospace; color: #6a7184; }
+  #close-btn { position: fixed; top: 7px; right: 8px; width: 20px; height: 20px; background: rgba(255,255,255,0.12);
+    border: none; border-radius: 50%; color: #ccc; font-size: 13px; line-height: 1; cursor: pointer; z-index: 51;
+    display: flex; align-items: center; justify-content: center; }
+  #close-btn:hover { background: rgba(255,255,255,0.25); color: #fff; }
+</style>
+</head>
+<body>
+  <div id="panel">
+    <div id="titlebar">CONTROLLERS <span id="count"></span></div>
+    <div id="list"></div>
+    <div class="hint">click a controller to show it in the overlay · ● in use now · drag to move</div>
+  </div>
+  <button id="close-btn" title="Close">&times;</button>
+  <script src="js/hud-window-chrome.js"></script>
+  <script type="module" src="js/controllers-window.js"></script>
+</body>
+</html>
diff --git a/apps/overlay/src/index.html b/apps/overlay/src/index.html
index ff6af63..f8a63c3 100644
--- a/apps/overlay/src/index.html
+++ b/apps/overlay/src/index.html
@@ -101,6 +101,21 @@
     letter-spacing: 0.5px;
   }
 
+  /* Controllers list (which controller drives the overlay) */
+  #ovl-ctrl-list { display: flex; flex-direction: column; gap: 5px; max-height: 210px; overflow-y: auto; }
+  .ovl-ctrl-row { display: flex; align-items: center; gap: 8px; padding: 6px 8px; border-radius: 8px; background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.09); cursor: pointer; }
+  .ovl-ctrl-row:hover { border-color: rgba(255,255,255,0.28); }
+  .ovl-ctrl-row.sel { border-color: #6ce08f; box-shadow: 0 0 0 1px rgba(108,224,143,.4); }
+  .ovl-dot { flex: 0 0 auto; width: 8px; height: 8px; border-radius: 50%; background: #39404e; transition: background .08s, box-shadow .08s; }
+  .ovl-dot.on { background: #6ce08f; box-shadow: 0 0 7px 1px #6ce08f; }
+  .ovl-ctrl-main { flex: 1 1 auto; min-width: 0; display: flex; flex-direction: column; }
+  .ovl-ctrl-name { font-size: 12px; font-weight: 600; color: #e7ecf5; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .ovl-ctrl-sub { font: 9px/1.3 ui-monospace, monospace; color: #8894a8; }
+  .ovl-tag { flex: 0 0 auto; font: 800 8px/1 ui-monospace, monospace; letter-spacing: .6px; padding: 3px 5px; border-radius: 4px; }
+  .ovl-tag.active { color: #06140c; background: #6ce08f; }
+  .ovl-tag.available { color: #c9d6ff; background: rgba(110,168,255,0.18); border: 1px solid rgba(110,168,255,0.4); }
+  .ovl-ctrl-empty { font: 10px/1.4 ui-monospace, monospace; color: #6a7184; text-align: center; padding: 8px; }
+
   .setting-row {
     display: flex;
     align-items: center;
@@ -919,7 +934,12 @@
   <h3>Controller Overlay</h3>
 
   <div class="setting-row">
-    <label>Controller</label>
+    <label>Controllers</label>
+    <button id="ovl-ctrl-popout" title="Open a movable window listing every connected controller with live activity">⧉ Show list…</button>
+  </div>
+
+  <div class="setting-row">
+    <label>Model</label>
     <select id="controller-type">
       <option value="auto">Auto-detect</option>
       <option value="dualsense">DualSense</option>
diff --git a/apps/overlay/src/js/app.js b/apps/overlay/src/js/app.js
index 7c88029..953ab84 100644
--- a/apps/overlay/src/js/app.js
+++ b/apps/overlay/src/js/app.js
@@ -12,7 +12,7 @@
 
 import * as THREE from 'three';
 import { ControllerOverlay, detectControllerType, PROFILES, GyroGimbal } from '@usersfirst/controller-visualizer';
-import { ControllerRegistry, SensorFusion, analyzeImuStep, SteamControllerDriver } from '@usersfirst/controller-core';
+import { ControllerRegistry, SensorFusion, analyzeImuStep, SteamControllerDriver, ControllerManager } from '@usersfirst/controller-core';
 import { recordStep, buildReport, exportReport, stepsForEntry, parseImuSamples,
   areasForSteps, filterStepsByAreas, AREA_LABELS, STEP_AREAS } from './test-report.js';
 
@@ -139,7 +139,75 @@ let syntheticGamepad = null;
 // Shared sensor fusion (was inline state + ~250 lines of duplicate math).
 // Keeps orientation, gravity tracking, stillness & sensor-fusion bias
 // calibration, and all related scratch vectors internal. See #224.
-const gyroFusion = new SensorFusion();
+// Phase 3b: the overlay drives its viz from the SELECTED pool entry's fusion —
+// the SAME per-controller SensorFusion the game uses (self-calibrating via
+// startCalibration). `gyroFusion` is an ALIAS repointed to that entry's fusion
+// on selection; `_idleFusion` is a neutral placeholder when nothing is selected
+// so the loop's `gyroFusion.displayOrientation` reads never hit null.
+const _idleFusion = new SensorFusion();
+let gyroFusion = _idleFusion;
+let selectedEntry = null;   // the pool HidEntry currently shown in the overlay
+
+// ── Controllers pool (Phase 3b: single owner) ──
+// A ControllerManager that opens EVERY granted HID handle over WebHID and keeps
+// each one live (driver + fusion + synthetic). The overlay's SELECTED controller
+// is simply a designated entry from this pool — no separate connection, no
+// eviction. The pool is the single owner of every HID device; the Gamepad API is
+// only a fallback for XInput-only pads (Xbox).
+const listManager = new ControllerManager({ slotIds: ['_ovl'] });
+async function initControllerList() {
+  if (!navigator.hid) return;
+  try {
+    const approved = await navigator.hid.getDevices();
+    for (const d of approved) {
+      if (ControllerRegistry.isKnownDevice(d)) await listManager.poolDevice(d);
+    }
+    listManager.wireHidHotplug();
+  } catch (e) { console.warn('[overlay] controller-pool init failed', e); }
+}
+// Set once by an explicit list-selection; consumed by connectControllerGyro so
+// it binds THIS exact handle (identical vid:pid pads share a vid:pid, not this).
+let _preferredGyroDevice = null;
+// Stable per-device id so the detached list can address an EXACT handle.
+const _deviceIds = new WeakMap();
+let _deviceIdSeq = 0;
+function deviceIdFor(device) {
+  if (!_deviceIds.has(device)) _deviceIds.set(device, ++_deviceIdSeq);
+  return _deviceIds.get(device);
+}
+// The controllers a user has interacted with at least once (dot lit) — keyed by
+// device id / gamepad index — so the list can show ACTIVE vs idle AVAILABLE.
+const _everActive = new Set();
+
+// Per-unit serial/MAC inventory from the Electron main process (the renderer's
+// WebHID handle carries no serial). Populated as devices are paired/hotplugged;
+// a boot scan (select-hid-device with the full deviceList) fills it for
+// already-present devices. Matched to rows by vid:pid.
+let _hidInventory = [];
+function initSerialInventory() {
+  if (!window.electronAPI) return;
+  try {
+    if (window.electronAPI.listHidControllers) window.electronAPI.listHidControllers().then((l) => { if (Array.isArray(l)) _hidInventory = l; }).catch(() => {});
+    if (window.electronAPI.onHidControllersSnapshot) window.electronAPI.onHidControllersSnapshot((l) => { if (Array.isArray(l)) _hidInventory = l; });
+    // Serial scan happens on the "Show list…" gesture — requestDevice needs user
+    // activation, so a boot timer can't populate the inventory.
+  } catch (e) { /* best-effort */ }
+}
+// Match a handle to its main-process serial. Electron's main HIDDevice exposes
+// no `collections` (so a descriptor fingerprint is impossible there) — but the
+// renderer DOES know each handle's connection type. Unique vid:pid → 1:1. Two
+// identical-vid:pid units (a BT clone + a USB DS4) → disambiguate by transport:
+// a Bluetooth unit carries a MAC serial, a USB DS4 carries none.
+function serialForDevice(vp, connType) {
+  const units = vp ? _hidInventory.filter((u) => u.vendorId === vp.vendorId && u.productId === vp.productId) : [];
+  if (!units.length) return '';
+  if (units.length === 1) return units[0].serialNumber || '(no serial)';
+  const withSerial = units.filter((u) => u.serialNumber);
+  if (connType === 'bluetooth' && withSerial.length === 1) return withSerial[0].serialNumber;
+  if (connType === 'usb' && units.some((u) => !u.serialNumber)) return '(USB — no serial)';
+  return units.map((u) => u.serialNumber || 'no serial').join(' / ');
+}
+
 // App-layer calibration still owns variance-check + retry UX — on success
 // it pushes the captured bias into gyroFusion.bias.
 let calibrating = false;
@@ -609,20 +677,20 @@ async function init() {
     });
   }
 
-  requestAnimationFrame(loop);
+  // Pool EVERY granted HID device FIRST (single owner), so auto-adopt below just
+  // DESIGNATES a live pool entry rather than opening its own — otherwise the
+  // device gets opened twice (once at auto-connect, once by the pool) and the
+  // list row points at a dead duplicate. (Was the USB DS4 "SELECTED but dead".)
+  await initControllerList();
+  initSerialInventory();
 
-  // Check for already-connected gamepad (may have connected before
-  // our event listeners were attached). Same approach as the game's
-  // pollGamepad() fallback in input-manager.js.
-  const foundViaGamepadAPI = checkForExistingGamepad();
+  requestAnimationFrame(loop);
 
-  // If the Gamepad API has nothing, fall back to probing WebHID directly.
-  // This recovers the cold-start case where a DualSense is still in 0x31
-  // full-report mode from a previous session — Gamepad API is blind to it,
-  // but navigator.hid.getDevices() still lists the granted device.
-  if (!foundViaGamepadAPI) {
-    bootstrapFromHID();
-  }
+  // Adopt an already-connected XInput pad at startup (Xbox has no HID interface,
+  // so it can't be pool-adopted). HID controllers are NOT auto-selected at
+  // startup — nothing is SELECTED until the user ENGAGES one (autoAdoptFromPool)
+  // or clicks its row, so the "No Controller" splash stays until then.
+  checkForExistingGamepad();
 }
 
 /**
@@ -683,11 +751,16 @@ function detectInitialController() {
 function checkForExistingGamepad() {
   const gamepads = navigator.getGamepads();
   for (let i = 0; i < gamepads.length; i++) {
-    if (gamepads[i]) {
-      console.log('Found existing gamepad at startup:', gamepads[i].id);
-      switchController(gamepads[i]);
-      return true;
-    }
+    const gp = gamepads[i];
+    if (!gp) continue;
+    // Skip HID controllers — they're adopted from the pool only when engaged, so
+    // an untouched pad never auto-selects. Only XInput pads (not in the pool)
+    // are adopted at startup here.
+    const vp = ControllerRegistry.parseGamepadVendorProduct(gp.id);
+    if (vp && listManager._findPoolEntryByVidPid(vp.vendorId, vp.productId)) continue;
+    console.log('Found existing XInput gamepad at startup:', gp.id);
+    switchController(gp);
+    return true;
   }
   return false;
 }
@@ -734,9 +807,10 @@ async function bootstrapFromHID() {
 // CONTROLLER LIFECYCLE
 // =====================================================================
 
-async function switchController(gamepad) {
+async function switchController(gamepad, preferredDevice = null) {
   if (switchingController) return;
   switchingController = true;
+  _preferredGyroDevice = preferredDevice;   // bind THIS exact handle if given (list-selection)
 
   try {
     const newType = controllerTypeSelect.value === 'auto'
@@ -767,13 +841,24 @@ async function switchController(gamepad) {
     noControllerSplash.classList.add('hidden');
 
     // Update UI
-    gamepadIndex = gamepad.index;
+    // HID-selection stub uses -1 → buttons from the synthetic. AND: if two pads
+    // share this vid:pid (a GameSir + a real DS4, both 054c:05c4) we can't trust
+    // the pad index to be OUR device, so drop to null and drive from the
+    // connected HID handle's synthetic — otherwise pressing one lights both rows.
+    const _vpG = ControllerRegistry.parseGamepadVendorProduct(gamepad.id);
+    const _dupPads = _vpG ? (navigator.getGamepads() || []).filter((g) => {
+      if (!g) return false; const v = ControllerRegistry.parseGamepadVendorProduct(g.id);
+      return v && v.vendorId === _vpG.vendorId && v.productId === _vpG.productId;
+    }).length : 1;
+    gamepadIndex = (gamepad.index >= 0 && _dupPads <= 1) ? gamepad.index : null;
     gamepadStatusEl.textContent = gamepad.id.slice(0, 30);
     gamepadStatusEl.classList.add('connected');
 
     // Show gyro toggle and auto-connect if controller supports gyro
     const info = ControllerRegistry.identifyFromGamepadId(gamepad.id);
-    if (navigator.hid && info?.hasGyro) {
+    // An explicit list-selection ALWAYS connects the chosen handle (so it
+    // becomes SELECTED); otherwise auto-connect only for gyro-capable pads.
+    if (navigator.hid && (preferredDevice || info?.hasGyro)) {
       showGyroToggle();
       // Always auto-connect gyro — in Electron requestDevice() auto-approves,
       // in browsers it will fail silently and the user can click the button.
@@ -809,9 +894,40 @@ function onGamepadDisconnected(index) {
   overlay.setVisible(false);
 }
 
+// Input-driven auto-adopt from the WebHID pool: when NOTHING is SELECTED,
+// designate the controller the user has actually ENGAGED (a pool entry that has
+// been pressed), else the first receiving gyro-capable entry. This is the ONLY
+// auto-SELECT path for HID controllers — so a controller's Gamepad-API pad merely
+// CONNECTING (e.g. a Switch Pro BT pad appearing a second after boot) never
+// auto-selects an untouched controller. Pressing a controller makes it ACTIVE,
+// not SELECTED; SELECTED only changes at startup, on disconnect re-adopt, or by
+// explicit list-click. Runs each frame from the loop while nothing is selected.
+function autoAdoptFromPool() {
+  if (hidDevice || _preferredGyroDevice || switchingController) return;
+  const pool = [...listManager._hidPool.values()];
+  const gyroable = (e) => { const en = ControllerRegistry.getEntry(e.device.vendorId, e.device.productId); return !!(en && en.capabilities.gyro); };
+  // ONLY adopt a controller the user has actually ENGAGED (pressed a button on).
+  // An untouched controller — however it connects — must never auto-SELECT; the
+  // user picks it by pressing it or clicking its row. This is what stopped the
+  // idle Switch Pro from grabbing SELECTED after a DS4 press.
+  const entry = pool.find((e) => e._everPressed && gyroable(e) && e.hidActiveSince > 0);
+  if (!entry) return;
+  const d = entry.device, hx = (n) => n.toString(16).padStart(4, '0');
+  const stub = { id: `${d.productName || 'Controller'} (STANDARD GAMEPAD Vendor: ${hx(d.vendorId)} Product: ${hx(d.productId)})`,
+    index: -1, axes: [0, 0, 0, 0], buttons: Array.from({ length: 22 }, () => ({ pressed: false, value: 0 })) };
+  switchController(stub, d);
+}
+
 // ── Gamepad events ──
 
 window.addEventListener('gamepadconnected', (e) => {
+  if (hidDevice || gyroActive || switchingController || _preferredGyroDevice) return;
+  // A HID controller is adopted via the POOL (autoAdoptFromPool), NOT its
+  // Gamepad-API pad connecting — otherwise a Switch Pro BT pad appearing a second
+  // after boot would auto-select an untouched controller. Only XInput pads (Xbox,
+  // no HID interface, so not in the pool) are adopted through the Gamepad API.
+  const vp = ControllerRegistry.parseGamepadVendorProduct(e.gamepad.id);
+  if (vp && listManager._findPoolEntryByVidPid(vp.vendorId, vp.productId)) return;
   switchController(e.gamepad);
 });
 
@@ -858,11 +974,17 @@ gyroToggleBtn.addEventListener('click', () => toggleGyro());
  */
 function scheduleGyroConnect() {
   cancelGyroConnect();
-  // 2-second delay: Switch Pro needs time for USB enumeration + HID readiness.
-  // The driver's init() has its own internal retries and delays for sub-commands.
+  // 2s for auto-connect (Switch Pro needs USB-enumeration + HID readiness time).
+  // An explicit list-selection targets an ALREADY-open pooled handle, so connect
+  // it promptly — the 2s wait made selection feel broken.
+  const delay = _preferredGyroDevice ? 150 : 2000;
   gyroConnectTimer = setTimeout(async () => {
     gyroConnectTimer = null;
-    if (gamepadIndex === null) return;
+    // Bail only when there's nothing to connect. An explicit list-selection of a
+    // HID-only pad (Steam, DualSense-BT) or an identical-vid:pid pad has
+    // gamepadIndex===null but DOES set _preferredGyroDevice — that must still
+    // connect (else it goes ACTIVE-not-SELECTED and needs a manual Connect click).
+    if (gamepadIndex === null && !_preferredGyroDevice) return;
     if (gyroActive) return;
     console.log('Auto-connecting gyro for', currentControllerType, '...');
     try {
@@ -875,7 +997,7 @@ function scheduleGyroConnect() {
     } catch (err) {
       console.warn('Gyro auto-connect failed:', err.message);
     }
-  }, 2000);
+  }, delay);
 }
 
 function cancelGyroConnect() {
@@ -898,21 +1020,33 @@ async function connectControllerGyro() {
   if (!navigator.hid) return;
 
   const filters = ControllerRegistry.getHIDFilters();
-  let device;
+  // An explicit list-selection targets THIS exact HID handle (so two identical
+  // vid:pid pads don't collide). Consumed once.
+  let device = _preferredGyroDevice;
+  _preferredGyroDevice = null;
+  if (device) { await finishGyroConnect(device); return; }
+
+  // Match the gyro HID device to the ACTIVE gamepad's vid:pid. Without this,
+  // with two controllers connected we'd grab the first gyro-capable granted
+  // device (e.g. a Steam Controller) and show ITS gyro under THIS controller's
+  // buttons — the exact cross-wire seen with a GameSir + Steam Controller.
+  let wantVp = null;
+  if (gamepadIndex !== null) {
+    const gp = navigator.getGamepads()[gamepadIndex];
+    if (gp) wantVp = ControllerRegistry.parseGamepadVendorProduct(gp.id);
+  }
 
   // Step 1: check previously-granted devices
-  console.log('connectControllerGyro: trying getDevices()...');
+  console.log('connectControllerGyro: trying getDevices()...', wantVp ? `(prefer ${wantVp.vendorId.toString(16)}:${wantVp.productId.toString(16)})` : '');
   try {
     const granted = await navigator.hid.getDevices();
     console.log('connectControllerGyro: getDevices returned', granted.length, 'device(s)');
-    for (const d of granted) {
-      const entry = ControllerRegistry.getEntry(d.vendorId, d.productId);
-      if (entry && entry.capabilities.gyro) {
-        device = d;
-        console.log('connectControllerGyro: found granted device:', d.productName);
-        break;
-      }
-    }
+    const gyroable = (d) => { const e = ControllerRegistry.getEntry(d.vendorId, d.productId); return !!(e && e.capabilities.gyro); };
+    // Prefer the handle matching the active gamepad; fall back to the first
+    // gyro-capable device (single-controller case, unchanged).
+    if (wantVp) device = granted.find((d) => d.vendorId === wantVp.vendorId && d.productId === wantVp.productId && gyroable(d));
+    if (!device) device = granted.find(gyroable);
+    if (device) console.log('connectControllerGyro: found granted device:', device.productName);
   } catch (err) {
     console.log('connectControllerGyro: getDevices failed:', err.message);
   }
@@ -933,81 +1067,92 @@ async function connectControllerGyro() {
     console.log('connectControllerGyro: no device found');
     return;
   }
-
-  console.log('connectControllerGyro: connecting to', device.productName,
-    'vid:' + device.vendorId.toString(16), 'pid:' + device.productId.toString(16));
-
-  // Clean up old device if any
-  if (hidDevice) {
-    hidDevice.removeEventListener('inputreport', handleInputReport);
-    try { await hidDevice.close(); } catch (e) { /* ok */ }
-    hidDevice = null;
-    for (const sib of hidExtraDevices) {
-      sib.removeEventListener('inputreport', handleInputReport);
-      try { await sib.close(); } catch (e) { /* ok */ }
-    }
-    hidExtraDevices = [];
-    if (controllerDriver?.destroy) controllerDriver.destroy();
-    controllerDriver = null;
-  }
-
-  controllerDriver = await ControllerRegistry.connect(device);
-  hidDevice = controllerDriver.device;
-  hidDevice.addEventListener('inputreport', handleInputReport);
-
-  // Multi-interface fan-out: requestDevice returns ONE HIDDevice, but
-  // some controllers (Steam Controller Puck) expose multiple interfaces
-  // sharing a vid:pid where only one emits the STATE reports we care
-  // about. Attach handleInputReport to every already-approved sibling
-  // with the same vid:pid so the active one drives the synthetic gamepad
-  // regardless of which the picker handed us. Generic logic — for
-  // DualSense / Switch Pro the usagePage filter in getHIDFilters keeps
-  // siblings out of the approval list, so this is a no-op there.
-  hidExtraDevices = [];
-  try {
-    const approved = await navigator.hid.getDevices();
-    const siblings = approved.filter((d) =>
-      d !== hidDevice && d.vendorId === hidDevice.vendorId && d.productId === hidDevice.productId
-    );
-    for (const sib of siblings) {
-      try {
-        if (!sib.opened) await sib.open();
-        sib.addEventListener('inputreport', handleInputReport);
-        hidExtraDevices.push(sib);
-      } catch (err) {
-        console.log('inputreport fan-out: skipping', sib.productName, '—', err.message);
-      }
-    }
-    if (hidExtraDevices.length > 0) {
-      console.log(`inputreport fan-out: listening on ${hidExtraDevices.length} extra HID handle(s) for ${hidDevice.productName}`);
-    }
-  } catch (err) {
-    console.log('inputreport fan-out: getDevices failed —', err.message);
-  }
-
+  await finishGyroConnect(device);
+}
+
+// Connect a SPECIFIC HID device as the overlay's active gyro/button source.
+// Shared by the auto-connect path and explicit list-selection (which sets
+// _preferredGyroDevice so two identical vid:pid pads don't collide).
+// Phase 3b: the device is ALREADY pooled and driven by the manager (driver,
+// fusion, synthetic all live). "Connecting" now just DESIGNATES that pool entry
+// as the one the overlay shows — no second connection, no eviction, no separate
+// inputreport listener, no app-layer calibration (the entry's fusion self-
+// calibrates). Kept the name/signature so callers (auto-connect, selection) are
+// unchanged.
+async function finishGyroConnect(device) {
+  const forVp = (e) => e.device.vendorId === device.vendorId && e.device.productId === device.productId;
+  const pool = () => [...listManager._hidPool.values()];
+  // Prefer the EXACT pooled handle. A getDevices() handle can be a DIFFERENT JS
+  // object than the pooled one for the SAME physical device — do NOT re-pool it,
+  // that double-opens the device and yields a dead duplicate entry (the "USB DS4
+  // SELECTED but dead" bug). Fall back to a same-vid:pid entry that's actually
+  // RECEIVING parsed reports (hidActiveSince > 0 — a wire-level fact, NOT the
+  // user-facing ACTIVE state, which means the user has interacted with it).
+  let entry = pool().find((e) => e.device === device)
+           || pool().filter(forVp).find((e) => e.hidActiveSince > 0)
+           || pool().find(forVp);
+  if (!entry) {
+    // Genuinely not pooled (e.g. a freshly-granted device) — pool once, then take it.
+    try { await listManager.poolDevice(device); } catch (e) { /* ok */ }
+    entry = pool().find((e) => e.device === device) || pool().find(forVp);
+  }
+  if (!entry) { console.warn('finishGyroConnect: no pool entry for', device.productName); return; }
+
+  // Steam Controller Puck: the picked handle may be a sibling that never emits
+  // STATE reports — designate the same-vid:pid interface that IS receiving them.
+  if (entry.driver?.constructor?.needsSiblingFanout) {
+    const rx = pool().filter((e) => forVp(e) && e.hidActiveSince > 0);
+    if (rx.length) entry = rx[0];
+  }
+
+  designateEntry(entry);
+  console.log('[designate]', entry.device.productName || (entry.device.vendorId.toString(16) + ':' + entry.device.productId.toString(16)),
+    (entry.driver && entry.driver.connectionType), 'receiving=' + (entry.hidActiveSince > 0));
+}
+
+// Point the overlay's viz at a pool entry: alias hidDevice/controllerDriver/
+// syntheticGamepad/gyroFusion to it, apply the overlay's gravity/yaw prefs to
+// its fusion, and run the post-connect hooks. The manager keeps feeding it.
+function designateEntry(entry) {
+  selectedEntry = entry;
+  hidDevice = entry.device;
+  controllerDriver = entry.driver;
+  syntheticGamepad = entry.synthetic;
+  gyroFusion = entry.fusion;
+  gyroFusion.gravityMode = GRAVITY_MODES[gravityMode] || 0;
+  gyroFusion.yawReturnHalfLife = YAW_RETURN_MODES[yawReturnMode] ?? 0;
   gyroActive = true;
   gyroPermitted = true;
   connectGyroBtn.textContent = 'Connected';
   updateGyroToggle();
   showGyroHud();
-  console.log('Gyro connected:', device.productName);
-
-  if (isPuckDevice(device)) onPuckConnected();
-  else onPuckDisconnected();
-
+  // The entry's fusion has been integrating since it was POOLED (boot), so its
+  // orientation carries accumulated drift and its bias was calibrated whenever
+  // the pad happened to be still (or not) during pooling. Reset the orientation
+  // for a clean start and re-run the one-shot bias calibration NOW (on selection,
+  // when the pad is usually at rest) for a tight window — matching the old
+  // connect-time behavior. Continuous stillness + manual L3+R4 refine from there.
+  gyroFusion.reset();
   startCalibration();
-
-  // The driver's init() has run an IMU-layout probe (PlayStation family
-  // only, for now) and set _detectedImuFamily if a wire-level signature
-  // matched a known family. When this disagrees with the profile we
-  // loaded a moment ago against gamepad.id alone — e.g. we loaded
-  // 'dualsense' because that's the first 054c:09cc match, but the
-  // pad is actually a GameSir clone — swap the visualizer to the
-  // family-matched entry's profile. Honors the dropdown override so
-  // an explicit user choice isn't undone.
+  if (isPuckDevice(hidDevice)) onPuckConnected();
+  else onPuckDisconnected();
   maybeSwapProfileAfterImuProbe();
 }
 
+// Stop showing the current controller (device stays pooled + live). Used on
+// disconnect / before switching. Falls back to the neutral idle fusion.
+function undesignateEntry() {
+  selectedEntry = null;
+  hidDevice = null;
+  controllerDriver = null;
+  syntheticGamepad = null;
+  gyroFusion = _idleFusion;
+  hidExtraDevices = [];
+  gyroActive = false;
+  gyroPermitted = false;
+  onPuckDisconnected();
+}
+
 /**
  * Consult the driver's runtime-detected IMU family and swap the overlay
  * profile to the family-matched entry's controllerProfile when the auto-
@@ -1051,28 +1196,13 @@ function maybeSwapProfileAfterImuProbe() {
  * Disconnect gyro and reset state.
  */
 async function disconnectGyro() {
-  if (hidDevice) {
-    hidDevice.removeEventListener('inputreport', handleInputReport);
-    try { await hidDevice.close(); } catch (e) { /* ok */ }
-    hidDevice = null;
-    for (const sib of hidExtraDevices) {
-      sib.removeEventListener('inputreport', handleInputReport);
-      try { await sib.close(); } catch (e) { /* ok */ }
-    }
-    hidExtraDevices = [];
-    onPuckDisconnected();
-  }
-  if (controllerDriver) {
-    if (controllerDriver.destroy) controllerDriver.destroy();
-    controllerDriver = null;
-  }
-  gyroActive = false;
-  gyroPermitted = false;
-  syntheticGamepad = null;
+  // Phase 3b: the device stays pooled + live (manager owns it) — we just stop
+  // showing it. NEVER reset the entry's fusion here (the manager keeps using it);
+  // undesignateEntry points gyroFusion back at the neutral _idleFusion first.
+  undesignateEntry();
   _firstReportLogged = false;
-  // Shared SensorFusion owns orientation + all intermediate state.
-  gyroFusion.reset();
-  gyroFusion.resetBias();
+  _idleFusion.reset();
+  _idleFusion.resetBias();
   calibrating = false;
   calibSamples = [];
   calibRetries = 0;
@@ -1084,8 +1214,153 @@ async function disconnectGyro() {
 
 // ── Main loop ──
 
+// ── Controllers list render (Phase 1: read-only list + live dots) ──
+function _padActive(gp) {
+  if (!gp) return false;
+  for (const b of (gp.buttons || [])) if (b && (b.pressed || (b.value || 0) > 0.5)) return true;
+  for (const a of (gp.axes || [])) if (Math.abs(a) > 0.5) return true;
+  return false;
+}
+function _vpStr(vp) { return vp ? ((vp.vendorId || 0).toString(16).padStart(4, '0') + ':' + (vp.productId || 0).toString(16).padStart(4, '0')) : '—'; }
+function _ctrlName(vp, fallback) {
+  if (vp) { const e = ControllerRegistry.getEntry(vp.vendorId, vp.productId); if (e && e.name) return e.name; }
+  return fallback || 'Controller';
+}
+// Three states: SELECTED (the one and only controller driving the overlay) >
+// ACTIVE (interacted at least once) > AVAILABLE (connected, idle).
+function overlayControllerRows() {
+  const rows = [];
+  const pads = navigator.getGamepads ? navigator.getGamepads() : [];
+  const stateFor = (key, isActive) => { if (isActive) _everActive.add(key); return _everActive.has(key) ? 'ACTIVE' : 'AVAILABLE'; };
+  if (hidDevice) {                                   // SELECTED — shown in the overlay
+    const vp = { vendorId: hidDevice.vendorId, productId: hidDevice.productId };
+    const conn = (controllerDriver && controllerDriver.connectionType) || 'hid';
+    rows.push({ key: 'active', sortId: deviceIdFor(hidDevice), name: _ctrlName(vp, hidDevice.productName), state: 'SELECTED',
+      conn, vp, serial: serialForDevice(vp, conn), active: _padActive(readGamepad()), selected: true });
+  }
+  // Pool entries → rows. A fan-out device (Steam Controller Puck: 5 same-vid:pid
+  // HID interfaces on ONE physical unit) rolls up to a SINGLE row; other handles
+  // are one row each. Siblings of the SELECTED controller are hidden.
+  // TODO: multiple Steam Controllers on one Puck will need per-unit rollup (issue).
+  const groups = new Map();
+  for (const entry of listManager._hidPool.values()) {
+    const d = entry.device;
+    if (d === hidDevice) continue;   // the SELECTED device is now pooled too — shown as its own row above
+    const isFanout = !!(entry.driver && entry.driver.constructor && entry.driver.constructor.needsSiblingFanout);
+    if (isFanout && hidDevice && d.vendorId === hidDevice.vendorId && d.productId === hidDevice.productId) continue;
+    const gk = isFanout ? ('fan:' + d.vendorId + ':' + d.productId) : ('dev:' + deviceIdFor(d));
+    const a = _padActive(entry.synthetic);
+    const g = groups.get(gk);
+    if (g) { g.active = g.active || a; } else groups.set(gk, { device: d, entry, active: a });
+  }
+  for (const g of groups.values()) {
+    const d = g.device, vp = { vendorId: d.vendorId, productId: d.productId };
+    const key = 'h:' + deviceIdFor(d), a = g.active;
+    const conn = (g.entry.driver && g.entry.driver.connectionType) || 'hid';
+    rows.push({ key, sortId: deviceIdFor(d), name: _ctrlName(vp, d.productName), state: stateFor(key, a),
+      conn, vp, serial: serialForDevice(vp, conn), active: a });
+  }
+  for (const gp of pads) {                            // gamepad-only pads not already shown
+    if (!gp) continue;
+    const vp = ControllerRegistry.parseGamepadVendorProduct(gp.id);
+    if (hidDevice && vp && hidDevice.vendorId === vp.vendorId && hidDevice.productId === vp.productId) continue;
+    if (vp && listManager._findPoolEntryByVidPid(vp.vendorId, vp.productId)) continue;
+    const key = 'g:' + gp.index, a = _padActive(gp);
+    rows.push({ key, sortId: 100000 + gp.index, name: _ctrlName(vp, 'Controller'), state: stateFor(key, a), conn: 'gamepad', vp, serial: serialForDevice(vp, 'gamepad'), active: a });
+  }
+  // Stable order by first-sighting (deviceId) so SELECTING a controller does NOT
+  // reorder the list — the row you clicked stays put instead of jumping to top.
+  rows.sort((x, y) => x.sortId - y.sortId);
+  return rows;
+}
+
+// Select a controller from the detached list to drive the overlay (Phase 2).
+async function selectController(key) {
+  if (!key || key === 'active') return;              // already the SELECTED one
+  if (key.startsWith('g:')) {
+    const gp = (navigator.getGamepads() || [])[parseInt(key.slice(2), 10)];
+    if (gp) await switchController(gp);              // model + gyro auto-matched to this pad
+    return;
+  }
+  if (key.startsWith('h:')) {
+    const id = key.slice(2);
+    let device = null;
+    for (const entry of listManager._hidPool.values()) { if (String(deviceIdFor(entry.device)) === id) { device = entry.device; break; } }
+    if (!device) return;
+    // Stub carries a proper gamepad-id (vid:pid) so the MODEL + labels resolve;
+    // preferredDevice binds THIS exact HID handle for gyro/buttons.
+    const hx = (n) => n.toString(16).padStart(4, '0');
+    const stub = {
+      id: `${device.productName || 'Controller'} (STANDARD GAMEPAD Vendor: ${hx(device.vendorId)} Product: ${hx(device.productId)})`,
+      index: -1, axes: [0, 0, 0, 0], buttons: Array.from({ length: 22 }, () => ({ pressed: false, value: 0 })),
+    };
+    await switchController(stub, device);
+    if (!syntheticGamepad) syntheticGamepad = createSyntheticGamepad(device.productName);
+    // Adopt a matching Gamepad pad ONLY when it's unambiguous (exactly one pad
+    // for this vid:pid). With two identical pads (a GameSir + a real DS4, both
+    // 054c:05c4) we can't tell which is ours, so drive buttons from THIS exact
+    // HID handle's synthetic instead — otherwise pressing one lights both rows.
+    const matchPads = (navigator.getGamepads() || []).filter((gp) => {
+      if (!gp) return false;
+      const vp = ControllerRegistry.parseGamepadVendorProduct(gp.id);
+      return vp && vp.vendorId === device.vendorId && vp.productId === device.productId;
+    });
+    gamepadIndex = matchPads.length === 1 ? matchPads[0].index : null;
+  }
+}
+// Forward the controller rows to the detached "Controllers" window (no-op if it
+// isn't open — main.js drops the frame). Serializable rows only (no DOM/refs).
+function forwardControllerList() {
+  if (!(window.electronAPI && window.electronAPI.sendHudState)) return;
+  try { window.electronAPI.sendHudState('controllers', overlayControllerRows()); } catch (e) { /* window closed */ }
+}
+// Drop phantom handles: a granted device that has NEVER delivered a raw report
+// (lastRawReportAt===0) after a grace window is a stale/half-open grant, not a
+// live controller (the "USB DS4 SELECTED but rawReportAt=0" case). The manager
+// does this in ingestFrame, which the overlay doesn't call — so do it here. A
+// physically-present controller streams within ms, so 3s is safe.
+const _PHANTOM_MS = 3000;
+function evictPhantoms(now) {
+  for (const entry of [...listManager._hidPool.values()]) {
+    if (entry.lastRawReportAt === 0 && typeof entry.pooledAt === 'number' && (now - entry.pooledAt) > _PHANTOM_MS) {
+      const dev = entry.device;
+      console.log('[overlay] evicting phantom (no reports in ' + Math.round((now - entry.pooledAt)) + 'ms):',
+        dev.productName || (dev.vendorId.toString(16) + ':' + dev.productId.toString(16)));
+      if (dev === hidDevice) undesignateEntry();   // was SELECTED — drop it, let auto-adopt find a live one
+      try { listManager._evictFromPool(dev); } catch (e) { /* ok */ }
+    }
+  }
+}
+// Stalled-stream recovery: a SELECTED handle can stop delivering reports mid-
+// session (seen on a USB DS4 — lastRawReportAt FREEZES at a non-zero value while
+// other controllers keep advancing) yet stay "connected" for a long time. The
+// overlay would show frozen gyro/buttons until Chromium finally fires disconnect.
+// Detect the freeze (no new raw report for a window) and re-init the driver to
+// kick the stream; back off between attempts so we don't churn a live-but-idle-
+// looking device. (A device that never streamed at all is handled by evictPhantoms.)
+let _streamWatchRaw = -1, _streamWatchAt = 0, _streamReinitAt = 0;
+function checkStalledStream(now) {
+  if (!selectedEntry || !gyroActive) { _streamWatchRaw = -1; return; }
+  const raw = selectedEntry.lastRawReportAt | 0;
+  if (raw !== _streamWatchRaw) { _streamWatchRaw = raw; _streamWatchAt = now; return; }  // still advancing
+  if (raw > 0 && (now - _streamWatchAt) > 1500 && (now - _streamReinitAt) > 4000) {
+    _streamReinitAt = now;
+    console.warn('[overlay] SELECTED stream stalled', Math.round(now - _streamWatchAt) + 'ms — re-initing driver:',
+      selectedEntry.device.productName || (selectedEntry.device.vendorId.toString(16) + ':' + selectedEntry.device.productId.toString(16)));
+    if (selectedEntry._reinitDriver) { try { selectedEntry._reinitDriver(); } catch (e) { /* ok */ } }
+  }
+}
+let _ovlListThrottle = 0, _phantomThrottle = 0, _streamThrottle = 0, _adoptThrottle = 0;
+
 function loop() {
   requestAnimationFrame(loop);
+  const _now = performance.now();
+  if (_now - _ovlListThrottle > 120) { _ovlListThrottle = _now; forwardControllerList(); }
+  if (_now - _phantomThrottle > 1000) { _phantomThrottle = _now; evictPhantoms(_now); }
+  if (_now - _streamThrottle > 500) { _streamThrottle = _now; checkStalledStream(_now); }
+  // Auto-adopt a HID controller from the pool when nothing is SELECTED (startup /
+  // after a disconnect). Cheap: bails immediately once something is selected.
+  if (!hidDevice && _now - _adoptThrottle > 200) { _adoptThrottle = _now; autoAdoptFromPool(); }
   if (!modelReady) return;
 
   const gamepad = readGamepad();
@@ -1116,6 +1391,19 @@ function loop() {
     }
   }
 
+  // Report-level extras (touchpad/grips) from the SELECTED pool entry — the
+  // manager stores the last parsed values on the entry (Phase 3b; handleInputReport
+  // no longer runs). Forward them the same way it used to.
+  if (selectedEntry) {
+    if (selectedEntry._lastTouchpad) overlay.updateTouchpad(selectedEntry._lastTouchpad, selectedEntry._lastTouchpadButton);
+    const grips = selectedEntry._lastGrips;
+    if (grips) {
+      _lastGrips = grips;
+      if (overlay.setGripState) overlay.setGripState(grips);
+      updateGripHud(grips);
+    }
+  }
+
   // displayOrientation is the recentered/yaw-returned orientation (issue #88);
   // pitch/roll are identical to the raw orientation, only the heading offset
   // differs, so every visual consumer reads it for a consistent picture.
@@ -1257,8 +1545,9 @@ function toggleSettings(source) {
 
 async function toggleGyro() {
   if (gyroActive) {
+    // Just stop DISPLAYING the gyro — never reset the entry's fusion (the manager
+    // owns it and keeps feeding it; resetting would fight the shared state).
     gyroActive = false;
-    gyroFusion.reset();
     updateGyroToggle();
     hideGyroHud();
   } else if (gyroPermitted && hidDevice) {
@@ -1471,23 +1760,20 @@ document.querySelectorAll('[data-remap]').forEach(btn => {
 });
 
 function readGamepad() {
-  // Force-prefer the HID-synthesized gamepad whenever we have a live
-  // Bluetooth driver. On Electron 33 (Chromium 130) the Gamepad API
-  // keeps returning a stale Gamepad object for the slot even after
-  // DualSense has switched to 0x31 full-report mode — frozen axes and
-  // buttons that never update. On Chrome/Mac the slot comes back null
-  // and the legacy "real-first, synthetic-fallback" path below handles
-  // it, but inside Electron we have to override the preference or the
-  // stale slot wins and sticks/buttons silently stop working. Same
-  // issue and same fix as the main game's InputManager.getGamepadState
-  // (petegordon/tandemonium#199).
-  if (controllerDriver &&
-      controllerDriver.connectionType === 'bluetooth' &&
-      syntheticGamepad) {
+  // ── WebHID-authoritative (Phase 3) ──
+  // Whenever we have a live HID driver + synthetic, that synthetic IS the source
+  // of truth — for every HID controller, not just Bluetooth. It carries the
+  // COMPLETE button map (Switch Capture / DualSense mic / back paddles), reads
+  // the exact physical handle (so two identical vid:pid pads never cross-wire),
+  // and is immune to the Gamepad API's stale-slot freezes and unmapped buttons
+  // (e.g. Chromium never surfacing the Switch Pro Capture button). The Gamepad
+  // API below is now only a FALLBACK for XInput-only pads (Xbox wired/dongle)
+  // that expose no HID input interface — those have no controllerDriver.
+  if (controllerDriver && syntheticGamepad) {
     return syntheticGamepad;
   }
 
-  // Preferred source: the real Gamepad API, if it still owns this slot.
+  // XInput-only fallback: no HID driver → read the Gamepad API slot.
   if (gamepadIndex !== null) {
     const gp = navigator.getGamepads()[gamepadIndex];
     if (gp) return gp;
@@ -1501,19 +1787,14 @@ function readGamepad() {
     return syntheticGamepad;
   }
 
-  // No slot yet and no HID → probe the Gamepad API for a fresh connection.
-  if (gamepadIndex === null) {
-    const gamepads = navigator.getGamepads();
-    for (let i = 0; i < gamepads.length; i++) {
-      if (gamepads[i]) {
-        switchController(gamepads[i]);
-        return null;
-      }
-    }
-    return null;
-  }
+  // Nothing SELECTED → no input this frame. Adoption is NOT done here anymore:
+  // HID controllers are auto-adopted from the pool ONLY when engaged
+  // (autoAdoptFromPool), and XInput pads via gamepadconnected. So a mere pad
+  // being present never auto-selects — the "No Controller" splash stays until the
+  // user presses a controller or clicks its row.
+  if (gamepadIndex === null) return null;
 
-  // Had a slot, the Gamepad API dropped it, and we have no HID fallback.
+  // Had an XInput slot, the Gamepad API dropped it.
   onGamepadDisconnected(gamepadIndex);
   return null;
 }
@@ -1577,7 +1858,7 @@ function updateSyntheticFromParsed(parsed) {
     set(14, b.dpadLeft);
     set(15, b.dpadRight);
     set(16, b.ps);
-    set(17, b.mic || b.quickAccess); // DualSense mic / Steam Controller "…" share slot 17
+    set(17, b.mic || b.quickAccess || b.capture); // DualSense mic / Steam "…" / Switch Pro Capture share slot 17
   }
 
   // Back paddles (L4/L5/R4/R5) — no Standard-Gamepad index, so park them in
@@ -1791,15 +2072,17 @@ function recenterHeading() {
 }
 
 function startCalibration() {
-  calibrating = true;
-  calibSamples = [];
-  calibRetries = 0;
-  resetGyroState();
-  // NB: calibration must NOT touch the camera. It only re-zeros gyro bias +
-  // orientation; snapping the view to a preset here stomped the user's manual
-  // zoom/pan every time they recalibrated (#94). The camera keeps its own
-  // preset controls; leave the current view alone.
-  showCalibHint('Calibrating...', null);
+  // Phase 3b: the SELECTED pool entry's fusion self-calibrates — SensorFusion
+  // .startCalibration has the same variance/retry logic this used to duplicate
+  // (and it's what the game uses). Trigger it; the manager drives the samples.
+  // Reset orientation (zero the displayed pose) + bias so a recalibrate returns
+  // to the zero positions (the old resetGyroState behavior — #94: no camera).
+  if (gyroFusion) {
+    if (gyroFusion.reset) gyroFusion.reset();
+    if (gyroFusion.resetBias) gyroFusion.resetBias();
+    if (gyroFusion.startCalibration) gyroFusion.startCalibration(controllerDriver?.connectionType);
+  }
+  showCalibHint('Calibrating...', 2500);
 }
 
 function finishCalibration() {
@@ -2135,6 +2418,25 @@ if (yawReturnSelect) {
 const recenterBtn = document.getElementById('recenter-btn');
 if (recenterBtn) recenterBtn.addEventListener('click', recenterHeading);
 
+// Pop out the movable Controllers list window (opaque panel — no green screen).
+const ovlCtrlPopoutBtn = document.getElementById('ovl-ctrl-popout');
+if (ovlCtrlPopoutBtn && window.electronAPI?.openHudWindow) {
+  ovlCtrlPopoutBtn.addEventListener('click', () => {
+    window.electronAPI.openHudWindow('controllers', currentControllerType, { on: false });
+    // Gesture-backed serial scan: requestDevice needs user activation, so a boot
+    // timer can't do it. This click IS a gesture — its select-hid-device handler
+    // upserts EVERY present device's serial into the inventory the window shows.
+    if (navigator.hid && navigator.userAgent.includes('Electron')) {
+      navigator.hid.requestDevice({ filters: ControllerRegistry.getHIDFilters() }).catch(() => {});
+    }
+  });
+}
+// A row was clicked in the detached Controllers window → switch which controller
+// drives this overlay (auto-model; the Model dropdown still overrides).
+if (window.electronAPI?.onControllerSelect) {
+  window.electronAPI.onControllerSelect((p) => { if (p && p.key) selectController(p.key); });
+}
+
 const opacitySlider = document.getElementById('opacity-slider');
 const opacityValue = document.getElementById('opacity-value');
 opacitySlider.addEventListener('input', (e) => {
diff --git a/apps/overlay/src/js/controllers-window.js b/apps/overlay/src/js/controllers-window.js
new file mode 100644
index 0000000..f695729
--- /dev/null
+++ b/apps/overlay/src/js/controllers-window.js
@@ -0,0 +1,50 @@
+// ============================================================
+// CONTROLLERS WINDOW — detached list of all connected controllers
+// ============================================================
+//
+// Display-only for now (Phase 1). The main overlay forwards the controller rows
+// each frame over IPC ('hud-state-update', kind 'controllers'); this window
+// renders them with live "in use" dots. Window chrome (drag / close) is handled
+// by hud-window-chrome.js. Click-to-select comes in Phase 2.
+
+const listEl = document.getElementById('list');
+const countEl = document.getElementById('count');
+
+function vpStr(vp) {
+  return vp ? ((vp.vendorId || 0).toString(16).padStart(4, '0') + ':' + (vp.productId || 0).toString(16).padStart(4, '0')) : '—';
+}
+const esc = (s) => String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
+
+let sig = '';
+function render(rows) {
+  if (!Array.isArray(rows)) return;
+  const s = rows.map((r) => r.key + '|' + r.state + '|' + r.name + '|' + r.conn + '|' + vpStr(r.vp) + '|' + (r.serial || '')).join('~');
+  if (s !== sig) {
+    sig = s;
+    listEl.innerHTML = rows.length ? rows.map((r) =>
+      `<div class="row${r.selected ? ' sel' : ''}" data-key="${esc(r.key)}">` +
+      `<span class="dot" data-dot="${esc(r.key)}"></span>` +
+      `<span class="main"><span class="name">${esc(r.name)}</span>` +
+      `<span class="sub">${esc(r.conn)} · ${vpStr(r.vp)}</span>` +
+      `${r.serial ? `<span class="serial"># ${esc(r.serial)}</span>` : ''}</span>` +
+      `<span class="tag ${esc(r.state).toLowerCase()}">${esc(r.state)}</span></div>`
+    ).join('') : '<div class="empty">No controllers detected.</div>';
+    if (countEl) countEl.textContent = rows.length ? `(${rows.length})` : '';
+  }
+  for (const r of rows) {
+    const d = listEl.querySelector(`[data-dot="${esc(r.key)}"]`);
+    if (d) d.classList.toggle('on', !!r.active);
+  }
+}
+
+if (window.electronAPI && window.electronAPI.onHudState) {
+  window.electronAPI.onHudState(render);
+}
+
+// Click a row → tell the overlay to switch to that controller.
+listEl.addEventListener('click', (e) => {
+  const row = e.target instanceof Element ? e.target.closest('.row') : null;
+  if (row && row.dataset.key && window.electronAPI && window.electronAPI.selectController) {
+    window.electronAPI.selectController({ key: row.dataset.key });
+  }
+});
diff --git a/apps/overlay/src/js/lobby-app.js b/apps/overlay/src/js/lobby-app.js
new file mode 100644
index 0000000..a5bdb7f
--- /dev/null
+++ b/apps/overlay/src/js/lobby-app.js
@@ -0,0 +1,555 @@
+// ============================================================
+// LOBBY-APP.JS — Seat-select navigator (versus / co-op / solo)
+// ============================================================
+//
+// A controller-driven "player select" built on the controller-core
+// ControllerManager. Uses the manager's native slot lifecycle:
+//   - press any button        → manager claims a slot  → we seat the player
+//   - hold PS/Home 2s          → manager releases slot  → we free the seat
+//   - B on a joined seat       → releaseSlotToPool       → free the seat
+// On top of that we add mode selection, team/seat topology, a join→ready
+// gate, and per-controller lightbar + rumble feedback (DualSense today).
+//
+// This is the seam that will become Tandemonium's real lobby. Fixing any
+// WebHID quirk belongs in packages/core, which flows here (workspace) and
+// into the game (sync-controller-core).
+// ============================================================
+
+import { ControllerManager, ControllerRegistry } from '@usersfirst/controller-core';
+
+const SLOT_IDS = ['P1', 'P2', 'P3', 'P4'];
+const manager = new ControllerManager({ slotIds: SLOT_IDS });
+window.__manager = manager;
+
+const $ = (id) => document.getElementById(id);
+
+// ── seat topology per mode ──
+const MODES = ['together', 'versus', 'solo'];
+function makeSeats(mode) {
+  if (mode === 'solo') return { seats: [
+      { id: 'cap', role: 'Captain', kind: 'cap', locked: false },
+      { id: 'sto', role: 'Stoker', kind: 'sto', locked: true },
+    ], fill: ['cap'] };
+  if (mode === 'together') return { seats: [
+      { id: 'cap', role: 'Captain', kind: 'cap', locked: false },
+      { id: 'sto', role: 'Stoker', kind: 'sto', locked: false },
+    ], fill: ['cap', 'sto'] };
+  return { seats: [
+      { id: 'bcap', role: 'Captain', team: 'a' }, { id: 'bsto', role: 'Stoker', team: 'a' },
+      { id: 'rcap', role: 'Captain', team: 'b' }, { id: 'rsto', role: 'Stoker', team: 'b' },
+    ], fill: ['bcap', 'rcap', 'bsto', 'rsto'] };
+}
+
+const state = {
+  screen: 'mode',        // mode | lobby | level
+  mode: null,
+  seats: [], fill: [],
+  occ: new Map(),        // seatId -> slotId (seated only)
+  bySlot: new Map(),     // slotId -> { seatId: string|null, phase:'active'|'joined'|'ready', player }
+                         //   active = recognized, no seat · joined/ready = in a seat (seatId set)
+  nextP: 1,
+};
+
+const seat = (id) => state.seats.find((s) => s.id === id);
+const teamCount = (t) => state.seats.filter((s) => s.team === t && state.occ.has(s.id)).length;
+function nextOpen() { for (const id of state.fill) { const s = seat(id); if (s && !s.locked && !state.occ.has(id)) return s; } return null; }
+
+// ── hardware feedback (DualSense lightbar + rumble; others no-op) ──
+const RGB = { cap: { r:122, g:224, b:154 }, sto: { r:255, g:158, b:107 }, a: { r:110, g:168, b:255 }, b: { r:255, g:107, b:125 } };
+function seatRGB(seatId) { const s = seat(seatId); if (!s) return RGB.cap; if (s.team) return RGB[s.team]; return s.kind === 'cap' ? RGB.cap : RGB.sto; }
+function driverOf(slotId) { const s = manager.getSlot(slotId); return s ? s.driver : null; }
+function feedback(slotId, ready) {
+  const d = driverOf(slotId); const L = state.bySlot.get(slotId); if (!d || !L) return;
+  const c = seatRGB(L.seatId); const k = ready ? 1 : 0.4;
+  const lb = { r: (c.r*k)|0, g: (c.g*k)|0, b: (c.b*k)|0 };
+  const pat = (d.constructor && d.constructor.PLAYER_LED_PATTERNS && d.constructor.PLAYER_LED_PATTERNS[L.player]) || 0;
+  try {
+    if (typeof d.setPlayerFeedback === 'function') d.setPlayerFeedback({ playerLEDs: pat, lightbar: lb });
+    else if (typeof d.setLightbar === 'function') d.setLightbar(lb.r, lb.g, lb.b);
+  } catch (e) {}
+}
+function clearFb(slotId) {
+  const d = driverOf(slotId); if (!d) return;
+  try {
+    if (typeof d.setPlayerFeedback === 'function') d.setPlayerFeedback({ playerLEDs: 0, lightbar: { r:0, g:0, b:0 } });
+    else if (typeof d.setLightbar === 'function') d.setLightbar(0, 0, 0);
+  } catch (e) {}
+}
+function rumble(slotId, kind) {
+  const d = driverOf(slotId); if (!d || typeof d.setRumble !== 'function') return;
+  try { d.setRumble(0.6, 0.6, 110); if (kind === 'double') setTimeout(() => { try { d.setRumble(0.6, 0.6, 110); } catch (e) {} }, 150); } catch (e) {}
+}
+
+// Dim neutral lightbar = recognized (ACTIVE) but not in a seat yet.
+function activeFb(slotId) {
+  const d = driverOf(slotId); const L = state.bySlot.get(slotId); if (!d || !L) return;
+  const lb = { r: 34, g: 36, b: 44 };
+  const pat = (d.constructor && d.constructor.PLAYER_LED_PATTERNS && d.constructor.PLAYER_LED_PATTERNS[L.player]) || 0;
+  try {
+    if (typeof d.setPlayerFeedback === 'function') d.setPlayerFeedback({ playerLEDs: pat, lightbar: lb });
+    else if (typeof d.setLightbar === 'function') d.setLightbar(lb.r, lb.g, lb.b);
+  } catch (e) {}
+}
+
+// ── recognition / seat state machine ──
+// PAIRED (pool) → ACTIVE (recognized, no seat) → ASSIGNED (in a Captain/Stoker
+// seat: phase joined→ready). B steps out one level; A steps in.
+function recognize(slot) {                                   // PAIRED → ACTIVE
+  if (state.bySlot.has(slot.id)) return;
+  state.bySlot.set(slot.id, { seatId: null, phase: 'active', player: state.nextP++ });
+  activeFb(slot.id); rumble(slot.id, 'single'); render();
+}
+function takeSeat(slotId) {                                   // ACTIVE → ASSIGNED
+  const L = state.bySlot.get(slotId); if (!L || L.phase !== 'active') return;
+  const s = nextOpen(); if (!s) return;                      // seats full → stay ACTIVE
+  state.occ.set(s.id, slotId); L.seatId = s.id; L.phase = 'joined';
+  feedback(slotId, false); rumble(slotId, 'single'); render();
+}
+function leaveSeat(slotId) {                                  // ASSIGNED → ACTIVE
+  const L = state.bySlot.get(slotId); if (!L || L.seatId == null) return;
+  state.occ.delete(L.seatId); L.seatId = null; L.phase = 'active';
+  activeFb(slotId); render();
+}
+// (No voluntary ACTIVE→AVAILABLE via B — "once active, always active". The only
+// way back to AVAILABLE is the manager's PS/Home hold-release or a disconnect,
+// both of which empty the manager slot → freeSeat below.)
+function freeSeat(slotId) {                                   // manager slot vanished (PS/Home hold or disconnect)
+  const L = state.bySlot.get(slotId); if (!L) return;
+  if (L.seatId != null) state.occ.delete(L.seatId);
+  state.bySlot.delete(slotId); clearFb(slotId); render();
+}
+function readyUp(slotId) { const L = state.bySlot.get(slotId); if (!L || L.phase !== 'joined') return; L.phase = 'ready'; feedback(slotId, true); rumble(slotId, 'double'); render(); }
+function unready(slotId) { const L = state.bySlot.get(slotId); if (!L || L.phase !== 'ready') return; L.phase = 'joined'; feedback(slotId, false); render(); }
+function switchTeam(slotId, dir) {
+  const L = state.bySlot.get(slotId); if (!L || L.seatId == null) return; const s = seat(L.seatId); if (!s || !s.team) return;
+  const other = s.team === 'a' ? 'b' : 'a';
+  const target = state.seats.find((x) => x.team === other && x.role === s.role && !state.occ.has(x.id))
+              || state.seats.find((x) => x.team === other && !state.occ.has(x.id));
+  if (!target) return;
+  state.occ.delete(s.id); state.occ.set(target.id, slotId); L.seatId = target.id;
+  feedback(slotId, L.phase === 'ready'); render();
+}
+// ▲▼ in versus: swap Captain ⇄ Stoker within your own team. If the other seat
+// is taken, the two players trade seats; if it's open, you just slide over.
+function switchRole(slotId) {
+  const L = state.bySlot.get(slotId); if (!L || L.seatId == null) return; const s = seat(L.seatId); if (!s || !s.team) return;
+  const otherRole = s.role === 'Captain' ? 'Stoker' : 'Captain';
+  const target = state.seats.find((x) => x.team === s.team && x.role === otherRole);
+  if (!target) return;
+  if (state.occ.has(target.id)) {
+    const otherSlot = state.occ.get(target.id); const OL = state.bySlot.get(otherSlot);
+    state.occ.set(target.id, slotId); state.occ.set(s.id, otherSlot);
+    L.seatId = target.id; if (OL) OL.seatId = s.id;
+    feedback(slotId, L.phase === 'ready'); if (OL) feedback(otherSlot, OL.phase === 'ready');
+  } else {
+    state.occ.delete(s.id); state.occ.set(target.id, slotId); L.seatId = target.id;
+    feedback(slotId, L.phase === 'ready');
+  }
+  render();
+}
+
+function minMet() {
+  if (state.mode === 'solo') return state.occ.has('cap');
+  if (state.mode === 'together') return state.occ.has('cap') && state.occ.has('sto');
+  return teamCount('a') >= 1 && teamCount('b') >= 1;
+}
+// Only SEATED controllers gate the launch — an ACTIVE (recognized, seatless)
+// controller is a bystander and neither counts nor blocks.
+function allReady() {
+  const seated = [...state.bySlot.keys()].filter((id) => state.bySlot.get(id).seatId != null);
+  return seated.length > 0 && minMet() && seated.every((id) => state.bySlot.get(id).phase === 'ready');
+}
+
+// ── per-slot edge detection ──
+const edge = new Map();
+function btns(gp) {
+  const p = (i) => !!(gp && gp.buttons && gp.buttons[i] && gp.buttons[i].pressed);
+  const ax = (gp && gp.axes) || [];
+  return { a: p(0), b: p(1), start: p(9),
+    up: p(12) || (ax[1] || 0) < -0.5, down: p(13) || (ax[1] || 0) > 0.5,
+    left: p(14) || (ax[0] || 0) < -0.5, right: p(15) || (ax[0] || 0) > 0.5 };
+}
+function edges(slotId, gp) {
+  const prev = edge.get(slotId) || {}; const cur = btns(gp); const f = {};
+  for (const k in cur) f[k] = cur[k] && !prev[k];
+  edge.set(slotId, cur); return f;
+}
+
+// ── device naming ──
+// Prefer the bound HID driver's real identity: a GameSir Super Nova claims via
+// the Gamepad API as DualSense (054c:0ce6) but its bound HID handle knows it's
+// a DualShock 4 — so once bound we name it by the driver, not the pad label.
+function devName(slotId) {
+  const s = manager.getSlot(slotId);
+  if (s && s.driver && s.driver.entry && s.driver.entry.name) return s.driver.entry.name;
+  const byLabel = ControllerRegistry.identifyFromGamepadId((s && s.controllerLabel) || '');
+  if (byLabel && byLabel.driverName) return byLabel.driverName;
+  const raw = (s && s.hidDevice && s.hidDevice.productName) || '';
+  const byName = ControllerRegistry.identifyFromGamepadId(raw);
+  return (byName && byName.driverName) ? byName.driverName : (raw || 'Controller');
+}
+
+// ── screens ──
+function showScreen(name) {
+  state.screen = name;
+  edge.clear();   // re-prime every slot on the new screen (a button still held from the last screen won't fire)
+  $('step-mode').hidden = name !== 'mode';
+  $('step-lobby').hidden = name !== 'lobby';
+  $('step-level').hidden = name !== 'level';
+}
+
+let modeIdx = 0;
+function setModeIdx(i) {
+  modeIdx = (i + MODES.length) % MODES.length;
+  document.querySelectorAll('#step-mode [data-mode]').forEach((b, k) => b.classList.toggle('sel', k === modeIdx));
+}
+function enterMode(mode) {
+  state.mode = mode; const m = makeSeats(mode); state.seats = m.seats; state.fill = m.fill;
+  state.occ.clear(); state.bySlot.clear(); state.nextP = 1;
+  $('lobby-title').textContent = mode === 'versus' ? 'Build your teams' : mode === 'solo' ? 'Solo ride' : 'Crew your tandem';
+  $('join-hint').innerHTML = mode === 'versus'
+    ? 'Press a button = active · <strong>A</strong> take seat → ready · <strong>◀ ▶</strong> team · <strong>▲ ▼</strong> swap · <strong>B</strong> back (ready→seat→active) · hold <strong>PS</strong> to release · all ready? <strong>A</strong> → level'
+    : 'Press a button = active · <strong>A</strong> take a seat → ready · <strong>B</strong> back (ready→seat→active) · hold <strong>PS/Home</strong> to release · all ready? <strong>A</strong> → level';
+  showScreen('lobby'); syncSeats(); render();
+}
+function goLevel() {
+  if (!allReady()) return;
+  const parts = [];
+  if (state.mode === 'versus') parts.push(`<span class="big">${teamCount('a')} v ${teamCount('b')}</span>Team Blue vs Team Red`);
+  else if (state.mode === 'solo') parts.push(`<span class="big">Solo</span>`);
+  else parts.push(`<span class="big">Co-op</span>Captain + Stoker`);
+  const roster = state.seats.filter((s) => state.occ.has(s.id)).map((s) => {
+    const slotId = state.occ.get(s.id); const L = state.bySlot.get(slotId);
+    return `${s.role}: P${L ? L.player : '?'} <span style="opacity:.6">(${devName(slotId)})</span>`;
+  }).join('<br>');
+  $('level-summary').innerHTML = parts.join('') + '<br><br>' + roster;
+  for (const id of state.bySlot.keys()) clearFb(id);
+  showScreen('level');
+}
+
+// ── render ──
+function cardHTML(s) {
+  const kind = s.team ? (s.team === 'a' ? 'ta' : 'tb') : s.kind;
+  if (s.locked) return `<div class="seat locked"><span class="role">${s.role}</span><span class="who">LOCKED</span><span class="dev">solo</span></div>`;
+  const slotId = state.occ.get(s.id);
+  if (slotId) {
+    const L = state.bySlot.get(slotId); const rdy = L && L.phase === 'ready';
+    return `<div class="seat ${kind} ${rdy ? 'ready' : 'joined'}"><span class="badge">P${L ? L.player : '?'}</span>${rdy ? '<span class="check">✓ READY</span>' : ''}<span class="role">${s.role}</span><span class="who">${devName(slotId)}</span><span class="dev">${rdy ? 'ready' : 'press A to ready'}</span></div>`;
+  }
+  return `<div class="seat open" data-seat="${s.id}"><span class="role">${s.role}</span><span class="who">OPEN</span><span class="dev">press a button</span></div>`;
+}
+// Recognized-but-seatless controllers waiting to pick a seat.
+function loungeHTML() {
+  const active = [...state.bySlot.keys()].filter((id) => state.bySlot.get(id).seatId == null);
+  if (!active.length) return '';
+  const chips = active.map((id) => {
+    const L = state.bySlot.get(id);
+    return `<div class="lounge-chip"><span class="lc-badge">P${L.player}</span><span class="lc-name">${devName(id)}</span><span class="lc-hint">press A to take a seat</span></div>`;
+  }).join('');
+  return `<div class="lounge"><div class="lounge-title">RECOGNIZED · pick a seat</div><div class="lounge-chips">${chips}</div></div>`;
+}
+function render() {
+  const area = $('seat-area');
+  let html;
+  if (state.mode === 'versus') {
+    const col = (t, title) => `<div class="team ${t}"><div class="team-title">${title}</div><div class="team-slots">${state.seats.filter((s) => s.team === t).map(cardHTML).join('')}</div></div>`;
+    html = `<div class="teams">${col('a', 'TEAM BLUE')}<div class="vs">VS</div>${col('b', 'TEAM RED')}</div>`;
+  } else {
+    html = `<div class="tandem"><div class="tandem-title">🚲 YOUR TANDEM</div><div class="tandem-seats">${state.seats.map(cardHTML).join('')}</div></div>`;
+  }
+  area.innerHTML = html + loungeHTML();
+  updateCTA(); updateDebug();
+}
+function updateCTA() {
+  const btn = $('btn-choose-level'); const r = allReady();
+  btn.disabled = !r; btn.classList.toggle('ready', r);
+  const mu = state.mode === 'versus' && (teamCount('a') || teamCount('b')) ? ` (${teamCount('a')} v ${teamCount('b')})` : '';
+  btn.textContent = (r ? '▶ CHOOSE LEVEL' : 'CHOOSE LEVEL') + mu;
+}
+function updateDebug() {
+  const el = $('debug'); if (!el) return;
+  const parts = manager.slots.filter((s) => s.state === 'claimed').map((s) => {
+    const L = state.bySlot.get(s.id); const d = s.driver;
+    return `${s.id}:${devName(s.id).split(' ')[0]}${L ? '·' + L.phase : ''}[${d ? (d.connectionType || 'hid') : 'no-hid'}]`;
+  });
+  const perf = `[${_frameMs.toFixed(1)}ms/f · ${_workMs.toFixed(1)}ms work · pool ${manager._hidPool.size}] `;
+  el.textContent = perf + (parts.join('   ') || 'no controllers — press a button to join') + (allReady() ? '   ✓ ALL READY' : '');
+}
+let pairMsg = '', pairMsgUntil = 0;
+function flashPairMsg(m) { pairMsg = m; pairMsgUntil = performance.now() + 2600; }
+function updateControllerCount() {
+  const el = $('ctrl-count'); if (!el) return;
+  if (pairMsg && performance.now() < pairMsgUntil) { el.textContent = pairMsg; return; }
+  const claimed = manager.slots.filter((s) => s.state === 'claimed').length;
+  const pooled = manager._hidPool.size;
+  el.textContent = (claimed === 0 && pooled === 0)
+    ? 'no controllers — press a button or Pair →'
+    : `${claimed} in use${pooled ? ` · ${pooled} available` : ''}`;
+}
+// Approve/pool the next controller (main.js auto-selects a not-yet-picked one).
+// requestDevice needs the click as its user gesture; the Steam Controller is
+// HID-only, so it can only be recognized after this. Gives visible feedback:
+// after boot auto-pools everything, there's often nothing new to pair, and the
+// old silent no-op read as "the button is broken".
+async function pairController() {
+  const free = SLOT_IDS.find((id) => manager.getSlot(id).state !== 'claimed') || SLOT_IDS[0];
+  const before = manager._hidPool.size;
+  flashPairMsg('pairing…'); openCtrlPanel(true);
+  try {
+    const dev = await manager.connectHidForSlot(free);
+    const after = manager._hidPool.size;
+    if (dev) flashPairMsg('paired ✓ ' + (dev.productName || 'controller'));
+    else if (after > before) flashPairMsg('paired ✓');
+    else flashPairMsg(after ? `nothing new — ${after} already paired` : 'no controller found to pair');
+  } catch (err) {
+    flashPairMsg('pair failed: ' + (err && err.message ? err.message : String(err)));
+  }
+}
+
+// ── controllers panel (paired vs active vs open, + live "in use" dot) ──
+const esc = (s) => String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
+function padActive(gp) {
+  if (!gp) return false;
+  for (const b of (gp.buttons || [])) if (b && (b.pressed || (b.value || 0) > 0.5)) return true;
+  for (const a of (gp.axes || [])) if (Math.abs(a) > 0.5) return true;
+  return false;
+}
+function stickMag(gp) { const ax = (gp && gp.axes) || []; return Math.max(Math.abs(ax[0] || 0), Math.abs(ax[1] || 0), Math.abs(ax[2] || 0), Math.abs(ax[3] || 0)); }
+// vid:pid string — the definitive identity, so a row that reads "DualSense" over
+// the Gamepad API vs its true WebHID handle is unambiguous.
+function vpStr(vp) { return vp ? ((vp.vendorId || 0).toString(16).padStart(4, '0') + ':' + (vp.productId || 0).toString(16).padStart(4, '0')) : '—'; }
+
+// ── per-unit identity (Electron main process; empty on the web build) ──
+// The renderer's WebHID handle carries no serial (Chromium blocklists it), but
+// the Electron main process sees it on the HID device events — over Bluetooth
+// that serial is the controller's MAC (a stable per-unit id whose OUI even outs
+// a spoofed clone). main.js pushes that inventory here via `hid-controllers-
+// snapshot`. We match it to panel rows by vid:pid.
+let hidInventory = [];
+function setInventory(list) { hidInventory = Array.isArray(list) ? list : []; }
+function unitsForVp(vp) {
+  if (!vp) return [];
+  return hidInventory.filter((u) => u.vendorId === vp.vendorId && u.productId === vp.productId);
+}
+function vpOfSlot(s) {
+  if (s.hidDevice) return { vendorId: s.hidDevice.vendorId, productId: s.hidDevice.productId };
+  return ControllerRegistry.parseGamepadVendorProduct(s.controllerLabel) || null;
+}
+// One line of per-unit identity for a panel row. Unique vid:pid → the serial.
+// Electron's main HIDDevice has no `collections`, so a descriptor fingerprint is
+// impossible; instead we disambiguate two identical-vid:pid units by connection
+// type (a Bluetooth unit carries a MAC serial, a USB DS4 carries none).
+function identityLine(vp, connType) {
+  const units = unitsForVp(vp);
+  if (!units.length) return '';
+  if (units.length === 1) return units[0].serialNumber ? '# ' + units[0].serialNumber : '# no serial (USB)';
+  const withSerial = units.filter((u) => u.serialNumber);
+  if (connType === 'bluetooth' && withSerial.length === 1) return '# ' + withSerial[0].serialNumber;
+  if (connType === 'usb' && units.some((u) => !u.serialNumber)) return '# no serial (USB)';
+  return '⚠ ' + units.length + ' units — ' + units.map((u) => u.serialNumber || 'no-serial').join(' · ');
+}
+// Enumerate every controller the manager can see, in three buckets:
+//   ACTIVE — a claimed slot (someone took a seat); may be HID-bound or Gamepad-API-only
+//   PAIRED — a HID entry idling in the pool (WebHID approved, gyro/lightbar ready, no seat yet)
+//   OPEN   — a live Gamepad-API pad that's neither claimed nor pooled (press to join)
+function ctrlEntries(pads) {
+  const items = [];
+  const claimedIdx = new Set();
+  for (const s of manager.slots) {
+    if (s.state !== 'claimed') continue;
+    if (s.gamepadIndex != null) claimedIdx.add(s.gamepadIndex);
+    const L = state.bySlot.get(s.id);
+    const seated = !!(L && L.seatId != null);
+    const role = seated && seat(L.seatId) ? seat(L.seatId).role : '';
+    const hid = !!s._hidEntry;
+    items.push({
+      key: 's:' + s.id, name: esc(devName(s.id)),
+      // controller layer: a claimed slot is ACTIVE. game layer: ASSIGNED/READY only when seated.
+      cstate: 'ACTIVE', gstate: seated ? (L.phase === 'ready' ? 'READY' : 'ASSIGNED') : null,
+      sub: seated ? `P${L.player} · ${role}` : (L ? `P${L.player} · recognized` : 'recognized'),
+      hw: esc((s.hidDevice && s.hidDevice.productName) || ''),   // real HID string — the ONLY way to tell apart two same-vid:pid pads
+      vp: vpOfSlot(s), device: s.hidDevice || null,
+      conn: hid ? (s.driver && s.driver.connectionType ? s.driver.connectionType : 'hid') : 'gamepad',
+      active: padActive(s.effectiveGamepad(pads)),
+    });
+  }
+  let hi = 0;
+  for (const entry of manager._hidPool.values()) {
+    const nm = (entry.driver && entry.driver.entry && entry.driver.entry.name) || (entry.device && entry.device.productName) || 'Controller';
+    items.push({
+      // index in the key: two identical-vid:pid devices (real DS4 + GameSir spoof)
+      // would otherwise collide to one row and share one activity dot.
+      key: 'h:' + (hi++) + ':' + ((entry.device && entry.device.vendorId) || 0) + ':' + ((entry.device && entry.device.productId) || 0),
+      name: esc(nm), cstate: 'AVAILABLE', gstate: null, sub: 'WebHID · idle',
+      hw: esc((entry.device && entry.device.productName) || ''),
+      vp: entry.device ? { vendorId: entry.device.vendorId, productId: entry.device.productId } : null,
+      device: entry.device || null,
+      conn: (entry.driver && entry.driver.connectionType) || 'hid',
+      active: padActive(entry.synthetic),
+    });
+  }
+  for (const gp of pads) {
+    if (!gp) continue;
+    if (claimedIdx.has(gp.index)) continue;
+    if (stickMag(gp) > 0.5) continue;   // stuck-stick pad = likely a Chrome BT-reconnect ghost; skip
+    const vp = ControllerRegistry.parseGamepadVendorProduct(gp.id);
+    if (vp && manager._findPoolEntryByVidPid(vp.vendorId, vp.productId)) continue;   // already shown as PAIRED
+    const info = ControllerRegistry.identifyFromGamepadId(gp.id);
+    items.push({
+      key: 'g:' + gp.index, name: esc((info && info.driverName) || 'Controller'), cstate: 'AVAILABLE', gstate: null,
+      sub: 'Gamepad · press a button', hw: '', vp: vp || null, conn: 'gamepad', active: padActive(gp),
+    });
+  }
+  for (const it of items) it.id = esc(identityLine(it.vp, it.conn));
+  return items;
+}
+function buildCtrlRows(items) {
+  const list = $('cp-list'); if (!list) return;
+  if (!items.length) { list.innerHTML = '<div class="cp-empty">No controllers detected.<br>Press a button, or “🎮 Pair controller”.</div>'; return; }
+  list.innerHTML = items.map((it) =>
+    `<div class="cp-row"><span class="cp-dot" data-dot="${it.key}"></span>` +
+    `<div class="cp-main"><div class="cp-name">${it.name}</div><div class="cp-sub">${it.sub} · ${it.conn} · ${vpStr(it.vp)}</div>` +
+    `${it.hw ? `<div class="cp-hw">▪ ${it.hw}</div>` : ''}` +
+    `${it.id ? `<div class="cp-id${it.id[0] === '⚠' ? ' warn' : ''}">${it.id}</div>` : ''}</div>` +
+    `<div class="cp-tags"><span class="cp-tag ${it.cstate.toLowerCase()}">${it.cstate}</span>` +
+    `${it.gstate ? `<span class="cp-tag ${it.gstate.toLowerCase()}">${it.gstate}</span>` : ''}</div></div>`
+  ).join('');
+}
+let ctrlSig = '';
+function renderCtrlPanel(pads) {
+  const panel = $('ctrl-panel'); if (!panel || panel.hidden) return;
+  const items = ctrlEntries(pads);
+  const sig = items.map((i) => i.key + '|' + i.cstate + '|' + (i.gstate || '') + '|' + i.sub + '|' + i.conn + '|' + i.name + '|' + i.hw + '|' + i.id + '|' + vpStr(i.vp)).join('~');
+  if (sig !== ctrlSig) { ctrlSig = sig; buildCtrlRows(items); }
+  const list = $('cp-list');
+  for (const it of items) { const d = list.querySelector(`[data-dot="${it.key}"]`); if (d) d.classList.toggle('on', it.active); }
+  const act = items.filter((i) => i.cstate === 'ACTIVE').length, av = items.filter((i) => i.cstate === 'AVAILABLE').length;
+  const asg = items.filter((i) => i.gstate === 'ASSIGNED').length, rdy = items.filter((i) => i.gstate === 'READY').length;
+  const note = $('cp-note'); if (note) note.textContent = `${act} active · ${av} available · ${asg} assigned · ${rdy} ready`;
+}
+function openCtrlPanel(open) {
+  const panel = $('ctrl-panel'); if (!panel) return;
+  panel.hidden = !open;
+  const btn = $('btn-ctrl-list');
+  if (btn) { btn.setAttribute('aria-expanded', String(open)); btn.textContent = 'Controllers ' + (open ? '▴' : '▾'); }
+  if (open) { ctrlSig = ''; renderCtrlPanel((navigator.getGamepads && navigator.getGamepads()) || []); }
+}
+function toggleCtrlPanel() {
+  const panel = $('ctrl-panel'); if (!panel) return;
+  const opening = panel.hidden;
+  // Gesture-backed serial scan (requestDevice needs user activation): opening the
+  // panel refreshes every present device's serial into the inventory.
+  if (opening && navigator.hid && navigator.userAgent.includes('Electron')) {
+    navigator.hid.requestDevice({ filters: ControllerRegistry.getHIDFilters() }).catch(() => {});
+  }
+  openCtrlPanel(opening);
+}
+
+// ── slot lifecycle sync (claim→seat, release→free) ──
+function syncSeats() {
+  // A newly-claimed manager slot is RECOGNIZED (ACTIVE), not auto-seated.
+  for (const s of manager.slots) if (s.state === 'claimed' && !state.bySlot.has(s.id)) recognize(s);
+  for (const id of [...state.bySlot.keys()]) { const s = manager.getSlot(id); if (!s || s.state !== 'claimed') freeSeat(id); }
+}
+
+// ── per-screen input drivers ──
+// Prime-and-skip: a slot with no edge history (just claimed, or first frame on
+// a screen) records its current button state and takes no action this frame,
+// so the button that CLAIMED the slot can't also trigger select/ready.
+function primeOrEdges(slot, gp) {
+  if (!edge.has(slot.id)) { edge.set(slot.id, btns(gp)); return null; }
+  return edges(slot.id, gp);
+}
+function driveMode(pads) {
+  for (const s of manager.slots) {
+    if (s.state !== 'claimed') { edge.delete(s.id); continue; }
+    const e = primeOrEdges(s, s.effectiveGamepad(pads)); if (!e) continue;
+    if (e.a) { enterMode(MODES[modeIdx]); return; }
+    if (e.up) setModeIdx(modeIdx - 1); else if (e.down) setModeIdx(modeIdx + 1);
+  }
+}
+function driveLobby(pads) {
+  syncSeats();
+  let start = false;
+  for (const s of manager.slots) {
+    if (s.state !== 'claimed') { edge.delete(s.id); continue; }
+    const L = state.bySlot.get(s.id); if (!L) continue;
+    const e = primeOrEdges(s, s.effectiveGamepad(pads)); if (!e) continue;
+    if (e.start) start = true;
+    if (L.phase === 'active') {                 // recognized & sticky ("once active, always active")
+      if (e.a) takeSeat(s.id);                  // A takes a seat; only a PS/Home hold releases (→ AVAILABLE)
+    } else if (L.phase === 'joined') {          // in a seat
+      if (e.a) readyUp(s.id);
+      else if (e.b) leaveSeat(s.id);            // step out to ACTIVE (recognized)
+      else if (e.left) switchTeam(s.id, -1);
+      else if (e.right) switchTeam(s.id, 1);
+      else if (e.up || e.down) switchRole(s.id);
+    } else if (L.phase === 'ready') {
+      if (e.a && allReady()) { goLevel(); return; }   // last confirm — A again launches
+      else if (e.b) unready(s.id);
+    }
+  }
+  if (start && allReady()) goLevel();
+}
+
+// ── boot + loop ──
+// Perf meters surfaced in the debug bar: _frameMs = wall time between frames
+// (≈16.7 at a healthy 60fps); _workMs = synchronous work per frame. If input
+// feels laggy but _workMs stays small, the cost is in HID/driver/main, not here.
+let _lastTs = 0, _frameMs = 0, _workMs = 0, _lastPanel = 0;
+function loop() {
+  const now = performance.now();
+  const pads = (navigator.getGamepads && navigator.getGamepads()) || [];
+  if (_lastTs) { const dt = now - _lastTs; if (dt > 0 && dt < 500) _frameMs = _frameMs ? _frameMs * 0.9 + dt * 0.1 : dt; }
+  _lastTs = now;
+  try {
+    manager.ingestFrame(pads, now);
+    if (state.screen === 'mode') driveMode(pads);
+    else if (state.screen === 'lobby') driveLobby(pads);
+    updateDebug();
+    updateControllerCount();
+    if (now - _lastPanel > 80) { _lastPanel = now; renderCtrlPanel(pads); }   // ~12Hz, not every frame
+  } catch (e) {
+    console.error('[lobby] frame error (recovered):', e);
+    const el = $('debug'); if (el) el.textContent = 'ERROR: ' + (e && e.message ? e.message : String(e));
+  }
+  const wm = performance.now() - now; _workMs = _workMs ? _workMs * 0.9 + wm * 0.1 : wm;
+  requestAnimationFrame(loop);
+}
+
+async function boot() {
+  // Mode buttons: click + controller.
+  document.querySelectorAll('#step-mode [data-mode]').forEach((b, k) => {
+    b.addEventListener('click', () => { setModeIdx(k); enterMode(b.dataset.mode); });
+    b.addEventListener('mouseenter', () => setModeIdx(k));
+  });
+  $('btn-back-mode').addEventListener('click', () => { for (const id of state.bySlot.keys()) clearFb(id); showScreen('mode'); });
+  $('btn-choose-level').addEventListener('click', goLevel);
+  $('btn-restart').addEventListener('click', () => enterMode(state.mode));
+  $('btn-pair').addEventListener('click', pairController);
+  $('btn-pair-global').addEventListener('click', pairController);
+  $('btn-ctrl-list').addEventListener('click', toggleCtrlPanel);
+
+  // Per-unit serial/MAC inventory from the Electron main process (no-op on web).
+  if (window.electronAPI) {
+    try {
+      if (electronAPI.listHidControllers) electronAPI.listHidControllers().then(setInventory).catch(() => {});
+      if (electronAPI.onHidControllersSnapshot) electronAPI.onHidControllersSnapshot(setInventory);
+      // Serial scan happens on a gesture (opening the Controllers panel / Pair) —
+      // requestDevice needs user activation, so a boot timer can't populate it.
+    } catch (e) { /* web build / API absent */ }
+  }
+
+  setModeIdx(0);
+
+  if (navigator.hid) {
+    // Pool already-approved controllers (gesture-free). New ones pair via the
+    // per-slot "Pair" button (connectHidForSlot needs a user gesture); hot-plug
+    // of approved devices is handled by wireHidHotplug.
+    await manager.autoPoolApprovedHid();
+    manager.wireHidHotplug();
+  }
+  loop();
+}
+
+boot();
diff --git a/apps/overlay/src/js/multi-app.js b/apps/overlay/src/js/multi-app.js
index d4cc8be..2901cec 100644
--- a/apps/overlay/src/js/multi-app.js
+++ b/apps/overlay/src/js/multi-app.js
@@ -339,10 +339,10 @@ async function boot() {
   });
 
   if (navigator.hid) {
+    // Already-approved controllers pool gesture-free; new ones pair via the
+    // per-slot Connect button (requestDevice needs a user gesture); hot-plug
+    // of approved devices is handled by wireHidHotplug.
     await manager.autoPoolApprovedHid();
-    if (navigator.userAgent.includes('Electron')) {
-      await manager.electronAutoRequestDevice();
-    }
     manager.wireHidHotplug();
   }
 
diff --git a/apps/overlay/src/lobby.html b/apps/overlay/src/lobby.html
new file mode 100644
index 0000000..17fb034
--- /dev/null
+++ b/apps/overlay/src/lobby.html
@@ -0,0 +1,224 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Tandemonium · Seat-Select Navigator</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  html, body {
+    width: 100%; height: 100%; overflow: hidden;
+    background: radial-gradient(120% 90% at 50% -10%, #16241a 0%, #0b0d12 55%, #07080c 100%);
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    color: #e7ecf5; user-select: none;
+  }
+  :root {
+    --p1: #7ae09a;   /* captain / team-blue-side green-cyan handled per-mode */
+    --team-a: #6ea8ff; --team-b: #ff6b7d;
+    --cap: #7ae09a; --sto: #ff9e6b;
+    --accent: #6ce08f;
+    --versus: #c79dff;
+    --mono: ui-monospace, 'Cascadia Mono', Menlo, monospace;
+  }
+  #drag-bar { position: fixed; top: 0; left: 0; right: 0; height: 34px; -webkit-app-region: drag; z-index: 100; }
+  #app-title { position: fixed; top: 9px; left: 16px; font-size: 11px; letter-spacing: 1.4px; color: #6a7184; text-transform: uppercase; z-index: 101; pointer-events: none; }
+  #app-title b { color: var(--accent); }
+
+  .stage { position: absolute; inset: 34px 0 0 0; display: grid; place-items: center; padding: 12px 24px 28px; }
+  .card { width: min(720px, 94vw); }
+  .step { display: flex; flex-direction: column; align-items: center; gap: 12px; animation: rise .32s cubic-bezier(.2,.8,.2,1) both; }
+  .step[hidden] { display: none; }
+  @keyframes rise { from { opacity: 0; transform: translateY(12px); } to { opacity: 1; transform: none; } }
+
+  .prompt { font-size: 20px; font-weight: 700; text-align: center; margin: 2px 0 6px; }
+  .hint { font-size: 12px; color: #8a93a6; text-align: center; }
+  .hint b, .hint strong { color: #cdd6e6; }
+
+  /* mode buttons */
+  .mode-btn {
+    width: 100%; padding: 16px 18px; border-radius: 14px; cursor: pointer;
+    border: 2px solid rgba(255,255,255,0.14); background: rgba(255,255,255,0.05);
+    color: #e7ecf5; font: 700 17px/1.3 inherit; text-align: center; transition: .15s;
+  }
+  .mode-btn .sub { display: block; font-size: 12px; font-weight: 400; color: #8a93a6; margin-top: 5px; }
+  .mode-btn.sel { transform: translateY(-2px); }
+  .mode-btn[data-mode="together"].sel { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent), 0 12px 34px -14px var(--accent); }
+  .mode-btn[data-mode="together"] .big { color: var(--accent); }
+  .mode-btn[data-mode="versus"].sel { border-color: var(--versus); box-shadow: 0 0 0 1px var(--versus), 0 12px 34px -14px var(--versus); }
+  .mode-btn[data-mode="versus"] .big { color: var(--versus); }
+  .mode-btn[data-mode="solo"].sel { border-color: #9fb0c6; box-shadow: 0 10px 28px -16px #000; }
+  .big { font-weight: 800; }
+
+  /* seat grid */
+  .teams { display: flex; align-items: stretch; justify-content: center; gap: 14px; width: 100%; margin: 4px 0; }
+  .team { flex: 1 1 0; min-width: 0; display: flex; flex-direction: column; align-items: center; gap: 8px; padding: 10px; border-radius: 12px; border: 2px solid transparent; }
+  .team.a { border-color: rgba(110,168,255,.4); background: rgba(110,168,255,.07); }
+  .team.b { border-color: rgba(255,107,125,.4); background: rgba(255,107,125,.07); }
+  .team-title { font: 700 12px/1 var(--mono); letter-spacing: 2px; }
+  .team.a .team-title { color: var(--team-a); } .team.b .team-title { color: var(--team-b); }
+  .vs { align-self: center; font: 800 18px/1 inherit; opacity: .5; letter-spacing: 1px; }
+  .team-slots { display: flex; flex-direction: column; gap: 8px; width: 100%; }
+  .tandem { width: 100%; display: flex; flex-direction: column; align-items: center; gap: 8px; }
+  .tandem-title { font: 700 12px/1 var(--mono); letter-spacing: 2px; color: #bfe7cd; }
+  .tandem-seats { display: flex; gap: 10px; width: 100%; }
+  .tandem-seats .seat { flex: 1 1 0; }
+
+  .seat {
+    position: relative; min-height: 62px; border-radius: 12px; padding: 10px;
+    display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 2px; text-align: center;
+    background: rgba(255,255,255,0.05); border: 1.5px solid rgba(255,255,255,0.16); transition: .18s;
+  }
+  .seat .role { font: 10px/1.3 var(--mono); letter-spacing: 1.4px; color: #8894a8; opacity: .7; text-transform: uppercase; }
+  .seat .who { font: 700 13px/1.25 inherit; letter-spacing: .4px; }
+  .seat .dev { font: 10px/1.2 var(--mono); color: #8894a8; }
+  .seat .badge { position: absolute; top: 6px; right: 8px; font: 800 9px/1 var(--mono); padding: 2px 5px; border-radius: 5px; background: rgba(0,0,0,.4); }
+  .seat.open { opacity: .5; border-style: dashed; background: transparent; cursor: pointer; }
+  .seat.locked { opacity: .3; border-style: dashed; background: repeating-linear-gradient(45deg, rgba(255,255,255,.03) 0 6px, transparent 6px 12px); }
+  .seat.joined { animation: pop .34s cubic-bezier(.2,1.5,.4,1); }
+  .seat.ready { animation: bob 1.9s ease-in-out infinite; }
+  .seat.cap { border-color: var(--cap); } .seat.sto { border-color: var(--sto); }
+  .seat.ta { border-color: var(--team-a); } .seat.tb { border-color: var(--team-b); }
+  .seat.cap .who { color: var(--cap); } .seat.sto .who { color: var(--sto); }
+  .seat.ta .who { color: var(--team-a); } .seat.tb .who { color: var(--team-b); }
+  .seat.ready.cap { box-shadow: 0 0 18px -4px var(--cap); } .seat.ready.sto { box-shadow: 0 0 18px -4px var(--sto); }
+  .seat.ready.ta { box-shadow: 0 0 18px -4px var(--team-a); } .seat.ready.tb { box-shadow: 0 0 18px -4px var(--team-b); }
+  .seat .check { font: 800 10px/1 var(--mono); letter-spacing: 1px; color: var(--accent); margin-bottom: 1px; }
+  @keyframes pop { 0% { transform: scale(.86); } 60% { transform: scale(1.04); } 100% { transform: scale(1); } }
+  @keyframes bob { 0%,100% { transform: translateY(0); } 50% { transform: translateY(-3px); } }
+
+  /* recognized-but-seatless lounge */
+  .lounge { margin-top: 12px; width: 100%; display: flex; flex-direction: column; align-items: center; gap: 6px; }
+  .lounge-title { font: 700 10px/1 var(--mono); letter-spacing: 2px; color: #e0b453; }
+  .lounge-chips { display: flex; flex-wrap: wrap; gap: 8px; justify-content: center; }
+  .lounge-chip { position: relative; display: flex; flex-direction: column; align-items: center; gap: 1px; padding: 7px 14px; border-radius: 10px; background: rgba(224,180,83,0.08); border: 1.5px solid rgba(224,180,83,0.5); animation: idle 1.8s ease-in-out infinite; }
+  .lounge-chip .lc-badge { font: 800 9px/1 var(--mono); color: #e0b453; letter-spacing: .5px; }
+  .lounge-chip .lc-name { font: 700 12px/1.25 inherit; letter-spacing: .3px; }
+  .lounge-chip .lc-hint { font: 9px/1.2 var(--mono); color: #8a93a6; }
+
+  .idle-strip { display: flex; flex-wrap: wrap; gap: 8px; justify-content: center; margin-top: 8px; min-height: 4px; }
+  .idle-chip { display: flex; flex-direction: column; align-items: center; gap: 1px; font: 600 11px/1.2 var(--mono); padding: 7px 12px; border-radius: 9px; color: #cdd6e6; background: rgba(255,255,255,0.05); border: 1.5px solid rgba(255,255,255,0.2); animation: idle 1.8s ease-in-out infinite; }
+  .idle-chip .ih { font-size: 9px; opacity: .6; }
+  @keyframes idle { 0%,100% { border-color: rgba(255,255,255,.2); } 50% { border-color: rgba(255,210,63,.6); } }
+
+  .cta {
+    width: 100%; padding: 16px; border-radius: 14px; cursor: not-allowed; font: 800 18px/1 inherit; letter-spacing: .5px;
+    border: 1.5px solid rgba(255,255,255,0.14); background: rgba(255,255,255,0.05); color: #6c7688; transition: .2s; margin-top: 4px;
+  }
+  .cta.ready { cursor: pointer; color: #06140c; background: var(--accent); border-color: var(--accent); box-shadow: 0 0 26px -6px var(--accent); animation: ctap 1.5s ease-in-out infinite; }
+  @keyframes ctap { 0%,100% { box-shadow: 0 0 0 0 rgba(108,224,143,.5); } 50% { box-shadow: 0 0 0 6px rgba(108,224,143,0); } }
+  .subtle-btn { background: none; border: none; color: #8a93a6; cursor: pointer; font: 12px/1 var(--mono); padding: 8px; letter-spacing: .5px; }
+  .subtle-btn:hover { color: #cdd6e6; }
+  .pairbtn { font: 12px/1 var(--mono); color: #9fb0c6; background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.16); border-radius: 9px; padding: 9px 12px; cursor: pointer; }
+  .pairbtn:hover { color: #fff; border-color: rgba(255,255,255,0.3); }
+
+  .summary { text-align: center; font-size: 14px; line-height: 1.6; }
+  .summary .big { font-size: 22px; color: var(--accent); display: block; margin-bottom: 4px; }
+
+  #pairbar { position: fixed; top: 7px; right: 12px; z-index: 101; display: flex; align-items: center; gap: 10px; -webkit-app-region: no-drag; }
+  #ctrl-count { font: 11px/1 var(--mono); color: #8a93a6; letter-spacing: .3px; }
+  .pairbtn-sm { font: 11px/1 var(--mono); color: #cdd6e6; background: rgba(255,255,255,0.06); border: 1px solid rgba(255,255,255,0.18); border-radius: 8px; padding: 7px 11px; cursor: pointer; }
+  .pairbtn-sm:hover { color: #fff; border-color: rgba(255,255,255,0.35); background: rgba(255,255,255,0.12); }
+
+  /* controllers panel */
+  #ctrl-panel { position: fixed; top: 44px; right: 12px; z-index: 101; width: 300px; max-width: 82vw; background: rgba(9,13,11,0.97); border: 1px solid rgba(255,255,255,0.14); border-radius: 12px; padding: 11px 12px; box-shadow: 0 20px 44px -18px #000; -webkit-app-region: no-drag; }
+  #ctrl-panel[hidden] { display: none; }
+  .cp-head { font: 700 10px/1 var(--mono); letter-spacing: 1.5px; color: #9fb0c6; margin-bottom: 9px; display: flex; justify-content: space-between; align-items: baseline; gap: 8px; }
+  #cp-note { font-weight: 400; color: #7d879a; letter-spacing: .3px; }
+  #cp-list { display: flex; flex-direction: column; gap: 6px; }
+  .cp-row { display: flex; align-items: center; gap: 9px; padding: 7px 9px; border-radius: 9px; background: rgba(255,255,255,0.04); border: 1px solid rgba(255,255,255,0.08); }
+  .cp-dot { flex: 0 0 auto; width: 9px; height: 9px; border-radius: 50%; background: #39404e; transition: background .08s, box-shadow .08s; }
+  .cp-dot.on { background: var(--accent); box-shadow: 0 0 8px 1px var(--accent); }
+  .cp-main { flex: 1 1 auto; min-width: 0; }
+  .cp-name { font: 700 12px/1.2 inherit; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .cp-sub { font: 10px/1.3 var(--mono); color: #8894a8; }
+  .cp-hw { font: 9px/1.3 var(--mono); color: #6a7184; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .cp-id { font: 9px/1.3 var(--mono); color: #7d8aa0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .cp-id.warn { color: #e0b453; }
+  .cp-tags { flex: 0 0 auto; display: flex; flex-direction: column; gap: 3px; align-items: flex-end; }
+  .cp-tag { flex: 0 0 auto; font: 800 8px/1 var(--mono); letter-spacing: .8px; padding: 3px 6px; border-radius: 5px; }
+  .cp-tag.ready { color: #06140c; background: var(--accent); box-shadow: 0 0 10px -2px var(--accent); }
+  .cp-tag.assigned { color: #06140c; background: #7fd0a0; }
+  .cp-tag.active { color: #1a1205; background: #e0b453; }
+  .cp-tag.available { color: #c9d6ff; background: rgba(110,168,255,0.18); border: 1px solid rgba(110,168,255,0.4); }
+  .cp-legend { margin-top: 9px; padding-top: 8px; border-top: 1px solid rgba(255,255,255,0.08); font: 9px/1.6 var(--mono); color: #6a7184; }
+  .cp-legend b { color: #9fb0c6; }
+  .cp-legend .cp-dot { display: inline-block; vertical-align: middle; }
+  .cp-empty { font: 11px/1.5 var(--mono); color: #6a7184; text-align: center; padding: 10px 6px; }
+  #debug { position: fixed; left: 10px; bottom: 6px; right: 10px; font: 10px/1.4 var(--mono); color: #6a7184; white-space: pre; overflow: hidden; text-overflow: ellipsis; pointer-events: none; }
+  @media (prefers-reduced-motion: reduce) { .seat.joined,.seat.ready,.idle-chip,.cta.ready { animation: none; } }
+</style>
+</head>
+<body>
+<div id="drag-bar"></div>
+<div id="app-title">TANDEM<b>ONIUM</b> · SEAT-SELECT NAVIGATOR</div>
+<div id="pairbar">
+  <span id="ctrl-count">no controllers</span>
+  <button id="btn-ctrl-list" class="pairbtn-sm" title="Show every controller — active, paired, and open" aria-expanded="false">Controllers ▾</button>
+  <button id="btn-pair-global" class="pairbtn-sm" title="Approve a controller for this app (WebHID). Steam Controller needs this; DualSense too for lightbar/gyro.">🎮 Pair controller</button>
+</div>
+<div id="ctrl-panel" hidden>
+  <div class="cp-head">CONTROLLERS <span id="cp-note"></span></div>
+  <div id="cp-list"></div>
+  <div class="cp-legend"><b>controller</b> <span class="cp-tag available">AVAILABLE</span> connected · <span class="cp-tag active">ACTIVE</span> in use, gyro on<br><b>game</b> <span class="cp-tag assigned">ASSIGNED</span> in a seat · <span class="cp-tag ready">READY</span> locked in · <span class="cp-dot on"></span> being used now</div>
+</div>
+
+<div class="stage">
+  <div class="card">
+    <!-- STEP 1: mode -->
+    <div id="step-mode" class="step">
+      <p class="prompt">How do you want to ride?</p>
+      <button class="mode-btn sel" data-mode="together"><span class="big">RIDE TOGETHER</span><span class="sub">Co-op · one shared tandem</span></button>
+      <button class="mode-btn" data-mode="versus"><span class="big">VERSUS</span><span class="sub">Compete · two tandems · 1v1–2v2</span></button>
+      <button class="mode-btn" data-mode="solo"><span class="big">SOLO RIDE</span><span class="sub">Just you</span></button>
+      <p class="hint">Press a button on a controller to navigate · <strong>A</strong> to choose · or click</p>
+    </div>
+
+    <!-- STEP 2: unified seat lobby -->
+    <div id="step-lobby" class="step" hidden>
+      <p class="prompt" id="lobby-title">Crew your tandem</p>
+      <div id="seat-area" style="width:100%"></div>
+      <p class="hint" id="join-hint">Press a button to join a seat · <strong>A</strong> ready · <strong>B</strong> leave</p>
+      <button class="pairbtn" id="btn-pair">Pair a controller for gyro + lightbar (WebHID)…</button>
+      <button class="cta" id="btn-choose-level">CHOOSE LEVEL</button>
+      <button class="subtle-btn" id="btn-back-mode">← Back</button>
+    </div>
+
+    <!-- STEP 3: hand-off stub -->
+    <div id="step-level" class="step" hidden>
+      <p class="prompt">Ready to roll 🚲</p>
+      <div class="summary" id="level-summary"></div>
+      <p class="hint">In the game this hands off to level select.</p>
+      <button class="subtle-btn" id="btn-restart">← Back to lobby</button>
+    </div>
+  </div>
+</div>
+
+<div id="debug">boot…</div>
+
+<template id="seat-template">
+  <div class="seat"></div>
+</template>
+
+<script>
+// Dynamic importmap — local vendor in Electron, CDN on web (mirrors multi.html).
+(function () {
+  const isElectron = navigator.userAgent.includes('Electron');
+  const threeMap = isElectron
+    ? { "three": "./lib/three.module.js", "three/addons/": "./lib/addons/" }
+    : { "three": "https://cdn.jsdelivr.net/npm/three@0.161.0/build/three.module.js", "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.161.0/examples/jsm/" };
+  const map = {
+    ...threeMap,
+    "@usersfirst/controller-core": "./lib/controller-core/index.js",
+    "@usersfirst/controller-core/manager": "./lib/controller-core/manager.js",
+    "@usersfirst/controller-core/drivers/": "./lib/controller-core/drivers/",
+    "@usersfirst/controller-visualizer": "./lib/controller-visualizer/index.js",
+  };
+  const el = document.createElement('script');
+  el.type = 'importmap';
+  el.textContent = JSON.stringify({ imports: map });
+  document.currentScript.after(el);
+})();
+</script>
+<script type="module" src="js/lobby-app.js"></script>
+</body>
+</html>
diff --git a/package.json b/package.json
index 653ad6e..e4cc609 100644
--- a/package.json
+++ b/package.json
@@ -7,6 +7,7 @@
   ],
   "scripts": {
     "test": "npm run test --workspaces --if-present",
+    "start:lobby": "npm run start:lobby --workspace @usersfirst/overlay",
     "face-painter": "npx -y serve tools/face-painter",
     "split-glb": "node tools/split-glb.js",
     "hid-probe": "npx -y serve tools/hid-probe",
diff --git a/packages/core/src/drivers/base-driver.js b/packages/core/src/drivers/base-driver.js
index ee3e486..af1bda9 100644
--- a/packages/core/src/drivers/base-driver.js
+++ b/packages/core/src/drivers/base-driver.js
@@ -10,6 +10,14 @@
 // or check capabilities.
 
 export class ControllerDriver {
+  // Whether the overlay should fan `inputreport` out to OTHER approved handles
+  // sharing this device's vid:pid. Only true for controllers whose one physical
+  // unit legitimately exposes several same-vid:pid interfaces (Steam Controller
+  // Puck). Default false: for Sony pads a "sibling" same-vid:pid handle is a
+  // DIFFERENT physical device (a real DS4 next to a DS4-spoofing GameSir), and
+  // feeding its reports into this driver corrupts the stream — kills gyro.
+  static needsSiblingFanout = false;
+
   /**
    * @param {HIDDevice} device — the WebHID device
    * @param {string} connectionType — 'usb' | 'bluetooth'
diff --git a/packages/core/src/drivers/controller-registry.js b/packages/core/src/drivers/controller-registry.js
index 7a3f960..de70572 100644
--- a/packages/core/src/drivers/controller-registry.js
+++ b/packages/core/src/drivers/controller-registry.js
@@ -135,7 +135,22 @@ export class ControllerRegistry {
       if (!entry.gamepadIdMatch.test(idString)) continue;
       return toResult(entry);
     }
-    // Pass 2: defaults — entries with no secondary filter
+    // Pass 2: EXACT vid:pid among default entries. Sony DualSense and DualShock 4
+    // (v1 05c4 / v2 09cc) all share ONE PLAYSTATION_ID pattern, so a bare
+    // first-pattern-match returns DualSense for EVERY Sony pad — mislabeling a
+    // DS4 (05c4) as "DualSense". The vid:pid in the id string disambiguates them;
+    // variants that share a vid:pid are already resolved by Pass 1.
+    const vp = ControllerRegistry.parseGamepadVendorProduct(idString);
+    if (vp) {
+      for (const entry of DEVICES) {
+        if (entry.gamepadIdMatch) continue;
+        if (entry.vendorId !== vp.vendorId || entry.productId !== vp.productId) continue;
+        if (!entry.gamepadIdPattern.test(idString)) continue;
+        return toResult(entry);
+      }
+    }
+    // Pass 3: first default pattern match (fallback when the id carries no
+    // recognisable vid:pid, or the pid isn't in the dictionary).
     for (const entry of DEVICES) {
       if (entry.gamepadIdMatch) continue;
       if (!entry.gamepadIdPattern.test(idString)) continue;
diff --git a/packages/core/src/drivers/playstation-driver.js b/packages/core/src/drivers/playstation-driver.js
index d12653a..c5db860 100644
--- a/packages/core/src/drivers/playstation-driver.js
+++ b/packages/core/src/drivers/playstation-driver.js
@@ -97,7 +97,7 @@ export class PlayStationDriver extends ControllerDriver {
    *
    * @returns {Promise<boolean>} whether the full report stream was confirmed
    */
-  async _activateFullReportMode(featureId, { attempts = 5, perAttemptMs = 450 } = {}) {
+  async _activateFullReportMode(featureId, { attempts = 3, perAttemptMs = 300 } = {}) {
     const fullId = this._fullReportId();
     const hex = (n) => '0x' + n.toString(16).padStart(2, '0');
     // A device without receiveFeatureReport is a test/unsupported handle —
@@ -106,23 +106,32 @@ export class PlayStationDriver extends ControllerDriver {
     const maxAttempts = canRead ? attempts : 1;
 
     for (let i = 1; i <= maxAttempts; i++) {
+      let readOk = true;
       if (canRead) {
         try {
           await this.device.receiveFeatureReport(featureId);
         } catch (err) {
+          readOk = false;
           console.warn(`PlayStation BT: feature ${hex(featureId)} query failed (attempt ${i}/${maxAttempts}):`, err.message);
         }
       }
-      const streaming = await this._waitForReport(fullId, perAttemptMs);
-      if (streaming) {
-        console.log(`PlayStation BT: full report mode active (${hex(fullId)}) after ${i} attempt(s)`);
-        return true;
+      // Only wait for the stream when the activating read was ACCEPTED. A
+      // thrown read means the BT link is still negotiating (the hot-plug case)
+      // — no full report will arrive, so skip the wait and let init hand off to
+      // the non-blocking background loop instead of blocking ~perAttemptMs per
+      // doomed attempt (this was ~2s of dead init that serialized pool loads).
+      if (readOk) {
+        const streaming = await this._waitForReport(fullId, perAttemptMs);
+        if (streaming) {
+          console.log(`PlayStation BT: full report mode active (${hex(fullId)}) after ${i} attempt(s)`);
+          return true;
+        }
       }
       if (i < maxAttempts) {
         console.log(`PlayStation BT: still in compatibility mode after feature ${hex(featureId)} (attempt ${i}/${maxAttempts}); retrying`);
       }
     }
-    console.warn(`PlayStation BT: full report mode (${hex(fullId)}) did not start after ${maxAttempts} attempt(s) — gyro unavailable until reconnect`);
+    console.warn(`PlayStation BT: full report mode (${hex(fullId)}) not up inline after ${maxAttempts} attempt(s) — handing off to background re-activation`);
     return false;
   }
 
@@ -164,7 +173,7 @@ export class PlayStationDriver extends ControllerDriver {
    *
    * @returns {Promise<boolean>} true if the stream started, false if it gave up
    */
-  _startBackgroundReactivation(featureId, { intervalMs = 1000, maxMs = 12000 } = {}) {
+  _startBackgroundReactivation(featureId, { intervalMs = 500, maxMs = 12000 } = {}) {
     if (this._reactivateTimer) return Promise.resolve(false);
     const fullId = this._fullReportId();
     const hex = (n) => '0x' + n.toString(16).padStart(2, '0');
@@ -179,15 +188,19 @@ export class PlayStationDriver extends ControllerDriver {
         resolve(ok);
       };
       const onReport = (event) => { if (event.reportId === fullId) finish(true); };
+      const nudge = () => {
+        if (typeof this.device.receiveFeatureReport === 'function') {
+          this.device.receiveFeatureReport(featureId).catch(() => {});
+        }
+      };
       this._reactivateStop = () => finish(false, 'driver destroyed');
       this.device.addEventListener('inputreport', onReport);
       console.warn(`PlayStation BT: full report stream not up yet — re-activating in the background (every ${intervalMs}ms, up to ${maxMs}ms)`);
+      nudge(); // fire the first read immediately — don't idle a full interval before nudging
       this._reactivateTimer = setInterval(() => {
         elapsed += intervalMs;
         if (elapsed > maxMs) { finish(false, `no full report after ${maxMs}ms`); return; }
-        if (typeof this.device.receiveFeatureReport === 'function') {
-          this.device.receiveFeatureReport(featureId).catch(() => {});
-        }
+        nudge();
       }, intervalMs);
     });
   }
@@ -396,17 +409,43 @@ export class PlayStationDriver extends ControllerDriver {
     const touchpadButton = !!(psByte & 0x02);
 
     if (isDs4) {
-      // DS4-family (real Sony DS4 + GameSir clones): WebHID supplies the IMU
-      // only. Buttons/sticks/triggers come from the Gamepad API (a DS4
-      // enumerates as a standard gamepad on every OS). We deliberately omit
-      // them here — parsing at the DualSense offsets is wrong for a real DS4,
-      // and a non-empty button set would make ControllerManager prefer this
-      // mis-parsed synthetic over the correct Gamepad-API pad. Touchpad is
-      // omitted too until a real-DS4 button/touchpad layout is captured and
-      // validated.
+      // DS4-family (real Sony DS4 + GameSir DS4-mode clones). The DS4 report
+      // puts buttons at DIFFERENT offsets than the DualSense fields read above:
+      //   +4 dpad(low nibble)+face(high)   +5 shoulders/options/stick-clicks
+      //   +6 PS(bit0)/touchpad(bit1)+counter   +7/+8 L2/R2 analog
+      // Layout validated from a GameSir Super Nova BT capture (054c:05c4).
+      // We now RETURN buttons/sticks/triggers (previously omitted) so a DS4
+      // whose input only reaches us over WebHID — a Bluetooth clone, or one of
+      // two same-vid:pid pads the Gamepad API can't disambiguate — drives and
+      // folds from its OWN HID stream instead of being stuck button-less.
+      const face = data.getUint8(baseOffset + 4);
+      const shoulder = data.getUint8(baseOffset + 5);
+      const sys = data.getUint8(baseOffset + 6);
+      const hat = face & 0x0F;
+      const ds4Buttons = {
+        square: !!(face & 0x10), cross: !!(face & 0x20),
+        circle: !!(face & 0x40), triangle: !!(face & 0x80),
+        l1: !!(shoulder & 0x01), r1: !!(shoulder & 0x02),
+        l2: !!(shoulder & 0x04), r2: !!(shoulder & 0x08),
+        create: !!(shoulder & 0x10), options: !!(shoulder & 0x20),
+        l3: !!(shoulder & 0x40), r3: !!(shoulder & 0x80),
+        ps: !!(sys & 0x01),
+        dpadUp:    hat === 7 || hat === 0 || hat === 1,
+        dpadRight: hat === 1 || hat === 2 || hat === 3,
+        dpadDown:  hat === 3 || hat === 4 || hat === 5,
+        dpadLeft:  hat === 5 || hat === 6 || hat === 7,
+      };
+      const ds4Triggers = {
+        l2: data.getUint8(baseOffset + 7) / 255,
+        r2: data.getUint8(baseOffset + 8) / 255,
+      };
       return {
+        sticks,
+        triggers: ds4Triggers,
+        buttons: ds4Buttons,
         gyro,
         accel,
+        touchpadButton: !!(sys & 0x02),
         gyroScale: 2000.0 / 32768.0,   // ±2000 dps, 16-bit
         accelScale: 1.0 / 8192.0        // ±4g, 16-bit (gravity ~8192)
       };
@@ -702,15 +741,27 @@ export class PlayStationDriver extends ControllerDriver {
     // a *feature* report, so we must check INPUT reports for 0x11 (not feature
     // reports) or a USB DS4 would misdetect as Bluetooth. The legacy
     // output-report 0x31 check is kept for DualSense.
+    //
+    // DIAGNOSTIC: dump the descriptor so a mis-detect (e.g. a GameSir that
+    // declares input 0x11 while streaming 0x01 over USB → detected 'bluetooth'
+    // → parseReport matches no branch → NO GYRO) is visible in the console.
+    const inIds = [], outIds = [];
+    let type = 'usb', len01 = 0;
     for (const col of device.collections) {
-      for (const report of (col.outputReports || [])) {
-        if (report.reportId === 0x31) return 'bluetooth';
+      for (const r of (col.inputReports || [])) {
+        let bits = 0; for (const it of (r.items || [])) bits += (it.reportSize || 0) * (it.reportCount || 0);
+        const bytes = Math.ceil(bits / 8);
+        inIds.push('0x' + (r.reportId || 0).toString(16) + ':' + bytes + 'B');
+        if (r.reportId === 0x01) len01 = Math.max(len01, bytes);
+        if (r.reportId === 0x31 || r.reportId === 0x11) type = 'bluetooth';
       }
-      for (const report of (col.inputReports || [])) {
-        if (report.reportId === 0x31 || report.reportId === 0x11) return 'bluetooth';
+      for (const r of (col.outputReports || [])) {
+        outIds.push('0x' + (r.reportId || 0).toString(16));
+        if (r.reportId === 0x31) type = 'bluetooth';
       }
     }
-    return 'usb';
+    console.log(`[PS detect] ${device.productName || '?'} ${(device.vendorId || 0).toString(16)}:${(device.productId || 0).toString(16)} → ${type} · in=[${inIds.join(' ')}] out=[${outIds.join(' ')}] 0x01=${len01}B`);
+    return type;
   }
 
   // USB-equivalent gyro offset → IMU family. baseOffset removes the BT
diff --git a/packages/core/src/drivers/steam-controller-driver.js b/packages/core/src/drivers/steam-controller-driver.js
index a30c4d0..8a88ace 100644
--- a/packages/core/src/drivers/steam-controller-driver.js
+++ b/packages/core/src/drivers/steam-controller-driver.js
@@ -70,11 +70,27 @@ const FEATURE_REPORT_ID_FALLBACK = 0x02;
 
 export class SteamControllerDriver extends ControllerDriver {
 
+  // The Puck exposes 5 same-vid:pid HID interfaces on ONE physical unit and only
+  // some emit the state reports we parse — so the overlay must fan inputreport
+  // out across siblings. (Safe here because they're genuinely one device.)
+  static needsSiblingFanout = true;
+
   // Whether to suppress the Puck's lizard-mode keyboard/mouse emulation
   // (default on). Toggled from overlay settings before/at connect; read in
   // init(). Static so the setting can be applied without a driver instance.
   static suppressLizardMode = true;
 
+  // One elected lizard-mode owner per physical Puck. All five of the Puck's
+  // HID interfaces share vid:pid and get pooled as separate driver instances;
+  // previously EVERY instance probed all five siblings AND ran its own 800ms
+  // heartbeat — 5× redundant SET_REPORT churn that the NotAllowedError storm
+  // made expensive enough to jank the renderer (~4s, issue #101). Only the
+  // first instance to init a given Puck probes + heartbeats; because it already
+  // broadcasts CLEAR to all five siblings, suppression coverage is unchanged.
+  // Keyed by vid:pid — two physical Pucks would share one owner, which is fine:
+  // the owner's heartbeat already targets every matching interface.
+  static _lizardOwners = new Map(); // 'vid:pid' -> owner driver instance
+
   // Steam Controller emits raw 3-axis gyro (bytes 39-44, ±2000 dps)
   // and 3-axis accel (bytes 33-38, ±2g) — same rate-based encoding as
   // DualSense, so it flows through the standard SensorFusion pipeline.
@@ -115,6 +131,14 @@ export class SteamControllerDriver extends ControllerDriver {
       return;
     }
 
+    // Elect a single lizard-mode owner per Puck. Sibling interfaces bail here —
+    // the owner's heartbeat already broadcasts CLEAR to all of them, so this
+    // avoids the 5×-per-interface probe + heartbeat churn (issue #101).
+    const puckKey = this._puckKey();
+    const owner = SteamControllerDriver._lizardOwners.get(puckKey);
+    if (owner && owner !== this && owner._lizardTimer) return;
+    SteamControllerDriver._lizardOwners.set(puckKey, this);
+
     // Puck path: disable lizard-mode (the firmware's default keyboard +
     // mouse + scroll emulation) by sending CLEAR_DIGITAL_MAPPINGS +
     // SET_SETTINGS (trackpads = NONE) to every Puck HID handle, then
@@ -251,8 +275,16 @@ export class SteamControllerDriver extends ControllerDriver {
       this._lizardTimer = null;
     }
     this._lizardCandidates = [];
+    // Release ownership so the next connect for this Puck can re-elect an owner
+    // (e.g. this interface unplugged/re-pooled) rather than being skipped.
+    if (SteamControllerDriver._lizardOwners.get(this._puckKey()) === this) {
+      SteamControllerDriver._lizardOwners.delete(this._puckKey());
+    }
   }
 
+  /** Stable per-Puck key. All 5 interfaces of one Puck share vid:pid. */
+  _puckKey() { return `${this.device.vendorId}:${this.device.productId}`; }
+
   /**
    * Enumerate already-approved HID handles for this Puck (primary +
    * siblings sharing vid:pid). Returns at least [this.device] even if
diff --git a/packages/core/src/drivers/switch-pro-driver.js b/packages/core/src/drivers/switch-pro-driver.js
index 35ed133..531619e 100644
--- a/packages/core/src/drivers/switch-pro-driver.js
+++ b/packages/core/src/drivers/switch-pro-driver.js
@@ -191,7 +191,56 @@ export class SwitchProDriver extends ControllerDriver {
     // The previous partial remap also had the wrong sign for gyro.z
     // relative to DualSense, which surfaced as "Switch Pro lean is
     // inverted" once sensor fusion landed.
+    // ── Buttons + sticks (report 0x30 data bytes 2-10) ──
+    // Needed for WebHID-first: previously the Switch Pro's buttons/sticks came
+    // ONLY from the Gamepad API, so an all-WebHID path had gyro but no inputs.
+    // Layout per Nintendo report 0x30 (DataView excludes the report id):
+    //   byte 2 (right): Y0x01 X0x02 B0x04 A0x08  R0x40 ZR0x80
+    //   byte 3 (shared): Minus0x01 Plus0x02 Rstick0x04 Lstick0x08 Home0x10 Capture0x20
+    //   byte 4 (left): Down0x01 Up0x02 Right0x04 Left0x08  L0x40 ZL0x80
+    // Nintendo's face layout is rotated vs Xbox/PS: the Gamepad-API "standard"
+    // maps button[0]=bottom=B, [1]=right=A, [2]=left=Y, [3]=top=X — so map into
+    // our cross/circle/square/triangle (= synthetic 0/1/2/3) accordingly.
+    let buttons, sticks, triggers;
+    if (data.byteLength >= 11) {
+      const b0 = data.getUint8(2), b1 = data.getUint8(3), b2 = data.getUint8(4);
+      buttons = {
+        cross:    !!(b0 & 0x04),  // B (bottom)
+        circle:   !!(b0 & 0x08),  // A (right)
+        square:   !!(b0 & 0x01),  // Y (left)
+        triangle: !!(b0 & 0x02),  // X (top)
+        l1:       !!(b2 & 0x40),  // L
+        r1:       !!(b0 & 0x40),  // R
+        create:   !!(b1 & 0x01),  // Minus (View)
+        options:  !!(b1 & 0x02),  // Plus (Menu)
+        l3:       !!(b1 & 0x08),  // left stick click
+        r3:       !!(b1 & 0x04),  // right stick click
+        ps:       !!(b1 & 0x10),  // Home
+        capture:  !!(b1 & 0x20),  // Capture (extra — not in standard map)
+        dpadDown:  !!(b2 & 0x01),
+        dpadUp:    !!(b2 & 0x02),
+        dpadRight: !!(b2 & 0x04),
+        dpadLeft:  !!(b2 & 0x08),
+      };
+      // ZL/ZR are DIGITAL on the Pro Controller (no analog travel) → 0 or 1.
+      triggers = { l2: (b2 & 0x80) ? 1 : 0, r2: (b0 & 0x80) ? 1 : 0 };
+      // Sticks: 12-bit packed, 3 bytes each. Nominal center 0x800; usable half-
+      // range ~0x5A8 (no per-unit calibration). Gamepad-API convention up = -1.
+      const stick = (o) => {
+        const a = data.getUint8(o), b = data.getUint8(o + 1), c = data.getUint8(o + 2);
+        const x = a | ((b & 0x0F) << 8);
+        const y = (b >> 4) | (c << 4);
+        const n = (v) => Math.max(-1, Math.min(1, (v - 0x800) / 0x5A8));
+        return { x: n(x), y: n(y) };
+      };
+      const ls = stick(5), rs = stick(8);
+      sticks = { lx: ls.x, ly: -ls.y, rx: rs.x, ry: -rs.y };
+    }
+
     return {
+      buttons,
+      sticks,
+      triggers,
       gyro: { x: -rawGyroY, y: rawGyroZ, z: -rawGyroX },
       accel: { x: -rawAccelY, y: rawAccelZ, z: rawAccelX },
       touchpad: null,
@@ -202,6 +251,18 @@ export class SwitchProDriver extends ControllerDriver {
   }
 
   static detectConnectionType(device) {
+    // The USB Pro Controller exposes the Nintendo handshake OUTPUT report 0x80;
+    // the Bluetooth transport does not. (Hardcoding 'usb' mislabelled BT pads AND
+    // ran a doomed USB handshake over BT — see the oversized 0x30 BT reports.)
+    try {
+      let has80 = false, sawReports = false;
+      for (const c of (device.collections || [])) {
+        for (const r of (c.outputReports || [])) { sawReports = true; if (r.reportId === 0x80) has80 = true; }
+        for (const _ of (c.inputReports || [])) { sawReports = true; }
+      }
+      if (has80) return 'usb';
+      if (sawReports) return 'bluetooth';   // has reports but no 0x80 → Bluetooth
+    } catch (e) { /* fall through to default */ }
     return 'usb';
   }
 
diff --git a/packages/core/src/manager.js b/packages/core/src/manager.js
index 677bda1..02534fe 100644
--- a/packages/core/src/manager.js
+++ b/packages/core/src/manager.js
@@ -33,6 +33,14 @@ const DEFAULTS = {
   psButtonIndex: 16,
   hidStaleMs: 800,
   axisActivityThreshold: 0.6,
+  // Grace window before a pooled HID handle that has NEVER streamed a report is
+  // evicted as a phantom. Present controllers stream within tens of ms; a
+  // spoofing pad's dragged-in same-vid:pid ghosts never do.
+  poolProbationMs: 3000,
+  // Window over which a button counts as "recently pressed" when folding a
+  // Gamepad pad to its WebHID handle. The claiming press often lands on the two
+  // faces a frame or two apart, so a same-frame match misses it.
+  foldWindowMs: 350,
   // Per-player DualSense lightbar colors (1-indexed by slot ordinal).
   // Override via `new ControllerManager({ playerColors: { 1: {...}, ... } })`.
   playerColors: {
@@ -47,7 +55,10 @@ const DEFAULTS = {
 
 export function makeSyntheticGamepad(hidDevice) {
   const buttons = [];
-  for (let i = 0; i < 17; i++) buttons.push({ pressed: false, touched: false, value: 0 });
+  // 22 slots: 0-16 standard + 17 shared extra (Switch Capture / DualSense mic /
+  // Steam "…") + 18-21 back paddles (L4/L5/R4/R5). None of 17-21 have a standard
+  // Gamepad-API index; each controller profile maps them to its own meshes.
+  for (let i = 0; i < 22; i++) buttons.push({ pressed: false, touched: false, value: 0 });
   return {
     id: `HID::${hidDevice.productName || 'hid'}`,
     index: -1,
@@ -83,6 +94,16 @@ export function applyParsedToSynthetic(gp, parsed) {
     setBtn(12, b.dpadUp); setBtn(13, b.dpadDown);
     setBtn(14, b.dpadLeft); setBtn(15, b.dpadRight);
     setBtn(16, b.ps);
+    // 17 = shared "extra" slot with no standard Gamepad index: DualSense mic /
+    // Steam Controller "…" quick-access / Switch Pro Capture. Each controller
+    // profile maps slot 17 to its own mesh; undefined fields stay false.
+    setBtn(17, b.capture || b.mic || b.quickAccess);
+  }
+  if (parsed.paddles) {
+    // 18-21 = back paddles (Steam Controller L4/L5/R4/R5). No standard index;
+    // the Steam profile maps these slots to the paddle meshes.
+    const p = parsed.paddles;
+    setBtn(18, p.l4); setBtn(19, p.l5); setBtn(20, p.r4); setBtn(21, p.r5);
   }
   if (parsed.triggers) {
     setBtn(6, parsed.triggers.l2 > 0.1, parsed.triggers.l2);
@@ -170,6 +191,23 @@ class HidEntry {
     this.synthetic = makeSyntheticGamepad(device);
     this.hasButtons = false;
     this.hidActiveSince = 0;
+    // Liveness bookkeeping for phantom eviction: when this handle entered the
+    // pool, and when it last received ANY raw inputreport (0 = never streamed).
+    // A physically-present controller sets lastRawReportAt within tens of ms;
+    // a granted-but-absent / spoof-dragged-in handle stays at 0.
+    this.pooledAt = performance.now();
+    this.lastRawReportAt = 0;
+    // Rolling window of recently-pressed buttons (index → timestamp), used to
+    // fold this handle to the Gamepad pad showing the same press. Populated by
+    // the manager each frame from `synthetic`.
+    this._recentBtns = new Map();
+    // True once this handle has EVER reported a non-zero button. Distinct from
+    // hasButtons (has a buttons *field*): a GameSir-as-DS4 gyro interface reports
+    // a DS4-shaped buttons field that's always zero — hasButtons=true but it
+    // never actually presses. _everPressed drives (a) whether effectiveGamepad
+    // trusts this synthetic for buttons and (b) whether it can be input-folded
+    // vs must be folded by elimination.
+    this._everPressed = false;
     this.slot = null; // set by ControllerManager when claimed
     this._handler = (ev) => this._onReport(ev);
     device.addEventListener('inputreport', this._handler);
@@ -189,6 +227,28 @@ class HidEntry {
     // and report phantom stuck buttons that would otherwise auto-claim a
     // slot with no user input.
     this._initialPressedMask = null;
+    // Axis baseline (first report), paired with the button mask above so a
+    // stick NUDGE also counts as fresh input — not just a stuck/drifted axis.
+    this._initialAxes = null;
+  }
+
+  /**
+   * Fresh USER input to gate a pool→slot claim: a button not stuck from the
+   * first report, OR a stick moved past a deadband from its first-report
+   * baseline. The stick path matters for a DualSense over Bluetooth in full-
+   * report (0x31) mode — Chromium's Gamepad API can't see it, so its ONLY way
+   * to become active is this WebHID claim, and a user often nudges the stick
+   * (which lights the "in use" dot) without pressing a face button.
+   */
+  hasFreshInput() {
+    if (this.hasFreshButtonPress()) return true;
+    const gp = this.synthetic;
+    if (!gp || !gp.axes || this.hidActiveSince === 0) return false;
+    if (this._initialAxes == null) { this._initialAxes = [...gp.axes]; return false; }
+    for (let i = 0; i < gp.axes.length; i++) {
+      if (Math.abs((gp.axes[i] || 0) - (this._initialAxes[i] || 0)) > 0.35) return true;
+    }
+    return false;
   }
 
   /** True if any button not in the initial-stuck set is currently pressed. */
@@ -214,11 +274,21 @@ class HidEntry {
   }
 
   _onReport(ev) {
+    this.lastRawReportAt = performance.now();   // raw report arrived — proves the device is present/streaming
     if (!this.driver) return;
     const parsed = this.driver.parseReport(ev.reportId, ev.data);
     if (!parsed) return;
     if (parsed.buttons) this.hasButtons = true;
     applyParsedToSynthetic(this.synthetic, parsed);
+    // Expose report-level extras so a POOLED (unclaimed) entry driving a viz can
+    // read touchpad/grips without a slot 'hid-report' emit. Used by the overlay
+    // once it reads the selected pool entry directly (WebHID-first, Phase 3b).
+    this._lastTouchpad = parsed.touchpad || null;
+    this._lastTouchpadButton = !!parsed.touchpadButton;
+    this._lastGrips = parsed.grips || null;
+    if (!this._everPressed) {
+      for (const b of this.synthetic.buttons) { if (b && (b.pressed || (b.value || 0) > 0.5)) { this._everPressed = true; break; } }
+    }
     this.hidActiveSince = performance.now();
     if (parsed.gyro) {
       const a = parsed.accel;
@@ -382,15 +452,16 @@ export class Slot {
   }
 
   /**
-   * Choose the input source each frame: prefer the HID-backed synthetic
-   * when bound and the driver emits buttons (BT DualSense case); fall
-   * back to Gamepad API for driver-skinny devices (Switch Pro) or when
-   * HID reports have gone stale.
+   * Choose the input source each frame: prefer the HID-backed synthetic when
+   * bound AND that handle has actually shown real button presses (BT DualSense).
+   * Fall back to the Gamepad pad for driver-skinny devices (Switch Pro) and for
+   * a spoof interface whose HID buttons are always zero (GameSir-as-DS4: buttons
+   * come over the Gamepad API, only gyro over WebHID) — or when HID goes stale.
    */
   effectiveGamepad(pads) {
     const realGp = this.gamepadIndex != null ? pads[this.gamepadIndex] : null;
     const entry = this._hidEntry;
-    if (entry && entry.hidActiveSince > 0 && entry.hasButtons) {
+    if (entry && entry.hidActiveSince > 0 && entry._everPressed) {
       const staleFor = performance.now() - entry.hidActiveSince;
       if (staleFor > this._opts.hidStaleMs) {
         resetSynthetic(entry.synthetic);
@@ -438,12 +509,34 @@ export class ControllerManager {
     // require axis motion (not just pinned position) to treat a pad as
     // active. Counters Chrome BT-reconnect ghost pads with stuck axes.
     this._prevAxesByIndex = new Map();
+    // Rolling window of recently-pressed buttons per Gamepad-pad index — the
+    // pad half of the fold correlation (the HID half lives on each HidEntry).
+    this._recentPadBtns = new Map();
+    this._frameNow = 0;
     this._hidConnectHandler = null;
     this._hidDisconnectHandler = null;
   }
 
   getSlot(id) { return this._slotById[id] || null; }
 
+  /**
+   * Public seat-release used by the lobby's "leave" (B on a joined seat).
+   * Mirrors the PS/Home hold-to-release gesture: detach any HID entry back to
+   * the pool, empty the slot, and arm the reclaim cooldown + await-silence so
+   * the still-connected controller doesn't instantly re-grab the seat. Returns
+   * true if a claimed slot was actually released.
+   */
+  releaseSlotToPool(slotId, now = performance.now()) {
+    const s = this.getSlot(slotId);
+    if (!s || s.state !== 'claimed') return false;
+    const freedIndex = s.gamepadIndex;
+    if (s._hidEntry) this._detachEntryFromSlot(s);
+    s.release();
+    if (freedIndex != null) this._recentlyReleasedByIndex.set(freedIndex, now);
+    this._recentlyReleasedBySlot.set(s.id, now);
+    return true;
+  }
+
   /**
    * Claim a specific slot to the first live Gamepad API pad that isn't
    * already claimed by another slot. Used by callers that need P1 to be
@@ -495,7 +588,7 @@ export class ControllerManager {
       controllerTypeHint: info?.controllerProfile || info?.protocol || null,
       silent: true,
     });
-    this._attachMatchingPoolEntry(slot);
+    this._attachMatchingPoolEntry(slot, pads);
     slot._emit('claimed');
     return gp;
   }
@@ -613,6 +706,127 @@ export class ControllerManager {
     return null;
   }
 
+  /** Indices of buttons currently pressed on a gamepad-shaped object. */
+  static _pressedSet(gp) {
+    const set = new Set();
+    const b = gp && gp.buttons;
+    if (b) for (let i = 0; i < b.length; i++) {
+      const x = b[i];
+      if (x && (x.pressed || (typeof x.value === 'number' && x.value > 0.5))) set.add(i);
+    }
+    return set;
+  }
+
+  /**
+   * Record this frame's pressed buttons into the rolling fold windows — one per
+   * Gamepad pad, one per pooled HID handle. Folding reads these windows so a
+   * press that lands on the two faces a frame or two apart still correlates.
+   */
+  _recordInput(pads, now) {
+    for (const gp of pads) {
+      if (!gp) continue;
+      let m = this._recentPadBtns.get(gp.index);
+      if (!m) { m = new Map(); this._recentPadBtns.set(gp.index, m); }
+      for (const i of ControllerManager._pressedSet(gp)) m.set(i, now);
+    }
+    for (const entry of this._hidPool.values()) {
+      if (!entry._recentBtns) entry._recentBtns = new Map();
+      for (const i of ControllerManager._pressedSet(entry.synthetic)) entry._recentBtns.set(i, now);
+    }
+  }
+
+  /** Buttons pressed within the fold window as of this frame. */
+  _recentPressed(map) {
+    const s = new Set();
+    if (!map) return s;
+    const w = this.opts.foldWindowMs;
+    for (const [i, ts] of map) if (this._frameNow - ts <= w) s.add(i);
+    return s;
+  }
+
+  /**
+   * Unbound pool entries that could belong to `slot` — the full vid:pid-OR-
+   * productName set (same rule as _entryMatchesSlot). We deliberately do NOT
+   * narrow to vid:pid: a multi-interface pad (GameSir Super Nova presents
+   * 054c:0ce6 to the Gamepad API but its real HID handle is 054c:09cc) is
+   * reachable only by name, so a vid:pid-only candidate set binds NOTHING and
+   * kills its gyro. Cross-wiring among candidates is prevented downstream by
+   * input correlation (_correlateEntryByInput), not by shrinking this set.
+   */
+  _candidateEntriesForSlot(slot) {
+    const out = [];
+    for (const entry of this._hidPool.values()) {
+      if (this._entryMatchesSlot(entry, slot)) out.push(entry);
+    }
+    return out;
+  }
+
+  /**
+   * Among several candidate entries that a seat's vid:pid can't tell apart
+   * (two identical controllers — a real DS4 and a DS4-spoofing clone both on
+   * 054c:*), pick the one whose OWN report stream shows the same input as the
+   * seat's live Gamepad pad. That's the only signal that ties a physical unit
+   * to its HID handle in the browser (no serial). Returns null when there's no
+   * input to correlate on, or when two entries match equally — defer rather
+   * than guess and cross-wire.
+   */
+  _correlateEntryByInput(candidates, gp) {
+    if (!gp) return null;
+    // Buttons over the fold window (not just this frame) — the claiming press
+    // reaches the Gamepad pad and the HID stream a frame or two apart.
+    const target = this._recentPressed(this._recentPadBtns.get(gp.index));
+    const axes = gp.axes || [];
+    const thr = this.opts.axisActivityThreshold;
+    const axisActive = axes.some((a) => Math.abs(a) > thr);
+    if (target.size === 0 && !axisActive) return null;
+
+    let best = null, bestScore = 0, tie = false;
+    for (const e of candidates) {
+      const ep = this._recentPressed(e._recentBtns);
+      let score = 0;
+      for (const i of target) if (ep.has(i)) score++;
+      const ea = (e.synthetic && e.synthetic.axes) || [];
+      for (let i = 0; i < 4; i++) {
+        const a = axes[i] || 0;
+        if (Math.abs(a) > thr && Math.sign(a) === Math.sign(ea[i] || 0) && Math.abs(a - (ea[i] || 0)) < 0.4) score += 0.5;
+      }
+      if (score > bestScore) { bestScore = score; best = e; tie = false; }
+      else if (score === bestScore && score > 0) tie = true;
+    }
+    if (bestScore <= 0 || tie) return null;
+    return best;
+  }
+
+  /**
+   * Choose which pooled HID entry to bind to `slot`. Fast path (the norm):
+   * exactly one candidate → that one, no input needed. Ambiguous (2+ identical
+   * units) → correlate by the seat's live Gamepad input; defer (null) until the
+   * player presses something rather than binding the wrong unit's gyro.
+   */
+  _pickPoolEntryForSlot(slot, pads) {
+    const candidates = this._candidateEntriesForSlot(slot);
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1) return candidates[0];
+    const gp = (pads && slot.gamepadIndex != null) ? pads[slot.gamepadIndex] : null;
+    // Tier 1 — correlate live input among handles that have actually shown a
+    // real button press. A pressed button appearing in a handle's own report
+    // stream unambiguously identifies the physical unit (real DS4, DualSense).
+    // Never binds an idle handle, so it can't cross-wire to a phantom.
+    const pressers = candidates.filter((e) => e._everPressed);
+    const corr = this._correlateEntryByInput(pressers, gp);
+    if (corr) return corr;
+    // Tier 2 — a handle that has never pressed a real button can't be input-
+    // correlated: either a truly gyro-only interface, or a spoof (GameSir-as-DS4)
+    // whose HID buttons are always zero because its buttons live on the Gamepad
+    // API. Bind it when it's the SOLE such candidate — otherwise its gyro is
+    // stranded and the seat stays mislabeled as the spoofed Gamepad identity. We
+    // never fall back to a non-correlated presser (that cross-wires to an idle
+    // real unit).
+    const silent = candidates.filter((e) => !e._everPressed);
+    if (silent.length === 1) return silent[0];
+    return null;
+  }
+
   /**
    * Find an already-claimed slot that this pool entry belongs to but isn't
    * yet bound to — matched by the slot's gamepad vid:pid OR by productName
@@ -620,10 +834,23 @@ export class ControllerManager {
    * the Gamepad API and WebHID report different vid:pid for one physical
    * device). Returns the slot or null. Binding-only: never creates a slot.
    */
-  _findClaimedUnboundSlotForEntry(entry) {
-    return this.slots.find((s) =>
+  _findClaimedUnboundSlotForEntry(entry, pads) {
+    const matching = this.slots.filter((s) =>
       s.state === 'claimed' && !s._hidEntry && this._entryMatchesSlot(entry, s)
-    ) || null;
+    );
+    if (matching.length <= 1) return matching[0] || null;
+    // Two identical-vid:pid units, two seats each awaiting their HID handle:
+    // bind this entry to the seat whose Gamepad pad shows the same button THIS
+    // entry's own report stream shows pressed (over the fold window). No shared
+    // press → defer.
+    const ep = this._recentPressed(entry._recentBtns);
+    if (ep.size) {
+      for (const s of matching) {
+        const sp = this._recentPressed(this._recentPadBtns.get(s.gamepadIndex));
+        for (const i of ep) if (sp.has(i)) return s;
+      }
+    }
+    return null;
   }
 
   /**
@@ -655,9 +882,40 @@ export class ControllerManager {
     ) || null;
   }
 
+  /**
+   * For a slot claimed via WebHID (its bound HID handle carries buttons), find
+   * that device's own Gamepad-API pad — same vid:pid, not already owned by
+   * another slot. Prevents a DS4/DualSense that seated over WebHID from leaving
+   * a redundant free-floating pad that would double-seat (and shows as a phantom
+   * panel row). Two identical pads → the one whose recent buttons match THIS
+   * slot's HID stream; ambiguous & idle → wait.
+   */
+  _findUnownedPadForHidSlot(slot, pads) {
+    const d = slot._hidEntry && slot._hidEntry.device;
+    if (!d) return null;
+    const owned = new Set(this.slots.filter((s) => s.gamepadIndex != null).map((s) => s.gamepadIndex));
+    const candidates = (pads || []).filter((p) => {
+      if (!p || owned.has(p.index)) return false;
+      const vp = ControllerRegistry.parseGamepadVendorProduct(p.id);
+      return vp && vp.vendorId === d.vendorId && vp.productId === d.productId;
+    });
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1) return candidates[0];
+    const hidBtns = this._recentPressed(slot._hidEntry._recentBtns);
+    if (hidBtns.size) {
+      for (const p of candidates) {
+        const padBtns = this._recentPressed(this._recentPadBtns.get(p.index));
+        for (const i of hidBtns) if (padBtns.has(i)) return p;
+      }
+    }
+    return null;
+  }
+
   ingestFrame(pads, now) {
     const claimedThisFrame = [];
     const releasedThisFrame = [];
+    this._frameNow = now;
+    this._recordInput(pads, now);   // fold-correlation windows (pad + HID button history)
 
     // Orphan check (Gamepad-API-backed claims only)
     // Note: _prevAxesByIndex is updated at the END of the frame so the
@@ -695,7 +953,7 @@ export class ControllerManager {
       const gp = this._findReturningPadForSlot(s, pads);
       if (gp) {
         s.claim(gp, { controllerTypeHint: s.controllerType, silent: true });
-        this._attachMatchingPoolEntry(s);
+        this._attachMatchingPoolEntry(s, pads);
         s._emit('claimed');
         claimedThisFrame.push(s.id);
         console.log(`[manager] ${s.id}: reconnected — re-claimed orphan via Gamepad API`);
@@ -717,10 +975,13 @@ export class ControllerManager {
     // across two slots. effectiveGamepad picks up the buttons next frame.
     for (const s of this.slots) {
       if (s.state !== 'claimed' || s.gamepadIndex != null) continue;
-      const gp = this._findReturningPadForSlot(s, pads);
+      // (a) sticky reconnect: the SAME pad returning (matched by stable id).
+      // (b) WebHID-claimed slot: adopt its device's own Gamepad pad (vid:pid)
+      //     so one physical controller isn't split into a second phantom seat.
+      const gp = this._findReturningPadForSlot(s, pads) || (s._hidEntry ? this._findUnownedPadForHidSlot(s, pads) : null);
       if (gp) {
         s.gamepadIndex = gp.index;
-        console.log(`[manager] ${s.id}: adopted returning Gamepad pad (buttons restored)`);
+        console.log(`[manager] ${s.id}: adopted Gamepad pad (buttons restored / deduped)`);
       }
     }
 
@@ -751,7 +1012,7 @@ export class ControllerManager {
       // hooked up. Without this defer, a lobby subscriber asking "does
       // this slot have gyro?" at claim time would always see false and
       // skip arming the motion toggle.
-      this._attachMatchingPoolEntry(empty);
+      this._attachMatchingPoolEntry(empty, pads);
       empty._emit('claimed');
     }
 
@@ -763,25 +1024,29 @@ export class ControllerManager {
     // GameSir-as-DS4), would otherwise be left with working buttons but a
     // dead gyro toggle after a reconnect (GameSir Super Nova auto-re-pairs
     // off its charger, so this path gets hit constantly). Binding-only — it
-    // never creates a
-    // slot — so it's safe to run every frame regardless of button activity.
-    // Snapshot the pool values: _attachEntryToSlot mutates the pool map.
-    for (const entry of [...this._hidPool.values()]) {
-      const slot = this._findClaimedUnboundSlotForEntry(entry);
-      if (slot) this._attachEntryToSlot(slot, entry);
+    // never creates a slot — so it's safe to run every frame regardless of
+    // button activity. Slot-centric so a UNIQUE remaining candidate cascades
+    // to a certain bind: once one of two identical units is bound (and leaves
+    // the pool), the other seat has a single candidate left and binds without
+    // needing input. Genuinely ambiguous same-vid:pid pairs correlate by live
+    // input inside _pickPoolEntryForSlot, and defer until a button is pressed.
+    for (const slot of this.slots) {
+      if (slot.state !== 'claimed' || slot._hidEntry) continue;
+      const entry = this._pickPoolEntryForSlot(slot, pads);
+      if (entry) this._attachEntryToSlot(slot, entry);
     }
 
     // Claim via WebHID synthetic activity (covers BT-silent DualSense):
     // iterate the HID pool, not slots. Any pool entry showing activity
     // promotes into an empty slot.
     for (const entry of this._hidPool.values()) {
-      // Require a *fresh* button press to claim via HID pool (ignoring
-      // buttons that were stuck-pressed from the first HID report).
-      // GameSir-as-DS4 gets mis-parsed by the DualSense driver, producing
-      // phantom stuck buttons (e.g. button 12) that would otherwise
-      // auto-claim a slot with no user input. BT-silent DualSense still
-      // claims normally because the user's PS press is a fresh transition.
-      if (!entry.hasFreshButtonPress()) continue;
+      // Require *fresh* input to claim via the HID pool — a button press that
+      // wasn't stuck from the first report, OR a stick nudge past its baseline.
+      // (Stuck buttons from a mis-parsed foreign layout, and drifted axes, are
+      // excluded by the baseline snapshots.) The stick path lets a DualSense
+      // over Bluetooth — invisible to the Gamepad API in 0x31 mode — become
+      // active when the user moves the stick, matching its lit "in use" dot.
+      if (!entry.hasFreshInput()) continue;
       // Dedupe: if this physical controller is already claimed via the
       // Gamepad API path (same vid:pid), attach the HID entry to that slot
       // for gyro/touchpad rather than spawning a second slot. Fixes pads
@@ -789,7 +1054,7 @@ export class ControllerManager {
       // Super Nova presenting as DS4 + raw HID). (The reconciliation pass
       // above already covers IMU-only devices; this catches a device that
       // emits buttons AND matches an already-claimed slot.)
-      const existing = this._findClaimedUnboundSlotForEntry(entry);
+      const existing = this._findClaimedUnboundSlotForEntry(entry, pads);
       if (existing) {
         this._attachEntryToSlot(existing, entry);
         continue;
@@ -840,6 +1105,23 @@ export class ControllerManager {
       }
     }
 
+    // Phantom eviction: drop pooled handles that have NEVER streamed a report
+    // within the probation window. A spoofing pad (GameSir Super Nova presenting
+    // DualSense 054c:0ce6 to the Gamepad API) makes autoPoolApprovedHid grab
+    // other approved same-vid:pid handles that aren't physically present; silent,
+    // they bloat per-frame cost and confound same-id binding (extra "no-button"
+    // candidates that keep the real unit from being uniquely identified). A
+    // present controller streams within tens of ms, so this only removes genuine
+    // phantoms. Guarded on numeric pooledAt so lightweight test doubles that omit
+    // it are never swept.
+    for (const [device, entry] of [...this._hidPool]) {
+      if (typeof entry.pooledAt !== 'number') continue;
+      if (entry.lastRawReportAt === 0 && (now - entry.pooledAt) > this.opts.poolProbationMs) {
+        console.log(`[manager] evicting phantom HID handle ${device.vendorId?.toString(16)}:${device.productId?.toString(16)} (${device.productName || '?'}) — silent for ${Math.round(now - entry.pooledAt)}ms`);
+        this._evictFromPool(device);
+      }
+    }
+
     // Snapshot axes for next frame's fresh-activity check.
     for (const gp of pads) {
       if (!gp) continue;
@@ -853,11 +1135,9 @@ export class ControllerManager {
    * On Gamepad API claim, pull a matching HID entry from the pool into
    * this slot. Matches by vid:pid parsed from gamepad.id.
    */
-  _attachMatchingPoolEntry(slot) {
+  _attachMatchingPoolEntry(slot, pads) {
     if (slot._hidEntry) return;
-    const vp = ControllerRegistry.parseGamepadVendorProduct(slot.controllerLabel);
-    if (!vp) return;
-    const entry = this._findPoolEntryByVidPid(vp.vendorId, vp.productId);
+    const entry = this._pickPoolEntryForSlot(slot, pads);
     if (entry) this._attachEntryToSlot(slot, entry);
   }
 
@@ -893,28 +1173,19 @@ export class ControllerManager {
   }
 
   /**
-   * Electron-only: requestDevice auto-approved by main.js handler, so we
-   * can call it at boot to pool controllers that haven't been approved yet.
+   * @deprecated No-op. Auto-pairing not-yet-approved devices at boot is
+   * impossible: WebHID `requestDevice()` requires transient user activation,
+   * which a fire-and-forget boot call doesn't have — it threw "Must be handling
+   * a user gesture to show a permission request" and pooled nothing. The paths
+   * that actually work:
+   *   • already-approved devices  → autoPoolApprovedHid()  (gesture-free)
+   *   • a not-yet-approved device → connectHidForSlot() from a user gesture
+   *                                 (the overlay's per-slot Connect button)
+   *   • hot-plug of approved ones → wireHidHotplug()
+   * Kept as a no-op so existing/synced callers (e.g. the game's boot chain)
+   * don't break; safe to delete once all call sites are gone.
    */
-  async electronAutoRequestDevice() {
-    if (!navigator.hid) return;
-    const filters = ControllerRegistry.getHIDFilters();
-    await new Promise((r) => setTimeout(r, 400));
-    // Call once per slot count so we cover the typical 2-controller case
-    // without looping forever on a single-controller setup.
-    for (let i = 0; i < this.slots.length; i++) {
-      try {
-        const picked = await navigator.hid.requestDevice({ filters });
-        const d = (picked || []).find((dev) => !this._isDeviceInPoolOrSlot(dev));
-        if (!d) break;
-        await this.poolDevice(d);
-        await new Promise((r) => setTimeout(r, 200));
-      } catch (err) {
-        console.log('electronAutoRequestDevice stopped:', err.message);
-        break;
-      }
-    }
-  }
+  async electronAutoRequestDevice() { /* intentionally a no-op — see deprecation note */ }
 
   /**
    * User-gesture HID pairing, initiated from a Connect button. If a slot
diff --git a/packages/core/test/controller-registry.test.js b/packages/core/test/controller-registry.test.js
index a89d168..29f86de 100644
--- a/packages/core/test/controller-registry.test.js
+++ b/packages/core/test/controller-registry.test.js
@@ -51,9 +51,22 @@ test('identifyFromGamepadId resolves PlayStation ids to the dualsense protocol w
   assert.equal(info.protocol, 'dualsense');
   assert.equal(info.hasGyro, true);
   assert.equal(info.hasTouchpad, true);
-  // NOTE: name resolves to the first PS entry ('Sony DualSense') because the
-  // gamepad.id alone cannot distinguish DS4 from DS5 or a clone — the IMU
-  // probe / spoof picker does that. This asserts the documented behavior.
+  // The vid:pid disambiguates within the shared PLAYSTATION_ID pattern, so a
+  // 09cc id resolves to DS4 v2 (not the first PS entry, DualSense).
+  assert.equal(info.driverName, 'Sony DualShock 4 v2');
+});
+
+test('identifyFromGamepadId disambiguates Sony pads by vid:pid (DS4 05c4 ≠ DualSense 0ce6)', () => {
+  // All Sony pads share ONE PLAYSTATION_ID pattern; without vid:pid the first
+  // match (DualSense) mislabels every DS4. A GameSir spoofing DS4 v1 (054c:05c4)
+  // must read as DualShock 4 v1, not DualSense.
+  const ds4v1 = ControllerRegistry.identifyFromGamepadId(
+    'Wireless Controller (STANDARD GAMEPAD Vendor: 054c Product: 05c4)');
+  assert.equal(ds4v1.driverName, 'Sony DualShock 4 v1');
+
+  const ds5 = ControllerRegistry.identifyFromGamepadId(
+    'DualSense Wireless Controller (STANDARD GAMEPAD Vendor: 054c Product: 0ce6)');
+  assert.equal(ds5.driverName, 'Sony DualSense');
 });
 
 test('identifyFromGamepadId is variant-first: GameSir Cyclone beats Switch Pro', () => {
diff --git a/packages/core/test/helpers.js b/packages/core/test/helpers.js
index 6c0def5..13423a1 100644
--- a/packages/core/test/helpers.js
+++ b/packages/core/test/helpers.js
@@ -90,17 +90,39 @@ export function buildPSReport({
  * offset + 2 (gyro 14, accel 20).
  * @returns {{reportId:number, data:DataView}}
  */
-export function buildDs4BtReport({
+export function buildDs4BtReport(opts = {}) {
+  return buildDs4Report({ ...opts, bt: true });
+}
+
+/**
+ * Build a **DualShock 4** report at the true DS4 button layout (distinct from
+ * the DualSense layout of buildPSReport): dpad+face at +4, shoulders at +5,
+ * PS/touchpad at +6, L2/R2 analog at +7/+8. `bt:true` prepends the 2-byte BT
+ * header (report 0x11, baseOffset 2, IMU +2); otherwise USB (report 0x01,
+ * baseOffset 0, IMU at 12). Defaults to dpad-neutral (0x08).
+ * @returns {{reportId:number, data:DataView}}
+ */
+export function buildDs4Report({
+  bt = false,
+  lx = 128, ly = 128, rx = 128, ry = 128,
+  l2 = 0, r2 = 0,
+  faceByte = 0x08, shoulderByte = 0, sysByte = 0,
   gyro = { x: 0, y: 0, z: 0 },
   accel = { x: 0, y: 0, z: 0 },
-  len = 78,
+  len,
 } = {}) {
-  const u8 = new Uint8Array(len);
-  u8[0] = 0xc0; u8[1] = 0x00;            // BT header (report id already stripped)
-  u8[2] = 128; u8[3] = 128; u8[4] = 128; u8[5] = 128; // sticks at baseOffset 2
-  writeS16LE(u8, 14, gyro.x); writeS16LE(u8, 16, gyro.y); writeS16LE(u8, 18, gyro.z);
-  writeS16LE(u8, 20, accel.x); writeS16LE(u8, 22, accel.y); writeS16LE(u8, 24, accel.z);
-  return { reportId: 0x11, data: dataView(u8) };
+  const base = bt ? 2 : 0;
+  const gyroOff = bt ? 14 : 12;
+  const u8 = new Uint8Array(len || (bt ? 78 : 64));
+  if (bt) { u8[0] = 0xc0; u8[1] = 0x00; }        // BT header (report id already stripped)
+  u8[base + 0] = lx; u8[base + 1] = ly; u8[base + 2] = rx; u8[base + 3] = ry;
+  u8[base + 4] = faceByte & 0xff;
+  u8[base + 5] = shoulderByte & 0xff;
+  u8[base + 6] = sysByte & 0xff;
+  u8[base + 7] = l2 & 0xff; u8[base + 8] = r2 & 0xff;
+  writeS16LE(u8, gyroOff, gyro.x); writeS16LE(u8, gyroOff + 2, gyro.y); writeS16LE(u8, gyroOff + 4, gyro.z);
+  writeS16LE(u8, gyroOff + 6, accel.x); writeS16LE(u8, gyroOff + 8, accel.y); writeS16LE(u8, gyroOff + 10, accel.z);
+  return { reportId: bt ? 0x11 : 0x01, data: dataView(u8) };
 }
 
 // ── Fake HID device (drives the IMU probe) ─────────────────────
diff --git a/packages/core/test/manager-duplicate-controllers.test.js b/packages/core/test/manager-duplicate-controllers.test.js
new file mode 100644
index 0000000..487aecd
--- /dev/null
+++ b/packages/core/test/manager-duplicate-controllers.test.js
@@ -0,0 +1,184 @@
+// ============================================================
+// ControllerManager — two identical-vid:pid controllers
+// ============================================================
+//
+// A real DualShock 4 and a DS4-spoofing clone (GameSir Super Nova in DS4
+// mode) both enumerate as 054c:09cc AND report the same productName
+// ("Wireless Controller"), so NOTHING static tells them apart — the browser
+// exposes no serial. The old bind path took the first pool entry matching a
+// seat's vid:pid, which cross-wired each seat to the wrong unit's HID handle
+// (so a seat's gyro came from the other controller). These tests lock the
+// report-stream correlation: a seat binds the entry whose OWN synthetic shows
+// the same button the seat's Gamepad pad is pressing.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ControllerManager, makeSyntheticGamepad } from '../src/manager.js';
+
+const DS4_ID = 'Wireless Controller (STANDARD GAMEPAD Vendor: 054c Product: 09cc)';
+const DS5_ID = 'DualSense Wireless Controller (STANDARD GAMEPAD Vendor: 054c Product: 0ce6)';
+
+function makePad(index, id, { buttons = {}, axes = [0, 0, 0, 0] } = {}) {
+  const btns = [];
+  for (let i = 0; i < 17; i++) btns.push({ pressed: false, touched: false, value: 0 });
+  for (const [i, v] of Object.entries(buttons)) { btns[i].pressed = !!v; btns[i].value = v ? 1 : 0; }
+  return { index, id, mapping: 'standard', connected: true, timestamp: 0, buttons: btns, axes: [...axes] };
+}
+
+// Two physically distinct units, same vid:pid + productName.
+function ds4Device() { return { vendorId: 0x054c, productId: 0x09cc, productName: 'Wireless Controller' }; }
+
+function fakeEntry(device) {
+  return {
+    device,
+    driver: null,
+    fusion: { startCalibration() {}, ingest() {} },
+    synthetic: makeSyntheticGamepad(device),
+    hasButtons: true,
+    _everPressed: false,
+    hidActiveSince: 0,
+    slot: null,
+    hasFreshButtonPress() { return false; },  // isolate the Gamepad-API claim + correlation path
+    hasFreshInput() { return false; },
+    destroy() {},
+  };
+}
+// Simulate the unit's own HID report stream showing a button held (a real press
+// also marks the handle as having ever pressed — see _everPressed).
+function press(entry, i) { entry.synthetic.buttons[i].pressed = true; entry.synthetic.buttons[i].value = 1; entry._everPressed = true; }
+
+test('claim-time: seat binds the entry whose report stream matches the pressed button', () => {
+  const m = new ControllerManager({ slotIds: ['P1', 'P2'] });
+  const devA = ds4Device(), devB = ds4Device();
+  const entryA = fakeEntry(devA), entryB = fakeEntry(devB);
+  m._hidPool.set(devA, entryA);
+  m._hidPool.set(devB, entryB);
+  press(entryB, 1);   // the unit being held (circle) is device B
+
+  // Its Gamepad pad shows the same button. First-match-by-vid:pid would grab
+  // entryA (inserted first) — correlation must pick entryB instead.
+  m.ingestFrame([makePad(0, DS4_ID, { buttons: { 1: true } })], 1000);
+
+  const p1 = m.getSlot('P1');
+  assert.equal(p1.state, 'claimed');
+  assert.equal(p1._hidEntry, entryB, 'seat must bind the unit that is actually pressing');
+  assert.equal(m._hidPool.has(devA), true, 'the other unit stays pooled');
+  assert.equal(m._hidPool.has(devB), false, 'bound unit left the pool');
+});
+
+test('two identical units → two seats, each bound to its own handle (cascade)', () => {
+  const m = new ControllerManager({ slotIds: ['P1', 'P2'] });
+  const devA = ds4Device(), devB = ds4Device();
+  const entryA = fakeEntry(devA), entryB = fakeEntry(devB);
+  m._hidPool.set(devA, entryA);
+  m._hidPool.set(devB, entryB);
+  press(entryA, 0);   // device A holds cross
+  press(entryB, 3);   // device B holds triangle
+
+  m.ingestFrame([
+    makePad(0, DS4_ID, { buttons: { 0: true } }),   // A's pad
+    makePad(1, DS4_ID, { buttons: { 3: true } }),   // B's pad
+  ], 1000);
+
+  assert.equal(m.getSlot('P1')._hidEntry, entryA, 'P1 (cross) → device A');
+  assert.equal(m.getSlot('P2')._hidEntry, entryB, 'P2 (triangle) → device B');
+  assert.equal(m._hidPool.size, 0, 'both units bound');
+});
+
+test('IMU-only handle (GameSir) binds by identity, not cross-wired to an idle phantom', () => {
+  const m = new ControllerManager({ slotIds: ['P1', 'P2'] });
+  // GameSir spoofs 054c:0ce6 to the Gamepad API but its WebHID handle is an
+  // IMU-only 054c:09cc ("Wireless Controller"). An idle real DualSense (0ce6)
+  // is also pooled (auto-pooled because the spoofed 0ce6 pad looked "live").
+  const gamesirHid = { vendorId: 0x054c, productId: 0x09cc, productName: 'Wireless Controller' };
+  const phantomDS = { vendorId: 0x054c, productId: 0x0ce6, productName: 'DualSense Wireless Controller' };
+  const gsEntry = fakeEntry(gamesirHid); gsEntry.hasButtons = false;   // gyro-only spoof interface
+  const dsEntry = fakeEntry(phantomDS); dsEntry.hasButtons = true; dsEntry._everPressed = true;  // a real DualSense that HAS been used
+  m._hidPool.set(gamesirHid, gsEntry);
+  m._hidPool.set(phantomDS, dsEntry);
+
+  // Seat claims via the GameSir's Gamepad pad (enumerates as DualSense 0ce6).
+  const pad = makePad(0, 'DualSense Wireless Controller (STANDARD GAMEPAD Vendor: 054c Product: 0ce6)', { buttons: { 0: true } });
+  m.ingestFrame([pad], 1000);
+
+  const p1 = m.getSlot('P1');
+  assert.equal(p1.state, 'claimed');
+  assert.equal(p1._hidEntry, gsEntry, 'binds the GameSir IMU-only gyro handle');
+  assert.equal(m._hidPool.has(phantomDS), true, 'the idle phantom DualSense is NOT bound');
+});
+
+test('HID-pool claim fires on fresh stick input (DualSense-BT: invisible to the Gamepad API)', () => {
+  const m = new ControllerManager({ slotIds: ['P1'] });
+  const dev = { vendorId: 0x054c, productId: 0x0ce6, productName: 'DualSense Wireless Controller' };
+  const entry = fakeEntry(dev);
+  entry.hasFreshInput = () => true;   // a stick nudge (lights the dot) — no face-button press
+  m._hidPool.set(dev, entry);
+
+  // No Gamepad pads: a DualSense over BT in 0x31 mode has none, so its only
+  // path to ACTIVE is the WebHID claim.
+  m.ingestFrame([], 1000);
+
+  assert.equal(m.getSlot('P1').state, 'claimed', 'claims via HID on fresh stick input, not just a button');
+  assert.equal(m.getSlot('P1')._hidEntry, entry);
+});
+
+test('a WebHID-claimed slot adopts its own Gamepad pad instead of leaving a phantom seat', () => {
+  const m = new ControllerManager({ slotIds: ['P1', 'P2'] });
+  const p1 = m.getSlot('P1');
+  const dev = { vendorId: 0x054c, productId: 0x05c4, productName: 'Wireless Controller' };
+  // Simulate a WebHID-first claim: a DS4 that seated via its HID handle (its
+  // synthetic carries buttons now), so gamepadIndex is still null.
+  p1.claim({ index: -1, id: 'HID::Wireless Controller Vendor: 054c Product: 05c4', mapping: 'standard' }, { silent: true });
+  m._attachEntryToSlot(p1, fakeEntry(dev));
+  assert.equal(p1.gamepadIndex, null, 'precondition: WebHID-claimed, no Gamepad pad yet');
+
+  // That device's Gamepad-API pad (same vid:pid) shows up.
+  const pad = makePad(0, 'Wireless Controller (STANDARD GAMEPAD Vendor: 054c Product: 05c4)');
+  m.ingestFrame([pad], 1000);
+
+  assert.equal(p1.gamepadIndex, 0, 'pad adopted into the WebHID-claimed slot');
+  assert.equal(m.getSlot('P2').state, 'empty', 'no second (phantom) seat for the same physical device');
+});
+
+test('windowed fold: a claiming press split across frames (pad first, HID a frame later) still folds', () => {
+  const m = new ControllerManager({ slotIds: ['P1'] });
+  const a = { vendorId: 0x054c, productId: 0x0ce6, productName: 'DualSense Wireless Controller' };
+  const b = { vendorId: 0x054c, productId: 0x0ce6, productName: 'DualSense Wireless Controller' };
+  const eA = fakeEntry(a), eB = fakeEntry(b);
+  m._hidPool.set(a, eA); m._hidPool.set(b, eB);
+
+  // Frame 1: the Gamepad pad presses button 2 and claims; neither HID stream
+  // shows it yet (report lands a frame later). A same-frame match would miss.
+  m.ingestFrame([makePad(0, DS5_ID, { buttons: { 2: true } })], 1000);
+  const p1 = m.getSlot('P1');
+  assert.equal(p1.state, 'claimed');
+  assert.equal(p1._hidEntry, null, 'no fold yet — HID stream has not shown the press');
+
+  // Frame 2 (within foldWindowMs): unit A now reports the same button; pad released.
+  press(eA, 2);
+  m.ingestFrame([makePad(0, DS5_ID)], 1150);
+  assert.equal(p1._hidEntry, eA, 'folds once the HID press lands within the window');
+});
+
+test('ambiguous input defers instead of cross-wiring, then resolves on a distinct press', () => {
+  const m = new ControllerManager({ slotIds: ['P1', 'P2'] });
+  const devA = ds4Device(), devB = ds4Device();
+  const entryA = fakeEntry(devA), entryB = fakeEntry(devB);
+  m._hidPool.set(devA, entryA);
+  m._hidPool.set(devB, entryB);
+
+  // Frame 1: seat claims on a button, but NEITHER unit's stream shows it yet
+  // (HID lag). The old code would have bound entryA (first match) — we must
+  // NOT, or we risk cross-wiring.
+  const pad = makePad(0, DS4_ID, { buttons: { 0: true } });
+  m.ingestFrame([pad], 1000);
+  const p1 = m.getSlot('P1');
+  assert.equal(p1.state, 'claimed');
+  assert.equal(p1._hidEntry, null, 'must defer while it cannot tell the units apart');
+
+  // Frame 2: device B's report stream now shows the held button → resolve.
+  press(entryB, 0);
+  m.ingestFrame([pad], 1016);
+  assert.equal(p1._hidEntry, entryB, 'binds the correlated unit once input disambiguates');
+});
diff --git a/packages/core/test/manager-electron-auto-request.test.js b/packages/core/test/manager-electron-auto-request.test.js
new file mode 100644
index 0000000..4781c6e
--- /dev/null
+++ b/packages/core/test/manager-electron-auto-request.test.js
@@ -0,0 +1,39 @@
+// ============================================================
+// ControllerManager.electronAutoRequestDevice — deprecated no-op (#101)
+// ============================================================
+//
+// Auto-pairing not-yet-approved devices at boot is impossible: WebHID
+// requestDevice() needs transient user activation, so a fire-and-forget boot
+// call threw "Must be handling a user gesture" and pooled nothing. The method
+// is now a no-op (kept for downstream/synced callers). This locks that it
+// neither throws nor calls requestDevice, so the broken boot loop can't creep
+// back in. Approved devices pool via autoPoolApprovedHid(); new ones pair via
+// connectHidForSlot() from a user gesture.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ControllerManager } from '../src/manager.js';
+
+test('electronAutoRequestDevice is a no-op: never calls requestDevice at boot', async () => {
+  const mgr = new ControllerManager({ slotIds: ['P1', 'P2'] });
+
+  let requestCalls = 0;
+  // navigator is a read-only getter in modern Node — override via defineProperty.
+  const orig = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
+  Object.defineProperty(globalThis, 'navigator', {
+    configurable: true,
+    value: { hid: { requestDevice: async () => { requestCalls++; return []; } } },
+  });
+  try {
+    await assert.doesNotReject(
+      () => mgr.electronAutoRequestDevice(),
+      'must not throw the "requires a user gesture" error at boot',
+    );
+    assert.strictEqual(requestCalls, 0, 'must not call navigator.hid.requestDevice (no boot gesture)');
+    assert.strictEqual(mgr._hidPool.size, 0, 'pools nothing');
+  } finally {
+    if (orig) Object.defineProperty(globalThis, 'navigator', orig);
+    else delete globalThis.navigator;
+  }
+});
diff --git a/packages/core/test/manager-hid-reconcile.test.js b/packages/core/test/manager-hid-reconcile.test.js
index 14ca96f..bde6b0d 100644
--- a/packages/core/test/manager-hid-reconcile.test.js
+++ b/packages/core/test/manager-hid-reconcile.test.js
@@ -47,6 +47,7 @@ function fakeEntry(device) {
     hidActiveSince: 0,
     slot: null,
     hasFreshButtonPress() { return false; },
+    hasFreshInput() { return false; },
     destroy() {},
   };
 }
diff --git a/packages/core/test/manager-pool-liveness.test.js b/packages/core/test/manager-pool-liveness.test.js
new file mode 100644
index 0000000..ac67106
--- /dev/null
+++ b/packages/core/test/manager-pool-liveness.test.js
@@ -0,0 +1,58 @@
+// ============================================================
+// ControllerManager — phantom HID eviction (pool liveness)
+// ============================================================
+//
+// A spoofing pad (GameSir Super Nova presenting DualSense 054c:0ce6 to the
+// Gamepad API) makes autoPoolApprovedHid pull in OTHER approved same-vid:pid
+// handles that aren't physically present. Silent, they bloat per-frame cost
+// and confound same-id binding. ingestFrame evicts a pooled handle that has
+// never streamed a raw report past the probation window; a present controller
+// (which streams within tens of ms) is kept.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ControllerManager, makeSyntheticGamepad } from '../src/manager.js';
+
+const dev = (pid, name = 'X') => ({ vendorId: 0x054c, productId: pid, productName: name });
+function fakeEntry(device, { pooledAt = 0, lastRawReportAt = 0 } = {}) {
+  return {
+    device, driver: null, fusion: { startCalibration() {}, ingest() {} },
+    synthetic: makeSyntheticGamepad(device), hasButtons: false, hidActiveSince: 0,
+    pooledAt, lastRawReportAt, slot: null,
+    hasFreshButtonPress() { return false; }, hasFreshInput() { return false; }, destroy() {},
+  };
+}
+
+test('evicts a pooled handle that never streams past the probation window', () => {
+  const m = new ControllerManager({ slotIds: ['P1'] });
+  const d = dev(0x0ce6, 'DualSense Wireless Controller');
+  m._hidPool.set(d, fakeEntry(d, { pooledAt: 1000, lastRawReportAt: 0 }));
+  m.ingestFrame([], 1000 + m.opts.poolProbationMs + 100);
+  assert.equal(m._hidPool.has(d), false, 'silent phantom evicted');
+});
+
+test('keeps a pooled handle that has streamed a report', () => {
+  const m = new ControllerManager({ slotIds: ['P1'] });
+  const d = dev(0x0ce6, 'DualSense Wireless Controller');
+  m._hidPool.set(d, fakeEntry(d, { pooledAt: 1000, lastRawReportAt: 1200 }));
+  m.ingestFrame([], 1000 + m.opts.poolProbationMs + 100);
+  assert.equal(m._hidPool.has(d), true, 'present/streaming device kept');
+});
+
+test('keeps a freshly-pooled silent handle inside the grace window', () => {
+  const m = new ControllerManager({ slotIds: ['P1'] });
+  const d = dev(0x09cc, 'Wireless Controller');
+  m._hidPool.set(d, fakeEntry(d, { pooledAt: 1000, lastRawReportAt: 0 }));
+  m.ingestFrame([], 1500);   // still inside probation
+  assert.equal(m._hidPool.has(d), true, 'not evicted before probation elapses');
+});
+
+test('test doubles without a numeric pooledAt are never swept', () => {
+  const m = new ControllerManager({ slotIds: ['P1'] });
+  const d = dev(0x0ce6);
+  const e = fakeEntry(d); delete e.pooledAt;   // legacy/minimal double
+  m._hidPool.set(d, e);
+  m.ingestFrame([], 999999);
+  assert.equal(m._hidPool.has(d), true, 'entries without pooledAt are left alone');
+});
diff --git a/packages/core/test/manager-release-slot.test.js b/packages/core/test/manager-release-slot.test.js
new file mode 100644
index 0000000..722b8d4
--- /dev/null
+++ b/packages/core/test/manager-release-slot.test.js
@@ -0,0 +1,46 @@
+// ============================================================
+// ControllerManager — releaseSlotToPool (lobby "leave" / B)
+// ============================================================
+//
+// The lobby's two-step B (ready → unready → leave seat) needs a public
+// seat-release. releaseSlotToPool empties the seat and arms the same
+// await-silence + reclaim cooldown as the PS/Home hold gesture, so the
+// still-connected controller doesn't instantly re-grab the seat it just left.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { ControllerManager } from '../src/manager.js';
+
+const ID = 'Wireless Controller (STANDARD GAMEPAD Vendor: 054c Product: 09cc)';
+
+function makePad(index, id, { buttons = {} } = {}) {
+  const btns = [];
+  for (let i = 0; i < 17; i++) btns.push({ pressed: false, touched: false, value: 0 });
+  for (const [i, v] of Object.entries(buttons)) { btns[i].pressed = !!v; btns[i].value = v ? 1 : 0; }
+  return { index, id, mapping: 'standard', connected: true, timestamp: 0, buttons: btns, axes: [0, 0, 0, 0] };
+}
+
+test('releaseSlotToPool frees a claimed seat and blocks instant re-claim', () => {
+  const m = new ControllerManager({ slotIds: ['P1', 'P2'] });
+  const p1 = m.getSlot('P1');
+  m.ingestFrame([makePad(0, ID, { buttons: { 0: true } })], 1000);
+  assert.equal(p1.state, 'claimed', 'precondition: seated');
+
+  assert.equal(m.releaseSlotToPool('P1', 1100), true);
+  assert.equal(p1.state, 'empty', 'seat emptied');
+
+  // Still-held controller must NOT immediately re-claim (await-silence + cooldown).
+  m.ingestFrame([makePad(0, ID, { buttons: { 0: true } })], 1116);
+  assert.equal(p1.state, 'empty', 'held controller does not re-grab the seat it just left');
+
+  // Goes idle (clears await-silence), then a fresh press past the cooldown re-seats.
+  m.ingestFrame([makePad(0, ID)], 1200);
+  m.ingestFrame([makePad(0, ID, { buttons: { 0: true } })], 3000);
+  assert.equal(p1.state, 'claimed', 're-claims after silence + reclaim cooldown');
+});
+
+test('releaseSlotToPool is a no-op on an empty slot', () => {
+  const m = new ControllerManager({ slotIds: ['P1'] });
+  assert.equal(m.releaseSlotToPool('P1'), false);
+});
diff --git a/packages/core/test/playstation-bt-handshake.test.js b/packages/core/test/playstation-bt-handshake.test.js
new file mode 100644
index 0000000..c54ff79
--- /dev/null
+++ b/packages/core/test/playstation-bt-handshake.test.js
@@ -0,0 +1,62 @@
+// ============================================================
+// PlayStationDriver — Bluetooth full-report activation handshake (#101)
+// ============================================================
+//
+// Over BT the DualSense/DS4 start in compatibility mode (report 0x01, no IMU);
+// reading a family feature report (DS5 0x05 / DS4 0x02) flips them to the full
+// IMU report (0x31 / 0x11). On a still-negotiating hot-plug link that read
+// THROWS, and the old code still waited ~450ms per attempt for a report that
+// couldn't come — ~2s of dead init that serialized subsequent pool loads.
+// These lock the hardened behavior: a thrown read skips the wait and fails
+// fast, an accepted read + full report activates, and the background loop
+// nudges immediately instead of idling a full interval.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { PlayStationDriver } from '../src/drivers/playstation-driver.js';
+
+function mockBtDS({ readRejects = false } = {}) {
+  const listeners = new Map();
+  return {
+    vendorId: 0x054c, productId: 0x0ce6, opened: true, collections: [],
+    reads: 0,
+    addEventListener(type, fn) { if (!listeners.has(type)) listeners.set(type, new Set()); listeners.get(type).add(fn); },
+    removeEventListener(type, fn) { listeners.get(type)?.delete(fn); },
+    async receiveFeatureReport() { this.reads++; if (readRejects) throw new Error('Failed to receive the feature report'); },
+    _emit(type, ev) { for (const fn of (listeners.get(type) || [])) fn(ev); },
+  };
+}
+
+test('BT activation: a thrown feature read skips the wait and fails fast', async () => {
+  const dev = mockBtDS({ readRejects: true });
+  let waited = false;
+  const origAdd = dev.addEventListener.bind(dev);
+  dev.addEventListener = (type, fn) => { if (type === 'inputreport') waited = true; origAdd(type, fn); };
+
+  const drv = new PlayStationDriver(dev, 'bluetooth', { mode: 'ds5' });
+  // perAttemptMs is huge on purpose — if the wait ran, this test would hang.
+  const active = await drv._activateFullReportMode(0x05, { attempts: 3, perAttemptMs: 5000 });
+
+  assert.strictEqual(active, false, 'no full report → not active');
+  assert.strictEqual(waited, false, 'a thrown read must not enter the perAttemptMs wait');
+  assert.strictEqual(dev.reads, 3, 'still re-issues the activating read each attempt');
+});
+
+test('BT activation: accepted read + full report (0x31) → active', async () => {
+  const dev = mockBtDS({ readRejects: false });
+  const drv = new PlayStationDriver(dev, 'bluetooth', { mode: 'ds5' });
+  const p = drv._activateFullReportMode(0x05, { attempts: 1, perAttemptMs: 2000 });
+  setTimeout(() => dev._emit('inputreport', { reportId: 0x31 }), 15);
+  assert.strictEqual(await p, true, 'full report during the wait → active');
+});
+
+test('BT background re-activation nudges immediately, before the first interval', async () => {
+  const dev = mockBtDS({ readRejects: false });
+  const drv = new PlayStationDriver(dev, 'bluetooth', { mode: 'ds5' });
+  const p = drv._startBackgroundReactivation(0x05, { intervalMs: 10000, maxMs: 60000 });
+  await new Promise((r) => setTimeout(r, 40)); // « intervalMs: only an immediate nudge could fire
+  assert.ok(dev.reads >= 1, 'fired an immediate read without idling a full interval');
+  dev._emit('inputreport', { reportId: 0x31 }); // flip the stream so the loop finishes + clears its timer
+  assert.strictEqual(await p, true);
+});
diff --git a/packages/core/test/playstation-driver.test.js b/packages/core/test/playstation-driver.test.js
index 703abda..ef4ccff 100644
--- a/packages/core/test/playstation-driver.test.js
+++ b/packages/core/test/playstation-driver.test.js
@@ -11,7 +11,7 @@ import assert from 'node:assert/strict';
 
 import { PlayStationDriver } from '../src/drivers/playstation-driver.js';
 import { ControllerDriver } from '../src/drivers/base-driver.js';
-import { buildPSReport, buildDs4BtReport, dataView } from './helpers.js';
+import { buildPSReport, buildDs4BtReport, buildDs4Report, dataView } from './helpers.js';
 
 const approx = (a, b, eps = 1e-9) =>
   assert.ok(Math.abs(a - b) <= eps, `expected ${a} ≈ ${b}`);
@@ -93,31 +93,47 @@ test('report-id / connection gating', () => {
   assert.equal(drv('bluetooth', { mode: 'ds4' }).parseReport(0x01, data), null);
 });
 
-test('DS4 emits IMU-only (no buttons/sticks/triggers/touchpad) so the Gamepad API wins', () => {
+test('DS4 USB: buttons/sticks/triggers parse at the DS4 offsets (+4/+5/+6, +7/+8)', () => {
   const d = drv('usb', { mode: 'ds4' });
-  const { data } = buildPSReport({
-    mode: 'ds4',
-    faceByte: DPAD_NEUTRAL | CROSS, l2: 200,
+  const { data } = buildDs4Report({
+    lx: 0, ly: 255, rx: 128, ry: 128,       // lx full-left, ly full-down
+    l2: 200,
+    faceByte: DPAD_NEUTRAL | CROSS,          // cross, dpad neutral
+    shoulderByte: 0x01 | 0x20,               // L1 + options
+    sysByte: 0x01,                           // PS
     gyro: { x: 1, y: 2, z: 3 }, accel: { x: 0, y: 0, z: 8192 },
   });
   const p = d.parseReport(0x01, data);
+  assert.ok(p);
+  approx(p.sticks.lx, -1);
+  approx(p.sticks.ly, (255 - 128) / 128);
+  approx(p.triggers.l2, 200 / 255);
+  assert.equal(p.buttons.cross, true);
+  assert.equal(p.buttons.square, false);
+  assert.equal(p.buttons.l1, true);
+  assert.equal(p.buttons.options, true);
+  assert.equal(p.buttons.ps, true);
+  assert.equal(p.buttons.dpadUp, false);      // dpad neutral (hat 8)
   assert.deepEqual(p.gyro, { x: 1, y: 2, z: 3 });
   assert.deepEqual(p.accel, { x: 0, y: 0, z: 8192 });
-  // Deliberately omitted for DS4 — these come from the Gamepad API.
-  assert.equal(p.buttons, undefined);
-  assert.equal(p.sticks, undefined);
-  assert.equal(p.triggers, undefined);
-  assert.equal(p.touchpad, undefined);
 });
 
-test('DS4 Bluetooth report 0x11 parses IMU at the +2 (baseOffset 2) offset', () => {
+test('DS4 Bluetooth report 0x11: IMU at +2 AND buttons at the DS4 offsets', () => {
   const d = drv('bluetooth', { mode: 'ds4' });
-  const { data } = buildDs4BtReport({ gyro: { x: 5, y: -6, z: 7 }, accel: { x: 0, y: 0, z: 8192 } });
+  const { data } = buildDs4Report({
+    bt: true,
+    faceByte: DPAD_NEUTRAL | TRIANGLE,       // triangle, dpad neutral
+    shoulderByte: 0x02,                      // R1
+    gyro: { x: 5, y: -6, z: 7 }, accel: { x: 0, y: 0, z: 8192 },
+  });
   const p = d.parseReport(0x11, data);
-  assert.ok(p, 'DS4 BT 0x11 should now parse');
+  assert.ok(p, 'DS4 BT 0x11 should parse');
   assert.deepEqual(p.gyro, { x: 5, y: -6, z: 7 });
   assert.deepEqual(p.accel, { x: 0, y: 0, z: 8192 });
-  assert.equal(p.buttons, undefined); // IMU-only for DS4
+  assert.equal(p.buttons.triangle, true);
+  assert.equal(p.buttons.cross, false);
+  assert.equal(p.buttons.r1, true);
+  assert.equal(p.buttons.dpadUp, false);
 });
 
 test('detectConnectionType: DS4 BT (input 0x11) vs USB (0x11 only as feature)', () => {
diff --git a/packages/core/test/steam-controller-lizard-owner.test.js b/packages/core/test/steam-controller-lizard-owner.test.js
new file mode 100644
index 0000000..81b5a82
--- /dev/null
+++ b/packages/core/test/steam-controller-lizard-owner.test.js
@@ -0,0 +1,67 @@
+// ============================================================
+// SteamControllerDriver — Puck lizard-mode owner election (#101)
+// ============================================================
+//
+// The Puck exposes 5 HID interfaces sharing vid:pid; the manager pools each
+// as its own driver instance. init() must elect a SINGLE lizard-mode owner
+// (probe + 800ms heartbeat). The owner already broadcasts CLEAR to all five
+// siblings, so running init on every instance was 5x redundant SET_REPORT
+// churn (the NotAllowedError storm that janked the renderer ~4s). These lock
+// "exactly one heartbeat timer" and "ownership is released on destroy".
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { SteamControllerDriver } from '../src/drivers/steam-controller-driver.js';
+
+const PUCK_PID = 0x1304;
+const key = (d) => `${d.vendorId}:${d.productId}`;
+
+// Minimal Puck HID interface. All instances share vid:pid, as the 5 real
+// interfaces do. No navigator.hid in the test env, so _candidatePuckDevices
+// resolves to just [this.device] — which is all the election test needs.
+function mockPuckDevice() {
+  return {
+    vendorId: 0x28de, productId: PUCK_PID, productName: 'Steam Controller Puck',
+    opened: true,
+    collections: [{
+      usagePage: 0xff00, usage: 0x0001,
+      featureReports: [{ reportId: 0x01, items: [{ reportSize: 8, reportCount: 64 }] }],
+    }],
+    async open() { this.opened = true; },
+    async sendFeatureReport() { /* accept the CLEAR / SET_SETTINGS */ },
+  };
+}
+
+test('Puck: exactly one interface owns the lizard-mode heartbeat (no 5x churn)', async () => {
+  SteamControllerDriver._lizardOwners.clear();
+  const drivers = Array.from({ length: 5 }, () => new SteamControllerDriver(mockPuckDevice(), 'usb', null));
+  try {
+    for (const drv of drivers) await drv.init();
+    const withTimer = drivers.filter((d) => d._lizardTimer != null);
+    assert.strictEqual(withTimer.length, 1, 'one heartbeat timer across all 5 interfaces');
+  } finally {
+    for (const drv of drivers) drv.destroy();
+  }
+});
+
+test('Puck: destroying the owner releases ownership so a fresh connect re-elects', async () => {
+  SteamControllerDriver._lizardOwners.clear();
+  const a = new SteamControllerDriver(mockPuckDevice(), 'usb', null);
+  const b = new SteamControllerDriver(mockPuckDevice(), 'usb', null);
+  try {
+    await a.init();
+    await b.init();
+    assert.ok(a._lizardTimer && !b._lizardTimer, 'a owns, b skips');
+
+    a.destroy();
+    assert.strictEqual(SteamControllerDriver._lizardOwners.get(key(a.device)), undefined, 'ownership released on destroy');
+
+    const c = new SteamControllerDriver(mockPuckDevice(), 'usb', null);
+    await c.init();
+    assert.ok(c._lizardTimer, 'a fresh instance re-elects as owner after the previous owner was destroyed');
+    c.destroy();
+  } finally {
+    b.destroy();
+  }
+});
diff --git a/packages/core/test/switch-pro-driver.test.js b/packages/core/test/switch-pro-driver.test.js
new file mode 100644
index 0000000..5412c26
--- /dev/null
+++ b/packages/core/test/switch-pro-driver.test.js
@@ -0,0 +1,69 @@
+// ============================================================
+// SwitchProDriver.parseReport — button / stick / trigger mapping
+// ============================================================
+//
+// Locks the report 0x30 button+stick decode added for the WebHID-first path
+// (previously the Switch Pro's inputs came ONLY from the Gamepad API, leaving an
+// all-WebHID session gyro-only). Nintendo's rotated face layout maps into the
+// standard cross/circle/square/triangle slots — a bit-swap regression trips here.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { SwitchProDriver } from '../src/drivers/switch-pro-driver.js';
+
+const approx = (a, b, eps = 0.02) =>
+  assert.ok(Math.abs(a - b) <= eps, `expected ${a} ≈ ${b}`);
+
+const drv = () => new SwitchProDriver({ opened: true, collections: [] }, 'usb', null);
+
+// Build a report 0x30 DataView (excludes the report id). 48 bytes = BT size.
+function build0x30({ b2 = 0, b3 = 0, b4 = 0, ls = [0x800, 0x800], rs = [0x800, 0x800] } = {}) {
+  const buf = new Uint8Array(48);
+  buf[2] = b2; buf[3] = b3; buf[4] = b4;
+  const pack = (o, x, y) => {
+    buf[o] = x & 0xFF;
+    buf[o + 1] = ((x >> 8) & 0x0F) | ((y & 0x0F) << 4);
+    buf[o + 2] = (y >> 4) & 0xFF;
+  };
+  pack(5, ls[0], ls[1]);
+  pack(8, rs[0], rs[1]);
+  return new DataView(buf.buffer);
+}
+
+test('Switch Pro: Nintendo face layout → standard slots (B=cross, A=circle, Y=square, X=triangle)', () => {
+  const d = drv();
+  assert.equal(d.parseReport(0x30, build0x30({ b2: 0x04 })).buttons.cross, true);    // B → bottom
+  assert.equal(d.parseReport(0x30, build0x30({ b2: 0x08 })).buttons.circle, true);   // A → right
+  assert.equal(d.parseReport(0x30, build0x30({ b2: 0x01 })).buttons.square, true);   // Y → left
+  assert.equal(d.parseReport(0x30, build0x30({ b2: 0x02 })).buttons.triangle, true); // X → top
+  // A pressed must NOT also flag cross (the classic Nintendo swap bug).
+  const a = d.parseReport(0x30, build0x30({ b2: 0x08 }));
+  assert.equal(a.buttons.cross, false);
+});
+
+test('Switch Pro: shoulders, ZL/ZR digital triggers, system + dpad', () => {
+  const d = drv();
+  assert.equal(d.parseReport(0x30, build0x30({ b2: 0x40 })).buttons.r1, true);  // R
+  assert.equal(d.parseReport(0x30, build0x30({ b4: 0x40 })).buttons.l1, true);  // L
+  assert.equal(d.parseReport(0x30, build0x30({ b2: 0x80 })).triggers.r2, 1);    // ZR digital
+  assert.equal(d.parseReport(0x30, build0x30({ b4: 0x80 })).triggers.l2, 1);    // ZL digital
+  assert.equal(d.parseReport(0x30, build0x30({ b3: 0x10 })).buttons.ps, true);       // Home
+  assert.equal(d.parseReport(0x30, build0x30({ b3: 0x01 })).buttons.create, true);   // Minus
+  assert.equal(d.parseReport(0x30, build0x30({ b3: 0x02 })).buttons.options, true);  // Plus
+  assert.equal(d.parseReport(0x30, build0x30({ b3: 0x08 })).buttons.l3, true);       // L-stick
+  assert.equal(d.parseReport(0x30, build0x30({ b3: 0x04 })).buttons.r3, true);       // R-stick
+  assert.equal(d.parseReport(0x30, build0x30({ b4: 0x02 })).buttons.dpadUp, true);
+  assert.equal(d.parseReport(0x30, build0x30({ b4: 0x01 })).buttons.dpadDown, true);
+});
+
+test('Switch Pro: sticks normalize to [-1,1] with Gamepad-API Y inversion', () => {
+  const d = drv();
+  const center = d.parseReport(0x30, build0x30({ ls: [0x800, 0x800], rs: [0x800, 0x800] }));
+  approx(center.sticks.lx, 0); approx(center.sticks.ly, 0);
+  approx(center.sticks.rx, 0); approx(center.sticks.ry, 0);
+  // Left stick physical X full → +1; physical Y full → ly negated to -1.
+  const pushed = d.parseReport(0x30, build0x30({ ls: [0x800 + 0x5A8, 0x800 + 0x5A8] }));
+  approx(pushed.sticks.lx, 1);
+  approx(pushed.sticks.ly, -1);
+});