@xmoxmo/bncr 0.6.5 → 0.6.7

package/src/messaging/inbound/commands.ts

@@ -11,6 +11,7 @@ import {
 import { dispatchOpenClawReplyWithBufferedBlockDispatcher } from '../../openclaw/reply-runtime.ts';
 import { resolveOpenClawAgentRoute } from '../../openclaw/routing-runtime.ts';
 import { performBncrGatewaySessionReset } from '../../openclaw/session-reset-runtime.ts';
+import { addNativeElevation, removeNativeElevation } from '../../plugin/config.ts';
 import { mergeBncrOwnerAllowFromIntoConfig } from './command-owner.ts';
 import type {
   BncrEnqueueFromReply,
@@ -120,8 +121,49 @@ export async function handleBncrNativeCommand(params: {
 
   // Stop always goes through the unified stop fast path in dispatch.ts.
   // It is not a bncr native command and must never be processed here.
-  if (isBncrStopCommandText(extracted.text)) {
-    return { handled: false };
+  // Only exact `/stop` is accepted; any other `/stop*` form is rejected.
+  const rawStopText = String(extracted.text || '')
+    .trim()
+    .toLowerCase();
+  if (rawStopText.startsWith('/stop')) {
+    if (isBncrStopCommandText(extracted.text)) {
+      return { handled: false };
+    }
+    // Non-exact `/stop` forms (extra args, @bot suffix, or other extension)
+    // are rejected immediately so they never reach the agent.
+    const rejectedRoute = buildBncrNativeCommandResolvedRoute({
+      api,
+      cfg,
+      channelId,
+      accountId,
+      peer,
+      resolvedAgentId,
+    });
+    const { baseSessionKey, sessionKey } = buildBncrNativeCommandSessionState({
+      parsed,
+      sessionAgentId: rejectedRoute.agentId || canonicalAgentId,
+      resolvedRoute: rejectedRoute,
+    });
+    logBncrNativeCommandSummary(
+      buildBncrNativeCommandSummary({
+        kind: 'stop',
+        command: rawStopText,
+        accountId,
+        to: formatDisplayScope(route),
+        msgId: msgId || null,
+        result: 'rejected',
+      }),
+    );
+    await enqueueFromReply({
+      accountId,
+      sessionKey: baseSessionKey,
+      route,
+      payload: {
+        text: 'Only exact /stop is supported. Send /stop to stop.',
+        replyToId: msgId || undefined,
+      },
+    });
+    return { handled: true, command: 'stop', sessionKey };
   }
 
   const whitelistBareCommand =
@@ -733,74 +775,83 @@ export async function handleBncrNativeCommand(params: {
     },
     { debugOnly: true, debugEnabled: nativeCommandDebugEnabled },
   );
-  await resolveBncrChannelInboundRuntime(api).run({
-    channel: channelId,
-    accountId,
-    raw: parsed,
-    adapter: {
-      ingest: () => ({
-        id: msgId ?? `${displayTo}:${Date.now()}`,
-        timestamp: Date.now(),
-        rawText: body,
-        textForAgent: ctxPayload.BodyForAgent,
-        textForCommands: ctxPayload.CommandBody,
-        raw: parsed,
-      }),
-      resolveTurn: () => {
-        const sessionMetaBarrier = createBncrSessionMetaTaskBarrier();
-        return {
-          channel: channelId,
-          accountId,
-          routeSessionKey: resolvedRoute.sessionKey,
-          storePath,
-          ctxPayload,
-          recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
-            recordInboundSession: recordBncrInboundSession as (
-              ...args: unknown[]
-            ) => Promise<unknown> | unknown,
-            expectedPatch: sessionIdentityPatch,
-          }),
-          record: {
-            updateLastRoute,
-            onRecordError: (err: unknown) => {
-              buildNativeCommandRecordErrorLogger(err);
-            },
-            trackSessionMetaTask: (task: Promise<unknown>) => {
-              sessionMetaBarrier.track(task);
-            },
-          },
-          runDispatch: async () => {
-            await sessionMetaBarrier.wait();
-            return dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
-              ctx: ctxPayload,
-              cfg: effectiveReply.replyCfg,
-              dispatcherOptions: {
-                deliver: createNativeCommandReplyDeliverer({
-                  command: command.command,
-                  accountId,
-                  sessionKey,
-                  to: displayTo,
-                  msgId: msgId || undefined,
-                  effectiveReply,
-                  route,
-                  enqueueFromReply,
-                  nativeCommandDebugEnabled,
-                  onResponded: () => responded,
-                  markResponded: () => {
-                    responded = true;
-                  },
-                }),
+  if (dispatchToOpenClaw && senderIdForContext) {
+    addNativeElevation(senderIdForContext);
+  }
+  try {
+    await resolveBncrChannelInboundRuntime(api).run({
+      channel: channelId,
+      accountId,
+      raw: parsed,
+      adapter: {
+        ingest: () => ({
+          id: msgId ?? `${displayTo}:${Date.now()}`,
+          timestamp: Date.now(),
+          rawText: body,
+          textForAgent: ctxPayload.BodyForAgent,
+          textForCommands: ctxPayload.CommandBody,
+          raw: parsed,
+        }),
+        resolveTurn: () => {
+          const sessionMetaBarrier = createBncrSessionMetaTaskBarrier();
+          return {
+            channel: channelId,
+            accountId,
+            routeSessionKey: resolvedRoute.sessionKey,
+            storePath,
+            ctxPayload,
+            recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
+              recordInboundSession: recordBncrInboundSession as (
+                ...args: unknown[]
+              ) => Promise<unknown> | unknown,
+              expectedPatch: sessionIdentityPatch,
+            }),
+            record: {
+              updateLastRoute,
+              onRecordError: (err: unknown) => {
+                buildNativeCommandRecordErrorLogger(err);
               },
-              replyOptions: {
-                disableBlockStreaming: !effectiveReply.blockStreaming,
-                shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+              trackSessionMetaTask: (task: Promise<unknown>) => {
+                sessionMetaBarrier.track(task);
               },
-            });
-          },
-        };
+            },
+            runDispatch: async () => {
+              await sessionMetaBarrier.wait();
+              return dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
+                ctx: ctxPayload,
+                cfg: effectiveReply.replyCfg,
+                dispatcherOptions: {
+                  deliver: createNativeCommandReplyDeliverer({
+                    command: command.command,
+                    accountId,
+                    sessionKey,
+                    to: displayTo,
+                    msgId: msgId || undefined,
+                    effectiveReply,
+                    route,
+                    enqueueFromReply,
+                    nativeCommandDebugEnabled,
+                    onResponded: () => responded,
+                    markResponded: () => {
+                      responded = true;
+                    },
+                  }),
+                },
+                replyOptions: {
+                  disableBlockStreaming: !effectiveReply.blockStreaming,
+                  shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+                },
+              });
+            },
+          };
+        },
       },
-    },
-  });
+    });
+  } finally {
+    if (dispatchToOpenClaw && senderIdForContext && !parsed.isAdmin) {
+      removeNativeElevation(senderIdForContext);
+    }
+  }
 
   if (!responded) {
     // Self-service commands must never fall back to the agent — doing so

package/src/messaging/inbound/conversation-history.ts

@@ -5,6 +5,7 @@ import {
   type HistoryEntry,
   type HistoryMediaEntry,
 } from 'openclaw/plugin-sdk/reply-history';
+import { BNCR_DEFAULT_ACCOUNT_ID, normalizeAccountId } from '../../core/accounts.ts';
 import { formatOpenClawAgentEnvelope } from '../../openclaw/reply-runtime.ts';
 import type { BncrInboundApi } from './contracts.ts';
 import type { ParsedInbound } from './dispatch-prep.ts';
@@ -87,33 +88,80 @@ export function resolveBncrHistoryLimit(historyLimit?: number): number {
   return resolved >= 2 ? resolved : DEFAULT_HISTORY_LIMIT;
 }
 
-export function buildBncrConversationHistoryKey(parsed: ParsedInbound): string | null {
+export function buildBncrConversationHistoryKey(
+  parsed: ParsedInbound,
+  options?: { accountId?: string | null },
+): string | null {
   const platform = String(parsed.platform || '').trim();
   if (!platform) return null;
+  const accountId = normalizeAccountId(options?.accountId ?? parsed.accountId);
   if (parsed.peer.kind === 'group') {
     const groupId = String(parsed.groupId || '').trim();
     if (!groupId || groupId === '0') return null;
-    return `${platform}:${groupId}`;
+    return `${accountId}:${platform}:${groupId}`;
   }
   const userId = String(parsed.userId || '').trim();
   if (!userId || userId === '0') return null;
-  return `${platform}:${userId}`;
+  return `${accountId}:${platform}:${userId}`;
 }
 
 export function buildBncrConversationHistoryKeyFromRoute(args: {
+  accountId?: string | null;
   platform?: string;
   groupId?: string;
   userId?: string;
 }): string | null {
   const platform = String(args.platform || '').trim();
   if (!platform) return null;
+  const accountId = normalizeAccountId(args.accountId);
   const groupId = String(args.groupId || '0').trim() || '0';
   const userId = String(args.userId || '0').trim() || '0';
-  if (groupId !== '0') return `${platform}:${groupId}`;
-  if (userId !== '0') return `${platform}:${userId}`;
+  if (groupId !== '0') return `${accountId}:${platform}:${groupId}`;
+  if (userId !== '0') return `${accountId}:${platform}:${userId}`;
   return null;
 }
 
+/**
+ * Migrate legacy scene-only history keys (`tgBot:10001`) to the current
+ * account-scoped format (`Primary:tgBot:10001`). Keys that already carry an
+ * accountId prefix are returned unchanged.
+ */
+export function normalizePersistedHistoryKey(key: string): string {
+  const raw = String(key || '').trim();
+  if (!raw) return raw;
+  const firstColon = raw.indexOf(':');
+  const secondColon = raw.indexOf(':', firstColon + 1);
+  if (firstColon <= 0 || secondColon < 0) return `${BNCR_DEFAULT_ACCOUNT_ID}:${raw}`;
+  return `${normalizeAccountId(raw.slice(0, firstColon))}:${raw.slice(firstColon + 1)}`;
+}
+
+export function resolvePersistedHistoryAccountId(key: string): string {
+  const normalized = normalizePersistedHistoryKey(key);
+  const separator = normalized.indexOf(':');
+  return normalizeAccountId(separator > 0 ? normalized.slice(0, separator) : undefined);
+}
+
+export function resolvePersistedHistoryKey(key: string, accountId: string): string {
+  const normalized = normalizePersistedHistoryKey(key);
+  const separator = normalized.indexOf(':');
+  const sceneKey = separator > 0 ? normalized.slice(separator + 1) : normalized;
+  return `${normalizeAccountId(accountId)}:${sceneKey}`;
+}
+
+/**
+ * Extract the scene key (platform:userId or platform:groupId) from a history
+ * key that may contain an accountId prefix. Legacy scene-only keys pass
+ * through unchanged.
+ */
+export function resolveBncrSceneKeyFromHistoryKey(historyKey: string): string {
+  const key = String(historyKey || '').trim();
+  const firstColon = key.indexOf(':');
+  if (firstColon > 0 && key.indexOf(':', firstColon + 1) !== -1) {
+    return key.slice(firstColon + 1);
+  }
+  return key;
+}
+
 export function resolveBncrConversationHistoryMessageId(parsed: ParsedInbound): string | undefined {
   const msgId = String(parsed.msgId || '').trim();
   return msgId || undefined;

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

@@ -57,9 +57,9 @@ export type NativeSessionResetCommand = {
  * the same code path as an admin caller. This whitelist is shared
  * across permission checks so admin and non-admin logic stay in sync.
  *
- * `stop` stays in this whitelist for semantic consistency, but it is
- * routed through the unified stop fast path in dispatch.ts rather than
- * the native command handler, so it is never processed here.
+ * `stop` is intentionally absent: it is handled before this set by the
+ * unified stop fast path in dispatch.ts, and `isBncrStopCommandText` only
+ * accepts the exact `/stop` form.
  */
 export const BNCR_SELF_SERVICE_COMMANDS: ReadonlySet<string> = new Set([
   'whoami',
@@ -68,7 +68,6 @@ export const BNCR_SELF_SERVICE_COMMANDS: ReadonlySet<string> = new Set([
   'model',
   'new',
   'reset',
-  'stop',
 ]);
 
 /**
@@ -136,13 +135,7 @@ export const BNCR_NATIVE_COMMANDS = new Set([
   'download-media',
 ]);
 
-export const BNCR_DIRECT_ALLOWED_BARE_COMMANDS = new Set([
-  'whoami',
-  'status',
-  'new',
-  'reset',
-  'stop',
-]);
+export const BNCR_DIRECT_ALLOWED_BARE_COMMANDS = new Set(['whoami', 'status', 'new', 'reset']);
 
 export const BNCR_DIRECT_ALLOWED_SUBCOMMANDS = new Set([
   'help',
@@ -340,6 +333,9 @@ export function resolveBncrNativeSessionResetCommand(args: {
   peerKind: 'direct' | 'group';
 }): NativeSessionResetCommand | null {
   if (args.command.command !== 'new' && args.command.command !== 'reset') return null;
+  // new/reset are exact session-reset commands. Extra arguments are not
+  // valid and must not silently reset or create a session.
+  if (String(args.command.argsText || '').trim()) return null;
   const reason = args.command.command === 'new' ? 'new' : 'reset';
   return {
     handled: true,

package/src/messaging/inbound/outbound-replay-cache.ts

@@ -1,3 +1,4 @@
+import { normalizeAccountId } from '../../core/accounts.ts';
 import type {
   BncrOutboundReplayEntry,
   BncrOutboundReplayMediaEntry,
@@ -66,7 +67,7 @@ export function buildBncrOutboundReplayKeyFromRoute(args: {
   groupId?: string;
   userId?: string;
 }): string | null {
-  const accountId = String(args.accountId || '').trim() || 'default';
+  const accountId = normalizeAccountId(args.accountId);
   const platform = String(args.platform || '').trim();
   const groupId = String(args.groupId || '0').trim() || '0';
   const userId = String(args.userId || '0').trim() || '0';
@@ -167,6 +168,18 @@ export type BncrOutboundReplayRecordResult = {
   historyVersion?: number;
 };
 
+/**
+ * Record an outbound bot reply into both the conversation-history window and
+ * the outbound-replay cache.
+ *
+ * Dual-write strategy: the conversation-history window is the canonical
+ * ordered source for structured context (conversation_context). The
+ * outbound-replay cache is a lighter, indexed copy used by bridge-facing
+ * queries such as `listRecentOutbound`. Both are kept in sync for the
+ * duration of the runtime session. This is a compatibility design; the
+ * cache may be retired once all read paths are migrated to the history
+ * window.
+ */
 export function recordBncrOutboundReplay(args: {
   cache: BncrOutboundReplayCache;
   conversationHistories?: BncrConversationHistoryMap;
@@ -200,6 +213,7 @@ export function recordBncrOutboundReplay(args: {
   if (!body) return { recorded: false, historyOverflow: false };
   const recordTimestamp = args.entry.lastPushAt ?? Date.now();
   const historyKey = buildBncrConversationHistoryKeyFromRoute({
+    accountId: args.entry.accountId,
     platform: args.entry.route?.platform,
     groupId: args.entry.route?.groupId,
     userId: args.entry.route?.userId,
@@ -347,7 +361,9 @@ export function readBncrOutboundReplaySnapshot(args: {
     : [];
   if (!args.conversationHistories) return legacyEntries;
 
-  const historyKey = buildBncrConversationHistoryKey(args.parsed);
+  const historyKey = buildBncrConversationHistoryKey(args.parsed, {
+    accountId: args.accountId,
+  });
   const historyEntries = historyKey
     ? (args.conversationHistories.get(historyKey) || [])
         .filter((entry) => entry.role === 'assistant')

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

@@ -247,6 +247,14 @@ export async function runBncrInboundReplyDispatch(args: {
                     sessionMetaBarrier.track(task);
                   },
                 },
+                // OpenClaw ≥8.1 requires prepared turns to carry a runDispatchLifecycle
+                // shim. Bncr dispatches directly via runDispatch and does not participate
+                // in the adoption lifecycle, so turnAdoptionLifecycle is intentionally
+                // left as undefined; onDispatchSkipped is a safe no-op here.
+                runDispatchLifecycle: {
+                  turnAdoptionLifecycle: undefined,
+                  onDispatchSkipped: async () => {},
+                },
                 runDispatch: async () => {
                   await sessionMetaBarrier.wait();
                   await correctBncrInboundSessionLabel({

package/src/openclaw/session-reset-runtime.ts

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
@@ -12,7 +13,7 @@ type SessionResetParams = {
 type SessionResetFn = (params: SessionResetParams) => Promise<SessionResetResult>;
 
 let testOverride: SessionResetFn | null = null;
-let resolvedSessionRuntimeUrlCache: string | null = null;
+let resolvedSessionResetRuntimeCache: SessionResetFn | null = null;
 
 export function setBncrSessionResetRuntimeForTest(fn: SessionResetFn | null): () => void {
   const previous = testOverride;
@@ -22,56 +23,103 @@ export function setBncrSessionResetRuntimeForTest(fn: SessionResetFn | null): ()
   };
 }
 
-function resolveOpenClawSessionsRuntimeUrl(): string {
-  if (resolvedSessionRuntimeUrlCache) return resolvedSessionRuntimeUrlCache;
-  let current = dirname(fileURLToPath(import.meta.url));
-  let pluginRoot: string | null = null;
+function findPackageRoot(startPath: string, packageName: string): string | null {
+  let current = dirname(startPath);
   while (true) {
     const pkgPath = join(current, 'package.json');
     try {
       const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { name?: string };
-      if (pkg.name === '@xmoxmo/bncr') {
-        pluginRoot = current;
-        break;
-      }
+      if (pkg.name === packageName) return current;
     } catch {
-      // Keep walking up toward the plugin root.
+      // Keep walking toward the package root.
     }
     const parent = dirname(current);
-    if (parent === current) break;
+    if (parent === current) return null;
     current = parent;
   }
-  if (!pluginRoot) {
-    throw new Error('bncr plugin root not found for session reset runtime');
+}
+
+function resolveOpenClawDistDir(): string {
+  let current = dirname(fileURLToPath(import.meta.url));
+  let resolvedOpenClawEntry: string | null = null;
+  try {
+    resolvedOpenClawEntry = createRequire(import.meta.url).resolve('openclaw');
+  } catch {
+    // Fall back to the plugin-local dependency path below.
   }
 
-  // Try candidate paths for the sessions runtime re-export file.
-  // The hash-stamped bundle name may change across OpenClaw releases, so we
-  // first try the stable re-export entry and fall back to the known hash.
-  const candidates = [
-    join(pluginRoot, 'node_modules', 'openclaw', 'dist', 'sessions.runtime.js'),
-    join(pluginRoot, 'node_modules', 'openclaw', 'dist', 'sessions.runtime-BQwwkuFq.js'),
-  ];
-  for (const target of candidates) {
-    if (existsSync(target)) {
-      resolvedSessionRuntimeUrlCache = pathToFileURL(target).href;
-      return resolvedSessionRuntimeUrlCache;
+  const openClawRoot = resolvedOpenClawEntry
+    ? findPackageRoot(resolvedOpenClawEntry, 'openclaw')
+    : null;
+  if (openClawRoot) {
+    const distDir = join(openClawRoot, 'dist');
+    if (existsSync(distDir)) return distDir;
+  }
+
+  while (true) {
+    const pluginRoot = findPackageRoot(current, '@xmoxmo/bncr');
+    if (pluginRoot) {
+      const distDir = join(pluginRoot, 'node_modules', 'openclaw', 'dist');
+      if (existsSync(distDir)) return distDir;
     }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
   }
+
+  const resolvedPath = resolvedOpenClawEntry || '(unresolved)';
+  const pluginPath = join(
+    dirname(fileURLToPath(import.meta.url)),
+    'node_modules',
+    'openclaw',
+    'dist',
+  );
   throw new Error(
-    `OpenClaw sessions runtime not found under ${join(pluginRoot, 'node_modules', 'openclaw', 'dist')}`,
+    `OpenClaw dist directory not found (resolved entry: ${resolvedPath}; plugin fallback: ${pluginPath})`,
   );
 }
 
+function resolveOpenClawSessionsRuntimeUrls(): string[] {
+  const distDir = resolveOpenClawDistDir();
+  if (!existsSync(distDir)) {
+    throw new Error(`OpenClaw dist directory not found: ${distDir}`);
+  }
+
+  // Scan dist for sessions.runtime*.js, preferring the stable re-export.
+  const candidates = readdirSync(distDir)
+    .filter((name) => /^sessions\.runtime(?:-[A-Za-z0-9_-]+)?\.js$/.test(name))
+    .sort(
+      (a, b) =>
+        Number(b === 'sessions.runtime.js') - Number(a === 'sessions.runtime.js') ||
+        a.localeCompare(b),
+    );
+  return candidates.map((name) => pathToFileURL(join(distDir, name)).href);
+}
+
 export async function performBncrGatewaySessionReset(
   params: SessionResetParams,
 ): Promise<SessionResetResult> {
   if (testOverride) return testOverride(params);
-  const mod = (await import(resolveOpenClawSessionsRuntimeUrl())) as {
-    performGatewaySessionReset?: SessionResetFn;
-  };
-  if (typeof mod.performGatewaySessionReset !== 'function') {
-    throw new Error('OpenClaw performGatewaySessionReset is unavailable');
+  if (!resolvedSessionResetRuntimeCache) {
+    const candidates = resolveOpenClawSessionsRuntimeUrls();
+    const importErrors: string[] = [];
+    for (const url of candidates) {
+      try {
+        const mod = (await import(url)) as { performGatewaySessionReset?: SessionResetFn };
+        if (typeof mod.performGatewaySessionReset === 'function') {
+          resolvedSessionResetRuntimeCache = mod.performGatewaySessionReset;
+          break;
+        }
+        importErrors.push(`${url}: export unavailable`);
+      } catch (error) {
+        importErrors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (!resolvedSessionResetRuntimeCache) {
+      throw new Error(
+        `OpenClaw performGatewaySessionReset is unavailable; candidates: ${importErrors.join('; ') || '(none)'}`,
+      );
+    }
   }
-  return mod.performGatewaySessionReset(params);
+  return resolvedSessionResetRuntimeCache(params);
 }

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

@@ -86,7 +86,7 @@ export type BncrPersistedConversationHistoryEntry = {
 export type BncrPersistedConversationHistoryMediaEntry = {
   path?: string;
   contentType?: string;
-  kind?: 'image' | 'video' | 'audio' | 'document' | 'unknown';
+  kind?: 'image' | 'video' | 'audio' | 'document' | 'sticker' | 'unknown';
   messageId?: string;
 };
 

package/src/plugin/config.ts

@@ -7,6 +7,17 @@ import {
 import { resolveBncrChannelPolicy } from '../core/policy.ts';
 import { setOpenClawAccountEnabledInConfigSection } from '../openclaw/sdk-helpers.ts';
 
+// 临时提权集合：非管理员用户执行原生命令时动态注入，命令完成后移除
+const pendingNativeElevation = new Set<string>();
+
+export function addNativeElevation(senderId: string): void {
+  if (senderId) pendingNativeElevation.add(senderId);
+}
+
+export function removeNativeElevation(senderId: string): void {
+  if (senderId) pendingNativeElevation.delete(senderId);
+}
+
 type BncrConfigSurfaceRoot = {
   channels?: {
     [CHANNEL_ID]?: {
@@ -53,4 +64,11 @@ export const BNCR_CONFIG_SURFACE = {
       configured: true,
     };
   },
+  resolveAllowFrom: ({ cfg }: { cfg: BncrConfigSurfaceRoot; accountId?: string | null }) => {
+    const policy = resolveBncrChannelPolicy(cfg?.channels?.[CHANNEL_ID] || {});
+    const base = policy.allowFrom;
+    if (pendingNativeElevation.size === 0) return base.length ? base : undefined;
+    const merged = [...base, ...pendingNativeElevation];
+    return merged.length ? merged : undefined;
+  },
 };

package/src/plugin/inbound-handlers.ts

@@ -1,4 +1,5 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import { runDetachedWebhookWork } from 'openclaw/plugin-sdk/webhook-request-guards';
 import { buildCanonicalBncrSessionKey } from '../core/targets.ts';
 import type { BncrConnection, BncrRoute } from '../core/types.ts';
 import type { BncrConversationHistoryMap } from '../messaging/inbound/conversation-history.ts';
@@ -171,6 +172,7 @@ export type BncrInboundHandlersRuntime = {
     defaultPublicAgentId: string;
     now: () => number;
   }) => Promise<unknown>;
+  runInboundDetached?: (run: () => Promise<unknown>) => Promise<unknown>;
 };
 
 export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRuntime, 'respond'>) {
@@ -326,8 +328,12 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
       );
       runtime.flushOnInboundAccepted(accountId);
 
-      void runtime
-        .dispatchInbound({
+      const runInboundDetached = runtime.runInboundDetached ?? runDetachedWebhookWork;
+      // Ack-first handlers must run follow-up work on an independent admitted
+      // root. Otherwise the host releases this request admission after respond,
+      // and later native/agent queue submissions are mistaken for draining.
+      void runInboundDetached(async () => {
+        await runtime.dispatchInbound({
           cfg,
           parsed,
           canonicalAgentId,
@@ -340,10 +346,10 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
           defaultAdminAgentId,
           defaultPublicAgentId: runtime.defaultPublicAgentId(),
           now: runtime.now,
-        })
-        .catch((err) => {
-          runtime.logError('inbound', `process failed: ${String(err)}`, { debugOnly: true });
         });
+      }).catch((err) => {
+        runtime.logError('inbound', `process failed: ${String(err)}`, { debugOnly: true });
+      });
     },
   };
 }