diff --git a/arena_studio.html b/arena_studio.html
index 126d66e1..160890d6 100644
--- a/arena_studio.html
+++ b/arena_studio.html
@@ -2548,6 +2548,7 @@ <h4>Auto-captured</h4>
           <div>sha256: <span class="sha" id="pvSha">—</span></div>
           <div>arena: <b id="pvArena">—</b> · rig: <b id="pvRig">—</b></div>
           <div>firmware: <b id="pvFw">—</b></div>
+          <div>panels: <b id="pvPanels" title="Which panels answered when the arena connected and the firmware fingerprint (CRC-32) each one runs. Recorded in the run log as panels.">—</b></div>
           <div>controller: <b id="pvCtl" title="Physical-setup identity — the controller's Ethernet MAC, derived from the Teensy's burned-in unique ID. Recorded in the run log as controller_id.">—</b></div>
           <div>run_id: <b id="pvRunId">— (assigned at run start)</b></div>
         </div>
@@ -3047,6 +3048,10 @@ <h2 id="modalTitle">Import error</h2>
             <input id="cFwAddr" type="number" min="1" value="1" style="width:56px" title="panel address (1-based)">
             <button class="pill danger" data-cmd="cfwflash" title="Program one panel from /firmware/panel.bin over SPI ISP (0xC8) — ~20 s, do NOT power off">Flash</button>
             <button class="pill" data-cmd="cfwverify" title="CRC the panel's running app flash vs the SD footer (0xC9)">Verify</button></div>
+          <div class="crow"><span class="lbl">fleet</span>
+            <button class="pill" data-cmd="cinv" title="GET_PANEL_INVENTORY 0xD1 — which panels answered at boot and the firmware fingerprint (CRC-32) each one runs; reads it again now (firmware with feature bit 0 only)">Inventory</button>
+            <button class="pill" data-cmd="cinvscan" title="PANEL_INVENTORY_SCAN 0xD0 action 1 — re-probe every panel and fingerprint them afresh (stops the display first); the result lands a few seconds later">Rescan</button>
+            <span class="dim" id="cInvSum"></span></div>
           <div class="crow" style="border-top:1px dashed var(--border);padding-top:9px;margin-bottom:0"><span class="lbl">batch</span>
             <input id="cIspRange" type="text" value="1-20" style="width:86px" title="Panels to program: a range/list like 1-20 or 1,3,5-8">
             <label title="Verify each panel's CRC (0xC9) right after flashing; the report marks verified vs flashed-only"><input type="checkbox" id="cIspVerify" checked> verify each</label>
@@ -3159,6 +3164,7 @@ <h2 id="modalTitle">Import error</h2>
 <!-- ============================================================ -->
 <script src="js/arena-wire-g6.js"></script>
 <script src="js/studio-analog-in.js"></script>
+<script src="js/studio-panel-inventory.js"></script>
 <script src="js/arena-link.js"></script>
 <script src="js/arena-runner-g6.js?v=20260926-cl-start"></script> <!-- ?v= forces a fresh load: a cached runner/client silently runs the old closed-loop start -->
 <script src="js/run-log.js"></script>
@@ -4009,6 +4015,61 @@ <h2 id="modalTitle">Import error</h2>
         return null;
     };
 
+    // Panel inventory (fw #59, GET_PANEL_INVENTORY 0xD1): which panels answered and
+    // the firmware fingerprint each one runs, read at every link-up → provenance
+    // box + run_metadata.panels. Gated on the 0xC2 feature bit `panel_inventory`
+    // (older firmware answers 0xD1 with CE_UNKNOWN_CMD and an error glyph). The
+    // boot fingerprint sweep may still be running right after a reset, so a read
+    // that says "in progress" schedules one follow-up read.
+    // `Studio.panels` is never left stale: it is cleared before every read, on a
+    // failed read and on disconnect, and `Studio.panelsStatus` says why it is
+    // null ('unsupported' | 'failed' | 'disconnected') or how to read it
+    // ('ok' | 'pending'). runOnce() re-reads it right before startRunLog() so
+    // run_metadata.panels is a run-start snapshot, not connect-time state.
+    Studio.panels = null; // StudioPanelInventory.summarize() result, or null
+    Studio.panelsStatus = 'disconnected';
+    Studio.scheduleInventoryFollowUp = function (ms) {
+        if (Studio._panelsFollowUp) clearTimeout(Studio._panelsFollowUp);
+        Studio._panelsFollowUp = setTimeout(() => {
+            Studio._panelsFollowUp = null;
+            if (Studio.session && Studio.session.connected && !Studio.session.running) Studio.refreshPanelInventory();
+        }, ms);
+    };
+    Studio.refreshPanelInventory = async function (opts) {
+        const quiet = !!(opts && opts.quiet);
+        const PI = window.StudioPanelInventory;
+        const feats = Studio.features || [];
+        const has = feats.includes('panel_inventory');
+        Studio.panels = null;
+        if (!Studio.session || !Studio.session.connected || !PI || !has) {
+            Studio.panelsStatus = !Studio.session || !Studio.session.connected ? 'disconnected' : 'unsupported';
+            if ($('pvPanels')) $('pvPanels').textContent = has ? '—' : '— (firmware without panel inventory)';
+            return null;
+        }
+        try {
+            const inv = PI.summarize(await PI.readAll((b, o) => Studio.session.send(b, o)));
+            Studio.panels = inv;
+            Studio.panelsStatus = inv.presenceValid ? 'ok' : 'pending';
+            const label = PI.describe(inv);
+            const worry = inv.missing.length > 0 || inv.mismatched.length > 0;
+            if ($('pvPanels')) {
+                $('pvPanels').textContent = label;
+                $('pvPanels').title = 'GET_PANEL_INVENTORY 0xD1 · scan ' + inv.scanId + ' · ' + inv.flagNames.join(' ') +
+                    (inv.mismatched.length ? ' · check panels ' + inv.mismatched.join(', ') : '');
+            }
+            if ($('cInvSum')) $('cInvSum').textContent = label;
+            if (!quiet) rawLine('‹ panels: ' + label, worry ? 'warn' : 'info');
+            if (inv.fpInProgress || !inv.presenceValid) Studio.scheduleInventoryFollowUp(4000);
+            return inv;
+        } catch (e) {
+            Studio.panelsStatus = 'failed';
+            if ($('pvPanels')) $('pvPanels').textContent = '— (panel inventory read failed)';
+            if ($('cInvSum')) $('cInvSum').textContent = 'read failed';
+            rawLine('panel inventory: ' + (e && e.message ? e.message : e), 'warn');
+            return null;
+        }
+    };
+
     // ---- connection ----------------------------------------------------------
     async function toggleConnect() {
         if (!Studio.session) {
@@ -4031,15 +4092,18 @@ <h2 id="modalTitle">Import error</h2>
                     // Capability names (e.g. 'io_ext') — gates the rig-I/O
                     // role apply-path + Console readouts per connection.
                     Studio.capabilities = info.capabilities || [];
+                    Studio.features = info.features || []; // 0xC2 feature bitmap (panel_inventory, qwiic_i2c, …)
                     // Physical-setup identity (Teensy unique ID → Ethernet MAC);
                     // null until the firmware appends it to the 0xC2 reply.
                     Studio.controllerId = info.mac || null;
                     rawLine('‹ controller info: fw v' + info.version +
                         ' · caps [' + info.capabilities.join(', ') + ']' +
+                        (info.features && info.features.length ? ' · features [' + info.features.join(', ') + ']' : '') +
                         (info.mac ? ' · id ' + info.mac : ''), 'info');
                     const ctl = $('pvCtl');
                     if (ctl) ctl.textContent = Studio.controllerId || '— (needs fw with MAC in 0xC2)';
                     await Studio.refreshFirmwareVersion(); // build identity → run_metadata.firmware
+                    await Studio.refreshPanelInventory(); // which panels + their firmware → run_metadata.panels
                     if (Studio.initTelemetry) await Studio.initTelemetry(); // ring drain (T4) when the fw has it
                     // Un-grey the fw-gated rig-I/O roles now that caps are known
                     // (the role menu may have rendered before this reply landed).
@@ -5252,11 +5316,13 @@ <h2 id="modalTitle">Import error</h2>
                     const info = Wire.decodeControllerInfo(await Studio.session.send(Wire.encodeGetControllerInfo(), { timeoutMs: 2000 }));
                     if (info) {
                         Studio.capabilities = info.capabilities || [];
+                        Studio.features = info.features || [];
                         Studio.controllerId = info.mac || Studio.controllerId || null;
                         if (!Studio.firmware) Studio.firmware = 'v' + info.version;
                         if ($('pvCtl')) $('pvCtl').textContent = Studio.controllerId || '—';
                     }
                     await Studio.refreshFirmwareVersion();
+                    await Studio.refreshPanelInventory();
                     if (Studio.initTelemetry) await Studio.initTelemetry();
                     refreshState();
                 } catch (_) { /* best-effort: a wedged controller answers nothing */ }
@@ -5809,18 +5875,43 @@ <h2 id="modalTitle">Import error</h2>
             if (info) {
                 Studio.firmware = 'v' + info.version;
                 Studio.capabilities = info.capabilities || [];
+                Studio.features = info.features || [];
                 Studio.controllerId = info.mac || Studio.controllerId || null;
                 if ($('pvCtl')) $('pvCtl').textContent = Studio.controllerId || '— (needs fw with MAC in 0xC2)';
                 Studio.refreshState();
                 if (Studio.updateRigIoGating) Studio.updateRigIoGating(); // refresh fw-gated role options
                 clog('  fw v' + info.version + ' · caps [' + info.capabilities.join(', ') + ']' +
+                    (info.features && info.features.length ? ' · features [' + info.features.join(', ') + ']' : '') +
                     (info.mac ? ' · id ' + info.mac : ' · (no MAC in reply — older fw)'), 'info');
                 const fv = await Studio.refreshFirmwareVersion();
                 if (fv) clog('  build ' + fv.label, 'info');
                 else if ((info.capabilities || []).includes('health')) clog('  build: (no 0xCB reply)', 'warn');
                 else clog('  build: unknown — this firmware predates GET_FIRMWARE_VERSION (0xCB)', 'warn');
+                const inv = await Studio.refreshPanelInventory();
+                if (inv) clog('  panels: ' + window.StudioPanelInventory.describe(inv), inv.mismatched.length || inv.missing.length ? 'warn' : 'info');
             }
         },
