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

package/scripts/topo-tabular-nums-sweep-test.mjs

@@ -0,0 +1,93 @@
+/* Round 225 verification: info-density tabular-nums sweep across
+ * the three remaining digit-bearing texts in the TopoGraph after
+ * R224's edge badge:
+ *   1) Hub center digit       (data-topo-hub-working-count)
+ *   2) Recent panel header    (data-recent-panel-count tspan)
+ *   3) Recent row count       (data-recent-row-count tspan)
+ *
+ * Pre-R225 each suffered the same monospace-digit jitter at the
+ * 9 → 10 boundary (the digit-vs-control glyph width variance is
+ * non-zero even in mono fonts; textAnchor='middle' or trailing
+ * text columns visibly shift on the boundary).
+ *
+ * Verification: getComputedStyle().fontVariantNumeric contains
+ * 'tabular-nums' on each of the three. Single populated scenario
+ * (4 working agents + 12-msg hot flow) drives all three at once.
+ */
+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'),
+  ] } });
+});
+const now = Date.now();
+const msgs = [];
+for (let i = 0; i < 12; 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(),
+  });
+}
+await ctx.route('**/api/hub/messages*', (r2) => r2.fulfill({ json: { messages: msgs } }));
+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-recent-row-count]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(400);
+
+const out = await page.evaluate(() => {
+  const fvn = (el) => el ? getComputedStyle(el).fontVariantNumeric : null;
+  const text = (el) => el?.textContent?.trim() || null;
+  const hubDigit  = document.querySelector('[data-topo-hub-working-count]');
+  const panelCnt  = document.querySelector('[data-recent-panel-count]');
+  const rowCnt    = document.querySelector('[data-recent-row-count]');
+  return {
+    hub:   { found: !!hubDigit, fvn: fvn(hubDigit),  text: text(hubDigit),
+             working: hubDigit?.getAttribute('data-topo-hub-working-count') },
+    panel: { found: !!panelCnt, fvn: fvn(panelCnt),  text: text(panelCnt) },
+    row:   { found: !!rowCnt,   fvn: fvn(rowCnt),    text: text(rowCnt) },
+  };
+});
+await browser.close();
+
+const hasTab = (s) => /tabular-nums/.test(s || '');
+const results = {
+  hub_found:         out.hub.found,
+  hub_tabular:       hasTab(out.hub.fvn),
+  hub_text_present:  /^\d+$/.test(out.hub.text || ''),
+  hub_text_equals_4: out.hub.text === '4',
+
+  panel_found:       out.panel.found,
+  panel_tabular:     hasTab(out.panel.fvn),
+  panel_text_flows:  /^\d+\s+flows?$/.test(out.panel.text || ''),
+
+  row_found:         out.row.found,
+  row_tabular:       hasTab(out.row.fvn),
+  row_text_equals_12: out.row.text === '12',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} tabular-nums sweep:`, JSON.stringify(results),
+  '\n  hub:  ', out.hub,
+  '\n  panel:', out.panel,
+  '\n  row:  ', out.row);
+process.exit(ok ? 0 : 1);

package/scripts/topo-tier-guide-dashes-test.mjs

@@ -0,0 +1,86 @@
+/* Round 303 verification: tier guide ring strokeDasharray tightens
+ * from "2 8" → "2 6". Same 2px dash; 8px gap → 6px gap so dashes
+ * read closer together, giving tier-guide rings clearer continuous-
+ * ring presence after R290/R291 cleared surrounding backdrop noise.
+ *
+ * Contract:
+ *   - All [data-tier-ring] elements have stroke-dasharray '2 6'.
+ *   - strokeWidth still 0.7 (regression).
+ *   - At least one tier ring rendered with the test fixture (4-node
+ *     working fleet → single-tier layout 220 fits).
+ *   - R302 empty-hint ls=0.2 + R301 panel titles ls=0.3 + R300 kicker
+ *     fw=500 + R294 pulse absent intact.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, model) => ({
+    alias, status: 'working', model, runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  // 4 working nodes → single-tier ring layout.
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'claude-opus-4'),
+    mk('beta',  'gpt-4o'),
+    mk('gamma', 'claude-sonnet-4'),
+    mk('delta', 'gpt-4'),
+  ] } });
+});
+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.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const tierRings = [...document.querySelectorAll('[data-tier-ring]')];
+  const samples = tierRings.map(t => ({
+    r:           t.getAttribute('data-tier-ring'),
+    dasharray:   t.getAttribute('stroke-dasharray'),
+    strokeWidth: t.getAttribute('stroke-width'),
+    occupancy:   t.getAttribute('data-tier-occupancy'),
+  }));
+  const empty = document.querySelector('[data-recent-signal-empty]');
+  const recentTitle = document.querySelector('[data-recent-panel-title]');
+  const legendTitle = document.querySelector('[data-legend-panel-title]');
+  const kicker = document.querySelector('[data-topo-section-kicker]');
+  return {
+    samples,
+    emptyLs:       empty?.getAttribute('letter-spacing') ?? null,
+    recentTitleLs: recentTitle?.getAttribute('letter-spacing') ?? null,
+    legendTitleLs: legendTitle?.getAttribute('letter-spacing') ?? null,
+    kickerFw:      kicker ? getComputedStyle(kicker).fontWeight : null,
+    pulseCount:    document.querySelectorAll('[data-pulse-wrapper]').length,
+  };
+});
+await browser.close();
+
+const results = {
+  tier_rings_rendered:     probe.samples.length >= 1,
+  all_dasharray_2_6:       probe.samples.every(s => s.dasharray === '2 6'),
+  all_stroke_width_0_7:    probe.samples.every(s => s.strokeWidth === '0.7'),
+  r302_empty_hint_ls_0_2:  probe.emptyLs === '0.2',
+  r301_recent_title_ls:    probe.recentTitleLs === '0.3',
+  r301_legend_title_ls:    probe.legendTitleLs === '0.3',
+  r300_kicker_fw_500:      String(probe.kickerFw) === '500',
+  r294_pulse_absent:       probe.pulseCount === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} tier guide dashes:`, JSON.stringify(results),
+  '\n  tier rings sampled:', probe.samples);
+process.exit(ok ? 0 : 1);

