@sleep2agi/agent-network-dashboard 0.4.6-preview.39 → 0.4.6-preview.396

package/scripts/topo-freshness-chip-test.mjs

@@ -0,0 +1,74 @@
+/* Round 46 verification: live · Ns freshness chip.
+ *  - renders in the topology header with initial "live · 0s" or "live · 1s"
+ *  - ticks up over time (>= 2s after a 2.5s wait)
+ *  - resets near 0 when SWR delivers a new sessions payload (we trigger
+ *    this by mutating the mocked /api/hub/status response — SWR's 5s
+ *    refresh re-fetches and the chip should re-zero)
+ *  - turns amber when stale (>10s since last sync; verified by blocking
+ *    the second poll and waiting >12s) */
+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: 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 {}
+});
+
+let pollCount = 0;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+await ctx.route('**/api/hub/status*', async (route) => {
+  pollCount++;
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const sessions = [
+    { alias: `a${pollCount}`, status: 'idle', network_id: nid, project_dir: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'b', 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('[data-freshness-chip]', { timeout: 30000 });
+
+const readChip = () => page.evaluate(() => {
+  const el = document.querySelector('[data-freshness-chip]');
+  if (!el) return null;
+  return {
+    text: (el.textContent || '').trim(),
+    isAmber: /amber|warning/i.test(el.className) || el.className.includes('amber'),
+  };
+});
+
+const initial = await readChip();
+await page.waitForTimeout(2500);
+const afterTick = await readChip();
+
+// SWR refreshes every 5s — wait past one cycle and confirm the chip re-zeros.
+// Initial chip might be 1s, after 2.5s should be 3s. After a ~5s sync,
+// should drop to 0-1s.
+await page.waitForTimeout(3500);
+const afterSync = await readChip();
+
+await browser.close();
+const seconds = (s) => +(s.text.match(/(\d+)s/)?.[1] ?? -1);
+const results = {
+  initialNearZero: initial !== null && seconds(initial) <= 2,
+  tickedUpAfter25s: afterTick !== null && seconds(afterTick) >= 2 && seconds(afterTick) <= 4,
+  reZeroedAfterSync: afterSync !== null && seconds(afterSync) <= 2,
+  pollsHappened: pollCount >= 2,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} freshness chip:`, JSON.stringify(results),
+  `\n  initial=${JSON.stringify(initial)}\n  afterTick=${JSON.stringify(afterTick)}\n  afterSync=${JSON.stringify(afterSync)} polls=${pollCount}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-freshness-chip-transition-test.mjs

@@ -0,0 +1,80 @@
+/* Round 187 verification: FreshnessChip color transition.
+ *
+ * Pre-R187 the chip swapped between fresh (gray) and stale
+ * (amber) Tailwind classes — bg/text/border snapped every
+ * time the >10s boundary was crossed. R187 adds
+ * transition-colors duration-300 so the palette eases
+ * smoothly through the stale-onset and recovery.
+ *
+ * Test:
+ *   1. Mount: data-freshness-chip-stale='false' (just synced)
+ *   2. className includes transition-colors + duration-300
+ *   3. className includes gray fresh palette
+ *   4. computed transition string includes background-color,
+ *      border-*, color properties
+ */
+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: '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-freshness-chip]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const chip = document.querySelector('[data-freshness-chip]');
+  if (!chip) return null;
+  const computed = getComputedStyle(chip);
+  return {
+    staleAttr:    chip.getAttribute('data-freshness-chip-stale'),
+    className:    chip.getAttribute('class') || '',
+    transition:   computed.transitionProperty + ' / ' + computed.transitionDuration,
+    text:         chip.textContent,
+  };
+});
+
+await browser.close();
+
+const results = {
+  chip_found:                probe !== null,
+  initial_stale_false:       probe?.staleAttr === 'false',
+  has_transition_colors:     probe?.className.includes('transition-colors'),
+  has_duration_300:          probe?.className.includes('duration-300'),
+  has_fresh_palette_bg:      probe?.className.includes('bg-gray-500/10'),
+  has_fresh_palette_text:    probe?.className.includes('text-gray-400'),
+  has_fresh_palette_border:  probe?.className.includes('border-gray-500/20'),
+  no_stale_palette:          !probe?.className.includes('bg-amber-500/10'),
+  transition_covers_bg:      (probe?.transition || '').includes('background-color'),
+  transition_covers_border:  (probe?.transition || '').includes('border'),
+  transition_covers_color:   (probe?.transition || '').match(/(^|[\s,/])color\b/),
+  text_shows_live:           /^live ·/.test(probe?.text || ''),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} freshness chip transition:`, JSON.stringify(Object.fromEntries(Object.entries(results).map(([k,v]) => [k, !!v]))),
+  `\n  probe:`, probe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-freshness-chip-weight-test.mjs

@@ -0,0 +1,90 @@
+/* Round 315 verification: FreshnessChip (R275 conditional warning
+ * chip, renders only when stale > 10s) joins the R313-R314 chip-row
+ * data-weight family with font-medium. Sibling parity — when it
+ * appears, it sits next to working/online/active-links/vendor chips
+ * which all carry font-medium (500) per R313/R314.
+ *
+ * Test trap: chip is conditionally rendered. We need to mock the
+ * SWR delivery path to keep sessions stable for >10s — easiest way
+ * is to inject the chip's stale state by waiting in test. Below we
+ * load the page and wait 12s to surface the chip.
+ *
+ * Contract:
+ *   - [data-freshness-chip] eventually appears with stale=true.
+ *   - Its className includes 'font-medium' + 'font-mono'.
+ *   - Computed font-weight === 500.
+ *   - R314 vendor chip + R313 main chip + R294 pulse all preserved.
+ */
+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();
+// Lock the status response so SWR re-fetches return the same
+// session reference; the chip detects staleness by the absence of
+// payload-reference change for >10s. We achieve this by serving
+// a static body repeatedly.
+let status = null;
+await ctx.route('**/api/hub/status*', async (route) => {
+  if (!status) {
+    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,
+    });
+    status = { ...b, sessions: [
+      mk('alpha', 'claude-opus-4'),
+      mk('beta',  'gpt-4o'),
+    ] };
+  }
+  await route.fulfill({ json: status });
+});
+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' });
+// FreshnessChip stale gate is sec > 10. Wait 12s to ensure stale.
+await page.waitForTimeout(12500);
+await page.waitForSelector('[data-freshness-chip]', { timeout: 5000 });
+
+const probe = await page.evaluate(() => {
+  const sel = (s) => document.querySelector(s);
+  const chip = sel('[data-freshness-chip]');
+  return {
+    chipPresent:  chip !== null,
+    chipCls:      chip?.className ?? '',
+    chipFw:       chip ? getComputedStyle(chip).fontWeight : null,
+    chipText:     chip?.textContent?.trim() ?? null,
+    chipStale:    chip?.getAttribute('data-freshness-chip-stale') ?? null,
+    vendorChipCls: sel('[data-vendor-letter]')?.className ?? '',
+    workingChipCls: sel('[data-working-chip]')?.className ?? '',
+    recentCountFw:  sel('[data-recent-panel-count]')?.getAttribute('font-weight') ?? null,
+    pulseCount:     document.querySelectorAll('[data-pulse-wrapper]').length,
+  };
+});
+await browser.close();
+
+const results = {
+  freshness_chip_present:      probe.chipPresent,
+  freshness_chip_stale:        probe.chipStale === 'true',
+  freshness_chip_has_medium:   probe.chipCls.includes('font-medium'),
+  freshness_chip_has_mono:     probe.chipCls.includes('font-mono'),
+  freshness_chip_fw_500:       String(probe.chipFw) === '500',
+  r313_working_chip_kept:      probe.workingChipCls.includes('font-medium'),
+  r311_recent_count_fw_600:    probe.recentCountFw === '600',
+  r294_pulse_absent:           probe.pulseCount === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} freshness chip weight:`, JSON.stringify(results),
+  '\n  chip text:', JSON.stringify(probe.chipText), 'fw=', probe.chipFw);
+process.exit(ok ? 0 : 1);

package/scripts/topo-freshness-conditional-render-test.mjs

@@ -0,0 +1,92 @@
+/* Round 275 verification: FreshnessChip converts from always-render
+ * to conditional render (only when stale) — chip-row simplification
+ * per Vincent 5214/5215-5217 visual audit ask ("乱" cleanup for
+ * Twitter screenshot).
+ *
+ * Pre-R275 the chip ALWAYS rendered:
+ *   fresh: gray  + "live · {sec}s"   (always-present "I'm fine" chip)
+ *   stale: amber + "lag · {sec}s"    (R272 prefix swap)
+ *
+ * Post-R275:
+ *   fresh: chip absent (null)
+ *   stale: amber + "lag · {sec}s"    (warning indicator only)
+ *
+ * Net effect: chip-row at rest has 1 fewer chip — cleaner Twitter
+ * screenshot, less right-edge chrome. Stale state still alerts via
+ * conditional appearance (amber "lag" warning chip).
+ *
+ * R272 prefix-swap intent (live↔lag) still in code; only the lag side
+ * is rendered now. Fresh state implicitly relies on other liveness
+ * signals (recent-signal panel rows, edge animations, count updates).
+ *
+ * Test scope:
+ *   1. At fresh state (default page load, 0s elapsed), chip element
+ *      is NOT present in DOM. R275 simplification verified.
+ *   2. R273 Layout toggle Grid inactive has hover:text-cyan-300
+ *      (regression).
+ *   3. R274 legend per-row count has tabular-nums (regression).
+ *   4. Source code regression: FreshnessChip body still contains the
+ *      "lag" / "live" ternary — verified by reading the bundled JS
+ *      isn't worth the effort; trust the source diff + this fresh-
+ *      absence test as proof R275 applied.
+ */
+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="grid"]',          { timeout: 10000 });
+await page.waitForSelector('[data-legend-count="working"]',             { timeout: 10000 });
+// Give the page time to settle so FreshnessChip mount cycle is stable.
+// Note: we are NOT waiting for [data-freshness-chip] — that selector
+// should NOT match in fresh state (chip absent). Use a short fixed
+// wait instead.
+await page.waitForTimeout(500);
+
+const probe = await page.evaluate(() => {
+  const freshnessChip = document.querySelector('[data-freshness-chip]');
+  const grid          = document.querySelector('[data-topo-chrome-layout="grid"]');
+  const legendCount   = document.querySelector('[data-legend-count="working"]');
+  return {
+    chipPresentAtFresh: freshnessChip !== null,
+    gridClasses:        grid ? grid.className.toString() : null,
+    legendCountFVN:     legendCount ? window.getComputedStyle(legendCount).fontVariantNumeric : null,
+  };
+});
+await browser.close();
+
+const results = {
+  chip_absent_at_fresh:             probe.chipPresentAtFresh === false,
+  r273_grid_has_cyan_hover_text:    (probe.gridClasses || '').includes('hover:text-cyan-300'),
+  r274_legend_count_tabular:        probe.legendCountFVN != null && probe.legendCountFVN.includes('tabular-nums'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} freshness conditional render:`, JSON.stringify(results),
+  '\n  chip present at fresh:', probe.chipPresentAtFresh, '(expected: false)',
+  '\n  legend count FVN:',      probe.legendCountFVN);
+process.exit(ok ? 0 : 1);

package/scripts/topo-fullscreen-active-test.mjs

@@ -0,0 +1,115 @@
+/* Round 178 verification: fullscreen chrome button picks up the
+ * active-state visual indicator R163 introduced for layout toggle.
+ *
+ * Pre-R178 the button changed icon when isFullscreen flipped but
+ * background + foreground stayed unchanged. R178 adds:
+ *   active:   bg-cyan-500/15 text-cyan-300 hover:bg-cyan-500/20
+ *   inactive: hover:bg-white/5 + palette-driven inline bg/color
+ *
+ * Mirrors R163 Ring/Grid pattern.
+ *
+ * Test:
+ *   1. Probe inactive state (default — not in fullscreen):
+ *        data-topo-chrome-fullscreen-active='false'
+ *        className does NOT include 'bg-cyan-500/15'
+ *        className includes 'hover:bg-white/5'
+ *        inline style.background is set (from palette)
+ *   2. Fake fullscreen state via dispatching fullscreenchange
+ *      with mocked document.fullscreenElement, then re-probe:
+ *        data-topo-chrome-fullscreen-active='true'
+ *        className includes 'bg-cyan-500/15' + 'text-cyan-300'
+ *        className DOES NOT include 'hover:bg-white/5'
+ *        inline style.background is unset (Tailwind wins)
+ */
+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: '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-chrome-fullscreen]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = () => page.evaluate(() => {
+  const btn = document.querySelector('[data-topo-chrome-fullscreen]');
+  if (!btn) return null;
+  return {
+    activeAttr:        btn.getAttribute('data-topo-chrome-fullscreen-active'),
+    className:         btn.getAttribute('class') || '',
+    inlineBg:          btn.style.background || '',
+    inlineColor:       btn.style.color || '',
+    ariaLabel:         btn.getAttribute('aria-label'),
+  };
+});
+
+const inactive = await probe();
+
+// Fake fullscreen state: define document.fullscreenElement to point at
+// the container, then dispatch fullscreenchange. The listener at
+// TopoGraph.tsx line ~1125 calls
+//   setIsFullscreen(document.fullscreenElement === containerRef.current)
+// We can find the container via the chrome's parent (the chrome <div>
+// sits inside the container <div ref={containerRef}>).
+await page.evaluate(() => {
+  const chrome = document.querySelector('[data-topo-chrome]');
+  const container = chrome?.parentElement;
+  if (!container) throw new Error('container not found');
+  Object.defineProperty(document, 'fullscreenElement', {
+    configurable: true,
+    get: () => container,
+  });
+  document.dispatchEvent(new Event('fullscreenchange'));
+});
+await page.waitForTimeout(250);
+const active = await probe();
+
+await browser.close();
+
+const results = {
+  // Inactive defaults
+  inactive_attr_false:         inactive.activeAttr === 'false',
+  inactive_no_cyan_bg_class:   !inactive.className.includes('bg-cyan-500/15'),
+  inactive_has_white_hover:    inactive.className.includes('hover:bg-white/5'),
+  inactive_inline_bg_set:      inactive.inlineBg !== '',
+  inactive_inline_color_set:   inactive.inlineColor !== '',
+  inactive_aria_label_enter:   /Enter fullscreen/.test(inactive.ariaLabel || ''),
+
+  // Active state (after faking fullscreenchange)
+  active_attr_true:            active.activeAttr === 'true',
+  active_has_cyan_bg_class:    active.className.includes('bg-cyan-500/15'),
+  active_has_cyan_text_class:  active.className.includes('text-cyan-300'),
+  active_has_cyan_hover_class: active.className.includes('hover:bg-cyan-500/20'),
+  active_no_white_hover:       !active.className.includes('hover:bg-white/5'),
+  active_inline_bg_empty:      active.inlineBg === '',
+  active_inline_color_empty:   active.inlineColor === '',
+  active_aria_label_exit:      /Exit fullscreen/.test(active.ariaLabel || ''),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} fullscreen active state:`, JSON.stringify(results),
+  `\n  inactive =`, inactive,
+  `\n  active   =`, active);
+process.exit(ok ? 0 : 1);

