@xmoxmo/bncr 0.6.1 → 0.6.3

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

@@ -18,7 +18,7 @@ import type {
   ParsedInbound,
 } from './dispatch-prep.ts';
 import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
-import { parseBncrNativeCommand } from './native-command.ts';
+import { isBncrStopCommandText, parseBncrNativeCommand } from './native-command.ts';
 import { buildBncrReplyConfig } from './reply-config.ts';
 import { runBncrReplyDispatchSerial } from './reply-dispatch-serial.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
@@ -126,6 +126,7 @@ export async function runBncrInboundReplyDispatch(args: {
   senderDisplayName: string;
   shouldDispatch: boolean;
   silentHistoryFlush?: boolean;
+  deliveryId?: string;
   setInboundActivity: (accountId: string, at: number) => void;
   scheduleSave: () => void;
   enqueueFromReply: BncrEnqueueFromReply;
@@ -145,6 +146,7 @@ export async function runBncrInboundReplyDispatch(args: {
     senderIdForContext,
     shouldDispatch,
     silentHistoryFlush = false,
+    deliveryId,
     setInboundActivity,
     scheduleSave,
     enqueueFromReply,
@@ -210,10 +212,9 @@ export async function runBncrInboundReplyDispatch(args: {
     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@');
+  // Stop commands also bypass the reply serial chain; the inbound history serial
+  // bypass is handled before this function runs so they can interrupt an agent.
+  const isStopCommand = isBncrStopCommandText(rawBody);
   const dispatchSessionKey = resolution.dispatchSessionKey;
 
   const runStopOrSerial = () => {
@@ -225,7 +226,7 @@ export async function runBncrInboundReplyDispatch(args: {
           raw: parsed,
           adapter: {
             ingest: () => ({
-              id: msgId ?? `${resolution.canonicalTo}:${Date.now()}`,
+              id: deliveryId || msgId || `${resolution.canonicalTo}:${Date.now()}`,
               timestamp: Date.now(),
               rawText: rawBody,
               textForAgent: ctxPayload.BodyForAgent,

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

@@ -3,6 +3,7 @@ import type {
   BncrSceneRecord,
   BncrSceneStatus,
 } from '../../plugin/channel-runtime-types.ts';
+import { resolveBncrHistoryLimit } from './conversation-history.ts';
 import type { ParsedInbound } from './dispatch-prep.ts';
 import type { NativeCommand } from './native-command.ts';
 
@@ -49,12 +50,12 @@ const MODE_HELP_TEXT = [
 ].join('\n');
 
 export const HISTORY_HELP_TEXT = [
-  '📋 Bncr Group History Configuration',
+  '📋 Bncr Conversation History Configuration',
   '',
   'Commands:',
-  '  • /bncr history-limit <number> [<SceneId>]',
-  '    Set history limit (default: 50)',
-  '  • /bncr history-force on|off [<SceneId>]',
+  '  • /bncr history-limit [<number>|clear] [<SceneId>]',
+  '    Set history limit (default: 50, minimum: 2)',
+  '  • /bncr history-force on|off|clear [<SceneId>]',
   '    When on, overflow triggers auto context at limit (default: on)',
   '    When off, oldest messages trim silently without context',
 ].join('\n');
@@ -88,6 +89,22 @@ function resolveCurrentGroupSceneKey(parsed: ParsedInbound): string | null {
   return `${platform}:${groupId}`;
 }
 
+function resolveCurrentSceneKey(parsed: ParsedInbound): string | null {
+  const platform = normalizeToken(parsed.platform);
+  if (!platform) return null;
+  if (parsed.peer.kind === 'group') {
+    const groupId = normalizeToken(parsed.groupId);
+    if (!groupId || groupId === '0') return null;
+    return `${platform}:${groupId}`;
+  }
+  if (parsed.peer.kind === 'direct') {
+    const userId = normalizeToken(parsed.userId);
+    if (!userId || userId === '0') return null;
+    return `${platform}:${userId}`;
+  }
+  return null;
+}
+
 export function parseSceneAdminCommand(command: NativeCommand): ParsedSceneAdminCommand {
   const args = splitArgs(command.argsText);
   switch (command.command) {
@@ -242,7 +259,7 @@ export function parseSceneAdminCommand(command: NativeCommand): ParsedSceneAdmin
       return {
         matched: true,
         valid: false,
-        text: 'Usage: /bncr history-limit [<number>] [<sceneKey>]',
+        text: 'Usage: /bncr history-limit [<number>|clear] [<sceneKey>]',
       };
     case 'history-force':
       if (args.length === 0) {
@@ -337,13 +354,11 @@ 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}` : '';
-  const historyLimitVal = scene.historyLimit;
+  const historyLimitVal = resolveBncrHistoryLimit(scene.historyLimit);
   const historyForceVal = scene.historyForce;
-  const hasNonDefaultHistory =
-    scene.kind === 'group' &&
-    ((typeof historyLimitVal === 'number' && historyLimitVal !== 50) || historyForceVal === false);
+  const hasNonDefaultHistory = historyLimitVal !== 50 || historyForceVal === false;
   const historyPart = hasNonDefaultHistory
-    ? ` historyLimit=${historyLimitVal ?? 50} autoFlush=${historyForceVal !== false ? 'on' : 'off'}`
+    ? ` historyLimit=${historyLimitVal} autoFlush=${historyForceVal !== false ? 'on' : 'off'}`
     : '';
   return `  Details: status=${scene.status} id=${idPart}${labelPart}${historyPart}`;
 }
@@ -475,19 +490,22 @@ export function executeSceneAdminCommand(args: {
   }
 
   if (command.kind === 'history-limit-get') {
-    const qSceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    const qSceneKey = command.sceneKey || resolveCurrentSceneKey(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}.` };
+    return {
+      ok: true,
+      text: `Current ${qSceneKey} history limit is ${resolveBncrHistoryLimit(s.historyLimit)}.`,
+    };
   }
 
   if (command.kind === 'history-limit-set') {
-    const sSceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    const sSceneKey = command.sceneKey || resolveCurrentSceneKey(parsed);
     if (!sSceneKey) {
-      return { ok: false, text: 'Current group shortcut only works inside a group chat.' };
+      return { ok: false, text: 'Current conversation shortcut requires a valid chat.' };
     }
     const sExisting = sceneRegistry.get(sSceneKey);
     if (!sExisting) return { ok: false, text: `Scene not found: ${sSceneKey}` };
@@ -503,12 +521,14 @@ export function executeSceneAdminCommand(args: {
     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 if (resolvedLimit >= 2) {
+      resolvedLimit = Math.floor(resolvedLimit);
+    } else if (resolvedLimit < 0 && Math.abs(resolvedLimit) >= 2) {
+      resolvedLimit = Math.min(Math.floor(Math.abs(resolvedLimit)), 10000);
     } else {
       return {
         ok: false,
-        text: `Value too small, must be >= 51, or use negative number (abs >= 3) for hidden override.`,
+        text: `Value too small, must be >= 2, or use negative number (abs >= 2) for hidden override.`,
       };
     }
     sceneRegistry.set(sSceneKey, {
@@ -520,7 +540,7 @@ export function executeSceneAdminCommand(args: {
   }
 
   if (command.kind === 'history-force-get') {
-    const qSceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    const qSceneKey = command.sceneKey || resolveCurrentSceneKey(parsed);
     if (!qSceneKey) {
       return { ok: true, text: 'Default history auto flush is on.' };
     }
@@ -534,9 +554,9 @@ export function executeSceneAdminCommand(args: {
   }
 
   if (command.kind === 'history-force-set') {
-    const sSceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    const sSceneKey = command.sceneKey || resolveCurrentSceneKey(parsed);
     if (!sSceneKey) {
-      return { ok: false, text: 'Current group shortcut only works inside a group chat.' };
+      return { ok: false, text: 'Current conversation shortcut requires a valid chat.' };
     }
     const sExisting = sceneRegistry.get(sSceneKey);
     if (!sExisting) return { ok: false, text: `Scene not found: ${sSceneKey}` };

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

@@ -9,20 +9,88 @@ import {
   buildBncrStructuredContextFactsFromInboundParts,
 } from './context-facts.ts';
 import type { BncrInboundApi, BncrInboundConfig, BncrInboundContextPayload } from './contracts.ts';
+import {
+  type BncrConversationHistoryMap,
+  type BncrHistoryEntry,
+  collectBncrHistoryMediaFromEntries,
+} from './conversation-history.ts';
 import type {
   BncrInboundConversationResolution,
   BncrPreparedInboundSessionContext,
   ParsedInbound,
 } from './dispatch-prep.ts';
-import {
-  type BncrGroupHistoryMap,
-  type BncrHistoryEntry,
-  buildBncrGroupContextFromEntries,
-  collectBncrHistoryMediaFromEntries,
-} from './group-history.ts';
-import type { BncrOutboundReplayEntry } from './outbound-replay-cache.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 
+function dedupeBncrTurnMedia(entries: readonly HistoryMediaEntry[]): HistoryMediaEntry[] {
+  const seen = new Set<string>();
+  const result: HistoryMediaEntry[] = [];
+  for (const item of entries) {
+    const key = `${item.path ?? ''}:${item.messageId ?? ''}`;
+    if (key && seen.has(key)) continue;
+    seen.add(key);
+    result.push(item);
+  }
+  return result;
+}
+
+function buildBncrParticipantsMap(args: {
+  entries: readonly BncrHistoryEntry[];
+  parsed: ParsedInbound;
+  currentSenderId: string;
+  currentSenderName: string;
+  currentSenderUsername?: string;
+  currentSenderIsAdmin: boolean;
+  currentSenderIsOwner: boolean;
+  currentSenderIsAuthorized: boolean;
+}): Record<
+  string,
+  {
+    name: string;
+    username?: string;
+    isBot?: boolean;
+    isAdmin?: boolean;
+    isOwner?: boolean;
+    isAuthorizedSender?: boolean;
+    role?: 'owner' | 'admin' | 'user';
+    displayName?: string;
+  }
+> {
+  const map: Record<
+    string,
+    {
+      name: string;
+      username?: string;
+      isBot?: boolean;
+      isAdmin?: boolean;
+      isOwner?: boolean;
+      isAuthorizedSender?: boolean;
+      role?: 'owner' | 'admin' | 'user';
+      displayName?: string;
+    }
+  > = {};
+  map[args.currentSenderId] = {
+    name: args.currentSenderName,
+    ...(args.currentSenderUsername ? { username: args.currentSenderUsername } : {}),
+    isBot: false,
+    ...(args.currentSenderIsAdmin ? { isAdmin: true } : {}),
+    ...(args.currentSenderIsOwner ? { isOwner: true } : {}),
+    ...(args.currentSenderIsAuthorized ? { isAuthorizedSender: true } : {}),
+    role: args.currentSenderIsOwner ? 'owner' : args.currentSenderIsAdmin ? 'admin' : 'user',
+    displayName: args.currentSenderName,
+  };
+  for (const entry of args.entries) {
+    if (!entry.senderId || map[entry.senderId]) continue;
+    const isBot = entry.role === 'assistant';
+    map[entry.senderId] = {
+      name: entry.sender || entry.senderId,
+      ...(isBot ? { isBot: true } : {}),
+      role: isBot ? 'admin' : 'user',
+      displayName: entry.sender || entry.senderId,
+    };
+  }
+  return map;
+}
+
 function parseSlashCommandName(body: string): string | undefined {
   const raw = String(body || '').trim();
   if (!raw.startsWith('/')) return undefined;
@@ -74,12 +142,11 @@ export function buildBncrInboundTurnContext(args: {
   bridgeSenderName?: string;
   resolution: BncrInboundConversationResolution;
   prepared: BncrPreparedInboundSessionContext;
-  groupHistories: BncrGroupHistoryMap;
+  conversationHistories: BncrConversationHistoryMap;
   shouldDispatch: boolean;
   historyLimit?: number;
   silentHistoryFlush?: boolean;
   pendingHistoryEntries?: readonly BncrHistoryEntry[];
-  outboundReplayEntries?: readonly BncrOutboundReplayEntry[];
 }): BncrInboundContextPayload | Promise<BncrInboundContextPayload> {
   const {
     api,
@@ -100,17 +167,12 @@ export function buildBncrInboundTurnContext(args: {
   const pendingHistoryEntries = Array.isArray(args.pendingHistoryEntries)
     ? args.pendingHistoryEntries
     : [];
-  const outboundReplayEntries = Array.isArray(args.outboundReplayEntries)
-    ? args.outboundReplayEntries
-    : [];
   const silentHistoryFlush = args.silentHistoryFlush === true;
-  const contextEntries = silentHistoryFlush
-    ? pendingHistoryEntries
-    : [...pendingHistoryEntries, ...outboundReplayEntries];
+  const contextEntries = pendingHistoryEntries;
   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.';
+    'This message was automatically generated by the system for conversation 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;
@@ -137,17 +199,32 @@ export function buildBncrInboundTurnContext(args: {
   const structuredContextEntries = shouldDispatch
     ? contextEntries.map((entry) => ({
         messageId: entry.messageId,
+        timestamp: entry.timestamp,
+        role: entry.role || 'user',
         sender: entry.sender,
         senderId: entry.senderId,
-        body: entry.body,
+        content: entry.body,
         media: (entry.media || []).map((item: HistoryMediaEntry) => ({
+          type: item.kind || 'document',
           path: item.path,
           contentType: item.contentType,
-          kind: item.kind,
           messageId: item.messageId,
         })),
       }))
     : [];
+  const isGroupChat = parsed.isGroup === true;
+  const participants = isGroupChat
+    ? buildBncrParticipantsMap({
+        entries: contextEntries,
+        parsed,
+        currentSenderId: effectiveSenderId,
+        currentSenderName: effectiveSenderDisplayName,
+        currentSenderUsername: parsed.userName,
+        currentSenderIsAdmin: parsed.isAdmin === true,
+        currentSenderIsOwner: senderIsOwner,
+        currentSenderIsAuthorized: senderIsAuthorized,
+      })
+    : null;
   const structuredContextFacts = buildBncrStructuredContextFactsFromInboundParts({
     channelId,
     parsed,
@@ -163,7 +240,10 @@ export function buildBncrInboundTurnContext(args: {
     bridgeSenderName,
     senderIsOwner,
     senderIsAuthorized,
-    pendingHistoryContext: structuredContextEntries,
+    conversationHistoryContext: structuredContextEntries,
+    participants,
+    isGroupChat,
+    groupSubject: parsed.groupName,
   });
   const promptVisibleContextFacts = buildBncrPromptVisibleContextFacts(structuredContextFacts);
   const supplementalUntrustedContext = [
@@ -184,30 +264,14 @@ export function buildBncrInboundTurnContext(args: {
   const platformWantsReply = parsed.shouldRespond === true;
   const wasMentioned = parsed.isBotMentioned === true || platformWantsReply;
   const isAuthorizedTextCommand = Boolean(ownerAllowFrom?.length);
-  const bodyForAgent =
-    shouldDispatch && contextEntries.length > 0
-      ? buildBncrGroupContextFromEntries({
-          api,
-          entries: contextEntries,
-          channelLabel: resolution.canonicalTo,
-          currentTimestamp: Date.now(),
-          previousTimestamp: readBncrSessionUpdatedAt(api, {
-            storePath: prepared.storePath,
-            sessionKey: resolution.dispatchSessionKey,
-          }),
-          envelope: envelopeOptions,
-          currentMessage: typeof effectiveBody === 'string' ? effectiveBody : prepared.body,
-        })
-      : typeof effectiveBody === 'string'
-        ? effectiveBody
-        : prepared.body;
+  const bodyForAgent = typeof effectiveBody === 'string' ? effectiveBody : prepared.body;
   const currentTurnMedia = (silentHistoryFlush ? [] : prepared.mediaItems).map((item) => ({
     path: item.path,
     contentType: item.contentType,
     kind: item.kind,
     messageId: msgId ?? undefined,
   }));
-  const media = [...contextMedia, ...currentTurnMedia];
+  const media = dedupeBncrTurnMedia([...contextMedia, ...currentTurnMedia]);
 
   return Promise.resolve(
     resolveBncrChannelInboundRuntime(api).buildContext({

package/src/plugin/bridge-lifecycle.ts

@@ -44,6 +44,7 @@ export function startBncrBridgeService(
       options?: { debugOnly?: boolean },
     ) => void;
     loadState: () => Promise<void>;
+    cutoverToSqlite?: () => Promise<{ backupPath: string | null; storeMode: string }>;
     setDebugFlag: (value: boolean) => void;
     refreshDebugFlagFromConfig: (options?: { forceLog?: boolean }) => Promise<void>;
     buildIntegratedDiagnostics: (accountId: string) => {
@@ -75,6 +76,13 @@ export function startBncrBridgeService(
       // ignore startup canonical agent initialization errors
     }
     await runtime.loadState();
+    if (process.env.BNCR_SQLITE_CUTOVER === '1' && runtime.cutoverToSqlite) {
+      const cutover = await runtime.cutoverToSqlite();
+      runtime.logInfo(
+        'sqlite',
+        `cutover completed backup=${cutover.backupPath || 'none'} storeMode=${cutover.storeMode}`,
+      );
+    }
     if (typeof debug === 'boolean') runtime.setDebugFlag(debug);
     await runtime.refreshDebugFlagFromConfig({ forceLog: true });
     const bootDiag = runtime.buildIntegratedDiagnostics(BNCR_DEFAULT_ACCOUNT_ID);

package/src/plugin/bridge-outbox-facade.ts

@@ -7,6 +7,7 @@ import {
 } from '../core/outbox-queue.ts';
 import { formatDisplayScope } from '../core/targets.ts';
 import type { BncrRecentOutboundEntry, OutboxEntry } from '../core/types.ts';
+import type { BncrConversationHistoryMap } from '../messaging/inbound/conversation-history.ts';
 import {
   type BncrOutboundReplayCache,
   type BncrOutboundReplayEntry,
@@ -42,7 +43,11 @@ export function createBncrBridgeOutboxFacade(runtime: {
   deadLetterSinceStartByAccount: Map<string, number>;
   lastOutboundByAccount: Map<string, number>;
   outboundReplayCache?: BncrOutboundReplayCache;
+  conversationHistories?: BncrConversationHistoryMap;
+  resolveOutboundHistoryLimit?: (entry: OutboxEntry) => number;
+  resolveOutboundHistoryForce?: (entry: OutboxEntry) => boolean;
   resolveOutboundSender?: (entry: OutboxEntry) => { sender: string; senderId?: string };
+  onConversationHistoryOverflow?: (entry: OutboxEntry, historyVersion?: number) => void;
   isOutboundAckRequired?: (accountId: string) => boolean;
   scheduleSave: () => void;
   flushPushQueueBestEffort: (args?: {
@@ -62,13 +67,22 @@ export function createBncrBridgeOutboxFacade(runtime: {
       sender: entry.accountId,
       senderId: entry.accountId,
     };
-    recordBncrOutboundReplay({
+    const replayResult = recordBncrOutboundReplay({
       cache: runtime.outboundReplayCache,
+      ...(runtime.conversationHistories
+        ? { conversationHistories: runtime.conversationHistories }
+        : {}),
+      ...(runtime.resolveOutboundHistoryLimit
+        ? { historyLimit: runtime.resolveOutboundHistoryLimit(entry) }
+        : {}),
       entry,
       sender: senderInfo.sender,
       senderId: senderInfo.senderId,
       status,
     });
+    if (replayResult.historyOverflow && runtime.resolveOutboundHistoryForce?.(entry) !== false) {
+      runtime.onConversationHistoryOverflow?.(entry, replayResult.historyVersion);
+    }
   };
 
   const markRecentOutboundAcked = (entry: OutboxEntry) => {

package/src/plugin/channel-components.ts

@@ -4,8 +4,8 @@ import { emitBncrLogLine } from '../core/logging.ts';
 import { formatDisplayScope, normalizeStoredSessionKey, parseRouteLike } from '../core/targets.ts';
 import type { BncrRoute } from '../core/types.ts';
 import type { BncrInboundParamsInput } from '../messaging/inbound/contracts.ts';
+import type { BncrConversationHistoryMap } from '../messaging/inbound/conversation-history.ts';
 import { dispatchBncrInbound } from '../messaging/inbound/dispatch.ts';
-import type { BncrGroupHistoryMap } from '../messaging/inbound/group-history.ts';
 import type { BncrOutboundReplayCache } from '../messaging/inbound/outbound-replay-cache.ts';
 import { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import { OUTBOUND_FLUSH_REASON, OUTBOUND_FLUSH_TRIGGER } from '../messaging/outbound/reasons.ts';
@@ -211,7 +211,7 @@ export function createBncrInboundHandlersComponent(runtime: {
   defaultAdminAgentId: Parameters<typeof createBncrInboundHandlers>[0]['defaultAdminAgentId'];
   defaultPublicAgentId: Parameters<typeof createBncrInboundHandlers>[0]['defaultPublicAgentId'];
   sceneRegistry: Parameters<typeof createBncrInboundHandlers>[0]['sceneRegistry'];
-  groupHistories: BncrGroupHistoryMap;
+  conversationHistories: BncrConversationHistoryMap;
   outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlers
@@ -257,7 +257,7 @@ export function createBncrInboundHandlersComponent(runtime: {
     defaultAdminAgentId: runtime.defaultAdminAgentId,
     defaultPublicAgentId: runtime.defaultPublicAgentId,
     sceneRegistry: runtime.sceneRegistry,
-    groupHistories: runtime.groupHistories,
+    conversationHistories: runtime.conversationHistories,
     outboundReplayCache: runtime.outboundReplayCache,
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     formatDisplayScope,
@@ -277,7 +277,7 @@ export function createBncrInboundHandlersComponent(runtime: {
       shouldDispatch,
       shouldAccumulate,
       sceneRegistry,
-      groupHistories,
+      conversationHistories,
       outboundReplayCache,
       defaultAdminAgentId,
       defaultPublicAgentId,
@@ -293,7 +293,7 @@ export function createBncrInboundHandlersComponent(runtime: {
         shouldDispatch,
         shouldAccumulate,
         sceneRegistry,
-        groupHistories,
+        conversationHistories,
         outboundReplayCache,
         defaultAdminAgentId,
         defaultPublicAgentId,

package/src/plugin/channel-runtime-builders-delivery.ts

@@ -1,6 +1,6 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
 import type { BncrRoute, OutboxEntry } from '../core/types.ts';
-import type { BncrGroupHistoryMap } from '../messaging/inbound/group-history.ts';
+import type { BncrConversationHistoryMap } from '../messaging/inbound/conversation-history.ts';
 import type { BncrOutboundReplayCache } from '../messaging/inbound/outbound-replay-cache.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
@@ -107,7 +107,7 @@ export function buildBncrInboundSurfaceRuntime(deps: {
   }) => string;
   defaultPublicAgentId: () => string;
   sceneRegistry: Map<string, BncrSceneRecord>;
-  groupHistories: BncrGroupHistoryMap;
+  conversationHistories: BncrConversationHistoryMap;
   outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: (args: {
     parsed: ReturnType<typeof parseBncrInboundParams>;

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

@@ -12,6 +12,8 @@ export const MAX_SESSION_ROUTE_ENTRIES = 1000;
 export const MAX_ACCOUNT_ACTIVITY_ENTRIES = 1000;
 export const PUSH_DRAIN_INTERVAL_MS = 500;
 export const PUSH_DRAIN_ACCOUNT_BUDGET = 5;
+export const HISTORY_SHARD_WORKER_INTERVAL_MS = 1_000;
+export const HISTORY_SHARD_WORKER_BATCH_LIMIT = 5;
 export const PUSH_DRAIN_ACCOUNT_TIME_BUDGET_MS = 2_000;
 export const PUSH_DRAIN_EXCEPTION_RETRY_LIMIT = 3;
 export const PUSH_DRAIN_EXCEPTION_RETRY_DELAY_MS = 1_000;

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

@@ -73,29 +73,30 @@ export type BncrSceneRecord = {
   lastSeenAt: number;
 };
 
-export type BncrPersistedGroupHistoryEntry = {
+export type BncrPersistedConversationHistoryEntry = {
   sender: string;
   senderId?: string;
+  role?: 'user' | 'assistant' | 'system';
   body: string;
   timestamp?: number;
   messageId?: string;
-  media?: BncrPersistedGroupHistoryMediaEntry[];
+  media?: BncrPersistedConversationHistoryMediaEntry[];
 };
 
-export type BncrPersistedGroupHistoryMediaEntry = {
+export type BncrPersistedConversationHistoryMediaEntry = {
   path?: string;
   contentType?: string;
   kind?: 'image' | 'video' | 'audio' | 'document' | 'unknown';
   messageId?: string;
 };
 
-export type BncrPersistedGroupHistoryBucket = {
+export type BncrPersistedConversationHistoryBucket = {
   key: string;
-  entries: BncrPersistedGroupHistoryEntry[];
+  entries: BncrPersistedConversationHistoryEntry[];
 };
 
 export type BncrPersistedOutboundReplayEntry = BncrOutboundReplayEntry;
-export type BncrPersistedOutboundReplayMediaEntry = BncrPersistedGroupHistoryMediaEntry;
+export type BncrPersistedOutboundReplayMediaEntry = BncrPersistedConversationHistoryMediaEntry;
 export type BncrPersistedOutboundReplayBucket = {
   key: string;
   entries: BncrPersistedOutboundReplayEntry[];
@@ -186,7 +187,8 @@ export type PersistedState = {
   deadLetter: OutboxEntry[];
   sessionRoutes: BncrPersistedSessionRoute[];
   sceneRegistry?: BncrSceneRecord[];
-  groupHistories?: BncrPersistedGroupHistoryBucket[];
+  conversationHistories?: BncrPersistedConversationHistoryBucket[];
+  groupHistories?: BncrPersistedConversationHistoryBucket[];
   outboundReplayCache?: BncrPersistedOutboundReplayBucket[];
   lastSessionByAccount?: BncrPersistedLastSession[];
   lastActivityByAccount?: BncrPersistedAccountTimestamp[];

package/src/plugin/inbound-acceptance.ts

@@ -66,30 +66,12 @@ function shouldDispatchForScene(args: {
 }
 
 function shouldAccumulateForScene(args: {
-  parsed: ReturnType<typeof parseBncrInboundParams>;
+  shouldDispatch: boolean;
   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';
-  // 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;
+  if (args.shouldDispatch) return true;
+  const mode = args.admission.scene.groupReplyMode || 'admin';
+  return mode === 'mention' || mode === 'hybrid';
 }
 
 export async function prepareBncrInboundAcceptance(args: {
@@ -206,6 +188,9 @@ export async function prepareBncrInboundAcceptance(args: {
     resolveAgentRoute: args.resolveAgentRoute,
   });
 
+  const shouldDispatch = shouldDispatchForScene({ parsed, admission, cfg });
+  const shouldAccumulate = shouldAccumulateForScene({ shouldDispatch, admission });
+
   return {
     ok: true as const,
     accountId,
@@ -213,8 +198,8 @@ export async function prepareBncrInboundAcceptance(args: {
     inboundText,
     hasMedia: Boolean(mediaBase64 || mediaPathFromTransfer),
     resolvedAgentId: admission.agentId,
-    shouldDispatch: shouldDispatchForScene({ parsed, admission, cfg }),
-    shouldAccumulate: shouldAccumulateForScene({ parsed, admission, cfg }),
+    shouldDispatch,
+    shouldAccumulate,
     dispatchBy: resolveDispatchBy({ parsed, admission, cfg }),
   };
 }