@sleep2agi/agent-network-dashboard 0.5.1-preview.7 → 0.5.1-preview.71

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-x-hover-scale-test.mjs

@@ -0,0 +1,99 @@
+/* Round 356 verification: filter pin pill × buttons gain hover:scale-
+ * 110 (Tailwind 4 modern CSS `scale` property). Pre-R356 the × had
+ * only hover:opacity-70 — target dimmed under cursor but didn't
+ * lift. R356 adds a 10 % scale so the click-target reads as "press
+ * me" alongside the dim. Sibling polish to R354 vendor letter glyph
+ * + R350/R352/R353 chrome icon hover-scales. replace_all touched
+ * all 4 filter pin pill × buttons (status / group / vendor / edge).
+ *
+ * Tailwind 4 compiles scale-110 to the modern CSS `scale` property
+ * — probes getComputedStyle(el).scale (verified during R352).
+ *
+ * Contract (cyber, status filter pinned to 'working'):
+ *   - Rest: × button computed scale 'none' (no scale applied).
+ *   - Hover ×: scale === '1.1'.
+ *   - Inline transition (computed) contains scale/transform.
+ *   - Pre-R356 invariants: hover:opacity-70 still applies (button
+ *     dims on hover), cursor: pointer, data-active-filter attr on
+ *     parent pill still 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');
+    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' });
+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 x = pill?.querySelector('button[aria-label^="Clear "]');
+  const cs = x ? getComputedStyle(x) : null;
+  return {
+    scale:      cs?.scale ?? null,
+    transition: cs?.transition ?? null,
+    cursor:     cs?.cursor ?? null,
+    className:  x?.getAttribute('class') ?? null,
+    pillAttr:   pill?.getAttribute('data-active-filter') ?? null,
+  };
+});
+
+await page.hover('[data-active-filter="status"] button[aria-label^="Clear "]');
+await page.waitForTimeout(300);
+const hoverProbe = await page.evaluate(() => {
+  const x = document.querySelector('[data-active-filter="status"] button[aria-label^="Clear "]');
+  return { scale: x ? getComputedStyle(x).scale : null };
+});
+
+await browser.close();
+
+const isRestScale = (s) => s === 'none' || s === '1' || s === '1 1' || s === null;
+const isHoverScale110 = (s) => s === '1.1' || s === '1.1 1.1';
+const hasTrans = (s, prop) =>
+  new RegExp(`${prop}\\s+\\d*\\.?\\d*s|${prop}\\s+\\d+ms`, 'i').test(s || '');
+
+const results = {
+  rest_scale_1:         isRestScale(restProbe.scale),
+  trans_has_scale:      hasTrans(restProbe.transition, 'scale') || hasTrans(restProbe.transition, 'transform'),
+  cursor_pointer:       restProbe.cursor === 'pointer',
+  cls_has_hover_op_70:  /hover:opacity-70/.test(restProbe.className || ''),  // R343
+  cls_has_hover_scale:  /hover:scale-110/.test(restProbe.className || ''),
+  pill_attr_status:     restProbe.pillAttr === 'status',
+  hover_scale_110:      isHoverScale110(hoverProbe.scale),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} filter pill × hover-scale:`, JSON.stringify(results),
+  '\n  rest:  ', restProbe,
+  '\n  hover: ', hoverProbe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-flow-rail-linecap-test.mjs

@@ -0,0 +1,79 @@
+/* Round 378 verification: edge flow-path dashed-rail picks up
+ * strokeLinecap='round'. Pre-R378 '2 12' dashes painted as sharp
+ * 1×2 rectangles; R378 rounds each cap so the dashes read as soft
+ * 3-px pills.
+ *
+ * Contract:
+ *   - [data-edge-flow-rail] element stroke-linecap attr === 'round'.
+ *   - data-edge-flow-rail-linecap === 'round'.
+ *   - Pre-R378 invariants:
+ *     * strokeWidth='1' preserved
+ *     * strokeDasharray='2 12' preserved
+ *     * R57 / R245 / R47 transition list (opacity + stroke) preserved
+ *     * data-edge-flow-rail key still surfaces the link
+ */
+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-flow-rail]', { timeout: 15000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const rail = document.querySelector('[data-edge-flow-rail]');
+  const cs = rail ? getComputedStyle(rail) : null;
+  return {
+    linecapAttr:     rail?.getAttribute('stroke-linecap') ?? null,
+    linecapData:     rail?.getAttribute('data-edge-flow-rail-linecap') ?? null,
+    strokeWidth:     rail?.getAttribute('stroke-width') ?? null,
+    strokeDasharray: rail?.getAttribute('stroke-dasharray') ?? null,
+    transition:      cs?.transition ?? null,
+    linkKey:         rail?.getAttribute('data-edge-flow-rail') ?? 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',
+  stroke_width_1:       probe.strokeWidth === '1',
+  dasharray_2_12:       probe.strokeDasharray === '2 12',
+  trans_has_opacity:    hasTrans(probe.transition, 'opacity'),
+  trans_has_stroke:     hasTrans(probe.transition, 'stroke'),
+  link_key_present:     (probe.linkKey || '').length > 0,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} flow-rail strokeLinecap='round':`, JSON.stringify(results),
+  '\n  probe:', probe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-freshness-chip-hierarchy-test.mjs

@@ -0,0 +1,93 @@
+/* Round 410 verification: FreshnessChip body picks up chip-internal-
+ * hierarchy — `{sec}` digit (fw=600 data tier) + `s` unit (opacity
+ * 0.7 label tier). Extends R333-R341/R362/R369/R389 arc to 10th
+ * anchor.
+ *
+ * Contract:
+ *   - R275 stale-only render: chip only mounts when sec > 10. Test
+ *     waits for /api/hub/status to settle, then advances lastSyncRef
+ *     by 11+ seconds via a long wait (the FreshnessChip ticks every
+ *     1s via setInterval). To avoid the slow wait we instead probe
+ *     the SOURCE-FILE for the wire change, then probe the chip if
+ *     it happens to mount during the test window.
+ *   - Source-file:
+ *     * <span className="font-semibold" data-freshness-chip-digit>
+ *     * <span className="opacity-70" data-freshness-chip-unit>
+ *   - If chip mounts at runtime: data-freshness-chip-digit + -unit
+ *     spans both present
+ */
+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') ] } });
+});
+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-topo-hub]', { timeout: 15000 });
+
+// Wait for FreshnessChip to mount (R275 stale-only: sec > 10). The
+// chip ticks every 1s. Wait 12s so lastSyncRef-based sec crosses 10.
+await page.waitForTimeout(12000);
+
+const probe = await page.evaluate(() => {
+  const chip = document.querySelector('[data-freshness-chip]');
+  if (!chip) return { mounted: false };
+  const digit = chip.querySelector('[data-freshness-chip-digit]');
+  const unit  = chip.querySelector('[data-freshness-chip-unit]');
+  return {
+    mounted:        true,
+    chipStale:      chip.getAttribute('data-freshness-chip-stale'),
+    digitClass:     digit?.className ?? null,
+    digitText:      digit?.textContent ?? null,
+    unitClass:      unit?.className ?? null,
+    unitText:       unit?.textContent ?? null,
+  };
+});
+
+const fileText = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const sourceHasDigitSpan = /<span className="font-semibold" data-freshness-chip-digit>/.test(fileText);
+const sourceHasUnitSpan  = /<span className="opacity-70" data-freshness-chip-unit>s<\/span>/.test(fileText);
+
+await browser.close();
+
+// Either runtime probe catches the chip OR source-file verification
+// alone establishes the wire change.
+const results = {
+  // Source-file canonical wire (deterministic)
+  source_digit_span:      sourceHasDigitSpan,
+  source_unit_span:       sourceHasUnitSpan,
+  // Runtime: chip might be present if test wait crossed 10s; assertions
+  // are conditional on mounted (only enforce structure when chip exists).
+  runtime_check_passed:   !probe.mounted || (
+    probe.chipStale === 'true' &&
+    probe.digitClass?.includes('font-semibold') === true &&
+    /^\d+$/.test(probe.digitText || '') &&
+    probe.unitClass?.includes('opacity-70') === true &&
+    probe.unitText === 's'
+  ),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} FreshnessChip chip-internal-hierarchy:`, JSON.stringify(results),
+  '\n  probe:', probe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-freshness-chip-tabular-test.mjs

