@sleep2agi/agent-network-dashboard 0.4.6-preview.28 → 0.4.6-preview.281

package/scripts/topo-hub-spoke-ease-test.mjs

@@ -0,0 +1,120 @@
+/* Round 241 verification: hub-link spokes (agent→hub paths in ring
+ * layout) gain a 250ms ease-out transition on stroke + stroke-width
+ * + opacity so the idle↔active state flip smooths instead of snaps.
+ *
+ * Pre-R241 a node going active flipped three properties in lockstep
+ * one-frame: stroke (gray→cyan), strokeWidth (1→2), opacity (0.45→
+ * 0.7). R241 eases all three together at the same 250ms cadence.
+ *
+ * Cyber theme palette:
+ *   pal.spokeStroke.idle   = #155e75 (dark cyan)
+ *   pal.spokeStroke.active = #22d3ee (bright cyan)
+ *
+ * Test scope:
+ *   - 4 nodes in ring layout, no messages → 4 idle spokes all
+ *     showing transition wiring, data-topo-hub-spoke-active='false'
+ *   - 5 messages alpha→beta → alpha + beta become active spokes
+ *     (data-topo-hub-spoke-active='true'), 2 stay idle
+ *   - transition style includes stroke + stroke-width + opacity at
+ *     250ms (or 0.25s browser-normalised)
+ */
+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 setup(messages) {
+  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');
+      // R87 layout toggle — ring is default but ensure it's set
+      // (the storage key may exist from previous test runs in grid)
+      localStorage.setItem('anet-topo-layout', 'ring');
+    } 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'), mk('beta'), mk('gamma'), mk('delta'),
+    ] } });
+  });
+  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 === 4, { timeout: 30000 });
+  await page.waitForSelector('[data-topo-hub-spoke-active]', { timeout: 10000, state: 'attached' });
+  await page.waitForTimeout(300);
+  return page;
+}
+
+const probeAll = (page) => page.evaluate(() => {
+  const spokes = Array.from(document.querySelectorAll('[data-topo-hub-spoke-active]'));
+  return spokes.map((s) => ({
+    active:     s.getAttribute('data-topo-hub-spoke-active'),
+    strokeAttr: s.getAttribute('stroke'),
+    strokeWidth: s.getAttribute('stroke-width'),
+    opacityAttr: s.getAttribute('opacity'),
+    transition: s.style.transition,
+  }));
+});
+
+// Scenario A: 4 nodes, no messages → all idle
+const pageA = await setup([]);
+const idleSpokes = await probeAll(pageA);
+await pageA.close();
+
+// Scenario B: 5-msg alpha→beta flow → alpha + beta active
+const now = Date.now();
+const msgs = [];
+for (let i = 0; i < 5; i++) {
+  msgs.push({
+    id: `m${i}`, from_alias: 'alpha', to_alias: 'beta', content: 'hi',
+    network_id: 'default', created_at: new Date(now - (1000 + i * 50)).toISOString(),
+  });
+}
+const pageB = await setup(msgs);
+const activeSpokes = await probeAll(pageB);
+await pageB.close();
+await browser.close();
+
+const hasProp = (s, prop) => new RegExp(`${prop}\\s+(?:250ms|0\\.25s)`).test(s || '');
+const hasFullTransition = (s) =>
+  hasProp(s, 'stroke') && hasProp(s, 'stroke-width') && hasProp(s, 'opacity');
+
+const activeCount = activeSpokes.filter(s => s.active === 'true').length;
+
+const results = {
+  idle_four_spokes:       idleSpokes.length === 4,
+  idle_all_inactive:      idleSpokes.every(s => s.active === 'false'),
+  idle_all_have_transition: idleSpokes.every(s => hasFullTransition(s.transition)),
+  idle_all_stroke_1:      idleSpokes.every(s => s.strokeWidth === '1'),
+  idle_all_opacity_045:   idleSpokes.every(s => s.opacityAttr === '0.45'),
+
+  active_four_spokes:     activeSpokes.length === 4,
+  active_two_active:      activeCount === 2,
+  active_two_inactive:    activeSpokes.length - activeCount === 2,
+  active_all_have_transition: activeSpokes.every(s => hasFullTransition(s.transition)),
+  // Active spokes have strokeWidth='2' and opacity='0.7'
+  active_active_stroke_2: activeSpokes.filter(s => s.active === 'true').every(s => s.strokeWidth === '2'),
+  active_active_opacity_07: activeSpokes.filter(s => s.active === 'true').every(s => s.opacityAttr === '0.7'),
+  // Inactive spokes still at 1/0.45
+  active_inactive_stable: activeSpokes.filter(s => s.active === 'false').every(s => s.strokeWidth === '1' && s.opacityAttr === '0.45'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub spoke ease:`, JSON.stringify(results),
+  '\n  idle:  ',   idleSpokes.map(s => ({ a: s.active, w: s.strokeWidth, o: s.opacityAttr })),
+  '\n  active:',   activeSpokes.map(s => ({ a: s.active, w: s.strokeWidth, o: s.opacityAttr })));
+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-hub-working-count-test.mjs

@@ -0,0 +1,99 @@
+/* Round 130 verification: hub center shows workingCount digit when
+ * > 0. The R84 busyness breath already encodes workingCount through
+ * motion (peak amplitude + period both vary with count buckets);
+ * R130 adds a second channel — the digit itself — at the canvas's
+ * focal point. A glance at the hub now answers two questions
+ * simultaneously: "is the fleet busy" (motion) and "how busy" (number).
+ *
+ * Layout invariant: workingCount=0 falls through to the existing
+ * decorative highlight (data-topo-hub-highlight); workingCount>0
+ * swaps it for the digit text (data-topo-hub-working-count={N}).
+ *
+ * Three states:
+ *   A. all idle (0 working)        → decorative highlight rendered,
+ *                                    no digit text
+ *   B. mix (3 working)             → digit "3" rendered, no highlight
+ *   C. all working (5 working)     → digit "5" rendered, no highlight
+ *
+ * Additional assertion: hub click-to-fit (R52) still works when
+ * the digit is rendered — the text's pointerEvents:none means the
+ * digit can't intercept clicks meant for the hub <g>.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+
+async function probe(workingCount, totalCount = 5) {
+  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'); 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 = [];
+    for (let i = 0; i < totalCount; i++) {
+      sessions.push({
+        alias: `node${i}`,
+        status: i < workingCount ? 'working' : '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 } });
+  });
+  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((n) => document.querySelectorAll('g[data-node]').length === n, totalCount, { timeout: 30000 });
+  await page.waitForTimeout(400);
+
+  const out = await page.evaluate(() => {
+    const digit = document.querySelector('[data-topo-hub-working-count]');
+    const highlight = document.querySelector('[data-topo-hub-highlight]');
+    return {
+      digitPresent:    !!digit,
+      digitText:       digit?.textContent,
+      digitAttr:       digit?.getAttribute('data-topo-hub-working-count'),
+      digitPointerEv:  digit?.getAttribute('style')?.includes('pointer-events: none'),
+      highlightPresent: !!highlight,
+    };
+  });
+
+  await browser.close();
+  return out;
+}
+
+const a = await probe(0, 3);
+const b = await probe(3, 5);
+const c = await probe(5, 5);
+
+const results = {
+  a_noDigit:           !a.digitPresent,
+  a_hasHighlight:      a.highlightPresent,
+
+  b_hasDigit:          b.digitPresent,
+  b_digitText3:        b.digitText === '3',
+  b_digitAttr3:        b.digitAttr === '3',
+  b_pointerNone:       b.digitPointerEv === true,
+  b_noHighlight:       !b.highlightPresent,
+
+  c_hasDigit:          c.digitPresent,
+  c_digitText5:        c.digitText === '5',
+  c_digitAttr5:        c.digitAttr === '5',
+  c_noHighlight:       !c.highlightPresent,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub working count:`, JSON.stringify(results),
+  `\n  A(0 working)=`, a,
+  `\n  B(3 working)=`, b,
+  `\n  C(5 working)=`, c);
+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-card-theme-ease-test.mjs

@@ -0,0 +1,85 @@
+/* Round 246 verification: node label card chrome rect picks up
+ * fill + opacity transitions to coordinate with the existing
+ * filter (R142) + stroke (R217) easing on the same element.
+ *
+ * Pre-R246 the rect transition list was 'filter 220ms ease-out,
+ * stroke 220ms ease-out'. fill (pal.labelBox.fill: cyber dark ↔
+ * light white) and opacity (cyber 0.94, light 1) snapped on theme
+ * toggle. Surrounding elements already ease theme:
+ *   R211 alias/sub text fill (same card)
+ *   R242 chat-target ring filter + stroke
+ *   R244 hub + halo opacity
+ *   R245 edge stroke
+ *
+ * R246 closes the label-card chrome — adds fill + opacity to the
+ * existing transition list so the whole card (background + text)
+ * eases as one unit through theme switches and any future
+ * fill/opacity state changes.
+ *
+ * Test scope per visible label card:
+ *   - element present at [data-node-label-card]
+ *   - style.transition contains filter, stroke, fill, AND opacity
+ *     each at 220ms (or 0.22s browser-normalised)
+ */
+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', 'ring');
+  } 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'), mk('beta'), mk('gamma'), mk('delta'),
+  ] } });
+});
+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 === 4, { timeout: 30000 });
+await page.waitForSelector('[data-node-label-card]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const cards = Array.from(document.querySelectorAll('[data-node-label-card]'));
+  return cards.map((r) => ({
+    alias:      r.getAttribute('data-node-label-card'),
+    elevation:  r.getAttribute('data-node-label-card-elevation'),
+    transition: r.style.transition,
+  }));
+});
+await browser.close();
+
+const hasProp = (s, prop) => new RegExp(`${prop}\\s+(?:220ms|0\\.22s)`).test(s || '');
+
+const results = {
+  four_cards:                probe.length === 4,
+  all_have_alias:            probe.every(p => typeof p.alias === 'string'),
+  all_idle_elevation:        probe.every(p => p.elevation === 'idle'),
+  all_have_filter_220:       probe.every(p => hasProp(p.transition, 'filter')),
+  all_have_stroke_220:       probe.every(p => hasProp(p.transition, 'stroke')),
+  all_have_fill_220:         probe.every(p => hasProp(p.transition, 'fill')),
+  all_have_opacity_220:      probe.every(p => hasProp(p.transition, 'opacity')),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} label card theme ease:`, JSON.stringify(results),
+  '\n  cards:', probe.map(p => ({ a: p.alias, e: p.elevation, t: (p.transition || '').slice(0, 100) })));
+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);