@sleep2agi/agent-network-dashboard 0.4.6-preview.8 → 0.4.6-preview.80

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

@@ -0,0 +1,68 @@
+/* Round 19 verification: each group-box label carries a member-count
+ * tspan ("· N"), reflecting the actual member count of the group. */
+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: 900 } });
+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.removeItem('anet-brand');
+    localStorage.removeItem('anet-topo-view');
+    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';
+  // A站 with 4 members, B站 with 2 members → 2 group boxes (counts 4 and 2).
+  const aliases = ['A站红', 'A站蓝', 'A站绿', 'A站黄', 'B站乙', 'B站丙'];
+  const sessions = aliases.map(a => ({
+    alias: a, 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/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(() => {
+  const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+  return !!svg && svg.querySelectorAll('g[data-group]').length === 2;
+}, { timeout: 30000 }).catch(() => {});
+await page.waitForTimeout(400);
+
+const labels = await page.$$eval('svg[viewBox="0 0 1000 680"] g[data-group]', els => els.map(g => {
+  const text = g.querySelector('text');
+  const tspan = text.querySelector('tspan');
+  return {
+    key: g.getAttribute('data-group'),
+    full: text.textContent.replace(/\s+/g, ' ').trim(),
+    chipFontSize: tspan ? +tspan.getAttribute('font-size') : null,
+    chipFontWeight: tspan ? tspan.getAttribute('font-weight') : null,
+  };
+}));
+
+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站·\s*4/.test(a?.full || '') && /^B站·\s*2/.test(b?.full || ''),
+  chipSmallerFont: a?.chipFontSize === 11,
+  chipLighterWeight: a?.chipFontWeight === '400',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group count chip:`, JSON.stringify(results), 'labels=', labels);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,82 @@
+/* Round 18 verification: hovering a node in a multi-member group upgrades
+ * the group-box to accent treatment (solid stroke, thicker, legendAccent
+ * colour) and brightens the label; other groups dim to 0.28; resting
+ * appearance unchanged. */
+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: 900 } });
+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.removeItem('anet-brand');
+    localStorage.removeItem('anet-topo-view');
+    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';
+  // Two prefix groups (A站 / B站), each ≥2 members so groupBoxes renders.
+  const aliases = ['A站红', 'A站蓝', 'A站绿', 'B站乙', 'B站丙', 'B站丁'];
+  const sessions = aliases.map(a => ({
+    alias: a, 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/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(() => {
+  const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+  return !!svg && svg.querySelectorAll('g[data-group]').length === 2;
+}, { timeout: 30000 }).catch(() => {});
+await page.waitForTimeout(400);
+
+const readGroup = key => page.evaluate(k => {
+  const g = document.querySelector(`g[data-group="${k}"]`);
+  if (!g) return null;
+  const rect = g.querySelector('rect');
+  const text = g.querySelector('text');
+  return {
+    opacity: parseFloat(getComputedStyle(g).opacity || '1'),
+    stroke: rect.getAttribute('stroke'),
+    strokeWidth: +rect.getAttribute('stroke-width'),
+    strokeDasharray: rect.getAttribute('stroke-dasharray'),
+    fillOpacity: rect.getAttribute('fill-opacity'),
+    textFill: text.getAttribute('fill'),
+  };
+}, key);
+
+// Resting state (no hover)
+const restA = await readGroup('A站');
+const restB = await readGroup('B站');
+
+// Hover a node in group A站
+await page.locator('g[data-node="A站红"]').hover();
+await page.waitForTimeout(350); // allow the 200ms transition to settle
+
+const hoverA = await readGroup('A站');
+const hoverB = await readGroup('B站');
+
+await browser.close();
+const results = {
+  restADashedThin:     restA?.strokeDasharray === '6 6' && restA?.strokeWidth === 1.5,
+  restBDashedThin:     restB?.strokeDasharray === '6 6' && restB?.strokeWidth === 1.5,
+  hoveredASolidThick:  hoverA?.strokeDasharray === 'none' && hoverA?.strokeWidth === 2,
+  hoveredAAccentStroke: hoverA?.stroke === '#67e8f9', // dark legendAccent
+  hoveredABrighterText: hoverA?.textFill === '#e5e7eb', // dark legendHeadline
+  otherBDimmedOpacity: Math.abs((hoverB?.opacity ?? 1) - 0.28) < 0.02,
+  otherBKeepsDashed: hoverB?.strokeDasharray === '6 6',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group hover linkage:`, JSON.stringify(results));
+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-test.mjs

@@ -86,9 +86,11 @@ const results = {};
     return allGood;
   });
 
-  // label text present for each group
+  // label text present for each group. R19 appended " · N" and R58 appended
+  // status-mix pips ("2w 1i") to the same <text> element, so the textContent
+  // is now "A站· 4 2w 1i" rather than bare "A站". Match by prefix.
   const labels = await page.$$eval(`${svg} g[data-group] text`, els => els.map(e => (e.textContent || '').trim()));
