@xmoxmo/bncr 0.5.1 → 0.5.2

package/package.json

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

package/scripts/check-pack.mjs

@@ -193,7 +193,10 @@ const output = execFileSync('npm', ['pack', '--dry-run', '--json'], {
   encoding: 'utf8',
   stdio: ['ignore', 'pipe', 'pipe'],
 });
-const [pack] = JSON.parse(output);
+const raw = JSON.parse(output);
+const pack = Array.isArray(raw)
+  ? raw[0]
+  : raw[Object.keys(raw).find((k) => k.startsWith('@')) || Object.keys(raw)[0]];
 const packedFiles = new Set((pack?.files ?? []).map((file) => file.path));
 const missing = requiredPackFiles.filter((file) => !packedFiles.has(file));
 const channelSource = fs.readFileSync(path.join(root, 'src/channel.ts'), 'utf8');

package/src/messaging/inbound/commands.ts

@@ -515,12 +515,6 @@ export async function handleBncrNativeCommand(params: {
           result: 'rejected',
         }),
       );
-      await recordAndPatchBncrInboundSessionEntry({
-        storePath,
-        sessionKey,
-        ctx: ctxPayload,
-        patch: sessionIdentityPatch,
-      });
       if (!silentNonAdminGroupReject) {
         await enqueueFromReply({
           accountId,

package/src/messaging/inbound/dispatch.ts

@@ -1,5 +1,7 @@
+import { DEFAULT_GROUP_HISTORY_LIMIT } from 'openclaw/plugin-sdk/reply-history';
 import { emitBncrLogLine } from '../../core/logging.ts';
 import type { BncrSceneRecord } from '../../plugin/channel-runtime-types.ts';
+import { buildSceneKey } from '../../plugin/scene-registry.ts';
 import { handleBncrNativeCommand } from './commands.ts';
 import type {
   BncrEnqueueFromReply,
@@ -18,7 +20,10 @@ import {
 } from './dispatch-prep.ts';
 import {
   type BncrGroupHistoryMap,
+  type BncrHistoryEntry,
+  buildBncrGroupHistoryKey,
   clearBncrPendingGroupHistory,
+  readBncrPendingGroupHistorySnapshot,
   recordBncrPendingGroupMedia,
   recordBncrPendingGroupText,
 } from './group-history.ts';
@@ -58,10 +63,10 @@ export async function dispatchBncrInbound(params: {
     cfg,
     parsed,
     canonicalAgentId,
-    shouldDispatch = true,
-    shouldAccumulate = shouldDispatch,
+    shouldDispatch: initialShouldDispatch = true,
+    shouldAccumulate = initialShouldDispatch,
     resolvedAgentId,
-    sceneRegistry,
+    sceneRegistry = new Map(),
     groupHistories = new Map(),
     defaultAdminAgentId,
     defaultPublicAgentId,
@@ -73,6 +78,7 @@ export async function dispatchBncrInbound(params: {
     logger,
   } = params;
   const { accountId, clientId, msgId, extracted, mimeType, peer } = parsed;
+  let shouldDispatch = initialShouldDispatch;
 
   const nativeCommand = await handleBncrNativeCommand({
     api,
@@ -130,31 +136,29 @@ export async function dispatchBncrInbound(params: {
       '[bncr] inbound missing clientId for chat identity; using route identity fallback',
     );
   }
-  const ctxPayload = await buildBncrInboundTurnContext({
-    api,
-    cfg,
-    channelId,
-    parsed,
-    msgId,
-    peer,
-    senderIdForContext,
-    senderDisplayName,
-    ownerAllowFrom,
-    bridgeSenderId,
-    bridgeSenderName,
-    resolution,
-    prepared,
-    groupHistories,
-    shouldDispatch,
-  });
+  const sceneHistoryLimit =
+    parsed.peer.kind === 'group'
+      ? (sceneRegistry.get(buildSceneKey(parsed))?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT)
+      : DEFAULT_GROUP_HISTORY_LIMIT;
+  const resolvedHistoryLimit =
+    typeof sceneHistoryLimit === 'number' &&
+    Number.isFinite(sceneHistoryLimit) &&
+    sceneHistoryLimit >= 0
+      ? Math.floor(sceneHistoryLimit)
+      : DEFAULT_GROUP_HISTORY_LIMIT;
 
+  let silentHistoryFlush = false;
+  let pendingHistoryEntries: BncrHistoryEntry[] = [];
   if (!shouldDispatch && shouldAccumulate) {
+    const historyKey = buildBncrGroupHistoryKey(parsed);
+    // Record the message first so overflow context includes it
     recordBncrPendingGroupText({
       historyMap: groupHistories,
       parsed,
       senderDisplayName,
       senderId: senderIdForContext,
       bodyText: rawBody,
+      historyLimit: resolvedHistoryLimit,
     });
     await recordBncrPendingGroupMedia({
       historyMap: groupHistories,
@@ -164,9 +168,67 @@ export async function dispatchBncrInbound(params: {
       bodyText: rawBody,
       mediaItems,
       mediaContentType: mediaContentType || mimeType,
+      historyLimit: resolvedHistoryLimit,
+    });
+    if (historyKey && parsed.peer.kind === 'group') {
+      const entries = groupHistories.get(historyKey);
+      if (entries && resolvedHistoryLimit > 0 && entries.length >= resolvedHistoryLimit) {
+        const sceneForHistory = sceneRegistry.get(buildSceneKey(parsed));
+        const historyForce = sceneForHistory?.historyForce !== false;
+        if (historyForce) {
+          pendingHistoryEntries = readBncrPendingGroupHistorySnapshot({
+            historyMap: groupHistories,
+            parsed,
+            historyLimit: resolvedHistoryLimit,
+          });
+          clearBncrPendingGroupHistory({
+            historyMap: groupHistories,
+            parsed,
+            historyLimit: resolvedHistoryLimit,
+          });
+          shouldDispatch = true;
+          silentHistoryFlush = true;
+        }
+      }
+    }
+  }
+
+  if (shouldDispatch && !silentHistoryFlush && parsed.peer.kind === 'group') {
+    pendingHistoryEntries = readBncrPendingGroupHistorySnapshot({
+      historyMap: groupHistories,
+      parsed,
+      historyLimit: resolvedHistoryLimit,
     });
+    if (pendingHistoryEntries.length > 0) {
+      clearBncrPendingGroupHistory({
+        historyMap: groupHistories,
+        parsed,
+        historyLimit: resolvedHistoryLimit,
+      });
+    }
   }
 
+  const ctxPayload = await buildBncrInboundTurnContext({
+    api,
+    cfg,
+    channelId,
+    parsed,
+    msgId,
+    peer,
+    senderIdForContext,
+    senderDisplayName,
+    ownerAllowFrom,
+    bridgeSenderId,
+    bridgeSenderName,
+    historyLimit: resolvedHistoryLimit,
+    resolution,
+    prepared,
+    groupHistories,
+    shouldDispatch,
+    silentHistoryFlush,
+    pendingHistoryEntries,
+  });
+
   await runBncrInboundReplyDispatch({
     api,
     channelId,
@@ -182,13 +244,18 @@ export async function dispatchBncrInbound(params: {
     senderIdForContext,
     senderDisplayName,
     shouldDispatch,
+    silentHistoryFlush,
     setInboundActivity,
     scheduleSave,
     enqueueFromReply,
   });
 
-  if (shouldDispatch) {
-    clearBncrPendingGroupHistory({ historyMap: groupHistories, parsed });
+  if (shouldDispatch && pendingHistoryEntries.length === 0) {
+    clearBncrPendingGroupHistory({
+      historyMap: groupHistories,
+      parsed,
+      historyLimit: resolvedHistoryLimit,
+    });
   }
 
   return {

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

@@ -37,13 +37,25 @@ export function recordBncrPendingGroupText(args: {
   senderDisplayName: string;
   senderId: string;
   bodyText: string;
+  historyLimit?: number;
 }) {
+  const limit =
+    typeof args.historyLimit === 'number' &&
+    Number.isFinite(args.historyLimit) &&
+    args.historyLimit >= 0
+      ? Math.floor(args.historyLimit)
+      : DEFAULT_GROUP_HISTORY_LIMIT;
   const historyKey = buildBncrGroupHistoryKey(args.parsed);
   const body = normalizeTextBody(args.bodyText);
   if (!historyKey || !body || args.parsed.msgType !== 'text') return;
+  const msgId = String(args.parsed.msgId || '').trim();
+  if (msgId) {
+    const existing = args.historyMap.get(historyKey) || [];
+    if (existing.some((e) => e.messageId === msgId)) return;
+  }
   createChannelHistoryWindow({ historyMap: args.historyMap }).record({
     historyKey,
-    limit: DEFAULT_GROUP_HISTORY_LIMIT,
+    limit,
     entry: {
       sender: args.senderDisplayName,
       senderId: args.senderId,
@@ -89,7 +101,14 @@ export async function recordBncrPendingGroupMedia(args: {
     kind?: BncrHistoryMediaKind;
   }>;
   mediaContentType?: string;
+  historyLimit?: number;
 }) {
+  const limit =
+    typeof args.historyLimit === 'number' &&
+    Number.isFinite(args.historyLimit) &&
+    args.historyLimit >= 0
+      ? Math.floor(args.historyLimit)
+      : DEFAULT_GROUP_HISTORY_LIMIT;
   const historyKey = buildBncrGroupHistoryKey(args.parsed);
   if (!historyKey || args.parsed.msgType === 'text') return;
   const normalizedMediaItems = Array.isArray(args.mediaItems) ? args.mediaItems : [];
@@ -110,9 +129,14 @@ export async function recordBncrPendingGroupMedia(args: {
       });
   const body = normalizeTextBody(args.bodyText) || buildBncrHistoryMediaBody(kind);
   if (normalizedMediaItems.length === 0) {
+    const msgId = String(args.parsed.msgId || '').trim();
+    if (msgId) {
+      const existing = args.historyMap.get(historyKey) || [];
+      if (existing.some((e) => e.messageId === msgId)) return;
+    }
     createChannelHistoryWindow({ historyMap: args.historyMap }).record({
       historyKey,
-      limit: DEFAULT_GROUP_HISTORY_LIMIT,
+      limit,
       entry: {
         sender: args.senderDisplayName,
         senderId: args.senderId,
@@ -123,9 +147,14 @@ export async function recordBncrPendingGroupMedia(args: {
     });
     return;
   }
+  const msgId = String(args.parsed.msgId || '').trim();
+  if (msgId) {
+    const existing = args.historyMap.get(historyKey) || [];
+    if (existing.some((e) => e.messageId === msgId)) return;
+  }
   createChannelHistoryWindow({ historyMap: args.historyMap }).record({
     historyKey,
-    limit: DEFAULT_GROUP_HISTORY_LIMIT,
+    limit,
     entry: {
       sender: args.senderDisplayName,
       senderId: args.senderId,
@@ -145,23 +174,56 @@ export async function recordBncrPendingGroupMedia(args: {
   });
 }
 
-export function buildBncrPendingGroupContext(args: {
-  api: BncrInboundApi;
+function cloneBncrHistoryEntry(entry: BncrHistoryEntry): BncrHistoryEntry {
+  return {
+    sender: entry.sender,
+    ...(entry.messageId ? { messageId: entry.messageId } : {}),
+    ...(typeof entry.timestamp === 'number' ? { timestamp: entry.timestamp } : {}),
+    ...(entry.senderId ? { senderId: entry.senderId } : {}),
+    body: entry.body,
+    ...(Array.isArray(entry.media)
+      ? {
+          media: entry.media.map((item) => ({
+            ...(item?.path ? { path: item.path } : {}),
+            ...(item?.contentType ? { contentType: item.contentType } : {}),
+            ...(item?.kind ? { kind: item.kind } : {}),
+            ...(item?.messageId ? { messageId: item.messageId } : {}),
+          })),
+        }
+      : {}),
+  };
+}
+
+export function readBncrPendingGroupHistorySnapshot(args: {
   historyMap: BncrGroupHistoryMap;
   parsed: ParsedInbound;
+  historyLimit?: number;
+}): BncrHistoryEntry[] {
+  const limit =
+    typeof args.historyLimit === 'number' &&
+    Number.isFinite(args.historyLimit) &&
+    args.historyLimit >= 0
+      ? Math.floor(args.historyLimit)
+      : DEFAULT_GROUP_HISTORY_LIMIT;
+  const historyKey = buildBncrGroupHistoryKey(args.parsed);
+  if (!historyKey) return [];
+  const entries = args.historyMap.get(historyKey) || [];
+  if (entries.length === 0) return [];
+  return entries.slice(-limit).map(cloneBncrHistoryEntry);
+}
+
+export function buildBncrGroupContextFromEntries(args: {
+  api: BncrInboundApi;
+  entries: readonly BncrHistoryEntry[];
   channelLabel: string;
   currentTimestamp: number;
   previousTimestamp?: unknown;
   envelope?: unknown;
   currentMessage: string;
 }) {
-  const historyKey = buildBncrGroupHistoryKey(args.parsed);
-  if (!historyKey) return args.currentMessage;
-  return createChannelHistoryWindow({ historyMap: args.historyMap }).buildPendingContext({
-    historyKey,
-    limit: DEFAULT_GROUP_HISTORY_LIMIT,
-    currentMessage: args.currentMessage,
-    formatEntry: (entry) =>
+  if (args.entries.length === 0) return args.currentMessage;
+  const historyText = args.entries
+    .map((entry) =>
       formatOpenClawAgentEnvelope(args.api, {
         channel: 'Bncr',
         from: args.channelLabel,
@@ -170,17 +232,15 @@ export function buildBncrPendingGroupContext(args: {
         envelope: args.envelope,
         body: entry.body,
       }),
-  });
+    )
+    .join('\n');
+  return `[Chat messages since your last reply - for context]\n${historyText}\n\n[Current message - respond to this]${args.currentMessage}`;
 }
 
-export function collectBncrPendingHistoryMedia(args: {
-  historyMap: BncrGroupHistoryMap;
-  parsed: ParsedInbound;
+export function collectBncrHistoryMediaFromEntries(args: {
+  entries: readonly BncrHistoryEntry[];
 }): HistoryMediaEntry[] {
-  const historyKey = buildBncrGroupHistoryKey(args.parsed);
-  if (!historyKey) return [];
-  const entries = args.historyMap.get(historyKey) || [];
-  return entries.flatMap((entry) => (Array.isArray(entry.media) ? entry.media : []));
+  return args.entries.flatMap((entry) => (Array.isArray(entry.media) ? entry.media : []));
 }
 
 function toBncrPromptMediaPath(value: string | undefined): string | undefined {
@@ -230,16 +290,12 @@ function buildHistoryWindowMedias(media: HistoryMediaEntry[] | undefined) {
   });
 }
 
-export function buildBncrPendingHistoryWindowContext(args: {
-  historyMap: BncrGroupHistoryMap;
-  parsed: ParsedInbound;
+export function buildBncrHistoryWindowContextFromEntries(args: {
+  entries: readonly BncrHistoryEntry[];
   channelId: string;
 }) {
-  const historyKey = buildBncrGroupHistoryKey(args.parsed);
-  if (!historyKey) return undefined;
-  const entries = args.historyMap.get(historyKey) || [];
-  if (entries.length === 0) return undefined;
-  const messages = entries.slice(-DEFAULT_GROUP_HISTORY_LIMIT).map((entry) => ({
+  if (args.entries.length === 0) return undefined;
+  const messages = args.entries.map((entry) => ({
     ...(entry.messageId ? { messageId: entry.messageId } : {}),
     sender: entry.sender,
     senderId: entry.senderId,
@@ -263,11 +319,18 @@ export function buildBncrPendingHistoryWindowContext(args: {
 export function clearBncrPendingGroupHistory(args: {
   historyMap: BncrGroupHistoryMap;
   parsed: ParsedInbound;
+  historyLimit?: number;
 }) {
+  const limit =
+    typeof args.historyLimit === 'number' &&
+    Number.isFinite(args.historyLimit) &&
+    args.historyLimit >= 0
+      ? Math.floor(args.historyLimit)
+      : DEFAULT_GROUP_HISTORY_LIMIT;
   const historyKey = buildBncrGroupHistoryKey(args.parsed);
   if (!historyKey) return;
   createChannelHistoryWindow({ historyMap: args.historyMap }).clear({
     historyKey,
-    limit: DEFAULT_GROUP_HISTORY_LIMIT,
+    limit: limit,
   });
 }

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

@@ -49,12 +49,16 @@ const BNCR_HELP_TEXT = [
   '  • /bncr allow [<SceneId>]',
   '  • /bncr deny [<SceneId>]',
   '  • /bncr bind <agentId> [<SceneId>]',
-  '  • /bncr mode',
   '  • /bncr mode help',
   '  • /bncr mode <admin|mention|hybrid|all> [<SceneId>]',
   '  • /bncr revoke [<SceneId>]',
   '  • /bncr list pending',
   '  • /bncr list scenes',
+  '',
+  '📋 Group history',
+  '  • /bncr history-help',
+  '  • /bncr history-limit [<number>] [<SceneId>]',
+  '  • /bncr history-force on|off [<SceneId>]',
 ].join('\n');
 
 const BNCR_NATIVE_COMMANDS = new Set([
@@ -70,9 +74,18 @@ const BNCR_NATIVE_COMMANDS = new Set([
   'mode',
   'revoke',
   'list',
+  'history-limit',
+  'history-help',
+  'history-force',
 ]);
 
-export const BNCR_DIRECT_ALLOWED_BARE_COMMANDS = new Set(['whoami', 'status', 'new', 'reset']);
+export const BNCR_DIRECT_ALLOWED_BARE_COMMANDS = new Set([
+  'whoami',
+  'status',
+  'new',
+  'reset',
+  'stop',
+]);
 
 export const BNCR_DIRECT_ALLOWED_SUBCOMMANDS = new Set([
   'help',

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

@@ -125,6 +125,7 @@ export async function runBncrInboundReplyDispatch(args: {
   senderIdForContext: string;
   senderDisplayName: string;
   shouldDispatch: boolean;
+  silentHistoryFlush?: boolean;
   setInboundActivity: (accountId: string, at: number) => void;
   scheduleSave: () => void;
   enqueueFromReply: BncrEnqueueFromReply;
@@ -143,6 +144,7 @@ export async function runBncrInboundReplyDispatch(args: {
     replyRouteFact,
     senderIdForContext,
     shouldDispatch,
+    silentHistoryFlush = false,
     setInboundActivity,
     scheduleSave,
     enqueueFromReply,
@@ -230,15 +232,16 @@ export async function runBncrInboundReplyDispatch(args: {
               textForCommands: ctxPayload.CommandBody,
               raw: parsed,
             }),
-            preflight: () =>
-              shouldDispatch
+            preflight: () => {
+              return shouldDispatch
                 ? undefined
                 : {
                     admission: {
                       kind: 'observeOnly' as const,
                       reason: 'bncr-group-mode-no-reply',
                     },
-                  },
+                  };
+            },
             resolveTurn: () => {
               const sessionMetaBarrier = createBncrSessionMetaTaskBarrier();
               return {
@@ -291,6 +294,10 @@ export async function runBncrInboundReplyDispatch(args: {
                             return;
                           }
 
+                          if (silentHistoryFlush) {
+                            return;
+                          }
+
                           await enqueueFromReply({
                             accountId: replyRouteFact.accountId,
                             sessionKey: replyRouteFact.sessionKey,

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

@@ -14,12 +14,19 @@ export type BncrSceneAdminCommand =
   | { kind: 'mode-help' }
   | { kind: 'mode-get'; sceneKey?: string }
   | { kind: 'mode'; sceneKey: string; mode: BncrGroupReplyMode }
-  | { kind: 'list'; scope: 'pending' | 'scenes' };
+  | { kind: 'list'; scope: 'pending' | 'scenes' }
+  | { kind: 'history-limit-get'; sceneKey?: string }
+  | { kind: 'history-limit-set'; sceneKey: string; limit: number }
+  | { kind: 'history-force-get'; sceneKey?: string }
+  | { kind: 'history-force-set'; sceneKey: string; enabled: boolean }
+  | { kind: 'history-help' };
 
 const GROUP_REPLY_MODES = new Set<BncrGroupReplyMode>(['admin', 'mention', 'hybrid', 'all']);
 
 const MODE_HELP_TEXT = [
-  '💬 Group reply modes',
+  '💬 Bncr Group Reply Mode Configuration',
+  '',
+  'Modes:',
   '  • default: admin',
   '  • admin: 仅管理员|消息上送并逐条回复',
   '  • mention: 全员|消息上送 仅指定消息触发回复',
@@ -32,9 +39,18 @@ const MODE_HELP_TEXT = [
   '  • platform-marked should-respond messages',
   '',
   'Usage:',
-  '  • /bncr mode',
-  '  • /bncr mode help',
-  '  • /bncr mode <admin|mention|hybrid|all> [<platform>:<groupId>]',
+  '  • /bncr mode <admin|mention|hybrid|all> [<SceneId>]',
+].join('\n');
+
+export const HISTORY_HELP_TEXT = [
+  '📋 Bncr Group History Configuration',
+  '',
+  'Commands:',
+  '  • /bncr history-limit <number> [<SceneId>]',
+  '    Set history limit (default: 50)',
+  '  • /bncr history-force on|off [<SceneId>]',
+  '    When on, overflow triggers auto context at limit (default: on)',
+  '    When off, oldest messages trim silently without context',
 ].join('\n');
 
 export type ParsedSceneAdminCommand =
@@ -141,6 +157,65 @@ export function parseSceneAdminCommand(command: NativeCommand): ParsedSceneAdmin
         return { matched: true, valid: true, command: { kind: 'list', scope: 'scenes' } };
       }
       return { matched: true, valid: false, text: 'Usage: /bncr list <pending|scenes>' };
+    case 'history-limit':
+      if (args.length === 0) {
+        return { matched: true, valid: true, command: { kind: 'history-limit-get' } };
+      }
+      if (args.length === 1) {
+        const num = parseInt(args[0], 10);
+        if (Number.isFinite(num)) {
+          return {
+            matched: true,
+            valid: true,
+            command: { kind: 'history-limit-set', sceneKey: '', limit: num },
+          };
+        }
+        return {
+          matched: true,
+          valid: true,
+          command: { kind: 'history-limit-get', sceneKey: args[0] },
+        };
+      }
+      if (args.length === 2) {
+        const num = parseInt(args[0], 10);
+        if (Number.isFinite(num)) {
+          return {
+            matched: true,
+            valid: true,
+            command: { kind: 'history-limit-set', sceneKey: args[1], limit: num },
+          };
+        }
+      }
+      return {
+        matched: true,
+        valid: false,
+        text: 'Usage: /bncr history-limit [<number>] [<sceneKey>]',
+      };
+    case 'history-force':
+      if (args.length === 0) {
+        return { matched: true, valid: true, command: { kind: 'history-force-get' } };
+      }
+      if (args[0] === 'on' || args[0] === 'off') {
+        if (args.length === 1) {
+          return {
+            matched: true,
+            valid: true,
+            command: { kind: 'history-force-set', sceneKey: '', enabled: args[0] === 'on' },
+          };
+        }
+        return {
+          matched: true,
+          valid: true,
+          command: { kind: 'history-force-set', sceneKey: args[1], enabled: args[0] === 'on' },
+        };
+      }
+      return {
+        matched: true,
+        valid: true,
+        command: { kind: 'history-force-get', sceneKey: args[0] },
+      };
+    case 'history-help':
+      return { matched: true, valid: true, command: { kind: 'history-help' } };
     default:
       return { matched: false };
   }
@@ -151,7 +226,15 @@ function formatSceneDetailsLine(scene: BncrSceneRecord): string {
     scene.kind === 'group' ? scene.groupId || scene.sceneKey : scene.userId || scene.sceneKey;
   const namePart = scene.kind === 'group' ? scene.groupName || '' : scene.userName || '';
   const labelPart = namePart ? ` name=${namePart}` : '';
-  return `  Details: status=${scene.status} id=${idPart}${labelPart}`;
+  const historyLimitVal = scene.historyLimit;
+  const historyForceVal = scene.historyForce;
+  const hasNonDefaultHistory =
+    scene.kind === 'group' &&
+    ((typeof historyLimitVal === 'number' && historyLimitVal !== 50) || historyForceVal === false);
+  const historyPart = hasNonDefaultHistory
+    ? ` historyLimit=${historyLimitVal ?? 50} autoFlush=${historyForceVal !== false ? 'on' : 'off'}`
+    : '';
+  return `  Details: status=${scene.status} id=${idPart}${labelPart}${historyPart}`;
 }
 
 function formatSceneEntry(scene: BncrSceneRecord): string {
@@ -209,6 +292,10 @@ export function executeSceneAdminCommand(args: {
     return { ok: false, text: 'Admin permission required.' };
   }
 
+  if (command.kind === 'history-help') {
+    return { ok: true, text: HISTORY_HELP_TEXT };
+  }
+
   if (command.kind === 'list') {
     const scenes = Array.from(sceneRegistry.values())
       .filter((scene) => (command.scope === 'pending' ? scene.status === 'pending' : true))
@@ -244,6 +331,78 @@ export function executeSceneAdminCommand(args: {
     };
   }
 
+  if (command.kind === 'history-limit-get') {
+    const qSceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    if (!qSceneKey) {
+      return { ok: true, text: 'Default history limit is 50.' };
+    }
+    const s = sceneRegistry.get(qSceneKey);
+    if (!s) return { ok: true, text: 'Default history limit is 50.' };
+    return { ok: true, text: `Current ${qSceneKey} history limit is ${s.historyLimit ?? 50}.` };
+  }
+
+  if (command.kind === 'history-limit-set') {
+    const sSceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    if (!sSceneKey) {
+      return { ok: false, text: 'Current group shortcut only works inside a group chat.' };
+    }
+    const sExisting = sceneRegistry.get(sSceneKey);
+    if (!sExisting) return { ok: false, text: `Scene not found: ${sSceneKey}` };
+    const rawLimit = command.limit;
+    if (!Number.isFinite(rawLimit) || Number.isNaN(rawLimit)) {
+      return { ok: false, text: 'Invalid number.' };
+    }
+    let resolvedLimit = rawLimit;
+    if (resolvedLimit >= 51) {
+      resolvedLimit = Math.min(Math.floor(resolvedLimit), 10000);
+    } else if (resolvedLimit < 0 && Math.abs(resolvedLimit) >= 3) {
+      resolvedLimit = Math.floor(Math.abs(resolvedLimit));
+    } else {
+      return {
+        ok: false,
+        text: `Value too small, must be >= 51, or use negative number (abs >= 3) for hidden override.`,
+      };
+    }
+    sceneRegistry.set(sSceneKey, {
+      ...sExisting,
+      historyLimit: resolvedLimit,
+      lastSeenAt: now(),
+    });
+    return { ok: true, text: `Set ${sSceneKey} history limit to ${resolvedLimit}.` };
+  }
+
+  if (command.kind === 'history-force-get') {
+    const qSceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    if (!qSceneKey) {
+      return { ok: true, text: 'Default history auto flush is on.' };
+    }
+    const s = sceneRegistry.get(qSceneKey);
+    if (!s) return { ok: true, text: 'Default history auto flush is on.' };
+    const enabled = s.historyForce !== false;
+    return {
+      ok: true,
+      text: `Current ${qSceneKey} history auto flush is ${enabled ? 'on' : 'off'}.`,
+    };
+  }
+
+  if (command.kind === 'history-force-set') {
+    const sSceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    if (!sSceneKey) {
+      return { ok: false, text: 'Current group shortcut only works inside a group chat.' };
+    }
+    const sExisting = sceneRegistry.get(sSceneKey);
+    if (!sExisting) return { ok: false, text: `Scene not found: ${sSceneKey}` };
+    sceneRegistry.set(sSceneKey, {
+      ...sExisting,
+      historyForce: command.enabled,
+      lastSeenAt: now(),
+    });
+    return {
+      ok: true,
+      text: `Set ${sSceneKey} history auto flush to ${command.enabled ? 'on' : 'off'}.`,
+    };
+  }
+
   const sceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
   if (!sceneKey) {
     return { ok: false, text: 'Current group shortcut only works inside a group chat.' };

package/src/messaging/inbound/turn-context.ts

@@ -1,5 +1,8 @@
 import { readBncrSessionUpdatedAt } from '../../openclaw/inbound-session-runtime.ts';
-import { resolveOpenClawEnvelopeFormatOptions } from '../../openclaw/reply-runtime.ts';
+import {
+  formatOpenClawAgentEnvelope,
+  resolveOpenClawEnvelopeFormatOptions,
+} from '../../openclaw/reply-runtime.ts';
 import {
   buildBncrPromptVisibleContextFacts,
   buildBncrStructuredContextFactsFromInboundParts,
@@ -12,9 +15,9 @@ import type {
 } from './dispatch-prep.ts';
 import {
   type BncrGroupHistoryMap,
-  buildBncrPendingGroupContext,
-  buildBncrPendingHistoryWindowContext,
-  collectBncrPendingHistoryMedia,
+  type BncrHistoryEntry,
+  buildBncrGroupContextFromEntries,
+  collectBncrHistoryMediaFromEntries,
 } from './group-history.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 
@@ -28,13 +31,15 @@ function applyBncrLegacyCommandFields(args: {
   ctx: BncrInboundContextPayload;
   channelId: string;
   senderIdForContext: string;
+  fromOverride?: string;
   resolution: BncrInboundConversationResolution;
   rawBody: string;
   ownerAllowFrom?: string[];
   isAuthorizedTextCommand: boolean;
 }) {
-  const { ctx, channelId, senderIdForContext, resolution, rawBody, ownerAllowFrom } = args;
-  ctx.From = senderIdForContext;
+  const { ctx, channelId, senderIdForContext, fromOverride, resolution, rawBody, ownerAllowFrom } =
+    args;
+  ctx.From = fromOverride || senderIdForContext;
   ctx.To = resolution.canonicalTo;
   ctx.SenderId = senderIdForContext;
   ctx.OriginatingChannel = channelId;
@@ -69,6 +74,9 @@ export function buildBncrInboundTurnContext(args: {
   prepared: BncrPreparedInboundSessionContext;
   groupHistories: BncrGroupHistoryMap;
   shouldDispatch: boolean;
+  historyLimit?: number;
+  silentHistoryFlush?: boolean;
+  pendingHistoryEntries?: readonly BncrHistoryEntry[];
 }): BncrInboundContextPayload | Promise<BncrInboundContextPayload> {
   const {
     api,
@@ -84,31 +92,50 @@ export function buildBncrInboundTurnContext(args: {
     bridgeSenderName,
     resolution,
     prepared,
-    groupHistories,
     shouldDispatch,
   } = args;
+  const pendingHistoryEntries = Array.isArray(args.pendingHistoryEntries)
+    ? args.pendingHistoryEntries
+    : [];
+  const silentHistoryFlush = args.silentHistoryFlush === true;
+  const flushSenderId = 'bncr-history-system';
+  const flushSenderName = 'Bncr History System';
+  const flushRawBody =
+    'This message was automatically generated by the system for group context accumulation. Do not reply to the user. Output exactly NO_REPLY.';
+  const effectiveSenderId = silentHistoryFlush ? flushSenderId : senderIdForContext;
+  const effectiveSenderDisplayName = silentHistoryFlush ? flushSenderName : senderDisplayName;
+  const effectiveRawBody = silentHistoryFlush ? flushRawBody : prepared.rawBody;
+  const envelopeOptions = resolveOpenClawEnvelopeFormatOptions(api, cfg);
+  const effectiveBody = silentHistoryFlush
+    ? formatOpenClawAgentEnvelope(api, {
+        channel: 'Bncr',
+        from: resolution.canonicalTo,
+        timestamp: Date.now(),
+        previousTimestamp: readBncrSessionUpdatedAt(api, {
+          storePath: prepared.storePath,
+          sessionKey: resolution.dispatchSessionKey,
+        }),
+        envelope: envelopeOptions,
+        body: effectiveRawBody,
+      })
+    : prepared.body;
   const senderIsOwner = parsed.isAdmin === true || Boolean(ownerAllowFrom?.length);
   const senderIsAuthorized = senderIsOwner;
   const inboundHistory = undefined;
-  const pendingHistoryMedia =
-    shouldDispatch && parsed.peer.kind === 'group'
-      ? collectBncrPendingHistoryMedia({ historyMap: groupHistories, parsed })
-      : [];
-  const pendingHistoryWindowContext =
-    shouldDispatch && parsed.peer.kind === 'group'
-      ? buildBncrPendingHistoryWindowContext({ historyMap: groupHistories, parsed, channelId })
-      : undefined;
+  const pendingHistoryMedia = shouldDispatch
+    ? collectBncrHistoryMediaFromEntries({ entries: pendingHistoryEntries })
+    : [];
   const structuredContextFacts = buildBncrStructuredContextFactsFromInboundParts({
     channelId,
     parsed,
     resolution,
     prepared: {
-      rawBody: prepared.rawBody,
-      body: prepared.body,
-      mediaItems: prepared.mediaItems,
+      rawBody: effectiveRawBody,
+      body: typeof effectiveBody === 'string' ? effectiveBody : prepared.body,
+      mediaItems: silentHistoryFlush ? [] : prepared.mediaItems,
     },
-    senderIdForContext,
-    senderDisplayName,
+    senderIdForContext: effectiveSenderId,
+    senderDisplayName: effectiveSenderDisplayName,
     bridgeSenderId,
     bridgeSenderName,
     senderIsOwner,
@@ -116,14 +143,16 @@ export function buildBncrInboundTurnContext(args: {
   });
   const promptVisibleContextFacts = buildBncrPromptVisibleContextFacts(structuredContextFacts);
   const supplementalUntrustedContext = [
-    ...(pendingHistoryWindowContext ? [pendingHistoryWindowContext] : []),
     ...(Object.keys(promptVisibleContextFacts).length
       ? [
           {
             label: 'Bncr inbound context',
             source: channelId,
             type: 'bncr.inbound_context',
-            payload: promptVisibleContextFacts,
+            payload: {
+              ...promptVisibleContextFacts,
+              ...(silentHistoryFlush ? { historyFlush: true } : {}),
+            },
           },
         ]
       : []),
@@ -132,22 +161,23 @@ export function buildBncrInboundTurnContext(args: {
   const wasMentioned = parsed.isBotMentioned === true || platformWantsReply;
   const isAuthorizedTextCommand = Boolean(ownerAllowFrom?.length);
   const bodyForAgent =
-    shouldDispatch && parsed.peer.kind === 'group'
-      ? buildBncrPendingGroupContext({
+    shouldDispatch && pendingHistoryEntries.length > 0
+      ? buildBncrGroupContextFromEntries({
           api,
-          historyMap: groupHistories,
-          parsed,
+          entries: pendingHistoryEntries,
           channelLabel: resolution.canonicalTo,
           currentTimestamp: Date.now(),
           previousTimestamp: readBncrSessionUpdatedAt(api, {
             storePath: prepared.storePath,
             sessionKey: resolution.dispatchSessionKey,
           }),
-          envelope: resolveOpenClawEnvelopeFormatOptions(api, cfg),
-          currentMessage: prepared.body,
+          envelope: envelopeOptions,
+          currentMessage: typeof effectiveBody === 'string' ? effectiveBody : prepared.body,
         })
-      : prepared.body;
-  const currentTurnMedia = prepared.mediaItems.map((item) => ({
+      : typeof effectiveBody === 'string'
+        ? effectiveBody
+        : prepared.body;
+  const currentTurnMedia = (silentHistoryFlush ? [] : prepared.mediaItems).map((item) => ({
     path: item.path,
     contentType: item.contentType,
     kind: item.kind,
@@ -163,11 +193,13 @@ export function buildBncrInboundTurnContext(args: {
       accountId: resolution.accountId,
       messageId: msgId,
       timestamp: Date.now(),
-      from: senderIdForContext,
+      from: effectiveSenderId,
       sender: {
-        id: senderIdForContext,
-        name: senderDisplayName,
-        username: parsed.userName || senderDisplayName,
+        id: effectiveSenderId,
+        name: effectiveSenderDisplayName,
+        username: silentHistoryFlush
+          ? effectiveSenderDisplayName
+          : parsed.userName || effectiveSenderDisplayName,
       },
       conversation: {
         kind: resolution.chatType,
@@ -191,13 +223,13 @@ export function buildBncrInboundTurnContext(args: {
       },
       message: {
         inboundEventKind: 'user_request',
-        body: prepared.body,
-        rawBody: prepared.rawBody,
+        body: typeof effectiveBody === 'string' ? effectiveBody : prepared.body,
+        rawBody: effectiveRawBody,
         bodyForAgent,
         inboundHistory,
-        commandBody: prepared.rawBody,
+        commandBody: effectiveRawBody,
         envelopeFrom: resolution.originatingTo,
-        senderLabel: senderDisplayName,
+        senderLabel: effectiveSenderDisplayName,
       },
       ...(isAuthorizedTextCommand
         ? {
@@ -242,9 +274,10 @@ export function buildBncrInboundTurnContext(args: {
     applyBncrLegacyCommandFields({
       ctx,
       channelId,
-      senderIdForContext,
+      senderIdForContext: effectiveSenderId,
+      fromOverride: effectiveSenderId,
       resolution,
-      rawBody: prepared.rawBody,
+      rawBody: effectiveRawBody,
       ownerAllowFrom,
       isAuthorizedTextCommand,
     }),

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

@@ -61,11 +61,14 @@ export type BncrSceneRecord = {
   groupName?: string;
   agentId?: string;
   groupReplyMode?: BncrGroupReplyMode;
+  historyLimit?: number;
+  historyForce?: boolean;
   lastSeenAt: number;
 };
 
 export type BncrPersistedGroupHistoryEntry = {
   sender: string;
+  senderId?: string;
   body: string;
   timestamp?: number;
   messageId?: string;

package/src/plugin/inbound-acceptance.ts

@@ -85,7 +85,10 @@ function shouldAccumulateForScene(args: {
   if (isAdminOpenClawNativeCommand) return true;
 
   const mode = admission.scene.groupReplyMode || 'admin';
-  if (mode === 'admin') return parsed.isAdmin === true;
+  // admin and all: no accumulation needed - messages are either dispatched directly or discarded
+  if (mode === 'admin') return false;
+  if (mode === 'all') return false;
+  // mention and hybrid: non-trigger messages accumulate for future context
   return true;
 }
 

package/src/plugin/scene-registry.ts

@@ -56,6 +56,8 @@ export function buildSceneRecord(args: {
     ...(kind === 'group' && parsed.groupName ? { groupName: parsed.groupName } : {}),
     ...(agentId ? { agentId } : {}),
     ...(kind === 'group' ? { groupReplyMode: defaultGroupReplyMode(kind) } : {}),
+    ...(kind === 'group' ? { historyLimit: 50 } : {}),
+    ...(kind === 'group' ? { historyForce: true } : {}),
     lastSeenAt,
   };
 }
@@ -88,6 +90,8 @@ export function decideSceneAdmission(args: {
       ...(kind === 'group' && !existing.groupReplyMode
         ? { groupReplyMode: defaultGroupReplyMode(kind) }
         : {}),
+      ...(kind === 'group' && existing.historyLimit === undefined ? { historyLimit: 50 } : {}),
+      ...(kind === 'group' && existing.historyForce === undefined ? { historyForce: true } : {}),
       lastSeenAt: now,
     } satisfies BncrSceneRecord;
 

package/src/plugin/state-store.ts

@@ -20,6 +20,7 @@ import type {
 } from './channel-runtime-types.ts';
 
 const GROUP_REPLY_MODES = new Set<BncrGroupReplyMode>(['admin', 'mention', 'hybrid', 'all']);
+const DEFAULT_PERSISTED_GROUP_HISTORY_LIMIT = 50;
 
 type BncrPersistedStateStoreInput = {
   outbox?: unknown;
@@ -76,6 +77,18 @@ export function createBncrStateStore(runtime: {
   getLastDriftSnapshot: () => BncrPersistedState['lastDriftSnapshot'];
   setLastDriftSnapshot: (value: BncrPersistedState['lastDriftSnapshot']) => void;
 }) {
+  function resolvePersistedGroupHistoryLimit(key: string): number {
+    const scene = runtime.sceneRegistry.get(key);
+    const sceneLimit = scene?.kind === 'group' ? scene.historyLimit : undefined;
+    if (typeof sceneLimit === 'number' && Number.isFinite(sceneLimit) && sceneLimit >= 0) {
+      return Math.max(
+        DEFAULT_PERSISTED_GROUP_HISTORY_LIMIT,
+        Math.ceil(Math.floor(sceneLimit) * 1.2),
+      );
+    }
+    return DEFAULT_PERSISTED_GROUP_HISTORY_LIMIT;
+  }
+
   function loadPersistedSceneRegistry(persisted: unknown): void {
     runtime.sceneRegistry.clear();
     const items = Array.isArray(persisted) ? (persisted as PersistedSceneRecordInput[]) : [];
@@ -120,6 +133,12 @@ export function createBncrStateStore(runtime: {
                 .trim() as BncrGroupReplyMode,
             }
           : {}),
+        ...(typeof item.historyLimit === 'number' &&
+        Number.isFinite(item.historyLimit) &&
+        item.historyLimit >= 0
+          ? { historyLimit: Math.floor(item.historyLimit) }
+          : {}),
+        ...(typeof item.historyForce === 'boolean' ? { historyForce: item.historyForce } : {}),
         lastSeenAt,
       });
     }
@@ -169,6 +188,9 @@ export function createBncrStateStore(runtime: {
 
         const normalizedEntry: BncrPersistedGroupHistoryEntry = {
           sender,
+          ...(runtime.asString(entry?.senderId || '').trim()
+            ? { senderId: runtime.asString(entry?.senderId || '').trim() }
+            : {}),
           body,
           ...(timestamp > 0 ? { timestamp } : {}),
           ...(messageId ? { messageId } : {}),
@@ -176,14 +198,16 @@ export function createBncrStateStore(runtime: {
         };
         entries.push(normalizedEntry);
       }
-      if (entries.length > 0) runtime.groupHistories.set(key, entries.slice(-50));
+      if (entries.length > 0) {
+        runtime.groupHistories.set(key, entries.slice(-resolvePersistedGroupHistoryLimit(key)));
+      }
     }
   }
 
   function dumpPersistedGroupHistories() {
     return Array.from(runtime.groupHistories.entries()).map(([key, entries]) => ({
       key,
-      entries: entries.slice(-50),
+      entries: entries.slice(-resolvePersistedGroupHistoryLimit(key)),
     }));
   }