@sleep2agi/agent-network-dashboard 0.4.6-preview.9 → 0.4.6

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

@@ -0,0 +1,115 @@
+/* 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();
+
+const lifted = (m) => m.beforeY != null && m.afterY != null && m.beforeY - m.afterY >= 1 && m.beforeY - m.afterY <= 2.5;
+
+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);

package/scripts/topo-lastseen-tooltip-test.mjs

@@ -0,0 +1,59 @@
+/* Round 34 verification: offline node tooltip carries "last seen: <relative>";
+ * online nodes skip the line. SQL-style timestamp parsing is exercised in
+ * production (CommHub format) but the existing isGhost filter has a
+ * separate TZ-sensitivity issue that ghosts SQL-without-Z entries on
+ * non-UTC browsers — out of Round 34 scope. The helper supports both
+ * formats; the SQL path is covered by manual inspection. */
+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 {}
+});
+// One online, two offline at different ages (both ISO).
+const now = Date.now();
+const isoMin = (m) => new Date(now - m * 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 fresh = isoMin(0.1);
+  const sessions = [
+    { alias: 'live',    status: 'idle',    network_id: nid, project_dir: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'off6m',   status: 'offline', network_id: nid, project_dir: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: isoMin(6) },
+    { alias: 'off45m',  status: 'offline', network_id: nid, project_dir: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: isoMin(45) },
+  ];
+  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 === 3, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const titleOf = alias => page.$eval(`g[data-node="${alias}"] title`, el => el.textContent);
+const live = await titleOf('live');
+const off6m = await titleOf('off6m');
+const off45m = await titleOf('off45m');
+
+await browser.close();
+const results = {
+  liveSkipsLastSeen: !/last seen:/.test(live),
+  off6mShows6mAgo: /last seen: [56]m ago/.test(off6m),    // 6m exactly, ±1 minute slack
+  off45mShows45mAgo: /last seen: 4[45]m ago/.test(off45m), // 45m exactly, ±1 minute slack
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} last-seen tooltip:`, JSON.stringify(results),
+  `\n  live=${JSON.stringify(live)}\n  off6m=${JSON.stringify(off6m)}\n  off45m=${JSON.stringify(off45m)}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-layout-key-test.mjs

@@ -0,0 +1,91 @@
+/* Round 32 verification: `l` (and `L`) keyboard shortcut toggles
+ * ring ↔ grid; titles + Help overlay surface the hint; input-focus
+ * suppression still blocks it. */
+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: 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'); // start on 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 = ['a', 'b', 'c'].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.waitForSelector('button[aria-label="Topology layout"], button[title*="Ring layout"]', { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const layoutPressed = () => page.evaluate(() => {
+  const ring = document.querySelector('button[title^="Ring layout"]');
+  const grid = document.querySelector('button[title^="Grid layout"]');
+  return { ring: ring?.getAttribute('aria-pressed'), grid: grid?.getAttribute('aria-pressed') };
+});
+
+const initial = await layoutPressed();
+
+// Press `l` → should toggle to ring
+await page.keyboard.press('l');
+await page.waitForTimeout(150);
+const afterL = await layoutPressed();
+
+// Press `L` (shift+l) → toggle back to grid
+await page.keyboard.press('Shift+L');
+await page.waitForTimeout(150);
+const afterShiftL = await layoutPressed();
+
+// Titles carry the hint
+const titles = await page.evaluate(() => ({
+  ring: document.querySelector('button[title^="Ring layout"]')?.getAttribute('title') || '',
+  grid: document.querySelector('button[title^="Grid layout"]')?.getAttribute('title') || '',
+}));
+
+// Help overlay lists the shortcut
+await page.keyboard.press('?');
+await page.waitForTimeout(200);
+const helpHasLayout = await page.evaluate(() => {
+  const heading = [...document.querySelectorAll('[role="dialog"] div')].find(el => el.textContent === 'Topology canvas');
+  if (!heading) return false;
+  return /Toggle layout/i.test(heading.parentElement?.textContent || '');
+});
+
+// Input-focus suppression — Cmd+K input, press l, no toggle
+await page.keyboard.press('Escape');
+await page.keyboard.press('Meta+k');
+await page.waitForTimeout(200);
+const palette = page.locator('input[placeholder*="Search"], input[type="search"], [role="dialog"] input').first();
+await palette.focus().catch(() => {});
+const beforeFocusToggle = await layoutPressed();
+await page.keyboard.press('l');
+await page.waitForTimeout(150);
+const afterFocusToggle = await layoutPressed();
+await page.keyboard.press('Escape');
+
+await browser.close();
+const results = {
+  startsGrid: initial.grid === 'true' && initial.ring === 'false',
+  lTogglesToRing: afterL.ring === 'true' && afterL.grid === 'false',
+  shiftLTogglesBack: afterShiftL.grid === 'true' && afterShiftL.ring === 'false',
+  titlesPresent: /l to toggle/i.test(titles.ring) && /l to toggle/i.test(titles.grid),
+  helpListsLayout: helpHasLayout,
+  inputFocusSuppressed: beforeFocusToggle.grid === afterFocusToggle.grid && beforeFocusToggle.ring === afterFocusToggle.ring,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} layout key:`, JSON.stringify(results), `titles=`, titles);
+process.exit(ok ? 0 : 1);

package/scripts/topo-minimap-test.mjs

@@ -0,0 +1,68 @@
+/* Round 30 verification: minimap.
+ *  - not mounted at default view (1×, centered)
+ *  - mounted when zoomed in (one node dot per session, viewport rect)
+ *  - click recenters the canvas (view.x / view.y change) */
+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: 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-view', JSON.stringify({ zoom: 1, x: 0, y: 0 }));
+    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 = ['A站', 'B站', 'C站', 'D站', 'E站', 'F站'].flatMap(g =>
+    Array.from({ length: 3 }, (_, i) => ({
+      alias: `${g}${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.waitForSelector('svg[viewBox="0 0 1000 680"]', { timeout: 30000 });
+await page.waitForTimeout(500);
+
+const minimap = '[data-topo-minimap]';
+const notMountedAtDefault = (await page.locator(minimap).count()) === 0;
+
+// Zoom in via `+` twice → view changes → minimap mounts
+await page.keyboard.press('=');
+await page.keyboard.press('=');
+await page.waitForTimeout(200);
+const mountedAfterZoom = (await page.locator(minimap).count()) === 1;
+const dotCount = await page.locator(`${minimap} svg circle`).count();
+const hasViewportRect = await page.locator(`${minimap} svg rect`).count() > 0;
+
+// Click on the minimap's far left → expect view.x to become more positive (canvas pans right)
+const beforeView = await page.evaluate(() => JSON.parse(localStorage.getItem('anet-topo-view')));
+const mmBox = await page.locator(minimap).boundingBox();
+await page.mouse.click(mmBox.x + 10, mmBox.y + mmBox.height / 2);
+await page.waitForTimeout(200);
+const afterView = await page.evaluate(() => JSON.parse(localStorage.getItem('anet-topo-view')));
+const clickRecenters = afterView.x !== beforeView.x || afterView.y !== beforeView.y;
+
+await browser.close();
+const results = {
+  notMountedAtDefault,
+  mountedAfterZoom,
+  oneDotPerSession: dotCount === 18, // 6 groups × 3 = 18 nodes
+  viewportRectPresent: hasViewportRect,
+  clickRecenters,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} minimap:`, JSON.stringify(results), `dots=${dotCount} view before=`, beforeView, `after=`, afterView);
+process.exit(ok ? 0 : 1);

package/scripts/topo-mobile-chips-test.mjs

@@ -0,0 +1,103 @@
+/* Round 47 verification: mobile chip collapse.
+ *  - At narrow viewport (375px), pressure / vendor-dist / active-links /
+ *    freshness chips are display:none; only essential chips render.
+ *  - At sm+ (≥640px), the full chip row is visible.
+ *  - Essential chips (Ring/Grid toggle + working + online) render at both. */
+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(width) {
+  const ctx = await browser.newContext({ viewport: { width, 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 = [
+      { alias: 'wkr', status: 'working', network_id: nid, project_dir: null,
+        model: 'claude-opus-4', runtime: 'cli-claude-code',
+        created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+      { alias: 'idl', status: 'idle', network_id: nid, project_dir: null,
+        model: 'gpt-5', runtime: 'codex-cli',
+        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: [
+    { from_alias: 'wkr', to_alias: 'idl', content: 'm', created_at: new Date().toISOString() },
+  ] } }));
+  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' });
+  // The Overview page auto-hides the topology when window.innerWidth < 1024
+  // (the lg breakpoint). On narrow viewports the user clicks "Show
+  // Topology" to surface it; mimic that here so the chip-row tests reach
+  // the actual code path. Wait for SWR to deliver sessions first so the
+  // button renders before we look for it.
+  await page.waitForTimeout(1500);
+  const showBtn = page.locator('button', { hasText: /Show Topology/i });
+  if (await showBtn.count() > 0) await showBtn.first().click();
+  await page.waitForSelector('svg[viewBox="0 0 1000 680"]', { timeout: 30000 });
+  await page.waitForTimeout(600);
+  const visible = (sel) => page.evaluate(s => {
+    const el = document.querySelector(s);
+    if (!el) return null;
+    const r = el.getBoundingClientRect();
+    return r.width > 0 && r.height > 0;
+  }, sel);
+  const result = {
+    workingChipVisible: await page.evaluate(() => {
+      // "{N} working" chip — find the green-tinted one
+      const spans = [...document.querySelectorAll('span')];
+      const chip = spans.find(s => /^\d+ working$/.test((s.textContent || '').trim()));
+      if (!chip) return false;
+      const r = chip.getBoundingClientRect();
+      return r.width > 0 && r.height > 0;
+    }),
+    onlineChipVisible: await page.evaluate(() => {
+      const spans = [...document.querySelectorAll('span')];
+      const chip = spans.find(s => /^\d+ online$/.test((s.textContent || '').trim()));
+      if (!chip) return false;
+      const r = chip.getBoundingClientRect();
+      return r.width > 0 && r.height > 0;
+    }),
+    pressureVisible: await visible('[data-fleet-pressure]'),
+    activeLinksVisible: await page.evaluate(() => {
+      const spans = [...document.querySelectorAll('span')];
+      const chip = spans.find(s => /active link/.test(s.textContent || ''));
+      if (!chip) return false;
+      const r = chip.getBoundingClientRect();
+      return r.width > 0 && r.height > 0;
+    }),
+    freshnessVisible: await visible('[data-freshness-chip]'),
+  };
+  await ctx.close();
+  return result;
+}
+
+const mobile = await probe(375);
+const desktop = await probe(900);
+await browser.close();
+
+const results = {
+  mobileEssentialsVisible: mobile.workingChipVisible && mobile.onlineChipVisible,
+  mobilePressureHidden: mobile.pressureVisible === false,
+  mobileActiveLinksHidden: mobile.activeLinksVisible === false,
+  mobileFreshnessHidden: mobile.freshnessVisible === false,
+  desktopAllVisible: desktop.workingChipVisible && desktop.onlineChipVisible && desktop.pressureVisible && desktop.activeLinksVisible && desktop.freshnessVisible,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} mobile chips:`, JSON.stringify(results),
+  `\n  mobile=`, mobile, `\n  desktop=`, desktop);
+process.exit(ok ? 0 : 1);

