@sleep2agi/agent-network-dashboard 0.4.6-preview.32 → 0.4.6-preview.320

package/scripts/topo-minimap-dot-transition-test.mjs

@@ -0,0 +1,113 @@
+/* Round 198 verification: minimap node dots get smooth opacity /
+ * fill / r transitions so a session flipping working→idle or going
+ * offline doesn't snap on the minimap mirror.
+ *
+ * Pre-R198 the canvas itself eased status changes (R167 stroke-width
+ * transition, R10 freshness alpha ramp, R3 fade-in chain), but the
+ * minimap below kept snap-cut. R198 brings the minimap dots in
+ * rhythm with the main canvas at 200ms.
+ *
+ * The minimap only mounts when isDefaultView=false (zoomed or panned),
+ * so the test must trigger a zoom-in first to populate it.
+ *
+ * Test:
+ *   Mock 3 working + 1 offline session. Default view → no minimap.
+ *   Click zoom-in → minimap mounts.
+ *   Probe each minimap dot:
+ *     1. 4 dots present with data-topo-minimap-dot=<alias>
+ *     2. Online dots: r=1.7, opacity=0.9, data-...-online='true'
+ *     3. Offline dot: r=1.2, opacity=0.5, data-...-online='false'
+ *     4. Every dot's style.transition includes 'opacity 200ms',
+ *        'fill 200ms', and 'r 200ms'
+ */
+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, 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',   'working'),
+    mk('delta',   'offline'),
+  ] } });
+});
+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-chrome-zoom-in]', { timeout: 10000 });
+await page.waitForTimeout(300);
+
+// Default view → minimap not mounted
+const minimapBeforeZoom = await page.evaluate(() =>
+  document.querySelector('[data-topo-minimap]') !== null);
+
+// Trigger zoom-in to mount the minimap
+await page.click('[data-topo-chrome-zoom-in]');
+await page.waitForTimeout(450);  // past 280ms smoothView crossfade + margin
+await page.waitForSelector('[data-topo-minimap-dot]', { timeout: 5000 });
+await page.waitForTimeout(200);
+
+const minimapAfterZoom = await page.evaluate(() =>
+  document.querySelector('[data-topo-minimap]') !== null);
+
+const dots = await page.evaluate(() =>
+  [...document.querySelectorAll('[data-topo-minimap-dot]')].map(el => ({
+    alias:      el.getAttribute('data-topo-minimap-dot'),
+    online:     el.getAttribute('data-topo-minimap-dot-online'),
+    r:          parseFloat(el.getAttribute('r') || ''),
+    opacity:    parseFloat(el.getAttribute('opacity') || ''),
+    fill:       el.getAttribute('fill'),
+    transition: el.style.transition,
+  })));
+
+await browser.close();
+
+const onlineDots  = dots.filter(d => d.online === 'true');
+const offlineDots = dots.filter(d => d.online === 'false');
+
+const trans = (s) => s || '';
+const hasOpacityT = (d) => /opacity\s+(0\.2s|200ms)/.test(trans(d.transition));
+const hasFillT    = (d) => /fill\s+(0\.2s|200ms)/.test(trans(d.transition));
+const hasRT       = (d) => /\br\s+(0\.2s|200ms)/.test(trans(d.transition));
+
+const results = {
+  minimap_hidden_at_default:  minimapBeforeZoom === false,
+  minimap_shown_after_zoom:   minimapAfterZoom === true,
+  four_dots_present:          dots.length === 4,
+  three_online:               onlineDots.length === 3,
+  one_offline:                offlineDots.length === 1,
+  online_r_1p7:               onlineDots.every(d => Math.abs(d.r - 1.7) < 0.01),
+  online_opacity_0p9:         onlineDots.every(d => Math.abs(d.opacity - 0.9) < 0.01),
+  offline_r_1p2:              offlineDots.every(d => Math.abs(d.r - 1.2) < 0.01),
+  offline_opacity_0p5:        offlineDots.every(d => Math.abs(d.opacity - 0.5) < 0.01),
+  all_have_opacity_transition: dots.every(hasOpacityT),
+  all_have_fill_transition:    dots.every(hasFillT),
+  all_have_r_transition:       dots.every(hasRT),
+  online_fill_truthy:          onlineDots.every(d => d.fill && d.fill !== 'none'),
+  offline_fill_truthy:         offlineDots.every(d => d.fill && d.fill !== 'none'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} minimap dot transition:`, JSON.stringify(results),
+  `\n  dots:`, dots);
+process.exit(ok ? 0 : 1);

package/scripts/topo-minimap-rect-stroke-test.mjs

@@ -0,0 +1,94 @@
+/* Round 287 verification: minimap viewport rect strokeWidth bumps
+ * 1 → 1.5. The rect frames the user's current view in the minimap —
+ * it IS the wayfinding "you are here" indicator. Bumping the stroke
+ * by half a pixel (same micro-polish family as R283 monogram stroke)
+ * lifts the boundary above ambient minimap-dot density without
+ * crowding the miniaturised dots inside.
+ *
+ * The minimap is only rendered when view ≠ default (zoomed or
+ * panned). Test simulates a zoom to surface the minimap.
+ *
+ * Contract:
+ *   - [data-topo-minimap-viewport] exists after zoom.
+ *   - Its stroke-width attribute === "1.5".
+ *   - data-topo-minimap-dot still rendered (≥1 dot regression).
+ *   - R283 monogram stroke + R282 watermark intact (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, 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'),
+    mk('gamma', 'claude-sonnet-4'),
+    mk('delta', null),
+  ] } });
+});
+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-brand-watermark]', { timeout: 10000 });
+
+// Trigger zoom-in to surface the minimap. The zoom-in button is the
+// '+' control inside the chrome strip.
+await page.click('[data-topo-chrome-zoom-in]');
+await page.click('[data-topo-chrome-zoom-in]');
+await page.waitForSelector('[data-topo-minimap-viewport]', { timeout: 5000 });
+await page.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const rect = document.querySelector('[data-topo-minimap-viewport]');
+  const dots = document.querySelectorAll('[data-topo-minimap-dot]');
+  const watermark = document.querySelector('[data-topo-brand-watermark]');
+  const alphaNode = document.querySelector('g[data-node="alpha"]');
+  const alphaCircles = alphaNode ? [...alphaNode.querySelectorAll('circle')] : [];
+  const alphaAvatarCircle = alphaCircles
+    .map(c => ({ r: +c.getAttribute('r') || 0, sw: c.getAttribute('stroke-width'), isBadge: c.hasAttribute('data-runtime-badge') }))
+    .filter(c => c.r > 0 && c.r < 18 && !c.isBadge)
+    .sort((a, b) => b.r - a.r)[0];
+  return {
+    rectPresent:       rect !== null,
+    rectStrokeWidth:   rect?.getAttribute('stroke-width') ?? null,
+    rectOpacity:       rect?.getAttribute('opacity') ?? null,
+    dotCount:          dots.length,
+    alphaAvatarStroke: alphaAvatarCircle?.sw ?? null,
+    watermarkPresent:  watermark !== null,
+  };
+});
+await browser.close();
+
+const results = {
+  minimap_rect_present:           probe.rectPresent,
+  minimap_rect_stroke_is_1_5:     probe.rectStrokeWidth === '1.5',
+  minimap_rect_opacity_kept:      probe.rectOpacity === '0.9',
+  minimap_has_dots:               probe.dotCount >= 1,
+  r283_monogram_stroke_kept:      probe.alphaAvatarStroke === '1.5',
+  r282_watermark_present:         probe.watermarkPresent,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} minimap rect stroke:`, JSON.stringify(results),
+  '\n  rect strokeWidth:', probe.rectStrokeWidth,
+  '\n  rect opacity:', probe.rectOpacity,
+  '\n  dot count:', probe.dotCount,
+  '\n  alpha avatar (R283):', probe.alphaAvatarStroke);
+process.exit(ok ? 0 : 1);

