fix(agent-display): reject runtime-leak displayName + use canonical resolver in DM frame (#292)

Live nova↔theo smoke surfaced a runtime-label leak: the §9 inline DM
frame rendered as "@nova (openclaw (nova))". Root cause: Nova's User
row stores botMetadata.displayName = "openclaw (nova)" (literally
`<agentName> (<instanceId>)`), and the §9 chain trusted it.

Two fixes:
- resolveAgentDisplayLabel detects + rejects the leak pattern (case-
  insensitive, exact tuple only — curated labels like "Strategist
  (Aria)" are kept). Falls through to instanceId.
- agentMentionService §9 frame replaces its inline chain with a call
  to resolveAgentDisplayLabel — single source of truth.

Tests: 5 new leak-pattern cases + 7 baseline. 12/12 pass.

A one-shot backfill on dev sweeps the contaminated User rows
post-deploy. The resolver guard catches future regressions defensively.

Author: samxu01

backend/__tests__/unit/services/agentIdentityService.resolveAgentDisplayLabel.test.js

@@ -57,4 +57,54 @@ describe('resolveAgentDisplayLabel', () => {
     };
     expect(resolveAgentDisplayLabel(user)).toBe('pixel');
   });
+
+  // Leak-pattern detection — defensive guard for historical contamination.
+  // Some path (likely a DM-creation pre-2026-05-04) wrote
+  // `botMetadata.displayName = "openclaw (nova)"` (i.e. literally
+  // `${agentName} (${instanceId})`), and that string then surfaced in pod
+  // names + the §9 inline DM frame. The resolver now detects + rejects this
+  // shape and falls through to instanceId.
+  describe('leak-pattern detection', () => {
+    it('rejects displayName === "<agentName> (<instanceId>)" and falls through to instanceId', () => {
+      const user = {
+        username: 'openclaw-nova',
+        botMetadata: { displayName: 'openclaw (nova)', agentName: 'openclaw', instanceId: 'nova' },
+      };
+      expect(resolveAgentDisplayLabel(user)).toBe('nova');
+    });
+
+    it('rejects bare displayName === agentName (e.g. just "openclaw")', () => {
+      const user = {
+        username: 'openclaw-aria',
+        botMetadata: { displayName: 'openclaw', agentName: 'openclaw', instanceId: 'aria' },
+      };
+      expect(resolveAgentDisplayLabel(user)).toBe('aria');
+    });
+
+    it('is case-insensitive — "OpenClaw (Pixel)" still rejected', () => {
+      const user = {
+        username: 'openclaw-pixel',
+        botMetadata: { displayName: 'OpenClaw (Pixel)', agentName: 'openclaw', instanceId: 'pixel' },
+      };
+      expect(resolveAgentDisplayLabel(user)).toBe('pixel');
+    });
+
+    it('keeps a curated displayName that happens to share the agentName prefix', () => {
+      // "Strategist (Aria)" is curated — agentName prefix is incidental, not
+      // the literal pattern. Keep it.
+      const user = {
+        username: 'openclaw-aria',
+        botMetadata: { displayName: 'Strategist (Aria)', agentName: 'openclaw', instanceId: 'aria' },
+      };
+      expect(resolveAgentDisplayLabel(user)).toBe('Strategist (Aria)');
+    });
+
+    it('keeps a normal curated label unchanged', () => {
+      const user = {
+        username: 'openclaw-nova',
+        botMetadata: { displayName: 'Nova', agentName: 'openclaw', instanceId: 'nova' },
+      };
+      expect(resolveAgentDisplayLabel(user)).toBe('Nova');
+    });
+  });
 });

backend/services/agentIdentityService.ts

@@ -70,8 +70,29 @@ export function resolveAgentDisplayLabel(
   if (!user) return safeFallback;
   const meta = user.botMetadata;
   const display = meta?.displayName?.trim();
-  if (display) return display;
-  const instanceId = meta?.instanceId?.trim();
+  const agentName = meta?.agentName?.trim() || '';
+  const instanceId = meta?.instanceId?.trim() || '';
+  // Leak-pattern detection. If displayName is literally `<agentName> (<instanceId>)`
+  // (e.g. "openclaw (nova)"), it's the runtime label leaking through — some
+  // historical writer formatted displayName as `${agentName} (${instanceId})`
+  // instead of using the curated label. Treat these as if displayName were
+  // missing and fall through to instanceId. Matches both the
+  // `<runtime> (<instance>)` form and the bare `<runtime>` form
+  // (e.g. displayName === 'openclaw'). Also catches the case where
+  // displayName equals just instanceId — the chain below would render the
+  // same thing, but we drop the redundant pass here.
+  const leakedPattern = (
+    !!display
+    && !!agentName
+    && (
+      display.toLowerCase() === agentName.toLowerCase()
+      || (
+        !!instanceId
+        && display.toLowerCase() === `${agentName.toLowerCase()} (${instanceId.toLowerCase()})`
+      )
+    )
+  );
+  if (display && !leakedPattern) return display;
   if (instanceId && instanceId !== 'default') return instanceId;
   if (user.username) return user.username;
   return safeFallback;

backend/services/agentMentionService.ts

@@ -10,6 +10,13 @@ const Pod = require('../models/Pod');
 const User = require('../models/User');
 // eslint-disable-next-line global-require
 const chatSummarizerService = require('./chatSummarizerService');
+// eslint-disable-next-line global-require, @typescript-eslint/no-require-imports
+const { resolveAgentDisplayLabel } = require('./agentIdentityService') as {
+  resolveAgentDisplayLabel: (
+    user: { username?: string; botMetadata?: { displayName?: string; instanceId?: string; agentName?: string } } | null | undefined,
+    fallback?: string,
+  ) => string;
+};
 
 const ChatSummarizerService = chatSummarizerService.constructor as {
   getLatestPodSummary: (podId: string) => Promise<unknown>;
@@ -747,15 +754,17 @@ const enqueueDmEvent = async ({
     // which §9 of ADR-012 demonstrated is not sufficient. Either re-apply the
     // frame in that surface or move framing into AgentEventService.enqueue
     // when it becomes a meaningful chokepoint.
+    // resolveAgentDisplayLabel is the canonical chain (botMetadata.displayName
+    // → instanceId → username → fallback) plus leak-pattern detection that
+    // skips displayName values shaped like `<agentName> (<instanceId>)` (the
+    // historical runtime-label leak that produced labels like
+    // "openclaw (nova)"). Using it here keeps the §9 frame consistent with
+    // every other display surface (pod inspector, chat author chips, etc).
     const senderMeta = sender?.botMetadata || {};
     const senderInstanceLabel = (senderMeta.instanceId && senderMeta.instanceId !== 'default')
       ? senderMeta.instanceId
       : '';
-    const senderDisplay = (senderMeta.displayName?.trim()
-      || senderInstanceLabel
-      || sender?.username
-      || username
-      || 'peer').trim();
+    const senderDisplay = resolveAgentDisplayLabel(sender, sender?.username || username || 'peer').trim();
     // senderHandle filters 'default' the same way as senderDisplay above —
     // otherwise an agent on the literal 'default' instanceId would render as
     // "@default (DisplayName)", which is meaningless.