@sleep2agi/agent-network-dashboard 0.4.6 → 0.5.0

package/scripts/topo-empty-state-recenter-test.mjs

@@ -0,0 +1,107 @@
+/* Round 258 verification: recent-signal panel empty-state re-centered
+ * within the post-R256 88-tall panel.
+ *
+ * Pre-R256 (panel height 84):
+ *   panel mid-line = (0 + 84) / 2 = 42
+ *   main "no flow yet" at y=54  → +12 below mid
+ *   hint "send a..."  at y=68  → +26 below mid
+ *   Optically balanced for an 84-tall panel.
+ *
+ * Post-R256 (panel height 88) — pre-R258:
+ *   panel mid-line = (0 + 88) / 2 = 44
+ *   main at y=54  → +10 below mid (drifted 2px high)
+ *   hint at y=68  → +24 below mid (drifted 2px high)
+ *   Empty state visually drifted up after the height bump.
+ *
+ * Post-R258:
+ *   main y=54 → y=56  (+2)
+ *   hint y=68 → y=70  (+2)
+ *   New offsets: +12 / +26 below mid — restored optical balance.
+ *
+ * Test scope:
+ *   1. Empty state mounts visible (flowLinks.length === 0).
+ *   2. Main text y === 56 (was 54).
+ *   3. Hint text y === 70 (was 68).
+ *   4. Panel rect height === 88 (regression — R256 holds).
+ *   5. Offsets-from-mid: (main_y - panel_height/2) === 12 (matches
+ *      original R45 optical placement).
+ *   6. R200 SMIL breath continues — animate child still attached.
+ *   7. Hint baseline still sits 12px above the footer (visible when
+ *      flowLinks.length > 3 — but in empty state footer is invisible
+ *      anyway; just verify y=70 < 82).
+ */
+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'),
+  ] } });
+});
+// Zero messages → flowLinks.length === 0 → empty state visible.
+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 === 2, { timeout: 30000 });
+await page.waitForSelector('[data-recent-signal-empty]',       { timeout: 10000 });
+await page.waitForSelector('[data-recent-signal-empty-hint]',  { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const panelG = document.querySelector('[data-topo-panel="recent"]');
+  const rect   = panelG?.querySelector('rect');
+  const wrap   = document.querySelector('[data-recent-signal-empty-wrapper]');
+  const main   = document.querySelector('[data-recent-signal-empty]');
+  const hint   = document.querySelector('[data-recent-signal-empty-hint]');
+  const mainAnim = main?.querySelector('animate');
+  const hintAnim = hint?.querySelector('animate');
+  return {
+    panelH:        rect ? +rect.getAttribute('height') : null,
+    wrapperVisible: wrap?.getAttribute('data-recent-signal-empty-visible'),
+    mainY:         main ? +main.getAttribute('y') : null,
+    hintY:         hint ? +hint.getAttribute('y') : null,
+    mainHasBreath: !!mainAnim,
+    hintHasBreath: !!hintAnim,
+  };
+});
+await browser.close();
+
+const midLine        = probe.panelH != null ? probe.panelH / 2 : null;
+const mainOffsetMid  = (probe.mainY != null && midLine != null) ? probe.mainY - midLine : null;
+const hintOffsetMid  = (probe.hintY != null && midLine != null) ? probe.hintY - midLine : null;
+
+const results = {
+  panel_h_88:                       probe.panelH === 88,
+  wrapper_empty_visible_true:       probe.wrapperVisible === 'true',
+  main_y_moved_to_56:               probe.mainY === 56,
+  hint_y_moved_to_70:               probe.hintY === 70,
+  main_offset_from_mid_is_12:       mainOffsetMid === 12,
+  hint_offset_from_mid_is_26:       hintOffsetMid === 26,
+  main_smil_breath_present:         probe.mainHasBreath === true,
+  hint_smil_breath_present:         probe.hintHasBreath === true,
+  hint_above_footer_y82:            probe.hintY != null && probe.hintY < 82,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} recent panel empty-state re-center:`, JSON.stringify(results),
+  '\n  panelH:', probe.panelH, 'midLine:', midLine,
+  '\n  mainY:', probe.mainY, '(offset-from-mid', mainOffsetMid, ')',
+  '\n  hintY:', probe.hintY, '(offset-from-mid', hintOffsetMid, ')');
+process.exit(ok ? 0 : 1);

package/scripts/topo-empty-subhint-tracking-test.mjs

@@ -0,0 +1,87 @@
+/* Round 304 verification: secondary instructional hint
+ * 'send a message between agents' gains letterSpacing='0.15'.
+ * Extends the R301/R302 editorial-spacing-by-loudness hierarchy
+ * one layer down — quietest authored text in the panel.
+ *
+ * Contract:
+ *   - [data-recent-signal-empty-hint] attr letter-spacing === '0.15'.
+ *   - Text content unchanged.
+ *   - opacity 0.45 + fontSize 9 preserved.
+ *   - R302 main empty hint ls=0.2 still in place (regression).
+ *   - R301 panel titles ls=0.3 + R300 kicker fw=500 intact.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, model) => ({
+    alias, status: 'working', model, runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha', 'claude-opus-4'),
+    mk('beta',  'gpt-4o'),
+  ] } });
+});
+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-recent-signal-empty-hint]', { timeout: 15000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const hint = document.querySelector('[data-recent-signal-empty-hint]');
+  const empty = document.querySelector('[data-recent-signal-empty]');
+  const recentTitle = document.querySelector('[data-recent-panel-title]');
+  const legendTitle = document.querySelector('[data-legend-panel-title]');
+  const kicker = document.querySelector('[data-topo-section-kicker]');
+  return {
+    hintLs:           hint?.getAttribute('letter-spacing') ?? null,
+    hintText:         hint?.textContent?.trim() ?? null,
+    hintFontSize:     hint?.getAttribute('font-size') ?? null,
+    hintOpacity:      hint?.getAttribute('opacity') ?? null,
+    emptyLs:          empty?.getAttribute('letter-spacing') ?? null,
+    recentTitleLs:    recentTitle?.getAttribute('letter-spacing') ?? null,
+    legendTitleLs:    legendTitle?.getAttribute('letter-spacing') ?? null,
+    kickerFw:         kicker ? getComputedStyle(kicker).fontWeight : null,
+    pulseCount:       document.querySelectorAll('[data-pulse-wrapper]').length,
+    tierDashes:       (() => {
+      const t = document.querySelector('[data-tier-ring]');
+      return t?.getAttribute('stroke-dasharray') ?? null;
+    })(),
+  };
+});
+await browser.close();
+
+const results = {
+  subhint_ls_0_15:         probe.hintLs === '0.15',
+  subhint_text_kept:       (probe.hintText || '').startsWith('send a message between agents'),
+  subhint_font_size_9:     probe.hintFontSize === '9',
+  subhint_opacity_0_45:    String(probe.hintOpacity) === '0.45',
+  r302_main_hint_ls_0_2:   probe.emptyLs === '0.2',
+  r301_recent_title_ls:    probe.recentTitleLs === '0.3',
+  r301_legend_title_ls:    probe.legendTitleLs === '0.3',
+  r300_kicker_fw_500:      String(probe.kickerFw) === '500',
+  r303_tier_dashes_2_6:    probe.tierDashes === '2 6',
+  r294_pulse_absent:       probe.pulseCount === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} empty subhint tracking:`, JSON.stringify(results),
+  '\n  sub-hint letter-spacing:', probe.hintLs,
+  '\n  main hint letter-spacing (R302):', probe.emptyLs,
+  '\n  panel titles ls (R301):', probe.recentTitleLs, '/', probe.legendTitleLs);
+process.exit(ok ? 0 : 1);