package/scripts/topo-offline-dim-test.mjs

@@ -0,0 +1,70 @@
+/* Round 17 verification: offline nodes render at opacity 0.6 at rest,
+ * online stay at 1, and the chat-focused node (even if offline) jumps
+ * to 1 when its ChatPopover opens. */
+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 {}
+});
+// fresh-enough so the ghost-age-out filter doesn't drop the offline node
+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: 'on1', status: 'idle',    network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'on2', status: 'working', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'off1', status: 'offline', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'off2', status: 'offline', 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-node]').length === 4;
+}, { timeout: 30000 }).catch(() => {});
+await page.waitForTimeout(500);
+
+const opacityOf = (alias) => page.$eval(`g[data-node="${alias}"]`, el =>
+  parseFloat(getComputedStyle(el).opacity || el.style.opacity || '1'));
+
+const restOn1 = await opacityOf('on1');
+const restOn2 = await opacityOf('on2');
+const restOff1 = await opacityOf('off1');
+const restOff2 = await opacityOf('off2');
+
+// Click an offline node — the chat popover should open and that node
+// should jump to full opacity.
+await page.locator('g[data-node="off1"]').click();
+await page.waitForTimeout(300);
+const focusedOff1 = await opacityOf('off1');
+const otherOff2 = await opacityOf('off2');
+
+await browser.close();
+const results = {
+  onlineFullOpacity: Math.abs(restOn1 - 1) < 0.01 && Math.abs(restOn2 - 1) < 0.01,
+  offlineDimmedAtRest: Math.abs(restOff1 - 0.6) < 0.01 && Math.abs(restOff2 - 0.6) < 0.01,
+  chatFocusOfflineRestoresOpacity: Math.abs(focusedOff1 - 1) < 0.01,
+  otherOfflineStaysDimmed: Math.abs(otherOff2 - 0.6) < 0.01,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} offline dim:`, JSON.stringify(results),
+  `rest=on1:${restOn1} on2:${restOn2} off1:${restOff1} off2:${restOff2}`,
+  `clicked off1=${focusedOff1} off2=${otherOff2}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-overlap-test.mjs

