@sleep2agi/agent-network-dashboard 0.4.6-preview.13 → 0.4.6-preview.130

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

package/scripts/topo-panel-elevation-test.mjs

@@ -0,0 +1,76 @@
+/* Round 57 verification: recent-signal + legend panels carry a drop-
+ * shadow filter so they read as floating cards instead of pasted-on
+ * graphics — especially important on light theme where panel fill is
+ * near-white on a near-white canvas.
+ *
+ *  - Both panels render a <rect> with `data-topo-panel-elevation`.
+ *  - The rect's `style.filter` contains "drop-shadow(".
+ *  - Light vs cyber themes use different shadow alpha (light tuned for
+ *    contrast against white canvas; cyber for subtle depth on dark).
+ *    Verify the strings differ so the theme switch isn't a no-op.
+ */
+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(theme) {
+  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((t) => {
+    try {
+      localStorage.setItem('anet-theme', t);
+      localStorage.setItem('anet-topo-layout', 'ring');
+      sessionStorage.setItem('anet_v3_auth', '1');
+    } catch {}
+  }, theme);
+  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'].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.waitForSelector('rect[data-topo-panel-elevation="recent"]', { timeout: 30000 });
+  await page.waitForTimeout(400);
+  const filters = await page.evaluate(() => {
+    const recent = document.querySelector('rect[data-topo-panel-elevation="recent"]');
+    const legend = document.querySelector('rect[data-topo-panel-elevation="legend"]');
+    return {
+      recent: recent?.getAttribute('style') || '',
+      legend: legend?.getAttribute('style') || '',
+      recentComputed: recent ? getComputedStyle(recent).filter : null,
+      legendComputed: legend ? getComputedStyle(legend).filter : null,
+    };
+  });
+  await ctx.close();
+  return filters;
+}
+
+const light = await probe('light');
+const cyber = await probe('cyber');
+await browser.close();
+
+const hasShadow = (s) => /drop-shadow\(/.test(s || '');
+const results = {
+  light_recent_hasShadow:  hasShadow(light.recent),
+  light_legend_hasShadow:  hasShadow(light.legend),
+  cyber_recent_hasShadow:  hasShadow(cyber.recent),
+  cyber_legend_hasShadow:  hasShadow(cyber.legend),
+  themes_differ:           light.recent !== cyber.recent,
+  computed_resolves:       hasShadow(light.recentComputed) && hasShadow(cyber.recentComputed),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} panel elevation:`, JSON.stringify(results),
+  `\n  light.recent=${JSON.stringify(light.recent)}`,
+  `\n  cyber.recent=${JSON.stringify(cyber.recent)}`);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,82 @@
+/* Round 103 verification: flow-particle `<animateMotion begin>` is
+ * unique per edge, staggered by `-(index × 0.37) % duration s`. Pre-
+ * R103 all edges' particles fired at t=0 in lockstep; the stagger
+ * gives the canvas an organic "many independent rivers" feel.
+ *
+ * Verifies:
+ *   - every edge has a `begin` attribute on its <animateMotion>
+ *   - all begin values are distinct (no two edges share a phase)
+ *   - the format is "-Ns" (negative offset for retroactive cycle start)
+ *   - reducedMotion still suppresses the particle entirely
+ */
+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() - 30 * 1000).toISOString();
+
+const probe = async (reducedMotion) => {
+  const ctx = await browser.newContext({
+    viewport: { width: 1400, height: 1500 },
+    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'); 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 mk = (alias) => ({
+      alias, 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: [mk('alpha'), mk('beta'), mk('gamma'), mk('delta'), mk('epsilon')] } });
+  });
+  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(),
+  });
+  // Five distinct edges → five animations.
+  await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [
+    mkMsg('m1', 'alpha', 'beta',   30 * 1000),
+    mkMsg('m2', 'gamma', 'delta',  35 * 1000),
+    mkMsg('m3', 'beta',  'gamma',  40 * 1000),
+    mkMsg('m4', 'delta', 'epsilon', 45 * 1000),
+    mkMsg('m5', 'epsilon', 'alpha', 50 * 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 === 5, { timeout: 30000 });
+  await page.waitForTimeout(400);
+
+  const beginValues = await page.evaluate(() => {
+    return [...document.querySelectorAll('animateMotion')]
+      .map(a => a.getAttribute('begin'));
+  });
+  await ctx.close();
+  return beginValues;
+};
+
+const normal = await probe(false);
+const reduced = await probe(true);
+await browser.close();
+
+const results = {
+  normal_hasAtLeast5: normal.length >= 5,
+  normal_allHaveBegin: normal.every(b => typeof b === 'string' && b.length > 0),
+  normal_allNegativeOffset: normal.every(b => /^-\d/.test(b || '')),
+  normal_allDistinct: new Set(normal).size === normal.length,
+  normal_firstIsZero: normal[0] === '-0.000s',
+  reduced_noParticles: reduced.length === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} particle stagger:`, JSON.stringify(results),
+  `\n  normal=`,  normal,
+  `\n  reduced=`, reduced);
+process.exit(ok ? 0 : 1);