package/scripts/topo-minimap-test.mjs

@@ -0,0 +1,68 @@
+/* Round 30 verification: minimap.
+ *  - not mounted at default view (1×, centered)
+ *  - mounted when zoomed in (one node dot per session, viewport rect)
+ *  - click recenters the canvas (view.x / view.y change) */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1280, height: 1600 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try {
+    localStorage.setItem('anet-theme', 'cyber');
+    localStorage.setItem('anet-topo-layout', 'grid');
+    localStorage.setItem('anet-topo-view', JSON.stringify({ zoom: 1, x: 0, y: 0 }));
+    sessionStorage.setItem('anet_v3_auth', '1');
+  } catch {}
+});
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const sessions = ['A站', 'B站', 'C站', 'D站', 'E站', 'F站'].flatMap(g =>
+    Array.from({ length: 3 }, (_, i) => ({
+      alias: `${g}${i + 1}`, status: 'idle', network_id: nid, project_dir: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+    })),
+  );
+  await route.fulfill({ response: r, json: { ...b, sessions } });
+});
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForSelector('svg[viewBox="0 0 1000 680"]', { timeout: 30000 });
+await page.waitForTimeout(500);
+
+const minimap = '[data-topo-minimap]';
+const notMountedAtDefault = (await page.locator(minimap).count()) === 0;
+
+// Zoom in via `+` twice → view changes → minimap mounts
+await page.keyboard.press('=');
+await page.keyboard.press('=');
+await page.waitForTimeout(200);
+const mountedAfterZoom = (await page.locator(minimap).count()) === 1;
+const dotCount = await page.locator(`${minimap} svg circle`).count();
+const hasViewportRect = await page.locator(`${minimap} svg rect`).count() > 0;
+
+// Click on the minimap's far left → expect view.x to become more positive (canvas pans right)
+const beforeView = await page.evaluate(() => JSON.parse(localStorage.getItem('anet-topo-view')));
+const mmBox = await page.locator(minimap).boundingBox();
+await page.mouse.click(mmBox.x + 10, mmBox.y + mmBox.height / 2);
+await page.waitForTimeout(200);
+const afterView = await page.evaluate(() => JSON.parse(localStorage.getItem('anet-topo-view')));
+const clickRecenters = afterView.x !== beforeView.x || afterView.y !== beforeView.y;
+
+await browser.close();
+const results = {
+  notMountedAtDefault,
+  mountedAfterZoom,
+  oneDotPerSession: dotCount === 18, // 6 groups × 3 = 18 nodes
+  viewportRectPresent: hasViewportRect,
+  clickRecenters,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} minimap:`, JSON.stringify(results), `dots=${dotCount} view before=`, beforeView, `after=`, afterView);
+process.exit(ok ? 0 : 1);

package/scripts/topo-minimap-viewport-smooth-test.mjs

@@ -0,0 +1,124 @@
+/* Round 199 verification: minimap viewport rect transitions x/y/w/h
+ * during R169 smoothView (discrete zoom +/− and reset). Closes the
+ * rhythm-mismatch R198 just fixed for minimap dots — now extended to
+ * the rectangle that frames them.
+ *
+ * Pre-R199 a click on zoom-in crossfaded the main canvas over R168's
+ * 280ms but the minimap viewport rect snap-cut to its new dimensions
+ * in one frame. R199 gates a `transition: x/y/w/h 280ms` on
+ * smoothView=true so discrete zooms ease the rect smoothly. Drag-pan
+ * and wheel-zoom (smoothView=false) keep snappy response — a
+ * persistent transition during drag would lag the cursor by 280ms.
+ *
+ * Test:
+ *   1. Open page with 4 sessions, zoom in once to mount minimap.
+ *   2. Idle (smoothView=false): rect has
+ *      data-topo-minimap-viewport-smooth='false', style.transition='none'.
+ *   3. Click zoom-in again → smoothView arms to 'true' for ~350ms.
+ *   4. Within 100ms of click: probe rect →
+ *      data-topo-minimap-viewport-smooth='true', style.transition
+ *      includes 'x 280ms', 'y 280ms', 'width 280ms', 'height 280ms'.
+ *   5. Wait past 400ms → smoothView clears → back to 'false', no
+ *      transition.
+ */
+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'), mk('delta'),
+  ] } });
+});
+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-chrome-zoom-in]', { timeout: 10000 });
+await page.waitForTimeout(300);
+
+// First zoom-in mounts the minimap. Wait past the 350ms smoothView
+// timer so the minimap rect is at idle state (smooth='false') before
+// we probe.
+await page.click('[data-topo-chrome-zoom-in]');
+await page.waitForTimeout(450);
+await page.waitForSelector('[data-topo-minimap-viewport]', { timeout: 5000 });
+
+const probe = async () => page.evaluate(() => {
+  const el = document.querySelector('[data-topo-minimap-viewport]');
+  if (!el) return null;
+  return {
+    smooth:     el.getAttribute('data-topo-minimap-viewport-smooth'),
+    transition: el.style.transition,
+    x:          parseFloat(el.getAttribute('x') || ''),
+    y:          parseFloat(el.getAttribute('y') || ''),
+    w:          parseFloat(el.getAttribute('width')  || ''),
+    h:          parseFloat(el.getAttribute('height') || ''),
+  };
+});
+
+const idle = await probe();
+
+// Click zoom-in once more — arms smoothView for ~350ms — and probe
+// within the arming window.
+await page.click('[data-topo-chrome-zoom-in]');
+await page.waitForTimeout(80);  // well inside the 350ms arming window
+const armed = await probe();
+
+await page.waitForTimeout(420);  // past 350ms timer + transition
+const settled = await probe();
+
+await browser.close();
+
+const hasAllAxes = (s) =>
+  /\bx\s+(?:280ms|0\.28s)/.test(s || '') &&
+  /\by\s+(?:280ms|0\.28s)/.test(s || '') &&
+  /\bwidth\s+(?:280ms|0\.28s)/.test(s || '') &&
+  /\bheight\s+(?:280ms|0\.28s)/.test(s || '');
+
+const results = {
+  idle_smooth_false:           idle?.smooth === 'false',
+  idle_transition_none:        idle?.transition === 'none' || idle?.transition === '',
+  idle_has_dimensions:         idle && Number.isFinite(idle.x) && Number.isFinite(idle.w) && idle.w > 0,
+
+  armed_smooth_true:           armed?.smooth === 'true',
+  armed_transition_present:    !!armed?.transition && armed.transition !== 'none',
+  armed_transition_has_all:    hasAllAxes(armed?.transition),
+
+  settled_smooth_false:        settled?.smooth === 'false',
+  settled_transition_none:     settled?.transition === 'none' || settled?.transition === '',
+
+  // R199 actually changed dimensions between idle (zoom 120%) and
+  // settled (zoom 144% after second click), or x/y diverged.
+  zoom_changed_dimensions:     idle && settled && (
+    Math.abs(idle.w - settled.w) > 1 ||
+    Math.abs(idle.h - settled.h) > 1 ||
+    Math.abs(idle.x - settled.x) > 1 ||
+    Math.abs(idle.y - settled.y) > 1
+  ),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} minimap viewport smooth:`, JSON.stringify(results),
+  `\n  idle:`,    idle,
+  `\n  armed:`,   armed,
+  `\n  settled:`, settled);
+process.exit(ok ? 0 : 1);

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-monogram-font-test.mjs

