@sleep2agi/agent-network-dashboard 0.4.6-preview.31 → 0.4.6-preview.310

package/scripts/topo-corner-radius-unify-test.mjs

@@ -0,0 +1,103 @@
+/* Round 262 verification: corner-radius vocabulary unified across the
+ * canvas chrome — panels drop rx="10" → rx="8" to match the wrapper's
+ * rounded-lg (8px).
+ *
+ * Pre-R262 corner-radius hierarchy:
+ *   Group label rect:    rx="4"   ← tiny chip
+ *   Node label card:     rx="6"   ← small card
+ *   Recent-signal panel: rx="10"  ← panel chrome   ← MISMATCHED
+ *   Legend panel:        rx="10"  ← panel chrome   ← MISMATCHED
+ *   Canvas wrapper:      rounded-lg (8 px CSS)
+ *   ⇒ Panels at 10 px more rounded than the wrapper at 8 px.
+ *
+ * Post-R262:
+ *   Group label:    rx=4
+ *   Node label card:rx=6
+ *   Panels:         rx=8   ← matches wrapper
+ *   Canvas wrapper: rounded-lg (8 px)
+ *   ⇒ Clean 4→6→8 progression. Panel corners now flush with wrapper
+ *      corners, not exceeding them.
+ *
+ * Test scope:
+ *   1. Recent-signal panel rect rx === "8".
+ *   2. Legend panel rect rx === "8".
+ *   3. Node label card rect rx === "6" (unchanged regression).
+ *   4. Group label rect rx === "4" (unchanged regression).
+ *   5. Canvas wrapper computed border-top-left-radius === 8 px.
+ */
+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');
+    // Grid layout exposes the group label rect (rx=4)
+    localStorage.setItem('anet-topo-layout', 'grid');
+  } 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,
+  });
+  // Use a group prefix so the prefix-group boundary box renders + its
+  // group label rect with rx=4 is in the DOM for regression check.
+  await route.fulfill({ response: r, json: { ...b, sessions: [
+    mk('alpha-1'), mk('alpha-2'), mk('alpha-3'), mk('alpha-4'),
+  ] } });
+});
+await ctx.route('**/api/hub/messages*', (r) => r.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (r) => r.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 4, { timeout: 30000 });
+await page.waitForSelector('[data-topo-panel="recent"]',  { timeout: 10000 });
+await page.waitForSelector('[data-topo-panel="legend"]',  { timeout: 10000 });
+await page.waitForSelector('[data-node-label-card]',      { timeout: 10000 });
+await page.waitForSelector('[data-group-label-tinted]',   { timeout: 10000 });
+await page.waitForSelector('[data-topo-wrapper]',         { timeout: 10000 });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  const recentG = document.querySelector('[data-topo-panel="recent"]');
+  const legendG = document.querySelector('[data-topo-panel="legend"]');
+  const recentRx = recentG?.querySelector('rect')?.getAttribute('rx');
+  const legendRx = legendG?.querySelector('rect')?.getAttribute('rx');
+  // Node label card rect — query any one of them
+  const cardRect = document.querySelector('[data-node-label-card]');
+  const cardRx   = cardRect?.getAttribute('rx');
+  // Group label rect — the bg tint rect inside the group-label-hit group
+  const groupTintRect = document.querySelector('[data-group-label-tinted]');
+  const groupTintRx   = groupTintRect?.getAttribute('rx');
+  // Wrapper CSS corner radius
+  const wrapper = document.querySelector('[data-topo-wrapper]');
+  const wrapperBorderRadius = wrapper ? window.getComputedStyle(wrapper).borderTopLeftRadius : null;
+  return {
+    recentRx, legendRx, cardRx, groupTintRx, wrapperBorderRadius,
+  };
+});
+await browser.close();
+
+const results = {
+  recent_panel_rx_8:           probe.recentRx === '8',
+  legend_panel_rx_8:           probe.legendRx === '8',
+  node_label_card_rx_6:        probe.cardRx === '6',
+  group_label_tint_rx_4:       probe.groupTintRx === '4',
+  wrapper_border_radius_8px:   probe.wrapperBorderRadius === '8px',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} corner-radius unify:`, JSON.stringify(results),
+  '\n  rxs: recent', probe.recentRx, '· legend', probe.legendRx, '· card', probe.cardRx, '· group-tint', probe.groupTintRx,
+  '\n  wrapper border-radius:', probe.wrapperBorderRadius);
+process.exit(ok ? 0 : 1);

package/scripts/topo-cwd-tooltip-test.mjs

@@ -0,0 +1,64 @@
+/* Round 33 verification: hover tooltip carries `cwd: <project_dir>` on a
+ * second line when reported; falls back to the identity-only line
+ * otherwise; no `cwd:` line for nodes without project_dir. */
+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: 1280, height: 900 } });
+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 {}
+});
+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 sessions = [
+    {
+      alias: 'full', status: 'idle', network_id: nid,
+      project_dir: '/home/vansin/agent-orchestra',
+      model: 'claude-opus-4-7', runtime: 'cli-claude-code',
+      created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+    },
+    {
+      alias: 'cwdOnly', status: 'idle', network_id: nid,
+      project_dir: '/home/vansin/some-project',
+      model: null, runtime: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+    },
+    {
+      alias: 'bare', status: 'idle', network_id: nid,
+      project_dir: null, model: null, runtime: null,
+      created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+    },
+  ];
+  await route.fulfill({ response: r, json: { ...b, sessions } });
+});
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 3, { timeout: 30000 });
+await page.waitForTimeout(400);
+
+const titleOf = alias => page.$eval(`g[data-node="${alias}"] title`, el => el.textContent);
+const full = await titleOf('full');
+const cwdOnly = await titleOf('cwdOnly');
+const bare = await titleOf('bare');
+
+await browser.close();
+const results = {
+  fullHasIdentityAndCwd: /claude-opus-4-7/.test(full) && /cwd: \/home\/vansin\/agent-orchestra/.test(full) && full.includes('\n'),
+  cwdOnlyShowsAliasAndCwd: cwdOnly.startsWith('cwdOnly') && /cwd: \/home\/vansin\/some-project/.test(cwdOnly),
+  bareShowsAliasOnly: bare === 'bare',
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} cwd tooltip:`, JSON.stringify(results),
+  `\n  full=${JSON.stringify(full)}\n  cwdOnly=${JSON.stringify(cwdOnly)}\n  bare=${JSON.stringify(bare)}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-dblclick-reset-test.mjs

@@ -0,0 +1,74 @@
+/* Round 41 verification: double-clicking empty canvas resets view to
+ * {zoom:1, x:0, y:0}. Double-clicking a node does NOT reset (the
+ * node's own onClick wins, and resetView should not fire). */
+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: 1280, height: 1600 } });
+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');
+    localStorage.setItem('anet-topo-view', JSON.stringify({ zoom: 1, x: 0, y: 0 }));
+    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 sessions = ['a', 'b'].map(a => ({
+    alias: a, status: 'idle', network_id: nid, project_dir: null,
+    created_at: fresh, updated_at: fresh, last_seen_at: fresh,
+  }));
+  await route.fulfill({ response: r, json: { ...b, sessions } });
+});
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForSelector('svg[viewBox="0 0 1000 680"]', { timeout: 30000 });
+await page.waitForTimeout(500);
+
+const readZoom = () => page.evaluate(() => {
+  const span = document.querySelector('button[aria-label="Zoom in"]').parentElement.querySelector('span[title*="zoom level"]');
+  return +span.textContent.replace('%', '');
+});
+
+// Zoom in a couple times via keyboard, then dbl-click empty canvas → expect reset to 100%.
+await page.keyboard.press('=');
+await page.keyboard.press('=');
+await page.waitForTimeout(120);
+const zoomedIn = await readZoom();
+
+// Find empty-canvas coords: top-left area of the SVG, well outside node positions.
+const box = await page.$eval('svg[viewBox="0 0 1000 680"]', el => el.getBoundingClientRect());
+// y=0.35 is below the top-overlay panels (which sit at y<100 inside the SVG)
+const emptyX = box.x + box.width * 0.20;
+const emptyY = box.y + box.height * 0.40;
+await page.mouse.dblclick(emptyX, emptyY);
+await page.waitForTimeout(200);
+const afterEmptyDbl = await readZoom();
+
+// Now zoom in again and dbl-click a node — view should NOT reset.
+await page.keyboard.press('=');
+await page.keyboard.press('=');
+await page.waitForTimeout(120);
+const zoomedIn2 = await readZoom();
+await page.locator('g[data-node="a"]').dblclick().catch(() => {});
+await page.waitForTimeout(200);
+const afterNodeDbl = await readZoom();
+
+await browser.close();
+const results = {
+  zoomedInBeforeDbl: zoomedIn > 100,
+  emptyCanvasResets:  afterEmptyDbl === 100,
+  nodeDoesNotReset:   zoomedIn2 > 100 && afterNodeDbl === zoomedIn2,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} dblclick reset:`, JSON.stringify(results),
+  `\n  zoomedIn=${zoomedIn} afterEmptyDbl=${afterEmptyDbl} zoomedIn2=${zoomedIn2} afterNodeDbl=${afterNodeDbl}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-dense-alias-fill-transition-test.mjs

@@ -0,0 +1,133 @@
+/* Round 212 verification: dense plain-text alias (used when
+ * denseLayout > 16 nodes) gains fill transition on status flip,
+ * extending R211's card-mode coverage to the dense fallback path
+ * users see most on busy fleets.
+ *
+ * Pre-R212 the dense alias snap-cut its fill on tier change while
+ * the status ring smoothly transitioned (R167). R212 inline
+ * transition combines R26 transform 200ms (hover lift) with R212
+ * fill 300ms (status flip ease).
+ *
+ * Test (cyber dark, 17 sessions in mixed status → denseLayout=true):
+ *   1. 17+ [data-node-dense-alias-text] elements present (one per
+ *      session — confirms denseLayout path fired, not card mode).
+ *   2. Inline transition includes BOTH 'transform 200ms' AND
+ *      'fill 300ms' (composite spliced, group-hover lift unbroken).
+ *   3. group-hover:-translate-y-[1.5px] className preserved (lift
+ *      still wires via CSS pseudo-class).
+ *   4. Mixed-status fleet renders different fills per tier (working
+ *      green ≠ idle teal ≠ offline gray family).
+ *   5. paintOrder: stroke + stroke attribute preserved (R110 halo).
+ */
+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();
+// Build 17 sessions: mostly working, a couple idle + offline so fill
+// colors visibly differ.
+const statuses = [
+  ...Array(13).fill('working'),
+  'working', 'idle', 'idle', 'offline',
+];
+const aliases = statuses.map((_, i) => `node-${(i + 1).toString().padStart(2, '0')}`);
+
+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';
+  await route.fulfill({ response: r, json: { ...b, sessions: aliases.map((alias, i) => ({
+    alias, status: statuses[i], 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 ctx.route('**/api/hub/messages*', (r2) => r2.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (r2) => r2.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 17, { timeout: 30000 });
+await page.waitForSelector('[data-node-dense-alias-text]', { timeout: 10000, state: 'attached' });
+await page.waitForTimeout(300);
+
+const probe = await page.evaluate(() => {
+  return [...document.querySelectorAll('[data-node-dense-alias-text]')].map(el => ({
+    alias:      el.getAttribute('data-node-dense-alias-text'),
+    text:       el.textContent,
+    fill:       el.getAttribute('fill'),
+    className:  el.getAttribute('class') || '',
+    transition: el.style.transition,
+    paintOrder: el.style.paintOrder,
+    stroke:     el.getAttribute('stroke'),
+  }));
+});
+
+await browser.close();
+
+const hasTransformT = (s) => /transform\s+(?:200ms|0\.2s)/.test(s || '');
+const hasFillT      = (s) => /fill\s+(?:300ms|0\.3s)/.test(s || '');
+
+const workingAlias = probe.find(p => p.alias === 'node-01');  // first working
+const idleAlias    = probe.find(p => p.alias === 'node-15');  // first idle
+const offlineAlias = probe.find(p => p.alias === 'node-17');  // offline
+
+const results = {
+  dense_mode_fired:           probe.length >= 17,
+  // R211 [data-node-alias-text] should NOT be present (card path skipped)
+  card_path_skipped:          true,  // implicit — if dense path fired, card path didn't render its texts
+  all_have_transition_fill:   probe.every(p => hasFillT(p.transition)),
+  all_have_transition_trans:  probe.every(p => hasTransformT(p.transition)),
+  all_keep_group_hover:       probe.every(p => /group-hover:-translate-y/.test(p.className)),
+  all_have_paint_order:       probe.every(p => p.paintOrder === 'stroke'),
+  all_have_halo_stroke:       probe.every(p => !!p.stroke && p.stroke !== 'none'),
+  working_idle_fill_differs:  workingAlias?.fill && idleAlias?.fill
+                              && workingAlias.fill !== idleAlias.fill,
+  working_offline_fill_differs: workingAlias?.fill && offlineAlias?.fill
+                              && workingAlias.fill !== offlineAlias.fill,
+  alias_text_rendered:        workingAlias?.text === 'node-01',
+};
+
+// Verify card path skipped — no R211 card-mode texts at >16 nodes
+const cardAliasCount = await chromium.launch({ headless: true }).then(async (b2) => {
+  const ctx2 = await b2.newContext();
+  await ctx2.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+  await ctx2.addInitScript(() => {
+    try { localStorage.setItem('anet-theme', 'cyber'); sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+  });
+  await ctx2.route('**/api/hub/status*', async (route) => {
+    const r = await route.fetch();
+    const bj = await r.json();
+    const nid = (bj.sessions || [])[0]?.network_id || 'default';
+    await route.fulfill({ response: r, json: { ...bj, sessions: aliases.map((alias, i) => ({
+      alias, status: statuses[i], 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 ctx2.route('**/api/hub/messages*', (rr) => rr.fulfill({ json: { messages: [] } }));
+  await ctx2.route('**/api/hub/tasks*', (rr) => rr.fulfill({ json: { tasks: [] } }));
+  const p2 = await ctx2.newPage();
+  await p2.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+  await p2.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 17, { timeout: 30000 });
+  await p2.waitForTimeout(300);
+  const c = await p2.evaluate(() =>
+    document.querySelectorAll('[data-node-alias-text]').length);
+  await b2.close();
+  return c;
+});
+results.card_path_skipped = cardAliasCount === 0;
+
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} dense alias fill transition:`, JSON.stringify(results),
+  `\n  sample (first 3):`, probe.slice(0, 3),
+  `\n  cardAliasCount:`, cardAliasCount);
+process.exit(ok ? 0 : 1);

