@xmoxmo/bncr 0.4.7 → 0.4.9

package/README.md

@@ -81,6 +81,14 @@ openclaw devices approve --latest
 - 状态诊断
 - 文件互传
 
+补充口径：
+
+- 入站会话按正式 scene / route 语义接入 OpenClaw，区分私聊与群聊会话。
+- 非管理员私聊支持受控的本地命令能力：`/whoami`、`/status`、`/new`、`/reset`，以及对应的 `/bncr ...` 入口。
+- 非管理员私聊中，不在支持范围内的 slash 命令会由 bncr 直接拒绝，不再 fallback 到 agent。
+- 群聊里的管理型 / 控制型命令对非管理员按静默拒绝处理，不给用户可见回复。
+- `/bncr list pending` 与 `/bncr list scenes` 采用按私聊 / 群聊分组的摘要展示格式，便于现场排查 scene 状态。
+
 ---
 
 ## 5. 架构定位

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmoxmo/bncr",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "private": false,
   "type": "module",
   "license": "MIT",

package/src/messaging/inbound/commands.ts

@@ -22,7 +22,10 @@ import type { ParsedInbound } from './dispatch-prep.ts';
 import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
 import {
   parseBncrNativeCommand,
+  parseBncrUnsupportedDirectCommand,
   resolveBncrNativeHelpCommand,
+  resolveBncrNativeSessionResetCommand,
+  resolveBncrNativeStatusCommand,
   resolveBncrNativeVerboseCommand,
   resolveBncrNativeWhoamiCommand,
 } from './native-command.ts';