@@ -3,7 +3,10 @@
  *   - node ↔ node       — status rings don't intersect
  *   - node ↔ panel      — no node circle intersects an overlay panel rect
  *   - node ↔ group-label — no group-box label text covers a node
- *   - group-box ↔ box   — no two group boxes overlap */
+ *   - group-box ↔ box   — no two group boxes overlap
+ *   - label ↔ label     — no two text labels overlap (Round 27 — caught
+ *                         the dense-node-label vs group-label collision
+ *                         Vincent reported in preview.29) */
 import { chromium } from 'playwright';
 import { readFileSync, mkdirSync } from 'node:fs';
 
@@ -80,11 +83,24 @@ async function check(layout) {
         label: { x: bb.x, y: bb.y, w: bb.width, h: bb.height },
       };
     });
-    return { nodes, panels, groups };
+    // Round 27 / P0: every visible label bbox (node alias text + group
+    // headings) so we can assert label↔label clearance. Skip elements
+    // with empty bboxes (e.g., text inside an unrendered <g>).
+    const allLabels = [];
+    for (const t of svg.querySelectorAll('g[data-node] text, g[data-group] text')) {
+      const bb = t.getBBox();
+      if (bb.width === 0 || bb.height === 0) continue;
+      allLabels.push({
+        kind: t.closest('g[data-group]') ? 'group' : 'node',
+        owner: (t.closest('g[data-group]')?.getAttribute('data-group')) || (t.closest('g[data-node]')?.getAttribute('data-node')) || '?',
+        x: bb.x, y: bb.y, w: bb.width, h: bb.height,
+      });
+    }
+    return { nodes, panels, groups, allLabels };
   });
 
   const TOL = 2; // px slack — touching edges is fine, real overlap is not
