@sleep2agi/agent-network-dashboard 0.4.6-preview.3 → 0.4.6-preview.301

package/app/components/types.ts

@@ -12,6 +12,13 @@ export interface Session {
   last_seen_at?: string;
   config_path?: string;
   network_id?: string;
+  // #111: working directory — nodes sharing a project_dir are one group
+  // (a more precise "same project" signal than the alias prefix).
+  project_dir?: string | null;
+  // #96: model vendor + execution runtime. Added to /api/status sessions in
+  // commhub-server 0.8.1-preview.0; null on older nodes / older hubs.
+  model?: string | null;
+  runtime?: string | null;
 }
 
 export interface Health {

package/app/components/utils.ts

@@ -11,14 +11,15 @@ export function previewContent(raw: string | null | undefined): string {
     .trim() || '--';
 }
 
+// Round 44 / Loop: timeAgo now delegates to the shared lib/time helper.
+// The old in-line `replace + 'Z'` parse appended a Z to already-ISO
+// inputs (producing "…ZZ", browser-fragile) — strict-superset semantics
+// preserved for SQL-style inputs, fixed for ISO. Plus a 'just now' fallback
+// when clock skew puts the timestamp in the future. Five callers benefit:
+// /admin · /logs · /settings/networks · InboxPanel · /messages.
+import { relativeAgo } from '../lib/time';
 export function timeAgo(dateStr: string): string {
-  if (!dateStr) return '--';
-  const diff = Date.now() - new Date(dateStr.replace(' ', 'T') + 'Z').getTime();
-  const s = Math.floor(diff / 1000);
-  if (s < 60) return `${s}s ago`;
-  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
-  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
-  return `${Math.floor(s / 86400)}d ago`;
+  return relativeAgo(dateStr) ?? '--';
 }
 
 export function statusColor(status: string, hasSse: boolean): string {

package/app/globals.css

@@ -828,6 +828,41 @@ body {
 }
 .anet-fade-in { animation: anet-fade-in 0.15s ease-out; }
 
+/* Round 184 — chrome reset button click-spin. The reset button's
+   onClick triggers R168 smoothView crossfade on the canvas, but the
+   BUTTON itself had no visual feedback that the click registered. A
+   single 360° rotation on the refresh-arrow icon (450ms ease-out) is
+   a quick "yes, I heard you" confirmation. Counter-clockwise (-360°)
+   reads as "rewind" / "undo" — natural for a reset gesture. Mirror
+   to R52's hub click ripple at the chrome scope. */
+@keyframes anet-reset-spin {
+  from { transform: rotate(0deg);     }
+  to   { transform: rotate(-360deg); }
+}
+.anet-reset-spin {
+  animation: anet-reset-spin 0.45s cubic-bezier(0.4, 0, 0.2, 1);
+  transform-origin: center;
+  transform-box: fill-box;
+}
+
+/* Round 186 — chrome zoom-in / zoom-out buttons get a brief icon pop
+   on click. Same click-feel idiom R184 added for the reset button —
+   the canvas already smoothes via R168/R169 smoothView, but the
+   chrome BUTTON itself needs its own confirmation. A quick scale
+   up-then-back (1 → 1.18 → 1 over 220ms) reads as "tapped". Same
+   transform-box: fill-box anchoring as R184 keeps the icon
+   centered in place. */
+@keyframes anet-chrome-pop {
+  0%   { transform: scale(1);    }
+  50%  { transform: scale(1.18); }
+  100% { transform: scale(1);    }
+}
+.anet-chrome-pop {
+  animation: anet-chrome-pop 0.22s ease-out;
+  transform-origin: center;
+  transform-box: fill-box;
+}
+
 /* Round 36 — current-step ring pulse on TaskDrawer timeline. Halo gently
    breathes around the active step's dot so users can spot "task is here". */
 @keyframes anet-current-step-pulse-kf {
@@ -840,24 +875,93 @@ body {
 
 /* Round 45 — TopoGraph rotating radar sweep wedge. 6s slow rotation
    gives the topology canvas a real "radar scan" feel without distracting
-   from the agent nodes. */
+   from the agent nodes.
+   R146: split shorthand into longhand so per-render inline style can
+   override animation-duration via --sweep-dur, joining the R145
+   --spoke-dur / R132 --march-dur pattern. Default 6s preserves R45's
+   original cadence for any caller that forgets the var. */
 @keyframes anet-topo-sweep-kf {
   0%   { transform: rotate(0deg); }
   100% { transform: rotate(360deg); }
 }
 .anet-topo-sweep {
-  animation: anet-topo-sweep-kf 6s linear infinite;
+  animation-name: anet-topo-sweep-kf;
+  animation-duration: var(--sweep-dur, 6s);
+  animation-timing-function: linear;
+  animation-iteration-count: infinite;
+}
+
+/* R155 — focus-visible outline for TopoGraph chip-row interactives.
+   Cyber theme's dark canvas often swallows the browser default focus
+   ring; R154 fixed it for chrome buttons via Tailwind's focus-visible:
+   ring (box-shadow). Chip-row chips reuse `box-shadow` for the R88 /
+   R139 / R140 pin-mirror inset — so a focus box-shadow would conflict
+   with the pinned-state shadow. `outline` is a separate CSS property
+   and doesn't fight box-shadow, so we use it here. `currentColor`
+   inherits the chip's own accent (green for working, cyan for online,
+   per-vendor for letters, etc.). Only fires on :focus-visible
+   (keyboard) — mouse focus stays unstyled. */
+.anet-topo-chip-focus:focus-visible {
+  outline: 2px solid currentColor;
+  outline-offset: 1px;
+}
+
+/* R156 — focus-visible outline for SVG-side TopoGraph interactives.
+   Same idiom as R155's chip-row class but for SVG <g> elements
+   (recent-signal rows, legend rows, group labels, edge badges,
+   node bodies, "+N more" footer). Each <g> already has role=
+   "button"/"link" + tabIndex=0 + onKeyDown (R116/R121/R133/R143/
+   R144/R151/R152). Browser default focus outline on SVG is hard
+   to spot against the canvas; explicit cyan-300 ring matches the
+   dashboard's legendAccent. 2-px outline-offset gives breathing
+   room around the painted bounding box. */
+.anet-topo-svg-focus:focus-visible {
+  outline: 2px solid #67e8f9;
+  outline-offset: 2px;
 }
 
 /* Round 46 — animated dashed spokes flowing from hub outward. Each spoke
    gets a small animationDelay (set inline) so the dashes don't all flow
-   in sync — reads as "command relay" pulse rather than a metronome. */
+   in sync — reads as "command relay" pulse rather than a metronome.
+   R145: split shorthand into longhand so per-render inline style can
+   override animation-duration via the --spoke-dur custom property —
+   same idiom R132 uses for --march-dur on group boxes. Default 2.4s
+   when --spoke-dur isn't set, so any future caller that forgets the
+   var keeps R46's original cadence. */
 @keyframes anet-topo-spoke-flow-kf {
   from { stroke-dashoffset: 0;   }
   to   { stroke-dashoffset: -40; }
 }
 .anet-topo-spoke-flow {
-  animation: anet-topo-spoke-flow-kf 2.4s linear infinite;
+  animation-name: anet-topo-spoke-flow-kf;
+  animation-duration: var(--spoke-dur, 2.4s);
+  animation-timing-function: linear;
+  animation-iteration-count: infinite;
+}
+
+/* Round 85 — group-box "marching ants" perimeter drift.
+   Applied to a grid-layout group box whose `statuses.working > 0`
+   AND that is neither hovered nor pinned (those treatments already
+   carry their own visual emphasis via solid stroke). Slow 12s
+   linear cycle reads as ambient motion, not animation — the eye
+   parses "this group has live work" without registering the box
+   as moving. R86 stride matches the box's `strokeDasharray="6 6"`
+   so a single full cycle returns to a frame-identical state.
+   prefers-reduced-motion handled by the blanket override below.
+   R132: split shorthand into longhand so per-group inline style can
+   override animation-duration via the --march-dur custom property
+   without re-declaring keyframe + timing + iteration count. Default
+   stays at 12s when --march-dur isn't set, so existing single-group
+   call sites keep their cadence. */
+@keyframes anet-topo-groupbox-march-kf {
+  from { stroke-dashoffset: 0;   }
+  to   { stroke-dashoffset: -12; }
+}
+.anet-topo-groupbox-live {
+  animation-name: anet-topo-groupbox-march-kf;
+  animation-duration: var(--march-dur, 12s);
+  animation-timing-function: linear;
+  animation-iteration-count: infinite;
 }
 
 /* ─────────────────────────────────────────────────────────────────────
@@ -894,7 +998,8 @@ body {
   .anet-fade-in,
   .anet-current-step-pulse,
   .anet-topo-sweep,
-  .anet-topo-spoke-flow {
+  .anet-topo-spoke-flow,
+  .anet-topo-groupbox-live {
     animation: none !important;
   }
   /* Tasks row grid 0fr↔1fr keep working (it's the toggle mechanism),

package/app/lib/time.ts

@@ -0,0 +1,36 @@
+/** Shared timestamp helpers for hub-sourced data.
+ *
+ *  Background — the CommHub serialises timestamps SQL-style without a
+ *  zone ("2026-05-15 06:00:28"), but some test data uses full ISO
+ *  ("…T06:00:28Z"). `Date.parse` on bare SQL is **local-time** in every
+ *  browser the dashboard supports, so a UTC+8 operator silently sees
+ *  every timestamp 8 h older than reality (Round 35 dug this out via
+ *  the `isGhost` filter mis-fire).
+ *
+ *  Round 38 / Loop consolidates parsing — TopoGraph (R35), ChatPopover
+ *  (R37) and utils.ts::timeAgo all mirrored the same SQL→UTC rewrite;
+ *  one source of truth here. */
+
+/** Parse a hub timestamp to ms-since-epoch, treating SQL-style strings
+ *  as UTC. ISO strings (with `T`) bypass the rewrite and are parsed as-is.
+ *  Returns null for empty / unparseable input. */
+export function parseHubTime(dateStr: string | null | undefined): number | null {
+  if (!dateStr) return null;
+  const iso = dateStr.includes('T') ? dateStr : dateStr.replace(' ', 'T') + 'Z';
+  const t = Date.parse(iso);
+  return Number.isFinite(t) ? t : null;
+}
+
+/** Format `dateStr` as a short relative-time string ("6m ago" / "2h ago").
+ *  Future timestamps (clock skew) collapse to "just now". Returns null when
+ *  the input doesn't parse — callers can decide on a fallback. */
+export function relativeAgo(dateStr: string | null | undefined): string | null {
+  const t = parseHubTime(dateStr);
+  if (t === null) return null;
+  const s = Math.floor((Date.now() - t) / 1000);
+  if (s < 0) return 'just now';
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+}

package/app/lib/vendorIdentity.ts

@@ -0,0 +1,145 @@
+/** Issue #96: node visual identity — model vendor + runtime.
+ *
+ * Single source for two orthogonal node dimensions:
+ *   - vendor : which model house powers the node (avatar body)
+ *   - runtime: which execution shell it runs in (corner badge)
+ *
+ * Both are driven by the server `model` / `runtime` fields added in
+ * commhub-server 0.8.1-preview.0 (#96 Phase 1, commit 08482ef). Old nodes
+ * report `model: null` / `runtime: null` and fall back gracefully — never a
+ * broken image or blank avatar.
+ *
+ * Adding a vendor = one entry in VENDOR_RULES. Dropping a real logo file into
+ * public/vendors/ + setting `logo` lights it up with zero render-code change;
+ * until then a vendor-tinted monogram stands in (not a fake official logo).
+ */
+
+export interface VendorIdentity {
+  id: string;
+  label: string;
+  /** Monogram fallback colours, used when `logo` is null. */
+  mono: { bg: string; ring: string; text: string };
+  /** 1-char monogram shown when there's no logo asset. */
+  initial: string;
+  /** Packaged logo asset path, or null → render the monogram instead. */
+  logo: string | null;
+}
+
+const UNKNOWN_VENDOR: VendorIdentity = {
+  id: 'unknown',
+  label: 'Unknown vendor',
+  mono: { bg: 'hsl(220 10% 26%)', ring: 'hsl(220 10% 46%)', text: 'hsl(220 14% 82%)' },
+  initial: '?',
+  logo: null,
+};
+
+// Ordered prefix rules — first match wins. `test` runs against a lowercased
+// model id. Keep the most specific prefixes first.
+const VENDOR_RULES: Array<{ test: (m: string) => boolean; vendor: VendorIdentity }> = [
+  {
+    test: (m) => m.startsWith('intern'),
+    vendor: {
+      id: 'intern',
+      label: '书生 · 上海 AI 实验室',
+      mono: { bg: 'hsl(28 38% 24%)', ring: 'hsl(32 45% 52%)', text: 'hsl(34 60% 82%)' },
+      initial: '书',
+      // #79 shipped this asset — reuse it as the 书生 vendor logo.
+      logo: '/intern_avatar.png',
+    },
+  },
+  {
+    test: (m) => m.startsWith('minimax'),
+    vendor: {
+      id: 'minimax',
+      label: 'MiniMax',
+      mono: { bg: 'hsl(18 50% 26%)', ring: 'hsl(18 65% 52%)', text: 'hsl(20 80% 82%)' },
+      initial: 'M',
+      logo: null, // → public/vendors/minimax.* when assets land
+    },
+  },
+  {
+    test: (m) => m.startsWith('claude'),
+    vendor: {
+      id: 'anthropic',
+      label: 'Anthropic',
+      mono: { bg: 'hsl(16 32% 26%)', ring: 'hsl(16 48% 54%)', text: 'hsl(18 60% 84%)' },
+      initial: 'A',
+      logo: null,
+    },
+  },
+  {
+    test: (m) => m.startsWith('gpt') || m.startsWith('codex') || m.startsWith('o1') || m.startsWith('o3') || m.startsWith('o4'),
+    vendor: {
+      id: 'openai',
+      label: 'OpenAI',
+      mono: { bg: 'hsl(165 26% 22%)', ring: 'hsl(165 40% 44%)', text: 'hsl(165 45% 80%)' },
+      initial: 'O',
+      logo: null,
+    },
+  },
+];
+
+/** Resolve a model id to its vendor identity. `null` / unmatched → UNKNOWN. */
+export function vendorForModel(model: string | null | undefined): VendorIdentity {
+  if (!model) return UNKNOWN_VENDOR;
+  const m = model.toLowerCase();
+  for (const rule of VENDOR_RULES) {
+    if (rule.test(m)) return rule.vendor;
+  }
+  return UNKNOWN_VENDOR;
+}
+
+export type Runtime = 'claude-code-cli' | 'codex-sdk' | 'claude-agent-sdk' | 'http-api';
+
+export interface RuntimeIdentity {
+  label: string;
+  /** SVG path(s) drawn inside a 0..24 viewBox for the corner badge. */
+  iconPath: string;
+  /** Badge accent colour — kept clear of working/idle/offline status hues. */
+  color: string;
+}
+
+const RUNTIME_MAP: Record<Runtime, RuntimeIdentity> = {
+  // terminal / CLI
+  'claude-code-cli': {
+    label: 'Claude Code CLI',
+    iconPath: 'M4 5h16v14H4z M7 9l3 3-3 3 M13 15h4',
+    color: '#a78bfa',
+  },
+  // code-block / SDK
+  'codex-sdk': {
+    label: 'Codex SDK',
+    iconPath: 'M9 7l-5 5 5 5 M15 7l5 5-5 5',
+    color: '#38bdf8',
+  },
+  // SDK, distinct hue from codex
+  'claude-agent-sdk': {
+    label: 'Claude Agent SDK',
+    iconPath: 'M4 7h16v10H4z M8 11h8 M8 14h5',
+    color: '#34d399',
+  },
+  // cloud / API — non-resident process
+  'http-api': {
+    label: 'HTTP API',
+    iconPath: 'M7 18a4 4 0 010-8 5 5 0 019.6-1.3A3.5 3.5 0 0118 18z',
+    color: '#fbbf24',
+  },
+};
+
+/** Resolve a server runtime string to badge identity. Unknown → null. */
+export function runtimeIdentity(runtime: string | null | undefined): RuntimeIdentity | null {
+  if (!runtime) return null;
+  return RUNTIME_MAP[runtime as Runtime] ?? null;
+}
+
+/** Compact one-line identity for hover / detail surfaces:
+ *  "Anthropic · claude-opus-4 · Claude Code CLI". Pieces with no data drop. */
+export function identityLine(model: string | null | undefined, runtime: string | null | undefined): string {
+  const v = vendorForModel(model);
+  const r = runtimeIdentity(runtime);
+  const parts: string[] = [];
+  if (v.id !== 'unknown') parts.push(v.label);
+  if (model) parts.push(model);
+  if (r) parts.push(r.label);
+  return parts.join(' · ');
+}

package/app/page.tsx

@@ -42,6 +42,10 @@ export default function Dashboard() {
   const [showDispatch, setShowDispatch] = useState(false);
   const [inbox, setInbox] = useState<InboxMessage[]>([]);
   const [agentFilter, setAgentFilter] = useState<'all' | 'working' | 'idle' | 'offline'>('all');
+  // #84: last node.renamed event — passed to TopoGraph so an open chat
+  // popover follows the rename instead of pointing at a dead alias. `ts`
+  // makes the effect re-fire even when the same from/to repeats.
+  const [renameSignal, setRenameSignal] = useState<{ from: string; to: string; ts: number } | null>(null);
   const { mutate } = useSWRConfig();
 
   // SSE: instant revalidation on CommHub events
@@ -51,6 +55,19 @@ export default function Dashboard() {
     url: '/api/hub/events',
     enabled: sseEnabled,
     onEvent: (event) => {
+      // #84 (RFC-010 §3.4): node.renamed — revalidate the session list so the
+      // new alias propagates instantly (TopoGraph + node grid re-render, the
+      // avatar hue recomputes as a pure fn of alias) instead of waiting for
+      // the next 5s poll. The renamed node's history keeps the old alias
+      // server-side, so the task list needs no revalidation here.
+      if (event.type === 'node.renamed') {
+        mutate('/api/hub/status');
+        const d = event.data as { old_alias?: string; new_alias?: string } | undefined;
+        if (d?.old_alias && d?.new_alias) {
+          setRenameSignal({ from: d.old_alias, to: d.new_alias, ts: Date.now() });
+        }
+        return;
+      }
       if (['new_task', 'new_message', 'new_reply', 'node_status_changed', 'broadcast'].includes(event.type)) {
         mutate('/api/hub/status');
         mutate((key: string) => typeof key === 'string' && key.startsWith('/api/hub/tasks'), undefined, { revalidate: true });
@@ -368,7 +385,7 @@ export default function Dashboard() {
         </div>
       )}
 
-      {showTopo && sessions.length > 0 && <TopoGraph sessions={sessions} sseSessions={sseSessions} />}
+      {showTopo && sessions.length > 0 && <TopoGraph sessions={sessions} sseSessions={sseSessions} renameSignal={renameSignal} />}
 
       {sessions.length === 0 && !sessError ? (
         <EmptyState

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@sleep2agi/agent-network-dashboard",
-  "version": "0.4.6-preview.3",
+  "version": "0.4.6-preview.301",
   "description": "Agent Network Dashboard — Web UI for managing AI Agent networks",
   "scripts": {
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
     "lint": "eslint",
-    "prepublishOnly": "rm -rf .next && npm run build"
+    "prepublishOnly": "[ -f .next/BUILD_ID ] || (echo 'prepublishOnly: .next/BUILD_ID missing — run npm run build first (see commit 05c1ebf body for R224 chunk-500 root cause)' >&2 && exit 1)"
   },
   "bin": {
     "agent-network-dashboard": "./bin/start.js"

package/scripts/chat-popover-test.mjs

@@ -17,6 +17,7 @@ async function run(nodeCount, viewport, label) {
   await ctx.addInitScript(() => {
     try {
       localStorage.setItem('anet-theme', 'cyber');
+localStorage.setItem('anet-topo-nodescale', '1');
       localStorage.removeItem('anet-brand');
       localStorage.removeItem('anet-topo-view');
       sessionStorage.setItem('anet_v3_auth', '1');
@@ -140,6 +141,7 @@ async function runFullscreen() {
   await ctx.addInitScript(() => {
     try {
       localStorage.setItem('anet-theme', 'cyber');
+      localStorage.setItem('anet-topo-nodescale', '1');
       localStorage.removeItem('anet-brand');
       localStorage.removeItem('anet-topo-view');
       sessionStorage.setItem('anet_v3_auth', '1');

package/scripts/chat-theme-test.mjs

@@ -0,0 +1,98 @@
+/* Issue #105 verification: TaskChatPanel + ChatPopover follow the dashboard
+ * light / dark theme (CSS design tokens, no hardcoded darks). Checks the
+ * popover panel + header + input resolve to a light surface under
+ * data-theme="light" and a dark one under "cyber", and captures both. */
+import { chromium } from 'playwright';
+import { readFileSync, mkdirSync } from 'node:fs';
+
+const TOKEN = JSON.parse(readFileSync('/home/vansin/.anet/config.json', 'utf8')).token;
+mkdirSync('/tmp/anet-issue-105', { recursive: true });
+const browser = await chromium.launch({ headless: true });
+
+// crude luminance from "rgb(r, g, b)" — >128 = light surface
+const isLight = (rgb) => {
+  const m = rgb.match(/\d+/g);
+  if (!m) return null;
+  const [r, g, b] = m.map(Number);
+  return (0.299 * r + 0.587 * g + 0.114 * b) > 128;
+};
+
+async function run(theme, expectLight) {
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 860 } });
+  await ctx.addCookies([{ name: 'anet_dashboard_session', value: `v3:${TOKEN}`, domain: '127.0.0.1', path: '/' }]);
+  await ctx.addInitScript((th) => {
+    try {
+      localStorage.setItem('anet-theme', th);
+localStorage.setItem('anet-topo-nodescale', '1');
+      localStorage.removeItem('anet-brand');
+      localStorage.removeItem('anet-topo-view');
+      localStorage.setItem('anet-topo-layout', 'grid');
+      sessionStorage.setItem('anet_v3_auth', '1');
+    } catch {}
+  }, theme);
+  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 fleet = Array.from({ length: 4 }, (_, i) => ({
+      alias: `节点${i + 1}号`, status: 'idle', network_id: nid,
+      created_at: '2026-05-15T00:00:00Z', updated_at: '2026-05-15T00:00:00Z', last_seen_at: '2026-05-15T00:00:00Z',
+    }));
+    await route.fulfill({ response: r, json: { ...b, sessions: fleet } });
+  });
+  await ctx.route('**/api/hub/tasks*', (route) => route.fulfill({ json: { tasks: [
+    { task_id: 't1', from_name: 'Dashboard', to_name: '节点1号', status: 'replied', priority: 'normal',
+      content: 'ping', result: 'pong — **ready**', created_at: '2026-05-15T00:00:00Z' },
+  ] } }));
+
+  const page = await ctx.newPage();
+  await page.goto('http://127.0.0.1:3000/', { waitUntil: 'domcontentloaded' });
+  await page.waitForFunction(() => {
+    const svg = document.querySelector('svg[viewBox="0 0 1000 680"]');
+    return !!svg && svg.querySelectorAll('circle[r="26"]').length > 0;
+  }, { timeout: 30000 }).catch(() => {});
+  await page.waitForTimeout(700);
+
+  // open the chat popover
+  const ring = page.locator('svg[viewBox="0 0 1000 680"] circle[r="26"]').first();
+  const bb = await ring.boundingBox();
+  if (bb) await page.mouse.wheel(0, bb.y - 160);
+  await page.waitForTimeout(150);
+  await ring.click({ force: true });
+  await page.waitForTimeout(500);
+
+  const popover = page.locator('[role="dialog"][aria-label^="Chat with"]');
+  const results = {};
+
+  const panelBg = await popover.evaluate(el => getComputedStyle(el).backgroundColor);
+  results.panelMatchesTheme = isLight(panelBg) === expectLight;
+
+  // header (first child div) + its title text colour
+  const header = popover.locator('div').first();
+  const headerBg = await header.evaluate(el => getComputedStyle(el).backgroundColor);
+  results.headerMatchesTheme = isLight(headerBg) === expectLight;
+  const titleColor = await header.locator('div.text-sm').first().evaluate(el => getComputedStyle(el).color);
+  // title text must contrast the panel: dark text on light theme, light on dark
+  results.titleContrasts = isLight(titleColor) === !expectLight;
+
+  // input textarea surface
+  const ta = popover.locator('textarea');
+  const taBg = await ta.evaluate(el => getComputedStyle(el).backgroundColor);
+  results.inputMatchesTheme = isLight(taBg) === expectLight;
+
+  await page.screenshot({ path: `/tmp/anet-issue-105/chat-${theme}.png` });
+  await ctx.close();
+
+  const ok = results.panelMatchesTheme && results.headerMatchesTheme &&
+    results.titleContrasts && results.inputMatchesTheme;
+  console.log(`${ok ? '✅' : '❌'} [${theme}] expectLight=${expectLight}:`, JSON.stringify(results), `panelBg=${panelBg}`);
+  return ok;
+}
+
+const all = [];
+all.push(await run('cyber', false));
+all.push(await run('light', true));
+await browser.close();
+const pass = all.every(Boolean);
+console.log(pass ? '\n✅ ALL PASS' : '\n❌ FAIL');
+process.exit(pass ? 0 : 1);

package/scripts/help-overlay-topo-test.mjs

@@ -0,0 +1,44 @@
+/* Round 25 verification: pressing `?` opens the help overlay, and the
+ * new "Topology canvas" section is present with the documented keys. */
+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 { sessionStorage.setItem('anet_v3_auth', '1'); } catch {}
+});
+await ctx.route('**/api/hub/status*', (route) => route.fulfill({ json: { 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.waitForTimeout(400);
+
+await page.keyboard.press('?');
+await page.waitForTimeout(200);
+
+// The overlay contains group headings; find the Topology canvas group + its rows.
+const data = await page.evaluate(() => {
+  // The group heading is a <div>; its parent wraps heading + the <ul> of items.
+  const heading = [...document.querySelectorAll('[role="dialog"] div')].find(el => el.textContent === 'Topology canvas');
+  if (!heading) return null;
+  return {
+    headingPresent: true,
+    sectionText: (heading.parentElement?.textContent || '').replace(/\s+/g, ' ').trim(),
+  };
+});
+
+await browser.close();
+const results = {
+  overlayOpened: !!data,
+  topologySectionPresent: !!data?.headingPresent,
+  hasZoomKeys: !!data && /Zoom in/.test(data.sectionText) && /Zoom out/.test(data.sectionText) && /Reset zoom/.test(data.sectionText),
+  hasMouseGestures: !!data && /wheel/.test(data.sectionText) && /Pan the canvas/.test(data.sectionText),
+  hasClickHint: !!data && /chat popover/.test(data.sectionText) && /dbl-click/.test(data.sectionText),
+};
+const ok = Object.values(results).every(Boolean);
+console.log(`${ok ? '✅' : '❌'} help overlay topology section:`, JSON.stringify(results));
+if (!ok && data) console.log('section text:', data.sectionText.slice(0, 300));
+process.exit(ok ? 0 : 1);