@sleep2agi/agent-network-dashboard 0.5.1-preview.1 → 0.5.1-preview.100

package/scripts/topo-edge-particle-hover-r-test.mjs

@@ -0,0 +1,113 @@
+/* Round 439 verification: edge flow particle radius hover lift —
+ * r 4.5 → 5.5 on (isHoveredEdge || isEndpointHoveredEdge). Continues
+ * the edge paint-layer parity arc (R436 visible path / R437 flow rail
+ * / R439 particle).
+ *
+ * Contract:
+ *   - rest: every particle reports data-edge-particle-radius '4.5' +
+ *     lifted='false'
+ *   - hover one node alias: particles on edges incident to that node
+ *     report radius '5.5' + lifted='true'
+ *   - siblings unaffected
+ *   - source-file probe confirms conditional + transition extension
+ */
+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: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    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', 'working'),
+    mk('beta',  'idle'),
+    mk('gamma', 'idle'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({
+  json: { messages: [
+    { id: 'm1', from_alias: 'alpha', to_alias: 'beta',  content: 'ping', created_at: fresh, network_id: 'default' },
+    { id: 'm2', from_alias: 'alpha', to_alias: 'gamma', content: 'pong', created_at: fresh, network_id: 'default' },
+    { id: 'm3', from_alias: 'gamma', to_alias: 'beta',  content: 'pang', created_at: fresh, network_id: 'default' },
+  ] },
+}));
+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-edge-particle]', { timeout: 15000 });
+await page.waitForTimeout(400);
+
+const readAll = () => page.evaluate(() => {
+  const ps = [...document.querySelectorAll('[data-edge-particle]')];
+  return ps.map(p => ({
+    key:    p.getAttribute('data-edge-particle'),
+    r_attr: p.getAttribute('r'),
+    r_data: parseFloat(p.getAttribute('data-edge-particle-radius') || '0'),
+    lifted: p.getAttribute('data-edge-particle-lifted'),
+  }));
+});
+
+const rest = await readAll();
+
+let hover = null;
+const box = await page.evaluate(() => {
+  const t = document.querySelector('[data-node-alias-text="alpha"]');
+  if (!t) return null;
+  const node = t.closest('[data-node]');
+  const target = node || t;
+  const b = target.getBoundingClientRect();
+  return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+});
+if (box) {
+  await page.mouse.move(box.x, box.y);
+  await page.waitForTimeout(300);
+  hover = await readAll();
+  await page.mouse.move(0, 0);
+}
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceWired      = /r=\{\(isHoveredEdge \|\| isEndpointHoveredEdge\) \? 5\.5 : 4\.5\}/.test(fileText);
+const sourceTransition = /transition: 'fill 200ms ease-out, opacity 200ms ease-out, r 200ms ease-out'/.test(fileText);
+
+await browser.close();
+
+const isAlphaKey = (k) => /alpha/i.test(k);
+const hoverByKey = new Map((hover || []).map(h => [h.key, h]));
+const alphaEntries    = [...hoverByKey.entries()].filter(([k]) => isAlphaKey(k));
+const nonAlphaEntries = [...hoverByKey.entries()].filter(([k]) => !isAlphaKey(k));
+
+const restAllR_4_5     = rest.every(r => r.r_data === 4.5);
+const restNoneLifted   = rest.every(r => r.lifted === 'false');
+const alphaAllR_5_5    = alphaEntries.length > 0 && alphaEntries.every(([, h]) => h.r_data === 5.5 && h.lifted === 'true');
+const nonAlphaRestR    = nonAlphaEntries.every(([, h]) => h.r_data === 4.5 && h.lifted === 'false');
+
+const results = {
+  rest_particle_count_ge_2:    rest.length >= 2,
+  rest_all_r_4_5:              restAllR_4_5,
+  rest_none_lifted:            restNoneLifted,
+  hover_alpha_count_ge_2:      alphaEntries.length >= 2,
+  hover_alpha_all_lifted_5_5:  alphaAllR_5_5,
+  hover_non_alpha_unaffected:  nonAlphaRestR,
+  source_r_wired:              sourceWired,
+  source_transition_wired:     sourceTransition,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} edge-particle r hover lift:`, JSON.stringify(results),
+  '\n  rest:', JSON.stringify(rest),
+  '\n  hover:', JSON.stringify(hover));
+process.exit(ok ? 0 : 1);

package/scripts/topo-edge-particle-radius-test.mjs

@@ -0,0 +1,76 @@
+/* Round 422 verification: edge flow particle radius 4 → 4.5.
+ * Visual-weight bump family 15th anchor — particles riding along
+ * edge animateMotion paths get +0.5px lift (~27% area increase).
+ *
+ * Contract:
+ *   - Seed a flow alpha→beta so an edge mounts → particle mounts
+ *   - The <circle data-edge-particle> has:
+ *     * r attr === '4.5'
+ *     * data-edge-particle-radius === '4.5'
+ *   - Pre-R422 invariants preserved:
+ *     * R251 fill present (pal.flowParticle)
+ *     * R252 transition list (fill 200ms + opacity 200ms)
+ */
+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: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const 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('alpha'), mk('beta'), mk('gamma') ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({
+  json: { messages: [
+    { id: 'm1', from_alias: 'alpha', to_alias: 'beta', content: 'ping', created_at: fresh, network_id: 'default' },
+  ] },
+}));
+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-edge-particle]', { timeout: 15000 });
+await page.waitForTimeout(500);
+
+const probe = await page.evaluate(() => {
+  const particle = document.querySelector('[data-edge-particle]');
+  if (!particle) return null;
+  return {
+    rAttr:        particle.getAttribute('r'),
+    rData:        particle.getAttribute('data-edge-particle-radius'),
+    fill:         particle.getAttribute('fill'),
+    fillPresent:  !!particle.getAttribute('fill'),
+    styleAttr:    particle.getAttribute('style') || '',
+  };
+});
+
+await browser.close();
+
+const results = {
+  // R422 wire
+  r_attr_4_5:                 probe?.rAttr === '4.5',
+  r_data_4_5:                 probe?.rData === '4.5',
+  // R251 fill invariant
+  fill_present:               probe?.fillPresent === true,
+  // R252 transition invariant
+  transition_fill:            probe?.styleAttr.includes('fill') === true,
+  transition_opacity:         probe?.styleAttr.includes('opacity') === true,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} edge flow particle radius 4 → 4.5:`, JSON.stringify(results),
+  '\n  probe:', probe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-edge-visible-linecap-test.mjs

