@sleep2agi/agent-network-dashboard 0.6.3-preview.43 → 0.6.3-preview.45

package/app/components/TopoGraph.tsx

@@ -11,6 +11,7 @@ import { vendorForModel, runtimeIdentity, identityLine } from '../lib/vendorIden
 import { parseHubTime, relativeAgo } from '../lib/time';
 import { DASHBOARD_VERSION } from '../lib/version';
 import { useChatUnread } from '../lib/chat-unread';
+import { isOnline as presenceIsOnline, sseCountFor as presenceSseCountFor } from '../lib/presence';
 
 /** v0.10.0 Hero 1+2 / §3.F server-health hook — fetches the normalized
  *  /api/hub/servers payload (preview.370 unblocked real-data via the
@@ -817,8 +818,8 @@ export function TopoGraph({ sessions, sseSessions, renameSignal }: TopoGraphProp
     treeConnectors,
     treeContentBox,
   } = useMemo(() => {
-    const sseCount = (s: { alias: string; network_id?: string }) =>
-      (s.network_id ? sseSessions[`${s.network_id}:${s.alias}`] : undefined) ?? sseSessions[s.alias];
+    // #515: unified with page.tsx / Sidebar.tsx via app/lib/presence.ts.
+    const sseCount = (s: { alias: string; network_id?: string }) => presenceSseCountFor(s, sseSessions);
     // Round 106 (issue #83): sort by alias so same-prefix agents
     // (通信龙 / 通信牛 / 通信工程马 …, or 研究员1号 / 研究员2号 …) end up
     // adjacent in the array — the tier layout below assigns angles by
@@ -837,6 +838,12 @@ export function TopoGraph({ sessions, sseSessions, renameSignal }: TopoGraphProp
     // come back while removing dead nodes well within an operator session.
     const GHOST_MS = 60 * 60 * 1000;
     const now = Date.now();
+    // #515 note: isGhost is deliberately NOT converted to presenceIsOnline —
+    // it's a different concept (age-based pruning of stale offline nodes) and
+    // its `status !== 'offline'` arm gives an intentional aliveness buffer:
+    // a node the hub still tags as `working` gets to stick around for the
+    // full GHOST_MS even if SSE dropped. Tightening that would silently
+    // shrink the visible topology on flaky-SSE hubs — separate change.
     const isGhost = (s: Session) => {
       if (s.status !== 'offline' || sseCount(s) || !s.last_seen_at) return false;
       // Round 35 / Loop: parseHubTime normalises SQL-style timestamps to UTC
@@ -845,8 +852,11 @@ export function TopoGraph({ sessions, sseSessions, renameSignal }: TopoGraphProp
       const t = parseHubTime(s.last_seen_at);
       return t !== null && now - t > GHOST_MS;
     };
-    const online = sessions.filter(s => s.status !== 'offline' || sseCount(s)).sort(byAlias);
-    const offline = sessions.filter(s => s.status === 'offline' && !sseCount(s) && !isGhost(s)).sort(byAlias);
+    // #515: online = SSE-reachable (shared with page.tsx / Sidebar via presence.ts).
+    // Old predicate (`status !== 'offline' || sseCount`) is retired — hub `status` is
+    // an unreliable signal on its own (see presence.ts and #520).
+    const online = sessions.filter(s => presenceIsOnline(s, sseSessions)).sort(byAlias);
+    const offline = sessions.filter(s => !presenceIsOnline(s, sseSessions) && !isGhost(s)).sort(byAlias);
     const positions: Record<string, Point> = {};
 
     if (layout === 'grid') {
@@ -974,7 +984,7 @@ export function TopoGraph({ sessions, sseSessions, renameSignal }: TopoGraphProp
           // preserving the node↔label overlap-test guarantee from R19.
           let w = 0, i = 0, o = 0;
           for (const s of band.members) {
-            const isOn = s.status !== 'offline' || !!sseCount(s);
+            const isOn = presenceIsOnline(s, sseSessions);
             if (s.status === 'working') w++;
             else if (isOn) i++;
             else o++;
@@ -1214,7 +1224,7 @@ export function TopoGraph({ sessions, sseSessions, renameSignal }: TopoGraphProp
       const tally = (members: Session[]) => {
         let w = 0, i = 0, o = 0;
         for (const s of members) {
-          const isOn = s.status !== 'offline' || !!sseCount(s);
+          const isOn = presenceIsOnline(s, sseSessions);
           if (s.status === 'working') w++;
           else if (isOn) i++;
           else o++;
@@ -4197,7 +4207,11 @@ export function TopoGraph({ sessions, sseSessions, renameSignal }: TopoGraphProp
               : null;
             const allSessions = [...onlineNodes, ...offlineNodes];
             const survivors = allSessions.filter(s => {
-              const isOnline = s.status !== 'offline';
+              // #515: pinned-status filter shares the presence definition too.
+              // Was `s.status !== 'offline'` (pure status), even more divergent
+              // than the count sites — a `working`-but-SSE-disconnected node
+              // would survive the `offline` pin filter and hide inside "online".
+              const isOnline = presenceIsOnline(s, sseSessions);
               if (pinnedStatus === 'working' && s.status !== 'working') return false;
               if (pinnedStatus === 'idle'    && !(isOnline && s.status !== 'working')) return false;
               if (pinnedStatus === 'offline' && isOnline) return false;
@@ -10493,8 +10507,9 @@ export function TopoGraph({ sessions, sseSessions, renameSignal }: TopoGraphProp
             const pos = nodePositions[session.alias];
             if (!pos) return null;
 
-            const sseCountFor = (session.network_id ? sseSessions[`${session.network_id}:${session.alias}`] : undefined) ?? sseSessions[session.alias];
-            const isOnline = session.status !== 'offline' || !!sseCountFor;
+            // #515: main per-node render uses the shared presence definition.
+            const sseCountFor = presenceSseCountFor(session, sseSessions);
+            const isOnline = presenceIsOnline(session, sseSessions);
             const status = nodeStatus(session, isOnline, isLight);
             const isActive = activeAliases.has(session.alias);
             // #113: node size scales with the S/M/L control; halos, labels,
@@ -15290,8 +15305,7 @@ export function TopoGraph({ sessions, sseSessions, renameSignal }: TopoGraphProp
                 {[...onlineNodes, ...offlineNodes].map(s => {
                   const p = nodePositions[s.alias];
                   if (!p) return null;
-                  const sseN = (s.network_id ? sseSessions[`${s.network_id}:${s.alias}`] : undefined) ?? sseSessions[s.alias];
-                  const isOn = s.status !== 'offline' || !!sseN;
+                  const isOn = presenceIsOnline(s, sseSessions);
                   const st = nodeStatus(s, isOn, isLight);
                   return (
                     /* Round 372 / Loop: minimap offline-dot opacity

package/app/lib/presence.ts

@@ -0,0 +1,98 @@
+// #515 / #53: single source of truth for "is this node online?" across
+// stats card / sidebar count / topology halos / chat popover / task
+// panel @-mention picker. If you add a new place that decides "online"
+// vs "offline", import isOnline() from here — don't roll your own.
+//
+// Definition: **SSE-reachable with at least one live connection**.
+// Adopted by #214 F2 (originally in app/page.tsx). Consolidated here so
+// consumers never disagree.
+//
+// Why `> 0` and not `!== undefined`:
+// - Hub `getSSEStats()` writes `sessions[name] = arr.length` and the
+//   three removal paths (cancel, rekey, dead-pushEvent) each `delete`
+//   the key when the array empties. So on the current hub the value
+//   is never `0` — but this JSON comes from a hub whose version this
+//   dashboard doesn't control (see the legacy alias-only fallback
+//   below for the version we already know we support), so treating
+//   the map defensively costs nothing and keeps the definition
+//   pointing the same direction #214 F2 took: SSE-reachable = "can I
+//   talk to it right now", and a zero-count row is not that.
+// - `!!sseLookup(s)` in the old page.tsx also treated 0 as false;
+//   preserving that keeps this a pure refactor for page.tsx.
+//
+// SSE keys in health.sse_sessions are `network_id:alias` since v0.7+
+// (per-network scoping). Legacy fallback: bare alias.
+
+export type SseSessionsMap = Record<string, unknown>;
+
+export type PresenceSubject = {
+  alias: string;
+  network_id?: string;
+};
+
+export function sseCountFor(session: PresenceSubject, sseSessions: SseSessionsMap | undefined): number | undefined {
+  if (!sseSessions) return undefined;
+  const scoped = session.network_id ? sseSessions[`${session.network_id}:${session.alias}`] : undefined;
+  const value = (scoped ?? sseSessions[session.alias]) as number | undefined;
+  return typeof value === 'number' ? value : undefined;
+}
+
+export function isOnline(session: PresenceSubject, sseSessions: SseSessionsMap | undefined): boolean {
+  const n = sseCountFor(session, sseSessions);
+  return typeof n === 'number' && n > 0;
+}
+
+// -----------------------------------------------------------------------
+// #53: three-state ambient presence signal.
+//
+// `sse_sessions` on hub's /health is **auth-gated** (post `#495-followup`
+// / `f28a6c1b`): an anonymous or wrong-scope caller gets the field
+// **completely omitted** — indistinguishable at the JSON level from
+// "no nodes connected".
+//
+// If we hand that state to isOnline() and only render numbers, the UI
+// shows a confident, consistent, and *wrong* 0 online everywhere and
+// the "three sites disagree" signal #515 used to have — which was
+// itself the clue that something upstream was broken — is gone.
+//
+// So callers need to distinguish three cases:
+//
+//   'ready'    — sseSessions is present (even if empty {}). Trust the
+//                count. `filter(isOnline).length` is the answer.
+//   'blind'    — sseSessions is absent but hub `sse_connections > 0`.
+//                Two fields contradict → we are seeing an anonymized
+//                view. Do NOT render "0 online"; render an alert.
+//   'loading'  — sseSessions is absent and no positive contradiction
+//                (either health hasn't loaded, or hub reports 0
+//                connections and no map). Render a placeholder — don't
+//                inflate the count, but don't cry wolf either.
+//
+// Callers that render user-visible counts MUST branch on this. Callers
+// that just need a per-node boolean (halos, chat-popover badges) can
+// stay on isOnline() — those degrade gracefully to "everyone offline"
+// which is the safer visual, while the ambient banner handles the
+// "why".
+// -----------------------------------------------------------------------
+
+export type PresenceStatus = 'ready' | 'blind' | 'loading';
+
+export type HealthShape = {
+  sse_connections?: number;
+} | null | undefined;
+
+export function presenceStatus(
+  sseSessions: SseSessionsMap | undefined,
+  health: HealthShape,
+): PresenceStatus {
+  if (sseSessions !== undefined) return 'ready';
+  // sseSessions is absent. Are we blind or truly empty/loading?
+  const conns = health && typeof health.sse_connections === 'number' ? health.sse_connections : 0;
+  // The contradiction case — hub says there are connections but the
+  // map isn't in this response — is the strongest "you're anonymous"
+  // signal we have.
+  if (conns > 0) return 'blind';
+  // No map AND hub reports 0 connections (or health hasn't loaded).
+  // Both look identical to us, and both should render placeholders,
+  // not "0 online" numbers. Conservative default = 'loading'.
+  return 'loading';
+}

package/app/page.tsx

@@ -18,6 +18,7 @@ import { useSessions, useHealth, useTasks, useStats } from './lib/hooks';
 import { useChatUnread } from './lib/chat-unread';
 import { isPinned, usePinVersion } from './lib/chat-pin';
 import { useSSE } from './lib/useSSE';
+import { isOnline as presenceIsOnline, sseCountFor as presenceSseCountFor, presenceStatus } from './lib/presence';
 import { useSWRConfig } from 'swr';
 
 export default function Dashboard() {
@@ -82,18 +83,20 @@ export default function Dashboard() {
   void pinVersion; // re-sort when pins change (isPinned used in comparator)
   if (isLoading) return <LoadingSkeleton />;
 
+  // #53: distinguish "we have the SSE map" from "we can't see it". The
+  // per-node `isOnline` predicate below is fine for halo/legend rendering
+  // (degrades to "everyone offline") but the header count MUST NOT
+  // confidently show 0 online when we're actually blind — HealthBanner
+  // surfaces the "why", and StatsBar renders '?' for online.
+  const presenceState = presenceStatus(health?.sse_sessions, health);
   const sseSessions = health?.sse_sessions || {};
-  // SSE keys are `network_id:alias` since v0.7+ (per-network scoping).
-  // Fall back to alias-only for legacy hubs.
-  const sseLookup = (s: { alias: string; network_id?: string }) =>
-    (s.network_id ? sseSessions[`${s.network_id}:${s.alias}`] : undefined) ?? sseSessions[s.alias];
-  // #214 F2: online = SSE-reachable ("can I talk to it right now").
-  // The old definition (status !== 'offline' OR sse) inflated the count
-  // with stale hub statuses and disagreed with /admin and /nodes, which
-  // both count pure SSE — and a "online" card you can't chat with
-  // contradicts the M2 tap-to-chat model. One definition everywhere.
-  const isOnline = (s: { alias: string; status: string; network_id?: string }) => !!sseLookup(s);
+  // #515 / #214 F2: presence = SSE-reachable ("can I talk to it right now").
+  // Definition lives in app/lib/presence.ts so stats card / sidebar /
+  // topology halos always agree. See presence.ts for why hub `status` is
+  // an unreliable signal on its own (#520).
+  const isOnline = (s: { alias: string; network_id?: string }) => presenceIsOnline(s, sseSessions);
   const online = sessions.filter(isOnline).length;
+  const presenceUnknown = presenceState !== 'ready';
   const total = sessions.length;
   const working = sessions.filter(s => s.status === 'working').length;
   // Task stats: prefer /api/stats, fallback to manual
@@ -135,7 +138,7 @@ export default function Dashboard() {
 
   return (
     <div className="min-h-screen bg-[#0b0b0d] text-gray-100 p-4 sm:p-6">
-      <StatsBar online={online} working={working} total={total} />
+      <StatsBar online={online} working={working} total={total} presenceUnknown={presenceUnknown} />
 
       {/* #217 S5 (Vincent: "极简极简，这些都可以放到设置里面去"): the
           Dispatch button and UserBar row are gone from Overview.
@@ -209,12 +212,18 @@ export default function Dashboard() {
         </div>
       )}
 
-      {sessions.length === 0 && !sessError ? (
+      {sessions.length === 0 && !sessError && presenceState === 'ready' ? (
+        // #53: only pitch "Spin up your first agent" when we actually
+        // know the fleet is empty. If presence is blind or still loading,
+        // suppress the empty state — HealthBanner already surfaces the
+        // real reason and the "first agent" CTA in that context would
+        // read as "the fleet died overnight", exactly the failure mode
+        // #53 was opened for.
         <EmptyState
           hint={sessHint}
           taskHistoryCount={Object.values(taskStats).reduce((a, b) => a + b, 0)}
         />
-      ) : (() => {
+      ) : sessions.length === 0 && !sessError ? null : (() => {
         const counts = {
           all: sortedSessions.length,
           working: sortedSessions.filter(s => isOnline(s) && s.status === 'working').length,
@@ -266,7 +275,7 @@ export default function Dashboard() {
                 xl breakpoint auto-inherits lg=3 cols; 2xl bumps to 4. */}
             <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 2xl:grid-cols-4 gap-3 sm:gap-4">
               {filtered.map(s => (
-                <AgentCard key={s.alias} session={s} hasSse={isOnline(s)} sseCount={sseLookup(s) || 0} onChat={cmd.openTab} unreadCount={unreadCount(s.alias)} />
+                <AgentCard key={s.alias} session={s} hasSse={isOnline(s)} sseCount={presenceSseCountFor(s, sseSessions) ?? 0} onChat={cmd.openTab} unreadCount={unreadCount(s.alias)} />
               ))}
             </div>
             {filtered.length === 0 && (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/agent-network-dashboard",
-  "version": "0.6.3-preview.43",
+  "version": "0.6.3-preview.45",
   "description": "Agent Network Dashboard — Web UI for managing AI Agent networks",
   "main": "apps/desktop/electron/main.cjs",
   "scripts": {

package/tests/e2e-515-presence-predicate.spec.ts

@@ -0,0 +1,75 @@
+import { test, expect } from '@playwright/test';
+import { isOnline, sseCountFor } from '../app/lib/presence';
+
+// #515 predicate unit test — the "narrow" companion to
+// tests/e2e-515-presence.spec.ts. That one proves the three DOM
+// consumers agree (integration). This one nails down the specific
+// invariant every consumer now inherits from app/lib/presence.ts:
+//
+//   A node with `status='working'` but NO SSE entry MUST classify as
+//   NOT online — because hub `status` doesn't age out on heartbeat
+//   loss (see presence.ts and #520). Historically L4204's pinnedStatus
+//   filter used pure `s.status !== 'offline'`, so pinning "offline"
+//   dropped this zombie into "online" and it hid from the offline
+//   filter — exactly the bug 通信龙 flagged as needing its own
+//   assertion so a future refactor can't silently regress it.
+//
+// If any downstream consumer of `isOnline(...)` starts special-casing
+// `status` again, THIS test goes red — matching the "unified predicate"
+// contract more precisely than a UI-level test could without hitting
+// the pin-intersection chip's two-dim activation requirement.
+
+const NET = 'net_a';
+
+test.describe('#515 predicate — SSE ground-truths presence, status alone lies', () => {
+  test('SSE-reachable with any status → online', () => {
+    const sse = { [`${NET}:working-sse`]: 1, [`${NET}:idle-sse`]: 1, [`${NET}:offline-sse`]: 2 };
+    expect(isOnline({ alias: 'working-sse', network_id: NET }, sse)).toBe(true);
+    expect(isOnline({ alias: 'idle-sse',    network_id: NET }, sse)).toBe(true);
+    // Even a node the hub already flagged offline is "online" if SSE
+    // is talking — the hub row is stale, the socket is ground truth.
+    expect(isOnline({ alias: 'offline-sse', network_id: NET }, sse)).toBe(true);
+  });
+
+  test('SSE-less with status=working → NOT online (the L4204 zombie case)', () => {
+    const sse = { [`${NET}:someone-else`]: 1 };
+    // The regression bait — before #515 this same session slipped
+    // through the pinned-offline filter and hid inside "online".
+    expect(isOnline({ alias: 'working-no-sse', network_id: NET }, sse)).toBe(false);
+  });
+
+  test('SSE-less with any status → NOT online', () => {
+    const sse = {};
+    expect(isOnline({ alias: 'w', network_id: NET }, sse)).toBe(false);
+    expect(isOnline({ alias: 'i', network_id: NET }, sse)).toBe(false);
+    expect(isOnline({ alias: 'o', network_id: NET }, sse)).toBe(false);
+  });
+
+  test('legacy alias-only SSE key still resolves (no network_id scoping)', () => {
+    const sse = { 'legacy-node': 1 };
+    // Older hubs (< v0.7) key sse_sessions by bare alias. presence
+    // falls back to bare-alias when scoped lookup misses.
+    expect(isOnline({ alias: 'legacy-node' }, sse)).toBe(true);
+    expect(isOnline({ alias: 'legacy-node', network_id: NET }, sse)).toBe(true);
+    expect(sseCountFor({ alias: 'legacy-node' }, sse)).toBe(1);
+  });
+
+  test('undefined sseSessions map → NOT online (fail-closed)', () => {
+    // If health hasn't loaded yet the map is undefined. Presence
+    // MUST fail-closed — treating undefined as "everyone online"
+    // would inflate the count during boot.
+    expect(isOnline({ alias: 'x', network_id: NET }, undefined)).toBe(false);
+  });
+
+  test('SSE value === 0 → NOT online (PR #52 round-2 finding 1)', () => {
+    // Older hubs may leave a zero-count entry in sse_sessions when the
+    // last connection dropped without cleanup. `!== undefined` would
+    // count this as online — inflating in exactly the direction #214 F2
+    // set out to eliminate. `> 0` is the SSE-reachable ground truth.
+    // page.tsx's old `!!sseLookup(s)` also treated 0 as false — so
+    // preserving `> 0` keeps this a pure refactor for that call site.
+    const sse = { [`${NET}:dead-edge`]: 0 };
+    expect(sseCountFor({ alias: 'dead-edge', network_id: NET }, sse)).toBe(0);
+    expect(isOnline({ alias: 'dead-edge', network_id: NET }, sse)).toBe(false);
+  });
+});

package/tests/e2e-515-presence.spec.ts

@@ -0,0 +1,148 @@
+import { test, expect, Page } from '@playwright/test';
+
+const BASE = process.env.TEST_URL || 'http://localhost:3100';
+
+// #515 regression test: stats card / sidebar / topology legend must show
+// the SAME "online" count when fed identical hub state. Historically each
+// site computed its own predicate (`isOnline = ...`) and they drifted
+// (page 95, sidebar 99, legend 99) — the fix extracts a single shared
+// presence.isOnline() in app/lib/presence.ts.
+//
+// SCOPE OF THIS TEST — this proves "given the same data, the 3 DOM
+// consumers render the same number", AND that number is the SSE-reachable
+// count (not the status-based count). It does NOT prove the wire fetch
+// gets sse_sessions from the right upstream endpoint — for that, see the
+// production-dashboard "before" screenshot referenced in the PR body and
+// the deploy-time smoke test. See memory
+// feedback_unit_mock_hides_wire_shape_bugs for why one class of evidence
+// doesn't cover the other.
+//
+// Fixture design (deliberately asymmetric):
+//   - SSE-reachable count differs from status-based count in ABSOLUTE
+//     value, so `expect(x).toBe(EXPECTED)` catches a mutation of the
+//     shared predicate (finding: card=sidebar=legend but wrong number)
+//     as well as drift (finding: two of three read the same, one different).
+//   - Includes a `SSE:0` node to gate the `> 0` fix from PR #52 round 2
+//     (findings 1) — a `!== undefined` predicate would count agent-06.
+
+const FIXTURE_STATUS = {
+  sessions: [
+    // present in SSE map AND status alive
+    { alias: 'agent-01', status: 'working', network_id: 'net_a' },
+    { alias: 'agent-02', status: 'idle',    network_id: 'net_a' },
+    // present in SSE map but hub row is stale — SSE wins
+    { alias: 'agent-03', status: 'offline', network_id: 'net_a' },
+    // NOT in SSE map, hub row still says working (the classic zombie)
+    { alias: 'agent-04', status: 'working', network_id: 'net_a' },
+    // NOT in SSE map, hub row still says idle
+    { alias: 'agent-05', status: 'idle',    network_id: 'net_a' },
+    // SSE map value is literally 0 (dead-connection edge from an older
+    // hub that didn't clean up empty client arrays; #515 round-2
+    // finding 1). Correct behaviour: NOT online.
+    { alias: 'agent-06', status: 'working', network_id: 'net_a' },
+  ],
+};
+
+const FIXTURE_HEALTH = {
+  ok: true,
+  version: '0.9.0-test',
+  sessions: 6,
+  sse_connections: 3,
+  sse_sessions: {
+    'net_a:agent-01': 1,
+    'net_a:agent-02': 1,
+    'net_a:agent-03': 1,
+    'net_a:agent-06': 0,  // dead-connection edge — MUST NOT count as online
+  },
+  uptime: 1,
+};
+
+// SSE-reachable with count > 0: agent-01, 02, 03 = 3
+// Status-based (retired): agent-01, 02, 04, 05, 06 = 5
+// `sseCountFor !== undefined` (finding 1 bug): 01, 02, 03, 06 = 4
+// Under status mutation → all three consumers agree on 5, absolute
+// assertion catches. Under `!== undefined` regression → all three
+// agree on 4, absolute assertion catches too. Under drift (one
+// consumer reverts to inline old) → one reads 5, others read 3.
+const EXPECTED_ONLINE = 3;
+
+async function login(context: Page['context'] extends () => infer C ? C : never) {
+  const res = await context.request.post(`${BASE}/api/auth/login`, {
+    data: { password: process.env.ANET_DASHBOARD_PASSWORD || 'admin123' },
+  });
+  const setCookie = res.headers()['set-cookie'] || '';
+  const match = setCookie.match(/anet_dashboard_session=([^;]+)/);
+  if (match) {
+    const domain = new URL(BASE).hostname;
+    await context.addCookies([{
+      name: 'anet_dashboard_session',
+      value: decodeURIComponent(match[1]),
+      domain,
+      path: '/',
+    }]);
+  }
+}
+
+async function mockHubEndpoints(page: Page) {
+  await page.route('**/api/hub/status**', async (route) => {
+    await route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(FIXTURE_STATUS) });
+  });
+  await page.route('**/api/hub/health', async (route) => {
+    await route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(FIXTURE_HEALTH) });
+  });
+  await page.route('**/api/hub/nodes**', async (route) => {
+    await route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ nodes: [] }) });
+  });
+  await page.route('**/api/hub/tasks**', async (route) => {
+    await route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ tasks: [], _hint: {} }) });
+  });
+  await page.route('**/api/hub/stats**', async (route) => {
+    await route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({}) });
+  });
+  await page.route('**/api/hub/messages**', async (route) => {
+    await route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ messages: [] }) });
+  });
+}
+
+test.describe('#515 presence — one online count everywhere', () => {
+  test('stats card / sidebar / topology legend all show the same number', async ({ page, context }) => {
+    await login(context);
+    await mockHubEndpoints(page);
+    await page.goto(`${BASE}/`);
+    await expect(page.locator('text=/\\d+\\s*\\/\\s*\\d+\\s+online/i').first()).toBeVisible({ timeout: 20000 });
+    await page.waitForTimeout(1500);
+
+    // Structural anchors — body-text regex is too greedy across the
+    // multiple "N Online" phrases on the page.
+    const cardText = await page.getByText('Online', { exact: true }).first()
+      .evaluate(el => el.previousElementSibling?.textContent ?? null);
+    const sidebarText = await page.getByRole('link', { name: /Agent Network/i }).first().innerText();
+    const sidebarMatch = sidebarText.match(/(\d+)\s*\/\s*\d+\s+online/i);
+    const legendName = await page.getByRole('link', { name: /^\d+\s+online$/i }).first().getAttribute('aria-label')
+      || await page.getByRole('link', { name: /^\d+\s+online$/i }).first().innerText();
+    const legendMatch = legendName.match(/(\d+)/);
+
+    const readings = {
+      card: cardText ? Number(cardText.trim()) : null,
+      sidebar: sidebarMatch ? Number(sidebarMatch[1]) : null,
+      legend: legendMatch ? Number(legendMatch[1]) : null,
+    };
+
+    console.log('#515 presence readings:', JSON.stringify(readings));
+
+    // Strict equality per #515 acceptance: no tolerance, no `>0` sanity.
+    // The absolute value catches "shared predicate regressed" (all three
+    // agree but wrong); the pairwise equality catches "one consumer
+    // reverted to inline old predicate" (drift).
+    expect(readings.card).toBe(EXPECTED_ONLINE);
+    expect(readings.sidebar).toBe(EXPECTED_ONLINE);
+    expect(readings.legend).toBe(EXPECTED_ONLINE);
+    expect(readings.card).toBe(readings.sidebar);
+    expect(readings.sidebar).toBe(readings.legend);
+
+    await page.screenshot({
+      path: 'test-results/e2e-515-three-numbers-agree.png',
+      fullPage: false,
+    });
+  });
+});