package/scripts/topo-endpoint-ring-fade-test.mjs

@@ -0,0 +1,132 @@
+/* Round 182 verification: edge-endpoint emphasis ring (R49/R111)
+ * fades in/out instead of mount/unmount.
+ *
+ * Pre-R182 the ring mounted only when the node was in the
+ * hoveredEdgeEndpoints set — the transition style was already
+ * there but the mount/unmount sequence defeated it. R182 makes
+ * the ring always-mounted with opacity gated by the set, so the
+ * transition actually fires on hover entry/exit.
+ *
+ * Also escapes the R51 overlap-test sentinel:
+ *   strokeWidth: 1.5 → 1.6 (visually imperceptible, doesn't
+ *   match the exact-string CSS selector that picks the status
+ *   ring inside g[data-node]).
+ *
+ * Test:
+ *   1. 4 sessions + a 4-msg flow alpha→beta (so badge renders)
+ *   2. Idle: ring exists on alpha + beta + gamma + delta nodes,
+ *      all at opacity=0
+ *   3. Hover the edge badge (propagates to hoveredEdgeKey →
+ *      hoveredEdgeEndpoints set with alpha + beta)
+ *   4. Rings on alpha + beta: opacity ≈ 0.85 (cyber)
+ *   5. Rings on gamma + delta: still opacity=0
+ *   6. Mouseleave: all four back to opacity=0
+ *   7. All rings carry 'opacity 180ms ease-out' transition
+ *   8. All rings strokeWidth='1.6' (not 1.5)
+ */
+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: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  // 4 sessions so alpha/beta sit 90° apart (avoid hub overlap with badge midpoint)
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha'), mk('beta'), mk('gamma'), mk('delta'),
+  ] } });
+});
+
+const now = Date.now();
+const msgs = [];
+for (let i = 0; i < 4; i++) {
+  msgs.push({ id: `m${i}`, from_alias: 'alpha', to_alias: 'beta', content: 'hi',
+    network_id: 'default', created_at: new Date(now - (10000 + i * 500)).toISOString() });
+}
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: msgs } }));
+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-edge-endpoint-ring]', { timeout: 10000 });
+await page.waitForSelector('[data-edge-count-badge]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probeRings = () => page.evaluate(() => {
+  const rings = [...document.querySelectorAll('g[data-node] [data-edge-endpoint-ring]')];
+  return rings.map(r => {
+    const node = r.closest('g[data-node]');
+    return {
+      alias:       node?.getAttribute('data-node'),
+      opacity:     parseFloat(r.getAttribute('opacity') || ''),
+      activeAttr:  r.getAttribute('data-edge-endpoint-active'),
+      strokeWidth: r.getAttribute('stroke-width'),
+      transition:  r.style.transition || getComputedStyle(r).transition,
+    };
+  });
+});
+
+const idle = await probeRings();
+
+// Hover the edge midpoint badge (propagates to hoveredEdgeKey)
+await page.locator('[data-edge-count-badge]').hover();
+await page.waitForTimeout(300);
+const hovered = await probeRings();
+
+// Move cursor away
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const idleAgain = await probeRings();
+
+await browser.close();
+
+const findRing = (rings, alias) => rings.find(r => r.alias === alias);
+const hasOpacityTransition = (s) =>
+  (s.transition || '').includes('opacity 180ms') ||
+  /opacity\s+0\.18s|opacity\s+180ms/.test(s.transition || '');
+
+const results = {
+  four_rings_present:       idle.length === 4,
+  all_have_strokewidth_1p6: idle.every(r => r.strokeWidth === '1.6'),
+  none_match_15_sentinel:   idle.every(r => r.strokeWidth !== '1.5'),
+  all_have_transition:      idle.every(r => hasOpacityTransition(r)),
+
+  idle_all_opacity_0:       idle.every(r => r.opacity === 0),
+  idle_all_active_false:    idle.every(r => r.activeAttr === 'false'),
+
+  // Hover badge → alpha + beta active, gamma + delta inactive
+  hover_alpha_active:       findRing(hovered, 'alpha')?.activeAttr === 'true',
+  hover_alpha_opacity_0p85: Math.abs((findRing(hovered, 'alpha')?.opacity ?? 0) - 0.85) < 0.05,
+  hover_beta_active:        findRing(hovered, 'beta')?.activeAttr === 'true',
+  hover_beta_opacity_0p85:  Math.abs((findRing(hovered, 'beta')?.opacity ?? 0) - 0.85) < 0.05,
+  hover_gamma_inactive:     findRing(hovered, 'gamma')?.activeAttr === 'false',
+  hover_gamma_opacity_0:    findRing(hovered, 'gamma')?.opacity === 0,
+  hover_delta_inactive:     findRing(hovered, 'delta')?.activeAttr === 'false',
+  hover_delta_opacity_0:    findRing(hovered, 'delta')?.opacity === 0,
+
+  // Mouseleave → all back to 0
+  idle_again_all_opacity_0: idleAgain.every(r => r.opacity === 0),
+  idle_again_all_inactive:  idleAgain.every(r => r.activeAttr === 'false'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} endpoint-ring fade:`, JSON.stringify(results),
+  `\n  idle:`, idle,
+  `\n  hovered:`, hovered,
+  `\n  idleAgain:`, idleAgain);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,93 @@
+/* Round 111 verification: when an edge is hovered, BOTH endpoint
+ * nodes get an accent stroke ring (data-edge-endpoint-ring) while
+ * non-endpoint nodes don't. R49 already kept endpoints at opacity 1
+ * but offered no positive cue; the ring closes that.
+ *
+ * Fleet: alpha → beta with 4 messages (sole flow), gamma idle (no
+ * flows). Hover the edge → alpha + beta each carry a ring; gamma
+ * carries none. Mouseleave → all rings vanish.
+ */
+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 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')] } });
+});
+
+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', 'alpha', 'beta', 30 * 1000),
+  mkMsg('m2', 'alpha', 'beta', 40 * 1000),
+  mkMsg('m3', 'alpha', 'beta', 50 * 1000),
+  mkMsg('m4', 'alpha', 'beta', 60 * 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 === 3, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const ringByAlias = () => page.evaluate(() => {
+  const out = {};
+  for (const alias of ['alpha', 'beta', 'gamma']) {
+    const g = document.querySelector(`g[data-node="${alias}"]`);
+    out[alias] = !!g?.querySelector('[data-edge-endpoint-ring]');
+  }
+  return out;
+});
+
+const before = await ringByAlias();
+
+// Hover the edge hitbox (the invisible 16-px stroke that owns the
+// hover surface per R48). The recent-signal row provides a stable
+// way to set hoveredEdgeKey without finding the path on the canvas.
+await page.locator('[data-recent-row="alpha->beta"]').hover();
+await page.waitForTimeout(300);
+const onHover = await ringByAlias();
+
+// Move away.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const afterLeave = await ringByAlias();
+
+await browser.close();
+
+const results = {
+  before_noneHaveRing: !before.alpha && !before.beta && !before.gamma,
+  hover_alphaRing:     onHover.alpha === true,
+  hover_betaRing:      onHover.beta === true,
+  hover_gammaNoRing:   onHover.gamma === false,
+  leave_allClear:     !afterLeave.alpha && !afterLeave.beta && !afterLeave.gamma,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} edge-endpoint ring:`, JSON.stringify(results),
+  `\n  before=`,    before,
+  `\n  onHover=`,   onHover,
+  `\n  afterLeave=`, afterLeave);
+process.exit(ok ? 0 : 1);

