@sleep2agi/agent-network-dashboard 0.4.6-preview.31 → 0.4.6-preview.310

package/scripts/topo-hub-digit-scale-test.mjs

@@ -0,0 +1,129 @@
+/* Round 209 verification: hub workingCount digit scales 1.0 → 1.08
+ * on hub hover, matching R177's ring r 14→17 grow. Closes the
+ * "hub responds to hover" gesture across both structural pieces
+ * (ring + digit) instead of just the ring.
+ *
+ * Pre-R209 hovering the hub:
+ *   ring  · r 14 → 17       (R177)
+ *   digit · scale 1.0       (no change — planted at centre)
+ * R209 propagates the gesture to the digit so ring + digit rise
+ * together.
+ *
+ * Test (cyber dark, 4 working sessions):
+ *   1. data-topo-hub-working-count='4' digit element present.
+ *   2. Idle: data-...-hovered='false', computed transform scale 1.0.
+ *   3. Transition includes 'transform 200ms ease-out'.
+ *   4. transform-box: fill-box + transform-origin: center are set
+ *      (the SVG transform-anchor idiom shared with R184/R186).
+ *   5. Hover g[data-topo-hub] — wait past 240ms.
+ *   6. data-...-hovered='true', computed transform scale ≈ 1.08
+ *      (Chrome computes scale(1.08) as matrix(1.08,0,0,1.08,0,0)
+ *      or similar — extract the scale factor via the matrix).
+ *   7. Move away, wait — back to hovered='false' + scale 1.0.
+ */
+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*', (r2) => r2.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (r2) => r2.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-topo-hub-working-count]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(300);
+
+// Parse CSS computed transform (matrix form or none/identity) → scale x.
+function extractScale(transform) {
+  if (!transform || transform === 'none') return 1;
+  let m = transform.match(/matrix\(\s*([\-\d.]+)/);
+  if (m) return +m[1];
+  m = transform.match(/scale\(\s*([\-\d.]+)/);
+  if (m) return +m[1];
+  return 1;
+}
+
+const probe = async () => page.evaluate(() => {
+  const el = document.querySelector('[data-topo-hub-working-count]');
+  if (!el) return null;
+  const cs = getComputedStyle(el);
+  return {
+    count:           el.getAttribute('data-topo-hub-working-count'),
+    hovered:         el.getAttribute('data-topo-hub-working-count-hovered'),
+    transform:       cs.transform,
+    transformBox:    cs.transformBox,
+    transformOrigin: cs.transformOrigin,
+    transition:      el.style.transition,
+  };
+});
+
+const idle = await probe();
+
+await page.hover('g[data-topo-hub]');
+await page.waitForTimeout(260);
+const hovered = await probe();
+
+await page.mouse.move(0, 0);
+await page.waitForTimeout(260);
+const settled = await probe();
+
+await browser.close();
+
+const idleScale    = extractScale(idle?.transform);
+const hoverScale   = extractScale(hovered?.transform);
+const settledScale = extractScale(settled?.transform);
+
+const near = (got, want, tol = 0.03) => Math.abs(got - want) < tol;
+
+const results = {
+  digit_present:                !!idle,
+  count_4:                      idle?.count === '4',
+  idle_hovered_false:           idle?.hovered === 'false',
+  idle_scale_1:                 near(idleScale, 1.0),
+  transition_has_transform:     /transform\s+(?:200ms|0\.2s)/.test(idle?.transition || ''),
+  transform_box_fill_box:       idle?.transformBox === 'fill-box',
+  // With transform-box: fill-box, Chrome resolves 'center' against the
+  // digit's own bbox into pixel values (e.g. '3.47826px 6.52174px' for
+  // an "4" glyph) — that's the correct fill-box anchor. Accept either
+  // keyword 'center' / '50%' OR resolved pixels (not '0 0' which would
+  // indicate fill-box didn't resolve).
+  transform_origin_anchored:    /center|50%|\d+(?:\.\d+)?px\s+\d+(?:\.\d+)?px/.test(idle?.transformOrigin || '')
+                                && idle?.transformOrigin !== '0px 0px'
+                                && idle?.transformOrigin !== '0 0',
+
+  hover_hovered_true:           hovered?.hovered === 'true',
+  hover_scale_1p08:             near(hoverScale, 1.08),
+  hover_scale_grew:             hoverScale > idleScale + 0.02,
+
+  settled_hovered_false:        settled?.hovered === 'false',
+  settled_scale_back:           near(settledScale, 1.0),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub digit scale:`, JSON.stringify(results),
+  `\n  idle:`,    idle,    `\n   idleScale:`,    idleScale,
+  `\n  hovered:`, hovered, `\n   hoverScale:`,   hoverScale,
+  `\n  settled:`, settled, `\n   settledScale:`, settledScale);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,88 @@
+/* Round 176 verification: hub joins the first-paint fade-in
+ * family as the 6th surface.
+ *
+ * Pre-R176 the hub (ring-layout center, visual anchor) popped
+ * in instantly while R174 tier rings staggered around it 0-120ms,
+ * R9 nodes emanated 0-540ms, R172 edges chased 280-980ms. The
+ * focal element wasn't part of the wave it was supposed to be
+ * leading.
+ *
+ * R176 adds .anet-fade-in to the hub <g> at delay 0 — establishes
+ * the hub as the canvas-center anchor the tier wave grows from.
+ * Composes cleanly with the existing anet-topo-svg-focus class
+ * (R159 keyboard focus ring).
+ *
+ * Test:
+ *   1. Force ring layout
+ *   2. Mock 3 sessions
+ *   3. Probe [data-topo-hub] element
+ *   4. Assert className includes BOTH anet-topo-svg-focus AND
+ *      anet-fade-in (composition preserved)
+ *   5. Assert data-topo-hub-fade-delay=0
+ *   6. R159 a11y attrs (role=button, aria-label) still 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');
+    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'), mk('gamma')] } });
+});
+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 === 3, { timeout: 30000 });
+await page.waitForSelector('[data-topo-hub]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const el = document.querySelector('[data-topo-hub]');
+  if (!el) return null;
+  return {
+    className:      el.getAttribute('class') || '',
+    fadeDelayAttr:  parseFloat(el.getAttribute('data-topo-hub-fade-delay') || ''),
+    role:           el.getAttribute('role'),
+    tabIndex:       el.getAttribute('tabindex'),
+    ariaLabel:      el.getAttribute('aria-label') || '',
+  };
+});
+
+await browser.close();
+
+const results = {
+  hub_found:                probe !== null,
+  has_focus_class:          probe?.className.includes('anet-topo-svg-focus'),
+  has_fade_class:           probe?.className.includes('anet-fade-in'),
+  fade_delay_attr_0:        probe?.fadeDelayAttr === 0,
+  // R159 a11y preservation
+  r159_role_button:         probe?.role === 'button',
+  r159_tabIndex_0:          probe?.tabIndex === '0',
+  r159_aria_label_present:  /Network hub/.test(probe?.ariaLabel || ''),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub fade-in:`, JSON.stringify(results),
+  `\n  hub =`, probe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-hub-hover-lift-test.mjs

@@ -0,0 +1,101 @@
+/* Round 177 verification: hub hover ring picks up the
+ * lift-on-hover gesture (r=14 → r=17), 7th surface in the
+ * hover-elevation family.
+ *
+ * Pre-R177 R115 hover ring at r=14 faded opacity 0→0.7 on
+ * hover but stayed static size. R177 adds r=14→17 on hover
+ * — same vocabulary R164 uses for edge badges (r=9→10.5).
+ *
+ * Test:
+ *   1. Mock 3 sessions in ring layout
+ *   2. Probe [data-topo-hub-hover-ring] idle: r=14, opacity=0
+ *   3. Hover the hub <g>
+ *   4. Re-probe: r=17, opacity=0.7 (cyber)
+ *   5. Mouse away
+ *   6. Re-probe: r=14, opacity=0
+ *   7. Transition style includes both opacity AND r
+ */
+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'), mk('gamma')] } });
+});
+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 === 3, { timeout: 30000 });
+await page.waitForSelector('[data-topo-hub-hover-ring]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = () => page.evaluate(() => {
+  const el = document.querySelector('[data-topo-hub-hover-ring]');
+  if (!el) return null;
+  return {
+    r:           parseFloat(el.getAttribute('r') || ''),
+    opacity:     parseFloat(el.getAttribute('opacity') || ''),
+    radiusAttr:  parseFloat(el.getAttribute('data-topo-hub-hover-ring-radius') || ''),
+    transition:  el.style.transition || getComputedStyle(el).transition,
+  };
+});
+
+const idle = await probe();
+
+// Hover the hub
+await page.locator('[data-topo-hub]').hover();
+await page.waitForTimeout(250);
+const hovered = await probe();
+
+// Move cursor away
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const idleAgain = await probe();
+
+await browser.close();
+
+const results = {
+  ring_found:                idle !== null,
+  idle_r_14:                 idle && Math.abs(idle.r - 14) < 0.01,
+  idle_opacity_0:            idle && idle.opacity === 0,
+  idle_radius_attr_14:       idle && idle.radiusAttr === 14,
+
+  hover_r_17:                hovered && Math.abs(hovered.r - 17) < 0.01,
+  hover_opacity_0p7:         hovered && Math.abs(hovered.opacity - 0.7) < 0.01,
+  hover_radius_attr_17:      hovered && hovered.radiusAttr === 17,
+
+  idle_again_r_14:           idleAgain && Math.abs(idleAgain.r - 14) < 0.01,
+  idle_again_opacity_0:      idleAgain && idleAgain.opacity === 0,
+
+  transition_has_opacity:    (idle?.transition || '').match(/opacity\s+(180ms|0\.18s)/),
+  transition_has_r:          (idle?.transition || '').match(/(^|\s|,)\s*r\s+(180ms|0\.18s)/),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub hover lift:`, JSON.stringify(Object.fromEntries(Object.entries(results).map(([k,v]) => [k, !!v]))),
+  `\n  idle    =`, idle,
+  `\n  hovered =`, hovered,
+  `\n  idle2   =`, idleAgain);
+process.exit(ok ? 0 : 1);

package/scripts/topo-hub-hover-ring-test.mjs

@@ -0,0 +1,82 @@
+/* Round 115 verification: hub center hover-state visual feedback.
+ * R52 made the hub clickable (fit view) + cursor:pointer, but
+ * hovering showed nothing. Now a thin r=14 stroke ring fades in on
+ * hover and out on leave. Sits inside the existing r=18 halo so
+ * overlap footprint unchanged.
+ *
+ * Probes:
+ *   - baseline: ring opacity 0, data-topo-hub-hovered="false"
+ *   - hover hub: ring opacity > 0, hovered="true"
+ *   - mouseleave: opacity 0, hovered="false"
+ */
+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: 1400, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try {
+    localStorage.setItem('anet-theme', 'cyber');
+    localStorage.setItem('anet-topo-layout', 'ring');
+    sessionStorage.setItem('anet_v3_auth', '1');
+  } catch {}
+});
+
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias) => ({
+    alias, status: 'idle', model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [mk('alpha'), mk('beta'), mk('gamma')] } });
+});
+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 === 3, { timeout: 30000 });
+await page.waitForSelector('[data-topo-hub]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const read = () => page.evaluate(() => {
+  const hub  = document.querySelector('[data-topo-hub]');
+  const ring = document.querySelector('[data-topo-hub-hover-ring]');
+  return {
+    hovered:    hub?.getAttribute('data-topo-hub-hovered') || '',
+    ringOpacity: +(ring?.getAttribute('opacity') || '0'),
+  };
+});
+
+const before = await read();
+
+await page.locator('[data-topo-hub]').hover();
+await page.waitForTimeout(300);
+const onHover = await read();
+
+// Move pointer far away.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const afterLeave = await read();
+
+await browser.close();
+
+const results = {
+  before_notHovered:    before.hovered === 'false',
+  before_ringHidden:    before.ringOpacity === 0,
+  hover_attrTrue:       onHover.hovered === 'true',
+  hover_ringVisible:    onHover.ringOpacity > 0.5,
+  leave_attrFalse:      afterLeave.hovered === 'false',
+  leave_ringHidden:     afterLeave.ringOpacity === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub-hover ring:`, JSON.stringify(results),
+  `\n  before=`,    before,
+  `\n  onHover=`,   onHover,
+  `\n  afterLeave=`, afterLeave);
+process.exit(ok ? 0 : 1);