package/scripts/topo-pin-persistence-test.mjs

@@ -0,0 +1,105 @@
+/* Round 66 verification: pinnedStatus + pinnedGroup persist across page
+ * reloads via sessionStorage. Stale group pins (group no longer exists)
+ * are cleared on hydration so the chip row doesn't show a phantom team.
+ *
+ *  - Pre-seed sessionStorage with anet-topo-pinned-status='working' →
+ *    reload → assert filter pill renders + working stays bright + idles
+ *    dim. (Status pin survives.)
+ *  - Pre-seed anet-topo-pinned-group='alpha' WITH alpha sessions → reload
+ *    → pill renders + alpha team stays bright.
+ *  - Pre-seed anet-topo-pinned-group='ghost' WITHOUT any ghost session →
+ *    reload → the stale pin is cleared on hydration; no pill renders.
+ */
+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({ status = null, group = null, sessions }) {
+  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(({ status, group }) => {
+    try {
+      localStorage.setItem('anet-theme', 'cyber');
+      localStorage.setItem('anet-topo-layout', 'grid');
+      sessionStorage.setItem('anet_v3_auth', '1');
+      if (status) sessionStorage.setItem('anet-topo-pinned-status', status);
+      else        sessionStorage.removeItem('anet-topo-pinned-status');
+      if (group)  sessionStorage.setItem('anet-topo-pinned-group', group);
+      else        sessionStorage.removeItem('anet-topo-pinned-group');
+    } catch {}
+  }, { status, group });
+  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 seeded = sessions.map(s => ({
+      alias: s.alias, status: s.status, network_id: nid, project_dir: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+    }));
+    await route.fulfill({ response: r, json: { ...b, sessions: seeded } });
+  });
+  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(c => document.querySelectorAll('g[data-node]').length === c, sessions.length, { timeout: 30000 });
+  await page.waitForTimeout(700);
+  const result = await page.evaluate(() => {
+    const pills = [...document.querySelectorAll('[data-active-filter]')].map(el => ({
+      kind: el.getAttribute('data-active-filter'),
+      text: (el.textContent || '').trim(),
+    }));
+    const opacities = {};
+    for (const el of document.querySelectorAll('g[data-node]')) {
+      const a = el.getAttribute('data-node');
+      if (a) opacities[a] = +(el.style.opacity || '1');
+    }
+    const storage = {
+      status: sessionStorage.getItem('anet-topo-pinned-status'),
+      group:  sessionStorage.getItem('anet-topo-pinned-group'),
+    };
+    return { pills, opacities, storage };
+  });
+  await ctx.close();
+  return result;
+}
+
+const sessions3 = [
+  { alias: 'alpha1', status: 'working' },
+  { alias: 'alpha2', status: 'idle' },
+  { alias: 'beta',   status: 'idle' },
+];
+const alphaPlus = [
+  { alias: 'alpha1', status: 'idle' },
+  { alias: 'alpha2', status: 'idle' },
+  { alias: 'alpha3', status: 'idle' },
+  { alias: 'beta',   status: 'idle' },
+];
+
+const statusRestore = await probe({ status: 'working', sessions: sessions3 });
+const groupRestore  = await probe({ group: 'alpha',   sessions: alphaPlus });
+const stalePin      = await probe({ group: 'ghost',   sessions: sessions3 });
+
+await browser.close();
+
+const bright = (v) => v != null && v >= 0.55;
+const dim    = (v) => v != null && v < 0.4;
+const results = {
+  statusPill_restored: statusRestore.pills.length === 1 && statusRestore.pills[0].kind === 'status'
+                        && /filter:\s*working/.test(statusRestore.pills[0].text),
+  statusPin_dimsIdle:  bright(statusRestore.opacities.alpha1) && dim(statusRestore.opacities.alpha2),
+  groupPill_restored:  groupRestore.pills.length === 1 && groupRestore.pills[0].kind === 'group'
+                        && /filter:\s*alpha/.test(groupRestore.pills[0].text),
+  groupPin_dimsOutsider: bright(groupRestore.opacities.alpha1) && dim(groupRestore.opacities.beta),
+  stale_pillCleared:   stalePin.pills.length === 0,
+  stale_storageCleared: stalePin.storage.group === null,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} pin persistence:`, JSON.stringify(results),
+  `\n  statusRestore=`, statusRestore,
+  `\n  groupRestore=`, groupRestore,
+  `\n  stalePin=`, stalePin);
+process.exit(ok ? 0 : 1);

package/scripts/topo-popover-meta-test.mjs

@@ -0,0 +1,78 @@
+/* Round 37 verification: ChatPopover header carries cwd / last-seen
+ * lines pulled from the SWR session cache. Three cases:
+ *   - online node with cwd → cwd line, no last-seen
+ *   - offline node with cwd → both lines
+ *   - bare node (no cwd, no last_seen) → drag/Esc fallback hint */
+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(targetAlias) {
+  const ctx = await browser.newContext({ viewport: { width: 1400, height: 1000 } });
+  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-nodescale', '1');
+      sessionStorage.setItem('anet_v3_auth', '1');
+    } catch {}
+  });
+  const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+  const offline = new Date(Date.now() - 8 * 60 * 1000).toISOString(); // 8 min ago
+  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: 'liveCwd', status: 'idle', network_id: nid,
+        project_dir: '/home/vansin/agent-orchestra',
+        created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+      { alias: 'offCwd', status: 'offline', network_id: nid,
+        project_dir: '/home/vansin/some-project',
+        created_at: fresh, updated_at: fresh, last_seen_at: offline },
+      { alias: 'bare', 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.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 3, { timeout: 30000 });
+  await page.waitForTimeout(400);
+  await page.locator(`g[data-node="${targetAlias}"]`).click();
+  await page.waitForTimeout(300);
+  const meta = await page.evaluate(() => {
+    const cwd = document.querySelector('[data-popover-cwd]');
+    const ls = document.querySelector('[data-popover-lastseen]');
+    const popover = document.querySelector('[aria-label^="Chat with"]');
+    const dragHint = popover ? [...popover.querySelectorAll('div')].find(d => /Drag to move/.test(d.textContent || '')) : null;
+    return {
+      cwdText: cwd?.textContent || null,
+      lsText: ls?.textContent || null,
+      dragHintPresent: !!dragHint,
+    };
+  });
+  await ctx.close();
+  return meta;
+}
+
+const live = await probe('liveCwd');
+const off = await probe('offCwd');
+const bare = await probe('bare');
+await browser.close();
+
+const results = {
+  liveShowsCwd: live.cwdText === 'cwd: /home/vansin/agent-orchestra' && live.lsText === null && !live.dragHintPresent,
+  offlineShowsBoth: off.cwdText === 'cwd: /home/vansin/some-project'
+    && /last seen: [78]m ago/.test(off.lsText || '')
+    && !off.dragHintPresent,
+  bareFallsBackToDragHint: bare.cwdText === null && bare.lsText === null && bare.dragHintPresent,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} popover meta:`, JSON.stringify(results),
+  `\n  live=`, live, `\n  off=`, off, `\n  bare=`, bare);
+process.exit(ok ? 0 : 1);

