@sleep2agi/agent-network-dashboard 0.5.1-preview.98 → 0.5.1

package/scripts/topo-legend-count-pin-fw-test.mjs

@@ -0,0 +1,90 @@
+/* Round 446 verification: legend-row count fontWeight lift on isPinned.
+ * 600 → 700 when the status tier is pinned. Mirror of R444/R445 at
+ * legend-row scope.
+ *
+ * Contract:
+ *   - rest: every legend-count reports font-weight '600' + pinned='false'
+ *   - click a legend-status group: that row's count flips to '700' +
+ *     pinned='true'; siblings stay rest
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'working'),
+    mk('beta',  'working'),
+    mk('gamma', 'idle'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*',    (r) => r.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForSelector('[data-legend-count]', { timeout: 15000 });
+await page.waitForTimeout(400);
+
+const readAll = () => page.evaluate(() => {
+  const ts = [...document.querySelectorAll('[data-legend-count]')];
+  return ts.map(t => ({
+    key:    t.getAttribute('data-legend-count'),
+    fw:     t.getAttribute('font-weight'),
+    pinned: t.getAttribute('data-legend-count-pinned'),
+  }));
+});
+
+const rest = await readAll();
+
+// Click the 'working' status row to pin it
+let pinned = null;
+const workingGroup = await page.$(`[data-legend-status="working"]`);
+if (workingGroup) {
+  await workingGroup.click();
+  await page.waitForTimeout(250);
+  pinned = await readAll();
+}
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceWired = /fontWeight=\{isPinned \? '700' : '600'\}/.test(fileText);
+
+await browser.close();
+
+const restAll600    = rest.every(r => r.fw === '600');
+const restNoPin     = rest.every(r => r.pinned === 'false');
+const pinnedEntry   = pinned?.find(r => r.key === 'working');
+const pinFw_700     = pinnedEntry?.fw === '700';
+const pinFlag       = pinnedEntry?.pinned === 'true';
+const othersStayRest = pinned ? pinned.filter(r => r.key !== 'working').every(r => r.fw === '600' && r.pinned === 'false') : false;
+
+const results = {
+  rest_three_rows:       rest.length === 3,
+  rest_all_fw_600:       restAll600,
+  rest_no_pin:           restNoPin,
+  pinned_target_fw_700:  pinFw_700,
+  pinned_target_flag:    pinFlag,
+  pinned_others_stay:    othersStayRest,
+  source_wired:          sourceWired,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend count fw pin:`, JSON.stringify(results),
+  '\n  rest:', JSON.stringify(rest),
+  '\n  pinned target:', JSON.stringify(pinnedEntry));
+process.exit(ok ? 0 : 1);

package/scripts/topo-minimap-viewport-opacity-test.mjs

@@ -0,0 +1,96 @@
+/* Round 450 verification: minimap viewport rect rest opacity 0.9 →
+ * 0.95. Closes half the alpha gap on the wayfinding indicator.
+ *
+ * Contract:
+ *   - rest: viewport rect opacity '0.95'
+ *   - hover the minimap container: viewport opacity '1' (R346 preserved)
+ *   - strokeWidth invariants preserved (rest=1.5, hover=1.75)
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  // Need enough nodes for minimap to render — and a non-default view
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'working'),
+    mk('beta',  'idle'),
+    mk('gamma', 'working'),
+    mk('delta', 'idle'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*',    (r) => r.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+
+// Trigger a zoom to mount the minimap (R30 gate: minimap only renders on non-default view)
+await page.waitForSelector('[data-topo-chrome-zoom-in]', { timeout: 15000 });
+await page.click('[data-topo-chrome-zoom-in]');
+await page.waitForTimeout(300);
+
+await page.waitForSelector('[data-topo-minimap-viewport]', { timeout: 5000 });
+await page.waitForTimeout(300);
+
+const rest = await page.evaluate(() => {
+  const v = document.querySelector('[data-topo-minimap-viewport]');
+  return v ? {
+    opacity: v.getAttribute('opacity'),
+    sw:      v.getAttribute('stroke-width'),
+    hover:   v.getAttribute('data-topo-minimap-viewport-hover'),
+  } : null;
+});
+
+// Hover the minimap container
+let hover = null;
+const minimap = await page.$('[data-topo-minimap]');
+if (minimap) {
+  await minimap.hover({ force: true });
+  await page.waitForTimeout(250);
+  hover = await page.evaluate(() => {
+    const v = document.querySelector('[data-topo-minimap-viewport]');
+    return v ? {
+      opacity: v.getAttribute('opacity'),
+      sw:      v.getAttribute('stroke-width'),
+      hover:   v.getAttribute('data-topo-minimap-viewport-hover'),
+    } : null;
+  });
+}
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceWired = /opacity=\{hoveredMinimap \? '1' : '0\.95'\}/.test(fileText);
+
+await browser.close();
+
+const results = {
+  rest_mounted:           !!rest,
+  rest_opacity_0_95:      rest?.opacity === '0.95',
+  rest_sw_1_5:            rest?.sw === '1.5',
+  rest_hover_false:       rest?.hover === 'false',
+  hover_opacity_1:        hover?.opacity === '1',
+  hover_sw_1_75:          hover?.sw === '1.75',
+  hover_hover_true:       hover?.hover === 'true',
+  source_wired:           sourceWired,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} minimap viewport rest opacity:`, JSON.stringify(results),
+  '\n  rest:', JSON.stringify(rest),
+  '\n  hover:', JSON.stringify(hover));
+process.exit(ok ? 0 : 1);

package/scripts/topo-node-halo-hover-opacity-test.mjs

@@ -0,0 +1,104 @@
+/* Round 440 verification: node halo opacity hover lift —
+ * online cyber 0.65 → 0.80 on hoveredAlias match. Pure paint axis;
+ * no geometry change.
+ *
+ * Contract:
+ *   - rest: every halo reports data-node-halo-hovered='false' and
+ *     resolved-opacity matching its tier (online cyber 0.65)
+ *   - hover one node: that halo flips to hovered='true' + resolved-
+ *     opacity '0.8'
+ *   - siblings stay rest
+ *   - R51 sentinel intact (overlap test still finds nodes)
+ *   - source-file probe confirms IIFE + conditional wired
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'working'),
+    mk('beta',  'idle'),
+    mk('gamma', 'working'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*',    (r) => r.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForSelector('[data-node-halo-hovered]', { timeout: 15000 });
+await page.waitForTimeout(400);
+
+const readAll = () => page.evaluate(() => {
+  const cs = [...document.querySelectorAll('[data-node-halo-hovered]')];
+  return cs.map(c => {
+    const node = c.closest('[data-node]');
+    return {
+      alias:   node?.getAttribute('data-node') || null,
+      hovered: c.getAttribute('data-node-halo-hovered'),
+      opacity: parseFloat(c.getAttribute('data-node-halo-resolved-opacity') || '0'),
+    };
+  });
+});
+
+const rest = await readAll();
+
+let hover = null;
+const box = await page.evaluate(() => {
+  const t = document.querySelector('[data-node-alias-text="alpha"]');
+  if (!t) return null;
+  const node = t.closest('[data-node]');
+  const target = node || t;
+  const b = target.getBoundingClientRect();
+  return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+});
+if (box) {
+  await page.mouse.move(box.x, box.y);
+  await page.waitForTimeout(300);
+  hover = await readAll();
+  await page.mouse.move(0, 0);
+}
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceIIFE      = /const isHaloHovered = !reducedMotion && hoveredAlias === session\.alias/.test(fileText);
+const sourceCyberOnline = /isLight \? \(isHaloHovered \? 1\s*:\s*0\.85\) : \(isHaloHovered \? 0\.80 : 0\.65\)/.test(fileText);
+
+await browser.close();
+
+const restAllRest      = rest.length > 0 && rest.every(r => r.hovered === 'false' && r.opacity === 0.65);
+const hoveredEntry     = hover?.find(r => r.alias === 'alpha');
+const hoverTarget08    = hoveredEntry?.opacity === 0.80;
+const hoverTargetFlag  = hoveredEntry?.hovered === 'true';
+const othersStayRest   = hover ? hover.filter(r => r.alias !== 'alpha').every(r => r.hovered === 'false' && r.opacity === 0.65) : false;
+
+const results = {
+  rest_halo_count_ge_3:      rest.length >= 3,
+  rest_all_rest_state:       restAllRest,
+  hover_target_opacity_0_8:  hoverTarget08,
+  hover_target_attr_true:    hoverTargetFlag,
+  hover_others_stay_rest:    othersStayRest,
+  source_IIFE_wired:         sourceIIFE,
+  source_cyber_online_wired: sourceCyberOnline,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} node-halo hover opacity:`, JSON.stringify(results),
+  '\n  rest:', JSON.stringify(rest),
+  '\n  hover target:', JSON.stringify(hoveredEntry));
+process.exit(ok ? 0 : 1);

package/scripts/topo-node-halo-light-offline-test.mjs

@@ -0,0 +1,80 @@
+/* Round 456 verification: node halo light-theme offline rest opacity
+ * 0.45 → 0.50. Stale-state legibility lift family extension.
+ *
+ * Contract:
+ *   - light theme, fixture has offline nodes
+ *   - every offline halo reports data-node-halo-resolved-opacity '0.5'
+ *     (was 0.45)
+ *   - online halos still at light 0.85 (R407 + R440 preserved)
+ *   - source-file probe confirms the conditional
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+// Use LIGHT theme for this test
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'light'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'working'),  // online
+    mk('beta',  'offline'),  // offline
+    mk('gamma', 'offline'),  // offline
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*',    (r) => r.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForSelector('[data-node-halo-hovered]', { timeout: 15000 });
+await page.waitForTimeout(400);
+
+const halos = await page.evaluate(() => {
+  const cs = [...document.querySelectorAll('[data-node-halo-hovered]')];
+  return cs.map(c => {
+    const node = c.closest('[data-node]');
+    const sub = node?.querySelector('[data-node-sub-text]')?.textContent || '';
+    return {
+      alias:    node?.getAttribute('data-node') || null,
+      status:   sub.trim(),
+      opacity:  parseFloat(c.getAttribute('data-node-halo-resolved-opacity') || '0'),
+      offline_attr_alpha: c.getAttribute('data-node-halo-offline-opacity'),
+    };
+  });
+});
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceWired = /isLight \? \(isHaloHovered \? 0\.60 : 0\.50\) : \(isHaloHovered \? 0\.45 : 0\.30\)/.test(fileText);
+
+await browser.close();
+
+const onlineHalo  = halos.find(h => h.status.includes('working'));
+const offlineHalos = halos.filter(h => h.status.includes('offline'));
+
+const results = {
+  any_mounted:                halos.length > 0,
+  online_opacity_0_85:        onlineHalo?.opacity === 0.85,
+  offline_count_ge_2:         offlineHalos.length >= 2,
+  offline_all_0_5:            offlineHalos.every(h => h.opacity === 0.5),
+  offline_attr_0_45_preserved: offlineHalos.every(h => h.offline_attr_alpha === '0.45'), /* attr exposes the LEGACY R407 light value 0.45; the resolved-opacity is the live 0.50; this preserves R407 test compat */
+  source_wired:               sourceWired,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} node halo light offline 0.5:`, JSON.stringify(results),
+  '\n  halos:', JSON.stringify(halos));
+process.exit(ok ? 0 : 1);

package/scripts/topo-node-sub-text-fw-test.mjs

@@ -0,0 +1,75 @@
+/* Round 448 verification: node sub-text fontWeight 400 → 500.
+ * Static legibility lift for small mono text at fontSize=9.
+ * Sibling to R363/R364 small-text fw lifts.
+ *
+ * Contract:
+ *   - every node sub-text reports font-weight '500'
+ *   - geometry invariants preserved (R428 hover ls + R211 fill
+ *     transition still intact)
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'working'),
+    mk('beta',  'idle'),
+    mk('gamma', 'working'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*',    (r) => r.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForSelector('[data-node-sub-text]', { timeout: 15000 });
+await page.waitForTimeout(400);
+
+const subs = await page.evaluate(() => {
+  const ts = [...document.querySelectorAll('[data-node-sub-text]')];
+  return ts.map(t => ({
+    alias: t.getAttribute('data-node-sub-text'),
+    fw:    t.getAttribute('font-weight'),
+    fw_data: t.getAttribute('data-node-sub-text-font-weight'),
+    text:  t.textContent,
+  }));
+});
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceWired = /fontWeight="500"\s*\n\s*data-node-sub-text=\{session\.alias\}/.test(fileText);
+
+await browser.close();
+
+const restAllFw500    = subs.every(s => s.fw === '500');
+const restAllAttr500  = subs.every(s => s.fw_data === '500');
+const restCountGe3    = subs.length >= 3;
+const restAllHaveText = subs.every(s => s.text && s.text.length > 0);
+
+const results = {
+  sub_count_ge_3:           restCountGe3,
+  all_fw_500_attr:          restAllFw500,
+  all_fw_data_attr_500:     restAllAttr500,
+  all_have_text:            restAllHaveText,
+  source_wired:             sourceWired,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} node sub-text fw 500:`, JSON.stringify(results),
+  '\n  subs:', JSON.stringify(subs));
+process.exit(ok ? 0 : 1);