@@ -0,0 +1,41 @@
+/* Round 377 verification: FreshnessChip baseClass picks up `tabular-
+ * nums`. The chip-row's last untouched chip joins the R224-R357
+ * tabular-nums sweep. `font-mono` already gave equal-width glyphs;
+ * R377 adds the explicit invariant the rest of the chip row carries.
+ *
+ * The chip only renders when stale (R275 gate: sec > 10s since
+ * last SWR sync). Test verifies the source-file invariant directly
+ * (className contains 'tabular-nums') since simulating > 10 s of
+ * no SWR refresh in a Playwright test is brittle.
+ *
+ * Contract:
+ *   - Source file TopoGraph.tsx contains the new baseClass with
+ *     'tabular-nums' between 'font-medium' and 'border'.
+ *   - Source file mentions R377 round marker.
+ *   - All preserved invariants: font-mono, font-medium (R313/R315),
+ *     transition-colors duration-300 (R187), rounded-md, border.
+ */
+import { readFileSync } from 'node:fs';
+
+const src = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+
+const baseClassLineMatch = src.match(/const baseClass = "([^"]+)"/);
+const baseClass = baseClassLineMatch?.[1] ?? '';
+
+const results = {
+  source_has_baseclass:       !!baseClassLineMatch,
+  baseclass_has_tabular_nums: /\btabular-nums\b/.test(baseClass),
+  baseclass_has_font_mono:    /\bfont-mono\b/.test(baseClass),
+  baseclass_has_font_medium:  /\bfont-medium\b/.test(baseClass),
+  baseclass_has_rounded_md:   /\brounded-md\b/.test(baseClass),
+  baseclass_has_border:       /\bborder\b/.test(baseClass),
+  baseclass_has_transition:   /\btransition-colors\b/.test(baseClass),
+  baseclass_duration_300:     /\bduration-300\b/.test(baseClass),
+  // Ensure ordering: font-medium → tabular-nums → border.
+  ordering_correct:           /font-medium tabular-nums border/.test(baseClass),
+  round_marker_present:       /Round 377 \/ Loop/.test(src),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} FreshnessChip baseClass tabular-nums:`, JSON.stringify(results),
+  '\n  baseClass:', baseClass);
+process.exit(ok ? 0 : 1);