@sleep2agi/agent-network-dashboard 0.5.3-preview.26 → 0.5.3-preview.260

package/app/lib/serverDedupe.ts

@@ -0,0 +1,122 @@
+/**
+ * #157 RC#2 — host telemetry row dedup for the Servers panel.
+ *
+ * The CommHub /api/servers endpoint keys host telemetry by (hostname,
+ * ip): a machine whose agents report over more than one interface
+ * yields one row per IP. Live data caught `iZrj93pr2rcf5r2y9uo1oyZ`
+ * twice — once at the Docker-bridge IP (carrying cpu/mem telemetry)
+ * and once at loopback (telemetry null) — so the panel showed the same
+ * physical host as two cards with split agent counts.
+ *
+ * Extracted from the /api/hub/servers route handler so the merge can
+ * be unit-tested against a mock fixture independently of the proxy.
+ */
+
+export interface HubServerRow {
+  hostname: string;
+  ip?: string | null;
+  agent_count?: number;
+  cpu_load_1min?: number | null;
+  cpu_cores?: number | null;
+  mem_used_gb?: number | null;
+  mem_total_gb?: number | null;
+  mem_avail_gb?: number | null;
+  disk_used_gb?: number | null;
+  disk_total_gb?: number | null;
+  cpu_history?: number[];
+  mem_history?: number[];
+  agents?: unknown[];
+  last_seen?: string | null;
+  status?: 'online' | 'offline';
+  note?: string;
+}
+
+/**
+ * Parse a hub timestamp to epoch ms. CommHub reports last_seen as
+ * "YYYY-MM-DD HH:MM:SS" (space-separated, no timezone) — treat as UTC
+ * so all clients agree regardless of local zone. ISO 8601 with an
+ * explicit offset also parses cleanly (the +'Z' is only appended when
+ * no zone is present). Returns NaN for missing / unparseable input.
+ */
+export function parseHubTime(ts: string | null | undefined): number {
+  if (!ts) return NaN;
+  const iso = ts.includes('T') ? ts : ts.replace(' ', 'T');
+  const withTz = /[zZ]|[+-]\d{2}:?\d{2}$/.test(iso) ? iso : iso + 'Z';
+  return Date.parse(withTz);
+}
+
+/**
+ * Collapse rows that share a hostname into one card.
+ *
+ * Dedup keys on hostname, not IP: a hostname is the machine identity,
+ * whereas an IP can be shared across hosts behind NAT (two distinct
+ * hostnames can surface as the same public IP) or differ per interface
+ * on one host. Merge rule for a multi-row hostname:
+ *   - agent_count  = sum across rows (one host's total fan-out)
+ *   - telemetry    = freshest-non-null per field — walk rows newest
+ *                    last_seen first, take the first row that actually
+ *                    reports each field, so a stale-but-telemetried row
+ *                    still contributes cpu/mem when the freshest row's
+ *                    values are null
+ *   - last_seen    = newest across rows
+ *   - agents[]     = union, dedup by alias
+ *
+ * Sentinel hostnames that are not real identities — empty or the
+ * literal "unknown" the hub emits when an agent never resolved its
+ * host — are passed through untouched: merging two distinct unknown
+ * machines into one card would be worse than showing both.
+ */
+export function dedupeByHostname(rows: HubServerRow[]): HubServerRow[] {
+  const groups = new Map<string, HubServerRow[]>();
+  const passthrough: HubServerRow[] = [];
+  for (const row of rows) {
+    const h = row.hostname;
+    if (!h || h === 'unknown') { passthrough.push(row); continue; }
+    const bucket = groups.get(h) ?? [];
+    bucket.push(row);
+    groups.set(h, bucket);
+  }
+  const merged: HubServerRow[] = [];
+  for (const bucket of groups.values()) {
+    if (bucket.length === 1) { merged.push(bucket[0]); continue; }
+    // Freshest last_seen first. NaN (missing timestamp) sorts last.
+    const sorted = [...bucket].sort((a, b) => {
+      const ta = parseHubTime(a.last_seen), tb = parseHubTime(b.last_seen);
+      return (Number.isNaN(tb) ? -Infinity : tb) - (Number.isNaN(ta) ? -Infinity : ta);
+    });
+    const coalesce = <K extends keyof HubServerRow>(key: K): HubServerRow[K] | undefined => {
+      for (const r of sorted) {
+        const v = r[key];
+        if (v != null) return v;
+      }
+      return undefined;
+    };
+    const agentMap = new Map<string, unknown>();
+    for (const r of sorted) {
+      if (!Array.isArray(r.agents)) continue;
+      for (const a of r.agents) {
+        const key = (a as { alias?: string })?.alias ?? JSON.stringify(a);
+        if (!agentMap.has(key)) agentMap.set(key, a);
+      }
+    }
+    merged.push({
+      hostname: sorted[0].hostname,
+      ip: coalesce('ip') ?? null,
+      agent_count: bucket.reduce((sum, r) => sum + (r.agent_count ?? 0), 0),
+      cpu_load_1min: coalesce('cpu_load_1min') ?? null,
+      cpu_cores: coalesce('cpu_cores') ?? null,
+      mem_used_gb: coalesce('mem_used_gb') ?? null,
+      mem_total_gb: coalesce('mem_total_gb') ?? null,
+      mem_avail_gb: coalesce('mem_avail_gb') ?? null,
+      disk_used_gb: coalesce('disk_used_gb') ?? null,
+      disk_total_gb: coalesce('disk_total_gb') ?? null,
+      cpu_history: coalesce('cpu_history'),
+      mem_history: coalesce('mem_history'),
+      agents: agentMap.size > 0 ? [...agentMap.values()] : undefined,
+      last_seen: coalesce('last_seen') ?? null,
+      status: coalesce('status'),
+      note: coalesce('note'),
+    });
+  }
+  return [...merged, ...passthrough];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/agent-network-dashboard",
-  "version": "0.5.3-preview.26",
+  "version": "0.5.3-preview.260",
   "description": "Agent Network Dashboard \u2014 Web UI for managing AI Agent networks",
   "scripts": {
     "dev": "next dev",

package/scripts/p157-rc2-dedup-test.mjs

@@ -0,0 +1,110 @@
+/* #157 RC#2 verification — Servers panel hostname dedup.
+ *
+ * Bug (Vincent 5560 + live re-probe 2026-05-20): the hub /api/servers
+ * endpoint keys host telemetry by (hostname, ip), so a machine whose
+ * agents report over more than one interface surfaces as multiple
+ * rows. `iZrj93pr2rcf5r2y9uo1oyZ` appeared twice — Docker-bridge IP
+ * (telemetry-bearing) + loopback (telemetry null) — splitting its
+ * agent count across two cards.
+ *
+ * Fix: `dedupeByHostname` in app/lib/serverDedupe.ts, applied in the
+ * /api/hub/servers proxy before normalizeServer.
+ *
+ * Two legs:
+ *   A. mock fixture — compile serverDedupe.ts, run a crafted payload
+ *      that exercises every branch (multi-row merge, telemetry
+ *      coalesce, NAT-shared IP NOT merged, `unknown` passthrough,
+ *      agents[] union).
+ *   B. real payload — GET the running dashboard proxy and assert no
+ *      hostname appears twice + counts are summed.
+ */
+import { execSync } from 'node:child_process';
+import { readFileSync, renameSync, mkdirSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+let failed = 0;
+const ok = (name, cond, detail = '') => {
+  if (cond) { console.log(`  ✅ ${name}`); }
+  else { console.log(`  ❌ ${name}${detail ? ' — ' + detail : ''}`); failed++; }
+};
+
+// ── Leg A: mock fixture against the real dedup module ──────────────
+console.log('Leg A — mock fixture (compiled serverDedupe.ts):');
+const OUT = '/tmp/p157-rc2-dedupe';
+mkdirSync(OUT, { recursive: true });
+execSync(
+  `npx tsc app/lib/serverDedupe.ts --outDir ${OUT} --module es2022 --target es2022 --moduleResolution bundler --skipLibCheck`,
+  { stdio: 'inherit' },
+);
+renameSync(`${OUT}/serverDedupe.js`, `${OUT}/serverDedupe.mjs`);
+const { dedupeByHostname } = await import(pathToFileURL(`${OUT}/serverDedupe.mjs`).href);
+
+const fixture = [
+  // same hostname, two interfaces — bridge row fresh + telemetried,
+  // loopback row staler + telemetry null
+  { hostname: 'host-A', ip: '172.17.0.2', agent_count: 29, last_seen: '2026-05-20 04:41:46',
+    cpu_load_1min: 1.49, cpu_cores: 8, mem_used_gb: 22.6, mem_total_gb: 32,
+    agents: [{ alias: 'a1' }, { alias: 'a2' }] },
+  { hostname: 'host-A', ip: '127.0.0.1', agent_count: 38, last_seen: '2026-05-20 04:41:43',
+    cpu_load_1min: null, mem_used_gb: null,
+    agents: [{ alias: 'a2' }, { alias: 'a3' }] },
+  // NAT-shared public IP, distinct hostnames — must NOT merge
+  { hostname: 'host-B', ip: '223.167.142.73', agent_count: 5, last_seen: '2026-05-18 02:34:16' },
+  { hostname: 'host-C', ip: '223.167.142.73', agent_count: 2, last_seen: '2026-05-13 16:44:41' },
+  // sentinel hostname — two distinct unknown machines, pass through both
+  { hostname: 'unknown', ip: '127.0.0.1', agent_count: 2, last_seen: '2026-05-16 08:40:14' },
+  { hostname: 'unknown', ip: '10.0.0.9', agent_count: 1, last_seen: '2026-05-16 09:00:00' },
+];
+const out = dedupeByHostname(fixture);
+const byHost = (h) => out.filter(r => r.hostname === h);
+const hostA = byHost('host-A')[0];
+
+ok('host-A collapses 2 rows → 1', byHost('host-A').length === 1, `got ${byHost('host-A').length}`);
+ok('host-A agent_count summed 29+38=67', hostA?.agent_count === 67, `got ${hostA?.agent_count}`);
+ok('host-A telemetry coalesced from bridge row (cpu 1.49)', hostA?.cpu_load_1min === 1.49, `got ${hostA?.cpu_load_1min}`);
+ok('host-A mem coalesced (22.6)', hostA?.mem_used_gb === 22.6, `got ${hostA?.mem_used_gb}`);
+ok('host-A last_seen = freshest (04:41:46)', hostA?.last_seen === '2026-05-20 04:41:46', `got ${hostA?.last_seen}`);
+ok('host-A agents[] unioned + dedup by alias (a1,a2,a3)',
+  hostA?.agents?.length === 3 &&
+  new Set(hostA.agents.map(a => a.alias)).size === 3,
+  `got ${JSON.stringify(hostA?.agents)}`);
+ok('host-B + host-C NOT merged despite shared IP', byHost('host-B').length === 1 && byHost('host-C').length === 1);
+ok('two `unknown` rows both pass through (not merged)', byHost('unknown').length === 2, `got ${byHost('unknown').length}`);
+ok('total rows: 1 (A) + 1 (B) + 1 (C) + 2 (unknown) = 5', out.length === 5, `got ${out.length}`);
+
+// idempotency — running dedup on already-deduped output is a no-op
+const twice = dedupeByHostname(out);
+ok('idempotent — dedup(dedup(x)) === dedup(x)', twice.length === out.length);
+
+// ── Leg B: real payload through the running dashboard proxy ─────────
+console.log('\nLeg B — real payload (live /api/hub/servers proxy):');
+let TOKEN;
+try {
+  TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+} catch {
+  console.log('  ⚠️  no anet config — skipping live leg');
+}
+if (TOKEN) {
+  const res = await fetch('http://127.0.0.1:3000/api/hub/servers', {
+    headers: { cookie: `anet_dashboard_session=v3:${TOKEN}` },
+  });
+  ok('proxy returns 200', res.status === 200, `status ${res.status}`);
+  const body = await res.json();
+  const servers = body.servers ?? [];
+  ok('proxy returns servers[]', Array.isArray(servers) && servers.length > 0, `got ${servers.length}`);
+  const counts = {};
+  for (const s of servers) counts[s.hostname] = (counts[s.hostname] ?? 0) + 1;
+  const dups = Object.entries(counts).filter(([h, n]) => n > 1 && h !== 'unknown' && h !== '');
+  ok('no real hostname appears twice', dups.length === 0, `dups: ${JSON.stringify(dups)}`);
+  const izrj = servers.find(s => s.hostname?.startsWith('iZrj93pr'));
+  if (izrj) {
+    ok('iZrj93pr… host present as single card', true);
+    ok('iZrj93pr… has telemetry after coalesce (cpu non-null)', izrj.cpu_load_1min != null, `cpu ${izrj.cpu_load_1min}`);
+    console.log(`  ℹ️  iZrj93pr… merged: agent_count=${izrj.agent_count}, cpu=${izrj.cpu_load_1min}, ip=${izrj.ip}`);
+  } else {
+    console.log('  ℹ️  iZrj93pr… not in current live payload (hub state changed) — structural dup check still authoritative');
+  }
+}
+
+console.log(`\n${failed === 0 ? '✅ ALL GREEN' : `❌ ${failed} FAILED`}`);
+process.exit(failed === 0 ? 0 : 1);

package/scripts/topo-a11y-titles-catalog-test.mjs

@@ -0,0 +1,132 @@
+/* Round 732 — a11y titles catalog on canvas root. 7TH orthogonal
+ * meta-doc axis. The introspection layer crosses families:
+ *
+ *   Breath family (6 meta-docs):
+ *     R710 data-topo-respiratory-rolodex              (cadences)
+ *     R716 data-topo-respiratory-dual-axis-surfaces   (axes)
+ *     R717 data-topo-respiratory-patterns             (patterns)
+ *     R720 data-topo-respiratory-tiers                (tiers)
+ *     R723 data-topo-respiratory-triple-axis-surfaces (triple-axis)
+ *     R729 data-topo-respiratory-axis-count-stats     (stats)
+ *
+ *   A11y sub-family (1 meta-doc):
+ *     R732 data-topo-a11y-titles                      (accessible names) ← this round
+ *
+ * Each entry maps surface → DOM selector → accessible name. The test
+ * resolves each selector at runtime and verifies the element's direct
+ * <title> child textContent matches the catalog's accessible_name.
+ *
+ * Assertions:
+ *   - attr present on root <svg>
+ *   - JSON parses to Array of 5 entries (R730: 3, R731: 2)
+ *   - Each entry has {surface, selector, accessible_name} shape with
+ *     non-empty string values
+ *   - Each accessible_name follows canonical "<name> · <role>" format
+ *   - Each selector resolves at runtime to an element (or null IF
+ *     conditionally rendered, treated as pass for the cross-check)
+ *   - When element exists, its direct <title> child's textContent
+ *     equals catalog's accessible_name (STRICT cross-check)
+ *   - All 5 surfaces are present in the expected anchor set
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1200 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try {
+    localStorage.setItem('anet-theme', 'cyber');
+    localStorage.setItem('anet-topo-layout', 'ring');
+    sessionStorage.setItem('anet_v3_auth', '1');
+  } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias) => ({
+    alias, status: 'idle', model: 'claude-opus-4', runtime: '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('a·1'), mk('a·2')] } });
+});
+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: 'networkidle' });
+await page.waitForSelector('[data-topo-canvas-aria]', { timeout: 15000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const result = await page.evaluate(() => {
+  const svg = document.querySelector('[data-topo-canvas-aria]');
+  const catalogAttr = svg?.getAttribute('data-topo-a11y-titles') ?? null;
+  let catalog = null;
+  try { catalog = JSON.parse(catalogAttr ?? ''); } catch {}
+
+  /* Direct child <title> only — skip nested titles in mask defs etc. */
+  const directTitleText = (el) => {
+    if (!el) return null;
+    for (const child of el.children) {
+      if (child.tagName.toLowerCase() === 'title') return child.textContent;
+    }
+    return null;
+  };
+
+  const crossChecks = Array.isArray(catalog)
+    ? catalog.map(entry => {
+        const el = document.querySelector(entry.selector);
+        return {
+          surface: entry.surface,
+          element_present: !!el,
+          actual_title: directTitleText(el),
+          matches: !el || directTitleText(el) === entry.accessible_name,
+        };
+      })
+    : [];
+
+  return { catalogAttr, catalog, crossChecks };
+});
+
+await browser.close();
+
+const { catalog, crossChecks } = result;
+
+const validShape = Array.isArray(catalog) && catalog.every(e =>
+  typeof e?.surface === 'string' && e.surface.length > 0
+  && typeof e?.selector === 'string' && e.selector.length > 0
+  && typeof e?.accessible_name === 'string' && e.accessible_name.length > 0
+);
+
+/* R733 relaxed canonical-format from "exactly 2 parts" to ">=2 parts"
+ * to admit the new hub-highlight entry's 3-part name ("hub · network
+ * center · idle indicator"). All earlier entries still match. */
+const canonicalFormat = (s) => typeof s === 'string' && /^[^·]+( · [^·]+)+$/.test(s);
+const allCanonical = Array.isArray(catalog) && catalog.every(e => canonicalFormat(e.accessible_name));
+
+const expectedSurfaces = ['canvas scan beam', 'canvas scan beam diagonal', 'canvas scan beam vertical', 'canvas-corner crescent', 'hub-highlight disc', 'legend panel title', 'recent panel title', 'title-block brand logo', 'watermark text'];
+const actualSurfaces = Array.isArray(catalog) ? catalog.map(e => e.surface).sort() : [];
+const surfacesMatch = JSON.stringify(actualSurfaces) === JSON.stringify(expectedSurfaces);
+
+const allCrossChecks = crossChecks.every(c => c.matches);
+
+const results = {
+  attr_present:                       !!result.catalogAttr,
+  json_parses:                        catalog !== null,
+  is_array:                           Array.isArray(catalog),
+  has_9_entries:                      Array.isArray(catalog) && catalog.length === 9,
+  shape_valid:                        validShape,
+  all_accessible_names_canonical:     allCanonical,
+  surfaces_match_expected_set:        surfacesMatch,
+  all_cross_checks_pass:              allCrossChecks,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} R732 a11y titles catalog (7th meta-doc — pentagon→hexagon→HEPTAGON, cross-family):`,
+  JSON.stringify(results, null, 2),
+  `\n  catalog: ${JSON.stringify(catalog)}`,
+  `\n  cross-checks: ${JSON.stringify(crossChecks)}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-active-chrome-hover-text-test.mjs

@@ -0,0 +1,107 @@
+/* Round 552 verification: chrome active-variant buttons gain
+ * hover:text-cyan-200 lift. Coordinated 4-anchor edit:
+ *   Ring | Grid | S/M/L | Fullscreen
+ *
+ * Test phases:
+ *   1. Pick an active button (Ring is active by default in ring layout)
+ *   2. Read rest text color (cyan-300 = rgb(103, 232, 249))
+ *   3. Hover → text color = cyan-200 (rgb(165, 243, 252))
+ *   4. Verify bg also deepened (cyan-500/20)
+ *   5. Source-side regex: 4 occurrences of the new className substring
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1200 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try {
+    localStorage.setItem('anet-theme', 'cyber');
+    localStorage.setItem('anet-topo-layout', 'ring');
+    sessionStorage.setItem('anet_v3_auth', '1');
+  } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias) => ({
+    alias, status: 'idle', model: 'claude-opus-4', runtime: '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('a·1')] } });
+});
+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: 'networkidle' });
+await page.waitForSelector('[data-topo-chrome-layout="ring"]', { timeout: 15000 });
+await page.waitForTimeout(500);
+
+// Ring is active in ring layout
+const sel = '[data-topo-chrome-layout="ring"]';
+const rest = await page.evaluate((s) => {
+  const el = document.querySelector(s);
+  if (!el) return null;
+  const cs = getComputedStyle(el);
+  return {
+    color: cs.color,
+    bg:    cs.backgroundColor,
+    activeAttr: el.getAttribute('data-topo-chrome-layout-active'),
+  };
+}, sel);
+
+await page.hover(sel);
+await page.waitForTimeout(400);
+const hover = await page.evaluate((s) => {
+  const el = document.querySelector(s);
+  if (!el) return null;
+  const cs = getComputedStyle(el);
+  return { color: cs.color, bg: cs.backgroundColor };
+}, sel);
+
+await browser.close();
+
+const src = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+// New active-variant substring must appear 4× (Ring, Grid, S/M/L, Fullscreen)
+const occurrences = (src.match(/bg-cyan-500\/15 text-cyan-300 font-medium hover:bg-cyan-500\/20 hover:text-cyan-200 active:bg-cyan-500\/25/g) || []).length;
+
+// Tailwind v4 emits cyan-300 / cyan-200 in lab() / oklab() color
+// space, not legacy rgb(). Parse the L (lightness) component and
+// verify hover L > rest L (cyan-200 is lighter than cyan-300).
+// Bg uses oklab with alpha; rest alpha = 0.15 (cyan-500/15), hover
+// alpha = 0.2 (cyan-500/20).
+const parseLab = (s) => {
+  const m = (s || '').match(/lab\(([0-9.]+)\s/) || (s || '').match(/oklab\(([0-9.]+)\s/);
+  return m ? parseFloat(m[1]) : NaN;
+};
+const parseAlpha = (s) => {
+  const m = (s || '').match(/\/\s*([0-9.]+)\)/);
+  return m ? parseFloat(m[1]) : NaN;
+};
+const restL  = parseLab(rest?.color);
+const hoverL = parseLab(hover?.color);
+const restBgA  = parseAlpha(rest?.bg);
+const hoverBgA = parseAlpha(hover?.bg);
+
+const results = {
+  active_attr:               rest?.activeAttr === 'true',
+  rest_text_parsed:          !Number.isNaN(restL),
+  hover_text_parsed:         !Number.isNaN(hoverL),
+  hover_text_lighter_than_rest: hoverL > restL + 3, // cyan-200 L≈91 > cyan-300 L≈85
+  rest_bg_alpha_0_15:        Math.abs(restBgA - 0.15) < 0.01,
+  hover_bg_alpha_0_20:       Math.abs(hoverBgA - 0.20) < 0.01,
+  source_4_occurrences:      occurrences === 4,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} R552 chrome active-variant hover:text-cyan-200 (4 anchors):`,
+  JSON.stringify(results, null, 2),
+  '\n  rest:', JSON.stringify(rest),
+  '\n  hover:', JSON.stringify(hover),
+  '\n  source occurrences:', occurrences);
+process.exit(ok ? 0 : 1);

package/scripts/topo-active-links-chip-halo-layers-test.mjs

@@ -0,0 +1,81 @@
+/* Round 686 — active-links chip extends from 4+ hover axes (bg/text/
+ * border swap + translate-y) to add multi-layer halo paint axis.
+ * Inline filter conditional on hoveredActiveLinks state (existing,
+ * line 1098) gates 2-layer drop-shadow at pal.legendAccent tint with
+ * 2+4 stride, alpha 80/40. 45th anchor — first active-links anchor.
+ *
+ * Source assertions:
+ *   - filter chain uses pal.legendAccent at 80/40 with 2+4 stride,
+ *     gated on hoveredActiveLinks && isInteractive
+ *   - data-active-links-chip-halo-layers attr toggles '2' ↔ '0'
+ *
+ * Runtime assertions:
+ *   - active-links chip present (renders when sessions exist)
+ *   - rest halo-layers='0'
+ *   - chip is interactive when flowLinks > 0 (mock messages create flows)
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1200 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try {
+    localStorage.setItem('anet-theme', 'cyber');
+    localStorage.setItem('anet-topo-layout', 'ring');
+    sessionStorage.setItem('anet_v3_auth', '1');
+  } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias) => ({
+    alias, status: 'idle', model: 'claude-opus-4', runtime: '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('a·1'), mk('a·2'), mk('a·3')] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [
+  { id: 'm1', from_alias: 'a·1', to_alias: 'a·2', kind: 'message', content: 'p', network_id: 'default', created_at: fresh },
+  { id: 'm2', from_alias: 'a·2', to_alias: 'a·3', kind: 'task',    content: 'p2', network_id: 'default', created_at: fresh },
+] } }));
+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: 'networkidle' });
+await page.waitForSelector('[data-active-links-chip]', { timeout: 15000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const runtimeState = await page.evaluate(() => {
+  const chip = document.querySelector('[data-active-links-chip]');
+  return chip ? {
+    halo_layers: chip.getAttribute('data-active-links-chip-halo-layers'),
+    interactive: chip.getAttribute('data-active-links-clickable'),
+    flow_count:  chip.getAttribute('data-active-links-flow-count'),
+  } : null;
+});
+
+await browser.close();
+
+const src = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceFilter = /filter: hoveredActiveLinks && isInteractive\s*\?\s*`drop-shadow\(0 0 2px \$\{pal\.legendAccent\}80\) drop-shadow\(0 0 4px \$\{pal\.legendAccent\}40\)`\s*: undefined/.test(src);
+const sourceAttr   = /data-active-links-chip-halo-layers=\{hoveredActiveLinks && isInteractive \? '2' : '0'\}/.test(src);
+
+const results = {
+  chip_present:        !!runtimeState,
+  rest_layers_zero:    runtimeState?.halo_layers === '0',
+  is_interactive:      runtimeState?.interactive === 'true',
+  has_flows:           runtimeState && parseInt(runtimeState.flow_count, 10) >= 1,
+  source_filter:       sourceFilter,
+  source_layers_attr:  sourceAttr,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} R686 active-links chip multi-layer halo (first active-links anchor):`,
+  JSON.stringify(results, null, 2),
+  `\n  runtime: ${JSON.stringify(runtimeState)}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-alias-chat-brightness-test.mjs

@@ -0,0 +1,79 @@
+/* Round 616 — alias text brightness gate extends from hover-only
+ * to (hover || chat-target). 2nd anchor in chat-target-gated
+ * brightness family (sibling to R615 chat ring).
+ *
+ * Test phases:
+ *   1. mock 2 idle nodes → alias text renders
+ *   2. rest (no hover, no chat): filter='none', brightness-attr='1'
+ *   3. computed transition-property contains 'filter'
+ *   4. source: filter conditional includes BOTH hover AND chat
+ *      gates, joined by `||`
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const fresh = new Date(Date.now() - 60 * 1000).toISOString();
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext({ viewport: { width: 1500, height: 1200 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try {
+    localStorage.setItem('anet-theme', 'cyber');
+    localStorage.setItem('anet-topo-layout', 'ring');
+    sessionStorage.setItem('anet_v3_auth', '1');
+  } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias) => ({
+    alias, status: 'idle', model: 'claude-opus-4', runtime: '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('a·1'), mk('a·2')] } });
+});
+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: 'networkidle' });
+await page.waitForSelector('[data-node-alias-text]', { timeout: 15000, state: 'attached' });
+await page.waitForTimeout(500);
+
+const rest = await page.evaluate(() => {
+  const el = document.querySelector('[data-node-alias-text]');
+  if (!el) return null;
+  const cs = getComputedStyle(el);
+  return {
+    filter: cs.filter,
+    transitionProperty: cs.transitionProperty,
+    brightnessAttr: el.getAttribute('data-node-alias-brightness'),
+    hoveredAttr: el.getAttribute('data-node-alias-hovered'),
+    chatTargetAttr: el.getAttribute('data-node-alias-chat-target'),
+  };
+});
+
+await browser.close();
+
+const src = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceFilter = /filter: !reducedMotion && \(hoveredAlias === session\.alias \|\| chatAlias === session\.alias\)\s*\?\s*`drop-shadow\(0 0 2px \$\{status\.text\}80\) brightness\(1\.15\)`\s*:\s*undefined/.test(src);
+const sourceAttr = /data-node-alias-brightness=\{!reducedMotion && \(hoveredAlias === session\.alias \|\| chatAlias === session\.alias\) \? '1\.15' : '1'\}/.test(src);
+
+const results = {
+  alias_present:          !!rest,
+  rest_filter_none:       rest?.filter === 'none',
+  rest_brightness_1:      rest?.brightnessAttr === '1',
+  rest_hovered_false:     rest?.hoveredAttr === 'false',
+  rest_chat_target_false: rest?.chatTargetAttr === 'false',
+  transition_has_filter:  /filter/.test(rest?.transitionProperty || ''),
+  source_filter_or_gate:  sourceFilter,
+  source_attr_or_gate:    sourceAttr,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} R616 alias chat-target brightness (chat-gated family 2/N):`,
+  JSON.stringify(results, null, 2),
+  `\n  rest: ${JSON.stringify(rest)}`);
+process.exit(ok ? 0 : 1);