@sleep2agi/agent-network-dashboard 0.5.1-preview.14 → 0.5.1-preview.140

package/scripts/topo-flow-rail-hover-sw-test.mjs

@@ -0,0 +1,113 @@
+/* Round 437 verification: flow-rail (dashed underline) strokeWidth
+ * hover lift — 1 → 1.5 on (isHoveredEdge || isEndpointHoveredEdge).
+ * Pairs with R50 visible-path width lift + R436 endpoint width lift
+ * so both edge paint layers thicken together on hover.
+ *
+ * Contract:
+ *   - rest: every flow-rail reports stroke-width '1' + lifted='false'
+ *   - hover one node alias: rails on edges incident to that node
+ *     report stroke-width '1.5' + lifted='true'; non-incident rails
+ *     stay rest
+ *   - 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-flow-rail]', { timeout: 15000 });
+await page.waitForTimeout(400);
+
+const readAll = () => page.evaluate(() => {
+  const ps = [...document.querySelectorAll('[data-edge-flow-rail]')];
+  return ps.map(p => ({
+    key:    p.getAttribute('data-edge-flow-rail'),
+    sw:     parseFloat(p.getAttribute('data-edge-flow-rail-stroke-width') || '0'),
+    sw_a:   p.getAttribute('stroke-width'),
+    lifted: p.getAttribute('data-edge-flow-rail-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      = /strokeWidth=\{\(isHoveredEdge \|\| isEndpointHoveredEdge\) \? 1\.5 : 1\}/.test(fileText);
+const sourceTransition = /transition: 'opacity 300ms ease-out, stroke 300ms ease-out, stroke-width 300ms ease-out'/.test(fileText);
+
+await browser.close();
+
+const restAllSw1     = rest.every(r => r.sw === 1);
+const restNoneLifted = rest.every(r => r.lifted === 'false');
+
+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 alphaAllLifted  = alphaEntries.length > 0 && alphaEntries.every(([, h]) => h.sw === 1.5 && h.lifted === 'true');
+const nonAlphaRestSw  = nonAlphaEntries.every(([, h]) => h.sw === 1 && h.lifted === 'false');
+
+const results = {
+  rest_count_ge_2:           rest.length >= 2,
+  rest_all_sw_1:             restAllSw1,
+  rest_none_lifted:          restNoneLifted,
+  hover_alpha_count_ge_2:    alphaEntries.length >= 2,
+  hover_alpha_all_lifted:    alphaAllLifted,
+  hover_non_alpha_unaffected: nonAlphaRestSw,
+  source_strokeWidth_wired:  sourceWired,
+  source_transition_wired:   sourceTransition,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} flow-rail hover sw lift:`, JSON.stringify(results),
+  '\n  rest:', JSON.stringify(rest),
+  '\n  hover:', JSON.stringify(hover));
+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);

package/scripts/topo-freshness-floor-lift-test.mjs

@@ -0,0 +1,92 @@
+/* Round 358 verification: freshness-ramp stale floor lifted 0.25 →
+ * 0.30 across 3 coordinated scopes:
+ *   - active-links chip dot     (line ~3055)
+ *   - recent-panel header count (line ~6524)
+ *   - recent-row freshness pip  (line ~7021)
+ *
+ * The ramp shape stays the same:
+ *   0-30s   → 1.0  (fully fresh)
+ *   30-300s → smooth decay 1.0 → 0.30
+ *   > 300s  → 0.30 (stale floor)
+ *
+ * R358 polish: stale state becomes ~20 % more readable (0.30 / 0.25
+ * = 1.2x) while the fresh-vs-stale ratio stays strong (1.0 / 0.30 ≈
+ * 3.3× vs prior 4×). Joins the R317 subordinate-text-lift family
+ * at the freshness scope.
+ *
+ * Test approach: feed a STALE message (~ 600s ago, well past the 300s
+ * floor boundary) to the route mock, then read all 3 freshness-alpha
+ * data attrs. Each should be '0.30'.
+ *
+ * Contract:
+ *   - Active-links chip dot data-active-links-freshness-alpha === '0.30'.
+ *   - Recent-panel header count data-recent-panel-count-freshness-alpha
+ *     === '0.30'.
+ *   - Recent-row pip data-recent-row-freshness-alpha === '0.30'.
+ *   - SVG fill colors include alpha 0.3 (rgba form).
+ */
+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') ] } });
+});
+
+// STALE message: created_at ~ 600s ago + last_at ~ 600s ago.
+const now = Date.now();
+const staleIso = new Date(now - 600 * 1000).toISOString();
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [
+  { id: 'm1', from_alias: 'a', to_alias: 'b', content: 'old ping',
+    network_id: 'default', created_at: staleIso, last_at: staleIso },
+] } }));
+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-active-links-freshness-dot]',       { timeout: 15000 });
+await page.waitForSelector('[data-recent-panel-count-freshness-alpha]', { timeout: 5000 });
+await page.waitForSelector('[data-recent-row-freshness-alpha]',         { timeout: 5000 });
+await page.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const dot   = document.querySelector('[data-active-links-freshness-dot]');
+  const count = document.querySelector('[data-recent-panel-count-freshness-alpha]');
+  const pip   = document.querySelector('[data-recent-row-freshness-alpha]');
+  return {
+    dotAlpha:   dot?.getAttribute('data-active-links-freshness-alpha') ?? null,
+    countAlpha: count?.getAttribute('data-recent-panel-count-freshness-alpha') ?? null,
+    pipAlpha:   pip?.getAttribute('data-recent-row-freshness-alpha') ?? null,
+    // The pip uses a static fill + a separate `opacity` SVG attr —
+    // probe that, not the fill colour.
+    pipOpacity: pip?.getAttribute('opacity') ?? null,
+  };
+});
+
+await browser.close();
+
+const results = {
+  dot_alpha_0_30:   probe.dotAlpha === '0.30',
+  count_alpha_0_30: probe.countAlpha === '0.30',
+  pip_alpha_0_30:   probe.pipAlpha === '0.30',
+  pip_opacity_0_3: /^0\.3$|^0\.30$/.test(probe.pipOpacity || ''),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} freshness floor lift 0.25 → 0.30:`, JSON.stringify(results),
+  '\n  probe:', probe);
+process.exit(ok ? 0 : 1);

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

@@ -0,0 +1,88 @@
+/* Round 357 verification: active-links chip freshness suffix wrapper
+ * picks up `tabular-nums` for digit width-lock. Pre-R357 the literal
+ * "last {rel}" text (e.g. "last 5s ago", "last 10s ago") had
+ * natural-figure digits — the ticker updates every second, so the
+ * 9→10 boundary on seconds and 59s→1m flip both jittered ~1-2 px of
+ * glyph width, propagating through the inline-flex chip row and
+ * nudging the freshness DOT + chip's left edge. Tabular-nums on the
+ * wrapper applies to all descendant digits (letters render at
+ * natural widths). Joins the R224-R232 info-density tabular-nums
+ * sweep at the chip-row freshness scope.
+ *
+ * Contract (cyber, fresh messages so the suffix renders):
+ *   - Freshness wrapper element computed font-variant-numeric
+ *     resolves to 'tabular-nums'.
+ *   - data-active-links-freshness-wrapper attr present on the span.
+ *   - The wrapper still carries text-gray-400 (R342) — invariant.
+ *   - The freshness dot still has its color transition (R342) —
+ *     invariant.
+ *   - The active-links chip still mounts with the suffix child.
+ */
+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'), mk('c') ] } });
+});
+// A fresh message so the active-links chip surfaces a suffix.
+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-active-links-freshness-wrapper]', { timeout: 15000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const wrap = document.querySelector('[data-active-links-freshness-wrapper]');
+  const dot  = wrap?.querySelector('[data-active-links-freshness-dot]');
+  const cs   = wrap ? getComputedStyle(wrap) : null;
+  const dotCs = dot ? getComputedStyle(dot) : null;
+  return {
+    wrapperFontVariant: cs?.fontVariantNumeric ?? null,
+    wrapperColor:       cs?.color ?? null,
+    wrapperCls:         wrap?.getAttribute('class') ?? null,
+    wrapperText:        wrap?.textContent ?? null,
+    dotPresent:         !!dot,
+    dotTransition:      dotCs?.transition ?? null,
+    dotColor:           dotCs?.color ?? null,
+  };
+});
+
+await browser.close();
+
+const hasTrans = (s, prop) =>
+  new RegExp(`${prop}\\s+\\d*\\.?\\d*s|${prop}\\s+\\d+ms`, 'i').test(s || '');
+
+const results = {
+  tabular_nums:        /tabular-nums/.test(probe.wrapperFontVariant || ''),
+  cls_has_text_gray:   /text-gray-400/.test(probe.wrapperCls || ''),    // R342
+  cls_has_tabular:     /tabular-nums/.test(probe.wrapperCls || ''),
+  text_has_last:       /last/.test(probe.wrapperText || ''),
+  dot_present:         probe.dotPresent,
+  dot_has_color_trans: hasTrans(probe.dotTransition, 'color'),          // R342
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} freshness suffix tabular-nums:`, JSON.stringify(results),
+  '\n  probe:', probe);
+process.exit(ok ? 0 : 1);

