@sleep2agi/agent-network-dashboard 0.4.6-preview.33 → 0.4.6-preview.331

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

package/scripts/topo-group-label-pin-spacing-test.mjs

@@ -0,0 +1,136 @@
+/* Round 218 verification: group label text gains letter-spacing
+ * transition on pin — 0px → 0.5px when group is pinned. Hover and
+ * pin share fill colour (R63 legendHeadline) so pre-R218 they
+ * looked typographically identical. R218 spreads the pinned text
+ * to read "locked in" at the text level.
+ *
+ * Test (cyber dark, 17 sessions in 2 prefix groups → 'group-A' +
+ * 'group-B' groupBoxes after switch to grid layout):
+ *   1. Switch to grid layout to trigger groupBoxes rendering.
+ *   2. Both group labels render with data-group-label.
+ *   3. Idle: data-group-label-pinned='false', computed
+ *      letter-spacing ~ 0px.
+ *   4. Inline transition includes 'letter-spacing 200ms'.
+ *   5. Click one group label → that group becomes pinned.
+ *   6. Pinned label: data-group-label-pinned='true', computed
+ *      letter-spacing ~ 0.5px.
+ *   7. Other (un-pinned) group stays at 0px letter-spacing.
+ *   8. Click pinned again → unpin → back to 0px.
+ */
+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,
+  });
+  // Two prefix groups: 'alpha-*' and 'beta-*' (each ≥2 → forms a group)
+  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-topo-chrome-layout="grid"]', { timeout: 10000 });
+await page.waitForTimeout(200);
+
+// Switch to grid layout to trigger groupBoxes
+await page.click('[data-topo-chrome-layout="grid"]');
+await page.waitForTimeout(600);
+await page.waitForSelector('[data-group-label]', { timeout: 5000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const probe = async () => page.evaluate(() => {
+  return [...document.querySelectorAll('[data-group-label]')].map(el => {
+    const cs = getComputedStyle(el);
+    return {
+      key:         el.getAttribute('data-group-label'),
+      pinned:      el.getAttribute('data-group-label-pinned'),
+      spacing:     cs.letterSpacing,
+      transition:  el.style.transition,
+    };
+  });
+});
+
+const idle = await probe();
+
+// Click first group label to pin it. The label hit area is the
+// invisible rect — but the <text> itself often gets the click via
+// the wrapper <g> with onClick. Find the parent <g role='button'>
+// (data-group-label-hit) and click it.
+const firstKey = idle[0]?.key;
+if (firstKey) {
+  await page.click(`[data-group-label-hit="${firstKey}"]`);
+  await page.waitForTimeout(260);  // past 200ms transition
+}
+const pinned = await probe();
+
+// Click again to unpin
+if (firstKey) {
+  await page.click(`[data-group-label-hit="${firstKey}"]`);
+  await page.waitForTimeout(260);
+}
+const unpinned = await probe();
+
+await browser.close();
+
+// CSS resolves `letterSpacing: '0px'` to the keyword 'normal' in
+// computed style — they're equivalent. Accept both forms as "zero
+// spacing"; numeric values still parse cleanly via parseFloat.
+const near = (s, want, tol = 0.15) => {
+  if (want === 0 && (s === 'normal' || s === '0px' || s === '0' || !s)) return true;
+  const got = parseFloat(s || '0');
+  return Math.abs(got - want) < tol;
+};
+const hasLetterSpacingT = (s) => /letter-spacing\s+(?:200ms|0\.2s)/.test(s || '');
+
+const firstIdle    = idle[0];
+const firstPinned  = pinned.find(p => p.key === firstKey);
+const otherIdle    = idle[1];
+const otherPinned  = pinned.find(p => p.key !== firstKey);
+const firstUnpin   = unpinned.find(p => p.key === firstKey);
+
+const results = {
+  two_groups_present:        idle.length >= 2,
+
+  // Idle: all unpinned, spacing 0, transition present
+  all_idle_unpinned:         idle.every(p => p.pinned === 'false'),
+  all_idle_spacing_zero:     idle.every(p => near(p.spacing, 0)),
+  all_have_transition:       idle.every(p => hasLetterSpacingT(p.transition)),
+
+  // First pinned, second still idle
+  first_pinned_attr:         firstPinned?.pinned === 'true',
+  first_pinned_spacing:      near(firstPinned?.spacing, 0.5),
+  other_stays_unpinned:      otherPinned?.pinned === 'false',
+  other_spacing_unchanged:   near(otherPinned?.spacing, 0),
+
+  // After unpin: spacing back to 0
+  unpinned_attr_false:       firstUnpin?.pinned === 'false',
+  unpinned_spacing_zero:     near(firstUnpin?.spacing, 0),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group-label pin spacing:`, JSON.stringify(results),
+  `\n  idle:`,     idle,
+  `\n  pinned:`,   pinned,
+  `\n  unpinned:`, unpinned);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,99 @@
+/* Round 107 verification: group-label hit `<rect>` picks up a tint
+ * on hover and pin — extends the R104 (recent-signal) / R105
+ * (legend) list-item-tint pattern to the SVG group labels. The tint
+ * is pal.legendAccent (cyan) since groups don't carry an inherent
+ * swatch; same colour family R68 already uses for hovered/pinned
+ * group-box strokes.
+ *
+ * Verifies idle / hover / pinned via the new data-group-label-tinted
+ * attribute + fill/opacity. Pin opacity stronger than hover.
+ */
+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-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,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha1'), mk('alpha2'), mk('alpha3'),
+    mk('beta1'),  mk('beta2'),
+  ] } });
+});
+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 readLabel = (key) => page.evaluate((k) => {
+  const g = document.querySelector(`[data-group-label-hit="${k}"]`);
+  if (!g) return null;
+  const rect = g.querySelector('rect');
+  return {
+    tinted:  rect?.getAttribute('data-group-label-tinted') || '',
+    fill:    rect?.getAttribute('fill') || '',
+    opacity: rect?.getAttribute('opacity') || '',
+  };
+}, key);
+
+const beforeAlpha = await readLabel('alpha');
+const beforeBeta  = await readLabel('beta');
+
+// Hover alpha label.
+await page.locator('[data-group-label-hit="alpha"]').hover();
+await page.waitForTimeout(250);
+const onHoverAlpha = await readLabel('alpha');
+const onHoverBeta  = await readLabel('beta');
+
+// Move pointer far away.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+
+// Pin beta.
+await page.locator('[data-group-label-hit="beta"]').click();
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const pinBeta = await readLabel('beta');
+const pinAlphaUnchanged = await readLabel('alpha');
+
+await browser.close();
+
+const opacity = (s) => parseFloat(s) || 0;
+const results = {
+  before_alphaTransparent:  beforeAlpha?.tinted === 'none' && beforeAlpha?.fill === 'transparent',
+  before_betaTransparent:   beforeBeta?.tinted  === 'none' && beforeBeta?.fill  === 'transparent',
+  hover_alphaTinted:        onHoverAlpha?.tinted === 'hover' && onHoverAlpha?.fill !== 'transparent',
+  hover_alphaOpacityLow:    opacity(onHoverAlpha?.opacity || '') > 0 && opacity(onHoverAlpha?.opacity || '') < 0.2,
+  hover_betaUnchanged:      onHoverBeta?.tinted === 'none',
+  pin_betaPinned:           pinBeta?.tinted === 'pinned' && pinBeta?.fill !== 'transparent',
+  pin_strongerThanHover:    opacity(pinBeta?.opacity || '') > opacity(onHoverAlpha?.opacity || ''),
+  pin_alphaClean:           pinAlphaUnchanged?.tinted === 'none',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group-label tint:`, JSON.stringify(results),
+  `\n  beforeAlpha=`,     beforeAlpha,
+  `\n  onHoverAlpha=`,    onHoverAlpha,
+  `\n  pinBeta=`,         pinBeta);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,83 @@
+/* Round 99 verification: group label <title> tooltip lists members
+ * + status breakdown. Same R97/R98 pattern — anywhere the UI shows
+ * "alpha · 3" should hover-explain WHICH 3.
+ *
+ * Fleet: alpha group has 3 members (2 working + 1 idle), beta has
+ * 2 idle. Pin alpha to confirm the title's last line flips from
+ * "click to pin" → "click to release pin".
+ */
+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-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, 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('alpha1', 'working'),
+    mk('alpha2', 'working'),
+    mk('alpha3', 'idle'),
+    mk('beta1',  'idle'),
+    mk('beta2',  'idle'),
+  ] } });
+});
+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 readTitle = (groupKey) => page.evaluate((k) => {
+  const g = document.querySelector(`[data-group-label-hit="${k}"]`);
+  return g?.querySelector('title')?.textContent || '';
+}, groupKey);
+
+const alphaTitle = await readTitle('alpha');
+const betaTitle  = await readTitle('beta');
+
+// Pin alpha — last line should flip.
+await page.locator('[data-group-label-hit="alpha"]').click();
+await page.waitForTimeout(250);
+const alphaTitlePinned = await readTitle('alpha');
+
+await browser.close();
+
+const results = {
+  alpha_heading:           /^alpha \(3 members\)/m.test(alphaTitle),
+  alpha_statusSummary:     /2 working · 1 idle/.test(alphaTitle),
+  alpha_listsMembers:      /alpha1.*alpha2.*alpha3/.test(alphaTitle),
+  alpha_pinHint:           /click to pin this group/.test(alphaTitle),
+  beta_heading:            /^beta \(2 members\)/m.test(betaTitle),
+  beta_statusSummary:      /2 idle/.test(betaTitle),
+  beta_noWorkingInSummary: !/working/.test(betaTitle),
+  beta_listsMembers:       /beta1.*beta2/.test(betaTitle),
+  pinned_hintFlipped:      /click to release pin/.test(alphaTitlePinned),
+  pinned_keepsMembers:     /alpha1.*alpha2.*alpha3/.test(alphaTitlePinned),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group-label title:`, JSON.stringify(results),
+  `\n  alpha:\n${alphaTitle}`,
+  `\n  beta:\n${betaTitle}`,
+  `\n  alphaPinned:\n${alphaTitlePinned}`);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,119 @@
+/* Round 63 verification: clicking the group label pins the group focus
+ * via pinnedGroup. activeGroup = hoveredGroup ?? pinnedGroup is read by
+ * the R8 inFocus dim mechanic and the R53 in-group edge boost.
+ *
+ *  - Click a group label → that group's nodes stay bright, others dim
+ *    via the existing inFocus formula (opacity 0.32).
+ *  - Move mouse away → pin persists (transient hover cleared).
+ *  - In-group edge between OTHER team members brightens 1.3× even
+ *    without an alias hover.
+ *  - Esc clears the pin (R62 extended).
+ *  - aria-pressed flips on the group <text>.
+ */
+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: 'beta',   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 } });
+});
+const now = new Date().toISOString();
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [
+  // alpha2 → alpha3: both in alpha group, neither is the pinned-group's "exact alias"
+  { from_alias: 'alpha2', to_alias: 'alpha3', content: 'm', created_at: now },
+  // alpha1 → beta: alpha1 in pinned group, beta outside → should dim
+  { from_alias: 'alpha1', to_alias: 'beta', content: 'm', created_at: now },
+] } }));
+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.waitForTimeout(600);
+
+const nodeOpacities = () => page.evaluate(() => {
+  const o = {};
+  for (const a of ['alpha1', 'alpha2', 'alpha3', 'beta']) {
+    const g = document.querySelector(`g[data-node="${a}"]`);
+    o[a] = g ? +(g.style.opacity || '1') : null;
+  }
+  return o;
+});
+const edgeOpacities = () => page.evaluate(() => {
+  const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+  const out = {};
+  for (const g of svg.querySelectorAll(':scope > g > g')) {
+    const t = g.querySelector('path[data-edge-hitbox] title');
+    if (!t) continue;
+    const route = (t.textContent || '').split('\n')[0];
+    const base = [...g.querySelectorAll(':scope > path')].find(
+      p => !p.hasAttribute('data-edge-hitbox') && p.hasAttribute('marker-end')
+    );
+    if (base) out[route] = +base.getAttribute('opacity');
+  }
+  return out;
+});
+
+const before = await nodeOpacities();
+const beforeEdges = await edgeOpacities();
+
+// Click the alpha group label via its R63 hitbox wrapper.
+const alphaLabel = page.locator('g[data-group-label-hit="alpha"]').first();
+const exists = await alphaLabel.count() > 0;
+if (!exists) { console.log('❌ alpha group label hit not found'); process.exit(1); }
+await alphaLabel.click({ force: true });
+// Mouse away so we observe pin-only state.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const afterPinNodes = await nodeOpacities();
+const afterPinEdges = await edgeOpacities();
+const ariaPressed = await page.evaluate(() => document.querySelector('g[data-group-label-hit="alpha"]')?.getAttribute('aria-pressed'));
+
+// Esc to release.
+await page.evaluate(() => document.activeElement && typeof document.activeElement.blur === 'function' && document.activeElement.blur());
+await page.keyboard.press('Escape');
+await page.waitForTimeout(300);
+const afterEscNodes = await nodeOpacities();
+const ariaAfterEsc = await page.evaluate(() => document.querySelector('g[data-group-label-hit="alpha"]')?.getAttribute('aria-pressed'));
+
+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.alpha2) && bright(before.alpha3) && bright(before.beta),
+  pin_keepsAlphaTeam:        bright(afterPinNodes.alpha1) && bright(afterPinNodes.alpha2) && bright(afterPinNodes.alpha3),
+  pin_dimsBeta:              dim(afterPinNodes.beta),
+  pin_ariaPressed:           ariaPressed === 'true',
+  pin_inGroupEdgeBoosts:     afterPinEdges['alpha2 → alpha3'] > beforeEdges['alpha2 → alpha3'] * 1.15,
+  pin_leavingEdgeDims:       afterPinEdges['alpha1 → beta'] < beforeEdges['alpha1 → beta'] * 0.6,
+  esc_releasesPin:           bright(afterEscNodes.alpha1) && bright(afterEscNodes.beta),
+  esc_ariaBackToFalse:       ariaAfterEsc === 'false',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group pin:`, JSON.stringify(results),
+  `\n  before nodes=`, before, ` edges=`, beforeEdges,
+  `\n  afterPin nodes=`, afterPinNodes, ` edges=`, afterPinEdges, ` aria=${ariaPressed}`,
+  `\n  afterEsc nodes=`, afterEscNodes, ` aria=${ariaAfterEsc}`);
+process.exit(ok ? 0 : 1);