@sleep2agi/agent-network-dashboard 0.4.6-preview.24 → 0.4.6-preview.241

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-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-layout-switch-crossfade-test.mjs

@@ -0,0 +1,126 @@
+/* Round 170 verification: layout toggle (Ring ↔ Grid) crossfade.
+ *
+ * Pre-R170 clicking Ring/Grid teleported every node to its new
+ * position in one frame — most jarring user action on the canvas.
+ *
+ * R170 introduces layoutSwitching one-shot flag (same pattern as
+ * R168 smoothView but on opacity axis). The viewport <g>:
+ *   transition: 'opacity 250ms ease-out' (always present)
+ *              + 'transform 300ms ease-out' (when smoothView armed)
+ *   opacity: layoutSwitching ? 0.45 : 1
+ *   data-topo-viewport-layout-switching: 'true' | 'false'
+ *
+ * Layout state swap is synchronous (setLayout) — the dim masks
+ * the snap as a soft blink. Auto-clears 400ms (covers fade-down
+ * 250ms + buffer for React commit).
+ *
+ * Test:
+ *   1. Idle (ring layout): layoutSwitching='false', opacity=1
+ *   2. Press 'L' (toggleLayout) → flag='true', opacity=0.45
+ *   3. Layout state flipped to grid (group boxes visible)
+ *   4. Wait 450ms → flag='false', opacity=1
+ *   5. Press 'L' again → flag='true' (reverse direction works too)
+ */
+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: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  // Prefix-clustered aliases so group boxes render in grid layout
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('agents-a1'), mk('agents-a2'), mk('infra-b1'), mk('infra-b2'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-topo-viewport]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probeViewport = () => page.evaluate(() => {
+  const g = document.querySelector('[data-topo-viewport]');
+  return {
+    layoutSwitching: g?.getAttribute('data-topo-viewport-layout-switching'),
+    opacity:        g?.style?.opacity || '',
+    transition:     g?.style?.transition || '',
+    hubVisible:     !!document.querySelector('[data-topo-hub]'),
+    groupBoxes:     document.querySelectorAll('[data-group-box-pinned]').length,
+  };
+});
+
+const idle = await probeViewport();
+
+// Press 'L' to toggle ring → grid. Probe within 400ms window.
+await page.keyboard.press('l');
+await page.waitForTimeout(50);
+const duringToggle1 = await probeViewport();
+
+// Wait past 400ms window
+await page.waitForTimeout(420);
+const afterToggle1 = await probeViewport();
+
+// Press 'L' again to toggle grid → ring
+await page.keyboard.press('l');
+await page.waitForTimeout(50);
+const duringToggle2 = await probeViewport();
+
+await page.waitForTimeout(420);
+const afterToggle2 = await probeViewport();
+
+await browser.close();
+
+const results = {
+  viewport_found:                idle !== null,
+  idle_layoutSwitching_false:    idle.layoutSwitching === 'false',
+  idle_opacity_1:                idle.opacity === '1' || idle.opacity === '',
+  idle_has_opacity_transition:   idle.transition.includes('opacity 250ms'),
+  idle_in_ring:                  idle.hubVisible && idle.groupBoxes === 0,
+
+  toggle1_flag_true:             duringToggle1.layoutSwitching === 'true',
+  toggle1_opacity_0p45:          duringToggle1.opacity === '0.45',
+  // Layout state has flipped synchronously inside toggleLayout
+  toggle1_now_grid:              !duringToggle1.hubVisible && duringToggle1.groupBoxes > 0,
+
+  after1_flag_false:             afterToggle1.layoutSwitching === 'false',
+  after1_opacity_1:              afterToggle1.opacity === '1',
+  after1_still_grid:             !afterToggle1.hubVisible && afterToggle1.groupBoxes > 0,
+
+  toggle2_flag_true:             duringToggle2.layoutSwitching === 'true',
+  toggle2_opacity_0p45:          duringToggle2.opacity === '0.45',
+  toggle2_back_to_ring:          duringToggle2.hubVisible && duringToggle2.groupBoxes === 0,
+
+  after2_flag_false:             afterToggle2.layoutSwitching === 'false',
+  after2_opacity_1:              afterToggle2.opacity === '1',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} layout switch crossfade:`, JSON.stringify(results),
+  `\n  idle =`, idle,
+  `\n  during toggle1 (ring→grid) =`, duringToggle1,
+  `\n  after toggle1 =`, afterToggle1,
+  `\n  during toggle2 (grid→ring) =`, duringToggle2,
+  `\n  after toggle2 =`, afterToggle2);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,131 @@
+/* Round 163 verification: Ring/Grid layout toggle buttons pick
+ * up the R154 chrome-button polish convention.
+ *
+ * Pre-R163 the buttons had aria-pressed + transition-colors but:
+ *   - no focus-visible ring (browser default invisible on canvas)
+ *   - inactive hover only nudged text-gray-500 → gray-400, no bg
+ *
+ * R163 adds:
+ *   data-topo-chrome-layout="ring|grid"
+ *   data-topo-chrome-layout-active="true|false"
+ *   focus-visible:ring-2 ring-cyan-400/60 ring-inset
+ *   inactive: hover:text-gray-300 + hover:bg-cyan-500/5
+ *   active:   hover:bg-cyan-500/20 (slightly hotter)
+ *
+ * Test:
+ *   1. Both buttons present with data-topo-chrome-layout attr
+ *   2. Active button has bg-cyan-500/15 class fragment (existing)
+ *   3. Focus the inactive button → focus-visible ring class fragment
+ *   4. Hover the inactive button → bg color shifts from transparent
+ *      to a cyan-ish tint (border bg-cyan-500/5)
+ */
+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: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [mk('alpha'), mk('beta')] } });
+});
+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 === 2, { timeout: 30000 });
+await page.waitForSelector('[data-topo-chrome-layout]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+// Probe basic attrs & class membership
+const probe = await page.evaluate(() => {
+  const ring = document.querySelector('[data-topo-chrome-layout="ring"]');
+  const grid = document.querySelector('[data-topo-chrome-layout="grid"]');
+  if (!ring || !grid) return null;
+  return {
+    ring_active:    ring.getAttribute('data-topo-chrome-layout-active'),
+    grid_active:    grid.getAttribute('data-topo-chrome-layout-active'),
+    ring_pressed:   ring.getAttribute('aria-pressed'),
+    grid_pressed:   grid.getAttribute('aria-pressed'),
+    ring_class:     ring.getAttribute('class') || '',
+    grid_class:     grid.getAttribute('class') || '',
+  };
+});
+
+// Focus the inactive (grid) button — focus-visible ring should kick in.
+// Tab-focus produces the :focus-visible state; .focus() doesn't always.
+// Use page.keyboard.press('Tab') after first focusing somewhere known.
+await page.locator('[data-topo-chrome-layout="grid"]').focus();
+// trigger keyboard navigation to enable focus-visible state heuristic
+await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-chrome-layout="grid"]');
+  if (el) el.matches(':focus-visible');
+});
+const focusVisibleProbe = await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-chrome-layout="grid"]');
+  if (!el) return null;
+  return {
+    isActiveElement: document.activeElement === el,
+    // Inspect outline & box-shadow because the Tailwind focus-visible:ring
+    // class compiles to a box-shadow. After .focus() Chromium reports
+    // :focus-visible heuristically — we verify the class fragment exists
+    // in the stylesheet bound to this element rather than relying on the
+    // dynamic pseudo-class match.
+    classFragments: {
+      hasFocusVisibleRingClass: (el.getAttribute('class') || '').includes('focus-visible:ring-cyan-400/60'),
+      hasRingInset:             (el.getAttribute('class') || '').includes('focus-visible:ring-inset'),
+      hasFocusOutlineNone:      (el.getAttribute('class') || '').includes('focus:outline-none'),
+    },
+  };
+});
+
+// Hover the inactive (grid) button — bg should shift away from transparent.
+const gridBgBefore = await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-chrome-layout="grid"]');
+  return el ? getComputedStyle(el).backgroundColor : null;
+});
+await page.locator('[data-topo-chrome-layout="grid"]').hover();
+await page.waitForTimeout(300);
+const gridBgHover = await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-chrome-layout="grid"]');
+  return el ? getComputedStyle(el).backgroundColor : null;
+});
+
+await browser.close();
+
+const results = {
+  both_buttons_found:        probe !== null,
+  ring_is_active:            probe?.ring_active === 'true',
+  grid_is_inactive:          probe?.grid_active === 'false',
+  ring_aria_pressed:         probe?.ring_pressed === 'true',
+  grid_aria_unpressed:       probe?.grid_pressed === 'false',
+  active_has_cyan_bg_class:  probe?.ring_class.includes('bg-cyan-500/15'),
+  inactive_hover_bg_class:   probe?.grid_class.includes('hover:bg-cyan-500/5'),
+  active_hover_bg_class:     probe?.ring_class.includes('hover:bg-cyan-500/20'),
+  focus_outline_none:        focusVisibleProbe?.classFragments?.hasFocusOutlineNone === true,
+  focus_visible_ring_class:  focusVisibleProbe?.classFragments?.hasFocusVisibleRingClass === true,
+  focus_visible_ring_inset:  focusVisibleProbe?.classFragments?.hasRingInset === true,
+  inactive_bg_before:        gridBgBefore !== null,
+  hover_changes_bg:          gridBgBefore !== gridBgHover,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} layout toggle polish:`, JSON.stringify(results),
+  `\n  probe=`, probe,
+  `\n  focus=`, focusVisibleProbe,
+  `\n  bg before/hover=`, gridBgBefore, '→', gridBgHover);
+process.exit(ok ? 0 : 1);