@xmoxmo/bncr 0.4.5 → 0.4.7

package/src/messaging/inbound/dispatch-prep.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { hasControlCommand } from 'openclaw/plugin-sdk/command-auth';
 import {
   formatDisplayScope,
   normalizeInboundSessionKey,
@@ -19,6 +20,7 @@ import {
 } from '../../openclaw/routing-runtime.ts';
 import type { BncrInboundApi, BncrInboundConfig, BncrRememberSessionRoute } from './contracts.ts';
 import { INBOUND_MEDIA_URL_MAX_BYTES, isHttpMediaUrl } from './media-url-download.ts';
+import { parseBncrNativeCommand } from './native-command.ts';
 import { loadInboundRemoteMedia } from './remote-media.ts';
 
 export type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
@@ -27,6 +29,7 @@ export type BncrInboundConversationResolution = {
   accountId: string;
   chatType: 'direct' | 'group';
   route: ParsedInbound['route'];
+  originalResolvedRouteSessionKey: string;
   resolvedRoute: {
     sessionKey: string;
     agentId: string;
@@ -51,6 +54,13 @@ export type BncrInboundReplyRouteFact = {
 
 export type BncrPreparedInboundSessionContext = {
   storePath: string;
+  mediaItems: Array<{
+    path: string;
+    contentType?: string;
+    fileName?: string;
+    kind: 'image' | 'video' | 'audio' | 'document';
+    transferId?: string;
+  }>;
   mediaPath?: string;
   mediaContentType?: string;
   rawBody: string;
@@ -63,10 +73,27 @@ export type BncrInboundPreparation = {
   replyRouteFact: BncrInboundReplyRouteFact;
   senderIdForContext: string;
   senderDisplayName: string;
+  ownerAllowFrom?: string[];
+  bridgeSenderId?: string;
+  bridgeSenderName?: string;
 };
 
 const INBOUND_MEDIA_MAX_BYTES = 30 * 1024 * 1024;
 
+const BNCR_GENERIC_MEDIA_TEXTS = new Set([
+  '收到媒体文件',
+  '收到图片',
+  '收到视频',
+  '收到语音',
+  '收到音频',
+  '收到文件',
+  '[图片]',
+  '[视频]',
+  '[语音]',
+  '[音频]',
+  '[文件]',
+]);
+
 function assertResolvedAgentRoute(resolvedRoute: OpenClawResolvedAgentRoute): {
   sessionKey: string;
   agentId: string;
@@ -90,14 +117,140 @@ function formatRawBncrInboundTarget(route: ParsedInbound['route']): string {
   return `Bncr:${String(route.platform || '').trim()}:${String(route.groupId || '').trim()}:${String(route.userId || '').trim()}`;
 }
 
+function inferBncrInboundMediaKind(args: {
+  msgType?: string;
+  mediaContentType?: string;
+}): 'image' | 'video' | 'audio' | 'document' {
+  const msgType = String(args.msgType || '')
+    .trim()
+    .toLowerCase();
+  const contentType = String(args.mediaContentType || '')
+    .trim()
+    .toLowerCase();
+  if (msgType === 'image' || contentType.startsWith('image/')) return 'image';
+  if (msgType === 'video' || contentType.startsWith('video/')) return 'video';
+  if (msgType === 'audio' || msgType === 'voice' || contentType.startsWith('audio/'))
+    return 'audio';
+  return 'document';
+}
+
+function isBncrGenericMediaText(value: string): boolean {
+  const normalized = String(value || '').trim();
+  if (!normalized) return true;
+  return BNCR_GENERIC_MEDIA_TEXTS.has(normalized);
+}
+
+function resolveBncrInboundRawBody(args: {
+  extractedText?: string;
+  msgType?: string;
+  mediaItems?: Array<{ contentType?: string; kind?: string }>;
+}) {
+  const text = String(args.extractedText || '').trim();
+  if (
+    String(args.msgType || 'text')
+      .trim()
+      .toLowerCase() === 'text'
+  )
+    return text;
+  if (text && !isBncrGenericMediaText(text)) return text;
+  const items = Array.isArray(args.mediaItems) ? args.mediaItems : [];
+  if (items.length === 0) {
+    const mediaKind = inferBncrInboundMediaKind({
+      msgType: args.msgType,
+      mediaContentType: undefined,
+    });
+    return `<media:${mediaKind}>`;
+  }
+  const kinds = items
+    .map((item) =>
+      String(item?.kind || '')
+        .trim()
+        .toLowerCase(),
+    )
+    .filter(Boolean);
+  const contentTypes = items.map((item) => String(item?.contentType || '').trim()).filter(Boolean);
+  const firstKind =
+    kinds[0] ||
+    inferBncrInboundMediaKind({
+      msgType: args.msgType,
+      mediaContentType: contentTypes[0],
+    });
+  const uniformKind =
+    kinds.length > 0 && kinds.every((candidate) => candidate === firstKind)
+      ? firstKind
+      : 'document';
+  const count = Math.max(items.length, 1);
+  if (count <= 1) return `<media:${uniformKind}>`;
+  if (uniformKind === 'image') return `<media:image> (${count} images)`;
+  if (uniformKind === 'video') return `<media:video> (${count} videos)`;
+  if (uniformKind === 'audio') return `<media:audio> (${count} audio attachments)`;
+  return `<media:document> (${count} attachments)`;
+}
+
+async function saveBncrInboundMediaItem(args: {
+  api: BncrInboundApi;
+  item: ParsedInbound['mediaItems'][number];
+}) {
+  const pathFromTransfer = String(args.item?.path || '').trim();
+  const base64 = String(args.item?.base64 || '').trim();
+  const mimeType = String(args.item?.mimeType || '').trim() || undefined;
+  const fileName = String(args.item?.fileName || '').trim() || undefined;
+  const transferId = String(args.item?.transferId || '').trim() || undefined;
+  let mediaPath: string | undefined;
+  let mediaContentType = mimeType;
+  if (base64) {
+    const mediaBuf = decodeInboundMediaBase64(base64);
+    const saved = await saveOpenClawChannelMediaBuffer(
+      args.api,
+      mediaBuf,
+      mimeType,
+      'inbound',
+      30 * 1024 * 1024,
+      fileName,
+    );
+    mediaPath = saved.path;
+  } else if (pathFromTransfer && isHttpMediaUrl(pathFromTransfer)) {
+    const downloaded = await loadInboundRemoteMedia(
+      args.api,
+      pathFromTransfer,
+      INBOUND_MEDIA_URL_MAX_BYTES,
+    );
+    mediaContentType = downloaded.contentType || mimeType;
+    const saved = await saveOpenClawChannelMediaBuffer(
+      args.api,
+      downloaded.buffer,
+      mediaContentType,
+      'inbound',
+      INBOUND_MEDIA_URL_MAX_BYTES,
+      fileName,
+    );
+    mediaPath = saved.path;
+  } else if (pathFromTransfer && fs.existsSync(pathFromTransfer)) {
+    mediaPath = pathFromTransfer;
+  }
+  if (!mediaPath) return null;
+  const kind = inferBncrInboundMediaKind({
+    msgType: String(args.item?.type || '').trim(),
+    mediaContentType: mediaContentType || mimeType,
+  });
+  return {
+    path: mediaPath,
+    ...(mediaContentType ? { contentType: mediaContentType } : {}),
+    ...(fileName ? { fileName } : {}),
+    kind,
+    ...(transferId ? { transferId } : {}),
+  };
+}
+
 export function resolveBncrInboundConversation(args: {
   api: BncrInboundApi;
   cfg: BncrInboundConfig;
   channelId: string;
   parsed: ParsedInbound;
   canonicalAgentId: string;
+  resolvedAgentId?: string;
 }) {
-  const { api, cfg, channelId, parsed, canonicalAgentId } = args;
+  const { api, cfg, channelId, parsed, canonicalAgentId, resolvedAgentId } = args;
   const { accountId, route, peer, sessionKeyfromroute, providedOriginatingTo, extracted } = parsed;
 
   const resolvedRoute = assertResolvedAgentRoute(
@@ -109,8 +262,9 @@ export function resolveBncrInboundConversation(args: {
     }),
   );
 
+  const targetAgentId = (resolvedAgentId || '').trim() || resolvedRoute.agentId || canonicalAgentId;
   const baseSessionKey =
-    normalizeInboundSessionKey(sessionKeyfromroute, route, canonicalAgentId) ||
+    normalizeInboundSessionKey(sessionKeyfromroute, route, targetAgentId) ||
     resolvedRoute.sessionKey;
   const taskSessionKey = withTaskSessionKey(baseSessionKey, extracted.taskKey);
   const dispatchSessionKey = taskSessionKey || baseSessionKey;
@@ -122,7 +276,12 @@ export function resolveBncrInboundConversation(args: {
     accountId,
     chatType: peer.kind,
     route,
-    resolvedRoute,
+    originalResolvedRouteSessionKey: resolvedRoute.sessionKey,
+    resolvedRoute: {
+      ...resolvedRoute,
+      agentId: targetAgentId || resolvedRoute.agentId,
+      sessionKey: baseSessionKey || resolvedRoute.sessionKey,
+    },
     canonicalTo,
     rawTo,
     originatingTo,
@@ -198,40 +357,38 @@ export async function prepareBncrInboundSessionContext(args: {
     agentId: resolvedRoute.agentId,
   });
 
-  let mediaPath: string | undefined;
-  let mediaContentType = mimeType;
-  if (mediaBase64) {
-    const mediaBuf = decodeInboundMediaBase64(mediaBase64);
-    const saved = await saveOpenClawChannelMediaBuffer(
-      api,
-      mediaBuf,
-      mimeType,
-      'inbound',
-      30 * 1024 * 1024,
-      fileName,
-    );
-    mediaPath = saved.path;
-  } else if (mediaPathFromTransfer && isHttpMediaUrl(mediaPathFromTransfer)) {
-    const downloaded = await loadInboundRemoteMedia(
-      api,
-      mediaPathFromTransfer,
-      INBOUND_MEDIA_URL_MAX_BYTES,
-    );
-    mediaContentType = downloaded.contentType || mimeType;
-    const saved = await saveOpenClawChannelMediaBuffer(
-      api,
-      downloaded.buffer,
-      mediaContentType,
-      'inbound',
-      INBOUND_MEDIA_URL_MAX_BYTES,
-      fileName,
-    );
-    mediaPath = saved.path;
-  } else if (mediaPathFromTransfer && fs.existsSync(mediaPathFromTransfer)) {
-    mediaPath = mediaPathFromTransfer;
-  }
+  const parsedMediaItems = Array.isArray(parsed.mediaItems) ? parsed.mediaItems : [];
+  const fallbackMediaItems =
+    parsedMediaItems.length > 0
+      ? parsedMediaItems
+      : [
+          {
+            ...(mediaPathFromTransfer ? { path: mediaPathFromTransfer } : {}),
+            ...(mediaBase64 ? { base64: mediaBase64 } : {}),
+            ...(mimeType ? { mimeType } : {}),
+            ...(fileName ? { fileName } : {}),
+            ...(msgType ? { type: msgType } : {}),
+          },
+        ];
+  const mediaItems = (
+    await Promise.all(
+      fallbackMediaItems.map((item) =>
+        saveBncrInboundMediaItem({
+          api,
+          item,
+        }),
+      ),
+    )
+  ).filter((item): item is NonNullable<typeof item> => Boolean(item));
+  const primaryMedia = mediaItems[0];
+  const mediaPath = primaryMedia?.path;
+  const mediaContentType = primaryMedia?.contentType || mimeType;
 
-  const rawBody = extracted.text || (msgType === 'text' ? '' : `[${msgType}]`);
+  const rawBody = resolveBncrInboundRawBody({
+    extractedText: extracted.text,
+    msgType,
+    mediaItems,
+  });
   const body = formatOpenClawAgentEnvelope(api, {
     channel: 'Bncr',
     from: `${platform}:${groupId}:${userId}`,
@@ -246,6 +403,7 @@ export async function prepareBncrInboundSessionContext(args: {
 
   return {
     storePath,
+    mediaItems,
     mediaPath,
     mediaContentType,
     rawBody,
@@ -272,15 +430,18 @@ export async function prepareBncrInboundDispatch(args: {
   cfg: BncrInboundConfig;
   parsed: ParsedInbound;
   canonicalAgentId: string;
+  resolvedAgentId?: string;
   rememberSessionRoute: BncrRememberSessionRoute;
 }) {
-  const { api, channelId, cfg, parsed, canonicalAgentId, rememberSessionRoute } = args;
+  const { api, channelId, cfg, parsed, canonicalAgentId, resolvedAgentId, rememberSessionRoute } =
+    args;
   const resolution = resolveBncrInboundConversation({
     api,
     cfg,
     channelId,
     parsed,
     canonicalAgentId,
+    resolvedAgentId,
   });
   const prepared = await prepareBncrInboundSessionContext({
     api,
@@ -290,8 +451,19 @@ export async function prepareBncrInboundDispatch(args: {
     rememberSessionRoute,
   });
   const replyRouteFact = buildBncrInboundReplyRouteFact(resolution);
-  const senderIdForContext = parsed.clientId || resolution.canonicalTo;
-  const senderDisplayName = parsed.clientId ? 'bncr-client' : resolution.canonicalTo;
+  const senderIdForContext = parsed.userId || parsed.clientId || resolution.canonicalTo;
+  const senderDisplayName = parsed.userName || resolution.canonicalTo;
+  const isBncrNativeCommand =
+    parseBncrNativeCommand(parsed.extracted.text, {
+      allowBareWhoami: parsed.isAdmin !== true,
+    }) !== null;
+  const isOpenClawNativeCommand =
+    !isBncrNativeCommand &&
+    hasControlCommand(parsed.extracted.text, cfg as Parameters<typeof hasControlCommand>[1]);
+  const ownerAllowFrom =
+    parsed.isAdmin === true && isOpenClawNativeCommand && senderIdForContext
+      ? [senderIdForContext]
+      : undefined;
 
   return {
     resolution,
@@ -299,5 +471,8 @@ export async function prepareBncrInboundDispatch(args: {
     replyRouteFact,
     senderIdForContext,
     senderDisplayName,
+    ...(ownerAllowFrom ? { ownerAllowFrom } : {}),
+    bridgeSenderId: parsed.bridgeId || parsed.clientId,
+    bridgeSenderName: parsed.bridgeName || 'Bncr',
   } satisfies BncrInboundPreparation;
 }

package/src/messaging/inbound/dispatch.ts

@@ -1,4 +1,5 @@
 import { emitBncrLogLine } from '../../core/logging.ts';
+import type { BncrSceneRecord } from '../../plugin/channel-runtime-types.ts';
 import { handleBncrNativeCommand } from './commands.ts';
 import type {
   BncrEnqueueFromReply,
@@ -15,6 +16,12 @@ import {
   prepareBncrInboundDispatch,
   resolveBncrInboundConversation,
 } from './dispatch-prep.ts';
+import {
+  type BncrGroupHistoryMap,
+  clearBncrPendingGroupHistory,
+  recordBncrPendingGroupMedia,
+  recordBncrPendingGroupText,
+} from './group-history.ts';
 import { runBncrInboundReplyDispatch } from './reply-dispatch.ts';
 import { buildBncrInboundTurnContext } from './turn-context.ts';
 
@@ -31,6 +38,14 @@ export async function dispatchBncrInbound(params: {
   cfg: BncrInboundConfig;
   parsed: ParsedInbound;
   canonicalAgentId: string;
+  shouldDispatch?: boolean;
+  shouldAccumulate?: boolean;
+  resolvedAgentId?: string;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: BncrGroupHistoryMap;
+  defaultAdminAgentId: string;
+  defaultPublicAgentId: string;
+  now: () => number;
   rememberSessionRoute: BncrRememberSessionRoute;
   enqueueFromReply: BncrEnqueueFromReply;
   setInboundActivity: (accountId: string, at: number) => void;
@@ -43,6 +58,14 @@ export async function dispatchBncrInbound(params: {
     cfg,
     parsed,
     canonicalAgentId,
+    shouldDispatch = true,
+    shouldAccumulate = shouldDispatch,
+    resolvedAgentId,
+    sceneRegistry,
+    groupHistories = new Map(),
+    defaultAdminAgentId,
+    defaultPublicAgentId,
+    now,
     rememberSessionRoute,
     enqueueFromReply,
     setInboundActivity,
@@ -57,6 +80,11 @@ export async function dispatchBncrInbound(params: {
     cfg,
     parsed,
     canonicalAgentId,
+    resolvedAgentId,
+    sceneRegistry,
+    defaultAdminAgentId,
+    defaultPublicAgentId,
+    now,
     rememberSessionRoute,
     enqueueFromReply,
     logger,
@@ -79,12 +107,23 @@ export async function dispatchBncrInbound(params: {
     cfg,
     parsed,
     canonicalAgentId,
+    resolvedAgentId,
     rememberSessionRoute,
   });
-  const { resolution, prepared, replyRouteFact, senderIdForContext, senderDisplayName } =
-    preparedDispatch;
+  const {
+    resolution,
+    prepared,
+    replyRouteFact,
+    senderIdForContext,
+    senderDisplayName,
+    ownerAllowFrom,
+    bridgeSenderId,
+    bridgeSenderName,
+  } = preparedDispatch;
   const { dispatchSessionKey: sessionKey } = resolution;
-  const { storePath, mediaPath, mediaContentType, rawBody } = prepared;
+  const { storePath, mediaItems, rawBody } = prepared;
+  const primaryMedia = mediaItems[0];
+  const mediaContentType = primaryMedia?.contentType;
   if (!clientId) {
     emitBncrLogLine(
       'warn',
@@ -93,18 +132,39 @@ export async function dispatchBncrInbound(params: {
   }
   const ctxPayload = await buildBncrInboundTurnContext({
     api,
+    cfg,
     channelId,
     parsed,
     msgId,
-    mimeType: mediaContentType || mimeType,
-    mediaPath,
     peer,
     senderIdForContext,
     senderDisplayName,
+    ownerAllowFrom,
+    bridgeSenderId,
+    bridgeSenderName,
     resolution,
     prepared,
+    groupHistories,
+    shouldDispatch,
   });
 
+  if (!shouldDispatch && shouldAccumulate) {
+    recordBncrPendingGroupText({
+      historyMap: groupHistories,
+      parsed,
+      senderDisplayName,
+      bodyText: rawBody,
+    });
+    await recordBncrPendingGroupMedia({
+      historyMap: groupHistories,
+      parsed,
+      senderDisplayName,
+      bodyText: rawBody,
+      mediaItems,
+      mediaContentType: mediaContentType || mimeType,
+    });
+  }
+
   await runBncrInboundReplyDispatch({
     api,
     channelId,
@@ -118,11 +178,17 @@ export async function dispatchBncrInbound(params: {
     resolution,
     replyRouteFact,
     senderIdForContext,
+    senderDisplayName,
+    shouldDispatch,
     setInboundActivity,
     scheduleSave,
     enqueueFromReply,
   });
 
+  if (shouldDispatch) {
+    clearBncrPendingGroupHistory({ historyMap: groupHistories, parsed });
+  }
+
   return {
     accountId,
     sessionKey,

package/src/messaging/inbound/gate.ts

@@ -1,59 +1,46 @@
 import { normalizeAccountId } from '../../core/accounts.ts';
-import { resolveBncrChannelPolicy } from '../../core/policy.ts';
-import { buildDisplayScopeCandidates } from '../../core/targets.ts';
-import type { BncrRoute } from '../../core/types.ts';
-import {
-  defineOpenClawStableChannelIngressIdentity,
-  resolveOpenClawChannelMessageIngress,
-} from '../../openclaw/ingress-runtime.ts';
 import type { BncrInboundConfig, BncrInboundParamsInput } from './contracts.ts';
 
-type RouteLike = Partial<Pick<BncrRoute, 'groupId' | 'userId' | 'platform'>>;
-type AccessGroupsLike = Parameters<typeof resolveOpenClawChannelMessageIngress>[0]['accessGroups'];
-
 export type BncrGateResult = { allowed: true } | { allowed: false; reason: string };
 
+const REQUIRED_PROTOCOL_VERSION = 'scene-routing-v1';
+const REQUIRED_CAPABILITY = 'scene-routing-v1';
+
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
   if (v == null) return fallback;
   return String(v);
 }
 
-const bncrIngressIdentity = defineOpenClawStableChannelIngressIdentity({
-  key: 'displayScope',
-  kind: 'plugin:bncr-display-scope',
-  normalize: (value: string) => asString(value).trim() || null,
-  sensitivity: 'pii',
-  entryIdPrefix: 'bncr-allow',
-  aliases: [
-    {
-      key: 'routeKey',
-      kind: 'plugin:bncr-route-key',
-      normalize: (value: string) => asString(value).trim() || null,
-      sensitivity: 'pii',
-    },
-  ],
-});
+function asBoolean(v: unknown, fallback = false): boolean {
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') {
+    const raw = v.trim().toLowerCase();
+    if (!raw) return fallback;
+    if (['true', '1', 'yes', 'y', 'on'].includes(raw)) return true;
+    if (['false', '0', 'no', 'n', 'off'].includes(raw)) return false;
+  }
+  return fallback;
+}
 
-function gateReasonFromIngress(reasonCode?: string): string {
-  switch (reasonCode) {
-    case 'dm_policy_disabled':
-      return 'dm disabled';
-    case 'dm_policy_not_allowlisted':
-    case 'dm_policy_pairing_required':
-      return 'dm allowlist blocked';
-    case 'group_policy_disabled':
-      return 'group disabled';
-    case 'group_policy_not_allowlisted':
-    case 'group_policy_empty_allowlist':
-      return 'group allowlist blocked';
-    default:
-      return reasonCode || 'ingress blocked';
+function asCapabilities(v: unknown): string[] {
+  if (Array.isArray(v)) {
+    return v.map((item) => asString(item).trim()).filter(Boolean);
+  }
+  if (typeof v === 'string') {
+    return v
+      .split(',')
+      .map((item) => item.trim())
+      .filter(Boolean);
   }
+  return [];
 }
 
 export async function checkBncrMessageGate(params: {
-  parsed: BncrInboundParamsInput & { route?: RouteLike };
+  parsed: BncrInboundParamsInput & {
+    route?: Partial<{ groupId: string; userId: string; platform: string }>;
+  };
   cfg: BncrInboundConfig;
   account: { accountId: string; enabled?: boolean };
 }): Promise<BncrGateResult> {
@@ -61,57 +48,40 @@ export async function checkBncrMessageGate(params: {
   const accountId = normalizeAccountId(account?.accountId);
   const channelCfg = cfg?.channels?.bncr || {};
   const accountCfg = channelCfg?.accounts?.[accountId] || {};
-  const policy = resolveBncrChannelPolicy(channelCfg);
-
-  if (policy.enabled === false || account?.enabled === false || accountCfg?.enabled === false) {
+  if (
+    channelCfg?.enabled === false ||
+    account?.enabled === false ||
+    accountCfg?.enabled === false
+  ) {
     return { allowed: false, reason: 'account disabled' };
   }
 
-  const route = parsed?.route;
-  if (!route?.platform || !route?.groupId || !route?.userId) {
-    return { allowed: false, reason: 'invalid route' };
+  const protocolVersion = asString(parsed?.protocolVersion || '').trim();
+  const capabilities = asCapabilities(parsed?.capabilities);
+  if (
+    protocolVersion !== REQUIRED_PROTOCOL_VERSION ||
+    !capabilities.includes(REQUIRED_CAPABILITY)
+  ) {
+    return { allowed: false, reason: 'client protocol outdated' };
   }
-  const resolvedRoute: BncrRoute = {
-    platform: route.platform,
-    groupId: route.groupId,
-    userId: route.userId,
-  };
-  const isGroup = asString(route?.groupId || '0') !== '0';
-
-  const candidates = buildDisplayScopeCandidates(resolvedRoute);
-  const displayScope = candidates[0] || '';
-  const routeKey = candidates.find((candidate) => candidate !== displayScope) || displayScope;
 
-  // requireMention 默认值为 false。
-  // 设计目标：当它未来真正生效时，含义是“群消息只有在明确提到机器人时才允许进入处理链”。
-  // 但当前 parse 层尚未稳定提取 mentions，上游客户端也未统一透传 mention 信号，
-  // 因此现阶段即使配置为 true，也仍不做实际拦截，避免出现半实现状态。
-  const resolved = await resolveOpenClawChannelMessageIngress({
-    channelId: 'bncr',
-    accountId,
-    identity: bncrIngressIdentity,
-    subject: {
-      stableId: displayScope,
-      aliases: { routeKey },
-    },
-    conversation: {
-      kind: isGroup ? 'group' : 'direct',
-      id: isGroup ? asString(route?.groupId) : asString(route?.userId || displayScope),
-    },
-    event: { kind: 'message', authMode: 'inbound', mayPair: !isGroup },
-    policy: {
-      dmPolicy: policy.dmPolicy,
-      groupPolicy: policy.groupPolicy,
-      groupAllowFromFallbackToAllowFrom: false,
-    },
-    allowFrom: policy.dmPolicy === 'open' ? ['*', ...policy.allowFrom] : policy.allowFrom,
-    groupAllowFrom: policy.groupAllowFrom,
-    accessGroups: cfg?.accessGroups as AccessGroupsLike,
-  });
-
-  if (resolved.ingress.admission === 'dispatch' || resolved.ingress.admission === 'observe') {
-    return { allowed: true };
+  const platform = asString(parsed?.platform || '').trim();
+  const userId = asString(parsed?.userId || '').trim();
+  const clientId = asString(parsed?.clientId || '').trim();
+  const groupId = asString(parsed?.groupId || '').trim();
+  const isGroupProvided = parsed && Object.hasOwn(parsed, 'isGroup');
+  const isAdminProvided = parsed && Object.hasOwn(parsed, 'isAdmin');
+  const isGroup = asBoolean(parsed?.isGroup, false);
+  if (!platform || !userId || !clientId || !isGroupProvided || !isAdminProvided) {
+    return { allowed: false, reason: 'inbound schema incomplete' };
+  }
+  if (isGroup && !groupId) {
+    return { allowed: false, reason: 'inbound schema incomplete' };
   }
 
-  return { allowed: false, reason: gateReasonFromIngress(resolved.ingress.reasonCode) };
+  const route = parsed?.route;
+  if (!route?.platform || !route?.groupId || !route?.userId) {
+    return { allowed: false, reason: 'invalid route' };
+  }
+  return { allowed: true };
 }