@sleep2agi/agent-network-dashboard 0.4.6 → 0.5.0

package/scripts/topo-kicker-weight-test.mjs

@@ -0,0 +1,98 @@
+/* Round 300 (milestone) verification: kicker font-weight bumps from
+ * default (400/normal) → font-medium (500). Uppercase eyebrow at
+ * text-xs with R285 tracking-widest reads slightly under-authored
+ * at 400; 500 lifts the label to the conventional SaaS-eyebrow
+ * weight (Stripe / Vercel / Linear).
+ *
+ * Hierarchy preserved: h2 (600 font-semibold) > kicker (500 font-
+ * medium) > body weight families.
+ *
+ * Contract:
+ *   - [data-topo-section-kicker] computed font-weight === 500.
+ *   - R296 kicker color (~gray-500) preserved.
+ *   - R285 tracking-widest (~1.2px @ 12px) preserved.
+ *   - R299 title-block mb=16px + R298 left flex gap=10px preserved.
+ *   - R297 brand-logo transition + R294 pulse absent intact.
+ */
+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'); } 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, model) => ({
+    alias, status: 'working', model, 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', 'claude-opus-4'),
+    mk('beta',  'gpt-4o'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (r) => r.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForSelector('[data-topo-section-kicker]', { timeout: 15000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const kicker = document.querySelector('[data-topo-section-kicker]');
+  const title  = document.querySelector('[data-topo-section-title]');
+  const logo   = document.querySelector('[data-topo-brand-logo]');
+  const kCs = kicker ? getComputedStyle(kicker) : null;
+  const tCs = title  ? getComputedStyle(title)  : null;
+  const flexParent = logo?.parentElement;
+  const flexCs = flexParent ? getComputedStyle(flexParent) : null;
+  const titleBlockContainer = flexParent?.parentElement;
+  const tbCs = titleBlockContainer ? getComputedStyle(titleBlockContainer) : null;
+  const swatch = document.querySelector('[data-legend-swatch="working"]');
+  return {
+    kickerFontWeight: kCs?.fontWeight ?? null,
+    kickerColor:      kCs?.color ?? null,
+    kickerLetterSpacing: kCs?.letterSpacing ?? null,
+    titleFontWeight:  tCs?.fontWeight ?? null,
+    titleBlockMarginBottom: tbCs?.marginBottom ?? null,
+    leftFlexGap:      flexCs?.columnGap ?? null,
+    brandLogoTransition: logo ? getComputedStyle(logo).transition : null,
+    swatchR:          swatch?.getAttribute('r') ?? null,
+    pulseCount:       document.querySelectorAll('[data-pulse-wrapper]').length,
+  };
+});
+await browser.close();
+
+const kFw = parseInt(probe.kickerFontWeight) || 0;
+const tFw = parseInt(probe.titleFontWeight) || 0;
+const ls = parseFloat(probe.kickerLetterSpacing) || 0;
+const mb = parseFloat(probe.titleBlockMarginBottom) || 0;
+const gap = parseFloat(probe.leftFlexGap) || 0;
+
+const results = {
+  kicker_weight_500:        kFw === 500,
+  title_weight_higher:      tFw > kFw,
+  r285_tracking_widest:     ls >= 1.0 && ls <= 1.5,
+  r296_kicker_color_not_gray600: !/rgba?\(\s*75\s*,\s*85\s*,\s*99/.test(probe.kickerColor || ''),
+  r299_mb_16:               mb >= 15.5 && mb <= 16.5,
+  r298_gap_10:              gap >= 9.5 && gap <= 10.5,
+  r297_transition_kept:     /color/.test(probe.brandLogoTransition || ''),
+  r295_swatch_r_6:          probe.swatchR === '6',
+  r294_pulse_absent:        probe.pulseCount === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} kicker weight (R300 milestone):`, JSON.stringify(results),
+  '\n  kicker font-weight:', probe.kickerFontWeight,
+  '\n  title  font-weight:', probe.titleFontWeight,
+  '\n  letter-spacing:', probe.kickerLetterSpacing,
+  '\n  title-block mb (R299):', probe.titleBlockMarginBottom);
+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

@@ -103,7 +103,11 @@ const denseClassPresent = await (async () => {
 
 await browser.close();
 
-const lifted = (m) => m.beforeY != null && m.afterY != null && m.beforeY - m.afterY >= 1 && m.beforeY - m.afterY <= 2.5;
+// 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),

package/scripts/topo-layout-hover-text-preview-test.mjs

@@ -0,0 +1,101 @@
+/* Round 273 verification: Layout toggle inactive buttons hover-text
+ * now previews active text color (cyan-300), completing R163's
+ * "hover previews active state" pattern.
+ *
+ * Pre-R273 the inactive Ring/Grid buttons used:
+ *   text-gray-500 hover:text-gray-300 hover:bg-cyan-500/5 active:bg-cyan-500/15
+ *
+ * The bg part previewed the active cyan-500/15 ghost via cyan-500/5,
+ * but the text just brightened gray-500→gray-300. Half-preview:
+ * cyan ghost bg + gray text. Active state was cyan-500/15 bg + cyan-300
+ * text — so hovering inactive didn't visually preview the active text
+ * color.
+ *
+ * Post-R273:
+ *   text-gray-500 hover:text-cyan-300 hover:bg-cyan-500/5 active:bg-cyan-500/15
+ *
+ * Hover state now previews BOTH the active bg (cyan ghost) AND text
+ * (cyan-300). Bg /5 vs /15 still distinguishes hover-preview from
+ * active-real.
+ *
+ * Test scope:
+ *   1. Ring inactive button (default state has Ring active; toggle to
+ *      Grid first so Ring becomes inactive) classlist contains
+ *      'hover:text-cyan-300' and does NOT contain 'hover:text-gray-300'.
+ *   2. Grid inactive button (default state) classlist contains
+ *      'hover:text-cyan-300'.
+ *   3. R163 invariant: hover:bg-cyan-500/5 still present on inactive.
+ *   4. R272 freshness chip text starts with 'live · ' (regression).
+ */
+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'); } 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*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (r) => r.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-chrome-layout="ring"]', { timeout: 10000 });
+await page.waitForSelector('[data-topo-chrome-layout="grid"]', { timeout: 10000 });
+await page.waitForSelector('[data-freshness-chip]',            { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  // Default localStorage = ring is active, grid is inactive.
+  const ring = document.querySelector('[data-topo-chrome-layout="ring"]');
+  const grid = document.querySelector('[data-topo-chrome-layout="grid"]');
+  const freshness = document.querySelector('[data-freshness-chip]');
+  return {
+    ringClasses:    ring ? ring.className.toString() : null,
+    ringActive:     ring ? ring.getAttribute('data-topo-chrome-layout-active') : null,
+    gridClasses:    grid ? grid.className.toString() : null,
+    gridActive:     grid ? grid.getAttribute('data-topo-chrome-layout-active') : null,
+    freshnessText:  freshness ? freshness.textContent.trim() : null,
+  };
+});
+await browser.close();
+
+const has = (s, cls) => (s || '').includes(cls);
+
+// Ring is default-active (true). Grid is default-inactive (false).
+// Grid (inactive) should have hover:text-cyan-300.
+// Ring (active) uses 'bg-cyan-500/15 text-cyan-300 hover:bg-cyan-500/20 active:bg-cyan-500/25'
+//   — no hover:text-cyan-300 (it's already cyan-300 at rest) — UNCHANGED.
+
+const results = {
+  ring_is_active:                       probe.ringActive === 'true',
+  grid_is_inactive:                     probe.gridActive === 'false',
+  grid_inactive_has_hover_cyan_text:    has(probe.gridClasses, 'hover:text-cyan-300'),
+  grid_inactive_no_hover_gray_text:     !has(probe.gridClasses, 'hover:text-gray-300'),
+  grid_inactive_keeps_cyan_bg_hover:    has(probe.gridClasses, 'hover:bg-cyan-500/5'),
+  ring_active_has_cyan_text_base:       has(probe.ringClasses, 'text-cyan-300'),
+  r272_freshness_starts_with_live:      probe.freshnessText != null && probe.freshnessText.startsWith('live · '),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} layout hover text preview:`, JSON.stringify(results),
+  '\n  ring classes:', probe.ringClasses,
+  '\n  grid classes:', probe.gridClasses,
+  '\n  freshness:',    probe.freshnessText);
+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-border-unify-test.mjs

@@ -0,0 +1,104 @@
+/* Round 268 verification: Layout toggle border unified with chrome
+ * strip's theme-aware borderColor.
+ *
+ * Pre-R268 the Layout toggle's wrapper + Grid button's internal
+ * divider used hardcoded `border-gray-500/25` (Tailwind pale gray,
+ * fixed in both themes). The bottom-right chrome strip's analogous
+ * wrappers (nodeSize, zoom) used pal.containerBorder (cyber
+ * #2a2a4a dark indigo ↔ light #e3e6eb pale gray).
+ *
+ * Visible mismatch in cyber theme: Layout toggle border read as pale
+ * gray-500/25 (rgba 107,114,128,0.25) while chrome strip borders read
+ * as darker indigo `#2a2a4a` — two different border colors on
+ * visually-analogous segmented controls. R268 replaces the hardcoded
+ * class with inline pal.containerBorder + a border-color transition.
+ *
+ * Test scope:
+ *   1. Layout toggle wrapper rgb(border-color) matches nodeSize
+ *      wrapper rgb(border-color) — both use pal.containerBorder.
+ *   2. Layout toggle wrapper has border-color transition (200ms).
+ *   3. Grid button's left border color matches the wrapper's
+ *      border color.
+ *   4. R260 chip-row semantic gap intact: gap toggle→working ≥ 11.
+ *   5. R267 title-block leading-tight regression: kicker still has
+ *      the class.
+ */
+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'); } 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*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (r) => r.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-chrome-layout-trailer]',     { timeout: 10000 });
+await page.waitForSelector('[data-topo-chrome-fleet-group-trailer]', { timeout: 10000 });
+await page.waitForSelector('[data-topo-chrome-layout="grid"]',       { timeout: 10000 });
+await page.waitForSelector('[data-topo-section-kicker]',             { timeout: 10000 });
+await page.waitForSelector('[data-working-chip]',                    { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const layoutWrapper = document.querySelector('[data-topo-chrome-layout-trailer]');
+  const nodeSize     = document.querySelector('[data-topo-chrome-fleet-group-trailer]');
+  const gridButton   = document.querySelector('[data-topo-chrome-layout="grid"]');
+  const kicker       = document.querySelector('[data-topo-section-kicker]');
+  const working      = document.querySelector('[data-working-chip]');
+  const layoutStyle  = layoutWrapper ? window.getComputedStyle(layoutWrapper) : null;
+  const nodeSizeStyle = nodeSize     ? window.getComputedStyle(nodeSize)      : null;
+  const gridStyle    = gridButton    ? window.getComputedStyle(gridButton)    : null;
+  return {
+    layoutBorderColor:      layoutStyle  ? layoutStyle.borderTopColor : null,
+    layoutTransition:       layoutWrapper ? layoutWrapper.style.transition : null,
+    nodeSizeBorderColor:    nodeSizeStyle ? nodeSizeStyle.borderTopColor : null,
+    gridBorderLeftColor:    gridStyle    ? gridStyle.borderLeftColor   : null,
+    kickerHasLeadingTight:  kicker?.classList.contains('leading-tight') ?? false,
+    toggleRight:            layoutWrapper ? layoutWrapper.getBoundingClientRect().right : null,
+    workingLeft:            working ? working.getBoundingClientRect().left : null,
+  };
+});
+await browser.close();
+
+const has = (s, prop) => new RegExp(`${prop}\\s+(?:200ms|0\\.2s)`).test(s || '');
+const gapToggleToWorking = (probe.toggleRight != null && probe.workingLeft != null)
+  ? (probe.workingLeft - probe.toggleRight) : null;
+
+const results = {
+  layout_border_matches_nodesize:        probe.layoutBorderColor != null
+                                          && probe.layoutBorderColor === probe.nodeSizeBorderColor,
+  layout_has_border_color_transition:    has(probe.layoutTransition, 'border-color'),
+  grid_button_border_matches_wrapper:    probe.gridBorderLeftColor != null
+                                          && probe.gridBorderLeftColor === probe.layoutBorderColor,
+  r260_chip_row_gap_intact:              gapToggleToWorking != null && gapToggleToWorking >= 11,
+  r267_kicker_has_leading_tight:         probe.kickerHasLeadingTight,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} layout toggle border unify:`, JSON.stringify(results),
+  '\n  layout    borderTop:', probe.layoutBorderColor,
+  '\n  nodeSize  borderTop:', probe.nodeSizeBorderColor,
+  '\n  grid btn  borderLeft:', probe.gridBorderLeftColor,
+  '\n  layout transition:', probe.layoutTransition,
+  '\n  toggle→working gap:', gapToggleToWorking);
+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);