package/scripts/topo-group-box-geom-transition-test.mjs

@@ -0,0 +1,110 @@
+/* Round 461 verification: parent group-box rect transition list
+ * extends to include x + y + width + height (200ms ease-out each).
+ * Pre-R461 the outer 200×140 px container snap-jumped on cluster
+ * resize while the inner R460 hitbox tint rect (160×18) slid —
+ * jarring two-rate motion at the same surface. R461 unifies the
+ * pair so the whole cluster boundary slides as one Hero D-coherent
+ * motion envelope at 200ms.
+ *
+ * Contract:
+ *   - every <rect data-group-box-geom-transition="x,y,width,height">
+ *     renders (one per cluster)
+ *   - inline style contains all 4 geometry tweens at 200ms
+ *   - existing R66 / R248 transition axes (stroke, stroke-width,
+ *     fill-opacity, filter, fill) all preserved
+ *   - source-file wired
+ */
+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', 'grid');
+    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·1', 'working'),
+    mk('alpha·2', 'idle'),
+    mk('beta·1',  'working'),
+    mk('beta·2',  '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('[data-group-box-geom-transition]', { timeout: 15000 });
+await page.waitForTimeout(400);
+
+const probe = await page.evaluate(() => {
+  const boxes = [...document.querySelectorAll('[data-group-box-geom-transition]')];
+  return {
+    count: boxes.length,
+    nodes: boxes.map(b => ({
+      geom:  b.getAttribute('data-group-box-geom-transition'),
+      style: b.getAttribute('style') || '',
+    })),
+  };
+});
+
+const src = readFileSync('/home/vansin/agent-network-dashboard/app/components/TopoGraph.tsx', 'utf8');
+const parentBoxBlockMatch = src.match(/data-group-box-pinned[\s\S]{0,5500}?\/>/);
+const parentBoxBlock = parentBoxBlockMatch ? parentBoxBlockMatch[0] : '';
+const sourceHasGeomAttr   = /data-group-box-geom-transition="x,y,width,height"/.test(parentBoxBlock);
+const sourceHasAll4Tweens = /x 200ms ease-out/.test(parentBoxBlock)
+                         && /y 200ms ease-out/.test(parentBoxBlock)
+                         && /width 200ms ease-out/.test(parentBoxBlock)
+                         && /height 200ms ease-out/.test(parentBoxBlock);
+const sourcePreservesR66  = /stroke 200ms ease-out/.test(parentBoxBlock)
+                         && /stroke-width 200ms ease-out/.test(parentBoxBlock)
+                         && /fill-opacity 200ms ease-out/.test(parentBoxBlock)
+                         && /filter 200ms ease-out/.test(parentBoxBlock)
+                         && /fill 200ms ease-out/.test(parentBoxBlock);
+
+await browser.close();
+
+const countGe2     = probe.count >= 2;
+const allDataAttr  = probe.nodes.every(n => n.geom === 'x,y,width,height');
+const allStyle4xy  = probe.nodes.every(n =>
+  /x 200ms ease-out/.test(n.style) &&
+  /y 200ms ease-out/.test(n.style) &&
+  /width 200ms ease-out/.test(n.style) &&
+  /height 200ms ease-out/.test(n.style));
+const allStyleR66  = probe.nodes.every(n =>
+  /stroke 200ms ease-out/.test(n.style) &&
+  /fill-opacity 200ms ease-out/.test(n.style) &&
+  /filter 200ms ease-out/.test(n.style) &&
+  /fill 200ms ease-out/.test(n.style));
+
+const results = {
+  box_count_ge_2:           countGe2,
+  all_data_attr_xywh:       allDataAttr,
+  all_style_has_4_geom:     allStyle4xy,
+  all_style_preserves_r66:  allStyleR66,
+  source_geom_attr_wired:   sourceHasGeomAttr,
+  source_all_4_tweens:      sourceHasAll4Tweens,
+  source_preserves_r66:     sourcePreservesR66,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} group box geom transition x+y+width+height:`, JSON.stringify(results),
+  '\n  count:', probe.count,
+  '\n  first style (truncated):', (probe.nodes[0]?.style || '').slice(0, 220));
+process.exit(ok ? 0 : 1);