@xmoxmo/bncr 0.4.6 → 0.4.7

package/src/plugin/inbound-acceptance.ts

@@ -1,13 +1,66 @@
+import { hasControlCommand } from 'openclaw/plugin-sdk/command-auth';
 import { resolveAccount } from '../core/accounts.ts';
 import { checkBncrMessageGate } from '../messaging/inbound/gate.ts';
+import { parseBncrNativeCommand } from '../messaging/inbound/native-command.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import type { OpenClawResolvedAgentRoute } from '../openclaw/routing-runtime.ts';
 import type { buildInboundResponsePayload } from './channel-inbound-helpers.ts';
 import { resolveInboundSessionContext } from './channel-inbound-helpers.ts';
-import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+import type { BncrChannelConfigRoot, BncrSceneRecord } from './channel-runtime-types.ts';
+import { decideSceneAdmission } from './scene-registry.ts';
 
 type InboundAcceptanceResponsePayload = ReturnType<typeof buildInboundResponsePayload>;
 
+function shouldDispatchForScene(args: {
+  parsed: ReturnType<typeof parseBncrInboundParams>;
+  admission: ReturnType<typeof decideSceneAdmission>;
+  cfg: BncrChannelConfigRoot;
+}) {
+  const { parsed, admission, cfg } = args;
+  if (parsed.peer.kind === 'direct') return true;
+  if (!admission.allowed) return false;
+
+  const isBncrNativeCommand =
+    parseBncrNativeCommand(parsed.extracted.text, {
+      allowBareWhoami: parsed.isAdmin !== true,
+    }) !== null;
+  const isAdminOpenClawNativeCommand =
+    parsed.isAdmin === true &&
+    !isBncrNativeCommand &&
+    hasControlCommand(parsed.extracted.text, cfg as Parameters<typeof hasControlCommand>[1]);
+  if (isAdminOpenClawNativeCommand) return true;
+
+  const mode = admission.scene.groupReplyMode || 'admin';
+  if (mode === 'all') return true;
+  if (mode === 'admin') return parsed.isAdmin === true;
+  if (mode === 'mention') return parsed.shouldRespond === true;
+  return parsed.isAdmin === true || parsed.shouldRespond === true;
+}
+
+function shouldAccumulateForScene(args: {
+  parsed: ReturnType<typeof parseBncrInboundParams>;
+  admission: ReturnType<typeof decideSceneAdmission>;
+  cfg: BncrChannelConfigRoot;
+}) {
+  const { parsed, admission, cfg } = args;
+  if (parsed.peer.kind === 'direct') return true;
+  if (!admission.allowed) return false;
+
+  const isBncrNativeCommand =
+    parseBncrNativeCommand(parsed.extracted.text, {
+      allowBareWhoami: parsed.isAdmin !== true,
+    }) !== null;
+  const isAdminOpenClawNativeCommand =
+    parsed.isAdmin === true &&
+    !isBncrNativeCommand &&
+    hasControlCommand(parsed.extracted.text, cfg as Parameters<typeof hasControlCommand>[1]);
+  if (isAdminOpenClawNativeCommand) return true;
+
+  const mode = admission.scene.groupReplyMode || 'admin';
+  if (mode === 'admin') return parsed.isAdmin === true;
+  return true;
+}
+
 export async function prepareBncrInboundAcceptance(args: {
   api: unknown;
   parsed: ReturnType<typeof parseBncrInboundParams>;
@@ -27,6 +80,10 @@ export async function prepareBncrInboundAcceptance(args: {
       | { kind: 'gate-denied'; accountId: string; msgId?: string | null; reason: string },
   ) => InboundAcceptanceResponsePayload;
   markInboundDedupSeen: (key: string) => boolean;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  now: () => number;
+  defaultAdminAgentId: string;
+  defaultPublicAgentId: string;
 }) {
   const { parsed, canonicalAgentId } = args;
   const {
@@ -83,6 +140,26 @@ export async function prepareBncrInboundAcceptance(args: {
     };
   }
 
+  const admission = decideSceneAdmission({
+    parsed,
+    now: args.now(),
+    sceneRegistry: args.sceneRegistry,
+    defaultAdminAgentId: args.defaultAdminAgentId,
+    defaultPublicAgentId: args.defaultPublicAgentId,
+  });
+  if (!admission.allowed) {
+    return {
+      ok: false as const,
+      status: admission.replyPolicy === 'pending',
+      payload: args.buildInboundResponsePayload({
+        kind: 'gate-denied',
+        accountId,
+        msgId: msgId ?? null,
+        reason: admission.reason,
+      }),
+    };
+  }
+
   const { sessionKey, inboundText } = resolveInboundSessionContext({
     cfg,
     accountId,
@@ -90,6 +167,7 @@ export async function prepareBncrInboundAcceptance(args: {
     route,
     sessionKeyFromRoute: sessionKeyfromroute,
     canonicalAgentId,
+    resolvedAgentId: admission.agentId,
     taskKey: extracted.taskKey ?? undefined,
     text,
     extractedText: extracted.text,
@@ -103,5 +181,8 @@ export async function prepareBncrInboundAcceptance(args: {
     sessionKey,
     inboundText,
     hasMedia: Boolean(mediaBase64 || mediaPathFromTransfer),
+    resolvedAgentId: admission.agentId,
+    shouldDispatch: shouldDispatchForScene({ parsed, admission, cfg }),
+    shouldAccumulate: shouldAccumulateForScene({ parsed, admission, cfg }),
   };
 }

package/src/plugin/inbound-handlers.ts

@@ -1,11 +1,12 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
 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 {
   buildInboundResponsePayload,
   resolveInboundSessionContext,
 } from './channel-inbound-helpers.ts';
-import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+import type { BncrChannelConfigRoot, BncrSceneRecord } from './channel-runtime-types.ts';
 import { buildBncrGatewayEventContext } from './gateway-event-context.ts';
 
 type InboundLifecycleStage = 'accepted';
@@ -39,6 +40,9 @@ type InboundAcceptanceResult =
       sessionKey: string;
       inboundText: string;
       hasMedia: boolean;
+      resolvedAgentId: string;
+      shouldDispatch: boolean;
+      shouldAccumulate: boolean;
     }
   | {
       ok: false;
@@ -98,6 +102,15 @@ export type BncrInboundHandlersRuntime = {
     peer: EnsureCanonicalAgentIdPeer;
     channelId: string;
   }) => string;
+  defaultAdminAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    peer: EnsureCanonicalAgentIdPeer;
+    channelId: string;
+  }) => string;
+  defaultPublicAgentId: () => string;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: BncrGroupHistoryMap;
   prepareInboundAcceptance: (args: {
     parsed: ParsedInboundParams;
     canonicalAgentId: string;
@@ -116,6 +129,14 @@ export type BncrInboundHandlersRuntime = {
     cfg: BncrChannelConfigRoot;
     parsed: ParsedInboundParams;
     canonicalAgentId: string;
+    resolvedAgentId: string;
+    shouldDispatch: boolean;
+    shouldAccumulate: boolean;
+    sceneRegistry: Map<string, BncrSceneRecord>;
+    groupHistories: BncrGroupHistoryMap;
+    defaultAdminAgentId: string;
+    defaultPublicAgentId: string;
+    now: () => number;
   }) => Promise<unknown>;
 };
 
@@ -191,13 +212,37 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
         peer,
         channelId: runtime.channelId,
       });
+      const defaultAdminAgentId = runtime.defaultAdminAgentId({
+        cfg,
+        accountId,
+        peer,
+        channelId: runtime.channelId,
+      });
       const acceptance = await runtime.prepareInboundAcceptance({ parsed, canonicalAgentId });
       if (!acceptance.ok) {
+        const reason = runtime
+          .asString((acceptance.payload as { reason?: unknown })?.reason || '')
+          .trim();
+        runtime.logInfo(
+          '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}`,
+        );
         respond(acceptance.status, acceptance.payload);
         return;
       }
 
-      const { sessionKey, inboundText, hasMedia } = acceptance;
+      const {
+        sessionKey,
+        inboundText,
+        hasMedia,
+        resolvedAgentId,
+        shouldDispatch,
+        shouldAccumulate,
+      } = acceptance;
+      runtime.logInfo(
+        'inbound',
+        `accept ok|accountId=${accountId}|msgId=${msgId ?? '-'}|scope=${runtime.formatDisplayScope(route)}|chatType=${peer.kind}|msgType=${msgType}|sessionKey=${sessionKey}|agent=${resolvedAgentId}|dispatch=${shouldDispatch}|accumulate=${shouldAccumulate}|isAdmin=${parsed.isAdmin === true}|shouldRespond=${parsed.shouldRespond === true}`,
+      );
       runtime.logInfo(
         'inbound',
         JSON.stringify({
@@ -239,6 +284,14 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
           cfg,
           parsed,
           canonicalAgentId,
+          resolvedAgentId,
+          shouldDispatch,
+          shouldAccumulate,
+          sceneRegistry: runtime.sceneRegistry,
+          groupHistories: runtime.groupHistories,
+          defaultAdminAgentId,
+          defaultPublicAgentId: runtime.defaultPublicAgentId(),
+          now: runtime.now,
         })
         .catch((err) => {
           runtime.logError('inbound', `process failed: ${String(err)}`, { debugOnly: true });

package/src/plugin/inbound-surface-handlers-group.ts

@@ -53,6 +53,9 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     clientId?: string;
     context: GatewayRequestHandlerOptions['context'];
   }) => void;
+  buildCanonicalSessionKey: Parameters<
+    typeof createBncrFileInboundHandlersComponent
+  >[0]['buildCanonicalSessionKey'];
   refreshLiveConnectionState: (args: {
     accountId: string;
     connId: string;
@@ -75,6 +78,14 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
   ensureCanonicalAgentId: Parameters<
     typeof createBncrInboundHandlersComponent
   >[0]['ensureCanonicalAgentId'];
+  defaultAdminAgentId: Parameters<
+    typeof createBncrInboundHandlersComponent
+  >[0]['defaultAdminAgentId'];
+  defaultPublicAgentId: Parameters<
+    typeof createBncrInboundHandlersComponent
+  >[0]['defaultPublicAgentId'];
+  sceneRegistry: Parameters<typeof createBncrInboundHandlersComponent>[0]['sceneRegistry'];
+  groupHistories: Parameters<typeof createBncrInboundHandlersComponent>[0]['groupHistories'];
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlersComponent
   >[0]['prepareInboundAcceptance'];
@@ -111,6 +122,7 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     matchesTransferOwner: runtime.matchesTransferOwner,
     refreshAcceptedFileTransferLiveState: runtime.refreshAcceptedFileTransferLiveState,
     logWarn: runtime.logWarn,
+    buildCanonicalSessionKey: runtime.buildCanonicalSessionKey,
     fileRecvTransfers: runtime.fileRecvTransfers,
     inboundFileTransferMaxBytes: runtime.inboundFileTransferMaxBytes,
     inboundFileTransferMaxChunks: runtime.inboundFileTransferMaxChunks,
@@ -136,6 +148,10 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     buildActiveConnectionDebugList: runtime.buildActiveConnectionDebugList,
     markLastInboundAt: runtime.markLastInboundAt,
     ensureCanonicalAgentId: runtime.ensureCanonicalAgentId,
+    defaultAdminAgentId: runtime.defaultAdminAgentId,
+    defaultPublicAgentId: runtime.defaultPublicAgentId,
+    sceneRegistry: runtime.sceneRegistry,
+    groupHistories: runtime.groupHistories,
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     logInboundSummary: runtime.logInboundSummary,
     flushPushQueueBestEffort: runtime.flushPushQueueBestEffort,

package/src/plugin/messaging.ts

@@ -10,6 +10,15 @@ import {
 } from '../messaging/outbound/target-resolver.ts';
 import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
 
+function formatBncrHumanDisplay(route: BncrRoute): string {
+  const platform = asSanitizedString(route?.platform).trim();
+  const groupId = asSanitizedString(route?.groupId).trim();
+  const userId = asSanitizedString(route?.userId).trim();
+  if (platform && groupId && groupId !== '0') return `Bncr:${platform}:Group:${groupId}`;
+  if (platform && userId && userId !== '0') return `Bncr:${platform}:User:${userId}`;
+  return formatDisplayScope(route);
+}
+
 type BncrMessagingRuntimeBridge = {
   canonicalAgentId?: string;
   ensureCanonicalAgentId: (params: { cfg: BncrChannelConfigRoot; accountId: string }) => string;
@@ -69,16 +78,24 @@ export function normalizeBncrMessagingTarget(raw: string) {
 }
 
 export function formatBncrMessagingTargetDisplay({ target }: BncrMessagingTargetDisplayInput) {
-  if (typeof target === 'string') return asSanitizedString(target).trim();
+  if (typeof target === 'string') {
+    const parsed = parseExplicitTarget(asSanitizedString(target).trim());
+    return parsed?.route ? formatBncrHumanDisplay(parsed.route) : asSanitizedString(target).trim();
+  }
   if (!isDisplayTarget(target)) return '';
   const displayScope = asSanitizedString(target?.displayScope || target?.to).trim();
-  if (displayScope) return displayScope;
+  if (displayScope) {
+    const parsed = parseExplicitTarget(displayScope);
+    if (parsed?.route) return formatBncrHumanDisplay(parsed.route);
+    return displayScope;
+  }
   if (target.platform || target.groupId || target.userId) {
-    return formatDisplayScope({
+    const route = {
       platform: asSanitizedString(target.platform).trim(),
       groupId: asSanitizedString(target.groupId).trim(),
       userId: asSanitizedString(target.userId).trim(),
-    });
+    };
+    return formatBncrHumanDisplay(route);
   }
   return '';
 }
@@ -188,7 +205,7 @@ export function createBncrMessagingTargetResolver(getBridge: () => BncrMessaging
       return {
         to: resolved.displayScope,
         kind: resolved.kind,
-        display: resolved.displayScope,
+        display: formatBncrHumanDisplay(resolved.route),
         source: 'normalized' as const,
       };
     },

package/src/plugin/scene-registry.ts

@@ -0,0 +1,155 @@
+import type {
+  BncrGroupReplyMode,
+  BncrSceneKind,
+  BncrSceneRecord,
+  BncrSceneStatus,
+} from './channel-runtime-types.ts';
+
+type ParsedInbound = ReturnType<
+  typeof import('../messaging/inbound/parse.ts')['parseBncrInboundParams']
+>;
+
+export type BncrSceneRegistryDecision =
+  | {
+      allowed: true;
+      scene: BncrSceneRecord;
+      agentId: string;
+    }
+  | {
+      allowed: false;
+      scene: BncrSceneRecord;
+      reason: string;
+      replyPolicy: 'silent' | 'pending';
+    };
+
+function asSceneKind(parsed: ParsedInbound): BncrSceneKind {
+  return parsed.peer.kind === 'group' ? 'group' : 'direct';
+}
+
+function defaultGroupReplyMode(kind: BncrSceneKind): BncrGroupReplyMode | undefined {
+  return kind === 'group' ? 'admin' : undefined;
+}
+
+export function buildSceneKey(parsed: ParsedInbound): string {
+  return parsed.peer.kind === 'group'
+    ? `${parsed.platform}:${parsed.groupId}`
+    : `${parsed.platform}:${parsed.userId}`;
+}
+
+export function buildSceneRecord(args: {
+  parsed: ParsedInbound;
+  sceneKey: string;
+  kind: BncrSceneKind;
+  status: BncrSceneStatus;
+  agentId?: string;
+  lastSeenAt: number;
+}): BncrSceneRecord {
+  const { parsed, sceneKey, kind, status, agentId, lastSeenAt } = args;
+  return {
+    sceneKey,
+    kind,
+    status,
+    platform: parsed.platform,
+    ...(parsed.userId ? { userId: parsed.userId } : {}),
+    ...(parsed.userName ? { userName: parsed.userName } : {}),
+    ...(kind === 'group' && parsed.groupId ? { groupId: parsed.groupId } : {}),
+    ...(kind === 'group' && parsed.groupName ? { groupName: parsed.groupName } : {}),
+    ...(agentId ? { agentId } : {}),
+    ...(kind === 'group' ? { groupReplyMode: defaultGroupReplyMode(kind) } : {}),
+    lastSeenAt,
+  };
+}
+
+export function decideSceneAdmission(args: {
+  parsed: ParsedInbound;
+  now: number;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  defaultAdminAgentId: string;
+  defaultPublicAgentId: string;
+}): BncrSceneRegistryDecision {
+  const { parsed, now, sceneRegistry, defaultAdminAgentId, defaultPublicAgentId } = args;
+  const sceneKey = buildSceneKey(parsed);
+  const kind = asSceneKind(parsed);
+  const existing = sceneRegistry.get(sceneKey);
+
+  if (existing) {
+    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 } : {}),
+      ...(kind === 'group' && !existing.groupReplyMode
+        ? { groupReplyMode: defaultGroupReplyMode(kind) }
+        : {}),
+      lastSeenAt: now,
+    } satisfies BncrSceneRecord;
+
+    if (kind === 'group' && nextScene.status === 'denied' && parsed.isAdmin) {
+      const allowedScene = {
+        ...nextScene,
+        status: 'allowed',
+      } satisfies BncrSceneRecord;
+      sceneRegistry.set(sceneKey, allowedScene);
+      return {
+        allowed: true,
+        scene: allowedScene,
+        agentId: allowedScene.agentId || defaultPublicAgentId,
+      };
+    }
+
+    sceneRegistry.set(sceneKey, nextScene);
+
+    if (nextScene.status === 'allowed') {
+      const fallbackAgentId =
+        kind === 'group'
+          ? defaultPublicAgentId
+          : parsed.isAdmin
+            ? defaultAdminAgentId
+            : defaultPublicAgentId;
+      return {
+        allowed: true,
+        scene: nextScene,
+        agentId: nextScene.agentId || fallbackAgentId,
+      };
+    }
+
+    return {
+      allowed: false,
+      scene: nextScene,
+      reason: nextScene.status === 'pending' ? 'scene pending approval' : 'scene denied',
+      replyPolicy:
+        kind === 'group' ? 'silent' : nextScene.status === 'pending' ? 'pending' : 'silent',
+    };
+  }
+
+  if (parsed.isAdmin) {
+    const agentId = kind === 'group' ? defaultPublicAgentId : defaultAdminAgentId;
+    const scene = buildSceneRecord({
+      parsed,
+      sceneKey,
+      kind,
+      status: 'allowed',
+      agentId,
+      lastSeenAt: now,
+    });
+    sceneRegistry.set(sceneKey, scene);
+    return { allowed: true, scene, agentId };
+  }
+
+  const scene = buildSceneRecord({
+    parsed,
+    sceneKey,
+    kind,
+    status: kind === 'direct' ? 'pending' : 'denied',
+    lastSeenAt: now,
+  });
+  sceneRegistry.set(sceneKey, scene);
+
+  return {
+    allowed: false,
+    scene,
+    reason: kind === 'direct' ? 'scene pending approval' : 'scene denied',
+    replyPolicy: kind === 'direct' ? 'pending' : 'silent',
+  };
+}

package/src/plugin/state-store.ts

@@ -8,16 +8,25 @@ import {
   writeOpenClawJsonFileAtomically,
 } from '../openclaw/sdk-helpers.ts';
 import type {
+  BncrGroupReplyMode,
   BncrPersistedAccountTimestamp,
+  BncrPersistedGroupHistoryBucket,
+  BncrPersistedGroupHistoryEntry,
+  BncrPersistedGroupHistoryMediaEntry,
   BncrPersistedLastSession,
   BncrPersistedSessionRoute,
   PersistedState as BncrPersistedState,
+  BncrSceneRecord,
 } from './channel-runtime-types.ts';
 
+const GROUP_REPLY_MODES = new Set<BncrGroupReplyMode>(['admin', 'mention', 'hybrid', 'all']);
+
 type BncrPersistedStateStoreInput = {
   outbox?: unknown;
   deadLetter?: unknown;
   sessionRoutes?: unknown;
+  sceneRegistry?: unknown;
+  groupHistories?: unknown;
   lastSessionByAccount?: unknown;
   lastActivityByAccount?: unknown;
   lastInboundByAccount?: unknown;
@@ -28,6 +37,9 @@ type BncrPersistedStateStoreInput = {
 type PersistedAccountTimestampInput = Partial<BncrPersistedAccountTimestamp>;
 type PersistedLastSessionInput = Partial<BncrPersistedLastSession>;
 type PersistedSessionRouteInput = Partial<BncrPersistedSessionRoute>;
+type PersistedSceneRecordInput = Partial<BncrSceneRecord>;
+type PersistedGroupHistoryBucketInput = Partial<BncrPersistedGroupHistoryBucket>;
+type PersistedGroupHistoryEntryInput = Partial<BncrPersistedGroupHistoryEntry>;
 
 export function createBncrStateStore(runtime: {
   getStatePath: () => string | null;
@@ -50,6 +62,8 @@ export function createBncrStateStore(runtime: {
   maxDeadLetterEntries: number;
   maxSessionRouteEntries: number;
   maxAccountActivityEntries: number;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: Map<string, BncrPersistedGroupHistoryEntry[]>;
   outbox: Map<string, OutboxEntry>;
   getDeadLetter: () => OutboxEntry[];
   setDeadLetter: (entries: OutboxEntry[]) => void;
@@ -62,6 +76,117 @@ export function createBncrStateStore(runtime: {
   getLastDriftSnapshot: () => BncrPersistedState['lastDriftSnapshot'];
   setLastDriftSnapshot: (value: BncrPersistedState['lastDriftSnapshot']) => void;
 }) {
+  function loadPersistedSceneRegistry(persisted: unknown): void {
+    runtime.sceneRegistry.clear();
+    const items = Array.isArray(persisted) ? (persisted as PersistedSceneRecordInput[]) : [];
+    for (const item of items) {
+      if (!item || typeof item !== 'object') continue;
+      const sceneKey = runtime.asString(item.sceneKey || '').trim();
+      const kind = runtime.asString(item.kind || '').trim();
+      const status = runtime.asString(item.status || '').trim();
+      const platform = runtime.asString(item.platform || '').trim();
+      const lastSeenAt = runtime.finiteNumberOr(item.lastSeenAt, 0);
+      if (!sceneKey || !platform || lastSeenAt <= 0) continue;
+      if (kind !== 'direct' && kind !== 'group') continue;
+      if (status !== 'pending' && status !== 'allowed' && status !== 'denied') continue;
+
+      runtime.sceneRegistry.set(sceneKey, {
+        sceneKey,
+        kind,
+        status,
+        platform,
+        ...(runtime.asString(item.userId || '').trim()
+          ? { userId: runtime.asString(item.userId || '').trim() }
+          : {}),
+        ...(runtime.asString(item.userName || '').trim()
+          ? { userName: runtime.asString(item.userName || '').trim() }
+          : {}),
+        ...(runtime.asString(item.groupId || '').trim()
+          ? { groupId: runtime.asString(item.groupId || '').trim() }
+          : {}),
+        ...(runtime.asString(item.groupName || '').trim()
+          ? { groupName: runtime.asString(item.groupName || '').trim() }
+          : {}),
+        ...(runtime.asString(item.agentId || '').trim()
+          ? { agentId: runtime.asString(item.agentId || '').trim() }
+          : {}),
+        ...(kind === 'group' &&
+        GROUP_REPLY_MODES.has(
+          runtime.asString(item.groupReplyMode || '').trim() as BncrGroupReplyMode,
+        )
+          ? {
+              groupReplyMode: runtime
+                .asString(item.groupReplyMode || '')
+                .trim() as BncrGroupReplyMode,
+            }
+          : {}),
+        lastSeenAt,
+      });
+    }
+  }
+
+  function dumpPersistedSceneRegistry() {
+    return Array.from(runtime.sceneRegistry.values()).sort((a, b) => a.lastSeenAt - b.lastSeenAt);
+  }
+
+  function loadPersistedGroupHistories(persisted: unknown): void {
+    runtime.groupHistories.clear();
+    const buckets = Array.isArray(persisted)
+      ? (persisted as PersistedGroupHistoryBucketInput[])
+      : [];
+    for (const bucket of buckets) {
+      const key = runtime.asString(bucket?.key || '').trim();
+      if (!key) continue;
+      const entries: BncrPersistedGroupHistoryEntry[] = [];
+      const rawEntries = Array.isArray(bucket?.entries)
+        ? (bucket.entries as PersistedGroupHistoryEntryInput[])
+        : [];
+      for (const entry of rawEntries) {
+        const sender = runtime.asString(entry?.sender || '').trim();
+        const body = runtime.asString(entry?.body || '').trim();
+        if (!sender || !body) continue;
+        const timestamp = runtime.finiteNumberOr(entry?.timestamp, 0);
+        const messageId = runtime.asString(entry?.messageId || '').trim();
+
+        const media: BncrPersistedGroupHistoryMediaEntry[] = [];
+        const rawMedia = Array.isArray(entry?.media)
+          ? (entry.media as Partial<BncrPersistedGroupHistoryMediaEntry>[])
+          : [];
+        for (const item of rawMedia) {
+          const path = runtime.asString(item?.path || '').trim();
+          if (!path) continue;
+          const contentType = runtime.asString(item?.contentType || '').trim();
+          const kind = runtime.asString(item?.kind || '').trim();
+          const mediaMessageId = runtime.asString(item?.messageId || '').trim();
+          const normalizedMedia: BncrPersistedGroupHistoryMediaEntry = {
+            path,
+            ...(contentType ? { contentType } : {}),
+            ...(kind ? { kind: kind as BncrPersistedGroupHistoryMediaEntry['kind'] } : {}),
+            ...(mediaMessageId ? { messageId: mediaMessageId } : {}),
+          };
+          media.push(normalizedMedia);
+        }
+
+        const normalizedEntry: BncrPersistedGroupHistoryEntry = {
+          sender,
+          body,
+          ...(timestamp > 0 ? { timestamp } : {}),
+          ...(messageId ? { messageId } : {}),
+          ...(media.length > 0 ? { media } : {}),
+        };
+        entries.push(normalizedEntry);
+      }
+      if (entries.length > 0) runtime.groupHistories.set(key, entries.slice(-50));
+    }
+  }
+
+  function dumpPersistedGroupHistories() {
+    return Array.from(runtime.groupHistories.entries()).map(([key, entries]) => ({
+      key,
+      entries: entries.slice(-50),
+    }));
+  }
+
   function loadPersistedAccountTimestampMap(target: Map<string, number>, persisted: unknown): void {
     target.clear();
     const items = Array.isArray(persisted)
@@ -208,6 +333,8 @@ export function createBncrStateStore(runtime: {
     runtime.setDeadLetter(deadLetter);
 
     loadPersistedSessionRoutes(data.sessionRoutes);
+    loadPersistedSceneRegistry(data.sceneRegistry);
+    loadPersistedGroupHistories(data.groupHistories);
     loadPersistedLastSessionMap(data.lastSessionByAccount);
     loadPersistedAccountTimestampMap(runtime.lastActivityByAccount, data.lastActivityByAccount);
     loadPersistedAccountTimestampMap(runtime.lastInboundByAccount, data.lastInboundByAccount);
@@ -225,6 +352,8 @@ export function createBncrStateStore(runtime: {
       outbox: Array.from(runtime.outbox.values()),
       deadLetter: runtime.getDeadLetter().slice(-runtime.maxDeadLetterEntries),
       sessionRoutes: dumpPersistedSessionRoutes(),
+      sceneRegistry: dumpPersistedSceneRegistry(),
+      groupHistories: dumpPersistedGroupHistories(),
       lastSessionByAccount: dumpPersistedLastSessionMap(),
       lastActivityByAccount: dumpPersistedAccountTimestampMap(runtime.lastActivityByAccount),
       lastInboundByAccount: dumpPersistedAccountTimestampMap(runtime.lastInboundByAccount),
@@ -242,6 +371,10 @@ export function createBncrStateStore(runtime: {
     dumpPersistedLastSessionMap,
     loadPersistedSessionRoutes,
     dumpPersistedSessionRoutes,
+    loadPersistedSceneRegistry,
+    dumpPersistedSceneRegistry,
+    loadPersistedGroupHistories,
+    dumpPersistedGroupHistories,
     backfillAccountActivityFromSessionRoutes,
     loadState,
     flushState,