@@ -0,0 +1,89 @@
+/* Round 381 verification: edge visible flow path strokeLinecap='round'.
+ * Sibling SVG stroke-softening polish to R378 flow-rail linecap — both
+ * flow-element paths now share 'round' linecap. R380 group box closed
+ * dash-cap + corner softening; R381 closes the flow-path family at the
+ * visible primary path.
+ *
+ * Stroke-softening family snapshot post-R381:
+ *   R288 chrome icons      strokeLinecap='round'
+ *   R378 flow-rail dashes  strokeLinecap='round'
+ *   R380 group box dashes  strokeLinecap='round'
+ *   R381 flow visible path strokeLinecap='round' (this round)
+ *   R379 viewport rect     strokeLinejoin='round'
+ *   R380 group box corners strokeLinejoin='round'
+ *
+ * Contract:
+ *   - [data-edge-visible] element stroke-linecap attr === 'round'.
+ *   - data-edge-visible-linecap === 'round'.
+ *   - Pre-R381 invariants:
+ *     * fill='none', stroke=pal.flowEdge
+ *     * markerEnd referencing arrow id
+ *     * opacity-based freshness preserved (any value in 0..1)
+ *     * transition list contains opacity + stroke-width + stroke
+ */
+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('a'), mk('b') ] } });
+});
+const now = Date.now();
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [
+  { id: 'm1', from_alias: 'a', to_alias: 'b', content: 'ping',
+    network_id: 'default', created_at: new Date(now - 5000).toISOString() },
+] } }));
+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-edge-visible]', { timeout: 15000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const p = document.querySelector('[data-edge-visible]');
+  const cs = p ? getComputedStyle(p) : null;
+  return {
+    linecapAttr:  p?.getAttribute('stroke-linecap') ?? null,
+    linecapData:  p?.getAttribute('data-edge-visible-linecap') ?? null,
+    fillAttr:     p?.getAttribute('fill') ?? null,
+    markerEndAttr: p?.getAttribute('marker-end') ?? null,
+    transition:   cs?.transition ?? null,
+    linkKey:      p?.getAttribute('data-edge-visible') ?? null,
+  };
+});
+
+await browser.close();
+
+const hasTrans = (s, prop) =>
+  new RegExp(`${prop}\\s+\\d*\\.?\\d*s|${prop}\\s+\\d+ms`, 'i').test(s || '');
+
+const results = {
+  linecap_round:        probe.linecapAttr === 'round',
+  data_linecap_round:   probe.linecapData === 'round',
+  fill_none:            probe.fillAttr === 'none',
+  marker_end_arrow:     /^url\(#topo-arrow-/.test(probe.markerEndAttr || ''),
+  trans_has_opacity:    hasTrans(probe.transition, 'opacity'),
+  trans_has_stroke_w:   hasTrans(probe.transition, 'stroke-width'),
+  trans_has_stroke:     hasTrans(probe.transition, 'stroke'),
+  link_key_present:     (probe.linkKey || '').length > 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} edge visible path strokeLinecap='round':`, JSON.stringify(results),
+  '\n  probe:', probe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-filter-pill-hover-lift-test.mjs

@@ -0,0 +1,101 @@
+/* Round 397 verification: filter pin pills gain hover lift
+ * translateY(-1px). Sibling to R143 recent-row lift idiom —
+ * extends the "rising on hover" gesture from SVG canvas surfaces
+ * to the HTML filter chip strip. All 4 filter pill variants
+ * (status / group / vendor / edge) carry the lift.
+ *
+ * Contract:
+ *   - Source-file verification of the new className tokens
+ *     (transition-transform + hover:-translate-y-px + transform-gpu)
+ *   - The data-topo-filter-pill-hover-lift="true" sentinel attr
+ *     is mounted when any filter pill is rendered (pinned filter
+ *     present). Test mounts a status filter by clicking a status
+ *     chip, then probes the resulting pill.
+ *   - Pre-R397 invariants preserved on the pill className:
+ *     * group / rounded-md / font-mono / font-medium / text-xs
+ *       / border / anet-fade-in / anet-topo-chip-focus
+ *
+ * Note: hover dispatch on HTML chips in headless can fire but
+ * computing the post-hover translate-y reliably requires a mouse
+ * sweep. Test asserts the className tokens are present (which
+ * is what Tailwind compiles into `:hover` CSS) plus the sentinel
+ * attr — both deterministic from source.
+ */
+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: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    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', 'working'),
+    mk('beta',  'idle'),
+    mk('gamma', 'idle'),
+  ] } });
+});
+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('g[data-node]', { timeout: 15000 });
+await page.waitForTimeout(400);
+
+// Click a legend status row to pin the status filter → mounts the
+// filter pill. Use the alpha node since `working` row exists in fixture.
+await page.click('[data-legend-status="working"]');
+await page.waitForSelector('[data-topo-filter-pill-hover-lift="true"]', { timeout: 5000 });
+
+const probe = await page.evaluate(() => {
+  const pill = document.querySelector('[data-topo-filter-pill-hover-lift="true"]');
+  return pill ? {
+    className: pill.className,
+    activeFilter: pill.getAttribute('data-active-filter'),
+  } : null;
+});
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const occurrences = (fileText.match(/hover:-translate-y-px/g) || []).length;
+const sentinelOccurrences = (fileText.match(/data-topo-filter-pill-hover-lift="true"/g) || []).length;
+
+await browser.close();
+
+const cls = probe?.className || '';
+const results = {
+  // Sentinel attr mounted on the filter pill
+  pill_mounted:             !!probe,
+  // R397: hover-lift tokens present in className
+  has_transition_transform: cls.includes('transition-transform'),
+  has_hover_translate:      cls.includes('hover:-translate-y-px'),
+  has_transform_gpu:        cls.includes('transform-gpu'),
+  has_duration_200:         cls.includes('duration-200'),
+  has_ease_out:             cls.includes('ease-out'),
+  // Pre-R397 className tokens preserved
+  has_rounded_md:           cls.includes('rounded-md'),
+  has_font_mono:            cls.includes('font-mono'),
+  has_anet_topo_chip_focus: cls.includes('anet-topo-chip-focus'),
+  // Source-file replace_all coverage: 3 "group ..." pills + 1 plain pill = 4 occurrences
+  source_4_pills_lifted:    occurrences === 4,
+  source_4_sentinels:       sentinelOccurrences === 4,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} filter pin pills hover lift translateY(-1px):`, JSON.stringify(results),
+  '\n  className:', cls,
+  '\n  activeFilter:', probe?.activeFilter,
+  '\n  occurrences:', occurrences, '/ sentinels:', sentinelOccurrences);
+process.exit(ok ? 0 : 1);

