@sleep2agi/agent-network-dashboard 0.4.6-preview.31 → 0.4.6-preview.310

package/scripts/topo-fullscreen-active-test.mjs

@@ -0,0 +1,115 @@
+/* Round 178 verification: fullscreen chrome button picks up the
+ * active-state visual indicator R163 introduced for layout toggle.
+ *
+ * Pre-R178 the button changed icon when isFullscreen flipped but
+ * background + foreground stayed unchanged. R178 adds:
+ *   active:   bg-cyan-500/15 text-cyan-300 hover:bg-cyan-500/20
+ *   inactive: hover:bg-white/5 + palette-driven inline bg/color
+ *
+ * Mirrors R163 Ring/Grid pattern.
+ *
+ * Test:
+ *   1. Probe inactive state (default — not in fullscreen):
+ *        data-topo-chrome-fullscreen-active='false'
+ *        className does NOT include 'bg-cyan-500/15'
+ *        className includes 'hover:bg-white/5'
+ *        inline style.background is set (from palette)
+ *   2. Fake fullscreen state via dispatching fullscreenchange
+ *      with mocked document.fullscreenElement, then re-probe:
+ *        data-topo-chrome-fullscreen-active='true'
+ *        className includes 'bg-cyan-500/15' + 'text-cyan-300'
+ *        className DOES NOT include 'hover:bg-white/5'
+ *        inline style.background is unset (Tailwind wins)
+ */
+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: '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')] } });
+});
+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 === 3, { timeout: 30000 });
+await page.waitForSelector('[data-topo-chrome-fullscreen]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = () => page.evaluate(() => {
+  const btn = document.querySelector('[data-topo-chrome-fullscreen]');
+  if (!btn) return null;
+  return {
+    activeAttr:        btn.getAttribute('data-topo-chrome-fullscreen-active'),
+    className:         btn.getAttribute('class') || '',
+    inlineBg:          btn.style.background || '',
+    inlineColor:       btn.style.color || '',
+    ariaLabel:         btn.getAttribute('aria-label'),
+  };
+});
+
+const inactive = await probe();
+
+// Fake fullscreen state: define document.fullscreenElement to point at
+// the container, then dispatch fullscreenchange. The listener at
+// TopoGraph.tsx line ~1125 calls
+//   setIsFullscreen(document.fullscreenElement === containerRef.current)
+// We can find the container via the chrome's parent (the chrome <div>
+// sits inside the container <div ref={containerRef}>).
+await page.evaluate(() => {
+  const chrome = document.querySelector('[data-topo-chrome]');
+  const container = chrome?.parentElement;
+  if (!container) throw new Error('container not found');
+  Object.defineProperty(document, 'fullscreenElement', {
+    configurable: true,
+    get: () => container,
+  });
+  document.dispatchEvent(new Event('fullscreenchange'));
+});
+await page.waitForTimeout(250);
+const active = await probe();
+
+await browser.close();
+
+const results = {
+  // Inactive defaults
+  inactive_attr_false:         inactive.activeAttr === 'false',
+  inactive_no_cyan_bg_class:   !inactive.className.includes('bg-cyan-500/15'),
+  inactive_has_white_hover:    inactive.className.includes('hover:bg-white/5'),
+  inactive_inline_bg_set:      inactive.inlineBg !== '',
+  inactive_inline_color_set:   inactive.inlineColor !== '',
+  inactive_aria_label_enter:   /Enter fullscreen/.test(inactive.ariaLabel || ''),
+
+  // Active state (after faking fullscreenchange)
+  active_attr_true:            active.activeAttr === 'true',
+  active_has_cyan_bg_class:    active.className.includes('bg-cyan-500/15'),
+  active_has_cyan_text_class:  active.className.includes('text-cyan-300'),
+  active_has_cyan_hover_class: active.className.includes('hover:bg-cyan-500/20'),
+  active_no_white_hover:       !active.className.includes('hover:bg-white/5'),
+  active_inline_bg_empty:      active.inlineBg === '',
+  active_inline_color_empty:   active.inlineColor === '',
+  active_aria_label_exit:      /Exit fullscreen/.test(active.ariaLabel || ''),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} fullscreen active state:`, JSON.stringify(results),
+  `\n  inactive =`, inactive,
+  `\n  active   =`, active);
+process.exit(ok ? 0 : 1);

package/scripts/topo-group-box-pinned-state-test.mjs

@@ -0,0 +1,95 @@
+/* Round 68 verification: group-box rect has a 3-tier visual ladder:
+ *  idle    → strokeWidth 1.5, dashed, ringStroke colour
+ *  hovered → strokeWidth 2,   solid, legendAccent colour
+ *  pinned  → strokeWidth 3,   solid, legendAccent colour (stronger)
+ *
+ * Plus `data-group-box-pinned` reflects the pinned state so external
+ * tooling can spot a pinned box without inspecting computed CSS.
+ */
+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: 1280, 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', 'grid');
+    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 sessions = [
+    { alias: 'alpha1', status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'alpha2', status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'alpha3', status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'beta1',  status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'beta2',  status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+  ];
+  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 === 5, { timeout: 30000 });
+await page.waitForTimeout(600);
+
+const readAlphaBox = () => page.evaluate(() => {
+  // Find the alpha group <g data-group="alpha"> and read its <rect>.
+  const g = document.querySelector('g[data-group="alpha"]');
+  if (!g) return null;
+  const rect = g.querySelector('rect');
+  if (!rect) return null;
+  return {
+    strokeWidth:    rect.getAttribute('stroke-width'),
+    stroke:         rect.getAttribute('stroke'),
+    dashArray:      rect.getAttribute('stroke-dasharray'),
+    fillOpacity:    rect.getAttribute('fill-opacity'),
+    pinnedAttr:     rect.getAttribute('data-group-box-pinned'),
+  };
+});
+
+const idle = await readAlphaBox();
+
+// Hover a member of alpha (alpha1) → group becomes hovered.
+await page.locator('g[data-node="alpha1"]').hover();
+await page.waitForTimeout(300);
+const hovered = await readAlphaBox();
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+
+// Pin alpha via group label click.
+await page.locator('g[data-group-label-hit="alpha"]').first().click({ force: true });
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const pinned = await readAlphaBox();
+
+await browser.close();
+
+const results = {
+  idle_stroke15:        idle && idle.strokeWidth === '1.5',
+  idle_dashed:          idle && (idle.dashArray || '').startsWith('6'),
+  idle_pinnedFalse:     idle && idle.pinnedAttr === 'false',
+  hovered_stroke2:      hovered && hovered.strokeWidth === '2',
+  hovered_solid:        hovered && (hovered.dashArray === 'none' || hovered.dashArray === null),
+  hovered_pinnedFalse:  hovered && hovered.pinnedAttr === 'false',
+  pinned_stroke3:       pinned && pinned.strokeWidth === '3',
+  pinned_solid:         pinned && (pinned.dashArray === 'none' || pinned.dashArray === null),
+  pinned_pinnedTrue:    pinned && pinned.pinnedAttr === 'true',
+  pinned_strongerFill:  pinned && hovered && parseFloat(pinned.fillOpacity) > parseFloat(hovered.fillOpacity),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group-box pinned state:`, JSON.stringify(results),
+  `\n  idle=`,    idle,
+  `\n  hovered=`, hovered,
+  `\n  pinned=`,  pinned);
+process.exit(ok ? 0 : 1);

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

