@sleep2agi/agent-network-dashboard 0.4.6-preview.21 → 0.4.6-preview.211

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

package/scripts/topo-group-status-pips-test.mjs

@@ -0,0 +1,103 @@
+/* Round 58 verification: group label includes a status-mix pip strip
+ * showing how many members are working / idle / offline.
+ *
+ * Sessions (mixed-status alpha team + singleton beta):
+ *   alpha1  — working
+ *   alpha2  — working
+ *   alpha3  — idle
+ *   alpha4  — offline
+ *   beta    — idle  (singleton, no group box)
+ *
+ * Grid layout draws a group box for alpha (4 members). Label should
+ * end in something like "alpha · 4 · 2w 1i 1o". Status pips render
+ * only when their count > 0, so a uniform group reads more simply.
+ */
+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 });
+
+async function probe(sessions) {
+  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();
+  const stale = new Date(Date.now() - 30 * 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 seeded = sessions.map(s => ({
+      alias: s.alias, status: s.status,
+      network_id: nid, project_dir: null,
+      created_at: s.status === 'offline' ? stale : fresh,
+      updated_at: s.status === 'offline' ? stale : fresh,
+      last_seen_at: s.status === 'offline' ? stale : fresh,
+    }));
+    await route.fulfill({ response: r, json: { ...b, sessions: seeded } });
+  });
+  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(c => document.querySelectorAll('g[data-node]').length === c, sessions.length, { timeout: 30000 });
+  await page.waitForTimeout(500);
+  const labels = await page.evaluate(() => {
+    const out = {};
+    for (const t of document.querySelectorAll('text[data-group-label]')) {
+      out[t.getAttribute('data-group-label')] = (t.textContent || '').trim();
+    }
+    return out;
+  });
+  await ctx.close();
+  return labels;
+}
+
+// Grouping is consecutive-run on the sorted [...online, ...offline] array,
+// so an offline member of the "alpha" prefix family ends up in a separate
+// band (it falls into the offline tier rather than joining the online
+// alpha group). All members that share a multi-member band are by
+// construction online, so the "offline pip" case is unreachable via the
+// group label and the test covers only the working/idle dimensions here.
+const mixed = await probe([
+  { alias: 'alpha1', status: 'working' },
+  { alias: 'alpha2', status: 'working' },
+  { alias: 'alpha3', status: 'idle' },
+  { alias: 'beta',   status: 'idle' },
+]);
+
+const allWorking = await probe([
+  { alias: 'gamma1', status: 'working' },
+  { alias: 'gamma2', status: 'working' },
+  { alias: 'gamma3', status: 'working' },
+  { alias: 'beta',   status: 'idle' },
+]);
+
+await browser.close();
+
+const alphaLabel = mixed.alpha || '';
+const gammaLabel = allWorking.gamma || '';
+
+const results = {
+  alpha_keyPresent:        /^alpha/.test(alphaLabel),
+  alpha_countCorrect:      /·\s*3/.test(alphaLabel),
+  alpha_workingPip:        /2w/.test(alphaLabel),
+  alpha_idlePip:           /1i/.test(alphaLabel),
+  alpha_noOfflinePip:      !/\d+o\b/.test(alphaLabel),
+  // Uniform-status group: only the working pip renders.
+  gamma_workingPip:        /3w/.test(gammaLabel),
+  gamma_noIdlePip:         !/\d+i\b/.test(gammaLabel),
+  gamma_noOfflinePip:      !/\d+o\b/.test(gammaLabel),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group status pips:`, JSON.stringify(results),
+  `\n  alpha="${alphaLabel}"`,
+  `\n  gamma="${gammaLabel}"`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-groupbox-fadein-test.mjs

@@ -0,0 +1,95 @@
+/* Round 173 verification: group boxes (grid layout) fade-in
+ * alongside the R9/R172 first-paint wave.
+ *
+ * Pre-R173 the structural box frames appeared instantly while
+ * nodes inside eased in via R9 (0-540ms) and edges via R172
+ * (280-980ms). The reveal felt like 'frame slams down, nodes
+ * drift in'.
+ *
+ * R173 wraps each group box <g> in:
+ *   className="transition-opacity anet-fade-in"
+ *   style={{ animationDelay: 'boxIdx × 60ms (cap 8)' }}
+ *   data-group-fade-delay={boxIdx × 60}
+ *
+ * Test:
+ *   1. Force grid layout
+ *   2. Mock 4 prefix-clustered sessions → 2 groups
+ *   3. Probe each [data-group] wrapper
+ *   4. Assert anet-fade-in className present
+ *   5. Assert animation-delay 0ms, 60ms
+ */
+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', '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: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  // 2 distinct prefix groups, 2 sessions each → 2 group boxes
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('agents-a1'), mk('agents-a2'),
+    mk('infra-b1'),  mk('infra-b2'),
+  ] } });
+});
+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-group]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const boxes = [...document.querySelectorAll('g[data-group]')];
+  return boxes.map(b => ({
+    key:            b.getAttribute('data-group'),
+    hasFadeClass:   (b.getAttribute('class') || '').includes('anet-fade-in'),
+    fadeDelayAttr:  parseFloat(b.getAttribute('data-group-fade-delay') || ''),
+    animationDelay: b.style.animationDelay || getComputedStyle(b).animationDelay,
+  }));
+});
+
+await browser.close();
+
+const parseDelay = (s) => {
+  if (!s) return null;
+  if (s.endsWith('ms')) return parseFloat(s);
+  if (s.endsWith('s')) return parseFloat(s) * 1000;
+  return parseFloat(s);
+};
+const delays = probe.map(p => parseDelay(p.animationDelay));
+
+const results = {
+  two_boxes_found:        probe.length === 2,
+  all_have_fade_class:    probe.every(p => p.hasFadeClass),
+  box0_delay_attr_0:      probe[0]?.fadeDelayAttr === 0,
+  box1_delay_attr_60:     probe[1]?.fadeDelayAttr === 60,
+  box0_anim_delay_0ms:    delays[0] === 0,
+  box1_anim_delay_60ms:   Math.abs(delays[1] - 60) < 0.5,
+  delays_strictly_increase: delays[0] < delays[1],
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} groupbox fade-in:`, JSON.stringify(results),
+  `\n  boxes =`, probe,
+  `\n  delays (ms) =`, delays);
+process.exit(ok ? 0 : 1);