-  let nodeNode = 0, nodePanel = 0, nodeLabel = 0, boxBox = 0;
+  let nodeNode = 0, nodePanel = 0, nodeLabel = 0, boxBox = 0, labelLabel = 0;
 
   // node ↔ node
   for (let i = 0; i < data.nodes.length; i++) {
@@ -119,12 +135,23 @@ async function check(layout) {
           overlaps1D(a.y, a.y + a.h, b.y, b.y + b.h, TOL)) boxBox++;
     }
   }
+  // label ↔ label  (Round 27)
+  // Same-node node-labels (e.g. alias + sub-status in the full card) are
+  // intentionally close and adjacent — skip pairs that share an owner.
+  for (let i = 0; i < data.allLabels.length; i++) {
+    for (let j = i + 1; j < data.allLabels.length; j++) {
+      const a = data.allLabels[i], b = data.allLabels[j];
+      if (a.owner === b.owner) continue;
+      if (overlaps1D(a.x, a.x + a.w, b.x, b.x + b.w, TOL) &&
+          overlaps1D(a.y, a.y + a.h, b.y, b.y + b.h, TOL)) labelLabel++;
+    }
+  }
 
   await page.screenshot({ path: `/tmp/anet-issue-112/overlap-${layout}.png` });
   await ctx.close();
-  const ok = nodeNode === 0 && nodePanel === 0 && nodeLabel === 0 && boxBox === 0;
+  const ok = nodeNode === 0 && nodePanel === 0 && nodeLabel === 0 && boxBox === 0 && labelLabel === 0;
   console.log(`${ok ? '✅' : '❌'} [${layout}] nodes=${data.nodes.length} groups=${data.groups.length} — ` +
-    `node↔node:${nodeNode} node↔panel:${nodePanel} node↔label:${nodeLabel} box↔box:${boxBox}`);
+    `node↔node:${nodeNode} node↔panel:${nodePanel} node↔label:${nodeLabel} box↔box:${boxBox} label↔label:${labelLabel}`);
   return ok;
 }