@xmoxmo/bncr 0.3.3 → 0.3.5

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

@@ -0,0 +1,53 @@
+import { normalizeAccountId } from './accounts.ts';
+import { normalizeStoredSessionKey, parseRouteLike } from './targets.ts';
+import type { OutboxEntry } from './types.ts';
+
+function asString(v: unknown, fallback = ''): string {
+  if (typeof v === 'string') return v;
+  if (v == null) return fallback;
+  return String(v);
+}
+
+function finiteNumberOr(value: unknown, fallback: number): number {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function optionalFiniteNumber(value: unknown): number | undefined {
+  if (value == null || value === '') return undefined;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+export function normalizePersistedOutboxEntry(args: {
+  entry: any;
+  canonicalAgentId: string;
+  now: () => number;
+}): OutboxEntry | null {
+  const { entry, canonicalAgentId } = args;
+  if (!entry?.messageId) return null;
+  const accountId = normalizeAccountId(entry.accountId);
+  const sessionKey = asString(entry.sessionKey || '').trim();
+  const normalized = normalizeStoredSessionKey(sessionKey, canonicalAgentId);
+  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;
+
+  return {
+    ...entry,
+    accountId,
+    sessionKey: normalized.sessionKey,
+    route,
+    payload,
+    createdAt: finiteNumberOr(entry.createdAt, args.now()),
+    retryCount: finiteNumberOr(entry.retryCount, 0),
+    nextAttemptAt: finiteNumberOr(entry.nextAttemptAt, args.now()),
+    lastAttemptAt: optionalFiniteNumber(entry.lastAttemptAt),
+    lastError: entry.lastError ? asString(entry.lastError) : undefined,
+  };
+}

package/src/core/probe.ts

@@ -1,3 +1,19 @@
+function finiteNumberOr(value: unknown, fallback: number): number {
+  if (value == null) return fallback;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function finiteNumberOrNull(value: unknown): number | null {
+  if (value == null) return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function nonNegativeFiniteNumberOr(value: unknown, fallback: number): number {
+  return Math.max(0, finiteNumberOr(value, fallback));
+}
+
 export function probeBncrAccount(params: {
   accountId: string;
   connected: boolean;
@@ -14,18 +30,22 @@ export function probeBncrAccount(params: {
   };
 }) {
   const issues: string[] = [];
+  const pending = nonNegativeFiniteNumberOr(params.pending, 0);
+  const deadLetter = nonNegativeFiniteNumberOr(params.deadLetter, 0);
+  const activeConnections = nonNegativeFiniteNumberOr(params.activeConnections, 0);
+  const invalidOutboxSessionKeys = nonNegativeFiniteNumberOr(params.invalidOutboxSessionKeys, 0);
+  const legacyAccountResidue = nonNegativeFiniteNumberOr(params.legacyAccountResidue, 0);
 
   if (!params.connected) issues.push('not-connected');
-  if (params.pending > 20) issues.push('pending-high');
-  if (params.deadLetter > 0) issues.push('dead-letter');
-  if (params.activeConnections > 3) issues.push('too-many-connections');
-  if (params.invalidOutboxSessionKeys > 0) issues.push('invalid-session-keys');
-  if (params.legacyAccountResidue > 0) issues.push('legacy-account-residue');
+  if (pending > 20) issues.push('pending-high');
+  if (deadLetter > 0) issues.push('dead-letter');
+  if (activeConnections > 3) issues.push('too-many-connections');
+  if (invalidOutboxSessionKeys > 0) issues.push('invalid-session-keys');
+  if (legacyAccountResidue > 0) issues.push('legacy-account-residue');
 
   let level: 'ok' | 'warn' | 'error' = 'ok';
   if (issues.length > 0) level = 'warn';
-  if (!params.connected && (params.deadLetter > 0 || params.invalidOutboxSessionKeys > 0))
-    level = 'error';
+  if (!params.connected && (deadLetter > 0 || invalidOutboxSessionKeys > 0)) level = 'error';
 
   return {
     ok: level === 'ok',
@@ -34,12 +54,12 @@ export function probeBncrAccount(params: {
     details: {
       accountId: params.accountId,
       connected: params.connected,
-      pending: params.pending,
-      deadLetter: params.deadLetter,
-      activeConnections: params.activeConnections,
-      invalidOutboxSessionKeys: params.invalidOutboxSessionKeys,
-      legacyAccountResidue: params.legacyAccountResidue,
-      lastActivityAt: params.lastActivityAt ?? null,
+      pending,
+      deadLetter,
+      activeConnections,
+      invalidOutboxSessionKeys,
+      legacyAccountResidue,
+      lastActivityAt: finiteNumberOrNull(params.lastActivityAt),
       structure: params.structure ?? null,
     },
   };

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

@@ -5,6 +5,17 @@ import {
   normalizeInboundSessionKey,
   withTaskSessionKey,
 } from '../../core/targets.ts';
+import {
+  recordBncrInboundSession,
+  resolveBncrInboundSessionStorePath,
+  resolveBncrPinnedMainDmOwnerFromAllowlist,
+} from '../../openclaw/inbound-session-runtime.ts';
+import { dispatchOpenClawReplyWithBufferedBlockDispatcher } from '../../openclaw/reply-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 {
@@ -12,43 +23,9 @@ import {
   recordAndPatchBncrInboundSessionEntry,
   wrapBncrInboundRecordSessionLabelCorrection,
 } from './session-label.ts';
-import { dispatchOpenClawReplyWithBufferedBlockDispatcher } from '../../openclaw/reply-runtime.ts';
-import {
-  resolveOpenClawAgentRoute,
-  resolveOpenClawInboundLastRouteSessionKey,
-} from '../../openclaw/routing-runtime.ts';
-import {
-  recordBncrInboundSession,
-  resolveBncrInboundSessionStorePath,
-  resolveBncrPinnedMainDmOwnerFromAllowlist,
-} from '../../openclaw/inbound-session-runtime.ts';
 
 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>,
@@ -58,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;
@@ -87,23 +50,25 @@ 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<
   | { handled: false }
   | { handled: true; command: string; sessionKey: string; fallbackToAgent?: boolean }
 > {
+  const { api, channelId, cfg, parsed, canonicalAgentId, rememberSessionRoute, enqueueFromReply } =
+    params;
   const {
-    api,
-    channelId,
-    cfg,
-    parsed,
-    canonicalAgentId,
-    rememberSessionRoute,
-    enqueueFromReply,
-    logger,
-  } = params;
-  const { accountId, route, peer, sessionKeyfromroute, providedOriginatingTo, clientId, extracted, msgId } = parsed;
+    accountId,
+    route,
+    peer,
+    sessionKeyfromroute,
+    providedOriginatingTo,
+    clientId,
+    extracted,
+    msgId,
+  } = parsed;
   const command = parseBncrNativeCommand(extracted.text);
   if (!command) return { handled: false };
   const nativeCommandDebugEnabled = cfg?.channels?.[channelId]?.debug?.verbose === true;
@@ -275,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;
@@ -316,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',
@@ -354,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',
@@ -386,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',
                 });
               },
             },