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

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

@@ -0,0 +1,113 @@
+/* Round 55 verification: hovering a legend status row dims nodes whose
+ * status doesn't match.
+ *
+ * Sessions (mix of statuses):
+ *   wkr  — working          (status=working)
+ *   idl1 — idle online      (status=idle)
+ *   idl2 — idle online      (status=idle)
+ *   off  — offline          (status=offline, last_seen old)
+ *
+ * Hover the "working node" row → wkr stays bright (~1.0), the rest dim
+ * (~0.28). Hover "online idle" → idl1/idl2 stay, wkr+off dim. Hover
+ * "offline / no SSE" → off stays, the three online dim. Release →
+ * all back to base.
+ */
+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 });
+
+// Dashboard chrome pushes the SVG ~830 px down at width 1400, so the
+// legend's offline row sits at screen y≈900 — below a 900-px viewport.
+// 1500 px tall gives a comfortable margin for all three rows.
+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 {}
+});
+
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+const stale = new Date(Date.now() - 30 * 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, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'idl1', status: 'idle',    network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'idl2', status: 'idle',    network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'off',  status: 'offline', network_id: nid, project_dir: null, created_at: stale, updated_at: stale, last_seen_at: stale },
+  ];
+  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 opacities = () => 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 before = await opacities();
+
+async function hoverRow(key) {
+  const target = await page.evaluate((k) => {
+    const g = document.querySelector(`g[data-legend-status="${k}"]`);
+    if (!g) return null;
+    const r = g.getBoundingClientRect();
+    return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+  }, key);
+  if (!target) throw new Error(`legend row ${key} not found`);
+  // jiggle from a neutral spot, then to the target
+  await page.mouse.move(10, 10);
+  await page.mouse.move(target.x, target.y);
+  await page.waitForTimeout(300);
+  return await opacities();
+}
+
+const onWorking = await hoverRow('working');
+const onIdle    = await hoverRow('idle');
+const onOffline = await hoverRow('offline');
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const released = await opacities();
+
+await browser.close();
+
+const dim = (v) => v != null && v < 0.4;
+const bright = (v) => v != null && v >= 0.55;
+const results = {
+  before_baseline: bright(before.wkr) && bright(before.idl1) && bright(before.idl2),
+  working_keepsWorking: bright(onWorking.wkr),
+  working_dimsIdle:     dim(onWorking.idl1) && dim(onWorking.idl2),
+  working_dimsOffline:  dim(onWorking.off),
+  idle_keepsIdle:       bright(onIdle.idl1) && bright(onIdle.idl2),
+  idle_dimsWorking:     dim(onIdle.wkr),
+  idle_dimsOffline:     dim(onIdle.off),
+  // Offline base opacity is 0.6 (R17), so "kept" means >= 0.55 which the
+  // bright() helper already covers — anything in [0.55, 1] counts.
+  offline_keepsOffline: bright(onOffline.off),
+  offline_dimsOnline:   dim(onOffline.wkr) && dim(onOffline.idl1) && dim(onOffline.idl2),
+  released_restoresAll: bright(released.wkr) && bright(released.idl1) && bright(released.idl2),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend status hover:`, JSON.stringify(results),
+  `\n  before=`, before,
+  `\n  onWorking=`, onWorking,
+  `\n  onIdle=`,    onIdle,
+  `\n  onOffline=`, onOffline,
+  `\n  released=`, released);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-offline-delimiter-test.mjs

@@ -0,0 +1,84 @@
+/* Round 269 verification: legend offline-row label " / " → " · "
+ * delimiter unification — closes R138 sweep.
+ *
+ * Pre-R269 the legend's offline row read "offline / no SSE" (ASCII
+ * forward-slash separator). R138 already swept the recent-signal
+ * row separators to " · " (typographic middot) along with filter
+ * pills, node tooltips, edge badges, and active-links tooltip. The
+ * legend offline label was the last hardcoded " / " in TopoGraph.
+ *
+ * R269 changes the label string from "offline / no SSE" to
+ * "offline · no SSE" — same monospace cell width (no layout shift),
+ * matches the dashboard-wide typographic delimiter convention.
+ *
+ * Test scope:
+ *   1. Legend offline row label text contains the typographic middot.
+ *   2. Label DOES NOT contain " / " (the ASCII separator).
+ *   3. Working + idle row labels unchanged (regression: they never
+ *      used " / ").
+ *   4. R257 legend header symmetric inset intact (legend count x === 211).
+ */
+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 = 'working') => ({
+    alias, status, model: 'claude-opus-4', runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha'), mk('beta'), mk('gamma'), mk('delta'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (r) => r.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-legend-row-label="offline"]', { timeout: 10000 });
+await page.waitForSelector('[data-legend-row-label="working"]', { timeout: 10000 });
+await page.waitForSelector('[data-legend-row-label="idle"]',    { timeout: 10000 });
+await page.waitForSelector('[data-legend-panel-count]',         { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const offline = document.querySelector('[data-legend-row-label="offline"]');
+  const working = document.querySelector('[data-legend-row-label="working"]');
+  const idle    = document.querySelector('[data-legend-row-label="idle"]');
+  const count   = document.querySelector('[data-legend-panel-count]');
+  return {
+    offlineText: offline ? offline.textContent : null,
+    workingText: working ? working.textContent : null,
+    idleText:    idle    ? idle.textContent    : null,
+    countX:      count   ? +count.getAttribute('x') : null,
+  };
+});
+await browser.close();
+
+const results = {
+  offline_uses_middot:           probe.offlineText === 'offline · no SSE',
+  offline_no_ascii_slash:        probe.offlineText != null && !probe.offlineText.includes(' / '),
+  working_text_unchanged:        probe.workingText === 'working node',
+  idle_text_unchanged:           probe.idleText    === 'online idle',
+  r257_legend_count_x_211:       probe.countX === 211,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend offline delimiter:`, JSON.stringify(results),
+  '\n  offline:', JSON.stringify(probe.offlineText),
+  '\n  working:', JSON.stringify(probe.workingText),
+  '\n  idle:   ', JSON.stringify(probe.idleText),
+  '\n  count x:', probe.countX);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-offline-label-simplify-test.mjs