@@ -0,0 +1,112 @@
+/* Round 284 verification: known-vendor monogram letter fontFamily
+ * swaps monospace → system sans-serif. Continuation of R283 Vincent
+ * 5216 vendor avatar polish arc.
+ *
+ * Contract:
+ *   - Known vendor (Anthropic, OpenAI, …) monogram letter — rendered
+ *     fontFamily resolves into a sans-serif stack (NOT monospace).
+ *     The actual computed font-family will likely return the OS-
+ *     preferred match such as -apple-system / Segoe UI / Inter / etc.
+ *     (We assert it does NOT include 'monospace' as the active stack.)
+ *   - data-monogram-letter attribute present on the <text> element
+ *     with the vendor.initial as its value.
+ *   - Prefix-group fallback (unknown vendor) keeps monospace — the
+ *     R283 contrast pattern: designed glyph = known, code text =
+ *     unknown.
+ *   - R283 monogram stroke=1.5 still in place (regression).
+ *   - R282 watermark still present (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, 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'),    // Anthropic → monogram (sans-serif)
+    mk('beta',  'gpt-4o'),            // OpenAI → monogram (sans-serif)
+    mk('gamma', null),                 // unknown → prefix-group (monospace)
+    mk('delta', null),                 // unknown
+  ] } });
+});
+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-monogram-letter]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  // All monogram letters carry data-monogram-letter; expect 2 (alpha + beta).
+  const monos = [...document.querySelectorAll('[data-monogram-letter]')];
+  const monoSamples = monos.map((t) => ({
+    letter:    t.getAttribute('data-monogram-letter'),
+    family:    getComputedStyle(t).fontFamily,
+    weight:    getComputedStyle(t).fontWeight,
+    parentAlias: t.closest('g[data-node]')?.getAttribute('data-node') ?? null,
+  }));
+  // Find prefix-group fallback text — inside g[data-node='gamma'], the
+  // <text> WITHOUT data-monogram-letter attribute (the prefix-group one).
+  const gammaNode = document.querySelector('g[data-node="gamma"]');
+  const gammaTexts = gammaNode ? [...gammaNode.querySelectorAll('text')] : [];
+  // The avatar text is the one inside the avatar IIFE — look for the
+  // text whose font-size matches avatar radius (~10-14) and is centered
+  // on the node. Easiest heuristic: text-anchor=middle, no data-monogram
+  // attr (so it's the unknown-vendor branch).
+  const prefixText = gammaTexts.find((t) =>
+    t.getAttribute('text-anchor') === 'middle' &&
+    !t.hasAttribute('data-monogram-letter')
+  );
+  const prefixFamily = prefixText ? getComputedStyle(prefixText).fontFamily : null;
+  // Also probe alpha monogram circle stroke (R283 regression).
+  const alphaNode = document.querySelector('g[data-node="alpha"]');
+  const alphaCircles = alphaNode ? [...alphaNode.querySelectorAll('circle')] : [];
+  const alphaAvatarCircle = alphaCircles
+    .map(c => ({ r: +c.getAttribute('r') || 0, sw: c.getAttribute('stroke-width'), isBadge: c.hasAttribute('data-runtime-badge') }))
+    .filter(c => c.r > 0 && c.r < 18 && !c.isBadge)
+    .sort((a, b) => b.r - a.r)[0];
+  const watermark = document.querySelector('[data-topo-brand-watermark]');
+  return {
+    monoSamples,
+    prefixFamily,
+    alphaAvatarStroke: alphaAvatarCircle?.sw ?? null,
+    watermarkPresent: watermark !== null,
+  };
+});
+await browser.close();
+
+const isMonospace = (s) => /(^|,)\s*monospace\s*(,|$)|"monospace"/i.test(s || '');
+const isSansSerif = (s) => /(sans-serif|system|Inter|Segoe|Helvetica|Arial|-apple-system|BlinkMac)/i.test(s || '');
+
+const results = {
+  two_monograms:                   probe.monoSamples.length === 2,
+  alpha_letter_A:                  probe.monoSamples.some(s => s.parentAlias === 'alpha' && s.letter === 'A'),
+  beta_letter_O:                   probe.monoSamples.some(s => s.parentAlias === 'beta'  && s.letter === 'O'),
+  all_monos_sans_serif:            probe.monoSamples.every(s => isSansSerif(s.family) && !isMonospace(s.family)),
+  prefix_group_keeps_monospace:    isMonospace(probe.prefixFamily),
+  r283_monogram_stroke_1_5_kept:   probe.alphaAvatarStroke === '1.5',
+  r282_watermark_present:          probe.watermarkPresent,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} monogram font swap:`, JSON.stringify(results),
+  '\n  alpha mono family:', probe.monoSamples.find(s => s.parentAlias === 'alpha')?.family,
+  '\n  beta  mono family:', probe.monoSamples.find(s => s.parentAlias === 'beta')?.family,
+  '\n  gamma prefix family:', probe.prefixFamily,
+  '\n  alpha avatar circle stroke (R283):', probe.alphaAvatarStroke);
+process.exit(ok ? 0 : 1);