package/scripts/topo-groupbox-hover-lift-test.mjs

@@ -0,0 +1,127 @@
+/* Round 142 verification: group boxes (R85+R68) gain a drop-
+ * shadow lift on hover or pin, mirroring R135's overlay panel
+ * hover-elevation. Closes the "interactive surface elevates"
+ * vocabulary across canvas-side major surfaces:
+ *   R18  KPI cards (Overview)
+ *   R135 overlay panels (recent-signal + legend)
+ *   R142 group boxes (canvas-level filter)
+ *
+ * Each carries a soft outward shadow when hovered/selected.
+ *
+ * States walked (grid layout, three prefix groups):
+ *   1. Idle → all 3 boxes: data-group-box-lifted="false", no filter
+ *   2. Hover infra label → infra lifted=true, filter set; others stay flat
+ *   3. Leave hover → infra restored to flat
+ *   4. Pin agents via CustomEvent → agents lifted=true (R63 pin path)
+ *   5. Esc → agents back to flat
+ */
+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');
+    // R85 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', 'idle'), mk('agents-a3', 'idle'),
+    mk('infra-b1',  'working'), mk('infra-b2',  'idle'),
+    mk('build-c1',  'idle'),    mk('build-c2',  '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('g[data-node]').length === 7, { timeout: 30000 });
+await page.waitForSelector('[data-group]', { timeout: 10000 });
+await page.waitForTimeout(500);
+
+const inspectAll = () => page.evaluate(() => {
+  const boxes = [...document.querySelectorAll('rect[data-group-box-pinned]')];
+  return boxes.map(rect => {
+    const parentG = rect.closest('g[data-group]');
+    return {
+      group:   parentG?.getAttribute('data-group'),
+      lifted:  rect.getAttribute('data-group-box-lifted'),
+      filter:  rect.getAttribute('filter'),
+      pinned:  rect.getAttribute('data-group-box-pinned'),
+    };
+  });
+});
+
+const state1 = await inspectAll();
+const idleAll = state1.every(b => b.lifted === 'false' && !b.filter);
+
+// Hover infra label
+const infra = state1.find(b => (b.group || '').startsWith('infra'));
+await page.locator(`[data-group-label-hit="${infra.group}"]`).first().hover({ timeout: 3000 });
+await page.waitForTimeout(250);
+const state2 = await inspectAll();
+const infra2 = state2.find(b => b.group === infra.group);
+const othersFlat2 = state2.filter(b => b.group !== infra.group).every(b => b.lifted === 'false' && !b.filter);
+
+// Mouse away → restore
+await page.mouse.move(20, 20);
+await page.waitForTimeout(250);
+const state3 = await inspectAll();
+const infra3 = state3.find(b => b.group === infra.group);
+
+// Pin agents via CustomEvent
+const agents = state1.find(b => (b.group || '').startsWith('agents'));
+await page.evaluate((key) => {
+  window.dispatchEvent(new CustomEvent('anet:topo-pin', { detail: { kind: 'group', value: key } }));
+}, agents.group);
+await page.waitForTimeout(250);
+const state4 = await inspectAll();
+const agents4 = state4.find(b => b.group === agents.group);
+
+// Esc clears pin
+await page.keyboard.press('Escape');
+await page.waitForTimeout(250);
+const state5 = await inspectAll();
+const agents5 = state5.find(b => b.group === agents.group);
+
+await browser.close();
+
+const liftFilter = 'url(#topo-groupbox-lift)';
+const results = {
+  s1_idleAllFlat:           idleAll,
+
+  s2_infraLifted:           infra2?.lifted === 'true',
+  s2_infraHasFilter:        infra2?.filter === liftFilter,
+  s2_othersStillFlat:       othersFlat2,
+
+  s3_infraRestored:         infra3?.lifted === 'false' && !infra3.filter,
+
+  s4_agentsLifted:          agents4?.lifted === 'true',
+  s4_agentsHasFilter:       agents4?.filter === liftFilter,
+  s4_agentsPinnedAttr:      agents4?.pinned === 'true',
+
+  s5_agentsCleared:         agents5?.lifted === 'false' && !agents5.filter,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} groupbox hover-lift:`, JSON.stringify(results),
+  `\n  s1=`, state1,
+  `\n  infra2=`, infra2, ` agents4=`, agents4, ` agents5=`, agents5);
+process.exit(ok ? 0 : 1);