@xmoxmo/bncr 0.6.1 → 0.6.2

package/src/messaging/inbound/dispatch.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_GROUP_HISTORY_LIMIT } from 'openclaw/plugin-sdk/reply-history';
+import { DEFAULT_GROUP_HISTORY_LIMIT as DEFAULT_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';
@@ -10,6 +10,15 @@ import type {
   BncrInboundLogger,
   BncrRememberSessionRoute,
 } from './contracts.ts';
+import {
+  type BncrConversationHistoryMap,
+  type BncrHistoryEntry,
+  buildBncrConversationHistoryKey,
+  clearBncrPendingConversationHistory,
+  readBncrPendingConversationHistorySnapshot,
+  recordBncrPendingConversationMedia,
+  recordBncrPendingConversationText,
+} from './conversation-history.ts';
 import {
   assertInboundMediaBase64Size,
   decodeInboundMediaBase64,
@@ -18,18 +27,8 @@ import {
   prepareBncrInboundDispatch,
   resolveBncrInboundConversation,
 } from './dispatch-prep.ts';
-import {
-  type BncrGroupHistoryMap,
-  type BncrHistoryEntry,
-  buildBncrGroupHistoryKey,
-  clearBncrPendingGroupHistory,
-  readBncrPendingGroupHistorySnapshot,
-  recordBncrPendingGroupMedia,
-  recordBncrPendingGroupText,
-} from './group-history.ts';
 import {
   type BncrOutboundReplayCache,
-  type BncrOutboundReplayEntry,
   clearBncrOutboundReplay,
   readBncrOutboundReplaySnapshot,
 } from './outbound-replay-cache.ts';
@@ -53,7 +52,7 @@ export async function dispatchBncrInbound(params: {
   shouldAccumulate?: boolean;
   resolvedAgentId?: string;
   sceneRegistry: Map<string, BncrSceneRecord>;
-  groupHistories: BncrGroupHistoryMap;
+  conversationHistories: BncrConversationHistoryMap;
   outboundReplayCache?: BncrOutboundReplayCache;
   defaultAdminAgentId: string;
   defaultPublicAgentId: string;
@@ -74,7 +73,7 @@ export async function dispatchBncrInbound(params: {
     shouldAccumulate = initialShouldDispatch,
     resolvedAgentId,
     sceneRegistry = new Map(),
-    groupHistories = new Map(),
+    conversationHistories = new Map(),
     outboundReplayCache = new Map(),
     defaultAdminAgentId,
     defaultPublicAgentId,
@@ -145,31 +144,29 @@ export async function dispatchBncrInbound(params: {
     );
   }
   const sceneHistoryLimit =
-    parsed.peer.kind === 'group'
-      ? (sceneRegistry.get(buildSceneKey(parsed))?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT)
-      : DEFAULT_GROUP_HISTORY_LIMIT;
+    sceneRegistry.get(buildSceneKey(parsed))?.historyLimit ?? DEFAULT_HISTORY_LIMIT;
   const resolvedHistoryLimit =
     typeof sceneHistoryLimit === 'number' &&
     Number.isFinite(sceneHistoryLimit) &&
     sceneHistoryLimit >= 0
       ? Math.floor(sceneHistoryLimit)
-      : DEFAULT_GROUP_HISTORY_LIMIT;
+      : DEFAULT_HISTORY_LIMIT;
 
   let silentHistoryFlush = false;
   let pendingHistoryEntries: BncrHistoryEntry[] = [];
-  if (!shouldDispatch && shouldAccumulate) {
-    const historyKey = buildBncrGroupHistoryKey(parsed);
+  if (shouldAccumulate) {
+    const historyKey = buildBncrConversationHistoryKey(parsed);
     // Record the message first so overflow context includes it
-    recordBncrPendingGroupText({
-      historyMap: groupHistories,
+    recordBncrPendingConversationText({
+      historyMap: conversationHistories,
       parsed,
       senderDisplayName,
       senderId: senderIdForContext,
       bodyText: rawBody,
       historyLimit: resolvedHistoryLimit,
     });
-    await recordBncrPendingGroupMedia({
-      historyMap: groupHistories,
+    await recordBncrPendingConversationMedia({
+      historyMap: conversationHistories,
       parsed,
       senderDisplayName,
       senderId: senderIdForContext,
@@ -178,48 +175,35 @@ export async function dispatchBncrInbound(params: {
       mediaContentType: mediaContentType || mimeType,
       historyLimit: resolvedHistoryLimit,
     });
-    if (historyKey && parsed.peer.kind === 'group') {
-      const entries = groupHistories.get(historyKey);
+    if (historyKey) {
+      const entries = conversationHistories.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;
+          shouldDispatch = true;
         }
       }
     }
   }
 
-  if (shouldDispatch && !silentHistoryFlush) {
-    pendingHistoryEntries = readBncrPendingGroupHistorySnapshot({
-      historyMap: groupHistories,
+  if (shouldDispatch) {
+    pendingHistoryEntries = readBncrPendingConversationHistorySnapshot({
+      historyMap: conversationHistories,
       parsed,
       historyLimit: resolvedHistoryLimit,
     });
     if (pendingHistoryEntries.length > 0) {
-      clearBncrPendingGroupHistory({
-        historyMap: groupHistories,
+      clearBncrPendingConversationHistory({
+        historyMap: conversationHistories,
         parsed,
         historyLimit: resolvedHistoryLimit,
       });
     }
-  }
-
-  let outboundReplayEntries: BncrOutboundReplayEntry[] = [];
-  if (shouldDispatch && !silentHistoryFlush) {
-    outboundReplayEntries = readBncrOutboundReplaySnapshot({
+    const legacyOutboundEntries = readBncrOutboundReplaySnapshot({
       cache: outboundReplayCache,
+      conversationHistories,
       parsed,
       accountId,
       excludeMessageId: msgId,
@@ -229,6 +213,48 @@ export async function dispatchBncrInbound(params: {
       parsed,
       accountId,
     });
+    const knownMessageIds = new Set(
+      pendingHistoryEntries
+        .map((entry) => entry.messageId)
+        .filter((messageId): messageId is string => Boolean(messageId)),
+    );
+    for (const entry of legacyOutboundEntries) {
+      if (entry.messageId && knownMessageIds.has(entry.messageId)) continue;
+      if (entry.messageId) knownMessageIds.add(entry.messageId);
+      pendingHistoryEntries.push({
+        sender: entry.sender,
+        ...(entry.senderId ? { senderId: entry.senderId } : {}),
+        body: entry.body,
+        ...(typeof entry.timestamp === 'number' ? { timestamp: entry.timestamp } : {}),
+        ...(entry.messageId ? { messageId: entry.messageId } : {}),
+        role: 'assistant',
+        ...(Array.isArray(entry.media)
+          ? {
+              media: entry.media.map((item) => ({
+                path: item.path,
+                contentType: item.contentType,
+                kind: item.kind,
+                messageId: item.messageId,
+              })),
+            }
+          : {}),
+      });
+    }
+    pendingHistoryEntries.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+    if (resolvedHistoryLimit > 0 && pendingHistoryEntries.length > resolvedHistoryLimit) {
+      const currentMessageId = String(msgId || '').trim();
+      const currentEntry = currentMessageId
+        ? pendingHistoryEntries.find((entry) => entry.messageId === currentMessageId)
+        : undefined;
+      pendingHistoryEntries = pendingHistoryEntries.slice(-resolvedHistoryLimit);
+      if (currentEntry && !pendingHistoryEntries.includes(currentEntry)) {
+        const withoutCurrent = pendingHistoryEntries.filter((entry) => entry !== currentEntry);
+        pendingHistoryEntries = [
+          ...withoutCurrent.slice(-(resolvedHistoryLimit - 1)),
+          currentEntry,
+        ];
+      }
+    }
   }
 
   const ctxPayload = await buildBncrInboundTurnContext({
@@ -246,11 +272,10 @@ export async function dispatchBncrInbound(params: {
     historyLimit: resolvedHistoryLimit,
     resolution,
     prepared,
-    groupHistories,
+    conversationHistories,
     shouldDispatch,
     silentHistoryFlush,
     pendingHistoryEntries,
-    outboundReplayEntries,
   });
 
   await runBncrInboundReplyDispatch({

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

@@ -55,7 +55,7 @@ const BNCR_HELP_TEXT = [
   '  • /bncr list pending [filters...]',
   '  • /bncr list scenes [filters...]',
   '',
-  '📋 Group history',
+  '📋 Conversation history',
   '  • /bncr history-help',
   '  • /bncr history-limit [<number>|clear] [<SceneId>]',
   '  • /bncr history-force on|off|clear [<SceneId>]',

package/src/messaging/inbound/outbound-replay-cache.ts

@@ -4,6 +4,12 @@ import type {
   BncrOutboundReplayStatus,
   OutboxEntry,
 } from '../../core/types.ts';
+import {
+  type BncrConversationHistoryMap,
+  buildBncrConversationHistoryKey,
+  buildBncrConversationHistoryKeyFromRoute,
+  recordBncrBotReply,
+} from './conversation-history.ts';
 import type { ParsedInbound } from './dispatch-prep.ts';
 
 export type {
@@ -152,6 +158,8 @@ function isAppMsg(type: string | undefined, msg: string): boolean {
 
 export function recordBncrOutboundReplay(args: {
   cache: BncrOutboundReplayCache;
+  conversationHistories?: BncrConversationHistoryMap;
+  historyLimit?: number;
   entry: OutboxEntry;
   sender: string;
   senderId?: string;
@@ -179,6 +187,38 @@ export function recordBncrOutboundReplay(args: {
     ? buildMediaBody('document')
     : normalizeTextBody(rawBody) || (isMedia ? buildMediaBody(kind) : '');
   if (!body) return;
+  const recordTimestamp = args.entry.lastPushAt ?? Date.now();
+
+  if (args.conversationHistories) {
+    const historyKey = buildBncrConversationHistoryKeyFromRoute({
+      platform: args.entry.route?.platform,
+      groupId: args.entry.route?.groupId,
+      userId: args.entry.route?.userId,
+    });
+    if (historyKey) {
+      recordBncrBotReply({
+        historyMap: args.conversationHistories,
+        historyKey,
+        sender: args.sender,
+        senderId: args.senderId,
+        body,
+        timestamp: recordTimestamp,
+        messageId: args.entry.messageId,
+        historyLimit: args.historyLimit,
+        ...(mediaUrl
+          ? {
+              media: [
+                {
+                  path: mediaUrl,
+                  kind,
+                  messageId: args.entry.messageId,
+                },
+              ],
+            }
+          : {}),
+      });
+    }
+  }
 
   recordOutboundReplayEntry({
     cache: args.cache,
@@ -187,7 +227,7 @@ export function recordBncrOutboundReplay(args: {
       sender: args.sender,
       ...(args.senderId ? { senderId: args.senderId } : {}),
       body,
-      timestamp: Date.now(),
+      timestamp: recordTimestamp,
       messageId: args.entry.messageId,
       accountId: args.entry.accountId,
       sessionKey: args.entry.sessionKey,
@@ -213,16 +253,52 @@ export function recordBncrOutboundReplay(args: {
 
 export function readBncrOutboundReplaySnapshot(args: {
   cache: BncrOutboundReplayCache;
+  conversationHistories?: BncrConversationHistoryMap;
   parsed: ParsedInbound;
   accountId: string;
   excludeMessageId?: string | null;
 }): BncrOutboundReplayEntry[] {
-  const cacheKey = buildBncrOutboundReplayKey(args.parsed, args.accountId);
-  if (!cacheKey) return [];
   const excludedMessageId = String(args.excludeMessageId || '').trim();
-  return (args.cache.get(cacheKey) || [])
-    .filter((entry) => !excludedMessageId || entry.messageId !== excludedMessageId)
-    .map(cloneBncrOutboundReplayEntry);
+  const cacheKey = buildBncrOutboundReplayKey(args.parsed, args.accountId);
+  const legacyEntries = cacheKey
+    ? (args.cache.get(cacheKey) || [])
+        .filter((entry) => !excludedMessageId || entry.messageId !== excludedMessageId)
+        .map(cloneBncrOutboundReplayEntry)
+    : [];
+  if (!args.conversationHistories) return legacyEntries;
+
+  const historyKey = buildBncrConversationHistoryKey(args.parsed);
+  const historyEntries = historyKey
+    ? (args.conversationHistories.get(historyKey) || [])
+        .filter((entry) => entry.role === 'assistant')
+        .filter((entry) => !excludedMessageId || entry.messageId !== excludedMessageId)
+        .map((entry) => ({
+          sender: entry.sender,
+          ...(entry.senderId ? { senderId: entry.senderId } : {}),
+          body: entry.body,
+          ...(typeof entry.timestamp === 'number' ? { timestamp: entry.timestamp } : {}),
+          ...(entry.messageId ? { messageId: entry.messageId } : {}),
+          ...(Array.isArray(entry.media)
+            ? {
+                media: entry.media.map((item) => ({
+                  path: item.path,
+                  contentType: item.contentType,
+                  kind: item.kind,
+                  messageId: item.messageId,
+                })),
+              }
+            : {}),
+        }))
+    : [];
+  const knownMessageIds = new Set(
+    historyEntries
+      .map((entry) => entry.messageId)
+      .filter((messageId): messageId is string => Boolean(messageId)),
+  );
+  return [
+    ...historyEntries,
+    ...legacyEntries.filter((entry) => !entry.messageId || !knownMessageIds.has(entry.messageId)),
+  ].sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
 }
 
 export function clearBncrOutboundReplay(args: {

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

@@ -49,7 +49,7 @@ 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>]',
@@ -88,6 +88,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) {
@@ -340,8 +356,7 @@ function formatSceneDetailsLine(scene: BncrSceneRecord): string {
   const historyLimitVal = scene.historyLimit;
   const historyForceVal = scene.historyForce;
   const hasNonDefaultHistory =
-    scene.kind === 'group' &&
-    ((typeof historyLimitVal === 'number' && historyLimitVal !== 50) || historyForceVal === false);
+    (typeof historyLimitVal === 'number' && historyLimitVal !== 50) || historyForceVal === false;
   const historyPart = hasNonDefaultHistory
     ? ` historyLimit=${historyLimitVal ?? 50} autoFlush=${historyForceVal !== false ? 'on' : 'off'}`
     : '';
@@ -475,7 +490,7 @@ 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.' };
     }
@@ -485,9 +500,9 @@ export function executeSceneAdminCommand(args: {
   }
 
   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}` };
@@ -520,7 +535,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 +549,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-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,6 +43,8 @@ export function createBncrBridgeOutboxFacade(runtime: {
   deadLetterSinceStartByAccount: Map<string, number>;
   lastOutboundByAccount: Map<string, number>;
   outboundReplayCache?: BncrOutboundReplayCache;
+  conversationHistories?: BncrConversationHistoryMap;
+  resolveOutboundHistoryLimit?: (entry: OutboxEntry) => number;
   resolveOutboundSender?: (entry: OutboxEntry) => { sender: string; senderId?: string };
   isOutboundAckRequired?: (accountId: string) => boolean;
   scheduleSave: () => void;
@@ -64,6 +67,12 @@ export function createBncrBridgeOutboxFacade(runtime: {
     };
     recordBncrOutboundReplay({
       cache: runtime.outboundReplayCache,
+      ...(runtime.conversationHistories
+        ? { conversationHistories: runtime.conversationHistories }
+        : {}),
+      ...(runtime.resolveOutboundHistoryLimit
+        ? { historyLimit: runtime.resolveOutboundHistoryLimit(entry) }
+        : {}),
       entry,
       sender: senderInfo.sender,
       senderId: senderInfo.senderId,