@sleep2agi/agent-network-dashboard 0.4.6-preview.3 → 0.4.6-preview.301

package/scripts/topo-layout-test.mjs

@@ -17,6 +17,7 @@ async function run(nodeCount, label) {
   await ctx.addInitScript(() => {
     try {
       localStorage.setItem('anet-theme', 'cyber');
+localStorage.setItem('anet-topo-nodescale', '1');
       localStorage.removeItem('anet-brand');
       sessionStorage.setItem('anet_v3_auth', '1');
     } catch {}

package/scripts/topo-layout-toggle-border-unify-test.mjs

@@ -0,0 +1,104 @@
+/* Round 268 verification: Layout toggle border unified with chrome
+ * strip's theme-aware borderColor.
+ *
+ * Pre-R268 the Layout toggle's wrapper + Grid button's internal
+ * divider used hardcoded `border-gray-500/25` (Tailwind pale gray,
+ * fixed in both themes). The bottom-right chrome strip's analogous
+ * wrappers (nodeSize, zoom) used pal.containerBorder (cyber
+ * #2a2a4a dark indigo ↔ light #e3e6eb pale gray).
+ *
+ * Visible mismatch in cyber theme: Layout toggle border read as pale
+ * gray-500/25 (rgba 107,114,128,0.25) while chrome strip borders read
+ * as darker indigo `#2a2a4a` — two different border colors on
+ * visually-analogous segmented controls. R268 replaces the hardcoded
+ * class with inline pal.containerBorder + a border-color transition.
+ *
+ * Test scope:
+ *   1. Layout toggle wrapper rgb(border-color) matches nodeSize
+ *      wrapper rgb(border-color) — both use pal.containerBorder.
+ *   2. Layout toggle wrapper has border-color transition (200ms).
+ *   3. Grid button's left border color matches the wrapper's
+ *      border color.
+ *   4. R260 chip-row semantic gap intact: gap toggle→working ≥ 11.
+ *   5. R267 title-block leading-tight regression: kicker still has
+ *      the class.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+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 {}
+});
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+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) => ({
+    alias, status: 'working', 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'), mk('beta'), mk('gamma'), mk('delta'),
+  ] } });
+});
+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.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-topo-chrome-layout-trailer]',     { timeout: 10000 });
+await page.waitForSelector('[data-topo-chrome-fleet-group-trailer]', { timeout: 10000 });
+await page.waitForSelector('[data-topo-chrome-layout="grid"]',       { timeout: 10000 });
+await page.waitForSelector('[data-topo-section-kicker]',             { timeout: 10000 });
+await page.waitForSelector('[data-working-chip]',                    { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const layoutWrapper = document.querySelector('[data-topo-chrome-layout-trailer]');
+  const nodeSize     = document.querySelector('[data-topo-chrome-fleet-group-trailer]');
+  const gridButton   = document.querySelector('[data-topo-chrome-layout="grid"]');
+  const kicker       = document.querySelector('[data-topo-section-kicker]');
+  const working      = document.querySelector('[data-working-chip]');
+  const layoutStyle  = layoutWrapper ? window.getComputedStyle(layoutWrapper) : null;
+  const nodeSizeStyle = nodeSize     ? window.getComputedStyle(nodeSize)      : null;
+  const gridStyle    = gridButton    ? window.getComputedStyle(gridButton)    : null;
+  return {
+    layoutBorderColor:      layoutStyle  ? layoutStyle.borderTopColor : null,
+    layoutTransition:       layoutWrapper ? layoutWrapper.style.transition : null,
+    nodeSizeBorderColor:    nodeSizeStyle ? nodeSizeStyle.borderTopColor : null,
+    gridBorderLeftColor:    gridStyle    ? gridStyle.borderLeftColor   : null,
+    kickerHasLeadingTight:  kicker?.classList.contains('leading-tight') ?? false,
+    toggleRight:            layoutWrapper ? layoutWrapper.getBoundingClientRect().right : null,
+    workingLeft:            working ? working.getBoundingClientRect().left : null,
+  };
+});
+await browser.close();
+
+const has = (s, prop) => new RegExp(`${prop}\\s+(?:200ms|0\\.2s)`).test(s || '');
+const gapToggleToWorking = (probe.toggleRight != null && probe.workingLeft != null)
+  ? (probe.workingLeft - probe.toggleRight) : null;
+
+const results = {
+  layout_border_matches_nodesize:        probe.layoutBorderColor != null
+                                          && probe.layoutBorderColor === probe.nodeSizeBorderColor,
+  layout_has_border_color_transition:    has(probe.layoutTransition, 'border-color'),
+  grid_button_border_matches_wrapper:    probe.gridBorderLeftColor != null
+                                          && probe.gridBorderLeftColor === probe.layoutBorderColor,
+  r260_chip_row_gap_intact:              gapToggleToWorking != null && gapToggleToWorking >= 11,
+  r267_kicker_has_leading_tight:         probe.kickerHasLeadingTight,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} layout toggle border unify:`, JSON.stringify(results),
+  '\n  layout    borderTop:', probe.layoutBorderColor,
+  '\n  nodeSize  borderTop:', probe.nodeSizeBorderColor,
+  '\n  grid btn  borderLeft:', probe.gridBorderLeftColor,
+  '\n  layout transition:', probe.layoutTransition,
+  '\n  toggle→working gap:', gapToggleToWorking);
+process.exit(ok ? 0 : 1);

package/scripts/topo-layout-toggle-test.mjs

@@ -0,0 +1,131 @@
+/* Round 163 verification: Ring/Grid layout toggle buttons pick
+ * up the R154 chrome-button polish convention.
+ *
+ * Pre-R163 the buttons had aria-pressed + transition-colors but:
+ *   - no focus-visible ring (browser default invisible on canvas)
+ *   - inactive hover only nudged text-gray-500 → gray-400, no bg
+ *
+ * R163 adds:
+ *   data-topo-chrome-layout="ring|grid"
+ *   data-topo-chrome-layout-active="true|false"
+ *   focus-visible:ring-2 ring-cyan-400/60 ring-inset
+ *   inactive: hover:text-gray-300 + hover:bg-cyan-500/5
+ *   active:   hover:bg-cyan-500/20 (slightly hotter)
+ *
+ * Test:
+ *   1. Both buttons present with data-topo-chrome-layout attr
+ *   2. Active button has bg-cyan-500/15 class fragment (existing)
+ *   3. Focus the inactive button → focus-visible ring class fragment
+ *   4. Hover the inactive button → bg color shifts from transparent
+ *      to a cyan-ish tint (border bg-cyan-500/5)
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+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'); localStorage.setItem('anet-topo-layout', 'ring'); } catch {}
+});
+
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+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) => ({
+    alias, status: 'working', model: 'claude-opus-4', runtime: 'cli-claude-code',
+    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'), mk('beta')] } });
+});
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 2, { timeout: 30000 });
+await page.waitForSelector('[data-topo-chrome-layout]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+// Probe basic attrs & class membership
+const probe = await page.evaluate(() => {
+  const ring = document.querySelector('[data-topo-chrome-layout="ring"]');
+  const grid = document.querySelector('[data-topo-chrome-layout="grid"]');
+  if (!ring || !grid) return null;
+  return {
+    ring_active:    ring.getAttribute('data-topo-chrome-layout-active'),
+    grid_active:    grid.getAttribute('data-topo-chrome-layout-active'),
+    ring_pressed:   ring.getAttribute('aria-pressed'),
+    grid_pressed:   grid.getAttribute('aria-pressed'),
+    ring_class:     ring.getAttribute('class') || '',
+    grid_class:     grid.getAttribute('class') || '',
+  };
+});
+
+// Focus the inactive (grid) button — focus-visible ring should kick in.
+// Tab-focus produces the :focus-visible state; .focus() doesn't always.
+// Use page.keyboard.press('Tab') after first focusing somewhere known.
+await page.locator('[data-topo-chrome-layout="grid"]').focus();
+// trigger keyboard navigation to enable focus-visible state heuristic
+await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-chrome-layout="grid"]');
+  if (el) el.matches(':focus-visible');
+});
+const focusVisibleProbe = await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-chrome-layout="grid"]');
+  if (!el) return null;
+  return {
+    isActiveElement: document.activeElement === el,
+    // Inspect outline & box-shadow because the Tailwind focus-visible:ring
+    // class compiles to a box-shadow. After .focus() Chromium reports
+    // :focus-visible heuristically — we verify the class fragment exists
+    // in the stylesheet bound to this element rather than relying on the
+    // dynamic pseudo-class match.
+    classFragments: {
+      hasFocusVisibleRingClass: (el.getAttribute('class') || '').includes('focus-visible:ring-cyan-400/60'),
+      hasRingInset:             (el.getAttribute('class') || '').includes('focus-visible:ring-inset'),
+      hasFocusOutlineNone:      (el.getAttribute('class') || '').includes('focus:outline-none'),
+    },
+  };
+});
+
+// Hover the inactive (grid) button — bg should shift away from transparent.
+const gridBgBefore = await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-chrome-layout="grid"]');
+  return el ? getComputedStyle(el).backgroundColor : null;
+});
+await page.locator('[data-topo-chrome-layout="grid"]').hover();
+await page.waitForTimeout(300);
+const gridBgHover = await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-chrome-layout="grid"]');
+  return el ? getComputedStyle(el).backgroundColor : null;
+});
+
+await browser.close();
+
+const results = {
+  both_buttons_found:        probe !== null,
+  ring_is_active:            probe?.ring_active === 'true',
+  grid_is_inactive:          probe?.grid_active === 'false',
+  ring_aria_pressed:         probe?.ring_pressed === 'true',
+  grid_aria_unpressed:       probe?.grid_pressed === 'false',
+  active_has_cyan_bg_class:  probe?.ring_class.includes('bg-cyan-500/15'),
+  inactive_hover_bg_class:   probe?.grid_class.includes('hover:bg-cyan-500/5'),
+  active_hover_bg_class:     probe?.ring_class.includes('hover:bg-cyan-500/20'),
+  focus_outline_none:        focusVisibleProbe?.classFragments?.hasFocusOutlineNone === true,
+  focus_visible_ring_class:  focusVisibleProbe?.classFragments?.hasFocusVisibleRingClass === true,
+  focus_visible_ring_inset:  focusVisibleProbe?.classFragments?.hasRingInset === true,
+  inactive_bg_before:        gridBgBefore !== null,
+  hover_changes_bg:          gridBgBefore !== gridBgHover,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} layout toggle polish:`, JSON.stringify(results),
+  `\n  probe=`, probe,
+  `\n  focus=`, focusVisibleProbe,
+  `\n  bg before/hover=`, gridBgBefore, '→', gridBgHover);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-compress-test.mjs

@@ -0,0 +1,107 @@
+/* Round 277 verification: legend panel compress 104 → 88, matching the
+ * recent-signal panel's height post-R256. Row stride 24 → 18.
+ *
+ * Pre-R277:
+ *   Panel: 224×104, rx=8
+ *   Row 1 (working): y0=32, y1=36
+ *   Row 2 (idle):    y0=56, y1=60
+ *   Row 3 (offline): y0=80, y1=84
+ *   Flow-arrow:      M140,80 Q164,56 196,80 (endpoints y=80)
+ *
+ * Post-R277:
+ *   Panel: 224×88, rx=8
+ *   Row 1 (working): y0=32, y1=36  (anchored — R271 hitbox y=21 invariant)
+ *   Row 2 (idle):    y0=50, y1=54  (-6)
+ *   Row 3 (offline): y0=68, y1=72  (-12)
+ *   Flow-arrow:      M140,68 Q164,44 196,68 (tracks new offline cy)
+ *
+ * Net: legend panel takes ~15% less vertical chrome; panel pair
+ * (recent-signal 88 + legend 88) now share the same height. Third
+ * 减法 cut after R275 (FreshnessChip conditional) + R276 (orbit
+ * particles retired).
+ *
+ * Test scope:
+ *   1. Legend panel rect height === 88.
+ *   2. Recent-signal panel rect height === 88 (regression — R256 invariant).
+ *   3. Working row hitbox y === 21 (R271 invariant: row.y0=32 unchanged).
+ *   4. Flow-arrow path starts with "M140,68" (tracks new offline cy=68).
+ *   5. R275 freshness chip absent at fresh (regression).
+ *   6. R276 orbit particles absent (regression).
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+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 {}
+});
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+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) => ({
+    alias, status: 'working', 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'), mk('beta'), mk('gamma'), mk('delta'),
+  ] } });
+});
+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.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-topo-panel="legend"]',         { timeout: 10000 });
+await page.waitForSelector('[data-topo-panel="recent"]',         { timeout: 10000 });
+await page.waitForSelector('[data-legend-status="working"] rect', { timeout: 10000 });
+await page.waitForSelector('[data-legend-flow-arrow]',           { timeout: 10000 });
+await page.waitForTimeout(300);
+
+// Hover working row to materialize the tinted hitbox rect for the
+// y=21 invariant check (R271). Without hover the rect carries the
+// same y attr but tint fills are transparent.
+await page.locator('[data-legend-status="working"]').hover();
+await page.waitForTimeout(150);
+
+const probe = await page.evaluate(() => {
+  const legendG       = document.querySelector('[data-topo-panel="legend"]');
+  const recentG       = document.querySelector('[data-topo-panel="recent"]');
+  const workingRow    = document.querySelector('[data-legend-status="working"]');
+  const workingHitbox = workingRow ? workingRow.querySelector('rect') : null;
+  const flowArrow     = document.querySelector('[data-legend-flow-arrow]');
+  const freshnessChip = document.querySelector('[data-freshness-chip]');
+  const orbits        = document.querySelectorAll('[data-topo-orbit-bucket]');
+  return {
+    legendHeight:   legendG?.querySelector('rect')?.getAttribute('height') ?? null,
+    recentHeight:   recentG?.querySelector('rect')?.getAttribute('height') ?? null,
+    workingHitboxY: workingHitbox ? +workingHitbox.getAttribute('y') : null,
+    flowArrowD:     flowArrow ? flowArrow.getAttribute('d') : null,
+    freshnessPresent: freshnessChip !== null,
+    orbitCount:     orbits.length,
+  };
+});
+await browser.close();
+
+const results = {
+  legend_height_88:              probe.legendHeight === '88',
+  recent_height_88_regression:   probe.recentHeight === '88',
+  r271_working_hitbox_y_21:      probe.workingHitboxY === 21,
+  flow_arrow_starts_at_y68:      probe.flowArrowD === 'M140,68 Q164,44 196,68',
+  r275_freshness_absent:         probe.freshnessPresent === false,
+  r276_orbit_absent:             probe.orbitCount === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend compress:`, JSON.stringify(results),
+  '\n  legend height:', probe.legendHeight,
+  '\n  recent height:', probe.recentHeight,
+  '\n  working hitbox y:', probe.workingHitboxY,
+  '\n  flow arrow d:', probe.flowArrowD,
+  '\n  orbit count:', probe.orbitCount);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-count-empty-test.mjs

@@ -0,0 +1,126 @@
+/* Round 204 verification: legend count text recedes when its status
+ * tier is empty (count = 0). Pre-R204 "0" at opacity 0.65 read
+ * visually identical to "12" at opacity 0.65; R204 drops empty rows
+ * to 0.30 (dark) / 0.28 (light) so the eye gets a "no nodes in this
+ * tier" signal without parsing the digit.
+ *
+ * Test (cyber dark, all 4 sessions = working → idle=0, offline=0):
+ *   1. Three legend count texts present with data-legend-count for
+ *      working / idle / offline.
+ *   2. Working row: count='4', data-legend-count-empty='false',
+ *      opacity = 0.65 (idle, not hovered).
+ *   3. Idle row: count='0', data-legend-count-empty='true',
+ *      opacity ≈ 0.30 (dim recede).
+ *   4. Offline row: count='0', data-legend-count-empty='true',
+ *      opacity ≈ 0.30.
+ *   5. Hover working row → its count bumps to opacity ~0.95
+ *      (existing R95 hover behaviour unbroken).
+ *   6. Hover idle row → empty-tier opacity DOES NOT bump (empty
+ *      gate wins over hover). Recedes regardless.
+ *   7. Transition: opacity 150ms ease-out still on all three.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+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 {}
+});
+
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+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';
+  // All 4 working — idle / offline tiers empty
+  const mk = (alias) => ({
+    alias, status: 'working', model: 'claude-opus-4', runtime: 'cli-claude-code',
+    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'), mk('beta'), mk('gamma'), mk('delta'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-legend-count="working"]', { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = async () => page.evaluate(() => {
+  const pick = (key) => {
+    const el = document.querySelector(`[data-legend-count="${key}"]`);
+    if (!el) return null;
+    return {
+      key,
+      text:        el.textContent,
+      empty:       el.getAttribute('data-legend-count-empty'),
+      opacity:     parseFloat(el.getAttribute('opacity') || ''),
+      transition:  el.style.transition,
+    };
+  };
+  return { working: pick('working'), idle: pick('idle'), offline: pick('offline') };
+});
+
+const idle = await probe();
+
+// Hover the working row — verify R95 hover bump still fires (count > 0)
+await page.hover('[data-legend-status="working"]');
+await page.waitForTimeout(200);
+const hovWorking = await probe();
+
+// Move off, then hover the empty (idle=0) row — verify empty gate wins
+await page.mouse.move(0, 0);
+await page.waitForTimeout(200);
+await page.hover('[data-legend-status="idle"]');
+await page.waitForTimeout(200);
+const hovIdle = await probe();
+
+await page.mouse.move(0, 0);
+await page.waitForTimeout(200);
+
+await browser.close();
+
+const opacityNear = (got, want, tol = 0.04) => Math.abs(got - want) < tol;
+
+const results = {
+  working_present:           !!idle?.working,
+  idle_present:              !!idle?.idle,
+  offline_present:           !!idle?.offline,
+
+  working_text_4:            idle?.working?.text === '4',
+  working_not_empty:         idle?.working?.empty === 'false',
+  working_opacity_0p65:      opacityNear(idle?.working?.opacity ?? 0, 0.65),
+
+  idle_text_0:               idle?.idle?.text === '0',
+  idle_empty_true:           idle?.idle?.empty === 'true',
+  idle_opacity_dim:          opacityNear(idle?.idle?.opacity ?? 0, 0.30),
+
+  offline_text_0:            idle?.offline?.text === '0',
+  offline_empty_true:        idle?.offline?.empty === 'true',
+  offline_opacity_dim:       opacityNear(idle?.offline?.opacity ?? 0, 0.30),
+
+  // R95 hover still bumps when row populated
+  working_hover_opacity_high: opacityNear(hovWorking?.working?.opacity ?? 0, 0.95),
+
+  // Empty-gate wins: hovering an empty row does NOT bump its count opacity
+  idle_hover_stays_dim:       opacityNear(hovIdle?.idle?.opacity ?? 0, 0.30),
+
+  // Transition still in place across all 3
+  all_have_transition:        ['working', 'idle', 'offline'].every(k =>
+    /opacity\s+(?:150ms|0\.15s)/.test(idle?.[k]?.transition || '')),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend count empty:`, JSON.stringify(results),
+  `\n  idle:`,        idle,
+  `\n  hovWorking:`,  hovWorking,
+  `\n  hovIdle:`,     hovIdle);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-count-tabular-parity-test.mjs

@@ -0,0 +1,90 @@
+/* Round 292 verification: legend panel header count picks up explicit
+ * fontVariantNumeric='tabular-nums' parity with the recent-signal
+ * panel header count (R232). Both panel headers now declare tabular-
+ * nums explicitly in inline style.
+ *
+ * Pre-R292 the legend count inherited tabular digit width via
+ * monospace but lacked the explicit directive its sibling
+ * recent-signal count carries. Post-R292 the panel-header pair
+ * shares the same explicit declaration.
+ *
+ * Note distinct from R274 (topo-legend-count-tabular-test.mjs)
+ * which probes the per-ROW counts (working/idle/offline). R292
+ * is the panel-level HEADER count ("N nodes" right-anchored).
+ *
+ * Contract:
+ *   - [data-legend-panel-count] computed font-variant-numeric
+ *     includes 'tabular-nums'.
+ *   - Text content still '{N} node[s]'.
+ *   - [data-recent-panel-count] also tabular (sibling parity check).
+ *   - R291 starfield 14 dots + R290 three radar rings intact.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+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 {}
+});
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+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, model) => ({
+    alias, status: 'working', model, 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', 'claude-opus-4'),
+    mk('beta',  'gpt-4o'),
+  ] } });
+});
+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-panel-count]', { timeout: 15000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const legendCount = document.querySelector('[data-legend-panel-count]');
+  const recentCount = document.querySelector('[data-recent-panel-count]');
+  const legendFvn = legendCount ? getComputedStyle(legendCount).fontVariantNumeric : null;
+  const recentFvn = recentCount ? getComputedStyle(recentCount).fontVariantNumeric : null;
+  const dots = document.querySelectorAll('[data-topo-starfield-dot]');
+  const rings = [...document.querySelectorAll('[data-topo-radar-ring]')]
+    .map(r => r.getAttribute('data-topo-radar-ring')).sort((a, b) => +a - +b);
+  return {
+    legendText:        legendCount?.textContent ?? null,
+    legendFvn,
+    legendFontFamily:  legendCount ? getComputedStyle(legendCount).fontFamily : null,
+    recentFvn,
+    starfieldCount:    dots.length,
+    radarRings:        rings,
+  };
+});
+await browser.close();
+
+const hasTab = (s) => /tabular-nums/.test(s || '');
+
+const results = {
+  legend_count_tabular:       hasTab(probe.legendFvn),
+  legend_count_text_kept:     /^\d+ node/.test(probe.legendText || ''),
+  legend_count_monospace:     /mono/i.test(probe.legendFontFamily || ''),
+  recent_count_tabular_sib:   hasTab(probe.recentFvn),
+  r291_starfield_14:          probe.starfieldCount === 14,
+  r290_three_rings:           JSON.stringify(probe.radarRings) === JSON.stringify(['170', '250', '330']),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend count tabular parity:`, JSON.stringify(results),
+  '\n  legend text:', JSON.stringify(probe.legendText),
+  '\n  legend font-variant-numeric:', probe.legendFvn,
+  '\n  legend font-family:', probe.legendFontFamily,
+  '\n  recent (sibling) font-variant-numeric:', probe.recentFvn);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-count-tabular-test.mjs

@@ -0,0 +1,87 @@
+/* Round 274 verification: legend per-row count text gains tabular-nums.
+ *
+ * Pre-R274 the legend per-row count at x=215 used fontFamily="monospace"
+ * (typically tabular by nature) but NO explicit fontVariantNumeric:
+ * 'tabular-nums'. The recent-signal panel header flow-count (R225)
+ * AND the group-label pip strip (R230) both explicitly set tabular-
+ * nums for digit-width stability across 9→10 / 99→100 thresholds.
+ *
+ * R274 closes the consistency gap: legend per-row counts now also
+ * carry fontVariantNumeric: 'tabular-nums'. Belt-and-suspenders for
+ * monospace fonts where some implementations have subtle digit-pair
+ * variance.
+ *
+ * Test scope:
+ *   1. Working row count text has computed fontVariantNumeric ===
+ *      'tabular-nums'.
+ *   2. Idle row count text same.
+ *   3. Offline row count text same.
+ *   4. R273 Layout toggle Grid inactive has hover:text-cyan-300
+ *      (regression).
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+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 {}
+});
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+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 = 'working') => ({
+    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,
+  });
+  // Mix of statuses so all 3 legend row counts have non-zero values
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'working'), mk('beta', 'idle'),
+    mk('gamma', 'idle'),    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' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-legend-count="working"]', { timeout: 10000 });
+await page.waitForSelector('[data-legend-count="idle"]',    { timeout: 10000 });
+await page.waitForSelector('[data-legend-count="offline"]', { timeout: 10000 });
+await page.waitForSelector('[data-topo-chrome-layout="grid"]', { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const working = document.querySelector('[data-legend-count="working"]');
+  const idle    = document.querySelector('[data-legend-count="idle"]');
+  const offline = document.querySelector('[data-legend-count="offline"]');
+  const grid    = document.querySelector('[data-topo-chrome-layout="grid"]');
+  return {
+    workingFVN: working ? window.getComputedStyle(working).fontVariantNumeric : null,
+    idleFVN:    idle    ? window.getComputedStyle(idle).fontVariantNumeric    : null,
+    offlineFVN: offline ? window.getComputedStyle(offline).fontVariantNumeric : null,
+    gridClasses: grid    ? grid.className.toString() : null,
+  };
+});
+await browser.close();
+
+const isTabular = (v) => v != null && v.includes('tabular-nums');
+
+const results = {
+  working_count_tabular:        isTabular(probe.workingFVN),
+  idle_count_tabular:           isTabular(probe.idleFVN),
+  offline_count_tabular:        isTabular(probe.offlineFVN),
+  r273_grid_has_cyan_hover_text: (probe.gridClasses || '').includes('hover:text-cyan-300'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend count tabular-nums:`, JSON.stringify(results),
+  '\n  working FVN:', probe.workingFVN,
+  '\n  idle FVN:   ', probe.idleFVN,
+  '\n  offline FVN:', probe.offlineFVN);
+process.exit(ok ? 0 : 1);