@xmoxmo/bncr 0.3.4 → 0.3.5

package/src/core/register-trace.ts

@@ -81,6 +81,54 @@ export function dominantRegisterBucket(sourceBuckets: Record<string, number>) {
   return winner;
 }
 
+export function normalizeRegisterDriftSnapshot(raw: unknown): RegisterDriftSnapshot | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const data = raw as Record<string, unknown>;
+  const finiteOrNull = (value: unknown): number | null => {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+  };
+  const cleanString = (value: unknown): string | null => {
+    const text = value == null ? '' : String(value);
+    return text.trim() || null;
+  };
+
+  return {
+    capturedAt: finiteNumberOr(data.capturedAt, 0),
+    registerCount: finiteOrNull(data.registerCount),
+    apiGeneration: finiteOrNull(data.apiGeneration),
+    postWarmupRegisterCount: finiteOrNull(data.postWarmupRegisterCount),
+    apiInstanceId: cleanString(data.apiInstanceId),
+    registryFingerprint: cleanString(data.registryFingerprint),
+    dominantBucket: cleanString(data.dominantBucket),
+    sourceBuckets:
+      data.sourceBuckets && typeof data.sourceBuckets === 'object'
+        ? { ...(data.sourceBuckets as Record<string, number>) }
+        : {},
+    traceWindowSize: finiteNumberOr(data.traceWindowSize, 0),
+    traceRecent: Array.isArray(data.traceRecent)
+      ? [...(data.traceRecent as Array<Record<string, unknown>>)]
+      : [],
+  };
+}
+
+export function dumpRegisterDriftSnapshot(snapshot: RegisterDriftSnapshot | null) {
+  return snapshot
+    ? {
+        capturedAt: snapshot.capturedAt,
+        registerCount: snapshot.registerCount,
+        apiGeneration: snapshot.apiGeneration,
+        postWarmupRegisterCount: snapshot.postWarmupRegisterCount,
+        apiInstanceId: snapshot.apiInstanceId,
+        registryFingerprint: snapshot.registryFingerprint,
+        dominantBucket: snapshot.dominantBucket,
+        sourceBuckets: { ...snapshot.sourceBuckets },
+        traceWindowSize: snapshot.traceWindowSize,
+        traceRecent: snapshot.traceRecent.map((trace) => ({ ...trace })),
+      }
+    : null;
+}
+
 export function buildRegisterTraceEntry(args: {
   ts: number;
   bridgeId: string;

package/src/core/status-meta.ts

@@ -0,0 +1,77 @@
+import type { PendingAdmission } from './types.ts';
+
+type RuntimeStatusMetaDisplayInput = {
+  pendingAdmissions?: PendingAdmission[];
+  lastSession?: { scope: string; updatedAt: number } | null;
+  lastActivityAt?: number | null;
+  lastInboundAt?: number | null;
+  lastOutboundAt?: number | null;
+};
+
+function now() {
+  return Date.now();
+}
+
+function finiteNumberOrNull(value: unknown): number | null {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function formatPendingAdmissionScope(route: unknown): string | null {
+  if (!route || typeof route !== 'object') return null;
+  const record = route as Record<string, unknown>;
+  if (
+    typeof record.platform !== 'string' ||
+    typeof record.groupId !== 'string' ||
+    typeof record.userId !== 'string'
+  ) {
+    return null;
+  }
+  return `${record.platform}:${record.groupId}:${record.userId}`;
+}
+
+function fmtAgo(ts?: number | null): string {
+  if (!ts || !Number.isFinite(ts) || ts <= 0) return '-';
+  const diff = Math.max(0, now() - ts);
+  if (diff < 1_000) return 'just now';
+  if (diff < 60_000) return `${Math.floor(diff / 1_000)}s ago`;
+  if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`;
+  if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}h ago`;
+  return `${Math.floor(diff / 86_400_000)}d ago`;
+}
+
+export function buildRuntimeStatusMetaDisplay(input: RuntimeStatusMetaDisplayInput) {
+  const lastSessionAt = finiteNumberOrNull(input.lastSession?.updatedAt);
+  const lastActivityAt = finiteNumberOrNull(input.lastActivityAt);
+  const lastInboundAt = finiteNumberOrNull(input.lastInboundAt);
+  const lastOutboundAt = finiteNumberOrNull(input.lastOutboundAt);
+
+  return {
+    pendingAdmissionsCount: Array.isArray(input.pendingAdmissions)
+      ? input.pendingAdmissions.length
+      : 0,
+    pendingAdmissions: Array.isArray(input.pendingAdmissions)
+      ? input.pendingAdmissions.map((item) => ({
+          clientId: item.clientId,
+          scope: formatPendingAdmissionScope(item.route),
+          scopes: Array.isArray(item.routes)
+            ? item.routes
+                .map((route) => formatPendingAdmissionScope(route))
+                .filter((scope): scope is string => scope !== null)
+            : [],
+          firstSeenAt: item.firstSeenAt,
+          lastSeenAt: item.lastSeenAt,
+          attempts: item.attempts,
+        }))
+      : [],
+    lastSessionScope: input.lastSession?.scope || null,
+    lastSessionAt,
+    lastSessionAgo: fmtAgo(lastSessionAt),
+    lastActivityAt,
+    lastActivityAgo: fmtAgo(lastActivityAt),
+    lastInboundAt,
+    lastInboundAgo: fmtAgo(lastInboundAt),
+    lastOutboundAt,
+    lastOutboundAgo: fmtAgo(lastOutboundAt),
+  };
+}

package/src/core/status.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { buildRuntimeStatusMetaDisplay } from './status-meta.ts';
 import type { BncrDiagnosticsSummary, PendingAdmission } from './types.ts';
 
 type RuntimeStatusInput = {
@@ -35,44 +36,50 @@ function finiteNumberOr(value: unknown, fallback: number): number {
   return Number.isFinite(n) ? n : fallback;
 }
 
-function fmtAgo(ts?: number | null): string {
-  if (!ts || !Number.isFinite(ts) || ts <= 0) return '-';
-  const diff = Math.max(0, now() - ts);
-  if (diff < 1_000) return 'just now';
-  if (diff < 60_000) return `${Math.floor(diff / 1_000)}s ago`;
-  if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`;
-  if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}h ago`;
-  return `${Math.floor(diff / 86_400_000)}d ago`;
+function nonNegativeFiniteNumberOr(value: unknown, fallback: number): number {
+  return Math.max(0, finiteNumberOr(value, fallback));
 }
 
 export function buildIntegratedDiagnostics(input: RuntimeStatusInput): BncrDiagnosticsSummary {
   const root = input.channelRoot || path.join(process.cwd(), 'plugins', 'bncr');
   const pluginIndexExists = fs.existsSync(path.join(root, 'index.ts'));
   const pluginChannelExists = fs.existsSync(path.join(root, 'src', 'channel.ts'));
+  const currentTime = now();
+  const startedAt = finiteNumberOr(input.startedAt, currentTime);
+  const pending = nonNegativeFiniteNumberOr(input.pending, 0);
+  const deadLetter = nonNegativeFiniteNumberOr(input.deadLetter, 0);
+  const activeConnections = nonNegativeFiniteNumberOr(input.activeConnections, 0);
+  const connectEvents = nonNegativeFiniteNumberOr(input.connectEvents, 0);
+  const inboundEvents = nonNegativeFiniteNumberOr(input.inboundEvents, 0);
+  const activityEvents = nonNegativeFiniteNumberOr(input.activityEvents, 0);
+  const ackEvents = nonNegativeFiniteNumberOr(input.ackEvents, 0);
+  const sessionRoutesCount = nonNegativeFiniteNumberOr(input.sessionRoutesCount, 0);
+  const invalidOutboxSessionKeys = nonNegativeFiniteNumberOr(input.invalidOutboxSessionKeys, 0);
+  const legacyAccountResidue = nonNegativeFiniteNumberOr(input.legacyAccountResidue, 0);
 
   return {
     health: {
       connected: input.connected,
-      pending: input.pending,
+      pending,
       pendingAdmissions: Array.isArray(input.pendingAdmissions)
         ? input.pendingAdmissions.length
         : 0,
-      deadLetter: input.deadLetter,
-      activeConnections: input.activeConnections,
-      connectEvents: input.connectEvents,
-      inboundEvents: input.inboundEvents,
-      activityEvents: input.activityEvents,
-      ackEvents: input.ackEvents,
-      uptimeSec: Math.floor((now() - input.startedAt) / 1000),
+      deadLetter,
+      activeConnections,
+      connectEvents,
+      inboundEvents,
+      activityEvents,
+      ackEvents,
+      uptimeSec: Math.max(0, Math.floor((currentTime - startedAt) / 1000)),
     },
     regression: {
       pluginFilesPresent: pluginIndexExists && pluginChannelExists,
       pluginIndexExists,
       pluginChannelExists,
-      totalKnownRoutes: input.sessionRoutesCount,
-      invalidOutboxSessionKeys: input.invalidOutboxSessionKeys,
-      legacyAccountResidue: input.legacyAccountResidue,
-      ok: input.invalidOutboxSessionKeys === 0 && input.legacyAccountResidue === 0,
+      totalKnownRoutes: sessionRoutesCount,
+      invalidOutboxSessionKeys,
+      legacyAccountResidue,
+      ok: invalidOutboxSessionKeys === 0 && legacyAccountResidue === 0,
     },
   };
 }
@@ -91,35 +98,21 @@ export function buildStatusHeadlineFromRuntime(input: RuntimeStatusInput): strin
 
 export function buildStatusMetaFromRuntime(input: RuntimeStatusInput) {
   const diagnostics = buildIntegratedDiagnostics(input);
+  const display = buildRuntimeStatusMetaDisplay(input);
   return {
-    pending: input.pending,
-    pendingAdmissionsCount: Array.isArray(input.pendingAdmissions)
-      ? input.pendingAdmissions.length
-      : 0,
-    pendingAdmissions: Array.isArray(input.pendingAdmissions)
-      ? input.pendingAdmissions.map((item) => ({
-          clientId: item.clientId,
-          scope: item.route
-            ? `${item.route.platform}:${item.route.groupId}:${item.route.userId}`
-            : null,
-          scopes: Array.isArray(item.routes)
-            ? item.routes.map((route) => `${route.platform}:${route.groupId}:${route.userId}`)
-            : [],
-          firstSeenAt: item.firstSeenAt,
-          lastSeenAt: item.lastSeenAt,
-          attempts: item.attempts,
-        }))
-      : [],
-    deadLetter: input.deadLetter,
-    lastSessionScope: input.lastSession?.scope || null,
-    lastSessionAt: input.lastSession?.updatedAt || null,
-    lastSessionAgo: fmtAgo(input.lastSession?.updatedAt || null),
-    lastActivityAt: input.lastActivityAt || null,
-    lastActivityAgo: fmtAgo(input.lastActivityAt || null),
-    lastInboundAt: input.lastInboundAt || null,
-    lastInboundAgo: fmtAgo(input.lastInboundAt || null),
-    lastOutboundAt: input.lastOutboundAt || null,
-    lastOutboundAgo: fmtAgo(input.lastOutboundAt || null),
+    pending: diagnostics.health.pending,
+    pendingAdmissionsCount: display.pendingAdmissionsCount,
+    pendingAdmissions: display.pendingAdmissions,
+    deadLetter: diagnostics.health.deadLetter,
+    lastSessionScope: display.lastSessionScope,
+    lastSessionAt: display.lastSessionAt,
+    lastSessionAgo: display.lastSessionAgo,
+    lastActivityAt: display.lastActivityAt,
+    lastActivityAgo: display.lastActivityAgo,
+    lastInboundAt: display.lastInboundAt,
+    lastInboundAgo: display.lastInboundAgo,
+    lastOutboundAt: display.lastOutboundAt,
+    lastOutboundAgo: display.lastOutboundAgo,
     diagnostics,
   };
 }
@@ -131,17 +124,17 @@ export function buildAccountRuntimeSnapshot(input: RuntimeStatusInput) {
     running: input.running ?? true,
     connected: input.connected,
     linked: input.connected,
-    lastEventAt: input.lastActivityAt || null,
-    lastInboundAt: input.lastInboundAt || null,
-    lastOutboundAt: input.lastOutboundAt || null,
+    lastEventAt: meta.lastActivityAt,
+    lastInboundAt: meta.lastInboundAt,
+    lastOutboundAt: meta.lastOutboundAt,
     mode: input.connected ? 'linked' : 'configured',
     lastError: input.lastError ?? null,
-    pending: input.pending,
-    deadLetter: input.deadLetter,
+    pending: meta.pending,
+    deadLetter: meta.deadLetter,
     lastSessionKey: input.lastSession?.sessionKey || null,
     lastSessionScope: input.lastSession?.scope || null,
-    lastSessionAt: input.lastSession?.updatedAt || null,
-    lastActivityAt: input.lastActivityAt || null,
+    lastSessionAt: meta.lastSessionAt,
+    lastActivityAt: meta.lastActivityAt,
     diagnostics: meta.diagnostics,
     meta,
   };
@@ -156,8 +149,8 @@ export function buildAccountStatusSnapshot(input: {
   const rt = input.runtime || {};
   const meta = rt?.meta || {};
 
-  const pending = finiteNumberOr(rt?.pending ?? meta.pending, 0);
-  const deadLetter = finiteNumberOr(rt?.deadLetter ?? meta.deadLetter, 0);
+  const pending = nonNegativeFiniteNumberOr(rt?.pending ?? meta.pending, 0);
+  const deadLetter = nonNegativeFiniteNumberOr(rt?.deadLetter ?? meta.deadLetter, 0);
   const lastSessionKey = rt?.lastSessionKey ?? meta.lastSessionKey ?? null;
   const lastSessionScope = rt?.lastSessionScope ?? meta.lastSessionScope ?? null;
   const lastSessionAt = rt?.lastSessionAt ?? meta.lastSessionAt ?? null;

package/src/messaging/inbound/commands.ts

@@ -11,10 +11,11 @@ import {
   resolveBncrPinnedMainDmOwnerFromAllowlist,
 } from '../../openclaw/inbound-session-runtime.ts';
 import { dispatchOpenClawReplyWithBufferedBlockDispatcher } from '../../openclaw/reply-runtime.ts';
-import {
-  resolveOpenClawAgentRoute,
-  resolveOpenClawInboundLastRouteSessionKey,
-} from '../../openclaw/routing-runtime.ts';
+import { resolveOpenClawAgentRoute } from '../../openclaw/routing-runtime.ts';
+import type { OutboundReplyTargetPolicy } from '../outbound/reply-target-policy.ts';
+import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
+import { parseBncrNativeCommand, resolveBncrNativeVerboseCommand } from './native-command.ts';
+import { buildBncrNativeReplyDeliveryPayload } from './native-reply-delivery.ts';
 import { buildBncrReplyConfig } from './reply-config.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 import {
@@ -25,38 +26,6 @@ import {
 
 type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
 
-type NativeCommand = {
-  command: string;
-  raw: string;
-  body: string;
-};
-
-type NativeVerboseCommand = {
-  handled: true;
-  verboseLevel?: 'on' | 'off' | 'full';
-  text: string;
-};
-
-function resolveBncrNativeVerboseCommand(command: NativeCommand): NativeVerboseCommand | null {
-  if (command.command !== 'verbose') return null;
-  const rawLevel = String(command.raw.slice('/verbose'.length) || '')
-    .trim()
-    .toLowerCase();
-  if (!rawLevel || rawLevel === 'status') {
-    return { handled: true, text: 'Current verbose level is unchanged.' };
-  }
-  if (rawLevel === 'on')
-    return { handled: true, verboseLevel: 'on', text: 'Verbose logging enabled.' };
-  if (rawLevel === 'off')
-    return { handled: true, verboseLevel: 'off', text: 'Verbose logging disabled.' };
-  if (rawLevel === 'full')
-    return { handled: true, verboseLevel: 'full', text: 'Verbose logging set to full.' };
-  return {
-    handled: true,
-    text: `Unrecognized verbose level "${rawLevel}". Valid levels: off, on, full.`,
-  };
-}
-
 function logBncrNativeCommandEvent(
   event: string,
   fields: Record<string, unknown>,
@@ -66,21 +35,7 @@ function logBncrNativeCommandEvent(
   emitBncrLogLine('info', `[bncr] native-command ${JSON.stringify({ event, ...fields })}`);
 }
 
-export function parseBncrNativeCommand(text: string): NativeCommand | null {
-  const raw = String(text || '').trim();
-  if (!raw.startsWith('/')) return null;
-  const match = raw.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/i);
-  if (!match) return null;
-
-  const command = String(match[1] || '')
-    .trim()
-    .toLowerCase();
-  if (!command) return null;
-
-  const rest = String(match[2] || '').trim();
-  const body = command === 'help' ? ['/commands', rest].filter(Boolean).join(' ') : raw;
-  return { command, raw, body };
-}
+export { parseBncrNativeCommand } from './native-command.ts';
 
 export async function handleBncrNativeCommand(params: {
   api: any;
@@ -95,6 +50,7 @@ export async function handleBncrNativeCommand(params: {
     route: any;
     payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] };
     mediaLocalRoots?: readonly string[];
+    replyTargetPolicy?: OutboundReplyTargetPolicy;
   }) => Promise<void>;
   logger?: { warn?: (msg: string) => void; error?: (msg: string) => void };
 }): Promise<
@@ -284,9 +240,15 @@ export async function handleBncrNativeCommand(params: {
           normalizeEntry: (entry: string) => String(entry || '').trim(),
         })
       : null;
-  const inboundLastRouteSessionKey = resolveOpenClawInboundLastRouteSessionKey({
-    route: resolvedRoute,
+  const updateLastRoute = buildBncrInboundRecordUpdateLastRoute({
+    channelId,
+    peerKind: peer.kind,
+    senderIdForContext,
+    accountId,
+    to: displayTo,
+    resolvedRoute,
     sessionKey,
+    pinnedMainDmOwner,
   });
 
   let responded = false;
@@ -325,22 +287,7 @@ export async function handleBncrNativeCommand(params: {
           expectedLabel: displayTo,
         }),
         record: {
-          updateLastRoute:
-            peer.kind === 'direct'
-              ? {
-                  sessionKey: inboundLastRouteSessionKey,
-                  channel: channelId,
-                  to: displayTo,
-                  accountId,
-                  mainDmOwnerPin:
-                    inboundLastRouteSessionKey === resolvedRoute.mainSessionKey && pinnedMainDmOwner
-                      ? {
-                          ownerRecipient: pinnedMainDmOwner,
-                          senderRecipient: senderIdForContext,
-                        }
-                      : undefined,
-                }
-              : undefined,
+          updateLastRoute,
           onRecordError: (err: unknown) => {
             emitBncrLogLine(
               'warn',
@@ -363,18 +310,13 @@ export async function handleBncrNativeCommand(params: {
                 info?: { kind?: 'tool' | 'block' | 'final' },
               ) => {
                 const kind = info?.kind;
-                const shouldForwardTool = effectiveReply.blockStreaming && effectiveReply.allowTool;
-
-                if (kind === 'tool' && !shouldForwardTool) {
-                  return;
-                }
-
-                const hasPayload = Boolean(
-                  payload?.text ||
-                    payload?.mediaUrl ||
-                    (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0),
-                );
-                if (!hasPayload) return;
+                const deliveryPayload = buildBncrNativeReplyDeliveryPayload({
+                  payload,
+                  kind,
+                  effectiveReply,
+                  msgId,
+                });
+                if (!deliveryPayload) return;
                 if (!responded) {
                   logBncrNativeCommandEvent(
                     'payload-produced',
@@ -395,11 +337,8 @@ export async function handleBncrNativeCommand(params: {
                   accountId,
                   sessionKey,
                   route,
-                  payload: {
-                    ...payload,
-                    kind: kind as 'tool' | 'block' | 'final' | undefined,
-                    replyToId: msgId || undefined,
-                  },
+                  payload: deliveryPayload,
+                  replyTargetPolicy: 'preserve',
                 });
               },
             },

package/src/messaging/inbound/dispatch.ts

@@ -18,15 +18,14 @@ import {
   formatOpenClawAgentEnvelope,
   resolveOpenClawEnvelopeFormatOptions,
 } from '../../openclaw/reply-runtime.ts';
-import {
-  resolveOpenClawAgentRoute,
-  resolveOpenClawInboundLastRouteSessionKey,
-} from '../../openclaw/routing-runtime.ts';
+import { resolveOpenClawAgentRoute } from '../../openclaw/routing-runtime.ts';
+import type { OutboundReplyTargetPolicy } from '../outbound/reply-target-policy.ts';
 import { handleBncrNativeCommand } from './commands.ts';
 import {
   buildBncrPromptVisibleContextFacts,
   buildBncrStructuredContextFactsFromInboundParts,
 } from './context-facts.ts';
+import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
 import { buildBncrReplyConfig } from './reply-config.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 import { wrapBncrInboundRecordSessionLabelCorrection } from './session-label.ts';
@@ -330,36 +329,6 @@ function buildBncrInboundTurnContext(args: {
   });
 }
 
-function buildBncrInboundRecordUpdateLastRoute(args: {
-  channelId: string;
-  peer: ParsedInbound['peer'];
-  senderIdForContext: string;
-  resolution: BncrInboundConversationResolution;
-  pinnedMainDmOwner: string | null;
-}) {
-  const { channelId, peer, senderIdForContext, resolution, pinnedMainDmOwner } = args;
-  if (peer.kind !== 'direct') return undefined;
-
-  const sessionKey = resolveOpenClawInboundLastRouteSessionKey({
-    route: resolution.resolvedRoute,
-    sessionKey: resolution.dispatchSessionKey,
-  });
-
-  return {
-    sessionKey,
-    channel: channelId,
-    to: resolution.canonicalTo,
-    accountId: resolution.accountId,
-    mainDmOwnerPin:
-      sessionKey === resolution.resolvedRoute.mainSessionKey && pinnedMainDmOwner
-        ? {
-            ownerRecipient: pinnedMainDmOwner,
-            senderRecipient: senderIdForContext,
-          }
-        : undefined,
-  };
-}
-
 function buildBncrInboundReplyRouteFact(
   resolution: BncrInboundConversationResolution,
 ): BncrInboundReplyRouteFact {
@@ -386,6 +355,7 @@ export async function dispatchBncrInbound(params: {
     route: any;
     payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] };
     mediaLocalRoots?: readonly string[];
+    replyTargetPolicy?: OutboundReplyTargetPolicy;
   }) => Promise<void>;
   setInboundActivity: (accountId: string, at: number) => void;
   scheduleSave: () => void;
@@ -478,9 +448,12 @@ export async function dispatchBncrInbound(params: {
       : null;
   const updateLastRoute = buildBncrInboundRecordUpdateLastRoute({
     channelId,
-    peer,
+    peerKind: peer.kind,
     senderIdForContext,
-    resolution,
+    accountId: resolution.accountId,
+    to: resolution.canonicalTo,
+    resolvedRoute: resolution.resolvedRoute,
+    sessionKey: resolution.dispatchSessionKey,
     pinnedMainDmOwner,
   });
 

package/src/messaging/inbound/last-route.ts

@@ -0,0 +1,46 @@
+import { resolveOpenClawInboundLastRouteSessionKey } from '../../openclaw/routing-runtime.ts';
+
+export function buildBncrInboundRecordUpdateLastRoute(args: {
+  channelId: string;
+  peerKind: 'direct' | 'group';
+  senderIdForContext: string;
+  accountId: string;
+  to: string;
+  resolvedRoute: {
+    sessionKey: string;
+    mainSessionKey?: string;
+  };
+  sessionKey: string;
+  pinnedMainDmOwner: string | null;
+}) {
+  const {
+    channelId,
+    peerKind,
+    senderIdForContext,
+    accountId,
+    to,
+    resolvedRoute,
+    sessionKey,
+    pinnedMainDmOwner,
+  } = args;
+  if (peerKind !== 'direct') return undefined;
+
+  const inboundLastRouteSessionKey = resolveOpenClawInboundLastRouteSessionKey({
+    route: resolvedRoute,
+    sessionKey,
+  });
+
+  return {
+    sessionKey: inboundLastRouteSessionKey,
+    channel: channelId,
+    to,
+    accountId,
+    mainDmOwnerPin:
+      inboundLastRouteSessionKey === resolvedRoute.mainSessionKey && pinnedMainDmOwner
+        ? {
+            ownerRecipient: pinnedMainDmOwner,
+            senderRecipient: senderIdForContext,
+          }
+        : undefined,
+  };
+}

package/src/messaging/inbound/native-command.ts

@@ -0,0 +1,49 @@
+export type NativeCommand = {
+  command: string;
+  raw: string;
+  body: string;
+};
+
+export type NativeVerboseCommand = {
+  handled: true;
+  verboseLevel?: 'on' | 'off' | 'full';
+  text: string;
+};
+
+export function parseBncrNativeCommand(text: string): NativeCommand | null {
+  const raw = String(text || '').trim();
+  if (!raw.startsWith('/')) return null;
+  const match = raw.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/i);
+  if (!match) return null;
+
+  const command = String(match[1] || '')
+    .trim()
+    .toLowerCase();
+  if (!command) return null;
+
+  const rest = String(match[2] || '').trim();
+  const body = command === 'help' ? ['/commands', rest].filter(Boolean).join(' ') : raw;
+  return { command, raw, body };
+}
+
+export function resolveBncrNativeVerboseCommand(
+  command: NativeCommand,
+): NativeVerboseCommand | null {
+  if (command.command !== 'verbose') return null;
+  const rawLevel = String(command.raw.slice('/verbose'.length) || '')
+    .trim()
+    .toLowerCase();
+  if (!rawLevel || rawLevel === 'status') {
+    return { handled: true, text: 'Current verbose level is unchanged.' };
+  }
+  if (rawLevel === 'on')
+    return { handled: true, verboseLevel: 'on', text: 'Verbose logging enabled.' };
+  if (rawLevel === 'off')
+    return { handled: true, verboseLevel: 'off', text: 'Verbose logging disabled.' };
+  if (rawLevel === 'full')
+    return { handled: true, verboseLevel: 'full', text: 'Verbose logging set to full.' };
+  return {
+    handled: true,
+    text: `Unrecognized verbose level "${rawLevel}". Valid levels: off, on, full.`,
+  };
+}

package/src/messaging/inbound/native-reply-delivery.ts

@@ -0,0 +1,43 @@
+type BncrNativeReplyKind = 'tool' | 'block' | 'final';
+
+export type BncrNativeReplyDeliveryPayload = {
+  text?: string;
+  mediaUrl?: string;
+  mediaUrls?: string[];
+  audioAsVoice?: boolean;
+  replyToId?: string;
+};
+
+export function buildBncrNativeReplyDeliveryPayload(args: {
+  payload?: {
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    audioAsVoice?: boolean;
+  };
+  kind?: BncrNativeReplyKind;
+  effectiveReply: {
+    blockStreaming: boolean;
+    allowTool: boolean;
+  };
+  msgId?: string;
+}): BncrNativeReplyDeliveryPayload | null {
+  const { payload, kind, effectiveReply, msgId } = args;
+  const shouldForwardTool = effectiveReply.blockStreaming && effectiveReply.allowTool;
+
+  if (kind === 'tool' && !shouldForwardTool) {
+    return null;
+  }
+
+  const hasPayload = Boolean(
+    payload?.text ||
+      payload?.mediaUrl ||
+      (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0),
+  );
+  if (!hasPayload) return null;
+
+  return {
+    ...payload,
+    replyToId: msgId || undefined,
+  };
+}