package/scripts/topo-group-box-pinned-state-test.mjs

@@ -0,0 +1,95 @@
+/* Round 68 verification: group-box rect has a 3-tier visual ladder:
+ *  idle    → strokeWidth 1.5, dashed, ringStroke colour
+ *  hovered → strokeWidth 2,   solid, legendAccent colour
+ *  pinned  → strokeWidth 3,   solid, legendAccent colour (stronger)
+ *
+ * Plus `data-group-box-pinned` reflects the pinned state so external
+ * tooling can spot a pinned box without inspecting computed CSS.
+ */
+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: 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', '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: 'alpha1', status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'alpha2', status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'alpha3', status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'beta1',  status: 'idle', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'beta2',  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 === 5, { timeout: 30000 });
+await page.waitForTimeout(600);
+
+const readAlphaBox = () => page.evaluate(() => {
+  // Find the alpha group <g data-group="alpha"> and read its <rect>.
+  const g = document.querySelector('g[data-group="alpha"]');
+  if (!g) return null;
+  const rect = g.querySelector('rect');
+  if (!rect) return null;
+  return {
+    strokeWidth:    rect.getAttribute('stroke-width'),
+    stroke:         rect.getAttribute('stroke'),
+    dashArray:      rect.getAttribute('stroke-dasharray'),
+    fillOpacity:    rect.getAttribute('fill-opacity'),
+    pinnedAttr:     rect.getAttribute('data-group-box-pinned'),
+  };
+});
+
+const idle = await readAlphaBox();
+
+// Hover a member of alpha (alpha1) → group becomes hovered.
+await page.locator('g[data-node="alpha1"]').hover();
+await page.waitForTimeout(300);
+const hovered = await readAlphaBox();
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+
+// Pin alpha via group label click.
+await page.locator('g[data-group-label-hit="alpha"]').first().click({ force: true });
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const pinned = await readAlphaBox();
+
+await browser.close();
+
+const results = {
+  idle_stroke15:        idle && idle.strokeWidth === '1.5',
+  idle_dashed:          idle && (idle.dashArray || '').startsWith('6'),
+  idle_pinnedFalse:     idle && idle.pinnedAttr === 'false',
+  hovered_stroke2:      hovered && hovered.strokeWidth === '2',
+  hovered_solid:        hovered && (hovered.dashArray === 'none' || hovered.dashArray === null),
+  hovered_pinnedFalse:  hovered && hovered.pinnedAttr === 'false',
+  pinned_stroke3:       pinned && pinned.strokeWidth === '3',
+  pinned_solid:         pinned && (pinned.dashArray === 'none' || pinned.dashArray === null),
+  pinned_pinnedTrue:    pinned && pinned.pinnedAttr === 'true',
+  pinned_strongerFill:  pinned && hovered && parseFloat(pinned.fillOpacity) > parseFloat(hovered.fillOpacity),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group-box pinned state:`, JSON.stringify(results),
+  `\n  idle=`,    idle,
+  `\n  hovered=`, hovered,
+  `\n  pinned=`,  pinned);
+process.exit(ok ? 0 : 1);

package/scripts/topo-group-count-test.mjs

@@ -53,8 +53,13 @@ const labels = await page.$$eval('svg[viewBox="0 0 1000 680"] g[data-group]', el
 await browser.close();
 const a = labels.find(l => l.key === 'A站');
 const b = labels.find(l => l.key === 'B站');
+// R58 appended status-mix pips inside the same <text>, and SVG textContent
+// concatenates tspans without preserving the visual `dx` gaps — so what
+// renders as "A站 · 4  4w" surfaces as the string "A站· 44w". The R19
+// count chip is still the second tspan; verify by matching "Group·" then
+// the count, allowing any trailing pip text.
 const results = {
-  bothGroupsHaveChip: a?.full === 'A站· 4' && b?.full === 'B站· 2',
+  bothGroupsHaveChip: /^A站·\s*4/.test(a?.full || '') && /^B站·\s*2/.test(b?.full || ''),
   chipSmallerFont: a?.chipFontSize === 11,
   chipLighterWeight: a?.chipFontWeight === '400',
 };