@sleep2agi/agent-network-dashboard 0.4.6-preview.15 → 0.4.6-preview.151

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-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);

package/scripts/topo-offline-dim-test.mjs

@@ -0,0 +1,70 @@
+/* Round 17 verification: offline nodes render at opacity 0.6 at rest,
+ * online stay at 1, and the chat-focused node (even if offline) jumps
+ * to 1 when its ChatPopover opens. */
+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: 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.removeItem('anet-brand');
+    localStorage.removeItem('anet-topo-view');
+    localStorage.setItem('anet-topo-layout', 'grid');
+    sessionStorage.setItem('anet_v3_auth', '1');
+  } catch {}
+});
+// fresh-enough so the ghost-age-out filter doesn't drop the offline node
+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: 'on1', status: 'idle',    network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'on2', status: 'working', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'off1', status: 'offline', network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'off2', status: 'offline', 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.waitForFunction(() => {
+  const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+  return !!svg && svg.querySelectorAll('g[data-node]').length === 4;
+}, { timeout: 30000 }).catch(() => {});
+await page.waitForTimeout(500);
+
+const opacityOf = (alias) => page.$eval(`g[data-node="${alias}"]`, el =>
+  parseFloat(getComputedStyle(el).opacity || el.style.opacity || '1'));
+
+const restOn1 = await opacityOf('on1');
+const restOn2 = await opacityOf('on2');
+const restOff1 = await opacityOf('off1');
+const restOff2 = await opacityOf('off2');
+
+// Click an offline node — the chat popover should open and that node
+// should jump to full opacity.
+await page.locator('g[data-node="off1"]').click();
+await page.waitForTimeout(300);
+const focusedOff1 = await opacityOf('off1');
+const otherOff2 = await opacityOf('off2');
+
+await browser.close();
+const results = {
+  onlineFullOpacity: Math.abs(restOn1 - 1) < 0.01 && Math.abs(restOn2 - 1) < 0.01,
+  offlineDimmedAtRest: Math.abs(restOff1 - 0.6) < 0.01 && Math.abs(restOff2 - 0.6) < 0.01,
+  chatFocusOfflineRestoresOpacity: Math.abs(focusedOff1 - 1) < 0.01,
+  otherOfflineStaysDimmed: Math.abs(otherOff2 - 0.6) < 0.01,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} offline dim:`, JSON.stringify(results),
+  `rest=on1:${restOn1} on2:${restOn2} off1:${restOff1} off2:${restOff2}`,
+  `clicked off1=${focusedOff1} off2=${otherOff2}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-online-chip-nav-test.mjs