package/scripts/topo-tier-ring-fadein-test.mjs

@@ -0,0 +1,107 @@
+/* Round 174 verification: tier guide rings (ring layout) fade-in
+ * alongside R9/R172/R173 first-paint wave.
+ *
+ * Pre-R174 the structural scaffolding for ring layout — R54
+ * dashed concentric guide rings — appeared instantly while
+ * nodes inside eased in via R9/R72. Closes the symmetry with
+ * R173 group boxes (grid layout's structural frame).
+ *
+ * R174 wraps each tier ring <circle> in:
+ *   className="anet-fade-in"
+ *   style.animationDelay: tierIdx × 60ms (cap 8)
+ *   transition list grows opacity 250ms ease-out
+ *   data-tier-fade-delay={...}
+ *
+ * Test:
+ *   1. Force ring layout
+ *   2. Mock 16 sessions → triggers triple-tier render (>14)
+ *   3. Probe all [data-tier-ring] circles
+ *   4. Each has .anet-fade-in className + correct fade-delay
+ *   5. Delays strictly increase by 60ms
+ */
+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';
+  // 16 sessions → R98 triple-tier (threshold > 14)
+  const sessions = [];
+  for (let i = 0; i < 16; i++) {
+    sessions.push({
+      alias: `n${i}`,
+      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 } });
+});
+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 === 16, { timeout: 30000 });
+await page.waitForSelector('[data-tier-ring]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const rings = [...document.querySelectorAll('[data-tier-ring]')];
+  return rings.map(r => ({
+    radius:         parseFloat(r.getAttribute('data-tier-ring') || ''),
+    occupancy:      parseFloat(r.getAttribute('data-tier-occupancy') || ''),
+    hasFadeClass:   (r.getAttribute('class') || '').includes('anet-fade-in'),
+    fadeDelayAttr:  parseFloat(r.getAttribute('data-tier-fade-delay') || ''),
+    animationDelay: r.style.animationDelay || getComputedStyle(r).animationDelay,
+    transition:     r.style.transition || getComputedStyle(r).transition,
+  }));
+});
+
+await browser.close();
+
+const parseDelay = (s) => {
+  if (!s) return null;
+  if (s.endsWith('ms')) return parseFloat(s);
+  if (s.endsWith('s')) return parseFloat(s) * 1000;
+  return parseFloat(s);
+};
+const delays = probe.map(p => parseDelay(p.animationDelay));
+
+const expectedDelays = probe.map((_, i) => Math.min(i, 8) * 60);
+
+const results = {
+  three_tiers_found:        probe.length === 3,
+  all_have_fade_class:      probe.every(p => p.hasFadeClass),
+  all_have_opacity_in_transition: probe.every(p =>
+    (p.transition || '').includes('opacity')),
+  delay_attrs_match:        probe.every((p, i) => p.fadeDelayAttr === expectedDelays[i]),
+  delays_match:             delays.every((d, i) => Math.abs(d - expectedDelays[i]) < 0.5),
+  delays_strictly_increase: delays[0] < delays[1] && delays[1] < delays[2],
+  first_delay_0ms:          delays[0] === 0,
+  third_delay_120ms:        delays[2] === 120,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} tier-ring fade-in:`, JSON.stringify(results),
+  `\n  rings =`, probe,
+  `\n  delays (ms) =`, delays,
+  `\n  expected =`, expectedDelays);
+process.exit(ok ? 0 : 1);

package/scripts/topo-tier-ring-occupancy-test.mjs

@@ -0,0 +1,87 @@
+/* Round 92 verification: tier-ring opacity reflects occupancy. R54
+ * drew the guide rings at a fixed opacity regardless of how many
+ * nodes lived on each tier. R92 buckets the count and scales
+ * opacity, so a crowded tier shouts and an empty tier disappears.
+ *
+ * Probe three fleet sizes: small (4 → 1 ring), medium (12 → 2 rings),
+ * large (18 → 3 rings). Assert bucket monotonicity (higher count =
+ * higher bucket = higher opacity) and that each rendered ring carries
+ * its occupancy + bucket data attributes.
+ */
+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 fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const probe = async (count) => {
+  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 {}
+  });
+  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 = [];
+    for (let i = 0; i < count; i++) {
+      sessions.push({ alias: `n${i}`, 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 } });
+  });
+  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((n) => document.querySelectorAll('g[data-node]').length === n,
+    count, { timeout: 30000 });
+  await page.waitForTimeout(500);
+
+  const rings = await page.evaluate(() => {
+    return [...document.querySelectorAll('[data-tier-ring]')].map(r => ({
+      radius:    r.getAttribute('data-tier-ring'),
+      occupancy: r.getAttribute('data-tier-occupancy'),
+      bucket:    r.getAttribute('data-tier-bucket'),
+      opacity:   +(r.getAttribute('opacity') || '0'),
+    })).sort((a, b) => +a.radius - +b.radius);
+  });
+  await ctx.close();
+  return rings;
+};
+
+const small  = await probe(4);    // 4 nodes → 1 ring, occupancy 4, bucket 1 (3-6)
+const medium = await probe(12);   // 12 nodes → 2 rings
+const large  = await probe(18);   // 18 nodes → 3 rings
+await browser.close();
+
+const occupancySum = (rings) => rings.reduce((acc, r) => acc + +r.occupancy, 0);
+
+const results = {
+  small_oneRing:        small.length === 1,
+  small_occupancy4:     small[0]?.occupancy === '4',
+  small_bucket1:        small[0]?.bucket === '1',
+  medium_twoRings:      medium.length === 2,
+  medium_occupancyMatchesFleet: occupancySum(medium) === 12,
+  large_threeRings:     large.length === 3,
+  large_occupancyMatchesFleet:  occupancySum(large) === 18,
+  // Higher bucket → higher opacity (monotonic ladder).
+  bucketLadder_monotonic: large.every(r => {
+    const b = +r.bucket;
+    // dark theme: bucket 0 → 0.32, 1 → 0.46, 2 → 0.62
+    const expected = [0.32, 0.46, 0.62][b];
+    return Math.abs(r.opacity - expected) < 0.01;
+  }),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} tier-ring occupancy:`, JSON.stringify(results),
+  `\n  small (4)=`,  small,
+  `\n  medium (12)=`, medium,
+  `\n  large (18)=`,  large);
+process.exit(ok ? 0 : 1);