@@ -129,7 +132,48 @@ export async function handleBncrNativeCommand(params: {
   const { accountId, route, peer, clientId, extracted, msgId } = parsed;
   const command = parseBncrNativeCommand(extracted.text, {
     allowBareWhoami: parsed.isAdmin !== true,
+    allowBareStatus: parsed.isAdmin !== true && parsed.peer.kind === 'direct',
+    allowBareSessionReset: parsed.isAdmin !== true && parsed.peer.kind === 'direct',
   });
+  if (!command && parsed.peer.kind === 'direct') {
+    const unsupportedDirectCommand = parseBncrUnsupportedDirectCommand(extracted.text);
+    if (unsupportedDirectCommand) {
+      const rejectedRoute = buildBncrNativeCommandResolvedRoute({
+        api,
+        cfg,
+        channelId,
+        accountId,
+        peer,
+        resolvedAgentId,
+      });
+      const { baseSessionKey, sessionKey } = buildBncrNativeCommandSessionState({
+        parsed,
+        sessionAgentId: rejectedRoute.agentId || canonicalAgentId,
+        resolvedRoute: rejectedRoute,
+      });
+      const displayTo = formatDisplayScope(route);
+      logBncrNativeCommandSummary(
+        buildBncrNativeCommandSummary({
+          kind: 'unsupported',
+          command: unsupportedDirectCommand.command,
+          accountId,
+          to: displayTo,
+          msgId: msgId || null,
+          result: 'rejected',
+        }),
+      );
+      await enqueueFromReply({
+        accountId,
+        sessionKey: baseSessionKey,
+        route,
+        payload: {
+          text: `Unsupported private-chat command: /${unsupportedDirectCommand.command}`,
+          replyToId: msgId || undefined,
+        },
+      });
+      return { handled: true, command: unsupportedDirectCommand.command, sessionKey };
+    }
+  }
   if (!command) return { handled: false };
   const nativeCommandDebugEnabled = resolveNativeCommandDebugEnabled({ cfg, channelId });
 
@@ -213,6 +257,16 @@ export async function handleBncrNativeCommand(params: {
     isGroup: parsed.isGroup,
     isAdmin: parsed.isAdmin,
   });
+  const nativeStatus = resolveBncrNativeStatusCommand({
+    command,
+    accountId,
+    platform: parsed.platform,
+    userId: parsed.userId,
+    userName: parsed.userName,
+    resolvedAgentId: resolvedRoute.agentId || canonicalAgentId,
+    sessionKey,
+  });
+  const nativeSessionReset = resolveBncrNativeSessionResetCommand({ command });
   if (nativeHelp) {
     logBncrNativeCommandSummary(
       buildBncrNativeCommandSummary({
@@ -273,11 +327,42 @@ export async function handleBncrNativeCommand(params: {
     return { handled: true, command: command.command, sessionKey };
   }
 
-  if (nativeVerbose) {
-    if (!parsed.isAdmin) {
+  if (nativeStatus) {
+    logBncrNativeCommandSummary(
+      buildBncrNativeCommandSummary({
+        kind: 'status',
+        command: command.command,
+        accountId,
+        to: displayTo,
+        msgId: msgId || null,
+        result: 'handled',
+      }),
+    );
+    await recordAndPatchBncrInboundSessionEntry({
+      storePath,
+      sessionKey,
+      ctx: ctxPayload,
+      patch: sessionIdentityPatch,
+    });
+    rememberSessionRoute(baseSessionKey, accountId, route);
+    await enqueueFromReply({
+      accountId,
+      sessionKey,
+      route,
+      payload: {
+        text: nativeStatus.text,
+        replyToId: msgId || undefined,
+      },
+    });
+    return { handled: true, command: command.command, sessionKey };
+  }
+
+  if (nativeSessionReset) {
+    const allowLocalSessionReset = parsed.peer.kind === 'direct';
+    if (!allowLocalSessionReset) {
       logBncrNativeCommandSummary(
         buildBncrNativeCommandSummary({
-          kind: 'verbose',
+          kind: nativeSessionReset.reason,
           command: command.command,
           accountId,
           to: displayTo,
@@ -292,15 +377,83 @@ export async function handleBncrNativeCommand(params: {
         patch: sessionIdentityPatch,
       });
       rememberSessionRoute(baseSessionKey, accountId, route);
-      await enqueueFromReply({
+      return { handled: true, command: command.command, sessionKey };
+    }
+
+    const requestedAgentId = resolvedRoute.agentId || canonicalAgentId;
+    const requestApi = api as BncrInboundApi & {
+      request?: (method: string, params: Record<string, unknown>) => Promise<unknown>;
+    };
+    if (typeof requestApi.request !== 'function') {
+      throw new Error('OpenClaw plugin api.request is unavailable for sessions.reset');
+    }
+    await recordAndPatchBncrInboundSessionEntry({
+      storePath,
+      sessionKey,
+      ctx: ctxPayload,
+      patch: sessionIdentityPatch,
+    });
+    const resetResult = (await requestApi.request('sessions.reset', {
+      key: baseSessionKey,
+      reason: nativeSessionReset.reason,
+      ...(requestedAgentId ? { agentId: requestedAgentId } : {}),
+    })) as { ok?: boolean } | undefined;
+    if (resetResult?.ok === false) {
+      throw new Error(`sessions.reset failed for ${baseSessionKey}`);
+    }
+    logBncrNativeCommandSummary(
+      buildBncrNativeCommandSummary({
+        kind: nativeSessionReset.reason,
+        command: command.command,
         accountId,
+        to: displayTo,
+        msgId: msgId || null,
+        result: 'handled',
+      }),
+    );
+    rememberSessionRoute(baseSessionKey, accountId, route);
+    await enqueueFromReply({
+      accountId,
+      sessionKey: baseSessionKey,
+      route,
+      payload: {
+        text: nativeSessionReset.text,
+        replyToId: msgId || undefined,
+      },
+    });
+    return { handled: true, command: command.command, sessionKey: baseSessionKey };
+  }
+
+  if (nativeVerbose) {
+    if (!parsed.isAdmin) {
+      logBncrNativeCommandSummary(
+        buildBncrNativeCommandSummary({
+          kind: 'verbose',
+          command: command.command,
+          accountId,
+          to: displayTo,
+          msgId: msgId || null,
+          result: 'rejected',
+        }),
+      );
+      await recordAndPatchBncrInboundSessionEntry({
+        storePath,
         sessionKey,
-        route,
-        payload: {
-          text: 'Admin permission required.',
-          replyToId: msgId || undefined,
-        },
+        ctx: ctxPayload,
+        patch: sessionIdentityPatch,
       });
+      rememberSessionRoute(baseSessionKey, accountId, route);
+      if (parsed.peer.kind !== 'group') {
+        await enqueueFromReply({
+          accountId,
+          sessionKey,
+          route,
+          payload: {
+            text: 'Admin permission required.',
+            replyToId: msgId || undefined,
+          },
+        });
+      }
       return { handled: true, command: command.command, sessionKey };
     }
 
@@ -350,6 +503,7 @@ export async function handleBncrNativeCommand(params: {
 
   const sceneAdmin = parseSceneAdminCommand(command);
   if (sceneAdmin.matched) {
+    const silentNonAdminGroupReject = !parsed.isAdmin && parsed.peer.kind === 'group';
     if (!sceneAdmin.valid) {
       logBncrNativeCommandSummary(
         buildBncrNativeCommandSummary({
@@ -367,15 +521,17 @@ export async function handleBncrNativeCommand(params: {
         ctx: ctxPayload,
         patch: sessionIdentityPatch,
       });
-      await enqueueFromReply({
-        accountId,
-        sessionKey,
-        route,
-        payload: {
-          text: sceneAdmin.text,
-          replyToId: msgId || undefined,
-        },
-      });
+      if (!silentNonAdminGroupReject) {
+        await enqueueFromReply({
+          accountId,
+          sessionKey,
+          route,
+          payload: {
+            text: sceneAdmin.text,
+            replyToId: msgId || undefined,
+          },
+        });
+      }
       return { handled: true, command: command.command, sessionKey };
     }
 
@@ -403,15 +559,17 @@ export async function handleBncrNativeCommand(params: {
       ctx: ctxPayload,
       patch: sessionIdentityPatch,
     });
-    await enqueueFromReply({
-      accountId,
-      sessionKey,
-      route,
-      payload: {
-        text: outcome.text,
-        replyToId: msgId || undefined,
-      },
-    });
+    if (!(silentNonAdminGroupReject && !outcome.ok)) {
+      await enqueueFromReply({
+        accountId,
+        sessionKey,
+        route,
+        payload: {
+          text: outcome.text,
+          replyToId: msgId || undefined,
+        },
+      });
+    }
     return { handled: true, command: command.command, sessionKey };
   }
 

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

@@ -7,6 +7,8 @@ export type NativeCommand = {
 
 export type ParseBncrNativeCommandOptions = {
   allowBareWhoami?: boolean;
+  allowBareStatus?: boolean;
+  allowBareSessionReset?: boolean;
 };
 
 export type NativeVerboseCommand = {
@@ -25,6 +27,17 @@ export type NativeWhoamiCommand = {
   text: string;
 };
 
+export type NativeStatusCommand = {
+  handled: true;
+  text: string;
+};
+
+export type NativeSessionResetCommand = {
+  handled: true;
+  reason: 'new' | 'reset';
+  text: string;
+};
+
 const BNCR_HELP_TEXT = [
   '🦞 Bncr command usage',
   '',
@@ -33,19 +46,22 @@ const BNCR_HELP_TEXT = [
   '  • /bncr verbose on|off|full',
   '',
   '🛡 Scene approval',
-  '  • /bncr allow [<platform>:<groupId>]',
-  '  • /bncr deny [<platform>:<groupId>]',
-  '  • /bncr bind <agentId> [<platform>:<groupId>]',
+  '  • /bncr allow [<SceneId>]',
+  '  • /bncr deny [<SceneId>]',
+  '  • /bncr bind <agentId> [<SceneId>]',
   '  • /bncr mode',
   '  • /bncr mode help',
-  '  • /bncr mode <admin|mention|hybrid|all> [<platform>:<groupId>]',
-  '  • /bncr revoke [<platform>:<groupId>]',
+  '  • /bncr mode <admin|mention|hybrid|all> [<SceneId>]',
+  '  • /bncr revoke [<SceneId>]',
   '  • /bncr list pending',
   '  • /bncr list scenes',
 ].join('\n');
 
 const BNCR_NATIVE_COMMANDS = new Set([
   'help',
+  'new',
+  'reset',
+  'status',
   'whoami',
   'verbose',
   'allow',
@@ -56,12 +72,33 @@ const BNCR_NATIVE_COMMANDS = new Set([
   'list',
 ]);
 
+export const BNCR_DIRECT_ALLOWED_BARE_COMMANDS = new Set(['whoami', 'status', 'new', 'reset']);
+
+export const BNCR_DIRECT_ALLOWED_SUBCOMMANDS = new Set([
+  'help',
+  'whoami',
+  'status',
+  'new',
+  'reset',
+]);
+
 export function parseBncrNativeCommand(
   text: string,
   options?: ParseBncrNativeCommandOptions,
 ): NativeCommand | null {
   const raw = String(text || '').trim();
   const allowBareWhoami = options?.allowBareWhoami !== false;
+  const allowBareStatus = options?.allowBareStatus === true;
+  const allowBareSessionReset = options?.allowBareSessionReset === true;
+  if (allowBareSessionReset && raw.toLowerCase() === '/new') {
+    return { command: 'new', raw, body: '/new', argsText: '' };
+  }
+  if (allowBareSessionReset && raw.toLowerCase() === '/reset') {
+    return { command: 'reset', raw, body: '/reset', argsText: '' };
+  }
+  if (allowBareStatus && raw.toLowerCase() === '/status') {
+    return { command: 'status', raw, body: '/status', argsText: '' };
+  }
   if (allowBareWhoami && raw.toLowerCase() === '/whoami') {
     return { command: 'whoami', raw, body: '/whoami', argsText: '' };
   }
@@ -81,6 +118,34 @@ export function parseBncrNativeCommand(
   return { command, raw, body, argsText };
 }
 
+export function parseBncrUnsupportedDirectCommand(text: string): {
+  command: string;
+  raw: string;
+} | null {
+  const raw = String(text || '').trim();
+  if (!raw.startsWith('/')) return null;
+
+  const bareMatch = raw.match(/^\/([A-Za-z0-9_]+)(?:@[A-Za-z0-9_]+)?(?:\s+.*)?$/);
+  if (!bareMatch) return null;
+  const bareCommand = String(bareMatch[1] || '')
+    .trim()
+    .toLowerCase();
+  if (!bareCommand) return null;
+
+  if (bareCommand === 'bncr') {
+    const subMatch = raw.match(/^\/bncr(?:@[A-Za-z0-9_]+)?(?:\s+([A-Za-z0-9_-]+))?/i);
+    const subCommand =
+      String(subMatch?.[1] || '')
+        .trim()
+        .toLowerCase() || 'help';
+    if (BNCR_DIRECT_ALLOWED_SUBCOMMANDS.has(subCommand)) return null;
+    return { command: `bncr ${subCommand}`, raw };
+  }
+
+  if (BNCR_DIRECT_ALLOWED_BARE_COMMANDS.has(bareCommand)) return null;
+  return { command: bareCommand, raw };
+}
+
 export function resolveBncrNativeHelpCommand(command: NativeCommand): NativeHelpCommand | null {
   if (command.command !== 'help') return null;
   return { handled: true, text: BNCR_HELP_TEXT };
@@ -110,6 +175,41 @@ export function resolveBncrNativeWhoamiCommand(args: {
   return { handled: true, text: lines.join('\n') };
 }
 
+export function resolveBncrNativeStatusCommand(args: {
+  command: NativeCommand;
+  accountId: string;
+  platform: string;
+  userId: string;
+  userName?: string;
+  resolvedAgentId: string;
+  sessionKey: string;
+}): NativeStatusCommand | null {
+  if (args.command.command !== 'status') return null;
+  const lines = ['🦞 Bncr Status', ''];
+  lines.push(`Channel: bncr`);
+  lines.push(`Account: ${args.accountId || 'Primary'}`);
+  lines.push(`User: ${args.userName || '(unknown)'} (${args.userId || '0'})`);
+  lines.push(`Scene: ${args.platform || '(unknown)'}:${args.userId || '0'}`);
+  lines.push(`Agent: ${args.resolvedAgentId || '(unknown)'}`);
+  lines.push(`SessionKey: ${args.sessionKey || '(unknown)'}`);
+  return { handled: true, text: lines.join('\n') };
+}
+
+export function resolveBncrNativeSessionResetCommand(args: {
+  command: NativeCommand;
+}): NativeSessionResetCommand | null {
+  if (args.command.command !== 'new' && args.command.command !== 'reset') return null;
+  const reason = args.command.command === 'new' ? 'new' : 'reset';
+  return {
+    handled: true,
+    reason,
+    text:
+      reason === 'new'
+        ? 'Started a new session for this private chat.'
+        : 'Reset the current session for this private chat.',
+  };
+}
+
 export function resolveBncrNativeVerboseCommand(
   command: NativeCommand,
 ): NativeVerboseCommand | null {

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

@@ -208,130 +208,143 @@ export async function runBncrInboundReplyDispatch(args: {
     return;
   }
 
-  await runBncrReplyDispatchSerial(
-    resolution.dispatchSessionKey,
-    async () =>
-      resolveBncrChannelInboundRuntime(api).run({
-        channel: channelId,
-        accountId: resolution.accountId,
-        raw: parsed,
-        adapter: {
-          ingest: () => ({
-            id: msgId ?? `${resolution.canonicalTo}:${Date.now()}`,
-            timestamp: Date.now(),
-            rawText: rawBody,
-            textForAgent: ctxPayload.BodyForAgent,
-            textForCommands: ctxPayload.CommandBody,
-            raw: parsed,
-          }),
-          preflight: () =>
-            shouldDispatch
-              ? undefined
-              : {
-                  admission: {
-                    kind: 'observeOnly' as const,
-                    reason: 'bncr-group-mode-no-reply',
-                  },
-                },
-          resolveTurn: () => {
-            const sessionMetaBarrier = createBncrSessionMetaTaskBarrier();
-            return {
-              channel: channelId,
-              accountId: resolution.accountId,
-              routeSessionKey: resolution.resolvedRoute.sessionKey,
-              storePath,
-              ctxPayload,
-              recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
-                recordInboundSession: recordBncrInboundSession as (
-                  ...args: unknown[]
-                ) => Promise<unknown> | unknown,
-                expectedPatch: sessionIdentityPatch,
-              }),
-              record: {
-                updateLastRoute,
-                onRecordError: (err: unknown) => {
-                  emitBncrLogLine('warn', `[bncr] inbound record session failed: ${String(err)}`);
-                },
-                trackSessionMetaTask: (task: Promise<unknown>) => {
-                  sessionMetaBarrier.track(task);
-                },
-              },
-              runDispatch: async () => {
-                await sessionMetaBarrier.wait();
-                await correctBncrInboundSessionLabel({
-                  storePath,
-                  sessionKey: resolution.dispatchSessionKey,
-                  expectedPatch: sessionIdentityPatch,
-                });
-                return Promise.resolve(
-                  dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
-                    ctx: ctxPayload,
-                    cfg: buildBncrReplyConfig(commandDispatchCfg).replyCfg,
-                    dispatcherOptions: {
-                      deliver: async (
-                        payload: {
-                          text?: string;
-                          mediaUrl?: string;
-                          mediaUrls?: string[];
-                          audioAsVoice?: boolean;
-                        },
-                        info?: { kind?: 'tool' | 'block' | 'final' },
-                      ) => {
-                        const kind = info?.kind;
-                        const shouldForwardTool =
-                          effectiveReply.blockStreaming && effectiveReply.allowTool;
-
-                        if (kind === 'tool' && !shouldForwardTool) {
-                          return;
-                        }
+  // Stop commands should bypass the serial chain so they can interrupt a running agent.
+  const rawTrimmed = (rawBody || '').trim();
+  const isStopCommand =
+    rawTrimmed === '/stop' || rawTrimmed.startsWith('/stop ') || rawTrimmed.startsWith('/stop@');
+  const dispatchSessionKey = resolution.dispatchSessionKey;
 
-                        await enqueueFromReply({
-                          accountId: replyRouteFact.accountId,
-                          sessionKey: replyRouteFact.sessionKey,
-                          route: replyRouteFact.route,
-                          payload: {
-                            text: payload.text,
-                            mediaUrl: payload.mediaUrl,
-                            mediaUrls: payload.mediaUrls,
-                            kind: kind || 'final',
-                            replyToId: msgId || undefined,
-                          },
-                        });
-                      },
-                      onError: (err: unknown) => {
-                        emitBncrLogLine('error', `[bncr] outbound reply failed: ${String(err)}`);
-                      },
-                    },
-                    replyOptions: {
-                      disableBlockStreaming: !effectiveReply.blockStreaming,
-                      shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+  const runStopOrSerial = () => {
+    const task = () =>
+      Promise.resolve(
+        resolveBncrChannelInboundRuntime(api).run({
+          channel: channelId,
+          accountId: resolution.accountId,
+          raw: parsed,
+          adapter: {
+            ingest: () => ({
+              id: msgId ?? `${resolution.canonicalTo}:${Date.now()}`,
+              timestamp: Date.now(),
+              rawText: rawBody,
+              textForAgent: ctxPayload.BodyForAgent,
+              textForCommands: ctxPayload.CommandBody,
+              raw: parsed,
+            }),
+            preflight: () =>
+              shouldDispatch
+                ? undefined
+                : {
+                    admission: {
+                      kind: 'observeOnly' as const,
+                      reason: 'bncr-group-mode-no-reply',
                     },
-                  }),
-                ).finally(async () => {
-                  await waitForBncrReplySessionQuiescence({
-                    api,
-                    storePath,
-                    sessionKey: resolution.dispatchSessionKey,
-                    msgId,
-                    to: resolution.canonicalTo,
-                    debugEnabled: cfg?.channels?.bncr?.debug?.verbose === true,
-                  });
+                  },
+            resolveTurn: () => {
+              const sessionMetaBarrier = createBncrSessionMetaTaskBarrier();
+              return {
+                channel: channelId,
+                accountId: resolution.accountId,
+                routeSessionKey: resolution.resolvedRoute.sessionKey,
+                storePath,
+                ctxPayload,
+                recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
+                  recordInboundSession: recordBncrInboundSession as (
+                    ...args: unknown[]
+                  ) => Promise<unknown> | unknown,
+                  expectedPatch: sessionIdentityPatch,
+                }),
+                record: {
+                  updateLastRoute,
+                  onRecordError: (err: unknown) => {
+                    emitBncrLogLine('warn', `[bncr] inbound record session failed: ${String(err)}`);
+                  },
+                  trackSessionMetaTask: (task: Promise<unknown>) => {
+                    sessionMetaBarrier.track(task);
+                  },
+                },
+                runDispatch: async () => {
+                  await sessionMetaBarrier.wait();
                   await correctBncrInboundSessionLabel({
                     storePath,
-                    sessionKey: resolution.dispatchSessionKey,
+                    sessionKey: dispatchSessionKey,
                     expectedPatch: sessionIdentityPatch,
                   });
-                });
-              },
-            };
-          },
-          onFinalize: () => {
-            const inboundAt = Date.now();
-            setInboundActivity(resolution.accountId, inboundAt);
-            scheduleSave();
+                  return Promise.resolve(
+                    dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
+                      ctx: ctxPayload,
+                      cfg: buildBncrReplyConfig(commandDispatchCfg).replyCfg,
+                      dispatcherOptions: {
+                        deliver: async (
+                          payload: {
+                            text?: string;
+                            mediaUrl?: string;
+                            mediaUrls?: string[];
+                            audioAsVoice?: boolean;
+                          },
+                          info?: { kind?: 'tool' | 'block' | 'final' },
+                        ) => {
+                          const kind = info?.kind;
+                          const shouldForwardTool =
+                            effectiveReply.blockStreaming && effectiveReply.allowTool;
+
+                          if (kind === 'tool' && !shouldForwardTool) {
+                            return;
+                          }
+
+                          await enqueueFromReply({
+                            accountId: replyRouteFact.accountId,
+                            sessionKey: replyRouteFact.sessionKey,
+                            route: replyRouteFact.route,
+                            payload: {
+                              text: payload.text,
+                              mediaUrl: payload.mediaUrl,
+                              mediaUrls: payload.mediaUrls,
+                              kind: kind || 'final',
+                              replyToId: msgId || undefined,
+                            },
+                          });
+                        },
+                        onError: (err: unknown) => {
+                          emitBncrLogLine('error', `[bncr] outbound reply failed: ${String(err)}`);
+                        },
+                      },
+                      replyOptions: {
+                        disableBlockStreaming: !effectiveReply.blockStreaming,
+                        shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+                      },
+                    }),
+                  );
+                },
+              };
+            },
+            onFinalize: () => {
+              const inboundAt = Date.now();
+              setInboundActivity(resolution.accountId, inboundAt);
+              scheduleSave();
+            },
           },
-        },
-      }),
-    { msgId, to: resolution.canonicalTo },
-  );
+        }),
+      ).finally(async () => {
+        await waitForBncrReplySessionQuiescence({
+          api,
+          storePath,
+          sessionKey: dispatchSessionKey,
+          msgId,
+          to: resolution.canonicalTo,
+          debugEnabled: cfg?.channels?.bncr?.debug?.verbose === true,
+        });
+        await correctBncrInboundSessionLabel({
+          storePath,
+          sessionKey: dispatchSessionKey,
+          expectedPatch: sessionIdentityPatch,
+        });
+      });
+
+    if (isStopCommand) {
+      return task();
+    }
+    return runBncrReplyDispatchSerial(dispatchSessionKey, task);
+  };
+
+  await runStopOrSerial();
 }

package/src/messaging/inbound/scene-admin.ts

@@ -146,15 +146,46 @@ export function parseSceneAdminCommand(command: NativeCommand): ParsedSceneAdmin
   }
 }
 
-function formatSceneLine(scene: BncrSceneRecord): string {
+function formatSceneDetailsLine(scene: BncrSceneRecord): string {
   const idPart =
     scene.kind === 'group' ? scene.groupId || scene.sceneKey : scene.userId || scene.sceneKey;
   const namePart = scene.kind === 'group' ? scene.groupName || '' : scene.userName || '';
-  const agentPart = scene.agentId ? ` agent=${scene.agentId}` : '';
-  const modePart =
-    scene.kind === 'group' && scene.groupReplyMode ? ` mode=${scene.groupReplyMode}` : '';
   const labelPart = namePart ? ` name=${namePart}` : '';
-  return `${scene.sceneKey} status=${scene.status} kind=${scene.kind} id=${idPart}${labelPart}${agentPart}${modePart}`;
+  return `  Details: status=${scene.status} id=${idPart}${labelPart}`;
+}
+
+function formatSceneEntry(scene: BncrSceneRecord): string {
+  return [`  SceneId: ${scene.sceneKey}`, formatSceneDetailsLine(scene)].join('\n');
+}
+
+function buildSceneGroupTitle(scene: BncrSceneRecord): string {
+  const agentId = normalizeToken(scene.agentId || '') || 'public';
+  if (scene.kind === 'group') {
+    const mode = normalizeToken(scene.groupReplyMode || '') || 'admin';
+    return `👥 Group Chat ${agentId} ${mode}`;
+  }
+  return `📱 Private Chat ${agentId}`;
+}
+
+function formatSceneGroups(scenes: BncrSceneRecord[]): string {
+  const directGrouped = new Map<string, string[]>();
+  const groupGrouped = new Map<string, string[]>();
+  for (const scene of scenes) {
+    const title = buildSceneGroupTitle(scene);
+    const target = scene.kind === 'group' ? groupGrouped : directGrouped;
+    const current = target.get(title) || [];
+    current.push(formatSceneEntry(scene));
+    target.set(title, current);
+  }
+
+  const orderedGroups = [
+    ...Array.from(directGrouped.entries()),
+    ...Array.from(groupGrouped.entries()).sort(([left], [right]) => left.localeCompare(right)),
+  ];
+
+  return orderedGroups
+    .map(([title, entries]) => [title, '', entries.join('\n\n')].join('\n'))
+    .join('\n\n');
 }
 
 function applySceneStatus(scene: BncrSceneRecord, status: BncrSceneStatus): BncrSceneRecord {
@@ -188,7 +219,7 @@ export function executeSceneAdminCommand(args: {
         text: command.scope === 'pending' ? 'No pending scenes.' : 'No scenes recorded.',
       };
     }
-    return { ok: true, text: scenes.map(formatSceneLine).join('\n') };
+    return { ok: true, text: formatSceneGroups(scenes) };
   }
 
   if (command.kind === 'mode-help') {

package/src/plugin/channel-components.ts

@@ -266,6 +266,7 @@ export function createBncrInboundHandlersComponent(runtime: {
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     formatDisplayScope,
     logInboundSummary: runtime.logInboundSummary,
+    enqueueFromReply: runtime.enqueueFromReply,
     flushOnInboundAccepted: (accountId) =>
       runtime.flushPushQueueBestEffort({
         accountId,

package/src/plugin/inbound-handlers.ts

@@ -1,7 +1,9 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import { buildCanonicalBncrSessionKey } from '../core/targets.ts';
 import type { BncrConnection, BncrRoute } from '../core/types.ts';
 import type { BncrGroupHistoryMap } from '../messaging/inbound/group-history.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
+import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
 import type {
   buildInboundResponsePayload,
   resolveInboundSessionContext,
@@ -50,6 +52,26 @@ type InboundAcceptanceResult =
       payload: Record<string, unknown>;
     };
 
+function buildBncrPendingDirectApprovalNotice(args: {
+  parsed: ParsedInboundParams;
+  reason: string;
+}): string | null {
+  if (args.parsed.peer.kind !== 'direct') return null;
+  if (args.reason !== 'scene pending approval') return null;
+  return `This private chat is pending approval. Ask the administrator to allow your SceneId: ${args.parsed.platform}:${args.parsed.userId}`;
+}
+
+function buildBncrPendingDirectApprovalPayload(args: {
+  msgId?: string;
+  text: string;
+}): ReplyPayloadInput {
+  return {
+    text: args.text,
+    kind: 'final',
+    ...(args.msgId ? { replyToId: args.msgId } : {}),
+  };
+}
+
 export type BncrInboundHandlersRuntime = {
   channelId: string;
   bridgeId: string;
@@ -123,6 +145,13 @@ export type BncrInboundHandlersRuntime = {
     text: string;
     hasMedia: boolean;
   }) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    payload: ReplyPayloadInput;
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<void>;
   respond: GatewayRequestHandlerOptions['respond'];
   flushOnInboundAccepted: (accountId: string) => void;
   dispatchInbound: (args: {
@@ -227,6 +256,19 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
           'inbound',
           `accept reject|accountId=${accountId}|msgId=${msgId ?? '-'}|scope=${runtime.formatDisplayScope(route)}|chatType=${peer.kind}|msgType=${msgType}|status=${acceptance.status}|reason=${reason || '-'}|isAdmin=${parsed.isAdmin === true}|shouldRespond=${parsed.shouldRespond === true}`,
         );
+        const pendingNotice = buildBncrPendingDirectApprovalNotice({ parsed, reason });
+        if (pendingNotice) {
+          const sessionKey = buildCanonicalBncrSessionKey(route, canonicalAgentId);
+          await runtime.enqueueFromReply({
+            accountId,
+            sessionKey,
+            route,
+            payload: buildBncrPendingDirectApprovalPayload({
+              msgId: msgId ?? undefined,
+              text: pendingNotice,
+            }),
+          });
+        }
         respond(acceptance.status, acceptance.payload);
         return;
       }

package/src/plugin/scene-registry.ts

@@ -71,14 +71,20 @@ export function decideSceneAdmission(args: {
   const sceneKey = buildSceneKey(parsed);
   const kind = asSceneKind(parsed);
   const existing = sceneRegistry.get(sceneKey);
+  const shouldForceDirectNonAdminPublic = (agentId?: string) =>
+    kind === 'direct' && parsed.isAdmin !== true && (!agentId || agentId === defaultAdminAgentId);
 
   if (existing) {
+    const forcedAgentId = shouldForceDirectNonAdminPublic(existing.agentId)
+      ? defaultPublicAgentId
+      : existing.agentId;
     const nextScene = {
       ...existing,
       ...(parsed.userId ? { userId: parsed.userId } : {}),
       ...(parsed.userName ? { userName: parsed.userName } : {}),
       ...(kind === 'group' && parsed.groupId ? { groupId: parsed.groupId } : {}),
       ...(kind === 'group' && parsed.groupName ? { groupName: parsed.groupName } : {}),
+      ...(forcedAgentId ? { agentId: forcedAgentId } : {}),
       ...(kind === 'group' && !existing.groupReplyMode
         ? { groupReplyMode: defaultGroupReplyMode(kind) }
         : {}),
@@ -137,19 +143,29 @@ export function decideSceneAdmission(args: {
     return { allowed: true, scene, agentId };
   }
 
+  const directNonAdminAllowed = kind === 'direct';
   const scene = buildSceneRecord({
     parsed,
     sceneKey,
     kind,
-    status: kind === 'direct' ? 'pending' : 'denied',
+    status: directNonAdminAllowed ? 'allowed' : 'denied',
+    agentId: directNonAdminAllowed ? defaultPublicAgentId : undefined,
     lastSeenAt: now,
   });
   sceneRegistry.set(sceneKey, scene);
 
+  if (directNonAdminAllowed) {
+    return {
+      allowed: true,
+      scene,
+      agentId: scene.agentId || defaultPublicAgentId,
+    };
+  }
+
   return {
     allowed: false,
     scene,
-    reason: kind === 'direct' ? 'scene pending approval' : 'scene denied',
-    replyPolicy: kind === 'direct' ? 'pending' : 'silent',
+    reason: 'scene denied',
+    replyPolicy: 'silent',
   };
 }