@@ -0,0 +1,143 @@
+/* Round 140 verification: the "N online" chip in the chip row
+ * gets an onClick that navigates to /nodes when interactive.
+ * Mirrors R136 active-links→/messages idiom; complements R139
+ * working→pin idiom. The online chip is the third chip-row chip
+ * that had cursor:pointer without a click action since R79.
+ *
+ * Why nav not pin: "online" = working + idle in semantics; there's
+ * no single pinnedStatus value that captures both. /nodes is the
+ * natural full-list destination.
+ *
+ * Three states tested:
+ *   - Empty fleet (onlineCount=0): chip not interactive
+ *   - 1 online: clickable, role=link, click → /nodes
+ *   - 5 online (mix of working+idle): same shape, click → /nodes
+ *
+ * Hover preview still works (R79 highlight all online) — that's
+ * a separate gesture verified in topo-active-links-chip-hover-test
+ * for the chip-row's hover ladder.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+
+// status: 'working' | 'idle' | 'offline' — distribute by counts
+async function probe({ working, idle, offline }) {
+  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 sessions = [];
+    let i = 0;
+    for (let n = 0; n < working;  n++, i++) sessions.push(mk(i, 'working',  fresh, nid));
+    for (let n = 0; n < idle;     n++, i++) sessions.push(mk(i, 'idle',     fresh, nid));
+    for (let n = 0; n < offline;  n++, i++) sessions.push(mk(i, 'offline',  fresh, nid));
+    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' });
+  // offline-only fleet won't render g[data-node] (only online ones do),
+  // but the chip row still renders because sessions.length > 0.
+  await page.waitForSelector('[data-online-chip]', { timeout: 10000 });
+  await page.waitForTimeout(400);
+
+  return { browser, page };
+}
+
+function mk(i, status, fresh, nid) {
+  return {
+    alias: `node${i}`,
+    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,
+  };
+}
+
+// State A: 5 online (3 working / 2 idle)
+const { browser: b1, page: p1 } = await probe({ working: 3, idle: 2, offline: 0 });
+const fiveProbe = await p1.evaluate(() => {
+  const chip = document.querySelector('[data-online-chip]');
+  return {
+    text:        chip?.textContent,
+    clickable:   chip?.getAttribute('data-online-chip-clickable'),
+    role:        chip?.getAttribute('role'),
+    tabindex:    chip?.getAttribute('tabindex'),
+    cursor:      chip?.getAttribute('style')?.includes('cursor: pointer'),
+    title:       chip?.getAttribute('title'),
+  };
+});
+await p1.locator('[data-online-chip]').click();
+await p1.waitForURL('**/nodes', { timeout: 10000 });
+const fiveUrl = p1.url();
+await b1.close();
+
+// State B: 1 online (1 idle, 0 working)
+const { browser: b2, page: p2 } = await probe({ working: 0, idle: 1, offline: 0 });
+const oneProbe = await p2.evaluate(() => {
+  const chip = document.querySelector('[data-online-chip]');
+  return {
+    text: chip?.textContent,
+    clickable: chip?.getAttribute('data-online-chip-clickable'),
+    role: chip?.getAttribute('role'),
+  };
+});
+await p2.locator('[data-online-chip]').click();
+await p2.waitForURL('**/nodes', { timeout: 10000 });
+const oneUrl = p2.url();
+await b2.close();
+
+// State C: offline-only fleet (2 sessions, all offline → onlineNodes=0)
+// 0-session fleet hits Overview's R52/R70 first-run CTA path, not
+// TopoGraph; offline-only keeps the chip row alive so the non-
+// interactive contract on "0 online" can be verified.
+const { browser: b3, page: p3 } = await probe({ working: 0, idle: 0, offline: 2 });
+const emptyProbe = await p3.evaluate(() => {
+  const chip = document.querySelector('[data-online-chip]');
+  return {
+    text: chip?.textContent,
+    clickable: chip?.getAttribute('data-online-chip-clickable'),
+    role: chip?.getAttribute('role'),
+    tabindex: chip?.getAttribute('tabindex'),
+    cursor: chip?.getAttribute('style')?.includes('cursor: pointer'),
+  };
+});
+await b3.close();
+
+const results = {
+  five_text5Online:        fiveProbe.text === '5 online',
+  five_clickableTrue:      fiveProbe.clickable === 'true',
+  five_roleLink:           fiveProbe.role === 'link',
+  five_tabIndex0:          fiveProbe.tabindex === '0',
+  five_cursorPointer:      fiveProbe.cursor === true,
+  five_titleMentionsNodes: (fiveProbe.title || '').includes('/nodes'),
+  five_navToNodes:         /\/nodes$/.test(fiveUrl),
+
+  one_text1Online:         oneProbe.text === '1 online',
+  one_clickableTrue:       oneProbe.clickable === 'true',
+  one_roleLink:            oneProbe.role === 'link',
+  one_navToNodes:          /\/nodes$/.test(oneUrl),
+
+  empty_text0Online:       emptyProbe.text === '0 online',
+  empty_clickableFalse:    emptyProbe.clickable === 'false',
+  empty_noRole:            emptyProbe.role === null || emptyProbe.role === undefined,
+  empty_noTabIndex:        emptyProbe.tabindex === null || emptyProbe.tabindex === undefined,
+  empty_noCursor:          !emptyProbe.cursor,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} online chip nav:`, JSON.stringify(results),
+  `\n  fiveProbe=`, fiveProbe, ` fiveUrl=`, fiveUrl,
+  `\n  oneProbe=`, oneProbe, ` oneUrl=`, oneUrl,
+  `\n  emptyProbe=`, emptyProbe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-orbit-busyness-test.mjs

@@ -0,0 +1,96 @@
+/* Round 131 verification: outer-ring orbit period buckets on
+ * workingCount, mirroring R84's hub-breath cadence. Idle fleet
+ * keeps the original 16s "calm sweep"; as work piles up the
+ * orbit accelerates to 14 / 12 / 10s. Both motion layers now
+ * read the same underlying "is the network busy" signal.
+ *
+ * Bucket boundaries identical to R84 (line ~2702):
+ *   workingCount === 0     → bucket 0, dur 16s
+ *   workingCount in [1, 2] → bucket 1, dur 14s
+ *   workingCount in [3, 5] → bucket 2, dur 12s
+ *   workingCount  >= 6     → bucket 3, dur 10s
+ *
+ * R50 only renders on cyber theme (light is skipped to keep the
+ * white surface clean). All probes use cyber.
+ *
+ * Probe fleet sizes pick one representative per bucket.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+
+async function probe(workingCount, totalCount) {
+  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 sessions = [];
+    for (let i = 0; i < totalCount; i++) {
+      sessions.push({
+        alias: `node${i}`,
+        status: i < workingCount ? 'working' : '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, totalCount, { timeout: 30000 });
+  await page.waitForTimeout(400);
+
+  const out = await page.evaluate(() => {
+    const orbits = [...document.querySelectorAll('[data-topo-orbit-bucket]')];
+    return orbits.map(g => ({
+      bucket: g.getAttribute('data-topo-orbit-bucket'),
+      dur:    g.getAttribute('data-topo-orbit-dur'),
+      animDur: g.querySelector('animateTransform')?.getAttribute('dur'),
+    }));
+  });
+
+  await browser.close();
+  return out;
+}
+
+// Pick one from each bucket
+const b0 = await probe(0, 4);  // workingCount=0  → bucket 0, dur 16
+const b1 = await probe(2, 4);  // workingCount=2  → bucket 1, dur 14
+const b2 = await probe(4, 5);  // workingCount=4  → bucket 2, dur 12
+const b3 = await probe(7, 8);  // workingCount=7  → bucket 3, dur 10
+
+const allConsistent = (orbits, bucket, dur) =>
+  orbits.length === 4 &&
+  orbits.every(o => o.bucket === String(bucket) && o.dur === String(dur) && o.animDur === `${dur}s`);
+
+const results = {
+  b0_fourOrbits:  b0.length === 4,
+  b0_bucket0_16s: allConsistent(b0, 0, 16),
+  b1_bucket1_14s: allConsistent(b1, 1, 14),
+  b2_bucket2_12s: allConsistent(b2, 2, 12),
+  b3_bucket3_10s: allConsistent(b3, 3, 10),
+  // dur strictly decreases as busy increases
+  dur_monotonic:
+    Number(b0[0]?.dur) > Number(b1[0]?.dur) &&
+    Number(b1[0]?.dur) > Number(b2[0]?.dur) &&
+    Number(b2[0]?.dur) > Number(b3[0]?.dur),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} orbit busyness:`, JSON.stringify(results),
+  `\n  b0(0w/4)=`, b0,
+  `\n  b1(2w/4)=`, b1,
+  `\n  b2(4w/5)=`, b2,
+  `\n  b3(7w/8)=`, b3);
+process.exit(ok ? 0 : 1);