package/scripts/topo-filter-pill-hover-opacity-test.mjs

@@ -0,0 +1,110 @@
+/* Round 355 verification: filter pin pills (status / group / vendor)
+ * gain pure-CSS group-hover lift of their inner opacity-70 spans
+ * (prefix `filter:` + count `· N`) to 100 % on pill hover. Marks the
+ * whole pill as scan-it interactive without layout reflow (opacity
+ * is paint-only). The R335 prefix-opacity tier + R323 count-opacity
+ * tier are preserved at rest; both ease to 100 % on pill hover.
+ *
+ * Contract (cyber, status filter pinned to 'working'):
+ *   - Rest: filter-prefix + filter-pill-count computed opacity 0.7.
+ *   - Hover pill: both spans computed opacity 1.
+ *   - Inline transition contains 'opacity'.
+ *   - Pre-R355 invariants:
+ *     * R335 prefix span keeps `hidden sm:inline opacity-70` baseline
+ *     * R323 count span keeps `opacity-70 tabular-nums` baseline
+ *     * Pill click-to-clear unchanged (still has onClick / cursor)
+ */
+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');
+    // Pre-pin status='working' so the filter pill mounts on first paint.
+    localStorage.setItem('anet-pinnedStatus', JSON.stringify('working'));
+  } 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('a'), mk('b'), mk('c') ] } });
+});
+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' });
+// If pre-pin via localStorage didn't take, click the working chip to pin.
+await page.waitForSelector('[data-working-chip]', { timeout: 15000 });
+const pillVisible = await page.locator('[data-active-filter="status"]').count();
+if (pillVisible === 0) {
+  await page.click('[data-working-chip]');
+  await page.waitForSelector('[data-active-filter="status"]', { timeout: 5000 });
+}
+await page.waitForTimeout(300);
+
+const restProbe = await page.evaluate(() => {
+  const pill = document.querySelector('[data-active-filter="status"]');
+  const prefix = pill?.querySelector('[data-filter-prefix]');
+  const count  = pill?.querySelector('[data-filter-pill-count]');
+  return {
+    prefixOpacity:  prefix ? getComputedStyle(prefix).opacity : null,
+    countOpacity:   count  ? getComputedStyle(count).opacity  : null,
+    prefixTrans:    prefix ? getComputedStyle(prefix).transition : null,
+    countTrans:     count  ? getComputedStyle(count).transition  : null,
+    prefixCls:      prefix?.getAttribute('class') ?? null,
+    countCls:       count?.getAttribute('class')  ?? null,
+    pillCursor:     pill ? getComputedStyle(pill).cursor : null,
+  };
+});
+
+// Hover the pill.
+await page.hover('[data-active-filter="status"]');
+await page.waitForTimeout(300);
+const hoverProbe = await page.evaluate(() => {
+  const pill = document.querySelector('[data-active-filter="status"]');
+  const prefix = pill?.querySelector('[data-filter-prefix]');
+  const count  = pill?.querySelector('[data-filter-pill-count]');
+  return {
+    prefixOpacity: prefix ? getComputedStyle(prefix).opacity : null,
+    countOpacity:  count  ? getComputedStyle(count).opacity  : null,
+  };
+});
+
+await browser.close();
+
+const approxEq = (a, b, tol = 0.02) => {
+  const x = parseFloat(a); const y = parseFloat(b);
+  return Number.isFinite(x) && Number.isFinite(y) && Math.abs(x - y) <= tol;
+};
+const hasTrans = (s, prop) =>
+  new RegExp(`${prop}\\s+\\d*\\.?\\d*s|${prop}\\s+\\d+ms`, 'i').test(s || '');
+
+const results = {
+  rest_prefix_0_7:        approxEq(restProbe.prefixOpacity, 0.7),
+  rest_count_0_7:         approxEq(restProbe.countOpacity,  0.7),
+  prefix_trans_has_op:    hasTrans(restProbe.prefixTrans, 'opacity'),
+  count_trans_has_op:     hasTrans(restProbe.countTrans,  'opacity'),
+  prefix_cls_has_op_70:   /opacity-70/.test(restProbe.prefixCls || ''),  // R335
+  count_cls_has_tabular:  /tabular-nums/.test(restProbe.countCls || ''), // R323
+  pill_cursor_pointer:    restProbe.pillCursor === 'pointer',
+  hover_prefix_1:         approxEq(hoverProbe.prefixOpacity, 1),
+  hover_count_1:          approxEq(hoverProbe.countOpacity,  1),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} filter pill hover-opacity lift:`, JSON.stringify(results),
+  '\n  rest: ', restProbe,
+  '\n  hover:', hoverProbe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-filter-pill-value-fw-test.mjs

@@ -0,0 +1,88 @@
+/* Round 412 verification: filter pin pill VALUE picks up fw=600
+ * (font-semibold). Extends chip-internal-hierarchy arc (11th
+ * anchor) — pill now reads with proper data-tier emphasis around
+ * its R355 opacity-70 prefix/suffix.
+ *
+ * Contract:
+ *   - Source-file verification of 4 occurrences of
+ *     `<span className="font-semibold" data-filter-value>`
+ *   - Runtime: pin a status filter, probe the data-filter-value
+ *     span on the mounted pill — className includes font-semibold
+ *     + textContent matches the pinned value.
+ *   - Pre-R412 invariants on the pill:
+ *     * data-filter-prefix span still opacity-70
+ *     * data-filter-pill-count still opacity-70 tabular-nums
+ *     * R397 hover-translate-y-px className still present
+ *     * R332/R355/R356 className tokens preserved
+ */
+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: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', async (route) => {
+  const r = await route.fetch();
+  const b = await r.json();
+  const nid = (b.sessions || [])[0]?.network_id || 'default';
+  const mk = (alias, status) => ({
+    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', 'working'),
+    mk('beta',  'idle'),
+  ] } });
+});
+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('g[data-node]', { timeout: 15000 });
+
+// Click legend status row to pin filter → mounts the filter pill
+await page.click('[data-legend-status="working"]');
+await page.waitForSelector('[data-filter-value]', { timeout: 5000 });
+
+const probe = await page.evaluate(() => {
+  const valueSpan = document.querySelector('[data-filter-value]');
+  if (!valueSpan) return null;
+  const pill = valueSpan.closest('[data-topo-filter-pill-hover-lift="true"]');
+  return {
+    valueText:      valueSpan.textContent,
+    valueClass:     valueSpan.className,
+    valueFwComputed: getComputedStyle(valueSpan).fontWeight,
+    pillClass:      pill?.className ?? null,
+    pillActiveFilter: pill?.getAttribute('data-active-filter') ?? null,
+  };
+});
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const valueOccurrences = (fileText.match(/<span className="font-semibold" data-filter-value>/g) || []).length;
+
+await browser.close();
+
+const results = {
+  // Runtime: value span has font-semibold
+  value_has_font_semibold:  probe?.valueClass.includes('font-semibold') === true,
+  value_text_working:       probe?.valueText === 'working',
+  value_fw_600:             probe?.valueFwComputed === '600',
+  // Pill mounted with R397 hover-lift
+  pill_has_hover_lift:      probe?.pillClass?.includes('hover:-translate-y-px') === true,
+  pill_active_filter:       probe?.pillActiveFilter === 'status',
+  // Source-file: 4 occurrences (status + group + vendor + edge filters)
+  source_4_value_spans:     valueOccurrences === 4,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} filter pin pill VALUE fw 500 → 600:`, JSON.stringify(results),
+  '\n  probe:', probe,
+  '\n  source occurrences:', valueOccurrences);
+process.exit(ok ? 0 : 1);

