@sleep2agi/agent-network-dashboard 0.4.6-preview.31 → 0.4.6-preview.310

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

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

@@ -0,0 +1,109 @@
+/* Round 144 verification: legend panel rows lift 1px on hover or
+ * pin. Symmetric extension of R143 (recent-signal rows) to the
+ * sibling overlay panel.
+ *
+ * Now both side panels share matching row-level affordances:
+ *   recent-signal row (R143): hover/pin → translateY(-1px)
+ *   legend row       (R144): hover/pin → translateY(-1px)
+ *
+ * Each row composes inside its panel's hover-shadow (R135) — two
+ * layers of feedback simultaneously when hovering a row.
+ *
+ * Path:
+ *   1. idle: working/idle/offline rows all flat
+ *   2. hover working row → that row lifts; others stay flat
+ *   3. leave hover → restored
+ *   4. click to pin idle row → idle lifted+pinned; working flat
+ *   5. Esc clears pin → idle flat again
+ */
+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();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'working'), mk('beta', 'idle'), mk('gamma', 'working'),
+  ] } });
+});
+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.waitForSelector('[data-legend-status="working"]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const inspectAll = () => page.evaluate(() => {
+  const rows = [...document.querySelectorAll('[data-legend-status]')];
+  return rows.map(row => ({
+    key:        row.getAttribute('data-legend-status'),
+    lifted:     row.getAttribute('data-legend-row-lifted'),
+    pressed:    row.getAttribute('aria-pressed'),
+    transform:  row.getAttribute('style')?.match(/translateY\([^)]+\)/)?.[0],
+  }));
+});
+
+const s1 = await inspectAll();
+
+await page.locator('[data-legend-status="working"]').hover();
+await page.waitForTimeout(250);
+const s2 = await inspectAll();
+const s2_working = s2.find(r => r.key === 'working');
+const s2_idle    = s2.find(r => r.key === 'idle');
+
+await page.mouse.move(20, 20);
+await page.waitForTimeout(250);
+const s3 = await inspectAll();
+const s3_working = s3.find(r => r.key === 'working');
+
+await page.locator('[data-legend-status="idle"]').click();
+await page.waitForTimeout(250);
+await page.mouse.move(20, 20);
+await page.waitForTimeout(250);
+const s4 = await inspectAll();
+const s4_idle    = s4.find(r => r.key === 'idle');
+const s4_working = s4.find(r => r.key === 'working');
+
+await page.keyboard.press('Escape');
+await page.waitForTimeout(250);
+const s5 = await inspectAll();
+const s5_idle = s5.find(r => r.key === 'idle');
+
+await browser.close();
+
+const liftStr = 'translateY(-1px)';
+const results = {
+  s1_threeRows:           s1.length === 3,
+  s1_allFlat:             s1.every(r => r.lifted === 'false' && !r.transform),
+
+  s2_workingLifted:       s2_working?.lifted === 'true' && s2_working?.transform === liftStr,
+  s2_idleStillFlat:       s2_idle?.lifted === 'false' && !s2_idle?.transform,
+
+  s3_workingRestored:     s3_working?.lifted === 'false' && !s3_working?.transform,
+
+  s4_idlePinned:          s4_idle?.pressed === 'true' && s4_idle?.lifted === 'true' && s4_idle?.transform === liftStr,
+  s4_workingNotLifted:    s4_working?.lifted === 'false' && !s4_working?.transform,
+
+  s5_idleCleared:         s5_idle?.lifted === 'false' && !s5_idle?.transform && s5_idle?.pressed === 'false',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend-row hover lift:`, JSON.stringify(results),
+  `\n  s1=`, s1, `\n  s2=`, s2, `\n  s3=`, s3, `\n  s4=`, s4, `\n  s5=`, s5);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,124 @@
+/* Round 219 verification: legend row text gets letter-spacing pin
+ * signature 0px → 0.5px, mirroring R218 group label treatment.
+ * Pre-R219 hover and pin shared fill colour and were typographically
+ * identical at letter form.
+ *
+ * Test (cyber dark, 4 working sessions):
+ *   1. Three legend rows (working / idle / offline) render with
+ *      data-legend-row-label.
+ *   2. Idle: data-legend-row-label-pinned='false' on all rows,
+ *      computed letter-spacing ~ 0 (CSS resolves '0px' → 'normal').
+ *   3. Inline transition includes 'letter-spacing 150ms'.
+ *   4. Click the working legend row → that row becomes pinned.
+ *   5. Working row: pinned='true', letter-spacing ~ 0.5px.
+ *   6. Other rows (idle / offline) stay unpinned + 0 spacing.
+ *   7. Click pinned row again → unpin → back to 0 spacing.
+ *
+ * Same 'normal' vs '0px' CSS-equivalence parser as R218 (CSS
+ * resolves letter-spacing: 0px to keyword 'normal' in computed style).
+ */
+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'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r2) => r2.fulfill({ json: { messages: [] } }));
+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-legend-row-label]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const probe = async () => page.evaluate(() => {
+  return [...document.querySelectorAll('[data-legend-row-label]')].map(el => {
+    const cs = getComputedStyle(el);
+    return {
+      key:         el.getAttribute('data-legend-row-label'),
+      pinned:      el.getAttribute('data-legend-row-label-pinned'),
+      spacing:     cs.letterSpacing,
+      transition:  el.style.transition,
+    };
+  });
+});
+
+const idle = await probe();
+
+// Click the working row to pin it. Use the row wrapper <g
+// data-legend-status="working"> to ensure the click hits the hit
+// area (the text itself has pointerEvents:'none' via the parent <g>).
+await page.click('[data-legend-status="working"]');
+await page.waitForTimeout(200);
+const pinned = await probe();
+
+await page.click('[data-legend-status="working"]');
+await page.waitForTimeout(200);
+const unpinned = await probe();
+
+await browser.close();
+
+// CSS resolves letter-spacing: 0px to 'normal' in computed style.
+// Accept both forms as "zero spacing".
+const near = (s, want, tol = 0.15) => {
+  if (want === 0 && (s === 'normal' || s === '0px' || s === '0' || !s)) return true;
+  const got = parseFloat(s || '0');
+  return Math.abs(got - want) < tol;
+};
+const hasLetterSpacingT = (s) => /letter-spacing\s+(?:150ms|0\.15s)/.test(s || '');
+
+const idleWorking   = idle.find(p => p.key === 'working');
+const idleIdle      = idle.find(p => p.key === 'idle');
+const idleOffline   = idle.find(p => p.key === 'offline');
+const pinWorking    = pinned.find(p => p.key === 'working');
+const pinIdle       = pinned.find(p => p.key === 'idle');
+const unpinWorking  = unpinned.find(p => p.key === 'working');
+
+const results = {
+  three_rows_present:       idle.length === 3,
+  has_working:              !!idleWorking,
+  has_idle:                 !!idleIdle,
+  has_offline:              !!idleOffline,
+
+  // Idle: all unpinned, spacing 0, transition present
+  all_idle_unpinned:        idle.every(p => p.pinned === 'false'),
+  all_idle_spacing_zero:    idle.every(p => near(p.spacing, 0)),
+  all_have_transition:      idle.every(p => hasLetterSpacingT(p.transition)),
+
+  // After pin click: working pinned, idle unchanged
+  working_pinned_attr:      pinWorking?.pinned === 'true',
+  working_spacing_half:     near(pinWorking?.spacing, 0.5),
+  idle_stays_unpinned:      pinIdle?.pinned === 'false',
+  idle_spacing_unchanged:   near(pinIdle?.spacing, 0),
+
+  // After unpin click: working back to unpinned + 0 spacing
+  unpin_attr_false:         unpinWorking?.pinned === 'false',
+  unpin_spacing_zero:       near(unpinWorking?.spacing, 0),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend-row pin spacing:`, JSON.stringify(results),
+  `\n  idle:`,     idle,
+  `\n  pinned:`,   pinned,
+  `\n  unpinned:`, unpinned);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-row-tint-test.mjs