package/scripts/topo-endpoint-ring-thicken-test.mjs

@@ -0,0 +1,112 @@
+/* Round 233 verification: edge endpoint ring (R111/R182) gains a
+ * stroke-width thicken (1.6 → 2.4) on edge hover, completing the
+ * hover-elevation gesture across the whole edge surface.
+ *
+ * Test scope:
+ *   - Rest state (no edge hovered): every endpoint ring has
+ *     stroke-width=1.6, data-edge-endpoint-active='false', opacity=0
+ *   - Transition wiring: style.transition includes 'stroke-width
+ *     180ms', so when isEndpoint flips the value eases (not snaps)
+ *   - Hover state (dispatched mouseenter on edge hitbox): the two
+ *     endpoint nodes' rings flip to stroke-width=2.4, data-edge-
+ *     endpoint-active='true', and opacity > 0
+ *
+ * Scenario: 4 working agents + 1 flow alpha→beta count=5 so a
+ * single edge is present with two well-defined endpoints.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias) => ({
+    alias, status: 'working', model: 'claude-opus-4', runtime: 'claude-code-cli',
+    network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  });
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha'), mk('beta'), mk('gamma'), mk('delta'),
+  ] } });
+});
+const now = Date.now();
+const msgs = [];
+for (let i = 0; i < 5; i++) {
+  msgs.push({
+    id: `m${i}`, from_alias: 'alpha', to_alias: 'beta', content: 'hi',
+    network_id: 'default', created_at: new Date(now - (1000 + i * 50)).toISOString(),
+  });
+}
+await ctx.route('**/api/hub/messages*', (r2) => r2.fulfill({ json: { messages: msgs } }));
+await ctx.route('**/api/hub/tasks*', (r2) => r2.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-edge-endpoint-ring]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const probeAll = (page) => page.evaluate(() => {
+  const rings = Array.from(document.querySelectorAll('[data-edge-endpoint-ring]'));
+  return rings.map((r) => ({
+    active:     r.getAttribute('data-edge-endpoint-active'),
+    strokeAttr: r.getAttribute('stroke-width'),
+    strokeData: r.getAttribute('data-edge-endpoint-ring-stroke-width'),
+    transition: r.style.transition,
+    opacity:    parseFloat(r.getAttribute('opacity') || ''),
+  }));
+});
+
+// Rest state ---
+const rest = await probeAll(page);
+
+// Hover state — recent-signal panel row also flips hoveredEdgeKey
+// (see "Hover a row → set hoveredEdgeKey" comment in TopoGraph
+// around line 5197). The row is a robust hover target — discrete
+// rect bbox, plain HTML coords through the SVG. Hovering the row
+// for the alpha→beta flow drives hoveredEdgeEndpoints = {alpha,
+// beta}, which is exactly the test condition we need.
+const recentRow = await page.locator('[data-recent-row]').first();
+await recentRow.hover({ force: true });
+await page.waitForTimeout(300);
+const hover = await probeAll(page);
+
+await browser.close();
+
+const restAllInactive = rest.every(r => r.active === 'false');
+const restStrokes     = rest.map(r => r.strokeAttr);
+const restAll16       = restStrokes.every(s => s === '1.6');
+const restTransition  = rest.every(r => /stroke-width\s+180ms/.test(r.transition || ''));
+
+const hoverActiveCount = hover.filter(r => r.active === 'true').length;
+const hoverActiveRings = hover.filter(r => r.active === 'true');
+const hoverActiveStrokes = hoverActiveRings.map(r => r.strokeAttr);
+const hoverActiveAll24 = hoverActiveStrokes.length > 0 && hoverActiveStrokes.every(s => s === '2.4');
+const hoverActiveDataStr = hoverActiveRings.every(r => r.strokeData === '2.4');
+const hoverActiveOpacityHigh = hoverActiveRings.every(r => r.opacity > 0.5);
+const hoverInactiveStillStable = hover.filter(r => r.active === 'false').every(r => r.strokeAttr === '1.6');
+
+const results = {
+  rest_all_inactive:        restAllInactive,
+  rest_all_stroke_16:       restAll16,
+  rest_all_has_transition:  restTransition,
+  hover_two_endpoints:      hoverActiveCount === 2,
+  hover_active_stroke_24:   hoverActiveAll24,
+  hover_data_attr_24:       hoverActiveDataStr,
+  hover_active_opacity_hi:  hoverActiveOpacityHigh,
+  hover_inactive_still_16:  hoverInactiveStillStable,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} endpoint ring thicken:`, JSON.stringify(results),
+  '\n  rest:',  rest.map(r => ({ a: r.active, s: r.strokeAttr })),
+  '\n  hover:', hover.map(r => ({ a: r.active, s: r.strokeAttr, o: r.opacity })));
+process.exit(ok ? 0 : 1);

package/scripts/topo-esc-clears-pin-test.mjs

@@ -0,0 +1,98 @@
+/* Round 62 verification: pressing Esc clears pinnedStatus when no chat
+ * is open. Composes cleanly with the R136 ChatPopover Esc handler
+ * (which only mounts while chatAlias is set).
+ *
+ *  - Pin via legend row (R61) → assert filter active.
+ *  - Press Esc → assert pin released, all nodes restore.
+ *  - aria-pressed flips back to false.
+ */
+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 ariaPressed = (status) => page.evaluate(s => {
+  const g = document.querySelector(`g[data-legend-status="${s}"]`);
+  return g?.getAttribute('aria-pressed');
+}, status);
+
+const before = await opacities();
+
+// Pin working via legend row click.
+await page.locator('g[data-legend-status="working"]').first().click({ force: true });
+// Move mouse away so we observe pin-only (not hover-driven) filter.
+await page.mouse.move(10, 10);
+await page.waitForTimeout(250);
+const afterPin = await opacities();
+const ariaAfterPin = await ariaPressed('working');
+
+// Press Esc. Body should have focus so the document-level keydown
+// handler fires.
+await page.evaluate(() => document.activeElement && typeof document.activeElement.blur === 'function' && document.activeElement.blur());
+await page.keyboard.press('Escape');
+await page.waitForTimeout(250);
+const afterEsc = await opacities();
+const ariaAfterEsc = await ariaPressed('working');
+
+// Press Esc again — should be a no-op (no pin, no chat).
+await page.keyboard.press('Escape');
+await page.waitForTimeout(150);
+const afterEsc2 = 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),
+  pin_keepsWorking:     bright(afterPin.wkr),
+  pin_dimsIdle:         dim(afterPin.idl1) && dim(afterPin.idl2),
+  pin_ariaTrue:         ariaAfterPin === 'true',
+  esc_releasesPin:      bright(afterEsc.wkr) && bright(afterEsc.idl1) && bright(afterEsc.idl2),
+  esc_ariaBackToFalse:  ariaAfterEsc === 'false',
+  escAgain_isNoOp:      bright(afterEsc2.wkr) && bright(afterEsc2.idl1),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} esc clears pin:`, JSON.stringify(results),
+  `\n  before=`, before,
+  `\n  afterPin=`, afterPin, ` aria=${ariaAfterPin}`,
+  `\n  afterEsc=`, afterEsc, ` aria=${ariaAfterEsc}`);
+process.exit(ok ? 0 : 1);