@sleep2agi/agent-network-dashboard 0.4.6-preview.4 → 0.4.6-preview.405

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);

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

@@ -0,0 +1,88 @@
+/* Round 95 verification: legend rows show live counts. Fleet = 3
+ * working + 2 idle + 1 offline. Each row's data-legend-count
+ * attribute matches the expected number. Pinning a row brightens
+ * its count alongside the label.
+ *
+ * The count is right-aligned at x=215 (after the flow-arrow swatch
+ * which spans x=140-196 on the offline row), pointerEvents:none so
+ * the row's R55 hover affordance still hits.
+ */
+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: 1400, 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');
+    localStorage.setItem('anet-topo-layout', 'ring');
+    sessionStorage.setItem('anet_v3_auth', '1');
+    sessionStorage.removeItem('anet-topo-pinned-status');
+  } catch {}
+});
+
+const fresh   = new Date(Date.now() - 60 * 1000).toISOString();
+const stale10 = new Date(Date.now() - 10 * 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, ts) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: ts, updated_at: ts, last_seen_at: ts,
+  });
+  const sessions = [
+    mk('wkr1', 'working', fresh),
+    mk('wkr2', 'working', fresh),
+    mk('wkr3', 'working', fresh),
+    mk('idl1', 'idle',    fresh),
+    mk('idl2', 'idle',    fresh),
+    mk('off1', 'offline', stale10),
+  ];
+  await route.fulfill({ response: r, json: { ...b, sessions } });
+});
+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 === 6, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const counts = () => page.evaluate(() => ({
+  working: document.querySelector('[data-legend-count="working"]')?.textContent,
+  idle:    document.querySelector('[data-legend-count="idle"]')?.textContent,
+  offline: document.querySelector('[data-legend-count="offline"]')?.textContent,
+}));
+const opacities = () => page.evaluate(() => ({
+  working: +(document.querySelector('[data-legend-count="working"]')?.getAttribute('opacity') || '0'),
+  idle:    +(document.querySelector('[data-legend-count="idle"]')?.getAttribute('opacity') || '0'),
+  offline: +(document.querySelector('[data-legend-count="offline"]')?.getAttribute('opacity') || '0'),
+}));
+
+const c = await counts();
+const opsRest = await opacities();
+
+// Pin the working row — its count should brighten.
+await page.locator('[data-legend-status="working"]').click();
+await page.waitForTimeout(250);
+const opsPinned = await opacities();
+
+await browser.close();
+
+const results = {
+  workingCount_3:        c.working === '3',
+  idleCount_2:           c.idle === '2',
+  offlineCount_1:        c.offline === '1',
+  resting_dim:           opsRest.working < 0.7 && opsRest.idle < 0.7 && opsRest.offline < 0.7,
+  pinnedWorking_bright:  opsPinned.working >= 0.9,
+  pinnedWorking_othersUnchanged: opsPinned.idle < 0.7 && opsPinned.offline < 0.7,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend counts:`, JSON.stringify(results),
+  `\n  counts=`,      c,
+  `\n  opsRest=`,     opsRest,
+  `\n  opsPinned=`,   opsPinned);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-count-tier-fill-test.mjs

@@ -0,0 +1,121 @@
+/* Round 239 verification: legend count text fill picks up the
+ * row's tier colour on hover/pin, completing the hover-deepen-own-
+ * hue idiom for the legend row triple (swatch + label + count).
+ *
+ * Pre-R239 the count digit had opacity 0.65→0.95 on hover but
+ * stayed at pal.legendText (neutral gray) for fill. The swatch
+ * (R197 grow) and label (R55 brighten) both reacted to hover with
+ * tier-identity signals; only the count stayed gray. R239 adds
+ * fill transition to row.fill (green/teal/slate) on hover so the
+ * row reads as one tier-coloured unit.
+ *
+ * Empty tiers (row.count === 0) stay at pal.legendText regardless
+ * of hover — empty doesn't get to claim tier identity.
+ *
+ * Test scope:
+ *   - rest state: count fill === neutral (pal.legendText)
+ *   - hover state (Playwright .hover() on the legend row <g>):
+ *     count fill === row.fill (tier colour)
+ *   - data-legend-count-fill attr flips 'neutral' ↔ 'tier'
+ *   - transition list includes both opacity AND fill at 150ms
+ *
+ * Scenario: 4 working agents → working tier has count=4 (populated),
+ * idle + offline tiers stay at 0 (empty, never tier-coloured).
+ * Hover the working legend row, verify only that row's count
+ * flips to tier colour.
+ */
+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*', (r2) => r2.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (r2) => r2.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, state: 'attached' });
+await page.waitForTimeout(300);
+
+const probeCount = (page, tier) => page.evaluate((t) => {
+  const text = document.querySelector(`[data-legend-count="${t}"]`);
+  if (!text) return null;
+  const cs = getComputedStyle(text);
+  return {
+    fillAttr:   text.getAttribute('fill'),
+    fillComp:   cs.fill,
+    empty:      text.getAttribute('data-legend-count-empty'),
+    fillState:  text.getAttribute('data-legend-count-fill'),
+    transition: cs.transition,
+    text:       (text.textContent || '').trim(),
+  };
+}, tier);
+
+// REST STATE — no hover
+const rest = await probeCount(page, 'working');
+
+// HOVER STATE — hover the working legend row group
+await page.locator('[data-legend-status="working"]').first().hover({ force: true });
+await page.waitForTimeout(400);
+const hover = await probeCount(page, 'working');
+
+// Idle tier is empty in this scenario — should stay neutral even
+// when hovered. Hover the idle row to confirm the empty-tier
+// exclusion holds.
+await page.locator('[data-legend-status="idle"]').first().hover({ force: true });
+await page.waitForTimeout(400);
+const idleHover = await probeCount(page, 'idle');
+
+await browser.close();
+
+// Browser normalises '150ms' → '0.15s' in computed-style transitions.
+// Accept either form.
+const hasTransition = (s, prop) => new RegExp(`${prop}\\s+(?:150ms|0\\.15s)`).test(s || '');
+// Cyber theme working tier fill is #22c55e = rgb(34, 197, 94)
+const tierColorRgb = 'rgb(34, 197, 94)';
+// Cyber theme legendText (pal.legendText for dark palette) = #94a3b8 = rgb(148, 163, 184)
+const neutralRgb = 'rgb(148, 163, 184)';
+
+const results = {
+  rest_present:               rest !== null,
+  rest_fill_state_neutral:    rest?.fillState === 'neutral',
+  rest_fill_is_neutral:       rest?.fillComp === neutralRgb,
+  rest_text_is_4:             rest?.text === '4',
+  rest_transition_has_fill:   hasTransition(rest?.transition, 'fill'),
+  rest_transition_has_opacity: hasTransition(rest?.transition, 'opacity'),
+
+  hover_fill_state_tier:      hover?.fillState === 'tier',
+  hover_fill_is_tier:         hover?.fillComp === tierColorRgb,
+  hover_text_is_4:            hover?.text === '4',
+
+  // Empty tier (idle, count=0) stays neutral even on hover
+  idle_empty:                 idleHover?.empty === 'true',
+  idle_stays_neutral:         idleHover?.fillState === 'neutral',
+  idle_fill_still_neutral:    idleHover?.fillComp === neutralRgb,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend count tier fill:`, JSON.stringify(results),
+  '\n  rest:     ', rest,
+  '\n  hover:    ', hover,
+  '\n  idleHover:', idleHover);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,86 @@
+/* Round 309 verification: legend per-row count gains fontWeight=600
+ * (semibold). The count is the DATA in each row; semibold gives it
+ * glanceable priority over the default-weight row label.
+ *
+ * Contract:
+ *   - [data-legend-count='working'] attr font-weight === '600'.
+ *   - [data-legend-count='idle']    attr font-weight === '600'.
+ *   - [data-legend-count='offline'] attr font-weight === '600'.
+ *   - All three preserve tabular-nums (R274 family).
+ *   - R308 row labels still 'working' / 'idle' / 'offline'.
+ *   - R306 chrome focus-ring-1 + R304 sub-hint + R294 pulse 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, status) => ({
+    alias, status, 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', 'working'),
+    mk('beta',  'gpt-4o',        'idle'),
+    mk('gamma', 'claude-sonnet-4', '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-legend-count="working"]', { timeout: 15000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const sel = (s) => document.querySelector(s);
+  const working = sel('[data-legend-count="working"]');
+  const idle    = sel('[data-legend-count="idle"]');
+  const offline = sel('[data-legend-count="offline"]');
+  const fvn = (el) => el ? getComputedStyle(el).fontVariantNumeric : null;
+  return {
+    workingFw:  working?.getAttribute('font-weight') ?? null,
+    idleFw:     idle?.getAttribute('font-weight') ?? null,
+    offlineFw:  offline?.getAttribute('font-weight') ?? null,
+    workingFvn: fvn(working),
+    workingLabel: sel('[data-legend-row-label="working"]')?.textContent?.trim() ?? null,
+    idleLabel:    sel('[data-legend-row-label="idle"]')?.textContent?.trim() ?? null,
+    offlineLabel: sel('[data-legend-row-label="offline"]')?.textContent?.trim() ?? null,
+    layoutRingCls: sel('[data-topo-chrome-layout="ring"]')?.className ?? '',
+    subhintLs:    sel('[data-recent-signal-empty-hint]')?.getAttribute('letter-spacing') ?? null,
+    pulseCount:   document.querySelectorAll('[data-pulse-wrapper]').length,
+  };
+});
+await browser.close();
+
+const hasTab = (s) => /tabular-nums/.test(s || '');
+
+const results = {
+  working_count_fw_600:   probe.workingFw === '600',
+  idle_count_fw_600:      probe.idleFw === '600',
+  offline_count_fw_600:   probe.offlineFw === '600',
+  count_tabular_kept:     hasTab(probe.workingFvn),
+  r308_working_label:     probe.workingLabel === 'working',
+  r308_idle_label:        probe.idleLabel === 'idle',
+  r307_offline_label:     probe.offlineLabel === 'offline',
+  r306_focus_ring_1:      probe.layoutRingCls.includes('focus-visible:ring-1'),
+  r304_subhint_ls_0_15:   probe.subhintLs === '0.15',
+  r294_pulse_absent:      probe.pulseCount === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend count weight:`, JSON.stringify(results),
+  '\n  counts fw:', probe.workingFw, '/', probe.idleFw, '/', probe.offlineFw,
+  '\n  labels:', probe.workingLabel, '/', probe.idleLabel, '/', probe.offlineLabel);
+process.exit(ok ? 0 : 1);