@xmoxmo/bncr 0.3.6 → 0.3.8

package/src/core/accounts.ts

@@ -1,3 +1,9 @@
+import type {
+  BncrAccountConfig,
+  BncrChannelConfigRoot,
+  BncrChannelConfigSection,
+} from '../plugin/channel-runtime-types.ts';
+
 const CHANNEL_ID = 'bncr';
 const BNCR_DEFAULT_ACCOUNT_ID = 'Primary';
 
@@ -29,8 +35,21 @@ export function resolveDefaultDisplayName(rawName: unknown, accountId: string):
   return raw;
 }
 
-export function resolveAccount(cfg: any, accountId?: string | null) {
-  const accounts = cfg?.channels?.[CHANNEL_ID]?.accounts || {};
+function getChannelConfig(cfg: BncrChannelConfigRoot | null | undefined): BncrChannelConfigSection {
+  return cfg?.channels?.[CHANNEL_ID] || {};
+}
+
+function getAccountsConfig(
+  cfg: BncrChannelConfigRoot | null | undefined,
+): Record<string, BncrAccountConfig | undefined> {
+  return getChannelConfig(cfg).accounts || {};
+}
+
+export function resolveAccount(
+  cfg: BncrChannelConfigRoot | null | undefined,
+  accountId?: string | null,
+) {
+  const accounts = getAccountsConfig(cfg);
   let key = normalizeAccountId(accountId);
 
   if (!accounts[key]) {
@@ -48,8 +67,8 @@ export function resolveAccount(cfg: any, accountId?: string | null) {
   };
 }
 
-export function listAccountIds(cfg: any): string[] {
-  const ids = Object.keys(cfg?.channels?.[CHANNEL_ID]?.accounts || {});
+export function listAccountIds(cfg: BncrChannelConfigRoot | null | undefined): string[] {
+  const ids = Object.keys(getAccountsConfig(cfg));
   return ids.length ? ids : [BNCR_DEFAULT_ACCOUNT_ID];
 }
 

package/src/core/dead-letter-diagnostics.ts

@@ -1,6 +1,10 @@
 import { summarizeBncrTextPreview } from './logging.ts';
 import { formatDisplayScope } from './targets.ts';
-import type { OutboxEntry } from './types.ts';
+import type {
+  BncrDeadLetterDiagnosticsSummary,
+  BncrDeadLetterEntrySummary,
+  OutboxEntry,
+} from './types.ts';
 
 export type DeadLetterTopReason = { reason: string; count: number };
 
@@ -17,6 +21,15 @@ function asString(value: unknown, fallback = ''): string {
   return String(value);
 }
 
+function asPayloadMessage(payload: OutboxEntry['payload']): {
+  msg?: string;
+  type?: string;
+  [key: string]: unknown;
+} {
+  const raw = payload.message;
+  return raw && typeof raw === 'object' ? (raw as { msg?: string; type?: string }) : {};
+}
+
 export function buildDeadLetterDiagnostics(options: BuildDeadLetterDiagnosticsOptions) {
   const reasonCounts = new Map<string, number>();
   let oldestAt: number | null = null;
@@ -43,7 +56,7 @@ export function buildDeadLetterDiagnostics(options: BuildDeadLetterDiagnosticsOp
       .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
       .slice(0, 5)
       .map(([reason, count]) => ({ reason, count })),
-  };
+  } satisfies BncrDeadLetterDiagnosticsSummary;
 }
 
 export function formatDeadLetterTopReasons(topReasons: DeadLetterTopReason[]): string {
@@ -75,17 +88,36 @@ export function parseDeadLetterOlderThan(raw: unknown): number | null {
 
 export function summarizeDeadLetterEntry(entry: OutboxEntry) {
   const meta = entry.payload?._meta || {};
-  const msg = (entry.payload as any)?.message || {};
+  const msg = asPayloadMessage(entry.payload);
   const text = asString(meta.text || msg.msg || '');
   return {
     messageId: entry.messageId,
     accountId: entry.accountId,
     sessionKey: entry.sessionKey,
     route: formatDisplayScope(entry.route),
-    kind: asString(meta.kind || (entry.payload as any)?.type || 'message'),
+    kind: asString(meta.kind || msg.type || 'message'),
     createdAt: Number.isFinite(Number(entry.createdAt)) ? Number(entry.createdAt) : null,
     retryCount: Number.isFinite(Number(entry.retryCount)) ? Number(entry.retryCount) : 0,
     lastError: entry.lastError || null,
     textPreview: summarizeBncrTextPreview(text, 24),
-  };
+  } satisfies BncrDeadLetterEntrySummary;
+}
+
+export function filterDeadLetterEntries(args: {
+  accountId: string;
+  entries: OutboxEntry[];
+  reason?: string | null;
+  olderThan?: number | null;
+}) {
+  const normalizedAccountId = asString(args.accountId).trim().toLowerCase();
+  const reason = asString(args.reason || '').trim();
+  return args.entries.filter((entry) => {
+    if (asString(entry.accountId).trim().toLowerCase() !== normalizedAccountId) return false;
+    if (reason && entry.lastError !== reason) return false;
+    if (typeof args.olderThan === 'number') {
+      const createdAt = Number(entry.createdAt);
+      if (!Number.isFinite(createdAt) || createdAt >= args.olderThan) return false;
+    }
+    return true;
+  });
 }

package/src/core/diagnostics.ts

@@ -1,31 +1,47 @@
+import type { BncrRuntimeFlags } from '../runtime/outbound-flags.ts';
+import type { BncrExtendedDiagnostics } from './extended-diagnostics.ts';
+import type { BncrPermissionSummary } from './permissions.ts';
 import { buildBncrPermissionSummary } from './permissions.ts';
+import type { BncrAccountProbe } from './probe.ts';
 import { probeBncrAccount } from './probe.ts';
+import type { BncrAccountRuntimeSnapshot } from './status.ts';
+import type { BncrDownlinkHealthSummary } from './types.ts';
+import { nonNegativeFiniteNumberOr } from './value-sanitize.ts';
 
-function finiteNumberOr(value: unknown, fallback: number): number {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function nonNegativeFiniteNumberOr(value: unknown, fallback: number): number {
-  return Math.max(0, finiteNumberOr(value, fallback));
-}
+export type BncrDiagnosticsWaiters = {
+  messageAck: number;
+  fileAck: number;
+};
 
 type DiagnosticsPayloadArgs = {
-  cfg: any;
+  cfg: unknown;
   channelId: string;
   accountId: string;
-  runtime: any;
-  diagnostics: any;
-  downlinkHealth: any;
-  runtimeFlags: any;
-  waiters: { messageAck: number; fileAck: number };
+  runtime: BncrAccountRuntimeSnapshot;
+  diagnostics: BncrExtendedDiagnostics;
+  downlinkHealth: BncrDownlinkHealthSummary;
+  runtimeFlags: BncrRuntimeFlags;
+  waiters: BncrDiagnosticsWaiters;
   activeConnections: number;
   invalidOutboxSessionKeys: number;
   legacyAccountResidue: number;
   now: number;
 };
 
-export function buildDiagnosticsPayload(args: DiagnosticsPayloadArgs) {
+export type BncrDiagnosticsPayload = {
+  channel: string;
+  accountId: string;
+  runtime: BncrAccountRuntimeSnapshot;
+  diagnostics: BncrExtendedDiagnostics;
+  downlinkHealth: BncrDownlinkHealthSummary;
+  runtimeFlags: BncrRuntimeFlags;
+  waiters: BncrDiagnosticsWaiters;
+  permissions: BncrPermissionSummary;
+  probe: BncrAccountProbe;
+  now: number;
+};
+
+export function buildDiagnosticsPayload(args: DiagnosticsPayloadArgs): BncrDiagnosticsPayload {
   const permissions = buildBncrPermissionSummary(args.cfg ?? {});
   const probe = probeBncrAccount({
     accountId: args.accountId,

package/src/core/downlink-health.ts

@@ -1,13 +1,5 @@
-import type { OutboxEntry } from './types.ts';
-
-function finiteNumberOr(value: unknown, fallback: number): number {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function nonNegativeFiniteNumberOr(value: unknown, fallback: number): number {
-  return Math.max(0, finiteNumberOr(value, fallback));
-}
+import type { BncrDownlinkHealthSummary, OutboxEntry } from './types.ts';
+import { finiteNumberOr, nonNegativeFiniteNumberOr } from './value-sanitize.ts';
 
 type DownlinkHealthInput = {
   accountId: string;
@@ -62,5 +54,5 @@ export function buildDownlinkHealth(input: DownlinkHealthInput) {
     recommendReason: ackStalled
       ? 'single-conn pending outbox with recent ack timeout and no recent ack-ok while inbound/activity is still alive'
       : '',
-  };
+  } satisfies BncrDownlinkHealthSummary;
 }

package/src/core/extended-diagnostics.ts

@@ -1,11 +1,46 @@
-import type { RegisterTraceEntry } from './register-trace.ts';
+import type { OpenClawChannelRuntimeSurfaceDiagnostics } from '../openclaw/runtime-surface.ts';
+import type {
+  RegisterDriftSnapshot,
+  RegisterTraceEntry,
+  RegisterTraceSummary,
+} from './register-trace.ts';
+import type {
+  BncrDeadLetterDiagnosticsSummary,
+  BncrDiagnosticsSummary,
+  BncrExtendedOutboundDiagnostics,
+  BncrStaleCounterSummary,
+} from './types.ts';
 
-type ExtendedDiagnosticsInput = {
-  diagnostics: Record<string, any>;
-  runtimeSurface?: {
-    channel: Record<string, boolean>;
-    missing: string[];
-  };
+type ExtendedConnectionDiagnostics = {
+  active: number;
+  hasGatewayContext?: boolean;
+  lastGatewayContextAt?: number | null;
+  primaryLeaseId: string | null;
+  primaryEpoch: number | null;
+  acceptedConnections: number;
+  lastConnectAt: number | null;
+  lastDisconnectAt: number | null;
+  lastActivityAt: number | null;
+  lastInboundAt: number | null;
+  lastAckAt: number | null;
+  recent: Array<{
+    leaseId: string;
+    epoch: number;
+    connectedAt: number;
+    lastActivityAt: number | null;
+    isPrimary: boolean;
+  }>;
+};
+
+type ExtendedProtocolDiagnostics = {
+  bridgeVersion: number;
+  protocolVersion: number;
+  minClientProtocol: number;
+  features: Record<string, boolean>;
+};
+
+export type BncrExtendedDiagnostics = BncrDiagnosticsSummary & {
+  runtimeSurface?: OpenClawChannelRuntimeSurfaceDiagnostics;
   register: {
     bridgeId: string;
     gatewayPid: number;
@@ -19,44 +54,51 @@ type ExtendedDiagnosticsInput = {
     lastApiRebindAt: number | null;
     apiGeneration: number;
     traceRecent: RegisterTraceEntry[];
-    traceSummary: Record<string, any>;
-    lastDriftSnapshot: any;
+    traceSummary: RegisterTraceSummary;
+    lastDriftSnapshot: RegisterDriftSnapshot | null;
   };
-  outbound?: Record<string, any>;
-  deadLetterSummary?: Record<string, any>;
-  connection: {
-    active: number;
-    primaryLeaseId: string | null;
-    primaryEpoch: number | null;
-    acceptedConnections: number;
-    lastConnectAt: number | null;
-    lastDisconnectAt: number | null;
-    lastActivityAt: number | null;
-    lastInboundAt: number | null;
-    lastAckAt: number | null;
-    recent: Array<{
-      leaseId: string;
-      epoch: number;
-      connectedAt: number;
-      lastActivityAt: number | null;
-      isPrimary: boolean;
-    }>;
-  };
-  protocol: {
-    bridgeVersion: number;
-    protocolVersion: number;
-    minClientProtocol: number;
-    features: Record<string, boolean>;
+  connection: ExtendedConnectionDiagnostics;
+  outbound?: BncrExtendedOutboundDiagnostics;
+  deadLetterSummary?: BncrDeadLetterDiagnosticsSummary;
+  protocol: ExtendedProtocolDiagnostics;
+  stale: BncrStaleCounterSummary;
+};
+
+type ExtendedDiagnosticsInput = {
+  diagnostics: BncrDiagnosticsSummary;
+  runtimeSurface?: OpenClawChannelRuntimeSurfaceDiagnostics;
+  register: {
+    bridgeId: string;
+    gatewayPid: number;
+    pluginVersion: string | null;
+    source: string | null;
+    apiInstanceId: string | null;
+    registryFingerprint: string | null;
+    registerCount: number;
+    firstRegisterAt: number | null;
+    lastRegisterAt: number | null;
+    lastApiRebindAt: number | null;
+    apiGeneration: number;
+    traceRecent: RegisterTraceEntry[];
+    traceSummary: RegisterTraceSummary;
+    lastDriftSnapshot: RegisterDriftSnapshot | null;
   };
-  stale: Record<string, any>;
+  outbound?: BncrExtendedOutboundDiagnostics;
+  deadLetterSummary?: BncrDeadLetterDiagnosticsSummary;
+  connection: ExtendedConnectionDiagnostics;
+  protocol: ExtendedProtocolDiagnostics;
+  stale: BncrStaleCounterSummary;
 };
 
-export function buildExtendedDiagnostics(input: ExtendedDiagnosticsInput) {
+export function buildExtendedDiagnostics(input: ExtendedDiagnosticsInput): BncrExtendedDiagnostics {
   return {
     ...input.diagnostics,
     runtimeSurface: input.runtimeSurface
       ? {
+          runtime: { ...input.runtimeSurface.runtime },
           channel: { ...input.runtimeSurface.channel },
+          channelMedia: { ...input.runtimeSurface.channelMedia },
+          contract: { ...input.runtimeSurface.contract },
           missing: input.runtimeSurface.missing.slice(),
         }
       : undefined,

package/src/core/file-transfer-payloads.ts

@@ -1,4 +1,4 @@
-import type { BncrRoute } from './accounts.ts';
+import type { BncrRoute } from './types.ts';
 
 export function buildFileTransferInitPayload(args: {
   transferId: string;

package/src/core/logging.ts

@@ -15,6 +15,7 @@ const TEXT_PAYLOAD_KEYS = new Set([
   'msg',
   'rawText',
   'text',
+  'textPreview',
 ]);
 const MEDIA_PAYLOAD_KEYS = new Set(['mediaUrl', 'path']);
 const MEDIA_LIST_PAYLOAD_KEYS = new Set(['mediaUrls', 'mediaList']);

package/src/core/outbox-enqueue.ts

@@ -1,13 +1,24 @@
 import type { OutboxEntry } from './types.ts';
 
+type OutboxEnqueueMessage = {
+  type?: unknown;
+  msg?: unknown;
+};
+
+type OutboxEnqueuePayload = {
+  type?: unknown;
+  message?: OutboxEnqueueMessage;
+};
+
 export function buildOutboxEnqueueDebugInfo(args: {
   bridgeId: string;
   entry: OutboxEntry;
   asString: (value: unknown) => string;
   formatDisplayScope: (route: OutboxEntry['route']) => string;
 }) {
-  const msg = (args.entry.payload as any)?.message || {};
-  const type = args.asString(msg.type || (args.entry.payload as any)?.type || 'unknown');
+  const payload = args.entry.payload as OutboxEnqueuePayload;
+  const msg = payload?.message || {};
+  const type = args.asString(msg.type || payload?.type || 'unknown');
   const text = args.asString(msg.msg || '');
   return {
     bridge: args.bridgeId,

package/src/core/outbox-entry-builders.ts

@@ -15,6 +15,7 @@ export function buildFileTransferOutboxEntry(args: {
   text: string;
   asVoice?: boolean;
   audioAsVoice?: boolean;
+  type?: string;
   kind?: 'tool' | 'block' | 'final';
   replyToId?: string;
   replyTargetPolicy?: OutboundReplyTargetPolicy;
@@ -36,6 +37,7 @@ export function buildFileTransferOutboxEntry(args: {
         text: args.text,
         asVoice: args.asVoice === true,
         audioAsVoice: args.audioAsVoice === true,
+        type: args.type,
         finalEvent: args.pushEvent,
         replyToId:
           normalizeOutboundReplyToId({

package/src/core/outbox-summary.ts

@@ -1,14 +1,86 @@
 import type { OutboxEntry } from './types.ts';
 
+type OutboxSummaryMeta = {
+  kind?: string;
+  asVoice?: boolean;
+  audioAsVoice?: boolean;
+  type?: unknown;
+  mediaUrl?: unknown;
+  text?: unknown;
+};
+
+type OutboxSummaryMessage = {
+  type?: unknown;
+  msg?: unknown;
+};
+
+type OutboxSummaryPayload = {
+  type?: unknown;
+  message?: OutboxSummaryMessage;
+  _meta?: OutboxSummaryMeta;
+};
+
+function inferMediaTypeFromUrl(raw: string): 'image' | 'video' | 'audio' | 'file' {
+  const clean = String(raw || '').split(/[?#]/, 1)[0] || '';
+  const ext = clean.includes('.') ? clean.slice(clean.lastIndexOf('.') + 1).toLowerCase() : '';
+  if (['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp', 'heic', 'heif'].includes(ext)) return 'image';
+  if (['mp4', 'mov', 'mkv', 'webm', 'avi', 'm4v'].includes(ext)) return 'video';
+  if (['mp3', 'wav', 'ogg', 'oga', 'opus', 'm4a', 'aac', 'flac'].includes(ext)) return 'audio';
+  return 'file';
+}
+
+function filenameFromUrl(raw: string): string {
+  const clean = String(raw || '').split(/[?#]/, 1)[0] || '';
+  const name = clean.split(/[\\/]/).filter(Boolean).pop() || '';
+  if (!name) return '';
+  try {
+    return decodeURIComponent(name);
+  } catch {
+    return name;
+  }
+}
+
+function summarizeOutboxType(
+  payload: OutboxSummaryPayload,
+  msg: OutboxSummaryMessage,
+  asString: (value: unknown) => string,
+) {
+  const directType = asString(msg.type || '');
+  if (directType) return directType;
+
+  const meta = payload?._meta || {};
+  if (meta.kind === 'file-transfer') {
+    if (meta.asVoice === true || meta.audioAsVoice === true) return 'voice';
+    const hintedType = asString(meta.type || '').trim();
+    if (hintedType) return hintedType;
+    return inferMediaTypeFromUrl(asString(meta.mediaUrl || ''));
+  }
+
+  return asString(payload?.type || 'unknown');
+}
+
+function summarizeOutboxText(
+  payload: OutboxSummaryPayload,
+  msg: OutboxSummaryMessage,
+  asString: (value: unknown) => string,
+) {
+  const text = asString(msg.msg || payload?._meta?.text || '').trim();
+  if (text) return text;
+  const meta = payload?._meta || {};
+  if (meta.kind === 'file-transfer') return filenameFromUrl(asString(meta.mediaUrl || ''));
+  return '';
+}
+
 export function summarizeOutboxEntry(args: {
   entry: OutboxEntry;
   asString: (value: unknown) => string;
   formatDisplayScope: (route: OutboxEntry['route']) => string;
   summarizeTextPreview: (raw: string, limit?: number) => string;
 }) {
-  const msg = (args.entry.payload as any)?.message || {};
-  const type = args.asString(msg.type || (args.entry.payload as any)?.type || 'unknown');
-  const text = args.asString(msg.msg || '');
+  const payload = args.entry.payload as OutboxSummaryPayload;
+  const msg = payload?.message || {};
+  const type = summarizeOutboxType(payload, msg, args.asString);
+  const text = summarizeOutboxText(payload, msg, args.asString);
   const preview = args.summarizeTextPreview(text);
   return [type, args.formatDisplayScope(args.entry.route), preview].join('|');
 }

package/src/core/permissions.ts

@@ -4,7 +4,18 @@ function asString(v: unknown, fallback = ''): string {
   return String(v);
 }
 
-export function getBncrElevatedConfig(rootCfg: any) {
+type BncrElevatedConfigRoot = {
+  tools?: {
+    elevated?: {
+      enabled?: boolean;
+      allowFrom?: {
+        bncr?: unknown;
+      };
+    };
+  };
+};
+
+export function getBncrElevatedConfig(rootCfg: BncrElevatedConfigRoot | null | undefined) {
   const elevated = rootCfg?.tools?.elevated || {};
   const allowFrom = elevated?.allowFrom || {};
   const bncrRules = Array.isArray(allowFrom?.bncr)
@@ -18,7 +29,7 @@ export function getBncrElevatedConfig(rootCfg: any) {
   };
 }
 
-export function buildBncrPermissionSummary(rootCfg: any) {
+export function buildBncrPermissionSummary(rootCfg: BncrElevatedConfigRoot | null | undefined) {
   const elevated = getBncrElevatedConfig(rootCfg);
   return {
     elevatedEnabled: elevated.enabled,
@@ -29,3 +40,5 @@ export function buildBncrPermissionSummary(rootCfg: any) {
       : 'bncr elevated not explicitly allowed',
   };
 }
+
+export type BncrPermissionSummary = ReturnType<typeof buildBncrPermissionSummary>;

package/src/core/persisted-outbox-entry.ts

@@ -2,6 +2,10 @@ import { normalizeAccountId } from './accounts.ts';
 import { normalizeStoredSessionKey, parseRouteLike } from './targets.ts';
 import type { OutboxEntry } from './types.ts';
 
+type PersistedOutboxEntryInput = Partial<OutboxEntry> & {
+  payload?: Record<string, unknown>;
+};
+
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
   if (v == null) return fallback;
@@ -20,7 +24,7 @@ function optionalFiniteNumber(value: unknown): number | undefined {
 }
 
 export function normalizePersistedOutboxEntry(args: {
-  entry: any;
+  entry: PersistedOutboxEntryInput | null | undefined;
   canonicalAgentId: string;
   now: () => number;
 }): OutboxEntry | null {
@@ -32,14 +36,16 @@ export function normalizePersistedOutboxEntry(args: {
   if (!normalized) return null;
 
   const route = parseRouteLike(entry.route) || normalized.route;
-  const payload = entry.payload && typeof entry.payload === 'object' ? { ...entry.payload } : {};
-  (payload as any).sessionKey = normalized.sessionKey;
-  (payload as any).platform = route.platform;
-  (payload as any).groupId = route.groupId;
-  (payload as any).userId = route.userId;
+  const payload: Record<string, unknown> =
+    entry.payload && typeof entry.payload === 'object' ? { ...entry.payload } : {};
+  payload.sessionKey = normalized.sessionKey;
+  payload.platform = route.platform;
+  payload.groupId = route.groupId;
+  payload.userId = route.userId;
 
   return {
     ...entry,
+    messageId: asString(entry.messageId).trim(),
     accountId,
     sessionKey: normalized.sessionKey,
     route,
@@ -49,5 +55,14 @@ export function normalizePersistedOutboxEntry(args: {
     nextAttemptAt: finiteNumberOr(entry.nextAttemptAt, args.now()),
     lastAttemptAt: optionalFiniteNumber(entry.lastAttemptAt),
     lastError: entry.lastError ? asString(entry.lastError) : undefined,
+    lastPushAt: optionalFiniteNumber(entry.lastPushAt),
+    lastPushConnId: entry.lastPushConnId ? asString(entry.lastPushConnId) : undefined,
+    lastPushClientId: entry.lastPushClientId ? asString(entry.lastPushClientId) : undefined,
+    routeAttemptConnIds: Array.isArray(entry.routeAttemptConnIds)
+      ? entry.routeAttemptConnIds.map((value) => asString(value)).filter(Boolean)
+      : undefined,
+    routeAttemptRound: optionalFiniteNumber(entry.routeAttemptRound),
+    fastReroutePending: entry.fastReroutePending === true,
+    awaitingRetryPush: entry.awaitingRetryPush === true,
   };
 }

package/src/core/policy.ts

@@ -4,6 +4,18 @@ function asString(v: unknown, fallback = ''): string {
   return String(v);
 }
 
+export type BncrChannelPolicyConfig = {
+  enabled?: boolean;
+  dmPolicy?: unknown;
+  groupPolicy?: unknown;
+  allowFrom?: unknown;
+  groupAllowFrom?: unknown;
+  requireMention?: unknown;
+};
+
+export type BncrDmPolicy = 'open' | 'allowlist' | 'disabled' | 'pairing';
+export type BncrGroupPolicy = 'open' | 'allowlist' | 'disabled';
+
 function asList(v: unknown): string[] {
   if (!Array.isArray(v)) return [];
   return v.map((x) => asString(x).trim()).filter(Boolean);
@@ -15,18 +27,47 @@ function asBoolean(v: unknown, fallback = false): boolean {
   return String(v).trim().toLowerCase() === 'true';
 }
 
-export function resolveBncrChannelPolicy(channelCfg: any) {
+function normalizeDmPolicy(value: unknown): BncrDmPolicy {
+  const normalized = asString(value || 'open')
+    .trim()
+    .toLowerCase();
+  switch (normalized) {
+    case 'allowlist':
+    case 'disabled':
+    case 'pairing':
+      return normalized;
+    default:
+      return 'open';
+  }
+}
+
+function normalizeGroupPolicy(value: unknown): BncrGroupPolicy {
+  const normalized = asString(value || 'open')
+    .trim()
+    .toLowerCase();
+  switch (normalized) {
+    case 'allowlist':
+    case 'disabled':
+      return normalized;
+    default:
+      return 'open';
+  }
+}
+
+export function resolveBncrChannelPolicy(channelCfg: BncrChannelPolicyConfig | null | undefined) {
   return {
     enabled: channelCfg?.enabled !== false,
-    dmPolicy: asString(channelCfg?.dmPolicy || 'open').toLowerCase(),
-    groupPolicy: asString(channelCfg?.groupPolicy || 'open').toLowerCase(),
+    dmPolicy: normalizeDmPolicy(channelCfg?.dmPolicy),
+    groupPolicy: normalizeGroupPolicy(channelCfg?.groupPolicy),
     allowFrom: asList(channelCfg?.allowFrom),
     groupAllowFrom: asList(channelCfg?.groupAllowFrom),
     requireMention: asBoolean(channelCfg?.requireMention, false),
   };
 }
 
-export function resolveBncrConfigWarnings(channelCfg: any): string[] {
+export function resolveBncrConfigWarnings(
+  channelCfg: BncrChannelPolicyConfig | null | undefined,
+): string[] {
   const policy = resolveBncrChannelPolicy(channelCfg || {});
   const warnings: string[] = [];
   if (policy.requireMention) {