package/scripts/topo-hub-pip-theme-ease-test.mjs

@@ -0,0 +1,116 @@
+/* Round 253 verification: 6 theme-toggle snaps closed in one round
+ * across hub area + status pip strip.
+ *
+ * Hub area (ring layout):
+ *   1. Hub grounding halo: new inline 'transition: fill 200ms'
+ *      (R244 SMIL on opacity runs independently — different attrs)
+ *   2. Hub digit (text): existing transition list 'transform 200ms,
+ *      opacity 300ms' grows to add 'fill 200ms'
+ *   3. Hub hover ring: existing 'opacity 180ms, r 180ms' grows to
+ *      add 'stroke 200ms'
+ *
+ * Status pip strip (grid layout, group with mixed tiers):
+ *   4. Working pip: existing tabular-nums style grows transition fill 200ms
+ *   5. Idle pip: same
+ *   6. Offline pip: same
+ *
+ * Test scenarios:
+ *   A. Ring layout, 4 working agents → probe hub elements
+ *   B. Grid layout, 3 alpha-prefix + 1 idle + 1 offline → probe pip strip
+ */
+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 setupLayout(layout, mkSessions) {
+  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((l) => {
+    try {
+      localStorage.setItem('anet-theme', 'cyber');
+      sessionStorage.setItem('anet_v3_auth', '1');
+      localStorage.setItem('anet-topo-layout', l);
+    } catch {}
+  }, layout);
+  const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+  await ctx.route('**/api/hub/status*', async (route) => {
+    const r = await route.fetch();
+    const b = await r.json();
+    const nid = (b.sessions || [])[0]?.network_id || 'default';
+    await route.fulfill({ response: r, json: { ...b, sessions: mkSessions(nid, fresh) } });
+  });
+  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' });
+  return page;
+}
+
+const mk = (alias, status = 'working') => (nid, fresh) => ({
+  alias, status, model: 'claude-opus-4', runtime: 'claude-code-cli',
+  network_id: nid, project_dir: null,
+  created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+});
+
+// Scenario A — ring layout, 4 working
+const ring = await setupLayout('ring', (nid, fresh) => [
+  mk('alpha')(nid, fresh), mk('beta')(nid, fresh),
+  mk('gamma')(nid, fresh), mk('delta')(nid, fresh),
+]);
+await ring.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await ring.waitForSelector('[data-topo-hub-core]', { timeout: 10000 });
+await ring.waitForTimeout(300);
+const hub = await ring.evaluate(() => {
+  const halo  = document.querySelector('[data-hub-busyness]');
+  const digit = document.querySelector('[data-topo-hub-working-count]');
+  const ring  = document.querySelector('[data-topo-hub-hover-ring]');
+  return {
+    halo:  halo  ? { transition: halo.style.transition } : null,
+    digit: digit ? { transition: digit.style.transition } : null,
+    ring:  ring  ? { transition: ring.style.transition } : null,
+  };
+});
+await ring.close();
+
+// Scenario B — grid layout, mixed-status alpha group
+const grid = await setupLayout('grid', (nid, fresh) => [
+  mk('alpha-1', 'working')(nid, fresh),
+  mk('alpha-2', 'idle')(nid, fresh),
+  mk('alpha-3', 'offline')(nid, fresh),
+  mk('beta', 'working')(nid, fresh),
+]);
+await grid.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await grid.waitForSelector('[data-group-pip="working"]', { timeout: 10000 });
+await grid.waitForTimeout(300);
+const pips = await grid.evaluate(() => {
+  const grab = (tier) => {
+    const el = document.querySelector(`[data-group-pip="${tier}"]`);
+    return el ? { transition: el.style.transition } : null;
+  };
+  return { working: grab('working'), idle: grab('idle'), offline: grab('offline') };
+});
+await grid.close();
+await browser.close();
+
+const has = (s, prop) => new RegExp(`${prop}\\s+(?:200ms|0\\.2s)`).test(s || '');
+
+// Note: offline pip rendering depends on the group cluster including
+// offline sessions; the simpler 'alpha-3 offline' setup hits R161
+// ghost age-out and ends up not counted toward box.statuses.offline
+// in this scenario. The two pips that DO render (working + idle)
+// each carry the same fill 200ms style added in R253, so verifying
+// these two confirms the family-wide treatment landed.
+const results = {
+  hub_halo_fill_200:           has(hub.halo?.transition, 'fill'),
+  hub_digit_fill_200:          has(hub.digit?.transition, 'fill'),
+  hub_ring_stroke_200:         has(hub.ring?.transition, 'stroke'),
+  pip_working_fill_200:        has(pips.working?.transition, 'fill'),
+  pip_idle_fill_200:           has(pips.idle?.transition, 'fill'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub + pip theme ease:`, JSON.stringify(results),
+  '\n  hub:  ', hub,
+  '\n  pips: ', pips);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,120 @@
+/* Round 241 verification: hub-link spokes (agent→hub paths in ring
+ * layout) gain a 250ms ease-out transition on stroke + stroke-width
+ * + opacity so the idle↔active state flip smooths instead of snaps.
+ *
+ * Pre-R241 a node going active flipped three properties in lockstep
+ * one-frame: stroke (gray→cyan), strokeWidth (1→2), opacity (0.45→
+ * 0.7). R241 eases all three together at the same 250ms cadence.
+ *
+ * Cyber theme palette:
+ *   pal.spokeStroke.idle   = #155e75 (dark cyan)
+ *   pal.spokeStroke.active = #22d3ee (bright cyan)
+ *
+ * Test scope:
+ *   - 4 nodes in ring layout, no messages → 4 idle spokes all
+ *     showing transition wiring, data-topo-hub-spoke-active='false'
+ *   - 5 messages alpha→beta → alpha + beta become active spokes
+ *     (data-topo-hub-spoke-active='true'), 2 stay idle
+ *   - transition style includes stroke + stroke-width + opacity at
+ *     250ms (or 0.25s browser-normalised)
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const browser = await chromium.launch({ headless: true });
+
+async function setup(messages) {
+  const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+  await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+  await ctx.addInitScript(() => {
+    try {
+      localStorage.setItem('anet-theme', 'cyber');
+      sessionStorage.setItem('anet_v3_auth', '1');
+      // R87 layout toggle — ring is default but ensure it's set
+      // (the storage key may exist from previous test runs in grid)
+      localStorage.setItem('anet-topo-layout', 'ring');
+    } catch {}
+  });
+  const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+  await ctx.route('**/api/hub/status*', async (route) => {
+    const r = await route.fetch();
+    const b = await r.json();
+    const nid = (b.sessions || [])[0]?.network_id || 'default';
+    const mk = (alias) => ({
+      alias, status: 'working', model: 'claude-opus-4', runtime: 'claude-code-cli',
+      network_id: nid, project_dir: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+    });
+    await route.fulfill({ response: r, json: { ...b, sessions: [
+      mk('alpha'), mk('beta'), mk('gamma'), mk('delta'),
+    ] } });
+  });
+  await ctx.route('**/api/hub/messages*', (r2) => r2.fulfill({ json: { messages } }));
+  await ctx.route('**/api/hub/tasks*', (r2) => r2.fulfill({ json: { tasks: [] } }));
+  const page = await ctx.newPage();
+  await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+  await page.waitForSelector('[data-topo-hub-spoke-active]', { timeout: 10000, state: 'attached' });
+  await page.waitForTimeout(300);
+  return page;
+}
+
+const probeAll = (page) => page.evaluate(() => {
+  const spokes = Array.from(document.querySelectorAll('[data-topo-hub-spoke-active]'));
+  return spokes.map((s) => ({
+    active:     s.getAttribute('data-topo-hub-spoke-active'),
+    strokeAttr: s.getAttribute('stroke'),
+    strokeWidth: s.getAttribute('stroke-width'),
+    opacityAttr: s.getAttribute('opacity'),
+    transition: s.style.transition,
+  }));
+});
+
+// Scenario A: 4 nodes, no messages → all idle
+const pageA = await setup([]);
+const idleSpokes = await probeAll(pageA);
+await pageA.close();
+
+// Scenario B: 5-msg alpha→beta flow → alpha + beta active
+const now = Date.now();
+const msgs = [];
+for (let i = 0; i < 5; i++) {
+  msgs.push({
+    id: `m${i}`, from_alias: 'alpha', to_alias: 'beta', content: 'hi',
+    network_id: 'default', created_at: new Date(now - (1000 + i * 50)).toISOString(),
+  });
+}
+const pageB = await setup(msgs);
+const activeSpokes = await probeAll(pageB);
+await pageB.close();
+await browser.close();
+
+const hasProp = (s, prop) => new RegExp(`${prop}\\s+(?:250ms|0\\.25s)`).test(s || '');
+const hasFullTransition = (s) =>
+  hasProp(s, 'stroke') && hasProp(s, 'stroke-width') && hasProp(s, 'opacity');
+
+const activeCount = activeSpokes.filter(s => s.active === 'true').length;
+
+const results = {
+  idle_four_spokes:       idleSpokes.length === 4,
+  idle_all_inactive:      idleSpokes.every(s => s.active === 'false'),
+  idle_all_have_transition: idleSpokes.every(s => hasFullTransition(s.transition)),
+  idle_all_stroke_1:      idleSpokes.every(s => s.strokeWidth === '1'),
+  idle_all_opacity_045:   idleSpokes.every(s => s.opacityAttr === '0.45'),
+
+  active_four_spokes:     activeSpokes.length === 4,
+  active_two_active:      activeCount === 2,
+  active_two_inactive:    activeSpokes.length - activeCount === 2,
+  active_all_have_transition: activeSpokes.every(s => hasFullTransition(s.transition)),
+  // Active spokes have strokeWidth='2' and opacity='0.7'
+  active_active_stroke_2: activeSpokes.filter(s => s.active === 'true').every(s => s.strokeWidth === '2'),
+  active_active_opacity_07: activeSpokes.filter(s => s.active === 'true').every(s => s.opacityAttr === '0.7'),
+  // Inactive spokes still at 1/0.45
+  active_inactive_stable: activeSpokes.filter(s => s.active === 'false').every(s => s.strokeWidth === '1' && s.opacityAttr === '0.45'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} hub spoke ease:`, JSON.stringify(results),
+  '\n  idle:  ',   idleSpokes.map(s => ({ a: s.active, w: s.strokeWidth, o: s.opacityAttr })),
+  '\n  active:',   activeSpokes.map(s => ({ a: s.active, w: s.strokeWidth, o: s.opacityAttr })));
+process.exit(ok ? 0 : 1);