package/scripts/topo-filter-pill-weight-test.mjs

@@ -0,0 +1,75 @@
+/* Round 343 verification: filter pin pills (status / group / vendor /
+ * edge — 4 surfaces sharing className) gain `font-medium`. Aligns
+ * chip-row data-weight tier with working/online chips (which already
+ * carry font-medium per R313).
+ *
+ * Contract:
+ *   - Active filter pill ([data-active-filter] of any kind) has
+ *     className containing 'font-medium'.
+ *   - Computed font-weight reads 500.
+ *   - Prefix opacity-0.7 (R335) + R342 freshness wrapper gray-400
+ *     regressions intact.
+ *   - R317/R318/R294 chrome + pulse regressions intact.
+ *
+ * Fixture: pin status (working) so the filter pin pill mounts.
+ */
+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') ] } });
+});
+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-working-chip]', { timeout: 15000 });
+await page.waitForTimeout(200);
+await page.click('[data-working-chip]', { delay: 50 }).catch(() => {});
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const filterPill = document.querySelector('[data-active-filter]');
+  const prefix     = document.querySelector('[data-filter-prefix]');
+  return {
+    pillClass:        filterPill?.className ?? '',
+    pillFw:           filterPill ? getComputedStyle(filterPill).fontWeight : null,
+    prefixClass:      prefix?.className ?? '',
+    layoutInactiveCls: document.querySelector('[data-topo-chrome-layout="grid"]')?.className ?? '',
+    layoutActiveCls:   document.querySelector('[data-topo-chrome-layout="ring"]')?.className ?? '',
+    pulseCount:        document.querySelectorAll('[data-pulse-wrapper]').length,
+  };
+});
+await browser.close();
+
+const results = {
+  pill_has_font_medium:        /font-medium/.test(probe.pillClass),
+  pill_computed_fw_500:        String(probe.pillFw) === '500',
+  // R335 regression — prefix still has opacity-70.
+  r335_prefix_opacity70:       /opacity-70/.test(probe.prefixClass),
+  // R317 / R318 chrome regression.
+  r317_inactive_gray_400:      probe.layoutInactiveCls.includes('text-gray-400'),
+  r318_active_font_medium:     probe.layoutActiveCls.includes('font-medium'),
+  r294_pulse_absent:           probe.pulseCount === 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} filter pill font-medium:`, JSON.stringify(results),
+  '\n  pill fw:', probe.pillFw);
+process.exit(ok ? 0 : 1);