package/scripts/topo-pressure-bar-test.mjs

@@ -0,0 +1,69 @@
+/* Round 31 verification: fleet-pressure chip with proportional segments.
+ * 4 working + 6 idle + 2 offline = 12 total → 33% / 50% / 17%. */
+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: 1000 } });
+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 make = (alias, status) => ({
+    alias, status, network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  const sessions = [
+    ...Array.from({ length: 4 }, (_, i) => make(`w${i}`, 'working')),
+    ...Array.from({ length: 6 }, (_, i) => make(`i${i}`, 'idle')),
+    ...Array.from({ length: 2 }, (_, i) => make(`o${i}`, 'offline')),
+  ];
+  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-fleet-pressure]', { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const chip = '[data-fleet-pressure]';
+const titleText = await page.locator(chip).getAttribute('title');
+// The chip layout: <chip> > <label-span> + <bar-span> ; bar-span has the 3 segment spans.
+const segments = await page.evaluate(() => {
+  const chip = document.querySelector('[data-fleet-pressure]');
+  if (!chip) return [];
+  // The bar container is the inline-flex w-16 span (second child).
+  const bar = [...chip.children].find(c => c.classList?.contains('w-16'));
+  if (!bar) return [];
+  return [...bar.children].map(el => ({ width: el.style.width, background: el.style.background }));
+});
+const segmentWidths = segments.map(s => s.width);
+const segmentColors = segments.map(s => s.background);
+
+// 4/12 = 33.33%, 6/12 = 50.00%, 2/12 = 16.67%
+const close = (a, b) => Math.abs(parseFloat(a) - b) < 0.5;
+
+await browser.close();
+const results = {
+  titleHasCounts: titleText === '4 working · 6 idle · 2 offline',
+  threeSegments: segmentWidths.length === 3,
+  workingProportion: close(segmentWidths[0], 100 * 4 / 12),
+  idleProportion: close(segmentWidths[1], 100 * 6 / 12),
+  offlineProportion: close(segmentWidths[2], 100 * 2 / 12),
+  workingColor: /22c55e|rgb\(34, 197, 94\)/.test(segmentColors[0] || ''),
+  idleColor: /2dd4bf|rgb\(45, 212, 191\)/.test(segmentColors[1] || ''),
+  offlineColor: /6b7280|rgb\(107, 114, 128\)/.test(segmentColors[2] || ''),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} pressure bar:`, JSON.stringify(results), `widths=${segmentWidths.join(',')} colors=${segmentColors.join(' | ')}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-pressure-hover-test.mjs

@@ -0,0 +1,123 @@
+/* Round 83 verification: pressure-bar segments expose a hover preview
+ * before the click pins. Matches the R55 legend + R79 status chip +
+ * R80 vendor letter hover pattern — same activeStatus mechanism, just
+ * the last surface that was click-only.
+ *
+ * Fleet: 1 working + 2 idle + 1 offline. Hover the working segment →
+ * working node stays bright, idle + offline dim. Mouseleave → restore.
+ * Then click the working segment → pin sticks via boxShadow. Hovering
+ * idle while working is pinned → live preview switches; mouseleave
+ * falls back to the working pin (activeStatus = hoveredStatus ??
+ * pinnedStatus).
+ */
+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: 1200 } });
+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');
+    sessionStorage.removeItem('anet-topo-pinned-status');
+    sessionStorage.removeItem('anet-topo-pinned-group');
+  } catch {}
+});
+
+const fresh   = new Date(Date.now() - 60 * 1000).toISOString();
+const stale10 = new Date(Date.now() - 10 * 60 * 1000).toISOString();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const sessions = [
+    { alias: 'wkr',  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 },
+    { alias: 'idl1', 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 },
+    { alias: 'idl2', 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 },
+    { alias: 'off',  status: 'offline', model: 'claude-opus-4', runtime: 'cli-claude-code',
+      network_id: nid, project_dir: null, created_at: stale10, updated_at: stale10, last_seen_at: stale10 },
+  ];
+  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(500);
+
+const ops = () => page.evaluate(() => {
+  const o = {};
+  for (const a of ['wkr', 'idl1', 'idl2', 'off']) {
+    const g = document.querySelector(`g[data-node="${a}"]`);
+    o[a] = g ? +(g.style.opacity || '1') : null;
+  }
+  return o;
+});
+const segShadow = (k) => page.evaluate((key) => {
+  const s = document.querySelector(`[data-pressure-seg="${key}"]`);
+  return s ? (s.getAttribute('style') || '').includes('inset') : false;
+}, k);
+
+const before = await ops();
+
+// Hover working segment → working stays bright, others dim.
+await page.locator('[data-pressure-seg="working"]').hover();
+await page.waitForTimeout(250);
+const onHoverWorking = await ops();
+const hoverPinShadowBefore = await segShadow('working');
+
+// Mouseleave → baseline restores (no pin yet).
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterLeave = await ops();
+
+// Click to pin working — segment gets inset shadow.
+await page.locator('[data-pressure-seg="working"]').click();
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterPin    = await ops();
+const pinShadow   = await segShadow('working');
+
+// Hover idle while working is pinned — hoveredStatus overrides for the
+// duration of the hover. idle stays bright, working dims (transient).
+await page.locator('[data-pressure-seg="idle"]').hover();
+await page.waitForTimeout(250);
+const onHoverIdle = await ops();
+
+// Mouseleave → falls back to working pin (NOT cleared).
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterLeaveIdle = await ops();
+
+await browser.close();
+
+const bright = (v) => v != null && v >= 0.55;
+const dim    = (v) => v != null && v < 0.4;
+const results = {
+  before_baseline:           bright(before.wkr) && bright(before.idl1) && bright(before.idl2) && before.off <= 0.6,
+  hoverWorking_workerStays:  bright(onHoverWorking.wkr),
+  hoverWorking_idlesDim:     dim(onHoverWorking.idl1) && dim(onHoverWorking.idl2),
+  hoverWorking_offDim:       dim(onHoverWorking.off),
+  hoverWorking_noPinYet:    !hoverPinShadowBefore,
+  leave_restoresBaseline:    bright(afterLeave.wkr) && bright(afterLeave.idl1) && bright(afterLeave.idl2),
+  pin_workerStays:           bright(afterPin.wkr),
+  pin_idlesDim:              dim(afterPin.idl1) && dim(afterPin.idl2),
+  pin_shadowRendered:        pinShadow,
+  hoverIdle_transient:       bright(onHoverIdle.idl1) && bright(onHoverIdle.idl2) && dim(onHoverIdle.wkr),
+  leaveIdle_pinPersists:     bright(afterLeaveIdle.wkr) && dim(afterLeaveIdle.idl1) && dim(afterLeaveIdle.idl2),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} pressure-hover:`, JSON.stringify(results),
+  `\n  before=`,          before,
+  `\n  onHoverWorking=`,  onHoverWorking,
+  `\n  afterPin=`,        afterPin,
+  `\n  onHoverIdle=`,     onHoverIdle,
+  `\n  afterLeaveIdle=`,  afterLeaveIdle);
+process.exit(ok ? 0 : 1);