@xmoxmo/bncr 0.4.7 → 0.4.8

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.8",
   "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/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',
   };
 }