@sleep2agi/agent-network-dashboard 0.4.6-preview.3 → 0.4.6-preview.301

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

@@ -0,0 +1,88 @@
+/* Round 95 verification: legend rows show live counts. Fleet = 3
+ * working + 2 idle + 1 offline. Each row's data-legend-count
+ * attribute matches the expected number. Pinning a row brightens
+ * its count alongside the label.
+ *
+ * The count is right-aligned at x=215 (after the flow-arrow swatch
+ * which spans x=140-196 on the offline row), pointerEvents:none so
+ * the row's R55 hover affordance still hits.
+ */
+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');
+    sessionStorage.removeItem('anet-topo-pinned-status');
+  } 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 mk = (alias, status, ts) => ({
+    alias, status, model: 'claude-opus-4', runtime: 'cli-claude-code',
+    network_id: nid, project_dir: null,
+    created_at: ts, updated_at: ts, last_seen_at: ts,
+  });
+  const sessions = [
+    mk('wkr1', 'working', fresh),
+    mk('wkr2', 'working', fresh),
+    mk('wkr3', 'working', fresh),
+    mk('idl1', 'idle',    fresh),
+    mk('idl2', 'idle',    fresh),
+    mk('off1', 'offline', 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 === 6, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const counts = () => page.evaluate(() => ({
+  working: document.querySelector('[data-legend-count="working"]')?.textContent,
+  idle:    document.querySelector('[data-legend-count="idle"]')?.textContent,
+  offline: document.querySelector('[data-legend-count="offline"]')?.textContent,
+}));
+const opacities = () => page.evaluate(() => ({
+  working: +(document.querySelector('[data-legend-count="working"]')?.getAttribute('opacity') || '0'),
+  idle:    +(document.querySelector('[data-legend-count="idle"]')?.getAttribute('opacity') || '0'),
+  offline: +(document.querySelector('[data-legend-count="offline"]')?.getAttribute('opacity') || '0'),
+}));
+
+const c = await counts();
+const opsRest = await opacities();
+
+// Pin the working row — its count should brighten.
+await page.locator('[data-legend-status="working"]').click();
+await page.waitForTimeout(250);
+const opsPinned = await opacities();
+
+await browser.close();
+
+const results = {
+  workingCount_3:        c.working === '3',
+  idleCount_2:           c.idle === '2',
+  offlineCount_1:        c.offline === '1',
+  resting_dim:           opsRest.working < 0.7 && opsRest.idle < 0.7 && opsRest.offline < 0.7,
+  pinnedWorking_bright:  opsPinned.working >= 0.9,
+  pinnedWorking_othersUnchanged: opsPinned.idle < 0.7 && opsPinned.offline < 0.7,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend counts:`, JSON.stringify(results),
+  `\n  counts=`,      c,
+  `\n  opsRest=`,     opsRest,
+  `\n  opsPinned=`,   opsPinned);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-count-tier-fill-test.mjs

@@ -0,0 +1,121 @@
+/* Round 239 verification: legend count text fill picks up the
+ * row's tier colour on hover/pin, completing the hover-deepen-own-
+ * hue idiom for the legend row triple (swatch + label + count).
+ *
+ * Pre-R239 the count digit had opacity 0.65→0.95 on hover but
+ * stayed at pal.legendText (neutral gray) for fill. The swatch
+ * (R197 grow) and label (R55 brighten) both reacted to hover with
+ * tier-identity signals; only the count stayed gray. R239 adds
+ * fill transition to row.fill (green/teal/slate) on hover so the
+ * row reads as one tier-coloured unit.
+ *
+ * Empty tiers (row.count === 0) stay at pal.legendText regardless
+ * of hover — empty doesn't get to claim tier identity.
+ *
+ * Test scope:
+ *   - rest state: count fill === neutral (pal.legendText)
+ *   - hover state (Playwright .hover() on the legend row <g>):
+ *     count fill === row.fill (tier colour)
+ *   - data-legend-count-fill attr flips 'neutral' ↔ 'tier'
+ *   - transition list includes both opacity AND fill at 150ms
+ *
+ * Scenario: 4 working agents → working tier has count=4 (populated),
+ * idle + offline tiers stay at 0 (empty, never tier-coloured).
+ * Hover the working legend row, verify only that row's count
+ * flips to tier colour.
+ */
+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-count="working"]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const probeCount = (page, tier) => page.evaluate((t) => {
+  const text = document.querySelector(`[data-legend-count="${t}"]`);
+  if (!text) return null;
+  const cs = getComputedStyle(text);
+  return {
+    fillAttr:   text.getAttribute('fill'),
+    fillComp:   cs.fill,
+    empty:      text.getAttribute('data-legend-count-empty'),
+    fillState:  text.getAttribute('data-legend-count-fill'),
+    transition: cs.transition,
+    text:       (text.textContent || '').trim(),
+  };
+}, tier);
+
+// REST STATE — no hover
+const rest = await probeCount(page, 'working');
+
+// HOVER STATE — hover the working legend row group
+await page.locator('[data-legend-status="working"]').first().hover({ force: true });
+await page.waitForTimeout(400);
+const hover = await probeCount(page, 'working');
+
+// Idle tier is empty in this scenario — should stay neutral even
+// when hovered. Hover the idle row to confirm the empty-tier
+// exclusion holds.
+await page.locator('[data-legend-status="idle"]').first().hover({ force: true });
+await page.waitForTimeout(400);
+const idleHover = await probeCount(page, 'idle');
+
+await browser.close();
+
+// Browser normalises '150ms' → '0.15s' in computed-style transitions.
+// Accept either form.
+const hasTransition = (s, prop) => new RegExp(`${prop}\\s+(?:150ms|0\\.15s)`).test(s || '');
+// Cyber theme working tier fill is #22c55e = rgb(34, 197, 94)
+const tierColorRgb = 'rgb(34, 197, 94)';
+// Cyber theme legendText (pal.legendText for dark palette) = #94a3b8 = rgb(148, 163, 184)
+const neutralRgb = 'rgb(148, 163, 184)';
+
+const results = {
+  rest_present:               rest !== null,
+  rest_fill_state_neutral:    rest?.fillState === 'neutral',
+  rest_fill_is_neutral:       rest?.fillComp === neutralRgb,
+  rest_text_is_4:             rest?.text === '4',
+  rest_transition_has_fill:   hasTransition(rest?.transition, 'fill'),
+  rest_transition_has_opacity: hasTransition(rest?.transition, 'opacity'),
+
+  hover_fill_state_tier:      hover?.fillState === 'tier',
+  hover_fill_is_tier:         hover?.fillComp === tierColorRgb,
+  hover_text_is_4:            hover?.text === '4',
+
+  // Empty tier (idle, count=0) stays neutral even on hover
+  idle_empty:                 idleHover?.empty === 'true',
+  idle_stays_neutral:         idleHover?.fillState === 'neutral',
+  idle_fill_still_neutral:    idleHover?.fillComp === neutralRgb,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend count tier fill:`, JSON.stringify(results),
+  '\n  rest:     ', rest,
+  '\n  hover:    ', hover,
+  '\n  idleHover:', idleHover);
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-header-symmetric-inset-test.mjs

@@ -0,0 +1,112 @@
+/* Round 257 verification: legend panel header symmetric 13L/13R inner-
+ * padding, matching the recent-signal panel pattern.
+ *
+ * Pre-R257 the two corner panels had inconsistent header inner-padding:
+ *
+ *   Recent-signal panel (width 230):
+ *     · "recent signal" at x=13   → 13px left inset
+ *     · "{N} flows ..." at x=217  → 13px right inset (end-anchored)
+ *     → 13L / 13R · symmetric ✅
+ *
+ *   Legend panel (width 224):
+ *     · "legend"        at x=13   → 13px left inset
+ *     · "{N} nodes"     at x=215  → 9px right inset (end-anchored)
+ *     → 13L / 9R · asymmetric ❌
+ *
+ * R257 changes legend header count x=215 → x=211 (= 224-13), so the
+ * legend panel header now reads 13L / 13R, matching recent-signal.
+ *
+ * The per-row count text at x=215 (offline-row level, line ~6321)
+ * stays — it's paired with the flow-arrow swatch geometry
+ * (path "M140,80 Q164,56 196,80" + marker tip ≈ x=202). Moving the
+ * row-level count to x=211 would tighten the swatch→count gap from
+ * 13px to 9px, visibly pinching the indicator. R257 only adjusts the
+ * standalone header count.
+ *
+ * Test scope:
+ *   1. Legend "legend" title x === 13.
+ *   2. Legend "{N} nodes" header count x === 211 (was 215).
+ *   3. Recent-signal title x === 13 (regression).
+ *   4. Recent-signal flow-count tspan parent <text> x === 217 (regression).
+ *   5. Legend row count (offline) x === 215 — UNCHANGED (paired with
+ *      flow-arrow swatch).
+ */
+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-panel-count]',                  { timeout: 10000 });
+await page.waitForSelector('[data-recent-panel-count]',                  { timeout: 10000 });
+await page.waitForSelector('[data-legend-status="offline"] [data-legend-count="offline"]', { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  // Legend panel
+  const legendPanelG = document.querySelector('[data-topo-panel="legend"]');
+  const legendRectW = +legendPanelG?.querySelector('rect').getAttribute('width');
+  const legendTitle = [...legendPanelG.querySelectorAll('text')].find(t => t.textContent.trim() === 'legend');
+  const legendCount = document.querySelector('[data-legend-panel-count]');
+  // Recent-signal panel
+  const recentPanelG = document.querySelector('[data-topo-panel="recent"]');
+  const recentRectW = +recentPanelG?.querySelector('rect').getAttribute('width');
+  const recentTitle = [...recentPanelG.querySelectorAll('text')].find(t => t.textContent.trim().startsWith('recent signal'));
+  const recentFlowCount = document.querySelector('[data-recent-panel-count]');
+  // Recent flow count tspan's parent <text> carries the x attr
+  const recentFlowCountParentX = recentFlowCount ? recentFlowCount.parentElement.getAttribute('x') : null;
+  // Legend offline-row count (unchanged @ x=215)
+  const legendOfflineCount = document.querySelector('[data-legend-count="offline"]');
+  return {
+    legendRectW, recentRectW,
+    legendTitleX:        legendTitle  ? +legendTitle.getAttribute('x')  : null,
+    legendCountX:        legendCount  ? +legendCount.getAttribute('x')  : null,
+    recentTitleX:        recentTitle  ? +recentTitle.getAttribute('x')  : null,
+    recentFlowCountX:    recentFlowCountParentX ? +recentFlowCountParentX : null,
+    legendOfflineCountX: legendOfflineCount ? +legendOfflineCount.getAttribute('x') : null,
+  };
+});
+await browser.close();
+
+const results = {
+  legend_title_x_is_13:               probe.legendTitleX === 13,
+  legend_count_x_moved_to_211:        probe.legendCountX === 211,
+  legend_symmetric_inset_13L_13R:     probe.legendRectW != null && probe.legendCountX != null &&
+                                       probe.legendTitleX === 13 &&
+                                       (probe.legendRectW - probe.legendCountX) === 13,
+  recent_title_x_is_13_unchanged:     probe.recentTitleX === 13,
+  recent_flow_count_x_217_unchanged:  probe.recentFlowCountX === 217,
+  recent_symmetric_inset_13L_13R:     probe.recentRectW != null && probe.recentFlowCountX != null &&
+                                       (probe.recentRectW - probe.recentFlowCountX) === 13,
+  legend_offline_count_x_215_unchanged: probe.legendOfflineCountX === 215,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend header symmetric inset:`, JSON.stringify(results),
+  '\n  legend  rect_w=', probe.legendRectW, ' title_x=', probe.legendTitleX, ' count_x=', probe.legendCountX,
+  '\n  recent  rect_w=', probe.recentRectW, ' title_x=', probe.recentTitleX, ' flow_count_x=', probe.recentFlowCountX,
+  '\n  legend  offline_count_x=', probe.legendOfflineCountX, '(should stay 215)');
+process.exit(ok ? 0 : 1);

package/scripts/topo-legend-hitbox-swatch-center-test.mjs

@@ -0,0 +1,93 @@
+/* Round 271 verification: legend row hitbox centers exactly on the
+ * swatch dot's cy.
+ *
+ * Pre-R271:
+ *   Hitbox y = row.y0 - 12, height = 22 → center at row.y0 - 1
+ *   Swatch cy = row.y0
+ *   ⇒ Swatch sits 1 px above hitbox center (asymmetric tint band)
+ *
+ * Post-R271:
+ *   Hitbox y = row.y0 - 11, height = 22 → center at row.y0
+ *   Swatch cy = row.y0
+ *   ⇒ Swatch sits exactly at hitbox center (symmetric tint band)
+ *
+ * Test scope:
+ *   1. Hover the working row → tint rect appears (data-legend-row-tinted='hover').
+ *   2. Tinted rect's getBBox.y === row.y0 - 11 (for working row.y0=32 → y=21).
+ *   3. Tinted rect's getBBox.height === 22 (unchanged).
+ *   4. Tinted rect's vertical center === swatch cy.
+ *   5. R270 fullscreen inactive cyan hover regression 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) => ({
+    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*', (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-status="working"]', { timeout: 10000 });
+await page.waitForSelector('[data-legend-swatch="working"]', { timeout: 10000 });
+await page.waitForSelector('[data-topo-chrome-fullscreen]',  { timeout: 10000 });
+await page.waitForTimeout(300);
+
+// Hover the working row to force the tint rect to render
+await page.locator('[data-legend-status="working"]').hover();
+await page.waitForTimeout(250);
+
+const probe = await page.evaluate(() => {
+  const row = document.querySelector('[data-legend-status="working"]');
+  if (!row) return null;
+  // The hitbox rect is the FIRST <rect> inside the row group
+  const rect = row.querySelector('rect');
+  const swatch = row.querySelector('[data-legend-swatch="working"]');
+  const fullscreen = document.querySelector('[data-topo-chrome-fullscreen]');
+  return {
+    rectY:      rect    ? +rect.getAttribute('y')      : null,
+    rectHeight: rect    ? +rect.getAttribute('height') : null,
+    rectTinted: rect    ? rect.getAttribute('data-legend-row-tinted') : null,
+    swatchCy:   swatch  ? +swatch.getAttribute('cy')   : null,
+    fullscreenClasses: fullscreen ? fullscreen.className.toString() : null,
+  };
+});
+await browser.close();
+
+const rectCenter = (probe.rectY != null && probe.rectHeight != null) ? probe.rectY + probe.rectHeight / 2 : null;
+const centerMatchesSwatch = (rectCenter != null && probe.swatchCy != null) && rectCenter === probe.swatchCy;
+
+const results = {
+  rect_y_is_21:          probe.rectY === 21,
+  rect_height_22:        probe.rectHeight === 22,
+  rect_tinted_on_hover:  probe.rectTinted === 'hover',
+  swatch_cy_32:          probe.swatchCy === 32,
+  rect_center_matches_swatch: centerMatchesSwatch,
+  r270_fullscreen_inactive_cyan: (probe.fullscreenClasses || '').includes('hover:bg-cyan-500/5'),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} legend hitbox swatch center:`, JSON.stringify(results),
+  '\n  rect y/height:', probe.rectY, probe.rectHeight, '(center', rectCenter, ')',
+  '\n  swatch cy:', probe.swatchCy,
+  '\n  rect tinted:', probe.rectTinted);
+process.exit(ok ? 0 : 1);

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