@@ -53,8 +53,13 @@ const labels = await page.$$eval('svg[viewBox="0 0 1000 680"] g[data-group]', el
 await browser.close();
 const a = labels.find(l => l.key === 'A站');
 const b = labels.find(l => l.key === 'B站');
+// R58 appended status-mix pips inside the same <text>, and SVG textContent
+// concatenates tspans without preserving the visual `dx` gaps — so what
+// renders as "A站 · 4  4w" surfaces as the string "A站· 44w". The R19
+// count chip is still the second tspan; verify by matching "Group·" then
+// the count, allowing any trailing pip text.
 const results = {
-  bothGroupsHaveChip: a?.full === 'A站· 4' && b?.full === 'B站· 2',
+  bothGroupsHaveChip: /^A站·\s*4/.test(a?.full || '') && /^B站·\s*2/.test(b?.full || ''),
   chipSmallerFont: a?.chipFontSize === 11,
   chipLighterWeight: a?.chipFontWeight === '400',
 };

package/scripts/topo-group-label-a11y-test.mjs

@@ -0,0 +1,113 @@
+/* Round 152 verification: group-label hit gains onKeyDown.
+ *
+ * R63 added role="button" + tabIndex=0 + aria-pressed to the
+ * group label hit-area, but never wired keyboard activation —
+ * focused users could Tab to the label but Enter / Space did
+ * nothing. R152 wires onKeyDown to fire the same setPinnedGroup
+ * setter onClick uses.
+ *
+ * This is the last keyboard gap among the role="button" surfaces;
+ * pressure-bar segs (R60), legend rows (R61), recent rows (R116),
+ * edge count badges (R121), chip-row chips (R136 / R139 / R140),
+ * vendor letters (R88), and nodes (R151) all had it. Group labels
+ * were the last hold-out.
+ *
+ * Fleet: 3 working sessions in grid layout to force group boxes
+ * (R85). Two prefix groups: agents-* (2) and infra-* (1).
+ *
+ * Path:
+ *   1. Focus agents group label → aria-pressed=false initially
+ *   2. Press Enter → aria-pressed=true (pinned)
+ *   3. Press Enter again → aria-pressed=false (released)
+ *   4. Press Space → aria-pressed=true (pinned)
+ *   5. Esc clears → aria-pressed=false
+ */
+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: 1600, 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');
+    // group boxes only render in grid layout
+    localStorage.setItem('anet-topo-layout', 'grid');
+  } 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) => ({
+    alias, status, 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('agents-a1', 'working'), mk('agents-a2', 'working'),
+    mk('infra-b1',  'working'),
+  ] } });
+});
+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 === 3, { timeout: 30000 });
+await page.waitForSelector('[data-group-label-hit]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+// Find the actual group keys (cluster prefix may differ)
+const groupKeys = await page.evaluate(() =>
+  [...document.querySelectorAll('[data-group-label-hit]')].map(g => g.getAttribute('data-group-label-hit')));
+const agentsKey = groupKeys.find(k => k.startsWith('agents')) || groupKeys[0];
+
+const readAriaPressed = () => page.evaluate((k) => {
+  const g = document.querySelector(`[data-group-label-hit="${k}"]`);
+  return g?.getAttribute('aria-pressed');
+}, agentsKey);
+
+const before = await readAriaPressed();
+
+// Focus the label and press Enter
+await page.locator(`[data-group-label-hit="${agentsKey}"]`).focus();
+await page.keyboard.press('Enter');
+await page.waitForTimeout(200);
+const afterEnter = await readAriaPressed();
+
+// Press Enter again → toggle off
+await page.keyboard.press('Enter');
+await page.waitForTimeout(200);
+const afterReEnter = await readAriaPressed();
+
+// Press Space → pin again
+await page.locator(`[data-group-label-hit="${agentsKey}"]`).focus();
+await page.keyboard.press(' ');
+await page.waitForTimeout(200);
+const afterSpace = await readAriaPressed();
+
+// Esc clears
+await page.keyboard.press('Escape');
+await page.waitForTimeout(200);
+const afterEsc = await readAriaPressed();
+
+await browser.close();
+
+const results = {
+  before_notPinned:   before === 'false',
+  enter_pins:         afterEnter === 'true',
+  reEnter_releases:   afterReEnter === 'false',
+  space_pins:         afterSpace === 'true',
+  esc_clears:         afterEsc === 'false',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group label a11y:`, JSON.stringify(results),
+  `\n  groupKey=${agentsKey}`,
+  `\n  before=${before} enter=${afterEnter} reEnter=${afterReEnter} space=${afterSpace} esc=${afterEsc}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-group-label-count-inherit-test.mjs

@@ -0,0 +1,99 @@
+/* Round 229 verification: group-label member-count tspan drops
+ * its explicit fill (now inherits from parent <text>) and picks up
+ * fontVariantNumeric: 'tabular-nums'.
+ *
+ * Two scopes:
+ *   1) Hover-deepen-own-hue family — count chip color now follows
+ *      parent name's R142 hover transition (legendText → legend-
+ *      Headline). Tonal hierarchy (count < name brightness) is
+ *      preserved across both rest AND hover instead of inverting
+ *      on hover.
+ *   2) Info-density tabular-nums — 5th surface after R224 edge
+ *      badge / R225 hub + panel header + recent row.
+ *
+ * Scenario: 6 prefix-shared aliases (alpha-1..alpha-3, beta-1..
+ * beta-3) → R106 cluster-by-prefix forms two groups, each with
+ * count=3. Grid layout has explicit group label rendering (#111).
+ *
+ * Verifications:
+ *   - data-group-label-count attr present (probe selector)
+ *   - tspan has NO explicit fill attribute (inheriting)
+ *   - getComputedStyle().fontVariantNumeric contains 'tabular-nums'
+ *   - tspan computed fill matches PARENT <text> computed fill
+ *     (R142 rest-state hierarchy preserved)
+ *   - count text matches '· 3'
+ *   - data-group-label-count-value reflects {box.count}
+ */
+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');
+    // R226 grid layout — group labels render here. Storage key inferred
+    // from data-topo-layout-toggle persistence pattern.
+    localStorage.setItem('anet-topo-layout', 'grid');
+  } 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-1'), mk('alpha-2'), mk('alpha-3'),
+    mk('beta-1'),  mk('beta-2'),  mk('beta-3'),
+  ] } });
+});
+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 === 6, { timeout: 30000 });
+await page.waitForSelector('[data-group-label-count]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(400);
+
+const out = await page.evaluate(() => {
+  const counts = Array.from(document.querySelectorAll('[data-group-label-count]'));
+  return counts.map((tspan) => {
+    const parent = tspan.parentElement; // the <text data-group-label>
+    return {
+      key:            tspan.getAttribute('data-group-label-count'),
+      countValue:     tspan.getAttribute('data-group-label-count-value'),
+      hasFillAttr:    tspan.hasAttribute('fill'),
+      text:           tspan.textContent,
+      fontVarNumeric: getComputedStyle(tspan).fontVariantNumeric,
+      tspanFill:      getComputedStyle(tspan).fill,
+      parentFill:     parent ? getComputedStyle(parent).fill : null,
+    };
+  });
+});
+await browser.close();
+
+const hasTab = (s) => /tabular-nums/.test(s || '');
+const present = out.length > 0;
+
+const results = {
+  groups_found:           out.length === 2,
+  all_have_key:           present && out.every(o => typeof o.key === 'string' && o.key.length > 0),
+  all_count_3:            present && out.every(o => o.countValue === '3'),
+  all_text_dot_3:         present && out.every(o => /·\s*3$/.test((o.text || '').trim())),
+  all_no_fill_attr:       present && out.every(o => !o.hasFillAttr),
+  all_tabular_nums:       present && out.every(o => hasTab(o.fontVarNumeric)),
+  fill_inherits_parent:   present && out.every(o => o.tspanFill === o.parentFill),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group-label count inherit + tabular:`, JSON.stringify(results),
+  '\n  probed:', out);
+process.exit(ok ? 0 : 1);

package/scripts/topo-group-label-hover-test.mjs

@@ -0,0 +1,119 @@
+/* Round 86 verification: hovering a group label previews the same
+ * dim mechanism as hovering a member node. R63 wired click-to-pin
+ * but forgot the hover preview — same R83 hover/click consistency
+ * gap. Now closed for group labels too.
+ *
+ * Fleet: 3 alpha + 2 beta in grid layout. Hover alpha label →
+ * alpha nodes stay bright, beta nodes dim. Hover beta label →
+ * inverse. Click alpha label → pin (R63 existing). Hover beta
+ * while alpha pinned → live transient preview of beta, alpha dims.
+ * Leave beta label → alpha pin restores (activeGroup =
+ * hoveredGroup ?? pinnedGroup).
+ */
+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', 'grid');
+    sessionStorage.setItem('anet_v3_auth', '1');
+    sessionStorage.removeItem('anet-topo-pinned-status');
+    sessionStorage.removeItem('anet-topo-pinned-group');
+  } 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: 'idle', model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  const sessions = [mk('alpha1'), mk('alpha2'), mk('alpha3'), mk('beta1'), mk('beta2')];
+  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('[data-group-label-hit]').length >= 2, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const ops = () => page.evaluate(() => {
+  const o = {};
+  for (const a of ['alpha1', 'alpha2', 'alpha3', 'beta1', 'beta2']) {
+    const g = document.querySelector(`g[data-node="${a}"]`);
+    o[a] = g ? +(g.style.opacity || '1') : null;
+  }
+  return o;
+});
+
+const before = await ops();
+
+// Hover the alpha label — alphas should stay bright, betas dim.
+await page.locator('[data-group-label-hit="alpha"]').hover();
+await page.waitForTimeout(250);
+const onHoverAlpha = await ops();
+
+// Leave (move mouse far away) — baseline restores.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterLeaveAlpha = await ops();
+
+// Hover beta label — inverse.
+await page.locator('[data-group-label-hit="beta"]').hover();
+await page.waitForTimeout(250);
+const onHoverBeta = await ops();
+
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+
+// Click alpha label to pin → alpha pinned (R63 behaviour preserved).
+await page.locator('[data-group-label-hit="alpha"]').click();
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterPinAlpha = await ops();
+
+// Hover beta while alpha is pinned — transient preview wins.
+await page.locator('[data-group-label-hit="beta"]').hover();
+await page.waitForTimeout(250);
+const onHoverBetaWhilePin = await ops();
+
+// Leave beta — alpha pin restores.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterLeaveBetaWhilePin = await ops();
+
+await browser.close();
+
+const bright = (v) => v != null && v >= 0.55;
+const dim    = (v) => v != null && v < 0.4;
+const results = {
+  before_baseline:           bright(before.alpha1) && bright(before.beta1),
+  hoverAlpha_alphasBright:   bright(onHoverAlpha.alpha1) && bright(onHoverAlpha.alpha2) && bright(onHoverAlpha.alpha3),
+  hoverAlpha_betasDim:       dim(onHoverAlpha.beta1) && dim(onHoverAlpha.beta2),
+  leaveAlpha_restores:       bright(afterLeaveAlpha.alpha1) && bright(afterLeaveAlpha.beta1),
+  hoverBeta_betasBright:     bright(onHoverBeta.beta1) && bright(onHoverBeta.beta2),
+  hoverBeta_alphasDim:       dim(onHoverBeta.alpha1) && dim(onHoverBeta.alpha2),
+  pinAlpha_keepsAlpha:       bright(afterPinAlpha.alpha1) && bright(afterPinAlpha.alpha2),
+  pinAlpha_dimsBeta:         dim(afterPinAlpha.beta1) && dim(afterPinAlpha.beta2),
+  hoverBetaPin_transient:    bright(onHoverBetaWhilePin.beta1) && dim(onHoverBetaWhilePin.alpha1),
+  leaveBetaPin_alphaRestored: bright(afterLeaveBetaWhilePin.alpha1) && dim(afterLeaveBetaWhilePin.beta1),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group-label hover:`, JSON.stringify(results),
+  `\n  before=`,            before,
+  `\n  onHoverAlpha=`,      onHoverAlpha,
+  `\n  onHoverBeta=`,       onHoverBeta,
+  `\n  afterPinAlpha=`,     afterPinAlpha,
+  `\n  onHoverBetaPin=`,    onHoverBetaWhilePin,
+  `\n  leaveBetaPin=`,      afterLeaveBetaWhilePin);
+process.exit(ok ? 0 : 1);