@@ -0,0 +1,95 @@
+/* Round 105 verification: legend rows in the SVG panel pick up a
+ * row-background tint on hover and pin, mirroring R104's treatment
+ * on the recent-signal panel. The tint uses the ROW'S OWN swatch
+ * colour (working=green, idle=teal, offline=slate) so the user's
+ * eye associates the highlight with its swatch instead of a generic
+ * accent.
+ *
+ * Verifies idle / hover / pinned states via the new data-legend-
+ * row-tinted attribute + actual fill/opacity. Pin is stronger than
+ * hover; idle is transparent.
+ */
+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');
+    sessionStorage.removeItem('anet-topo-pinned-status');
+  } catch {}
+});
+
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('wkr1', 'working'),
+    mk('idl1', 'idle'),
+    mk('off1', 'offline'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 3, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const readRow = (key) => page.evaluate((k) => {
+  const g = document.querySelector(`[data-legend-status="${k}"]`);
+  if (!g) return null;
+  const rect = g.querySelector('rect');
+  return {
+    tinted:  rect?.getAttribute('data-legend-row-tinted') || '',
+    fill:    rect?.getAttribute('fill') || '',
+    opacity: rect?.getAttribute('opacity') || '',
+  };
+}, key);
+
+const before = await Promise.all(['working', 'idle', 'offline'].map(readRow));
+
+// Hover working.
+await page.locator('[data-legend-status="working"]').hover();
+await page.waitForTimeout(250);
+const onHoverWorking = await Promise.all(['working', 'idle', 'offline'].map(readRow));
+
+// Move away — clears hover.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+
+// Pin idle.
+await page.locator('[data-legend-status="idle"]').click();
+await page.waitForTimeout(250);
+const onPinIdle = await Promise.all(['working', 'idle', 'offline'].map(readRow));
+
+await browser.close();
+
+const opacity = (s) => parseFloat(s) || 0;
+const results = {
+  before_allTransparent: before.every(r => r?.tinted === 'none' && r?.fill === 'transparent'),
+  hoverWorking_workingTinted: onHoverWorking[0]?.tinted === 'hover' && onHoverWorking[0]?.fill !== 'transparent',
+  hoverWorking_othersUnchanged: onHoverWorking.slice(1).every(r => r?.tinted === 'none'),
+  hoverWorking_opacityLow:    opacity(onHoverWorking[0]?.opacity || '') > 0 && opacity(onHoverWorking[0]?.opacity || '') < 0.2,
+  pinIdle_idlePinned:         onPinIdle[1]?.tinted === 'pinned' && onPinIdle[1]?.fill !== 'transparent',
+  pinIdle_pinStrongerThanHover: opacity(onPinIdle[1]?.opacity || '') > opacity(onHoverWorking[0]?.opacity || ''),
+  pinIdle_otherRowsClean:     onPinIdle.filter((_, i) => i !== 1).every(r => r?.tinted === 'none'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend-row tint:`, JSON.stringify(results),
+  `\n  before=`,         before,
+  `\n  onHoverWorking=`, onHoverWorking,
+  `\n  onPinIdle=`,      onPinIdle);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-row-title-test.mjs

@@ -0,0 +1,102 @@
+/* Round 149 verification: legend rows gain a <title> tooltip
+ * symmetric with R148's recent-signal row tooltip. Closes the
+ * R97 idiom on the panel side — anywhere the UI shows "N" should
+ * hover-explain WHICH N.
+ *
+ * Both side panels now have matching row-tooltip affordances:
+ *   recent-signal row (R148): full from/to/timestamp/content + pin hint
+ *   legend row       (R149): status label + matched-aliases + pin hint
+ *
+ * Fleet: 3 working / 2 idle / 1 offline so all three bucket rows
+ * show non-zero. Verify each row's title contains:
+ *   - status label + count
+ *   - alias list of matching nodes
+ *   - "click to pin" hint when not pinned
+ *
+ * Then click idle to pin → title flips to "click to release pin".
+ */
+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();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('worker-a', 'working'), mk('worker-b', 'working'), mk('worker-c', 'working'),
+    mk('idle-a',   'idle'),    mk('idle-b',   'idle'),
+    mk('off-a',    'offline'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+// 3 working + 2 idle + 1 offline = 6 sessions; offline nodes still
+// render as g[data-node] (line ~2754 [...onlineNodes, ...offlineNodes]
+// .map). Initial count check was off-by-one.
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 6, { timeout: 30000 });
+await page.waitForSelector('[data-legend-status="working"]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const readTitle = (key) => page.evaluate((k) => {
+  const row = document.querySelector(`[data-legend-status="${k}"]`);
+  return row?.querySelector('title')?.textContent || '';
+}, key);
+
+const wTitle = await readTitle('working');
+const iTitle = await readTitle('idle');
+const oTitle = await readTitle('offline');
+
+// Pin idle → its title flips
+await page.locator('[data-legend-status="idle"]').click();
+await page.waitForTimeout(200);
+const iPinnedTitle = await readTitle('idle');
+
+await browser.close();
+
+const results = {
+  // Working row: 3 working aliases
+  w_hasLabel:        wTitle.includes('working node · 3'),
+  w_hasWorkerA:      wTitle.includes('worker-a'),
+  w_hasWorkerB:      wTitle.includes('worker-b'),
+  w_hasWorkerC:      wTitle.includes('worker-c'),
+  w_pinHint:         wTitle.includes('click to pin'),
+
+  // Idle row: 2 idle aliases
+  i_hasLabel:        iTitle.includes('online idle · 2'),
+  i_hasIdleA:        iTitle.includes('idle-a'),
+  i_hasIdleB:        iTitle.includes('idle-b'),
+  i_pinHint:         iTitle.includes('click to pin'),
+
+  // Offline row: 1 offline alias
+  o_hasLabel:        oTitle.includes('offline / no SSE · 1'),
+  o_hasOffA:         oTitle.includes('off-a'),
+
+  // After pin: title hint flipped
+  iPinned_releaseHint: iPinnedTitle.includes('click to release pin'),
+  iPinned_noPinHint:   !iPinnedTitle.includes('click to pin · hover to preview'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend-row title:`, JSON.stringify(results),
+  `\n  workingTitle:\n${wTitle}`,
+  `\n  idleTitle:\n${iTitle}`,
+  `\n  offlineTitle:\n${oTitle}`,
+  `\n  idlePinnedTitle:\n${iPinnedTitle}`);
+process.exit(ok ? 0 : 1);