@sleep2agi/agent-network-dashboard 0.4.6-preview.18 → 0.4.6-preview.180

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

@@ -0,0 +1,103 @@
+/* Round 47 verification: mobile chip collapse.
+ *  - At narrow viewport (375px), pressure / vendor-dist / active-links /
+ *    freshness chips are display:none; only essential chips render.
+ *  - At sm+ (≥640px), the full chip row is visible.
+ *  - Essential chips (Ring/Grid toggle + working + online) render at both. */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const browser = await chromium.launch({ headless: true });
+
+async function probe(width) {
+  const ctx = await browser.newContext({ viewport: { width, height: 900 } });
+  await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+  await ctx.addInitScript(() => {
+    try {
+      localStorage.setItem('anet-theme', 'cyber');
+      localStorage.setItem('anet-topo-layout', 'grid');
+      sessionStorage.setItem('anet_v3_auth', '1');
+    } catch {}
+  });
+  const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+  await ctx.route('**/api/hub/status*', async (route) => {
+    const r = await route.fetch();
+    const b = await r.json();
+    const nid = (b.sessions || [])[0]?.network_id || 'default';
+    const sessions = [
+      { alias: 'wkr', status: 'working', network_id: nid, project_dir: null,
+        model: 'claude-opus-4', runtime: 'cli-claude-code',
+        created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+      { alias: 'idl', status: 'idle', network_id: nid, project_dir: null,
+        model: 'gpt-5', runtime: 'codex-cli',
+        created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    ];
+    await route.fulfill({ response: r, json: { ...b, sessions } });
+  });
+  await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [
+    { from_alias: 'wkr', to_alias: 'idl', content: 'm', created_at: new Date().toISOString() },
+  ] } }));
+  await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+  const page = await ctx.newPage();
+  await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+  // The Overview page auto-hides the topology when window.innerWidth < 1024
+  // (the lg breakpoint). On narrow viewports the user clicks "Show
+  // Topology" to surface it; mimic that here so the chip-row tests reach
+  // the actual code path. Wait for SWR to deliver sessions first so the
+  // button renders before we look for it.
+  await page.waitForTimeout(1500);
+  const showBtn = page.locator('button', { hasText: /Show Topology/i });
+  if (await showBtn.count() > 0) await showBtn.first().click();
+  await page.waitForSelector('svg[viewBox="0 0 1000 680"]', { timeout: 30000 });
+  await page.waitForTimeout(600);
+  const visible = (sel) => page.evaluate(s => {
+    const el = document.querySelector(s);
+    if (!el) return null;
+    const r = el.getBoundingClientRect();
+    return r.width > 0 && r.height > 0;
+  }, sel);
+  const result = {
+    workingChipVisible: await page.evaluate(() => {
+      // "{N} working" chip — find the green-tinted one
+      const spans = [...document.querySelectorAll('span')];
+      const chip = spans.find(s => /^\d+ working$/.test((s.textContent || '').trim()));
+      if (!chip) return false;
+      const r = chip.getBoundingClientRect();
+      return r.width > 0 && r.height > 0;
+    }),
+    onlineChipVisible: await page.evaluate(() => {
+      const spans = [...document.querySelectorAll('span')];
+      const chip = spans.find(s => /^\d+ online$/.test((s.textContent || '').trim()));
+      if (!chip) return false;
+      const r = chip.getBoundingClientRect();
+      return r.width > 0 && r.height > 0;
+    }),
+    pressureVisible: await visible('[data-fleet-pressure]'),
+    activeLinksVisible: await page.evaluate(() => {
+      const spans = [...document.querySelectorAll('span')];
+      const chip = spans.find(s => /active link/.test(s.textContent || ''));
+      if (!chip) return false;
+      const r = chip.getBoundingClientRect();
+      return r.width > 0 && r.height > 0;
+    }),
+    freshnessVisible: await visible('[data-freshness-chip]'),
+  };
+  await ctx.close();
+  return result;
+}
+
+const mobile = await probe(375);
+const desktop = await probe(900);
+await browser.close();
+
+const results = {
+  mobileEssentialsVisible: mobile.workingChipVisible && mobile.onlineChipVisible,
+  mobilePressureHidden: mobile.pressureVisible === false,
+  mobileActiveLinksHidden: mobile.activeLinksVisible === false,
+  mobileFreshnessHidden: mobile.freshnessVisible === false,
+  desktopAllVisible: desktop.workingChipVisible && desktop.onlineChipVisible && desktop.pressureVisible && desktop.activeLinksVisible && desktop.freshnessVisible,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} mobile chips:`, JSON.stringify(results),
+  `\n  mobile=`, mobile, `\n  desktop=`, desktop);
+process.exit(ok ? 0 : 1);

package/scripts/topo-node-a11y-test.mjs

@@ -0,0 +1,107 @@
+/* Round 151 verification: node <g> gains a11y compliance.
+ *
+ * Node clickable for chat since R45, but tab-unreachable +
+ * screen-reader-unannounced. R151 matches the pattern R116 /
+ * R139 / R140 / R148 / R149 applied to other interactive
+ * surfaces:
+ *   role="button"
+ *   tabIndex={0}
+ *   aria-label="Chat with {alias} ({status})"
+ *   aria-pressed={chatAlias === session.alias}
+ *   onKeyDown(Enter / Space) → setChatAlias
+ *
+ * Three checks:
+ *   1. All nodes carry role=button, tabIndex=0, aria-label, aria-
+ *      pressed=false by default
+ *   2. Pressing Enter on a focused node opens chat (aria-pressed
+ *      flips to true, chat popover renders)
+ *   3. Pressing Space on a different node moves the open chat
+ *      target — only one aria-pressed=true at a time
+ */
+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'); 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, status) => ({
+    alias, status, 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', 'working'), mk('beta', 'idle'), mk('gamma', 'working'),
+  ] } });
+});
+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.waitForTimeout(400);
+
+const inspectAll = () => page.evaluate(() => {
+  const nodes = [...document.querySelectorAll('g[data-node]')];
+  return nodes.map(n => ({
+    alias:    n.getAttribute('data-node'),
+    role:     n.getAttribute('role'),
+    tabIndex: n.getAttribute('tabindex'),
+    ariaLabel: n.getAttribute('aria-label'),
+    ariaPressed: n.getAttribute('aria-pressed'),
+  }));
+});
+
+const before = await inspectAll();
+
+// Focus alpha node and press Enter → opens chat
+await page.locator('g[data-node="alpha"]').focus();
+await page.keyboard.press('Enter');
+await page.waitForTimeout(250);
+const afterAlpha = await inspectAll();
+const popoverPresentA = await page.locator('.anet-chat-popover, [data-chat-popover]').count() > 0
+                       || await page.evaluate(() => !!document.querySelector('[role="dialog"]'));
+
+// Focus gamma node and press Space → moves chat target (only one pressed)
+await page.locator('g[data-node="gamma"]').focus();
+await page.keyboard.press(' ');
+await page.waitForTimeout(250);
+const afterGamma = await inspectAll();
+
+await browser.close();
+
+const results = {
+  // Baseline shape
+  threeNodes:         before.length === 3,
+  allRoleButton:      before.every(n => n.role === 'button'),
+  allTabIndex0:       before.every(n => n.tabIndex === '0'),
+  allAriaLabel:       before.every(n => /^Chat with /.test(n.ariaLabel || '')),
+  allAriaPressedFalse: before.every(n => n.ariaPressed === 'false'),
+
+  // After Enter on alpha
+  enterOpensChat:     afterAlpha.find(n => n.alias === 'alpha')?.ariaPressed === 'true',
+  popoverShown:       popoverPresentA,
+  othersStillFalse:   afterAlpha.filter(n => n.alias !== 'alpha').every(n => n.ariaPressed === 'false'),
+
+  // After Space on gamma (chat target moved)
+  spaceMovesTarget:   afterGamma.find(n => n.alias === 'gamma')?.ariaPressed === 'true',
+  alphaUnpressed:     afterGamma.find(n => n.alias === 'alpha')?.ariaPressed === 'false',
+  onlyOnePressed:     afterGamma.filter(n => n.ariaPressed === 'true').length === 1,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} node a11y:`, JSON.stringify(results),
+  `\n  before=`, before,
+  `\n  afterAlpha=`, afterAlpha,
+  `\n  afterGamma=`, afterGamma);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,85 @@
+/* Round 51 verification: hovered node <g> lifts -2px via CSS transform.
+ *  - At rest, every node's CSS transform is "none" (or matrix with 0 ty).
+ *  - On hover, the hovered <g> reports `translateY(-2px)` (matrix(1,0,0,1,0,-2))
+ *    via getComputedStyle.transform, while siblings stay at identity.
+ *  - Release: returns to identity.
+ *  - With prefers-reduced-motion forced, NO lift even on hover.
+ */
+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(reducedMotion) {
+  const ctx = await browser.newContext({
+    viewport: { width: 1280, height: 900 },
+    reducedMotion: reducedMotion ? 'reduce' : 'no-preference',
+  });
+  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 sessions = ['alpha', 'beta', 'gamma'].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/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.waitForTimeout(500);
+
+  const readTy = (alias) => page.evaluate(a => {
+    const el = document.querySelector(`g[data-node="${a}"]`);
+    if (!el) return null;
+    const m = getComputedStyle(el).transform;
+    if (!m || m === 'none') return 0;
+    // matrix(a, b, c, d, tx, ty) — extract ty
+    const parts = m.match(/matrix\(([^)]+)\)/);
+    if (!parts) return null;
+    const arr = parts[1].split(',').map(s => parseFloat(s.trim()));
+    return arr[5] ?? null;
+  }, alias);
+
+  const restAlpha = await readTy('alpha');
+  const restBeta = await readTy('beta');
+  await page.locator('g[data-node="alpha"]').hover({ force: true });
+  await page.waitForTimeout(300);
+  const hoveredAlpha = await readTy('alpha');
+  const hoveredBeta  = await readTy('beta');
+  await page.mouse.move(10, 10);
+  await page.waitForTimeout(300);
+  const releasedAlpha = await readTy('alpha');
+
+  await ctx.close();
+  return { restAlpha, restBeta, hoveredAlpha, hoveredBeta, releasedAlpha };
+}
+
+const normal = await probe(false);
+const reduced = await probe(true);
+await browser.close();
+
+const results = {
+  normal_restAtZero: normal.restAlpha === 0 && normal.restBeta === 0,
+  normal_hoveredLifts: normal.hoveredAlpha === -2,
+  normal_siblingStays: normal.hoveredBeta === 0,
+  normal_released: normal.releasedAlpha === 0,
+  reduced_noLift: reduced.hoveredAlpha === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} node hover lift:`, JSON.stringify(results),
+  `\n  normal=`, normal, `\n  reduced=`, reduced);
+process.exit(ok ? 0 : 1);

package/scripts/topo-node-stroke-transition-test.mjs

@@ -0,0 +1,103 @@
+/* Round 167 verification: node status-ring picks up stroke-width
+ * transition.
+ *
+ * Pre-R167 the node outer ring (cx,cy,r,fill,stroke + binary
+ * stroke-width 3/1.5 + dasharray) had transition-[fill,stroke]
+ * duration-300 — colors transitioned but stroke-width snapped
+ * when a session went working → offline. R167 adds stroke-width
+ * to the transition list (300ms ease-out), symmetric with R165
+ * (pressure-bar width) and R166 (edge stroke-width).
+ *
+ * Test:
+ *   1. Mock 2 working + 2 offline sessions
+ *   2. Probe each node's status ring (via data-node-status-ring)
+ *   3. Working ring: strokeWidth=3, transition includes
+ *      'stroke-width 300ms'
+ *   4. Offline ring: strokeWidth=1.5, dasharray='5 5',
+ *      transition includes 'stroke-width 300ms'
+ *   5. Both rings expose data-node-status-ring with the status
+ *      label
+ *
+ * The DOM attribute reflects the React-rendered value, not the
+ * CSS-interpolated value during transitions — so the R51
+ * overlap-test's stroke-width=3 / 1.5 selectors still match.
+ */
+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();
+const stale = new Date(Date.now() - 10 * 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, status, last) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: last, updated_at: last, last_seen_at: last,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('w1', 'working', fresh), mk('w2', 'working', fresh),
+    mk('o1', 'offline', stale), mk('o2', 'offline', stale),
+  ] } });
+});
+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-node-status-ring]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const rings = [...document.querySelectorAll('[data-node-status-ring]')];
+  return rings.map(r => ({
+    label:       r.getAttribute('data-node-status-ring'),
+    strokeWidth: parseFloat(r.getAttribute('stroke-width')),
+    dasharray:   r.getAttribute('stroke-dasharray'),
+    inlineTransition: r.style.transition || '',
+    computedTransition: getComputedStyle(r).transition || '',
+  }));
+});
+
+await browser.close();
+
+const working = probe.filter(p => p.label === 'working');
+const offline = probe.filter(p => p.label === 'offline');
+
+const allHaveStrokeWidth = probe.every(p =>
+  p.inlineTransition.includes('stroke-width 300ms') ||
+  /stroke-width\s+0\.3s|stroke-width\s+300ms/.test(p.computedTransition));
+const allHaveFill = probe.every(p =>
+  p.inlineTransition.includes('fill 300ms') ||
+  /fill\s+0\.3s|fill\s+300ms/.test(p.computedTransition));
+const allHaveStroke = probe.every(p =>
+  p.inlineTransition.includes('stroke 300ms') ||
+  /[^-]stroke\s+0\.3s|[^-]stroke\s+300ms/.test(p.computedTransition));
+
+const results = {
+  four_rings_found:       probe.length === 4,
+  two_working_rings:      working.length === 2,
+  two_offline_rings:      offline.length === 2,
+  working_strokeWidth_3:  working.every(p => p.strokeWidth === 3),
+  offline_strokeWidth_15: offline.every(p => p.strokeWidth === 1.5),
+  working_no_dasharray:   working.every(p => p.dasharray === 'none' || !p.dasharray),
+  offline_dasharray_5_5:  offline.every(p => p.dasharray === '5 5'),
+  all_have_stroke_width_transition: allHaveStrokeWidth,
+  all_have_fill_transition:         allHaveFill,
+  all_have_stroke_transition:       allHaveStroke,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} node status-ring transition:`, JSON.stringify(results),
+  `\n  rings=`, probe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-node-title-peers-test.mjs