package/scripts/topo-overlap-test.mjs

@@ -3,7 +3,10 @@
  *   - node ↔ node       — status rings don't intersect
  *   - node ↔ panel      — no node circle intersects an overlay panel rect
  *   - node ↔ group-label — no group-box label text covers a node
- *   - group-box ↔ box   — no two group boxes overlap */
+ *   - group-box ↔ box   — no two group boxes overlap
+ *   - label ↔ label     — no two text labels overlap (Round 27 — caught
+ *                         the dense-node-label vs group-label collision
+ *                         Vincent reported in preview.29) */
 import { chromium } from 'playwright';
 import { readFileSync, mkdirSync } from 'node:fs';
 
@@ -80,11 +83,24 @@ async function check(layout) {
         label: { x: bb.x, y: bb.y, w: bb.width, h: bb.height },
       };
     });
-    return { nodes, panels, groups };
+    // Round 27 / P0: every visible label bbox (node alias text + group
+    // headings) so we can assert label↔label clearance. Skip elements
+    // with empty bboxes (e.g., text inside an unrendered <g>).
+    const allLabels = [];
+    for (const t of svg.querySelectorAll('g[data-node] text, g[data-group] text')) {
+      const bb = t.getBBox();
+      if (bb.width === 0 || bb.height === 0) continue;
+      allLabels.push({
+        kind: t.closest('g[data-group]') ? 'group' : 'node',
+        owner: (t.closest('g[data-group]')?.getAttribute('data-group')) || (t.closest('g[data-node]')?.getAttribute('data-node')) || '?',
+        x: bb.x, y: bb.y, w: bb.width, h: bb.height,
+      });
+    }
+    return { nodes, panels, groups, allLabels };
   });
 
   const TOL = 2; // px slack — touching edges is fine, real overlap is not
