@sleep2agi/agent-network-dashboard 0.4.6-preview.7 → 0.4.6-preview.71

package/scripts/topo-groupbox-test.mjs

@@ -22,6 +22,7 @@ async function load(theme, layout) {
   await ctx.addInitScript(({ th, lay }) => {
     try {
       localStorage.setItem('anet-theme', th);
+localStorage.setItem('anet-topo-nodescale', '1');
       localStorage.removeItem('anet-brand');
       localStorage.removeItem('anet-topo-view');
       localStorage.setItem('anet-topo-layout', lay);
@@ -85,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-hub-click-fit-test.mjs

@@ -0,0 +1,137 @@
+/* Round 52 verification: clicking the central hub triggers fitView() and
+ * shows a click-ripple. The hub was previously decoration; now it's the
+ * "re-center" affordance for users who don't know the `f` shortcut.
+ *
+ * Steps:
+ *  - Zoom + pan the topology to a non-default view (Cmd+= twice + drag).
+ *    Confirm the zoom group's transform shifted off identity.
+ *  - Click the hub. Assert:
+ *      1. the zoom group's transform returns to a fitted state (zoom and
+ *         translate change), i.e. the view changed back toward identity-
+ *         or-fit;
+ *      2. a transient ripple <circle> shows up at the hub center, then
+ *         vanishes within ~800ms.
+ *  - Confirm the hub's <title> mentions "click to fit view".
+ */
+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', 'ring');
+    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 = ['alpha', 'beta', 'gamma'].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/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.waitForSelector('g[data-topo-hub]', { timeout: 30000 });
+await page.waitForTimeout(500);
+
+// Read the hub <title> to verify the hint text.
+const hubTitle = await page.evaluate(() => {
+  return document.querySelector('g[data-topo-hub] title')?.textContent || '';
+});
+
+// Find the zoom/pan wrapper <g> (the one whose transform attribute holds
+// the scale + translate string). The TopoGraph wraps all canvas content
+// in a <g> with transform="translate(x, y) scale(zoom)" at the panel root.
+// Grab the first child <g> under the SVG that carries a `transform` with
+// a `scale(` token — that's our zoom group.
+const readTransform = () => page.evaluate(() => {
+  const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+  for (const g of svg.querySelectorAll(':scope > g')) {
+    const t = g.getAttribute('transform') || '';
+    if (t.includes('scale(')) return t;
+  }
+  return null;
+});
+
+const baseTransform = await readTransform();
+
+// Nudge zoom by simulating Ctrl+= twice via keyboard shortcut. The
+// keymap maps '+' to zoomBy; press 'Equal' with the right modifier so
+// browsers see '+'.
+await page.keyboard.press('+');
+await page.keyboard.press('+');
+await page.keyboard.press('+');
+await page.waitForTimeout(150);
+const zoomedTransform = await readTransform();
+
+// Confirm the zoom transform actually changed.
+const zoomChanged = baseTransform !== zoomedTransform;
+
+// Click the hub center. Locator-based click hits the union bbox edge and
+// gets intercepted by the SVG panel rect (which must keep pointer events
+// for canvas pan). Sample the inner core circle (r=10 at viewBox 500,330)
+// via getScreenCTM and click that on-screen point directly.
+const hubCenter = await page.evaluate(() => {
+  const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+  const core = [...svg.querySelectorAll('g[data-topo-hub] circle')].find(
+    c => c.getAttribute('r') === '10'
+  );
+  if (!core) return null;
+  const ctm = core.getScreenCTM();
+  const cx = +core.getAttribute('cx');
+  const cy = +core.getAttribute('cy');
+  return { x: cx * ctm.a + cy * ctm.c + ctm.e, y: cx * ctm.b + cy * ctm.d + ctm.f };
+});
+if (!hubCenter) { console.log('❌ hub core circle not found'); process.exit(1); }
+await page.mouse.click(hubCenter.x, hubCenter.y);
+await page.waitForTimeout(150);
+const afterClickTransform = await readTransform();
+const ripplePresent = await page.evaluate(() => {
+  const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+  // The click ripple is a <circle> with stroke-width="2" + an <animate>.
+  const ripples = [...svg.querySelectorAll('circle')].filter(c => {
+    const sw = c.getAttribute('stroke-width');
+    return sw === '2' && c.querySelector('animate[attributeName="r"]');
+  });
+  return ripples.length > 0;
+});
+
+await page.waitForTimeout(800);
+const rippleGone = await page.evaluate(() => {
+  const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+  const ripples = [...svg.querySelectorAll('circle')].filter(c => {
+    const sw = c.getAttribute('stroke-width');
+    return sw === '2' && c.querySelector('animate[attributeName="r"]');
+  });
+  return ripples.length === 0;
+});
+
+await browser.close();
+
+const results = {
+  hubTitleHasFitHint: /click to fit view/i.test(hubTitle),
+  zoomShifted: zoomChanged,
+  hubClickRestoredView: afterClickTransform !== zoomedTransform,
+  ripplePresentDuringClick: ripplePresent,
+  rippleClearsAfter600ms: rippleGone,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub click fit:`, JSON.stringify(results),
+  `\n  hubTitle=${JSON.stringify(hubTitle)}`,
+  `\n  base    =${baseTransform}`,
+  `\n  zoomed  =${zoomedTransform}`,
+  `\n  fitBack =${afterClickTransform}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-hub-title-test.mjs

@@ -0,0 +1,93 @@
+/* Round 43 verification: central hub carries a `<title>` summary in ring
+ * layout. Assertions:
+ *   - hub renders in ring layout (data-topo-hub group present)
+ *   - <title> reads "Network hub · N sessions · …" with the right counts
+ *   - zero-count clauses (online/working/links) drop cleanly
+ *   - grid layout doesn't render the hub at all */
+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({ layout, sessionsSpec, msgs = [] }) {
+  const ctx = await browser.newContext({ viewport: { width: 1400, height: 1000 } });
+  await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+  await ctx.addInitScript((lay) => {
+    try {
+      localStorage.setItem('anet-theme', 'cyber');
+      localStorage.setItem('anet-topo-layout', lay);
+      sessionStorage.setItem('anet_v3_auth', '1');
+    } catch {}
+  }, layout);
+  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 = sessionsSpec.map(s => ({
+      alias: s.alias, status: s.status, 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: msgs } }));
+  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.waitForSelector('svg[viewBox="0 0 1000 680"]', { timeout: 30000 });
+  await page.waitForTimeout(500);
+  const data = await page.evaluate(() => {
+    const hub = document.querySelector('g[data-topo-hub]');
+    const title = hub?.querySelector('title');
+    return { hubPresent: !!hub, titleText: title?.textContent || null };
+  });
+  await ctx.close();
+  return data;
+}
+
+// Ring + mixed-status fleet → full summary line
+const ringFull = await probe({
+  layout: 'ring',
+  sessionsSpec: [
+    { alias: 'a', status: 'working' },
+    { alias: 'b', status: 'idle' },
+    { alias: 'c', status: 'idle' },
+    { alias: 'd', status: 'offline' },
+  ],
+  msgs: [
+    { from_alias: 'a', to_alias: 'b', content: 'm', created_at: new Date().toISOString() },
+  ],
+});
+// Ring + all-offline → online/working/links clauses drop
+const ringOfflineOnly = await probe({
+  layout: 'ring',
+  sessionsSpec: [
+    { alias: 'x', status: 'offline' },
+    { alias: 'y', status: 'offline' },
+  ],
+});
+// Grid → no hub at all
+const grid = await probe({
+  layout: 'grid',
+  sessionsSpec: [{ alias: 'a', status: 'idle' }, { alias: 'b', status: 'idle' }],
+});
+
+await browser.close();
+// R52 appended "\nclick to fit view" as a second line to the hub
+// <title> so the click-to-fit affordance is discoverable on hover.
+// Compare on the first line only; assert the hint is present too.
+const firstLine = (s) => (s || '').split('\n')[0];
+const results = {
+  ringHubPresent:        ringFull.hubPresent === true,
+  ringFullSummary:       firstLine(ringFull.titleText) === 'Network hub · 4 sessions · 3 online · 1 working · 1 active link',
+  ringOfflineSummary:    ringOfflineOnly.hubPresent === true && firstLine(ringOfflineOnly.titleText) === 'Network hub · 2 sessions',
+  ringHintsAtFit:        /click to fit view/i.test(ringFull.titleText || ''),
+  gridHasNoHub:          grid.hubPresent === false,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub title:`, JSON.stringify(results),
+  `\n  ringFull=${JSON.stringify(ringFull.titleText)}`,
+  `\n  ringOffline=${JSON.stringify(ringOfflineOnly.titleText)}`,
+  `\n  gridHub=${grid.hubPresent}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-ingroup-edge-test.mjs

@@ -0,0 +1,103 @@
+/* Round 53 verification: edges between two members of the hovered prefix
+ * group brighten to 1.3× even if neither endpoint is the exact hovered
+ * alias. Edges leaving the team still dim per R40.
+ *
+ * Sessions:
+ *   alpha1, alpha2, alpha3   — share prefix "alpha" → same group
+ *   beta                     — singleton
+ * Messages:
+ *   alpha1 → alpha2  (touches alpha1 directly → 1.7× per R40)
+ *   alpha2 → alpha3  (BOTH in alpha group but neither is hovered → 1.3× per R53)
+ *   alpha1 → beta    (touches alpha1, beta is outside → 1.7× per R40)
+ *   alpha2 → beta    (in-group endpoint, but beta is outside → 0.35× per R40)
+ *
+ * Hover alpha1 and read the visible flow paths' opacity to validate the
+ * 4-tier ladder.
+ */
+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.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 = ['alpha1', 'alpha2', 'alpha3', 'beta'].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 } });
+});
+const now = new Date().toISOString();
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [
+  { from_alias: 'alpha1', to_alias: 'alpha2', content: 'm', created_at: now },
+  { from_alias: 'alpha2', to_alias: 'alpha3', content: 'm', created_at: now },
+  { from_alias: 'alpha1', to_alias: 'beta',   content: 'm', created_at: now },
+  { from_alias: 'alpha2', 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 readEdgeOpacities = () => 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 readEdgeOpacities();
+
+// Hover alpha1.
+await page.locator('g[data-node="alpha1"]').hover();
+await page.waitForTimeout(300);
+const after = await readEdgeOpacities();
+
+await browser.close();
+
+const get = (m, r) => m[r];
+const baseRef = get(before, 'alpha1 → alpha2');  // pick any
+const exactTouch = get(after, 'alpha1 → alpha2');    // R40 1.7×
+const inGroupOnly = get(after, 'alpha2 → alpha3');   // R53 1.3×
+const externalTouch = get(after, 'alpha1 → beta');   // R40 1.7×
+const externalAway = get(after, 'alpha2 → beta');    // R40 0.35×
+
+const results = {
+  baselineAllEqual: Object.values(before).every(o => Math.abs(o - baseRef) < 0.001),
+  exactTouchBrightest: exactTouch > baseRef * 1.5,
+  inGroupBoosted: inGroupOnly > baseRef * 1.15 && inGroupOnly < exactTouch,
+  externalEndpointStillBright: externalTouch > baseRef * 1.5,
+  externalDims: externalAway < baseRef * 0.5,
+  hierarchyOrdered: exactTouch > inGroupOnly && inGroupOnly > externalAway,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} in-group edge boost:`, JSON.stringify(results),
+  `\n  baseline=${baseRef}`,
+  `\n  α1→α2 (exact)=${exactTouch}`,
+  `\n  α2→α3 (in-group)=${inGroupOnly}`,
+  `\n  α1→β (exact, out)=${externalTouch}`,
+  `\n  α2→β (leaving)=${externalAway}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-label-lift-test.mjs

@@ -0,0 +1,119 @@
+/* Round 26 verification: hovering a node lifts its label group up by
+ * 1.5 px (CSS transform stacked on the SVG positioning translate). Both
+ * the full-card path (sparse fleet) and the dense plain-text path
+ * (large fleet) should respond. */
+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(fleetSize) {
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 1600 } });
+  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');
+      localStorage.setItem('anet-topo-nodescale', '1');
+      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 = Array.from({ length: fleetSize }, (_, i) => ({
+      alias: `lab${i + 1}`, 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((n) => {
+    const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+    return !!svg && svg.querySelectorAll('g[data-node]').length === n;
+  }, fleetSize, { timeout: 30000 }).catch(() => {});
+  await page.waitForTimeout(500);
+
+  // Re-query the label element fresh each sample — React re-renders on
+  // hover (hoveredAlias state change) so any element handle captured
+  // before the hover would be detached/stale by the time we read its
+  // post-hover position.
+  const readLabelTop = () => page.evaluate(() => {
+    const node = document.querySelector('g[data-node="lab1"]');
+    if (!node) return null;
+    const full = [...node.querySelectorAll('g')].find(g => /group-hover:-translate-y/.test(g.getAttribute('class') || ''));
+    const el = full || [...node.querySelectorAll('text')].find(t => /group-hover:-translate-y/.test(t.getAttribute('class') || ''));
+    return el ? el.getBoundingClientRect().top : null;
+  });
+
+  const beforeY = await readLabelTop();
+  await page.locator('g[data-node="lab1"]').hover();
+  await page.waitForTimeout(300);
+  const afterY = await readLabelTop();
+
+  await ctx.close();
+  return { beforeY, afterY };
+}
+
+const sparse = await probe(4);
+// Note: in dense mode the same alias's hover triggers `showFullLabel`,
+// which swaps the plain-text element for the full-card <g>. That path
+// switch makes a same-element before/after comparison meaningless.
+// The plain-text element still carries the same hover-lift class, so
+// the lift wiring is verified at the DOM level via the second probe.
+const denseClassPresent = await (async () => {
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 1600 } });
+  const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+  await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+  await ctx.addInitScript(() => {
+    localStorage.setItem('anet-topo-layout', 'grid');
+    localStorage.setItem('anet-topo-nodescale', '1');
+    sessionStorage.setItem('anet_v3_auth', '1');
+  });
+  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 = Array.from({ length: 28 }, (_, i) => ({
+      alias: `lab${i + 1}`, 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(() => document.querySelectorAll('g[data-node]').length === 28, { timeout: 30000 }).catch(() => {});
+  await page.waitForTimeout(500);
+  const has = await page.evaluate(() => {
+    const node = document.querySelector('g[data-node="lab2"]'); // not the one we'd hover
+    if (!node) return false;
+    const t = [...node.querySelectorAll('text')].find(x => /group-hover:-translate-y/.test(x.getAttribute('class') || ''));
+    return !!t;
+  });
+  await ctx.close();
+  return has;
+})();
+
+await browser.close();
+
+// R26 contributes label-only -1.5px lift; R51 (preview.58) adds -2px on the
+// parent <g data-node> on hover, so the label's total measured movement
+// when the node is hovered is ~3.5px. Widen the upper bound to 4 so the
+// two lifts compose without flagging this as a regression.
+const lifted = (m) => m.beforeY != null && m.afterY != null && m.beforeY - m.afterY >= 1 && m.beforeY - m.afterY <= 4;
+
+const results = {
+  sparseLabelLifts: lifted(sparse),
+  densePlainTextHasLiftClass: denseClassPresent,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} label hover lift:`, JSON.stringify(results),
+  `sparse=Δ${(sparse.beforeY - sparse.afterY)?.toFixed(2)}px`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-label-scale-test.mjs

@@ -0,0 +1,78 @@
+/* Round 15 verification: at nodeScale=S the label card + fonts step down
+ * one tier (rect 100×42 → 88×36, alias 12 → 11, sub 9 → 8); M and L keep
+ * the existing sizes. */
+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 measure(scaleVal) {
+  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((s) => {
+    try {
+      localStorage.setItem('anet-theme', 'cyber');
+      localStorage.removeItem('anet-brand');
+      localStorage.removeItem('anet-topo-view');
+      localStorage.setItem('anet-topo-layout', 'grid');
+      localStorage.setItem('anet-topo-nodescale', s);
+      sessionStorage.setItem('anet_v3_auth', '1');
+    } catch {}
+  }, scaleVal);
+  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';
+    // 4 nodes only → sparse, so the full-card label path renders.
+    const sessions = ['lab1', 'lab2', 'lab3', 'lab4'].map(a => ({
+      alias: a, status: 'idle', network_id: nid, project_dir: null,
+      created_at: '2026-05-15T00:00:00Z', updated_at: '2026-05-15T00:00:00Z',
+      last_seen_at: new Date().toISOString(),
+    }));
+    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-node]').length === 4;
+  }, { timeout: 30000 }).catch(() => {});
+  await page.waitForTimeout(400);
+  const m = await page.$eval('g[data-node="lab1"]', g => {
+    // label card = the <g transform="translate(...)" > inside the node <g>
+    // that contains the rect+two texts; pick the rect we just changed.
+    const labelG = [...g.querySelectorAll('g')].find(x => x.querySelector('rect') && x.querySelectorAll('text').length === 2);
+    if (!labelG) return null;
+    const rect = labelG.querySelector('rect');
+    const texts = labelG.querySelectorAll('text');
+    return {
+      w: +rect.getAttribute('width'),
+      h: +rect.getAttribute('height'),
+      aliasFs: +texts[0].getAttribute('font-size'),
+      subFs: +texts[1].getAttribute('font-size'),
+    };
+  });
+  await ctx.close();
+  return m;
+}
+
+const S = await measure('0.7');
+const M = await measure('0.84');
+const L = await measure('1');
+await browser.close();
+
+const results = {
+  smallCardW: S?.w === 88,
+  smallCardH: S?.h === 36,
+  smallAliasFs: S?.aliasFs === 11,
+  smallSubFs: S?.subFs === 8,
+  mediumKeepsW: M?.w === 100,
+  mediumKeepsAliasFs: M?.aliasFs === 12,
+  largeKeepsW: L?.w === 100,
+  largeKeepsAliasFs: L?.aliasFs === 12,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} label scale:`, JSON.stringify(results), 'S=', S, 'M=', M, 'L=', L);
+process.exit(ok ? 0 : 1);