@@ -0,0 +1,107 @@
+/* Round 147 verification: node tooltip extends R98's flow summary
+ * with the actual sender / receiver alias breakdown. The R97 idiom
+ * — anywhere the UI shows "N" should hover-explain WHICH N — was
+ * applied to filter pills, group labels, vendor letters, pressure
+ * segments, recent-row, active-links chip. The node title was the
+ * last surface showing only aggregate counts ("12 in / 5 out");
+ * R147 adds peer lines.
+ *
+ * Fleet:
+ *   alpha — sends 3 msgs to beta, 5 to gamma, 2 to delta
+ *   beta  — sends 4 msgs to alpha, 1 to gamma
+ *   gamma — quiet (receiver only)
+ *   delta — quiet (receiver only)
+ *
+ * For alpha:
+ *   flowOut = 3 + 5 + 2 = 10
+ *   flowIn  = 4 (from beta)
+ *   senders ← beta (4)
+ *   receivers → beta (3), gamma (5), delta (2) — sorted by count desc:
+ *               gamma (5), beta (3), delta (2)
+ *
+ * Title should contain:
+ *   "flows: 4 in / 10 out"
+ *   "← from: beta (4)"
+ *   "→ to:   gamma (5), beta (3), delta (2)"  (sorted desc by count)
+ *
+ * Also verify a node with no flows (gamma will have 5 inbound from alpha
+ * and 1 from beta; let's pick delta which only has 2 inbound from alpha).
+ */
+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'); 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, status) => ({
+    alias, status, 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', 'working'), mk('beta', 'working'),
+    mk('gamma', 'idle'),    mk('delta', 'idle'),
+  ] } });
+});
+
+const now = Date.now();
+const mkMsg = (id, from, to, ageMs) => ({
+  id, from_alias: from, to_alias: to, content: 'hi',
+  network_id: 'default', created_at: new Date(now - ageMs).toISOString(),
+});
+const msgs = [];
+let id = 0;
+// alpha → beta (3), gamma (5), delta (2)
+for (let i = 0; i < 3; i++) msgs.push(mkMsg(`m${id++}`, 'alpha', 'beta',  10000 + id * 100));
+for (let i = 0; i < 5; i++) msgs.push(mkMsg(`m${id++}`, 'alpha', 'gamma', 10000 + id * 100));
+for (let i = 0; i < 2; i++) msgs.push(mkMsg(`m${id++}`, 'alpha', 'delta', 10000 + id * 100));
+// beta → alpha (4), gamma (1)
+for (let i = 0; i < 4; i++) msgs.push(mkMsg(`m${id++}`, 'beta',  'alpha', 10000 + id * 100));
+for (let i = 0; i < 1; i++) msgs.push(mkMsg(`m${id++}`, 'beta',  'gamma', 10000 + id * 100));
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: msgs } }));
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const readTitle = (alias) => page.evaluate((a) => {
+  const node = document.querySelector(`g[data-node="${a}"]`);
+  return node?.querySelector('title')?.textContent || '';
+}, alias);
+
+const alphaTitle = await readTitle('alpha');
+const deltaTitle = await readTitle('delta');
+
+await browser.close();
+
+const results = {
+  // alpha: flows aggregate
+  alpha_flowSummary:  alphaTitle.includes('flows: 4 in / 10 out'),
+  // alpha: senders line
+  alpha_sendersLine:  alphaTitle.includes('← from: beta (4)'),
+  // alpha: receivers line — must be sorted desc by count (gamma 5, beta 3, delta 2)
+  alpha_receiversOrder: alphaTitle.includes('→ to:   gamma (5), beta (3), delta (2)'),
+
+  // delta: receiver only, only inbound from alpha (2 msgs)
+  delta_flowSummary:  deltaTitle.includes('flows: 2 in / 0 out'),
+  delta_sendersLine:  deltaTitle.includes('← from: alpha (2)'),
+  delta_noReceivers:  !deltaTitle.includes('→ to:'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} node title peers:`, JSON.stringify(results),
+  `\n  alpha title:\n${alphaTitle}`,
+  `\n  delta title:\n${deltaTitle}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-node-title-test.mjs

@@ -0,0 +1,101 @@
+/* Round 98 verification: node <title> tooltips now include status,
+ * group membership (when applicable), and per-node flow counts
+ * (inbound/outbound) alongside the existing identity/cwd/last-seen
+ * lines. Same info-density spirit as R97 pill tooltips — hover any
+ * node and the answer is right there.
+ *
+ * Fleet:
+ *   - alpha1 (working, claude) + alpha2 (idle, claude) → alpha group of 2
+ *   - solo (working, gpt-5) — no group (singleton)
+ *   - off1 (offline, claude) — has last_seen_at older
+ *
+ * Flows:
+ *   alpha1 → solo × 3
+ *   solo → alpha1 × 1
+ *   ⇒ alpha1: 1 in / 3 out; solo: 3 in / 1 out; alpha2/off1: no flows
+ */
+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'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+const stale = new Date(Date.now() - 20 * 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, status, model, ts) => ({
+    alias, status, model, runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: ts, updated_at: ts, last_seen_at: ts,
+  });
+  const sessions = [
+    mk('alpha1', 'working', 'claude-opus-4', fresh),
+    mk('alpha2', 'idle',    'claude-opus-4', fresh),
+    mk('solo',   'working', 'gpt-5',         fresh),
+    mk('off1',   'offline', 'claude-opus-4', stale),
+  ];
+  await route.fulfill({ response: r, json: { ...b, sessions } });
+});
+
+const now = Date.now();
+const mkMsg = (id, from_alias, to_alias, ageMs) => ({
+  id, from_alias, to_alias, content: 'hi', network_id: 'default',
+  created_at: new Date(now - ageMs).toISOString(),
+});
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [
+  mkMsg('m1', 'alpha1', 'solo', 30 * 1000),
+  mkMsg('m2', 'alpha1', 'solo', 60 * 1000),
+  mkMsg('m3', 'alpha1', 'solo', 90 * 1000),
+  mkMsg('m4', 'solo', 'alpha1', 45 * 1000),
+] } }));
+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(400);
+
+const titles = await page.evaluate(() => {
+  const out = {};
+  for (const alias of ['alpha1', 'alpha2', 'solo', 'off1']) {
+    const g = document.querySelector(`g[data-node="${alias}"]`);
+    out[alias] = g?.querySelector('title')?.textContent || '';
+  }
+  return out;
+});
+
+await browser.close();
+
+const results = {
+  // Status line is the heading.
+  alpha1_statusHeading:  /^alpha1 · working/m.test(titles.alpha1),
+  alpha2_statusHeading:  /^alpha2 · idle/m.test(titles.alpha2),
+  solo_statusHeading:    /^solo · working/m.test(titles.solo),
+  off1_statusHeading:    /^off1 · offline/m.test(titles.off1),
+  // Group line only on multi-member band.
+  alpha1_groupShown:     /group: alpha · 2/.test(titles.alpha1),
+  alpha2_groupShown:     /group: alpha · 2/.test(titles.alpha2),
+  solo_groupSkipped:    !/group:/.test(titles.solo),
+  // Flow counts on participating nodes only.
+  alpha1_flowsCorrect:   /flows: 1 in \/ 3 out/.test(titles.alpha1),
+  solo_flowsCorrect:     /flows: 3 in \/ 1 out/.test(titles.solo),
+  alpha2_noFlows:       !/flows:/.test(titles.alpha2),
+  off1_lastSeen:         /last seen:/.test(titles.off1),
+  // Identity line still present.
+  alpha1_hasIdentity:    /claude/i.test(titles.alpha1),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} node titles:`, JSON.stringify(results),
+  `\n  alpha1:\n${titles.alpha1}`,
+  `\n  alpha2:\n${titles.alpha2}`,
+  `\n  solo:\n${titles.solo}`,
+  `\n  off1:\n${titles.off1}`);
+process.exit(ok ? 0 : 1);