@xmoxmo/bncr 0.4.6 → 0.4.8

package/src/plugin/channel-runtime-builders-delivery.ts

@@ -7,6 +7,7 @@ import type {
   FileSendTransferState,
   OutboxEntry,
 } from '../core/types.ts';
+import type { BncrGroupHistoryMap } from '../messaging/inbound/group-history.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import type {
   NormalizedReplyPayload,
@@ -18,7 +19,11 @@ import type {
   buildInboundAcceptedLifecycleDebugInfo as buildInboundAcceptedLifecycleDebugInfoFromRuntime,
   buildInboundResponsePayload as buildInboundResponsePayloadFromRuntime,
 } from './channel-inbound-helpers.ts';
-import type { BncrChannelConfigRoot, BncrVerifiedTarget } from './channel-runtime-types.ts';
+import type {
+  BncrChannelConfigRoot,
+  BncrSceneRecord,
+  BncrVerifiedTarget,
+} from './channel-runtime-types.ts';
 import type { LeaseEventPayload } from './connection-handlers.ts';
 import type { BncrActiveConnectionDebugEntry } from './connection-state.ts';
 import type { FileAckPayloadState, FileAckWaiter } from './file-ack-runtime.ts';
@@ -121,6 +126,11 @@ export function buildBncrStateTransientRuntime(deps: {
   maxDeadLetterEntries: number;
   maxSessionRouteEntries: number;
   maxAccountActivityEntries: number;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: Map<
+    string,
+    import('./channel-runtime-types.ts').BncrPersistedGroupHistoryEntry[]
+  >;
   outbox: Map<string, OutboxEntry>;
   getDeadLetter: () => OutboxEntry[];
   setDeadLetter: (entries: OutboxEntry[]) => void;
@@ -446,6 +456,15 @@ export function buildBncrInboundSurfaceRuntime(deps: {
     peer?: unknown;
     channelId?: string;
   }) => string;
+  defaultAdminAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    peer?: unknown;
+    channelId?: string;
+  }) => string;
+  defaultPublicAgentId: () => string;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: BncrGroupHistoryMap;
   prepareInboundAcceptance: (args: {
     parsed: ReturnType<typeof parseBncrInboundParams>;
     canonicalAgentId: string;
@@ -456,6 +475,9 @@ export function buildBncrInboundSurfaceRuntime(deps: {
         sessionKey: string;
         inboundText: string;
         hasMedia: boolean;
+        resolvedAgentId: string;
+        shouldDispatch: boolean;
+        shouldAccumulate: boolean;
       }
     | {
         ok: false;
@@ -486,6 +508,7 @@ export function buildBncrInboundSurfaceRuntime(deps: {
   }) => Promise<void>;
   setInboundActivity: (accountId: string, at: number) => void;
   scheduleSave: () => void;
+  buildCanonicalSessionKey: (route: BncrRoute) => string;
   fileRecvTransfers: Parameters<typeof createBncrFileInboundHandlers>[0]['fileRecvTransfers'];
   inboundFileTransferMaxBytes: number;
   inboundFileTransferMaxChunks: number;

package/src/plugin/channel-runtime-types.ts

@@ -44,6 +44,46 @@ export type BncrPersistedLastSession = {
   updatedAt: number;
 };
 
+export type BncrSceneKind = 'direct' | 'group';
+
+export type BncrSceneStatus = 'pending' | 'allowed' | 'denied';
+
+export type BncrGroupReplyMode = 'admin' | 'mention' | 'hybrid' | 'all';
+
+export type BncrSceneRecord = {
+  sceneKey: string;
+  kind: BncrSceneKind;
+  status: BncrSceneStatus;
+  platform: string;
+  userId?: string;
+  userName?: string;
+  groupId?: string;
+  groupName?: string;
+  agentId?: string;
+  groupReplyMode?: BncrGroupReplyMode;
+  lastSeenAt: number;
+};
+
+export type BncrPersistedGroupHistoryEntry = {
+  sender: string;
+  body: string;
+  timestamp?: number;
+  messageId?: string;
+  media?: BncrPersistedGroupHistoryMediaEntry[];
+};
+
+export type BncrPersistedGroupHistoryMediaEntry = {
+  path?: string;
+  contentType?: string;
+  kind?: 'image' | 'video' | 'audio' | 'document' | 'unknown';
+  messageId?: string;
+};
+
+export type BncrPersistedGroupHistoryBucket = {
+  key: string;
+  entries: BncrPersistedGroupHistoryEntry[];
+};
+
 export type BncrStatusRuntimeSnapshot = {
   connected?: boolean;
   running?: boolean;
@@ -133,6 +173,8 @@ export type PersistedState = {
   outbox: OutboxEntry[];
   deadLetter: OutboxEntry[];
   sessionRoutes: BncrPersistedSessionRoute[];
+  sceneRegistry?: BncrSceneRecord[];
+  groupHistories?: BncrPersistedGroupHistoryBucket[];
   lastSessionByAccount?: BncrPersistedLastSession[];
   lastActivityByAccount?: BncrPersistedAccountTimestamp[];
   lastInboundByAccount?: BncrPersistedAccountTimestamp[];

package/src/plugin/file-inbound-init.ts

@@ -45,34 +45,49 @@ export function createBncrFileInboundInitHandler(runtime: BncrFileInboundRuntime
     const chunkSize = runtime.finiteNonNegativeNumberOrNull(params?.chunkSize ?? 256 * 1024);
     const totalChunks = runtime.finiteNonNegativeNumberOrNull(params?.totalChunks);
     const fileSha256 = runtime.asString(params?.fileSha256 || '').trim();
+    const routeFromParams = runtime.parseRouteLike({
+      platform: runtime.asString(params?.platform || '').trim(),
+      groupId: runtime.asString(params?.groupId || '0').trim() || '0',
+      userId: runtime.asString(params?.userId || '0').trim() || '0',
+    });
+
+    const reject = (error: string) => {
+      runtime.logWarn(
+        'file',
+        `file.init reject accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId || '-'} error=${error} sessionKey=${sessionKey || '-'} fileSize=${fileSize ?? 'null'} chunkSize=${chunkSize ?? 'null'} totalChunks=${totalChunks ?? 'null'}`,
+      );
+      respond(false, { error });
+    };
 
     if (!transferId || !sessionKey || !fileSize || !chunkSize || !totalChunks) {
-      respond(false, { error: 'transferId/sessionKey/fileSize/chunkSize/totalChunks required' });
+      reject('transferId/sessionKey/fileSize/chunkSize/totalChunks required');
       return;
     }
     if (fileSize > runtime.inboundFileTransferMaxBytes) {
-      respond(false, {
-        error: `fileSize too large size=${fileSize} max=${runtime.inboundFileTransferMaxBytes}`,
-      });
+      reject(`fileSize too large size=${fileSize} max=${runtime.inboundFileTransferMaxBytes}`);
       return;
     }
     if (totalChunks > runtime.inboundFileTransferMaxChunks) {
-      respond(false, {
-        error: `totalChunks too large total=${totalChunks} max=${runtime.inboundFileTransferMaxChunks}`,
-      });
+      reject(
+        `totalChunks too large total=${totalChunks} max=${runtime.inboundFileTransferMaxChunks}`,
+      );
       return;
     }
     const expectedTotalChunks = Math.ceil(fileSize / chunkSize);
     if (totalChunks !== expectedTotalChunks) {
-      respond(false, {
-        error: `totalChunks mismatch total=${totalChunks} expected=${expectedTotalChunks}`,
-      });
+      reject(`totalChunks mismatch total=${totalChunks} expected=${expectedTotalChunks}`);
       return;
     }
 
-    const normalized = runtime.normalizeStoredSessionKey(sessionKey);
+    let normalized = runtime.normalizeStoredSessionKey(sessionKey);
+    if (!normalized && routeFromParams) {
+      normalized = {
+        sessionKey: runtime.buildCanonicalSessionKey(routeFromParams),
+        route: routeFromParams,
+      };
+    }
     if (!normalized) {
-      respond(false, { error: 'invalid sessionKey' });
+      reject('invalid sessionKey');
       return;
     }
 

package/src/plugin/file-inbound-runtime.ts

@@ -1,4 +1,5 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrSessionKind } from '../core/targets.ts';
 import type { BncrRoute, FileRecvTransferState } from '../core/types.ts';
 
 export type BncrFileInboundLeaseEventKind =
@@ -40,6 +41,7 @@ export type BncrFileInboundRuntime = {
   normalizeStoredSessionKey: (
     sessionKey: string,
   ) => { sessionKey: string; route: BncrRoute } | null;
+  buildCanonicalSessionKey: (route: BncrRoute, kind?: BncrSessionKind) => string;
   saveInboundMediaBuffer: (args: {
     buffer: Buffer;
     mimeType: string;

package/src/plugin/inbound-acceptance.ts

@@ -1,13 +1,66 @@
+import { hasControlCommand } from 'openclaw/plugin-sdk/command-auth';
 import { resolveAccount } from '../core/accounts.ts';
 import { checkBncrMessageGate } from '../messaging/inbound/gate.ts';
+import { parseBncrNativeCommand } from '../messaging/inbound/native-command.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import type { OpenClawResolvedAgentRoute } from '../openclaw/routing-runtime.ts';
 import type { buildInboundResponsePayload } from './channel-inbound-helpers.ts';
 import { resolveInboundSessionContext } from './channel-inbound-helpers.ts';
-import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+import type { BncrChannelConfigRoot, BncrSceneRecord } from './channel-runtime-types.ts';
+import { decideSceneAdmission } from './scene-registry.ts';
 
 type InboundAcceptanceResponsePayload = ReturnType<typeof buildInboundResponsePayload>;
 
+function shouldDispatchForScene(args: {
+  parsed: ReturnType<typeof parseBncrInboundParams>;
+  admission: ReturnType<typeof decideSceneAdmission>;
+  cfg: BncrChannelConfigRoot;
+}) {
+  const { parsed, admission, cfg } = args;
+  if (parsed.peer.kind === 'direct') return true;
+  if (!admission.allowed) return false;
+
+  const isBncrNativeCommand =
+    parseBncrNativeCommand(parsed.extracted.text, {
+      allowBareWhoami: parsed.isAdmin !== true,
+    }) !== null;
+  const isAdminOpenClawNativeCommand =
+    parsed.isAdmin === true &&
+    !isBncrNativeCommand &&
+    hasControlCommand(parsed.extracted.text, cfg as Parameters<typeof hasControlCommand>[1]);
+  if (isAdminOpenClawNativeCommand) return true;
+
+  const mode = admission.scene.groupReplyMode || 'admin';
+  if (mode === 'all') return true;
+  if (mode === 'admin') return parsed.isAdmin === true;
+  if (mode === 'mention') return parsed.shouldRespond === true;
+  return parsed.isAdmin === true || parsed.shouldRespond === true;
+}
+
+function shouldAccumulateForScene(args: {
+  parsed: ReturnType<typeof parseBncrInboundParams>;
+  admission: ReturnType<typeof decideSceneAdmission>;
+  cfg: BncrChannelConfigRoot;
+}) {
+  const { parsed, admission, cfg } = args;
+  if (parsed.peer.kind === 'direct') return true;
+  if (!admission.allowed) return false;
+
+  const isBncrNativeCommand =
+    parseBncrNativeCommand(parsed.extracted.text, {
+      allowBareWhoami: parsed.isAdmin !== true,
+    }) !== null;
+  const isAdminOpenClawNativeCommand =
+    parsed.isAdmin === true &&
+    !isBncrNativeCommand &&
+    hasControlCommand(parsed.extracted.text, cfg as Parameters<typeof hasControlCommand>[1]);
+  if (isAdminOpenClawNativeCommand) return true;
+
+  const mode = admission.scene.groupReplyMode || 'admin';
+  if (mode === 'admin') return parsed.isAdmin === true;
+  return true;
+}
+
 export async function prepareBncrInboundAcceptance(args: {
   api: unknown;
   parsed: ReturnType<typeof parseBncrInboundParams>;
@@ -27,6 +80,10 @@ export async function prepareBncrInboundAcceptance(args: {
       | { kind: 'gate-denied'; accountId: string; msgId?: string | null; reason: string },
   ) => InboundAcceptanceResponsePayload;
   markInboundDedupSeen: (key: string) => boolean;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  now: () => number;
+  defaultAdminAgentId: string;
+  defaultPublicAgentId: string;
 }) {
   const { parsed, canonicalAgentId } = args;
   const {
@@ -83,6 +140,26 @@ export async function prepareBncrInboundAcceptance(args: {
     };
   }
 
+  const admission = decideSceneAdmission({
+    parsed,
+    now: args.now(),
+    sceneRegistry: args.sceneRegistry,
+    defaultAdminAgentId: args.defaultAdminAgentId,
+    defaultPublicAgentId: args.defaultPublicAgentId,
+  });
+  if (!admission.allowed) {
+    return {
+      ok: false as const,
+      status: admission.replyPolicy === 'pending',
+      payload: args.buildInboundResponsePayload({
+        kind: 'gate-denied',
+        accountId,
+        msgId: msgId ?? null,
+        reason: admission.reason,
+      }),
+    };
+  }
+
   const { sessionKey, inboundText } = resolveInboundSessionContext({
     cfg,
     accountId,
@@ -90,6 +167,7 @@ export async function prepareBncrInboundAcceptance(args: {
     route,
     sessionKeyFromRoute: sessionKeyfromroute,
     canonicalAgentId,
+    resolvedAgentId: admission.agentId,
     taskKey: extracted.taskKey ?? undefined,
     text,
     extractedText: extracted.text,
@@ -103,5 +181,8 @@ export async function prepareBncrInboundAcceptance(args: {
     sessionKey,
     inboundText,
     hasMedia: Boolean(mediaBase64 || mediaPathFromTransfer),
+    resolvedAgentId: admission.agentId,
+    shouldDispatch: shouldDispatchForScene({ parsed, admission, cfg }),
+    shouldAccumulate: shouldAccumulateForScene({ parsed, admission, cfg }),
   };
 }

package/src/plugin/inbound-handlers.ts

@@ -1,11 +1,14 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import { buildCanonicalBncrSessionKey } from '../core/targets.ts';
 import type { BncrConnection, BncrRoute } from '../core/types.ts';
+import type { BncrGroupHistoryMap } from '../messaging/inbound/group-history.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
+import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
 import type {
   buildInboundResponsePayload,
   resolveInboundSessionContext,
 } from './channel-inbound-helpers.ts';
-import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+import type { BncrChannelConfigRoot, BncrSceneRecord } from './channel-runtime-types.ts';
 import { buildBncrGatewayEventContext } from './gateway-event-context.ts';
 
 type InboundLifecycleStage = 'accepted';
@@ -39,6 +42,9 @@ type InboundAcceptanceResult =
       sessionKey: string;
       inboundText: string;
       hasMedia: boolean;
+      resolvedAgentId: string;
+      shouldDispatch: boolean;
+      shouldAccumulate: boolean;
     }
   | {
       ok: false;
@@ -46,6 +52,26 @@ type InboundAcceptanceResult =
       payload: Record<string, unknown>;
     };
 
+function buildBncrPendingDirectApprovalNotice(args: {
+  parsed: ParsedInboundParams;
+  reason: string;
+}): string | null {
+  if (args.parsed.peer.kind !== 'direct') return null;
+  if (args.reason !== 'scene pending approval') return null;
+  return `This private chat is pending approval. Ask the administrator to allow your SceneId: ${args.parsed.platform}:${args.parsed.userId}`;
+}
+
+function buildBncrPendingDirectApprovalPayload(args: {
+  msgId?: string;
+  text: string;
+}): ReplyPayloadInput {
+  return {
+    text: args.text,
+    kind: 'final',
+    ...(args.msgId ? { replyToId: args.msgId } : {}),
+  };
+}
+
 export type BncrInboundHandlersRuntime = {
   channelId: string;
   bridgeId: string;
@@ -98,6 +124,15 @@ export type BncrInboundHandlersRuntime = {
     peer: EnsureCanonicalAgentIdPeer;
     channelId: string;
   }) => string;
+  defaultAdminAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    peer: EnsureCanonicalAgentIdPeer;
+    channelId: string;
+  }) => string;
+  defaultPublicAgentId: () => string;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: BncrGroupHistoryMap;
   prepareInboundAcceptance: (args: {
     parsed: ParsedInboundParams;
     canonicalAgentId: string;
@@ -110,12 +145,27 @@ export type BncrInboundHandlersRuntime = {
     text: string;
     hasMedia: boolean;
   }) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    payload: ReplyPayloadInput;
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<void>;
   respond: GatewayRequestHandlerOptions['respond'];
   flushOnInboundAccepted: (accountId: string) => void;
   dispatchInbound: (args: {
     cfg: BncrChannelConfigRoot;
     parsed: ParsedInboundParams;
     canonicalAgentId: string;
+    resolvedAgentId: string;
+    shouldDispatch: boolean;
+    shouldAccumulate: boolean;
+    sceneRegistry: Map<string, BncrSceneRecord>;
+    groupHistories: BncrGroupHistoryMap;
+    defaultAdminAgentId: string;
+    defaultPublicAgentId: string;
+    now: () => number;
   }) => Promise<unknown>;
 };
 
@@ -191,13 +241,50 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
         peer,
         channelId: runtime.channelId,
       });
+      const defaultAdminAgentId = runtime.defaultAdminAgentId({
+        cfg,
+        accountId,
+        peer,
+        channelId: runtime.channelId,
+      });
       const acceptance = await runtime.prepareInboundAcceptance({ parsed, canonicalAgentId });
       if (!acceptance.ok) {
+        const reason = runtime
+          .asString((acceptance.payload as { reason?: unknown })?.reason || '')
+          .trim();
+        runtime.logInfo(
+          'inbound',
+          `accept reject|accountId=${accountId}|msgId=${msgId ?? '-'}|scope=${runtime.formatDisplayScope(route)}|chatType=${peer.kind}|msgType=${msgType}|status=${acceptance.status}|reason=${reason || '-'}|isAdmin=${parsed.isAdmin === true}|shouldRespond=${parsed.shouldRespond === true}`,
+        );
+        const pendingNotice = buildBncrPendingDirectApprovalNotice({ parsed, reason });
+        if (pendingNotice) {
+          const sessionKey = buildCanonicalBncrSessionKey(route, canonicalAgentId);
+          await runtime.enqueueFromReply({
+            accountId,
+            sessionKey,
+            route,
+            payload: buildBncrPendingDirectApprovalPayload({
+              msgId: msgId ?? undefined,
+              text: pendingNotice,
+            }),
+          });
+        }
         respond(acceptance.status, acceptance.payload);
         return;
       }
 
-      const { sessionKey, inboundText, hasMedia } = acceptance;
+      const {
+        sessionKey,
+        inboundText,
+        hasMedia,
+        resolvedAgentId,
+        shouldDispatch,
+        shouldAccumulate,
+      } = acceptance;
+      runtime.logInfo(
+        'inbound',
+        `accept ok|accountId=${accountId}|msgId=${msgId ?? '-'}|scope=${runtime.formatDisplayScope(route)}|chatType=${peer.kind}|msgType=${msgType}|sessionKey=${sessionKey}|agent=${resolvedAgentId}|dispatch=${shouldDispatch}|accumulate=${shouldAccumulate}|isAdmin=${parsed.isAdmin === true}|shouldRespond=${parsed.shouldRespond === true}`,
+      );
       runtime.logInfo(
         'inbound',
         JSON.stringify({
@@ -239,6 +326,14 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
           cfg,
           parsed,
           canonicalAgentId,
+          resolvedAgentId,
+          shouldDispatch,
+          shouldAccumulate,
+          sceneRegistry: runtime.sceneRegistry,
+          groupHistories: runtime.groupHistories,
+          defaultAdminAgentId,
+          defaultPublicAgentId: runtime.defaultPublicAgentId(),
+          now: runtime.now,
         })
         .catch((err) => {
           runtime.logError('inbound', `process failed: ${String(err)}`, { debugOnly: true });

package/src/plugin/inbound-surface-handlers-group.ts

@@ -53,6 +53,9 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     clientId?: string;
     context: GatewayRequestHandlerOptions['context'];
   }) => void;
+  buildCanonicalSessionKey: Parameters<
+    typeof createBncrFileInboundHandlersComponent
+  >[0]['buildCanonicalSessionKey'];
   refreshLiveConnectionState: (args: {
     accountId: string;
     connId: string;
@@ -75,6 +78,14 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
   ensureCanonicalAgentId: Parameters<
     typeof createBncrInboundHandlersComponent
   >[0]['ensureCanonicalAgentId'];
+  defaultAdminAgentId: Parameters<
+    typeof createBncrInboundHandlersComponent
+  >[0]['defaultAdminAgentId'];
+  defaultPublicAgentId: Parameters<
+    typeof createBncrInboundHandlersComponent
+  >[0]['defaultPublicAgentId'];
+  sceneRegistry: Parameters<typeof createBncrInboundHandlersComponent>[0]['sceneRegistry'];
+  groupHistories: Parameters<typeof createBncrInboundHandlersComponent>[0]['groupHistories'];
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlersComponent
   >[0]['prepareInboundAcceptance'];
@@ -111,6 +122,7 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     matchesTransferOwner: runtime.matchesTransferOwner,
     refreshAcceptedFileTransferLiveState: runtime.refreshAcceptedFileTransferLiveState,
     logWarn: runtime.logWarn,
+    buildCanonicalSessionKey: runtime.buildCanonicalSessionKey,
     fileRecvTransfers: runtime.fileRecvTransfers,
     inboundFileTransferMaxBytes: runtime.inboundFileTransferMaxBytes,
     inboundFileTransferMaxChunks: runtime.inboundFileTransferMaxChunks,
@@ -136,6 +148,10 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     buildActiveConnectionDebugList: runtime.buildActiveConnectionDebugList,
     markLastInboundAt: runtime.markLastInboundAt,
     ensureCanonicalAgentId: runtime.ensureCanonicalAgentId,
+    defaultAdminAgentId: runtime.defaultAdminAgentId,
+    defaultPublicAgentId: runtime.defaultPublicAgentId,
+    sceneRegistry: runtime.sceneRegistry,
+    groupHistories: runtime.groupHistories,
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     logInboundSummary: runtime.logInboundSummary,
     flushPushQueueBestEffort: runtime.flushPushQueueBestEffort,

package/src/plugin/messaging.ts

@@ -10,6 +10,15 @@ import {
 } from '../messaging/outbound/target-resolver.ts';
 import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
 
+function formatBncrHumanDisplay(route: BncrRoute): string {
+  const platform = asSanitizedString(route?.platform).trim();
+  const groupId = asSanitizedString(route?.groupId).trim();
+  const userId = asSanitizedString(route?.userId).trim();
+  if (platform && groupId && groupId !== '0') return `Bncr:${platform}:Group:${groupId}`;
+  if (platform && userId && userId !== '0') return `Bncr:${platform}:User:${userId}`;
+  return formatDisplayScope(route);
+}
+
 type BncrMessagingRuntimeBridge = {
   canonicalAgentId?: string;
   ensureCanonicalAgentId: (params: { cfg: BncrChannelConfigRoot; accountId: string }) => string;
@@ -69,16 +78,24 @@ export function normalizeBncrMessagingTarget(raw: string) {
 }
 
 export function formatBncrMessagingTargetDisplay({ target }: BncrMessagingTargetDisplayInput) {
-  if (typeof target === 'string') return asSanitizedString(target).trim();
+  if (typeof target === 'string') {
+    const parsed = parseExplicitTarget(asSanitizedString(target).trim());
+    return parsed?.route ? formatBncrHumanDisplay(parsed.route) : asSanitizedString(target).trim();
+  }
   if (!isDisplayTarget(target)) return '';
   const displayScope = asSanitizedString(target?.displayScope || target?.to).trim();
-  if (displayScope) return displayScope;
+  if (displayScope) {
+    const parsed = parseExplicitTarget(displayScope);
+    if (parsed?.route) return formatBncrHumanDisplay(parsed.route);
+    return displayScope;
+  }
   if (target.platform || target.groupId || target.userId) {
-    return formatDisplayScope({
+    const route = {
       platform: asSanitizedString(target.platform).trim(),
       groupId: asSanitizedString(target.groupId).trim(),
       userId: asSanitizedString(target.userId).trim(),
-    });
+    };
+    return formatBncrHumanDisplay(route);
   }
   return '';
 }
@@ -188,7 +205,7 @@ export function createBncrMessagingTargetResolver(getBridge: () => BncrMessaging
       return {
         to: resolved.displayScope,
         kind: resolved.kind,
-        display: resolved.displayScope,
+        display: formatBncrHumanDisplay(resolved.route),
         source: 'normalized' as const,
       };
     },