-  let nodeNode = 0, nodePanel = 0, nodeLabel = 0, boxBox = 0;
+  let nodeNode = 0, nodePanel = 0, nodeLabel = 0, boxBox = 0, labelLabel = 0;
 
   // node ↔ node
   for (let i = 0; i < data.nodes.length; i++) {
@@ -119,12 +135,23 @@ async function check(layout) {
           overlaps1D(a.y, a.y + a.h, b.y, b.y + b.h, TOL)) boxBox++;
     }
   }
+  // label ↔ label  (Round 27)
+  // Same-node node-labels (e.g. alias + sub-status in the full card) are
+  // intentionally close and adjacent — skip pairs that share an owner.
+  for (let i = 0; i < data.allLabels.length; i++) {
+    for (let j = i + 1; j < data.allLabels.length; j++) {
+      const a = data.allLabels[i], b = data.allLabels[j];
+      if (a.owner === b.owner) continue;
+      if (overlaps1D(a.x, a.x + a.w, b.x, b.x + b.w, TOL) &&
+          overlaps1D(a.y, a.y + a.h, b.y, b.y + b.h, TOL)) labelLabel++;
+    }
+  }
 
   await page.screenshot({ path: `/tmp/anet-issue-112/overlap-${layout}.png` });
   await ctx.close();
-  const ok = nodeNode === 0 && nodePanel === 0 && nodeLabel === 0 && boxBox === 0;
+  const ok = nodeNode === 0 && nodePanel === 0 && nodeLabel === 0 && boxBox === 0 && labelLabel === 0;
   console.log(`${ok ? '✅' : '❌'} [${layout}] nodes=${data.nodes.length} groups=${data.groups.length} — ` +
-    `node↔node:${nodeNode} node↔panel:${nodePanel} node↔label:${nodeLabel} box↔box:${boxBox}`);
+    `node↔node:${nodeNode} node↔panel:${nodePanel} node↔label:${nodeLabel} box↔box:${boxBox} label↔label:${labelLabel}`);
   return ok;
 }
 

package/scripts/topo-pan-cursor-test.mjs

@@ -0,0 +1,62 @@
+/* Round 21 verification: SVG cursor flips from grab → grabbing during
+ * a pan drag and back to grab on release. */
+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 });
+// Need a tall enough viewport to keep the SVG ABOVE the fold so real
+// pointer events land — at 1280×900 the canvas starts at ~y=815 (the
+// /admin hero + StatsBar above push it below the viewport bottom).
+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');
+    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'].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/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(400);
+
+const cursorAt = () => page.$eval('svg[viewBox="0 0 1000 680"]', el => el.style.cursor);
+const rest = await cursorAt();
+
+// pick a pan-safe target far from any node — top-left empty canvas region
+const box = await page.$eval('svg[viewBox="0 0 1000 680"]', el => el.getBoundingClientRect());
+const sx = box.x + box.width * 0.08;
+const sy = box.y + box.height * 0.40;
+
+await page.mouse.move(sx, sy);
+await page.mouse.down();
+await page.mouse.move(sx + 40, sy + 30);
+await page.waitForTimeout(50);
+const during = await cursorAt();
+await page.mouse.up();
+await page.waitForTimeout(50);
+const after = await cursorAt();
+
+await browser.close();
+const results = {
+  restIsGrab: rest === 'grab',
+  duringIsGrabbing: during === 'grabbing',
+  afterIsGrab: after === 'grab',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} pan cursor:`, JSON.stringify(results), `rest=${rest} during=${during} after=${after}`);
+process.exit(ok ? 0 : 1);