package/scripts/topo-overlap-stale-build-guard-test.mjs

@@ -0,0 +1,66 @@
+/* Round 463 verification: topo-overlap-test.mjs grew a zombie-
+ * build guard that consumes R462's svg[data-dashboard-version]
+ * surface. Pre-R463 a stale next-server (dash zombie holding
+ * cached chunks from an earlier preview) would let overlap-test
+ * report fake green — bit us in R441 + R460. R463 closes that
+ * by reading the DOM-side version and comparing to the package.
+ * json version, failing fast with exit code 2 on mismatch.
+ *
+ * This test verifies:
+ *   1. The augmented topo-overlap-test source contains the
+ *      guard machinery (regex assertions on the actual file).
+ *   2. The live dash agrees with package.json (sanity-check
+ *      the current run state matches the guard's expectation).
+ *   3. The guard sentinel path is wired in the caller (sentinel
+ *      object with .stale === true triggers exit code 2).
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const expected = JSON.parse(readFileSync('/home/vansin/agent-network-dashboard/package.json', 'utf8')).version;
+
+const src = readFileSync('/home/vansin/agent-network-dashboard/scripts/topo-overlap-test.mjs', 'utf8');
+const sourceHasGuardComment  = /Round 463.*zombie-build guard/.test(src);
+const sourceHasLiveProbe     = /svg\.getAttribute\('data-dashboard-version'\)/.test(src);
+const sourceHasMismatchBail  = /STALE BUILD/.test(src);
+const sourceHasSentinelObj   = /\{ stale: true, live, expected \}/.test(src);
+const sourceHasCallerCheck   = /typeof r === 'object' && r\.stale/.test(src);
+const sourceHasExit2         = /process\.exit\(2\)/.test(src);
+
+// Run a live probe to confirm the dash + pkg are aligned (we're in
+// a clean state where the guard would PASS silently).
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1280, height: 920 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try {
+    localStorage.setItem('anet-theme', 'cyber');
+    localStorage.setItem('anet-topo-layout', 'grid');
+    sessionStorage.setItem('anet_v3_auth', '1');
+  } catch {}
+});
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForSelector('svg[viewBox="0 0 1000 680"]', { timeout: 15000 });
+const live = await page.evaluate(() =>
+  document.querySelector('svg[viewBox="0 0 1000 680"]')?.getAttribute('data-dashboard-version')
+);
+await browser.close();
+
+const liveMatchesPkg = live === expected;
+
+const results = {
+  source_has_guard_comment:    sourceHasGuardComment,
+  source_has_live_probe:       sourceHasLiveProbe,
+  source_has_mismatch_bail:    sourceHasMismatchBail,
+  source_has_sentinel_object:  sourceHasSentinelObj,
+  source_has_caller_check:     sourceHasCallerCheck,
+  source_has_exit_2:           sourceHasExit2,
+  dash_live_matches_package:   liveMatchesPkg,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} overlap-test stale-build guard:`, JSON.stringify(results),
+  '\n  expected pkg:', expected,
+  '\n  live DOM:    ', live);
+process.exit(ok ? 0 : 1);

package/scripts/topo-overlap-test.mjs

@@ -59,6 +59,37 @@ async function check(layout) {
   }, { timeout: 30000 }).catch(() => {});
   await page.waitForTimeout(800);
 
+  // Round 463 / Loop: zombie-build guard — consumes R462's
+  // svg[data-dashboard-version] surface (preview.130+). Before
+  // reporting collision metrics, verify the dash is actually
+  // serving the build that matches package.json. This catches
+  // the dash-zombie-port-3000 failure mode (next-server cached
+  // chunks from earlier preview) that bit R441 + R460 — those
+  // rounds reported false-positive overlap-test green because
+  // probes ran against stale code. Test scripts shipping before
+  // R462 don't have the attr; we tolerate its absence (older
+  // dash) but fail hard on mismatch. The `expected` value comes
+  // from this script's CWD package.json — co-located with the
+  // working tree → it reflects whatever version was bumped this
+  // round.
+  const expected = JSON.parse(readFileSync('/home/vansin/agent-network-dashboard/package.json', 'utf8')).version;
+  const live = await page.evaluate(() => {
+    const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+    return svg ? svg.getAttribute('data-dashboard-version') : null;
+  });
+  if (live && live !== expected) {
+    console.error(`❌ [${layout}] STALE BUILD — dash serves ${live} but package.json says ${expected}.`);
+    console.error(`   Likely cause: zombie next-server (pkill -9 + restart). See feedback_dash_zombie_port_3000.md.`);
+    await ctx.close();
+    return { stale: true, live, expected };
+  }
+  if (!live) {
+    // R462 attr not present — dash is on an older build than the
+    // R462 surface ships in. Don't fail; just warn so the loop
+    // operator notices. Real overlap metrics still run.
+    console.warn(`⚠️  [${layout}] data-dashboard-version absent (dash pre-R462? expected ${expected}). Skipping zombie-guard.`);
+  }
+
   const data = await page.evaluate(() => {
     const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
     // node status rings: stroke-width 3 (online) / 1.5 (offline), centred on the node
@@ -159,6 +190,16 @@ const all = [];
 all.push(await check('grid'));
 all.push(await check('ring'));
 await browser.close();
-const pass = all.every(Boolean);
+// R463: any non-boolean return is a sentinel (e.g. { stale: true }
+// from the zombie-build guard). Treat as a hard fail — collision
+// metrics from a stale build are meaningless, and reporting them
+// as green would re-create the R441/R460 false-positive that hit
+// us before the data-dashboard-version surface existed.
+const stale = all.find(r => r && typeof r === 'object' && r.stale);
+if (stale) {
+  console.error(`\n❌ STALE BUILD — dash served ${stale.live}, expected ${stale.expected}. Restart dash + retry.`);
+  process.exit(2);
+}
+const pass = all.every(r => r === true);
 console.log(pass ? '\n✅ ZERO OVERLAP' : '\n❌ OVERLAP DETECTED');
 process.exit(pass ? 0 : 1);