package/scripts/topo-tier-ring-test.mjs

@@ -0,0 +1,69 @@
+/* Round 54 verification: tier-radius guide rings render at the active
+ * tier radii only, picked from the online node count.
+ *  - N ≤ 8  → 1 ring at r=220
+ *  - 9-14   → 2 rings at r=175 and r=260
+ *  - N > 14 → 3 rings at r=145, 215, 285
+ *  - Grid layout has NO tier rings (they're ring-only).
+ * Identified via the `data-tier-ring` attribute the implementation
+ * stamps on each guide circle. */
+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(layout, count) {
+  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((layout) => {
+    try {
+      localStorage.setItem('anet-theme', 'cyber');
+      localStorage.setItem('anet-topo-layout', layout);
+      sessionStorage.setItem('anet_v3_auth', '1');
+    } 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';
+    const sessions = Array.from({ length: count }).map((_, i) => ({
+      alias: `n${i.toString().padStart(2, '0')}`,
+      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(c => document.querySelectorAll('g[data-node]').length === c, count, { timeout: 30000 });
+  await page.waitForTimeout(400);
+  const radii = await page.evaluate(() => {
+    const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+    return [...svg.querySelectorAll('circle[data-tier-ring]')]
+      .map(c => +c.getAttribute('data-tier-ring'))
+      .sort((a, b) => a - b);
+  });
+  await ctx.close();
+  return radii;
+}
+
+const single = await probe('ring', 6);
+const dual = await probe('ring', 12);
+const triple = await probe('ring', 22);
+const grid = await probe('grid', 6);
+
+await browser.close();
+const eq = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+const results = {
+  singleHas220: eq(single, [220]),
+  dualHas175And260: eq(dual, [175, 260]),
+  tripleHas145_215_285: eq(triple, [145, 215, 285]),
+  gridHasNoTierRings: eq(grid, []),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} tier rings:`, JSON.stringify(results),
+  `\n  single=${JSON.stringify(single)} dual=${JSON.stringify(dual)} triple=${JSON.stringify(triple)} grid=${JSON.stringify(grid)}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-tier-ring-tint-test.mjs

@@ -0,0 +1,110 @@
+/* Round 93 verification: tier rings tint to pal.legendAccent when
+ * any of pinnedStatus / pinnedGroup / pinnedVendor is active, and
+ * revert to the neutral pal.ringStroke when all three release.
+ *
+ * Drive pin state via the R69 CustomEvent for status (deterministic;
+ * same approach the R82 chip-pin-mirror test uses) and the vendor
+ * letter click for vendor. Verify data-tier-tinted toggles + stroke
+ * attribute differs from the neutral baseline.
+ */
+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');
+    sessionStorage.removeItem('anet-topo-pinned-status');
+    sessionStorage.removeItem('anet-topo-pinned-group');
+    sessionStorage.removeItem('anet-topo-pinned-vendor');
+  } 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';
+  // 4 nodes → single tier (≤8 threshold). Enough to have 1 ring to inspect.
+  const mk = (alias, model) => ({
+    alias, status: 'idle', model, runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  const sessions = [
+    mk('alpha', 'claude-opus-4'),
+    mk('beta',  'gpt-5'),
+    mk('gamma', 'claude-opus-4'),
+    mk('delta', 'gpt-5'),
+  ];
+  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 === 4, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const ring = () => page.evaluate(() => {
+  const r = document.querySelector('[data-tier-ring]');
+  if (!r) return null;
+  return {
+    tinted: r.getAttribute('data-tier-tinted'),
+    stroke: r.getAttribute('stroke'),
+  };
+});
+
+const before = await ring();
+
+// Pin a status — tier ring should tint.
+await page.evaluate(() => {
+  sessionStorage.setItem('anet-topo-pinned-status', 'idle');
+  window.dispatchEvent(new CustomEvent('anet:topo-pin', { detail: { kind: 'status', value: 'idle' } }));
+});
+await page.waitForTimeout(300);
+const afterStatusPin = await ring();
+
+// Clear via Esc — ring should revert.
+await page.keyboard.press('Escape');
+await page.waitForTimeout(250);
+const afterEscStatus = await ring();
+
+// Pin vendor — tier ring should tint again.
+await page.locator('[data-vendor-letter="A"]').click();
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterVendorPin = await ring();
+
+// Clear via Esc — back to neutral.
+await page.keyboard.press('Escape');
+await page.waitForTimeout(250);
+const afterEscVendor = await ring();
+
+await browser.close();
+
+const results = {
+  before_neutral:       before?.tinted === 'false',
+  before_strokeSet:     typeof before?.stroke === 'string' && before.stroke.length > 0,
+  statusPin_tinted:     afterStatusPin?.tinted === 'true',
+  statusPin_strokeDiffers: afterStatusPin?.stroke !== before?.stroke,
+  escStatus_revertsTinted: afterEscStatus?.tinted === 'false',
+  escStatus_strokeMatchesBaseline: afterEscStatus?.stroke === before?.stroke,
+  vendorPin_tinted:     afterVendorPin?.tinted === 'true',
+  vendorPin_strokeDiffers: afterVendorPin?.stroke !== before?.stroke,
+  escVendor_revertsTinted: afterEscVendor?.tinted === 'false',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} tier-ring tint:`, JSON.stringify(results),
+  `\n  before=`,           before,
+  `\n  afterStatusPin=`,   afterStatusPin,
+  `\n  afterEscStatus=`,   afterEscStatus,
+  `\n  afterVendorPin=`,   afterVendorPin,
+  `\n  afterEscVendor=`,   afterEscVendor);
+process.exit(ok ? 0 : 1);

package/scripts/topo-tier-stagger-test.mjs

@@ -0,0 +1,89 @@
+/* Round 72 verification: ring-layout first-paint stagger is tier-radial
+ * (inner ring → outer ring → offline ring), instead of R9's pure
+ * clockwise nodeIdx walk. Grid mode keeps R9 unchanged.
+ *
+ *  - Mount 20 sessions in ring layout → triple-tier (r1=145 / r2=215 /
+ *    r3=285). data-tier-idx reflects 0/1/2 (offline=3).
+ *  - For ring: every tier-2 node's animationDelay is >= every tier-0
+ *    node's animationDelay (strict tier ordering).
+ *  - For grid: every node has data-tier-idx="-1" and the delay falls
+ *    on R9's `nodeIdx * 25` schedule (max 600ms tail).
+ */
+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(layout, count) {
+  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((layout) => {
+    try {
+      localStorage.setItem('anet-theme', 'cyber');
+      localStorage.setItem('anet-topo-layout', layout);
+      sessionStorage.setItem('anet_v3_auth', '1');
+      sessionStorage.removeItem('anet-topo-pinned-status');
+      sessionStorage.removeItem('anet-topo-pinned-group');
+    } 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';
+    const sessions = Array.from({ length: count }).map((_, i) => ({
+      alias: `n${i.toString().padStart(2, '0')}`,
+      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(c => document.querySelectorAll('g[data-node]').length === c, count, { timeout: 30000 });
+  await page.waitForTimeout(600);
+  const rows = await page.evaluate(() => {
+    return [...document.querySelectorAll('g[data-node]')].map(g => ({
+      alias: g.getAttribute('data-node'),
+      tier:  g.getAttribute('data-tier-idx'),
+      delay: g.style.animationDelay,
+    }));
+  });
+  await ctx.close();
+  return rows;
+}
+
+const ringRows = await probe('ring', 20);
+const gridRows = await probe('grid', 6);
+
+await browser.close();
+
+const ms = (s) => parseFloat((s || '0ms').replace('ms', ''));
+const tier0 = ringRows.filter(r => r.tier === '0').map(r => ms(r.delay));
+const tier1 = ringRows.filter(r => r.tier === '1').map(r => ms(r.delay));
+const tier2 = ringRows.filter(r => r.tier === '2').map(r => ms(r.delay));
+
+const maxTier0 = Math.max(...(tier0.length ? tier0 : [0]));
+const minTier1 = Math.min(...(tier1.length ? tier1 : [Infinity]));
+const minTier2 = Math.min(...(tier2.length ? tier2 : [Infinity]));
+const maxTier1 = Math.max(...(tier1.length ? tier1 : [0]));
+
+const results = {
+  ring_tier0_present: tier0.length > 0,
+  ring_tier1_present: tier1.length > 0,
+  ring_tier2_present: tier2.length > 0,
+  ring_tier1_after_tier0: minTier1 > maxTier0,   // every t1 delay > every t0 delay
+  ring_tier2_after_tier1: minTier2 > maxTier1,
+  grid_allTierMinus1:    gridRows.every(r => r.tier === '-1'),
+  grid_followsR9:        gridRows.every((r, i) => ms(r.delay) === Math.min(i, 24) * 25),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} tier stagger:`, JSON.stringify(results),
+  `\n  ring tier0 delays=`, tier0,
+  `\n  ring tier1 delays=`, tier1,
+  `\n  ring tier2 delays=`, tier2,
+  `\n  grid delays=`,       gridRows.map(r => r.delay));
+process.exit(ok ? 0 : 1);