@@ -0,0 +1,85 @@
+/* Round 307 verification: legend offline row label drops the
+ * '· no SSE' qualifier. 'offline · no SSE' (16 chars) → 'offline'
+ * (7 chars). Visual already communicates the disconnected state
+ * via status ring dashed pattern + gray fill + gray swatch.
+ *
+ * Contract:
+ *   - [data-legend-row-label='offline'] text content === 'offline'.
+ *   - Does NOT contain 'no SSE' substring.
+ *   - Working row label still 'working node'.
+ *   - Idle row label still 'online idle'.
+ *   - R306 focus-ring-1 + R305 alias chat-target attr + R304/R302/
+ *     R301/R294 regressions 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, status) => ({
+    alias, status, 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', 'working'),
+    mk('beta',  'gpt-4o',        'idle'),
+    mk('gamma', 'claude-sonnet-4', 'offline'),
+  ] } });
+});
+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.waitForSelector('[data-legend-row-label="offline"]', { timeout: 15000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const sel = (s) => document.querySelector(s);
+  const txt = (el) => (el?.textContent || '').trim();
+  const offlineLabel = sel('[data-legend-row-label="offline"]');
+  const workingLabel = sel('[data-legend-row-label="working"]');
+  const idleLabel    = sel('[data-legend-row-label="idle"]');
+  const layoutRing   = sel('[data-topo-chrome-layout="ring"]');
+  const alias        = sel('[data-node-alias-text]');
+  const subhint      = sel('[data-recent-signal-empty-hint]');
+  return {
+    offlineText:        txt(offlineLabel),
+    workingText:        txt(workingLabel),
+    idleText:           txt(idleLabel),
+    layoutRingCls:      layoutRing?.className ?? '',
+    aliasChatTargetAttr: alias?.hasAttribute('data-node-alias-chat-target') ?? false,
+    subhintLs:          subhint?.getAttribute('letter-spacing') ?? null,
+    pulseCount:         document.querySelectorAll('[data-pulse-wrapper]').length,
+  };
+});
+await browser.close();
+
+const results = {
+  offline_label_simplified:        probe.offlineText === 'offline',
+  offline_label_no_sse_dropped:    !/no SSE/i.test(probe.offlineText),
+  working_label_kept:              probe.workingText === 'working node',
+  idle_label_kept:                 probe.idleText === 'online idle',
+  r306_layout_ring_1_kept:         probe.layoutRingCls.includes('focus-visible:ring-1'),
+  r306_layout_no_ring_2:           !probe.layoutRingCls.includes('focus-visible:ring-2'),
+  r305_alias_chat_target_attr:     probe.aliasChatTargetAttr,
+  r304_subhint_ls_0_15:            probe.subhintLs === '0.15',
+  r294_pulse_absent:               probe.pulseCount === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend offline label simplify:`, JSON.stringify(results),
+  '\n  offline:', JSON.stringify(probe.offlineText),
+  '\n  working:', JSON.stringify(probe.workingText),
+  '\n  idle:',    JSON.stringify(probe.idleText));
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-panel-header-test.mjs

@@ -0,0 +1,83 @@
+/* Round 106 verification: legend panel gains a header matching the
+ * recent-signal panel's "recent signal · N flows" format. Same
+ * font/position vocabulary so the two side panels feel paired. The
+ * fleet count is right-aligned at x=215 in the accent colour.
+ *
+ * Sanity-checks:
+ *   - "legend" title text exists in the legend panel
+ *   - "N node(s)" count matches sessions.length
+ *   - Singular vs plural ("1 node" vs "5 nodes") correct
+ *   - Existing rows still render (hover affordance preserved)
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const browser = await chromium.launch({ headless: true });
+const 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'); 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.waitForSelector('[data-legend-panel-count]', { timeout: 10000 });
+  await page.waitForTimeout(400);
+
+  const data = await page.evaluate(() => {
+    const headerCount = document.querySelector('[data-legend-panel-count]')?.textContent;
+    const headerTitle = (() => {
+      // Find a <text> with "legend" content in the legend panel <g>
+      const panel = document.querySelector('[data-topo-panel-elevation="legend"]')?.parentElement;
+      if (!panel) return null;
+      for (const t of panel.querySelectorAll('text')) {
+        if (t.textContent === 'legend') return t.textContent;
+      }
+      return null;
+    })();
+    const legendRows = document.querySelectorAll('[data-legend-status]').length;
+    return { headerCount, headerTitle, legendRows };
+  });
+  await ctx.close();
+  return data;
+};
+
+const single = await probe(1);
+const many   = await probe(5);
+await browser.close();
+
+const results = {
+  single_hasTitle:        single.headerTitle === 'legend',
+  single_count1Node:      single.headerCount === '1 node',
+  many_hasTitle:          many.headerTitle === 'legend',
+  many_count5Nodes:       many.headerCount === '5 nodes',
+  many_rowsStillRender:   many.legendRows >= 1, // depends on which states are present
+  // Sanity: singular vs plural
+  singular_correct:       single.headerCount?.endsWith(' node'),
+  plural_correct:         many.headerCount?.endsWith(' nodes'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend panel header:`, JSON.stringify(results),
+  `\n  single (1 node)=`, single,
+  `\n  many (5 nodes)=`,  many);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-pin-ring-fade-test.mjs

@@ -0,0 +1,112 @@
+/* Round 181 verification: legend row pinned-state ring (R61) is
+ * now always-mounted with opacity-gated visibility + 150ms
+ * transition — smooth fade in/out on pin / unpin.
+ *
+ * Pre-R181 the ring mounted/unmounted conditionally, snapping
+ * on every state change. Same vocabulary as R165/R180 smooth-
+ * pin-mirror family, applied at the legend-row scope.
+ *
+ * Test:
+ *   1. Idle: ring exists in DOM but opacity=0
+ *   2. Click 'working' legend row → ring for working = opacity=1
+ *   3. Other rings (idle / offline) stay opacity=0
+ *   4. Re-click 'working' → unpin → opacity returns to 0
+ *   5. All rings carry 'opacity 150ms ease-out' 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();
+const stale = 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 mk = (alias, status, last) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: last, updated_at: last, last_seen_at: last,
+  });
+  // Mix of statuses so all three legend rows render
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('w1', 'working', fresh), mk('w2', 'working', fresh),
+    mk('i1', 'idle',    fresh),
+    mk('o1', 'offline', stale),
+  ] } });
+});
+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-legend-pin-ring]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = () => page.evaluate(() => {
+  const grab = (k) => {
+    const r = document.querySelector(`[data-legend-pin-ring="${k}"]`);
+    return r ? {
+      opacity:    parseFloat(r.getAttribute('opacity') || ''),
+      pinnedAttr: r.getAttribute('data-legend-pin-ring-pinned'),
+      transition: r.style.transition || getComputedStyle(r).transition,
+    } : null;
+  };
+  return {
+    working: grab('working'),
+    idle:    grab('idle'),
+    offline: grab('offline'),
+  };
+});
+
+const idle = await probe();
+
+// Pin 'working' status by clicking the legend row
+await page.locator('[data-legend-status="working"]').click();
+await page.waitForTimeout(250);
+const afterPin = await probe();
+
+// Re-click to unpin
+await page.locator('[data-legend-status="working"]').click();
+await page.waitForTimeout(250);
+const afterUnpin = await probe();
+
+await browser.close();
+
+const hasTransition = (s) =>
+  (s?.transition || '').includes('opacity 150ms') ||
+  /opacity\s+0\.15s|opacity\s+150ms/.test(s?.transition || '');
+
+const results = {
+  // Idle (no pin)
+  three_rings_present:       idle.working !== null && idle.idle !== null && idle.offline !== null,
+  idle_working_opacity_0:    idle.working?.opacity === 0,
+  idle_idle_opacity_0:       idle.idle?.opacity === 0,
+  idle_offline_opacity_0:    idle.offline?.opacity === 0,
+  all_have_transition:       hasTransition(idle.working) && hasTransition(idle.idle) && hasTransition(idle.offline),
+
+  // After pin working
+  pin_working_opacity_1:     afterPin.working?.opacity === 1,
+  pin_working_pinned_attr:   afterPin.working?.pinnedAttr === 'true',
+  pin_idle_stays_0:          afterPin.idle?.opacity === 0,
+  pin_offline_stays_0:       afterPin.offline?.opacity === 0,
+
+  // After unpin
+  unpin_working_opacity_0:   afterUnpin.working?.opacity === 0,
+  unpin_working_pinned_attr: afterUnpin.working?.pinnedAttr === 'false',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend pin-ring fade:`, JSON.stringify(results),
+  `\n  idle =`, idle,
+  `\n  pinned =`, afterPin,
+  `\n  unpinned =`, afterUnpin);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,128 @@
+/* Round 61 verification: legend rows also pin status filter on click.
+ *  - Hovering still works (R55, transient release).
+ *  - Clicking a row toggles pinnedStatus same as R60 pressure segments.
+ *  - Pinned row's swatch gets an outer ring at r=8 (concentric, row colour).
+ *  - Click same row again → release.
+ *  - Sticky: pin survives mouse-move-away (vs R55 hover which clears).
+ *  - The R60 pressure-segment pin and this share `pinnedStatus`, so
+ *    clicking the legend then clicking the pressure-segment for a
+ *    different status replaces (not stacks) the filter — verified by
+ *    chain: legend.working → pressure.idle → only idle stays bright.
+ */
+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');
+  } 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, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'idl1', status: 'idle',    network_id: nid, project_dir: null, created_at: fresh, updated_at: fresh, last_seen_at: fresh },
+    { alias: 'idl2', 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 opacities = () => page.evaluate(() => {
+  const o = {};
+  for (const a of ['wkr', 'idl1', 'idl2']) {
+    const g = document.querySelector(`g[data-node="${a}"]`);
+    o[a] = g ? +(g.style.opacity || '1') : null;
+  }
+  return o;
+});
+
+const before = await opacities();
+
+// Click the WORKING legend row.
+const workingLegend = page.locator('g[data-legend-status="working"]').first();
+const workingExists = await workingLegend.count() > 0;
+if (!workingExists) { console.log('❌ legend row[working] not found'); process.exit(1); }
+await workingLegend.click({ force: true });
+await page.waitForTimeout(250);
+const afterPin = await opacities();
+
+// Pin survives mouse move.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterMouseMove = await opacities();
+
+// Pinned row should carry an aria-pressed=true.
+const pinnedAria = await page.evaluate(() => {
+  const g = document.querySelector('g[data-legend-status="working"]');
+  return g?.getAttribute('aria-pressed');
+});
+// And a concentric r=8 ring exists inside it.
+const pinnedRingExists = await page.evaluate(() => {
+  const g = document.querySelector('g[data-legend-status="working"]');
+  if (!g) return false;
+  return [...g.querySelectorAll('circle')].some(c => c.getAttribute('r') === '8');
+});
+
+// Switch pin via pressure segment (idle) — should REPLACE, not stack.
+const idleSeg = page.locator('[data-pressure-seg="idle"]').first();
+await idleSeg.click({ force: true });
+await page.waitForTimeout(250);
+const afterSwitch = await opacities();
+
+// And the legend pin should release (concentric ring gone from working).
+const workingRingGone = await page.evaluate(() => {
+  const g = document.querySelector('g[data-legend-status="working"]');
+  if (!g) return true;
+  return ![...g.querySelectorAll('circle')].some(c => c.getAttribute('r') === '8');
+});
+
+// Click idle legend again to release pin. The click ALSO triggers a
+// mouseenter that sets hoveredStatus='idle', which would keep the
+// filter active (activeStatus = hoveredStatus ?? pinnedStatus). Move
+// the mouse away to clear the hover so we observe the pin-only state.
+await page.locator('g[data-legend-status="idle"]').first().click({ force: true });
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterRelease = await opacities();
+
+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),
+  legendPin_keepsWorking:    bright(afterPin.wkr),
+  legendPin_dimsIdle:        dim(afterPin.idl1) && dim(afterPin.idl2),
+  legendPin_survivesMouse:   bright(afterMouseMove.wkr) && dim(afterMouseMove.idl1),
+  legendPin_ariaPressed:     pinnedAria === 'true',
+  legendPin_ringRendered:    pinnedRingExists,
+  pressureSwitch_replaces:   dim(afterSwitch.wkr) && bright(afterSwitch.idl1) && bright(afterSwitch.idl2),
+  pressureSwitch_clearsLegendRing: workingRingGone,
+  release_restoresAll:       bright(afterRelease.wkr) && bright(afterRelease.idl1),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend pin:`, JSON.stringify(results),
+  `\n  before=`, before,
+  `\n  afterPin=`, afterPin,
+  `\n  afterMouseMove=`, afterMouseMove,
+  `\n  afterSwitch=`, afterSwitch,
+  `\n  afterRelease=`, afterRelease,
+  `\n  pinnedAria=${pinnedAria} ringRendered=${pinnedRingExists} workingRingGone=${workingRingGone}`);
+process.exit(ok ? 0 : 1);