-  results.gridLabels = ['A站', '书生', '通信'].every(g => labels.includes(g));
+  results.gridLabels = ['A站', '书生', '通信'].every(g => labels.some(l => l.startsWith(g)));
 
   await page.screenshot({ path: '/tmp/anet-issue-111/groupbox-grid-cyber.png' });
   await ctx.close();

package/scripts/topo-help-overlay-r59-test.mjs

@@ -0,0 +1,67 @@
+/* Round 59 verification: HelpOverlay topology section documents the new
+ * R52 (hub click → fit) / R55 (legend hover) / R56 (recent-signal hover)
+ * interactions. R41 dbl-click clarification is also expected.
+ *
+ *   Press "?" on the overview page → assert each of the three new entries
+ *   shows up under the "Topology canvas" group heading.
+ */
+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: 900 } });
+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 {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  await route.fulfill({ response: r, json: b });
+});
+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.waitForTimeout(800);
+
+// Open help overlay via `?` (Shift + /).
+await page.keyboard.press('?');
+await page.waitForSelector('[role="dialog"][aria-label="Keyboard shortcuts"]', { timeout: 5000 });
+
+const topology = await page.evaluate(() => {
+  const dialog = document.querySelector('[role="dialog"][aria-label="Keyboard shortcuts"]');
+  if (!dialog) return null;
+  // Walk the group divs — each starts with the group title text. Pick the
+  // one that says "Topology canvas" and capture its `<li>` items.
+  const groups = [...dialog.querySelectorAll('div')];
+  let active = null;
+  for (const g of groups) {
+    if (g.textContent && /^Topology canvas$/i.test(g.textContent.trim())) {
+      active = g.parentElement;
+      break;
+    }
+  }
+  if (!active) return null;
+  return [...active.querySelectorAll('li')].map(li => (li.textContent || '').trim());
+});
+
+await browser.close();
+if (!topology) { console.log('❌ topology group not found in help overlay'); process.exit(1); }
+
+const has = (s) => topology.some(t => t.includes(s));
+const results = {
+  hasHubClickEntry:     has('Fit topology to canvas (R52)'),
+  hasLegendHoverEntry:  has('Highlight nodes of a status (R55)'),
+  hasSignalHoverEntry:  has('Highlight one flow edge (R56)'),
+  hasDblClickClarified: has('(empty canvas only)'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} help overlay R59:`, JSON.stringify(results),
+  `\n  topology items=`, topology);
+process.exit(ok ? 0 : 1);

package/scripts/topo-help-overlay-r65-test.mjs

@@ -0,0 +1,64 @@
+/* Round 65 verification: HelpOverlay topology section catches up on
+ * R63 (group label pin) + R64 (active-filter pill ×).
+ *
+ *   Press "?" → assert both new entries render under "Topology canvas".
+ *   Also verify the R59/R62 prior entries still exist (no regression
+ *   in the section).
+ */
+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: 900 } });
+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 {}
+});
+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.waitForTimeout(800);
+
+// Open help overlay via `?`.
+await page.keyboard.press('?');
+await page.waitForSelector('[role="dialog"][aria-label="Keyboard shortcuts"]', { timeout: 5000 });
+
+const items = await page.evaluate(() => {
+  const dialog = document.querySelector('[role="dialog"][aria-label="Keyboard shortcuts"]');
+  if (!dialog) return [];
+  const groups = [...dialog.querySelectorAll('div')];
+  let active = null;
+  for (const g of groups) {
+    if (g.textContent && /^Topology canvas$/i.test(g.textContent.trim())) {
+      active = g.parentElement;
+      break;
+    }
+  }
+  if (!active) return [];
+  return [...active.querySelectorAll('li')].map(li => (li.textContent || '').trim());
+});
+
+await browser.close();
+if (items.length === 0) { console.log('❌ topology section not found'); process.exit(1); }
+
+const has = (s) => items.some(t => t.includes(s));
+const results = {
+  r63_groupPin:      has('Pin a team focus (R63)'),
+  r64_clearOne:      has('Clear one filter (R64) — Esc clears all'),
+  // R59 priors still present (no regression in section)
+  r52_clickHub:      has('Fit topology to canvas (R52)'),
+  r55_legendHover:   has('Highlight nodes of a status (R55)'),
+  r56_signalHover:   has('Highlight one flow edge (R56)'),
+  r60_pinChip:       has('Pin a status filter (R60/R61)'),
+  r62_esc:           has('Clear pinned filter (R62)'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} help overlay R65:`, JSON.stringify(results),
+  `\n  items=`, items);
+process.exit(ok ? 0 : 1);