+        // panel fleet inventory (fw #59, feature bit 0)
+        cinv: async () => {
+            if (!connected()) return;
+            if (!(Studio.features || []).includes('panel_inventory')) { clog('panel inventory: this firmware has no GET_PANEL_INVENTORY (0xC2 feature bit 0 clear)', 'warn'); return; }
+            const inv = await Studio.refreshPanelInventory();
+            if (!inv) return;
+            clog('  ' + window.StudioPanelInventory.describe(inv), inv.mismatched.length || inv.missing.length ? 'warn' : 'info');
+            if (inv.mismatched.length) clog('  check panels ' + inv.mismatched.join(', ') + (inv.refPresent ? ' (≠ /firmware/panel.bin)' : ' (fingerprint minority / no ISP reply)'), 'warn');
+            for (const f of inv.firmware) clog('  ' + f.hex + ' ×' + f.panels.length + ': panels ' + f.panels.join(', '), 'info');
+        },
+        cinvscan: () => guardDestructive(async () => {
+            // Stops the display (0xD0 needs ALL_OFF) — confirm-and-STOP like the other destructive actions.
+            if (!connected()) return;
+            if (!(Studio.features || []).includes('panel_inventory')) { clog('panel inventory: this firmware has no PANEL_INVENTORY_SCAN (0xC2 feature bit 0 clear)', 'warn'); return; }
+            await quiesceDisplay();
+            const r = await send(Wire.encodePanelInventoryScan(1), 'PANEL_INVENTORY_SCAN 0xD0 · presence + fingerprints', { timeoutMs: 10000, expectedCmd: Wire.OPCODES.PANEL_INVENTORY_SCAN });
+            const page0 = r && Wire.decodePanelInventory(r);
+            if (!page0) return;
+            if ($('cInvSum')) $('cInvSum').textContent = 'rescanning… (scan ' + page0.scanId + ')';
+            Studio.scheduleInventoryFollowUp(3000); // the sweep runs one panel per loop() pass; gated on connected + not running
+        }),
         ip: async () => { const r = await send(Wire.encodeGetIp(), 'GET_ETHERNET_IP 0xC1'); const ip = r && Wire.decodeIp && Wire.decodeIp(r); if (ip) clog('  ip ' + ip, 'info'); },
         frames: async () => { const r = await send(Wire.encodeGetFramesSent(), 'GET_FRAMES_SENT 0x33'); const n = r && Wire.decodeFramesSent(r); if (n != null) clog('  frames sent ' + n, 'info'); },
         resetframes: () => send(Wire.encodeResetFramesSent(), 'RESET_FRAMES_SENT 0x34'),
@@ -6524,6 +6615,10 @@ <h2 id="modalTitle">Import error</h2>
             // Forget the controller's capabilities so the NEXT connect re-detects
             // io_ext (avoids stale caps gating the rig-I/O roles for a swapped rig).
             Studio.capabilities = null;
+            Studio.features = null;
+            Studio.panels = null; // never carry one controller's panel inventory into the next connection
+            Studio.panelsStatus = 'disconnected';
+            if (Studio._panelsFollowUp) { clearTimeout(Studio._panelsFollowUp); Studio._panelsFollowUp = null; }
             if (Studio.updateRigIoGating) Studio.updateRigIoGating();
         }
     }
@@ -6919,6 +7014,7 @@ <h2 id="modalTitle">Import error</h2>
         );
         if (info) {
             Studio.capabilities = info.capabilities || [];
+            Studio.features = info.features || [];
             if (info.mac && !Studio.controllerId) Studio.controllerId = info.mac;
         }
     } catch (_) { /* older fw / no reply — hasIoExt() stays false */ }
@@ -8636,6 +8732,10 @@ <h2 id="modalTitle">Import error</h2>
     if (refuseUnsupportedRequires(exp)) return null;
     const { steps } = RunnerLib.flattenStructure(exp, { shuffle: shuffleInPlace });
     const conditionsByName = new Map((exp.conditions || []).map((c) => [c.name, c]));
+    // Run-start snapshot of the panel fleet (0xD1 is a pure read, ~10 ms per page):
+    // run_metadata.panels must describe the panels at THIS run's start, not whatever
+    // was cached at connect. Feature-gated inside; a failure records status 'failed'.
+    await Studio.refreshPanelInventory({ quiet: true });
     startRunLog(isExperiment);
     document.body.classList.toggle('testing', !isExperiment);
     // Surface the live scope for BOTH run and test — the whole point of a test is
@@ -9161,7 +9261,11 @@ <h2 id="modalTitle">Import error</h2>
             notes: $('mNotes').value
         },
         doc: { filename: doc.filename, sha256: doc.sha256 },
-        session: { firmware: Studio.firmware, controllerId: Studio.controllerId },
+        session: {
+            firmware: Studio.firmware,
+            controllerId: Studio.controllerId,
+            panels: window.StudioPanelInventory ? window.StudioPanelInventory.toRunMeta(Studio.panels, Studio.panelsStatus) : null
+        },
         rig: doc.rig,
         toolVersion: Studio.TOOL_VERSION,
         build: Studio.build
@@ -16655,6 +16759,9 @@ <h2 id="modalTitle">Import error</h2>
     '.rail-btn[data-panel="io"]': 'The controller’s analog and digital input/output connectors.',
     '.rail-btn[data-panel="ai"]': 'Watch the two analog inputs live, and check the wiring by looping Analog Out back into an input.',
     '.rail-btn[data-panel="fw"]': 'Update or check the firmware on the LED panels.',