package/scripts/topo-discrete-zoom-smooth-test.mjs

@@ -0,0 +1,125 @@
+/* Round 169 verification: keyboard '+'/'−' and chrome zoom in/out
+ * buttons arm the R168 smoothView transition.
+ *
+ * R168 introduced one-shot smoothView arming on resetView/fitView.
+ * R169 extends the same arming to the three other DISCRETE zoom
+ * surfaces (one keypress / button-click = one 1.2× step):
+ *   keyboard '+' / '=' / '−' / '_'
+ *   chrome zoom-in / zoom-out buttons
+ *
+ * Wheel zoom stays direct (every tick = live, no transition lag).
+ * Wrapper:
+ *   const zoomByDiscrete = (factor) => {
+ *     setSmoothView(true);
+ *     setTimeout(() => setSmoothView(false), 350);
+ *     zoomBy(factor);
+ *   };
+ *
+ * Test:
+ *   1. Idle:        smooth=false, no transition
+ *   2. Press '+':   smooth=true, transition 'transform 300ms ease-out'
+ *                   zoom 100% → 120%
+ *   3. Wait 450ms:  smooth=false, transition cleared
+ *   4. Click chrome zoom-in button: smooth=true again (same path)
+ *   5. Press '−':   smooth=true, zoom back toward 100%
+ */
+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: 'cli-claude-code',
+    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*', (route) => route.fulfill({ json: { messages: [] } }));
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 3, { timeout: 30000 });
+await page.waitForSelector('[data-topo-viewport]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probeViewport = () => page.evaluate(() => {
+  const g = document.querySelector('[data-topo-viewport]');
+  return {
+    smooth: g?.getAttribute('data-topo-viewport-smooth'),
+    transition: g?.style?.transition || '',
+  };
+});
+const probeZoom = () => page.evaluate(() =>
+  document.querySelector('[data-topo-chrome-zoom-level]')?.textContent?.trim());
+
+const idle = await probeViewport();
+const zoomIdle = await probeZoom();
+
+// Press '+' → keyboard zoom-in. Probe within the 350ms window.
+await page.keyboard.press('+');
+await page.waitForTimeout(50);
+const duringKbZoomIn = await probeViewport();
+const zoomAfterKb = await probeZoom();
+
+// Wait past the 350ms window
+await page.waitForTimeout(450);
+const afterKbZoomIn = await probeViewport();
+
+// Click chrome zoom-in button → same arming path
+await page.locator('[data-topo-chrome-zoom-in]').click();
+await page.waitForTimeout(50);
+const duringChromeZoomIn = await probeViewport();
+const zoomAfterChromeIn = await probeZoom();
+
+// Wait past window then press '−' (keyboard zoom-out)
+await page.waitForTimeout(450);
+await page.keyboard.press('-');
+await page.waitForTimeout(50);
+const duringKbZoomOut = await probeViewport();
+const zoomAfterKbOut = await probeZoom();
+
+await browser.close();
+
+const results = {
+  viewport_found:                  idle !== null,
+  idle_smooth_false:               idle.smooth === 'false',
+  idle_no_transition:              !idle.transition.includes('transform'),
+  idle_zoom_100:                   zoomIdle === '100%',
+
+  kb_plus_armed_smooth:            duringKbZoomIn.smooth === 'true',
+  kb_plus_transition_set:          duringKbZoomIn.transition.includes('transform 300ms'),
+  kb_plus_zoom_increased:          zoomAfterKb !== '100%',
+
+  after_kb_smooth_cleared:         afterKbZoomIn.smooth === 'false',
+  after_kb_no_transition:          !afterKbZoomIn.transition.includes('transform'),
+
+  chrome_in_armed_smooth:          duringChromeZoomIn.smooth === 'true',
+  chrome_in_transition_set:        duringChromeZoomIn.transition.includes('transform 300ms'),
+  chrome_in_zoom_increased:        zoomAfterChromeIn !== zoomAfterKb,
+
+  kb_minus_armed_smooth:           duringKbZoomOut.smooth === 'true',
+  kb_minus_transition_set:         duringKbZoomOut.transition.includes('transform 300ms'),
+  kb_minus_zoom_decreased:         zoomAfterKbOut !== zoomAfterChromeIn,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} discrete zoom smooth:`, JSON.stringify(results),
+  `\n  idle =`, idle, `zoom=${zoomIdle}`,
+  `\n  '+' fired =`, duringKbZoomIn, `zoom=${zoomAfterKb}`,
+  `\n  after '+' =`, afterKbZoomIn,
+  `\n  chrome-in fired =`, duringChromeZoomIn, `zoom=${zoomAfterChromeIn}`,
+  `\n  '-' fired =`, duringKbZoomOut, `zoom=${zoomAfterKbOut}`);
+process.exit(ok ? 0 : 1);

package/scripts/topo-edge-badge-click-pin-test.mjs

@@ -0,0 +1,94 @@
+/* Round 121 verification: clicking an edge midpoint count badge
+ * (R100) pins the matching flow, mirroring the R116 recent-signal
+ * row click-pin from the canvas side. Closes the gap where the
+ * canvas had no pin-from-here affordance.
+ *
+ * Drive: 1 flow with count >= 3 (badge renders). Click badge →
+ * data-edge-count-badge-pinned="true", aria-pressed="true", the
+ * matching pill (R119) appears. Click again → release.
+ */
+import { chromium } from 'playwright';
+import { readFileSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+const browser = await chromium.launch({ headless: true });
+
+const ctx = await browser.newContext({ viewport: { width: 1400, height: 1500 } });
+await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+await ctx.addInitScript(() => {
+  try { localStorage.setItem('anet-theme', 'cyber'); 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: 'idle', model: 'claude-opus-4', runtime: 'cli-claude-code',
+    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')] } });
+});
+
+const now = Date.now();
+const mkMsg = (id, from_alias, to_alias, ageMs) => ({
+  id, from_alias, to_alias, content: 'hi', network_id: 'default',
+  created_at: new Date(now - ageMs).toISOString(),
+});
+await ctx.route('**/api/hub/messages*', (route) => route.fulfill({ json: { messages: [
+  mkMsg('m1', 'alpha', 'beta', 30 * 1000),
+  mkMsg('m2', 'alpha', 'beta', 40 * 1000),
+  mkMsg('m3', 'alpha', 'beta', 50 * 1000),
+  mkMsg('m4', 'alpha', 'beta', 60 * 1000),
+] } }));
+await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [] } }));
+const page = await ctx.newPage();
+await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+await page.waitForFunction(() => document.querySelectorAll('g[data-node]').length === 3, { timeout: 30000 });
+await page.waitForSelector('[data-edge-count-badge]', { timeout: 10000 });
+await page.waitForTimeout(400);
+
+const probe = () => page.evaluate(() => {
+  const badge = document.querySelector('[data-edge-count-badge="alpha->beta"]');
+  return {
+    badgePinned: badge?.getAttribute('data-edge-count-badge-pinned') || '',
+    aria:        badge?.getAttribute('aria-pressed') || '',
+    pillExists:  document.querySelector('[data-active-filter="edge"]') !== null,
+    title:       badge?.querySelector('title')?.textContent || '',
+  };
+});
+
+const before = await probe();
+
+// Click the badge → pin.
+await page.locator('[data-edge-count-badge="alpha->beta"]').click();
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const afterClick = await probe();
+
+// Click again → release.
+await page.locator('[data-edge-count-badge="alpha->beta"]').click();
+await page.mouse.move(10, 10);
+await page.waitForTimeout(300);
+const afterRelease = await probe();
+
+await browser.close();
+
+const results = {
+  before_notPinned:       before.badgePinned === 'false' && before.aria === 'false',
+  before_noPill:          before.pillExists === false,
+  before_titlePinHint:    /click to pin/.test(before.title),
+  click_pinned:           afterClick.badgePinned === 'true' && afterClick.aria === 'true',
+  click_pillAppears:      afterClick.pillExists === true,
+  click_titleReleaseHint: /click to release pin/.test(afterClick.title),
+  release_unpinned:       afterRelease.badgePinned === 'false' && afterRelease.aria === 'false',
+  release_pillGone:       afterRelease.pillExists === false,
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} edge-badge click-pin:`, JSON.stringify(results),
+  `\n  before=`,       before,
+  `\n  afterClick=`,   afterClick,
+  `\n  afterRelease=`, afterRelease);
+process.exit(ok ? 0 : 1);