+    '[data-cmd="cinv"]': 'Show which panels the controller found at start-up and which firmware each one runs.',
+    '[data-cmd="cinvscan"]': 'Look for the panels again and re-check their firmware (the display is stopped while this runs).',
+    '#pvPanels': 'How many panels answered when the arena connected, and their firmware. Saved with every run.',
     '[data-cmd="ctelem"]': 'Turn the controller\'s built-in activity recording on or off (it is written into the run log alongside the tracking data).',
     '[data-cmd="chealth"]': 'Ask the controller how it is doing — loop timing, memory-card read times, and what it was doing before its last restart.',
     '#fmSoak': 'Repeat the open protocol unattended (overnight) to catch the rare controller freeze; on a freeze it records diagnostics and, if you chose so, restarts the controller and continues.',
diff --git a/js/arena-wire-g6.js b/js/arena-wire-g6.js
index cc0e221f..de8479e7 100644
--- a/js/arena-wire-g6.js
+++ b/js/arena-wire-g6.js
@@ -88,6 +88,8 @@ const ArenaWireG6 = (function () {
         GET_FIRMWARE_INFO: 0xe3, // [01 E3] reply: 32-byte footer {magic[8], version[16], crc32 LE, size LE}
         G6_PROGRAM_PANEL: 0xc8, // [02 C8 panel_index] reflash one panel from /firmware/panel.bin via SPI ISP
         G6_VERIFY_PANEL: 0xc9, // [02 C9 panel_index] CRC the panel's running app flash vs /firmware/panel.bin footer
+        PANEL_INVENTORY_SCAN: 0xd0, // [02 D0 action] re-probe the fleet: 0 presence (keeps fingerprints), 1 presence + fresh fingerprints; replies with 0xD1 page 0 (feature bit 0)
+        GET_PANEL_INVENTORY: 0xd1, // [01 D1] | [02 D1 first] per-panel presence + firmware fingerprint, 32-panel pages (feature bit 0)
         ALL_ON: 0xff
     };
 
@@ -124,11 +126,42 @@ const ArenaWireG6 = (function () {
         // 0xAD / SET_AO_MODE 0xA3 / GET_ANALOG_IN 0xA4 — hosts detect the
         // DIO-role machinery by this bit, not by firmware-version guessing.
         [5, 'io_ext'],
+        // Per-board analog-input calibration (fw #47): GET_ANALOG_IN_RAW 0xA5 /
+        // SET_ANALOG_CAL 0xA6 / GET_ANALOG_CAL 0xA7 + the 0xA4 flags byte.
+        [6, 'ai_cal'],
         // Controller health counters + reset breadcrumb (GET_HEALTH 0xCA) — the
         // fw #50 soak/post-mortem probe. Hosts grey the health readout without it.
         [7, 'health']
     ];
 
+    // The capability byte is full. New command families are advertised in the
+    // feature bitmap appended to the 0xC2 reply after the MAC: payload[8] = N
+    // bytes follow, bit k (LSB of features[0] = bit 0) = feature k. Presence is
+    // signalled by payload length, like the MAC (g6_03-controller.md § 0xC2).
+    const FEATURE_BITS = [
+        [0, 'panel_inventory'], // PANEL_INVENTORY_SCAN 0xD0 / GET_PANEL_INVENTORY 0xD1
+        [1, 'qwiic_i2c'], // GET_I2C_SCAN 0xB0 / I2C_TRANSFER 0xB1 (arena_12-18 only)
+        [2, 'ai_stream'] // reserved: sampled analog-input block stream
+    ];
+
+    // GET_PANEL_INVENTORY entry status byte (firmware PanelInventory::PanelStatus).
+    const PANEL_STATUS_NAMES = [
+        'unknown', // 0 not scanned
+        'absent', // 1 no COMM_CHECK reply
+        'present', // 2 replied; not fingerprinted (yet)
+        'fw_match', // 3 fingerprint == /firmware/panel.bin
+        'fw_differs', // 4 fingerprint != /firmware/panel.bin
+        'fw_no_reference', // 5 fingerprinted; no SD image to compare against
+        'fw_failed' // 6 replied to COMM_CHECK but not to ISP
+    ];
+    const PANEL_INVENTORY_FLAGS = {
+        PRESENCE_VALID: 0x01,
+        FP_VALID: 0x02,
+        FP_IN_PROGRESS: 0x04,
+        REF_PRESENT: 0x08,
+        FP_PREFIX: 0x10
+    };
+
     // ───────────────────────── validation helpers ─────────────────────────
 
     function requireInt(value, name) {
@@ -676,7 +709,98 @@ const ArenaWireG6 = (function () {
                 .map((b) => b.toString(16).padStart(2, '0').toUpperCase())
                 .join(':');
         }
-        return { version, capability, capabilities, mac };
+        // Optional feature bitmap [N, features[N]] after the MAC. Valid only when
+        // the payload holds all N bytes; a truncated bitmap reads as no features.
+        let featureBits = null;
+        let features = [];
+        if (r.payload.length >= 9) {
+            const n = r.payload[8];
+            if (n > 0 && r.payload.length >= 9 + n) {
+                featureBits = 0;
+                for (let i = 0; i < Math.min(n, 4); i++) {
+                    featureBits |= r.payload[9 + i] << (8 * i);
+                }
+                featureBits >>>= 0;
+                features = FEATURE_BITS.filter(([bit]) => featureBits & (1 << bit)).map(
+                    ([, name]) => name
+                );
+            }
+        }
+        return { version, capability, capabilities, mac, featureBits, features };
+    }
+
+    /**
+     * panel-inventory-scan (0xD0): [02 D0 action]. action 0 = presence only
+     * (panels still present keep their fingerprint), 1 = presence + restart the
+     * fingerprint sweep. Needs ALL_OFF (else status 10) and no SD transfer.
+     * Replies with 0xD1 page 0 (echo 0xD0). Gate on feature 'panel_inventory'.
+     */
+    function encodePanelInventoryScan(action) {
+        requireInt(action, 'action');
+        if (action !== 0 && action !== 1) {
+            throw new RangeError('action must be 0 (presence) or 1 (presence + fingerprints)');
+        }
+        return Uint8Array.from([0x02, OPCODES.PANEL_INVENTORY_SCAN, action]);
+    }
+
+    /**
+     * get-panel-inventory (0xD1): [01 D1] or [02 D1 first]. `first` = 0-based
+     * index of the page's first panel (32 per page). Pure read, always allowed.
+     */
+    function encodeGetPanelInventory(first) {
+        if (first === undefined || first === null) {
+            return Uint8Array.from([0x01, OPCODES.GET_PANEL_INVENTORY]);
+        }
+        requireInt(first, 'first');
+        if (first < 0 || first > 255) throw new RangeError('first must be 0..255');
+        return Uint8Array.from([0x02, OPCODES.GET_PANEL_INVENTORY, first]);
+    }
+
+    /**
+     * 0xD1 page (also the 0xD0 reply) -> {version, panelCount, flags, flagNames,
+     * first, n, refCrc32, fpLen, ageMs, scanId, entries[{panel, status, statusName,
+     * crc32}]} or null. Header (18 B, LE): version=1, panel_count, flags, first, n,
+     * ref_crc32 u32, fp_len u32, age_ms u32, scan_id; then n × {status u8, crc32
+     * u32}. `panel` is the 1-based panel number (first + k + 1), the numbering
+     * 0xC8/0xC9 use. `scanId` changes on every presence scan: the pages of one
+     * multi-page read must agree, else re-read (firmware PanelInventory.h).
+     */
+    function decodePanelInventory(resp) {
+        const r = asResponse(resp);
+        if (!r || !r.ok) return null;
+        const p = r.payload;
+        if (p.length < 18 || p[0] !== 1) return null;
+        const n = p[4];
+        if (p.length !== 18 + 5 * n) return null;
+        const u32 = (o) => (p[o] | (p[o + 1] << 8) | (p[o + 2] << 16) | (p[o + 3] << 24)) >>> 0;
+        const flags = p[2];
+        const first = p[3];
+        const entries = [];
+        for (let k = 0; k < n; k++) {
+            const o = 18 + 5 * k;
+            const status = p[o];
+            entries.push({
+                panel: first + k + 1,
+                status,
+                statusName: PANEL_STATUS_NAMES[status] || 'status_' + status,
+                crc32: u32(o + 1)
+            });
+        }
+        return {
+            version: p[0],
+            panelCount: p[1],
+            flags,
+            flagNames: Object.keys(PANEL_INVENTORY_FLAGS).filter(
+                (k) => flags & PANEL_INVENTORY_FLAGS[k]
+            ),
+            first,
+            n,
+            refCrc32: u32(5),
+            fpLen: u32(9),
+            ageMs: u32(13),
+            scanId: p[17],
+            entries
+        };
     }
 
     // set/get-spi-clock (0xC5/0xC6) reply carries the clock as uint16 LE MHz.
@@ -1298,6 +1422,9 @@ const ArenaWireG6 = (function () {
         MODES,
         PANEL_DISPLAY_MODE_NAMES,
         CAPABILITY_BITS,
+        FEATURE_BITS,
+        PANEL_STATUS_NAMES,
+        PANEL_INVENTORY_FLAGS,
         STREAM_FRAME_BYTES,
 
         // Encoders (request frames)
@@ -1344,6 +1471,8 @@ const ArenaWireG6 = (function () {
         encodeGetFirmwareInfo,
         encodeG6ProgramPanel,
         encodeG6VerifyPanel,
+        encodePanelInventoryScan,
+        encodeGetPanelInventory,
         encodeSetAoVoltage,
         encodeGetAoVoltage,
         encodeGetDigitalOut,
@@ -1390,7 +1519,8 @@ const ArenaWireG6 = (function () {
         decodeAnalogIn,
         decodeSetFirmwareFileResponse,
         decodeFirmwareInfo,
-        decodeProgramPanelResponse
+        decodeProgramPanelResponse,
+        decodePanelInventory
     };
 })();
 
diff --git a/js/studio-meta.js b/js/studio-meta.js
index 1e997146..5478556c 100644
--- a/js/studio-meta.js
+++ b/js/studio-meta.js
@@ -41,7 +41,9 @@
      * @param {object} a
      * @param {object} a.panel   {experimenter, genotype, age, sex, fly_number, notes} from the side panel
      * @param {object} a.doc     {filename, sha256}  loaded/edited protocol
-     * @param {object} a.session {firmware, controllerId} from GET_CONTROLLER_INFO 0xC2 only
+     * @param {object} a.session {firmware, controllerId, panels} — firmware/controllerId from
+     *                           GET_CONTROLLER_INFO 0xC2 / 0xCB, panels = StudioPanelInventory
+     *                           .toRunMeta() of the 0xD1 inventory (null on firmware without it)
      * @param {object} a.rig     {name, arenaConfig} from the loaded rig YAML (NOT the controller)
      * @param {string} a.toolVersion  e.g. 'Arena Studio v0.1'
      * @param {string} a.runId
@@ -74,6 +76,13 @@
             // from the Teensy's burned-in unique ID. null until the firmware
             // ships it in the 0xC2 reply (tolerant decode on the web side).
             controller_id: session.controllerId || null,
+            // Which panels answered at RUN START and the firmware fingerprint each
+            // runs (GET_PANEL_INVENTORY 0xD1, fw #59), StudioPanelInventory.toRunMeta():
+            // {schema: 1, status: 'ok'|'pending'|'failed'|'unsupported'|'disconnected',
+            // count, present, missing, panel_status[], firmware[{crc32, panels}],
+            // mismatched, ref_crc32, fp_len, presence_valid, fp_valid, fp_in_progress,
+            // scan_id, age_ms}. Only null when the Studio asset itself is missing.
+            panels: session.panels || null,
             tool_version: o.toolVersion || null,
             // Which release tier ran this (docs/development/release-process.md): a Next
             // candidate shares its upcoming tool_version with the release, so `channel` +
diff --git a/js/studio-panel-inventory.js b/js/studio-panel-inventory.js
new file mode 100644
index 00000000..1aa33a03
--- /dev/null
+++ b/js/studio-panel-inventory.js
@@ -0,0 +1,195 @@
+/**
+ * studio-panel-inventory.js — read and summarize the controller's panel
+ * inventory (GET_PANEL_INVENTORY 0xD1 / PANEL_INVENTORY_SCAN 0xD0, firmware
+ * #59; g6_03-controller.md § 0xD_), DOM-free so it is Node-testable
+ * (tests/test-studio-panel-inventory.js):
+ *
+ *   - readAll(send)        pages the whole fleet (32 panels per page) and re-reads
+ *                          from the start when the pages' scan_id disagree (a boot
+ *                          retry or another host's rescan landed between pages)
+ *   - summarize(pages)     per-panel statuses → present/missing, distinct firmware
+ *                          fingerprints, the panels that differ from the majority
+ *   - describe(inv)        one-line label for the Console log / provenance box
+ *   - toRunMeta(inv)       the compact record written to run_metadata.panels
+ *
+ * Gate every call on the 0xC2 feature 'panel_inventory' (decodeControllerInfo
+ * ().features): firmware without it answers 0xD1 with CE_UNKNOWN_CMD and an error
+ * glyph on the arena.
+ *
+ * LOADING: classic <script src> (window-global `StudioPanelInventory` + CommonJS),
+ * no ES `export` — same rule as arena-session.js (CLAUDE.md).
+ */
+(function (global) {
+    'use strict';
+
+    const Wire =
+        (typeof require === 'function' &&
+            (() => {
+                try {
+                    return require('./arena-wire-g6.js');
+                } catch (_) {
+                    return null;
+                }
+            })()) ||
+        global.ArenaWireG6;
+
+    const PRESENT_STATUSES = new Set([2, 3, 4, 5, 6]);
+    const FINGERPRINTED = new Set([3, 4, 5]);
+
+    const hex32 = (v) => '0x' + (v >>> 0).toString(16).toUpperCase().padStart(8, '0');
+
+    /**
+     * Read every page. `send(bytes, {timeoutMs})` resolves to the raw response
+     * (ArenaSession.send). Resolves to {pages[], entries[]} or throws.
+     */
+    async function readAll(send, opts) {
+        const o = opts || {};
+        const retries = o.retries == null ? 3 : o.retries;
+        const timeoutMs = o.timeoutMs || 2000;
+        let lastErr = null;
+        for (let attempt = 0; attempt < retries; attempt++) {
+            const page0 = Wire.decodePanelInventory(
+                await send(Wire.encodeGetPanelInventory(), { timeoutMs })
+            );
+            if (!page0) throw new Error('no GET_PANEL_INVENTORY reply');
+            const pages = [page0];
+            let entries = page0.entries.slice();
+            let consistent = true;
+            while (entries.length < page0.panelCount) {
+                const next = Wire.decodePanelInventory(
+                    await send(Wire.encodeGetPanelInventory(entries.length), { timeoutMs })
+                );
+                if (!next || next.n === 0) throw new Error('short GET_PANEL_INVENTORY page');
+                if (next.scanId !== page0.scanId) {
+                    consistent = false;
+                    lastErr = new Error('scan_id changed between pages');
+                    break;
+                }
+                if (next.first !== entries.length || next.panelCount !== page0.panelCount) {
+                    consistent = false;
+                    lastErr = new Error('incoherent GET_PANEL_INVENTORY pages');
+                    break;
+                }
+                pages.push(next);
+                entries = entries.concat(next.entries);
+            }
+            if (consistent) return { pages, entries };
+        }
+        throw lastErr || new Error('panel inventory read did not settle');
+    }
+
+    /** {pages, entries} → the summary object every consumer reads. */
+    function summarize(read) {
+        const page0 = read.pages[0];
+        const entries = read.entries;
+        const statuses = entries.map((e) => e.status);
+        const present = entries.filter((e) => PRESENT_STATUSES.has(e.status)).map((e) => e.panel);
+        const missing = entries.filter((e) => e.status === 1).map((e) => e.panel);
+        const unknown = entries.filter((e) => e.status === 0).map((e) => e.panel);
+        const noIsp = entries.filter((e) => e.status === 6).map((e) => e.panel);
+        const byCrc = new Map();
+        for (const e of entries) {
+            if (!FINGERPRINTED.has(e.status)) continue;
+            if (!byCrc.has(e.crc32))
+                byCrc.set(e.crc32, { crc32: e.crc32, panels: [], status: e.status });
+            byCrc.get(e.crc32).panels.push(e.panel);
+        }
+        const firmware = Array.from(byCrc.values())
+            .sort((a, b) => b.panels.length - a.panels.length || a.crc32 - b.crc32)
+            .map((f) => ({
+                crc32: f.crc32,
+                hex: hex32(f.crc32),
+                panels: f.panels,
+                statusName: Wire.PANEL_STATUS_NAMES[f.status]
+            }));
+        const F = Wire.PANEL_INVENTORY_FLAGS;
+        const refPresent = !!(page0.flags & F.REF_PRESENT);
+        // "Mismatched" = a panel a preflight should flag: differs from the SD
+        // image when there is one, else outside the strict fingerprint majority
+        // (a tie names no majority); plus panels that answered COMM_CHECK but
+        // not ISP.
+        let mismatched = [];
+        if (refPresent) {
+            mismatched = entries.filter((e) => e.status === 4).map((e) => e.panel);
+        } else if (firmware.length > 1 && firmware[0].panels.length > firmware[1].panels.length) {
+            mismatched = firmware.slice(1).flatMap((f) => f.panels);
+        }
+        mismatched = mismatched.concat(noIsp).sort((a, b) => a - b);
+        return {
+            panelCount: page0.panelCount,
+            statuses,
+            present,
+            missing,
+            unknown,
+            noIsp,
+            firmware,
+            mismatched,
+            flags: page0.flags,
+            flagNames: page0.flagNames,
+            presenceValid: !!(page0.flags & F.PRESENCE_VALID),
+            fpValid: !!(page0.flags & F.FP_VALID),
+            fpInProgress: !!(page0.flags & F.FP_IN_PROGRESS),
+            refPresent,
+            fpPrefix: !!(page0.flags & F.FP_PREFIX),
+            refCrc32: page0.refCrc32,
+            fpLen: page0.fpLen,
+            ageMs: page0.ageMs,
+            scanId: page0.scanId
+        };
+    }
+
+    /** One line: "20/20 present · fw 0x9BE0D3C7 ×20 (64 KB prefix, no SD image)". */
+    function describe(inv) {
+        if (!inv) return '—';
+        if (!inv.presenceValid) return 'panel scan pending';
+        let s = inv.present.length + '/' + inv.panelCount + ' present';
+        if (inv.missing.length) s += ' (missing ' + inv.missing.join(', ') + ')';
+        if (inv.fpInProgress) {
+            s += ' · fingerprinting…';
+        } else if (inv.firmware.length) {
+            s +=
+                ' · fw ' +
+                inv.firmware.map((f) => f.hex + ' ×' + f.panels.length).join(', ') +
+                (inv.refPresent
+                    ? inv.mismatched.length
+                        ? ' (' + inv.mismatched.length + ' ≠ SD panel.bin)'
+                        : ' (= SD panel.bin)'
+                    : ' (' + Math.round(inv.fpLen / 1024) + ' KB prefix, no SD image)');
+        }
+        if (inv.noIsp.length) s += ' · no ISP reply: ' + inv.noIsp.join(', ');
+        return s;
+    }
+
+    /**
+     * Compact, JSON-friendly record for run_metadata.panels. Always an object, so
+     * a log never has to guess what a missing inventory meant: `status` is 'ok'
+     * (presence scan valid), 'pending' (the controller's boot scan had not
+     * finished), 'failed' (the 0xD1 read failed), 'unsupported' (firmware without
+     * the feature) or 'disconnected'. `schema` guards the shape for later readers.
+     */
+    function toRunMeta(inv, status) {
+        if (!inv) return { schema: 1, status: status || 'unsupported' };
+        return {
+            schema: 1,
+            status: status || (inv.presenceValid ? 'ok' : 'pending'),
+            count: inv.panelCount,
+            present: inv.present.length,
+            missing: inv.missing,
+            panel_status: inv.statuses,
+            firmware: inv.firmware.map((f) => ({ crc32: f.hex, panels: f.panels })),
+            mismatched: inv.mismatched,
+            ref_crc32: inv.refPresent ? hex32(inv.refCrc32) : null,
+            fp_len: inv.fpLen,
+            presence_valid: inv.presenceValid,
+            fp_valid: inv.fpValid,
+            fp_in_progress: inv.fpInProgress,
+            scan_id: inv.scanId,
+            age_ms: inv.ageMs
+        };
+    }
+
+    const StudioPanelInventory = { readAll, summarize, describe, toRunMeta, hex32 };
+
+    if (typeof module !== 'undefined' && module.exports) module.exports = StudioPanelInventory;
+    global.StudioPanelInventory = StudioPanelInventory;
+})(typeof window !== 'undefined' ? window : globalThis);
diff --git a/pixi.toml b/pixi.toml
index 9baeb10c..c1b3a922 100644
--- a/pixi.toml
+++ b/pixi.toml
@@ -21,7 +21,7 @@ serve = "python -m http.server 8000 --bind 127.0.0.1"
 # The full test suite. yaml is vendored (js/vendor/yaml), so no package install.
 # The v3 suite pulls in ESM modules that `import 'yaml'`; --import maps that bare
 # specifier to the vendored copy (tests/vendor-yaml.register.mjs).
-test = "node tests/test-project-skills.js && node tests/validate-arena-calculations.js && node tests/test-protocol-roundtrip.js && node --import ./tests/vendor-yaml.register.mjs tests/test-protocol-roundtrip-v3.js && node --import ./tests/vendor-yaml.register.mjs tests/test-runtime-controls.js && node tests/test-plugin-registry.js && node tests/test-arena-wire-g6.js && node tests/test-arena-link.js && node tests/test-arena-runner-g6.js && node tests/test-arena-session.js && node tests/test-fictrac-bridge-client.js && node tests/test-run-log.js && node tests/test-bin-classifier.js && node tests/test-pattern-set.js && node tests/test-pat-preview.js && node tests/test-studio-meta.js && node tests/test-build-channel.js && node tests/test-studio-analog-in.js && node tests/test-studio-url-state.js && node tests/test-studio-runlog-adapter.js && node tests/test-studio-github.js && node tests/test-studio-canmutate.js && node tests/test-studio-protocols-index.js && node tests/test-g6-tall-rigs.js && node tests/test-arena-studio-alt.js && node tests/test-three-viewer-led-glow.js && node tests/test-three-viewer-preview-omissions.js && node tests/test-arena-replay-viewer-protocol.js && node tests/test-kinematics.js && node tests/test-runlog-replay.js && node tests/test-studio-replay.js && node tests/test-fly-gait.js && node tests/test-runlog-format.js && node tests/test-metadata-yaml.js && python tests/test-bridge-behavior.py && python tests/test-build-runlog-index.py && node tests/test-studio-postmortem.js && node tests/test-arena-telemetry.js && python tests/test-wedge-scan.py && python tests/test-runlog-check.py && node tests/test-trial-quality.js && python tests/test-telemetry-report.py && python tests/test-fictrac-sim.py && node --import ./tests/vendor-yaml.register.mjs tests/test-studio-runtime-vars.js && python tests/test-tiers-candidate.py"
+test = "node tests/test-project-skills.js && node tests/validate-arena-calculations.js && node tests/test-protocol-roundtrip.js && node --import ./tests/vendor-yaml.register.mjs tests/test-protocol-roundtrip-v3.js && node --import ./tests/vendor-yaml.register.mjs tests/test-runtime-controls.js && node tests/test-plugin-registry.js && node tests/test-arena-wire-g6.js && node tests/test-arena-link.js && node tests/test-arena-runner-g6.js && node tests/test-arena-session.js && node tests/test-fictrac-bridge-client.js && node tests/test-run-log.js && node tests/test-bin-classifier.js && node tests/test-pattern-set.js && node tests/test-pat-preview.js && node tests/test-studio-meta.js && node tests/test-build-channel.js && node tests/test-studio-analog-in.js && node tests/test-studio-panel-inventory.js && node tests/test-studio-url-state.js && node tests/test-studio-runlog-adapter.js && node tests/test-studio-github.js && node tests/test-studio-canmutate.js && node tests/test-studio-protocols-index.js && node tests/test-g6-tall-rigs.js && node tests/test-arena-studio-alt.js && node tests/test-three-viewer-led-glow.js && node tests/test-three-viewer-preview-omissions.js && node tests/test-arena-replay-viewer-protocol.js && node tests/test-kinematics.js && node tests/test-runlog-replay.js && node tests/test-studio-replay.js && node tests/test-fly-gait.js && node tests/test-runlog-format.js && node tests/test-metadata-yaml.js && python tests/test-bridge-behavior.py && python tests/test-build-runlog-index.py && node tests/test-studio-postmortem.js && node tests/test-arena-telemetry.js && python tests/test-wedge-scan.py && python tests/test-runlog-check.py && node tests/test-trial-quality.js && python tests/test-telemetry-report.py && python tests/test-fictrac-sim.py && node --import ./tests/vendor-yaml.register.mjs tests/test-studio-runtime-vars.js && python tests/test-tiers-candidate.py"
 # ── Two-tier releases: Production + Next (docs/development/release-process.md) ──
 # pixi run candidate -- 219 178   build a frozen Next candidate from those PRs
 # pixi run release                 promote the validated candidate to Production
diff --git a/tests/test-arena-wire-g6.js b/tests/test-arena-wire-g6.js
index a61cd36d..1d891ce3 100644
--- a/tests/test-arena-wire-g6.js
+++ b/tests/test-arena-wire-g6.js
@@ -930,5 +930,148 @@ check('FIRMWARE_VERSION_PAYLOAD_BYTES', Wire.FIRMWARE_VERSION_PAYLOAD_BYTES, 46)
     }
 }
 
+// Panel inventory (fw #59, g6_03 § 0xD_): 0xC2 feature bitmap after the MAC,
+// 0xD0/0xD1 encoders, the 18-byte 0xD1 page header with scan_id at [17].
+console.log('\n=== panel inventory (0xC2 features, 0xD0 / 0xD1) ===');
+{
+    // 0xC2 with MAC + feature bitmap [4, 01 00 00 00] → panel_inventory; cap 0xA3.
+    const ciFeat = Uint8Array.from([
+        0x0f, 0x00, 0xc2, 0x02, 0xa3, 0x04, 0xe9, 0xe5, 0xab, 0xcd, 0x12, 0x04, 0x01, 0x00, 0x00,
+        0x00
+    ]);
+    const fi = Wire.decodeControllerInfo(ciFeat);
+    check('feature bitmap parsed', fi.featureBits, 1);
+    check('feature names', fi.features.join(','), 'panel_inventory');
+    check(
+        'caps with health (0xA3)',
+        fi.capabilities.join(','),
+        'g6_mode,v2_local_storage,io_ext,health'
+    );
+    check('mac still parsed with features', fi.mac, '04:E9:E5:AB:CD:12');
+    // qwiic_i2c = bit 1; ai_cal = capability bit 6 (0xE3 with #47 merged).
+    const fq = Wire.decodeControllerInfo(
+        Uint8Array.from([
+            0x0f, 0x00, 0xc2, 0x02, 0xe3, 1, 2, 3, 4, 5, 6, 0x04, 0x02, 0x00, 0x00, 0x00
+        ])
+    );
+    check('qwiic_i2c feature', fq.features.join(','), 'qwiic_i2c');
+    check(
+        'ai_cal capability (0xE3)',
+        fq.capabilities.join(','),
+        'g6_mode,v2_local_storage,io_ext,ai_cal,health'
+    );
+    // No bitmap (8-byte payload) → featureBits null, features []; truncated bitmap → same.
+    const f8 = Wire.decodeControllerInfo(
+        Uint8Array.from([0x0a, 0x00, 0xc2, 0x02, 0xa3, 1, 2, 3, 4, 5, 6])
+    );
+    checkBool('no bitmap → featureBits null', f8.featureBits === null && f8.features.length === 0);
+    const ft = Wire.decodeControllerInfo(
+        Uint8Array.from([0x0c, 0x00, 0xc2, 0x02, 0xa3, 1, 2, 3, 4, 5, 6, 0x04, 0x01])
+    );
+    checkBool(
+        'truncated bitmap → no features',
+        ft.featureBits === null && ft.features.length === 0
+    );
+    check(
+        'FEATURE_BITS exported',
+        Wire.FEATURE_BITS.map(([, n]) => n).join(','),
+        'panel_inventory,qwiic_i2c,ai_stream'
+    );
+
+    checkBytes('panel-inventory-scan presence', Wire.encodePanelInventoryScan(0), '02 d0 00');
+    checkBytes('panel-inventory-scan fingerprints', Wire.encodePanelInventoryScan(1), '02 d0 01');
+    checkThrows('panel-inventory-scan rejects action 2', () => Wire.encodePanelInventoryScan(2));
+    checkBytes('get-panel-inventory default', Wire.encodeGetPanelInventory(), '01 d1');
+    checkBytes('get-panel-inventory first=32', Wire.encodeGetPanelInventory(32), '02 d1 20');
+    checkThrows('get-panel-inventory rejects 256', () => Wire.encodeGetPanelInventory(256));
+
+    // A 3-panel page (panel_count 3, so one page): flags 0x13 = presence_valid |
+    // fp_valid | fp_prefix, first 0, n 3, ref_crc 0, fp_len 65536, age 1234 ms,
+    // scan_id 7; panels: 5 (no ref) crc 0x9BE0D3C7, absent, 6 (no ISP).
+    const page = Uint8Array.from([
+        0x23,
+        0x00,
+        0xd1, // len 35 (status + echo + 33 payload), status 0, echo
+        0x01,
+        0x03,
+        0x13,
+        0x00,
+        0x03, // version, count, flags, first, n
+        0x00,
+        0x00,
+        0x00,
+        0x00, // ref_crc32
+        0x00,
+        0x00,
+        0x01,
+        0x00, // fp_len 65536
+        0xd2,
+        0x04,
+        0x00,
+        0x00, // age_ms 1234
+        0x07, // scan_id
+        0x05,
+        0xc7,
+        0xd3,
+        0xe0,
+        0x9b, // panel 1: fw_no_reference, crc 0x9BE0D3C7
+        0x01,
+        0x00,
+        0x00,
+        0x00,
+        0x00, // panel 2: absent
+        0x06,
+        0x00,
+        0x00,
+        0x00,
+        0x00 // panel 3: fw_failed
+    ]);
+    const pi = Wire.decodePanelInventory(page);
+    checkBool('decodePanelInventory parses', !!pi);
+    check('inventory panelCount', pi.panelCount, 3);
+    check('inventory flags', pi.flagNames.join(','), 'PRESENCE_VALID,FP_VALID,FP_PREFIX');
+    check('inventory fpLen', pi.fpLen, 65536);
+    check('inventory ageMs', pi.ageMs, 1234);
+    check('inventory scanId', pi.scanId, 7);
+    check(
+        'inventory entry panel numbers (1-based)',
+        pi.entries.map((e) => e.panel).join(','),
+        '1,2,3'
+    );
+    check(
+        'inventory entry statuses',
+        pi.entries.map((e) => e.statusName).join(','),
+        'fw_no_reference,absent,fw_failed'
+    );
+    check('inventory crc32 LE', pi.entries[0].crc32, 0x9be0d3c7);
+    // 0xD0 replies carry the same payload under its own echo byte.
+    const scanReply = Uint8Array.from(page);
+    scanReply[2] = 0xd0;
+    checkBool(
+        'decodePanelInventory accepts the 0xD0 echo',
+        Wire.decodePanelInventory(scanReply).scanId === 7
+    );
+    // Past the end: n = 0, 18-byte header only.
+    const empty = Uint8Array.from([
+        0x14, 0x00, 0xd1, 1, 3, 0x13, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 7
+    ]);
+    check(
+        'inventory past-end page has no entries',
+        Wire.decodePanelInventory(empty).entries.length,
+        0
+    );
+    // Length mismatch (17-byte pre-scan_id header) and error status → null.
+    checkBool(
+        'inventory rejects a short header',
+        Wire.decodePanelInventory(page.slice(0, 20)) === null
+    );
+    checkBool(
+        'inventory rejects status!=0',
+        Wire.decodePanelInventory(Uint8Array.from([0x04, 0x0a, 0xd0, 0x53, 0x74])) === null
+    );
+    check('OPCODES.PANEL_INVENTORY_SCAN', Wire.OPCODES.PANEL_INVENTORY_SCAN, 0xd0);
+    check('OPCODES.GET_PANEL_INVENTORY', Wire.OPCODES.GET_PANEL_INVENTORY, 0xd1);
+}
+
 console.log(`\n=== Summary ===\n${totalChecks - failures} / ${totalChecks} checks passed`);
 process.exit(failures > 0 ? 1 : 0);
diff --git a/tests/test-studio-panel-inventory.js b/tests/test-studio-panel-inventory.js
new file mode 100644
index 00000000..7c11dabe
--- /dev/null
+++ b/tests/test-studio-panel-inventory.js
@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+/**
+ * Tests for js/studio-panel-inventory.js (the panel-inventory reader behind the
+ * Studio's link-up identity + run_metadata.panels) and its wiring in
+ * arena_studio.html. No DOM: readAll() is driven by a fake send() that serves
+ * canned 0xD1 pages, including a scan_id change between pages.
+ * Run: node tests/test-studio-panel-inventory.js   (wired into `pixi run test`)
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const Inv = require('../js/studio-panel-inventory.js');
+const Wire = require('../js/arena-wire-g6.js');
+const studioHtml = fs.readFileSync(path.join(__dirname, '..', 'arena_studio.html'), 'utf8');
+
+let total = 0;
+let failures = 0;
+function check(name, got, expected) {
+    total++;
+    const ok = JSON.stringify(got) === JSON.stringify(expected);
+    console.log(
+        `  ${ok ? 'PASS' : 'FAIL'}  ${name}${ok ? '' : ` — got ${JSON.stringify(got)}, expected ${JSON.stringify(expected)}`}`
+    );
+    if (!ok) failures++;
+}
+function checkBool(name, ok, info) {
+    total++;
+    console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}${ok ? '' : ' — ' + (info || '')}`);
+    if (!ok) failures++;
+}
+
+// Build a 0xD1 page frame: header fields + entries [{status, crc32}].
+function page(o) {
+    const u32 = (v) => [v & 0xff, (v >>> 8) & 0xff, (v >>> 16) & 0xff, (v >>> 24) & 0xff];
+    const body = [1, o.count, o.flags, o.first, o.entries.length]
+        .concat(u32(o.refCrc || 0), u32(o.fpLen || 65536), u32(o.ageMs || 100), [o.scanId])
+        .concat(o.entries.flatMap((e) => [e.status].concat(u32(e.crc32 || 0))));
+    return Uint8Array.from([body.length + 2, 0x00, 0xd1].concat(body));
+}
+const fwA = 0x9be0d3c7;
+const fwB = 0x03e66c15;
+
+// Fake send: routes by the request's `first` byte, serving the page set `pagesByFirst`;
+// `onCall` lets a test mutate the world between pages.
+function fakeSend(pagesByFirst, onCall) {
+    const calls = [];
+    return {
+        calls,
+        send: async (bytes) => {
+            const first = bytes.length >= 3 ? bytes[2] : 0;
+            calls.push(first);
+            if (onCall) onCall(calls.length, first);
+            const p = pagesByFirst[first];
+            if (!p) throw new Error('no page for first=' + first);
+            return p;
+        }
+    };
+}
+
+(async () => {
+    console.log('=== readAll: one page (20 panels) ===');
+    {
+        const entries = Array.from({ length: 20 }, () => ({ status: 5, crc32: fwA }));
+        const f = fakeSend({ 0: page({ count: 20, flags: 0x13, first: 0, scanId: 3, entries }) });
+        const r = await Inv.readAll(f.send);
+        check('one page → one request', f.calls, [0]);
+        check('entries', r.entries.length, 20);
+        const inv = Inv.summarize(r);
+        check('present', inv.present.length, 20);
+        check('missing', inv.missing, []);
+        check(
+            'firmware groups',
+            inv.firmware.map((g) => [g.hex, g.panels.length]),
+            [['0x9BE0D3C7', 20]]
+        );
+        check('mismatched (single fw, no ref)', inv.mismatched, []);
+        check('scanId', inv.scanId, 3);
+        check(
+            'describe',
+            Inv.describe(inv),
+            '20/20 present · fw 0x9BE0D3C7 ×20 (64 KB prefix, no SD image)'
+        );
+        const meta = Inv.toRunMeta(inv);
+        check('run meta shape', Object.keys(meta), [
+            'schema',
+            'status',
+            'count',
+            'present',
+            'missing',
+            'panel_status',
+            'firmware',
+            'mismatched',
+            'ref_crc32',
+            'fp_len',
+            'presence_valid',
+            'fp_valid',
+            'fp_in_progress',
+            'scan_id',
+            'age_ms'
+        ]);
+        check('run meta status ok when presence is valid', [meta.schema, meta.status], [1, 'ok']);
+        check('run meta firmware', meta.firmware, [
+            { crc32: '0x9BE0D3C7', panels: entries.map((_, i) => i + 1) }
+        ]);
+        check('run meta ref_crc32 null without SD image', meta.ref_crc32, null);
+        check('run meta per-panel status array', meta.panel_status.length, 20);
+        check('run meta explicit status wins', Inv.toRunMeta(inv, 'pending').status, 'pending');
+    }
+
+    console.log('\n=== readAll: incoherent pages (wrong first / panel_count) → re-read ===');
+    {
+        const e0 = Array.from({ length: 32 }, () => ({ status: 2 }));
+        const e1 = Array.from({ length: 8 }, () => ({ status: 2 }));
+        let served = 0;
+        const f = {
+            calls: [],
+            send: async (bytes) => {
+                const first = bytes.length >= 3 ? bytes[2] : 0;
+                f.calls.push(first);
+                served++;
+                // The first second page comes back for the wrong offset; the retry is right.
+                const wrongFirst = served === 2 ? 0 : first;
+                return page({
+                    count: 40,
+                    flags: 1,
+                    first: wrongFirst,
+                    scanId: 5,
+                    entries: first ? e1 : e0
+                });
+            }
+        };
+        const r = await Inv.readAll(f.send);
+        check('re-read after a wrong-offset page', f.calls, [0, 32, 0, 32]);
+        check('40 entries after the retry', r.entries.length, 40);
+    }
+
+    console.log('\n=== readAll: two pages (48 panels), consistent ===');
+    {
+        const e0 = Array.from({ length: 32 }, () => ({ status: 3, crc32: fwA }));
+        const e1 = Array.from({ length: 16 }, (_, i) => ({
+            status: i === 4 ? 4 : 3,
+            crc32: i === 4 ? fwB : fwA
+        }));
+        const f = fakeSend({
+            0: page({
+                count: 48,
+                flags: 0x0b,
+                first: 0,
+                scanId: 9,
+                refCrc: fwA,
+                fpLen: 135248,
+                entries: e0
+            }),
+            32: page({
+                count: 48,
+                flags: 0x0b,
+                first: 32,
+                scanId: 9,
+                refCrc: fwA,
+                fpLen: 135248,
+                entries: e1
+            })
+        });
+        const inv = Inv.summarize(await Inv.readAll(f.send));
+        check('two requests: first=0 then 32', f.calls, [0, 32]);
+        check('48 statuses', inv.statuses.length, 48);
+        check('refPresent', inv.refPresent, true);
+        check('mismatched = the fw_differs panel (37)', inv.mismatched, [37]);
+        check(
+            'firmware groups sorted by size',
+            inv.firmware.map((g) => [g.hex, g.panels.length]),
+            [
+                ['0x9BE0D3C7', 47],
+                ['0x03E66C15', 1]
+            ]
+        );
+        checkBool(
+            'describe flags the mismatch',
+            Inv.describe(inv).includes('1 ≠ SD panel.bin'),
+            Inv.describe(inv)
+        );
+        check('run meta ref_crc32', Inv.toRunMeta(inv).ref_crc32, '0x9BE0D3C7');
+    }
+
+    console.log('\n=== readAll: scan_id changes between pages → re-read ===');
+    {
+        const e0 = Array.from({ length: 32 }, () => ({ status: 2 }));
+        const e1 = Array.from({ length: 16 }, () => ({ status: 2 }));
+        const pages = {
+            0: page({ count: 48, flags: 0x01, first: 0, scanId: 1, entries: e0 }),
+            32: page({ count: 48, flags: 0x01, first: 32, scanId: 2, entries: e1 }) // a rescan landed
+        };
+        const f = fakeSend(pages, (n) => {
+            if (n === 2)
+                pages[0] = page({ count: 48, flags: 0x01, first: 0, scanId: 2, entries: e0 }); // page 0 now agrees
+        });
+        const inv = Inv.summarize(await Inv.readAll(f.send));
+        check('re-read from first=0 after the mismatch', f.calls, [0, 32, 0, 32]);
+        check('settled on scan_id 2', inv.scanId, 2);
+    }
+    {
+        // Never settles → throws after `retries` attempts.
+        let flip = 0;
+        const e = Array.from({ length: 32 }, () => ({ status: 2 }));
+        const f = fakeSend({}, () => {});
+        f.send = async (bytes) => {
+            const first = bytes.length >= 3 ? bytes[2] : 0;
+            flip++;
+            return page({
+                count: 40,
+                flags: 1,
+                first,
+                scanId: flip,
+                entries: first ? e.slice(0, 8) : e
+            });
+        };
+        let threw = null;
+        try {
+            await Inv.readAll(f.send, { retries: 2 });
+        } catch (err) {
+            threw = err.message;
+        }
+        check('gives up after retries', threw, 'scan_id changed between pages');
+    }
+
+    console.log('\n=== summarize: presence-only, partial, no-ISP ===');
+    {
+        const entries = [
+            { status: 5, crc32: fwA },
+            { status: 1 },
+            { status: 6 },
+            { status: 5, crc32: fwA },
+            { status: 5, crc32: fwB }
+        ];
+        const inv = Inv.summarize({
+            pages: [
+                Wire.decodePanelInventory(
+                    page({ count: 5, flags: 0x15, first: 0, scanId: 4, entries })
+                )
+            ],
+            entries: Wire.decodePanelInventory(
+                page({ count: 5, flags: 0x15, first: 0, scanId: 4, entries })
+            ).entries
+        });
+        check('present excludes absent', inv.present, [1, 3, 4, 5]);
+        check('missing', inv.missing, [2]);
+        check('noIsp', inv.noIsp, [3]);
+        check('fpInProgress', inv.fpInProgress, true);
+        check('minority fw + no-ISP are mismatched', inv.mismatched, [3, 5]);
+        checkBool(
+            'describe says fingerprinting…',
+            Inv.describe(inv).includes('fingerprinting…'),
+            Inv.describe(inv)
+        );
+        const pending = Inv.summarize({
+            pages: [
+                Wire.decodePanelInventory(
+                    page({
+                        count: 5,
+                        flags: 0x00,
+                        first: 0,
+                        scanId: 0,
+                        entries: entries.map(() => ({ status: 0 }))
+                    })
+                )
+            ],
+            entries: []
+        });
+        check('describe before the boot scan', Inv.describe(pending), 'panel scan pending');
+        check('toRunMeta(pending) status', Inv.toRunMeta(pending).status, 'pending');
+        check(
+            'toRunMeta records presence_valid=false',
+            Inv.toRunMeta(pending).presence_valid,
+            false
+        );
+        check('describe(null)', Inv.describe(null), '—');
+        check('toRunMeta(null) = unsupported, never null', Inv.toRunMeta(null), {
+            schema: 1,
+            status: 'unsupported'
+        });
+        check('toRunMeta(null, failed)', Inv.toRunMeta(null, 'failed'), {
+            schema: 1,
+            status: 'failed'
+        });
+    }
+
+    console.log('\n=== arena_studio.html wiring ===');
+    checkBool(
+        'studio loads js/studio-panel-inventory.js as a classic script',
+        /<script src="js\/studio-panel-inventory\.js"><\/script>/.test(studioHtml)
+    );
+    checkBool(
+        'studio reads the inventory on link-up (refreshPanelInventory defined + called)',
+        /Studio\.refreshPanelInventory = async function/.test(studioHtml) &&
+            (studioHtml.match(/await Studio\.refreshPanelInventory\(\)/g) || []).length >= 2
+    );
+    checkBool(
+        'inventory read is gated on the panel_inventory feature',
+        /features[\s\S]{0,120}includes\('panel_inventory'\)/.test(studioHtml)
+    );
+    checkBool(
+        'run_metadata carries panels with its status',
+        /toRunMeta\(Studio\.panels, Studio\.panelsStatus\)/.test(studioHtml)
+    );
+    checkBool(
+        'run start re-reads the inventory before startRunLog (run-start snapshot)',
+        /await Studio\.refreshPanelInventory\(\{ quiet: true \}\);\s*\n\s*startRunLog\(isExperiment\);/.test(
+            studioHtml
+        )
+    );
+    checkBool(
+        'a failed read never leaves a stale inventory',
+        /Studio\.panels = null;\s*\n\s*if \(!Studio\.session/.test(studioHtml) &&
+            /catch \(e\) \{\s*\n\s*Studio\.panelsStatus = 'failed';/.test(studioHtml)
+    );
+    checkBool(
+        'disconnect clears features + panels',
+        /Studio\.features = null;\s*\n\s*Studio\.panels = null;/.test(studioHtml)
+    );
+    checkBool('provenance box shows panels', /id="pvPanels"/.test(studioHtml));
+    checkBool(
+        'Console fw panel has inventory + rescan buttons',
+        /data-cmd="cinv"/.test(studioHtml) && /data-cmd="cinvscan"/.test(studioHtml)
+    );
+    checkBool(
+        'Rescan stops the display, so it is guardDestructive',
+        /cinvscan: \(\) => guardDestructive\(async/.test(studioHtml)
+    );
+    checkBool(
+        'follow-up reads go through the gated scheduler (no bare setTimeout)',
+        (studioHtml.match(/Studio\.scheduleInventoryFollowUp\(/g) || []).length >= 2 &&
+            !/setTimeout\(\(\) => Studio\.refreshPanelInventory\(\), 3000\)/.test(studioHtml)
+    );
+
+    console.log('\n=== Summary ===');
+    console.log(`${total - failures} / ${total} checks passed`);
+    process.exit(failures ? 1 : 0);
+})();