@xmoxmo/bncr 0.6.0 → 0.6.2

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

@@ -0,0 +1,312 @@
+import type {
+  BncrOutboundReplayEntry,
+  BncrOutboundReplayMediaEntry,
+  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 {
+  BncrOutboundReplayEntry,
+  BncrOutboundReplayMediaEntry,
+  BncrOutboundReplayStatus,
+} from '../../core/types.ts';
+
+export type BncrOutboundReplayCache = Map<string, BncrOutboundReplayEntry[]>;
+
+function normalizeTextBody(value: string): string {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function cloneMediaEntry(entry: BncrOutboundReplayMediaEntry): BncrOutboundReplayMediaEntry {
+  return {
+    ...(entry?.path ? { path: entry.path } : {}),
+    ...(entry?.contentType ? { contentType: entry.contentType } : {}),
+    ...(entry?.kind ? { kind: entry.kind } : {}),
+    ...(entry?.messageId ? { messageId: entry.messageId } : {}),
+  };
+}
+
+export function cloneBncrOutboundReplayEntry(
+  entry: BncrOutboundReplayEntry,
+): BncrOutboundReplayEntry {
+  return {
+    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) => cloneMediaEntry(item)) }
+      : {}),
+    ...(entry.accountId ? { accountId: entry.accountId } : {}),
+    ...(entry.sessionKey ? { sessionKey: entry.sessionKey } : {}),
+    ...(entry.route ? { route: { ...entry.route } } : {}),
+    ...(entry.type ? { type: entry.type } : {}),
+    ...(entry.mediaUrl ? { mediaUrl: entry.mediaUrl } : {}),
+    ...(typeof entry.createdAt === 'number' ? { createdAt: entry.createdAt } : {}),
+    ...(entry.status ? { status: entry.status } : {}),
+  };
+}
+
+export function buildBncrOutboundReplayKeyFromRoute(args: {
+  accountId?: string;
+  platform?: string;
+  groupId?: string;
+  userId?: string;
+}): string | null {
+  const accountId = String(args.accountId || '').trim() || 'default';
+  const platform = String(args.platform || '').trim();
+  const groupId = String(args.groupId || '0').trim() || '0';
+  const userId = String(args.userId || '0').trim() || '0';
+  if (!platform) return null;
+  if (groupId !== '0') return `${accountId}:${platform}:${groupId}`;
+  if (userId !== '0') return `${accountId}:${platform}:${userId}`;
+  return null;
+}
+
+export function buildBncrOutboundReplayKey(
+  parsed: ParsedInbound,
+  accountId: string,
+): string | null {
+  return buildBncrOutboundReplayKeyFromRoute({
+    accountId,
+    platform: parsed.platform,
+    groupId: parsed.groupId,
+    userId: parsed.userId,
+  });
+}
+
+function recordOutboundReplayEntry(args: {
+  cache: BncrOutboundReplayCache;
+  cacheKey: string;
+  entry: BncrOutboundReplayEntry;
+}) {
+  const msgId = String(args.entry.messageId || '').trim();
+  const existing = args.cache.get(args.cacheKey) || [];
+  if (msgId && existing.some((entry) => entry.messageId === msgId)) return;
+
+  const next = [...existing, cloneBncrOutboundReplayEntry(args.entry)].sort(
+    (a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0),
+  );
+
+  if (args.cache.has(args.cacheKey)) {
+    args.cache.delete(args.cacheKey);
+  }
+  args.cache.set(args.cacheKey, next);
+}
+
+function inferMediaKind(args: {
+  msgType?: string;
+  contentType?: string;
+  mediaUrl?: string;
+  type?: string;
+}): NonNullable<BncrOutboundReplayMediaEntry['kind']> {
+  const msgType = String(args.msgType || '')
+    .trim()
+    .toLowerCase();
+  const type = String(args.type || '')
+    .trim()
+    .toLowerCase();
+  const contentType = String(args.contentType || '')
+    .trim()
+    .toLowerCase();
+  const mediaUrl = String(args.mediaUrl || '')
+    .trim()
+    .toLowerCase();
+
+  if (msgType === 'image' || type === 'image' || contentType.startsWith('image/')) return 'image';
+  if (msgType === 'video' || type === 'video' || contentType.startsWith('video/')) return 'video';
+  if (
+    msgType === 'audio' ||
+    msgType === 'voice' ||
+    type === 'audio' ||
+    type === 'voice' ||
+    contentType.startsWith('audio/')
+  ) {
+    return 'audio';
+  }
+  if (type === 'file' || type === 'document' || msgType === 'file' || msgType === 'document') {
+    return 'document';
+  }
+  if (/\.(png|jpe?g|gif|webp|bmp|svg)$/.test(mediaUrl)) return 'image';
+  if (/\.(mp4|mov|webm|mkv|avi)$/.test(mediaUrl)) return 'video';
+  if (/\.(mp3|ogg|oga|silk|amr|wav|m4a|aac|flac)$/.test(mediaUrl)) return 'audio';
+  if (contentType) return 'document';
+  return 'unknown';
+}
+
+function buildMediaBody(kind: NonNullable<BncrOutboundReplayMediaEntry['kind']>): string {
+  return `<media:${kind}>`;
+}
+
+function isAppMsg(type: string | undefined, msg: string): boolean {
+  return (
+    String(type || '')
+      .trim()
+      .toLowerCase() === 'appmsg' || /^<appmsg/i.test(msg)
+  );
+}
+
+export function recordBncrOutboundReplay(args: {
+  cache: BncrOutboundReplayCache;
+  conversationHistories?: BncrConversationHistoryMap;
+  historyLimit?: number;
+  entry: OutboxEntry;
+  sender: string;
+  senderId?: string;
+  status?: BncrOutboundReplayStatus;
+}) {
+  const cacheKey = buildBncrOutboundReplayKeyFromRoute({
+    accountId: args.entry.accountId,
+    platform: args.entry.route?.platform,
+    groupId: args.entry.route?.groupId,
+    userId: args.entry.route?.userId,
+  });
+  if (!cacheKey) return;
+
+  const message =
+    args.entry.payload?.message && typeof args.entry.payload.message === 'object'
+      ? (args.entry.payload.message as Record<string, unknown>)
+      : {};
+  const type = typeof message.type === 'string' ? message.type : undefined;
+  const rawBody = typeof message.msg === 'string' ? message.msg : '';
+  const mediaUrl = typeof message.mediaUrl === 'string' ? message.mediaUrl.trim() : '';
+  const kind = inferMediaKind({ type, mediaUrl });
+  const isMedia =
+    message.transferMode === 'media' || Boolean(mediaUrl) || (!!type && type !== 'text');
+  const body = isAppMsg(type, rawBody)
+    ? 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,
+    cacheKey,
+    entry: {
+      sender: args.sender,
+      ...(args.senderId ? { senderId: args.senderId } : {}),
+      body,
+      timestamp: recordTimestamp,
+      messageId: args.entry.messageId,
+      accountId: args.entry.accountId,
+      sessionKey: args.entry.sessionKey,
+      route: { ...args.entry.route },
+      ...(type ? { type } : {}),
+      ...(mediaUrl ? { mediaUrl } : {}),
+      createdAt: args.entry.createdAt,
+      ...(args.status ? { status: args.status } : {}),
+      ...(mediaUrl
+        ? {
+            media: [
+              {
+                path: mediaUrl,
+                kind,
+                messageId: args.entry.messageId,
+              },
+            ],
+          }
+        : {}),
+    },
+  });
+}
+
+export function readBncrOutboundReplaySnapshot(args: {
+  cache: BncrOutboundReplayCache;
+  conversationHistories?: BncrConversationHistoryMap;
+  parsed: ParsedInbound;
+  accountId: string;
+  excludeMessageId?: string | null;
+}): BncrOutboundReplayEntry[] {
+  const excludedMessageId = String(args.excludeMessageId || '').trim();
+  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: {
+  cache: BncrOutboundReplayCache;
+  parsed: ParsedInbound;
+  accountId: string;
+}) {
+  const cacheKey = buildBncrOutboundReplayKey(args.parsed, args.accountId);
+  if (!cacheKey) return;
+  args.cache.delete(cacheKey);
+}

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,19 +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 { 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;
@@ -73,7 +142,7 @@ export function buildBncrInboundTurnContext(args: {
   bridgeSenderName?: string;
   resolution: BncrInboundConversationResolution;
   prepared: BncrPreparedInboundSessionContext;
-  groupHistories: BncrGroupHistoryMap;
+  conversationHistories: BncrConversationHistoryMap;
   shouldDispatch: boolean;
   historyLimit?: number;
   silentHistoryFlush?: boolean;
@@ -99,10 +168,11 @@ export function buildBncrInboundTurnContext(args: {
     ? args.pendingHistoryEntries
     : [];
   const silentHistoryFlush = args.silentHistoryFlush === true;
+  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;
@@ -123,23 +193,38 @@ export function buildBncrInboundTurnContext(args: {
   const senderIsOwner = parsed.isAdmin === true || Boolean(ownerAllowFrom?.length);
   const senderIsAuthorized = senderIsOwner;
   const inboundHistory = undefined;
-  const pendingHistoryMedia = shouldDispatch
-    ? collectBncrHistoryMediaFromEntries({ entries: pendingHistoryEntries })
+  const contextMedia = shouldDispatch
+    ? collectBncrHistoryMediaFromEntries({ entries: contextEntries })
     : [];
-  const pendingHistoryContext = shouldDispatch
-    ? pendingHistoryEntries.map((entry) => ({
+  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,
@@ -155,7 +240,10 @@ export function buildBncrInboundTurnContext(args: {
     bridgeSenderName,
     senderIsOwner,
     senderIsAuthorized,
-    pendingHistoryContext,
+    conversationHistoryContext: structuredContextEntries,
+    participants,
+    isGroupChat,
+    groupSubject: parsed.groupName,
   });
   const promptVisibleContextFacts = buildBncrPromptVisibleContextFacts(structuredContextFacts);
   const supplementalUntrustedContext = [
@@ -176,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 && pendingHistoryEntries.length > 0
-      ? buildBncrGroupContextFromEntries({
-          api,
-          entries: pendingHistoryEntries,
-          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 = [...pendingHistoryMedia, ...currentTurnMedia];
+  const media = dedupeBncrTurnMedia([...contextMedia, ...currentTurnMedia]);
 
   return Promise.resolve(
     resolveBncrChannelInboundRuntime(api).buildContext({

package/src/plugin/ack-outbox-runtime-group.ts

@@ -105,6 +105,7 @@ export function createBncrAckOutboxRuntimeGroup(runtime: {
   setOutboxEntry: (messageId: string, entry: OutboxEntry) => void;
   resolveMessageAck: (messageId: string, result: 'acked' | 'timeout') => boolean;
   moveToDeadLetter: (entry: OutboxEntry, reason: string) => void;
+  markRecentOutboundAcked?: (entry: OutboxEntry) => void;
   recordAckTimeoutTelemetry: (accountId: string) => void;
   degradeOutboundCapability: (args: {
     accountId: string;
@@ -154,6 +155,7 @@ export function createBncrAckOutboxRuntimeGroup(runtime: {
       runtime.resolveMessageAck(messageId, result);
     },
     moveToDeadLetter: runtime.moveToDeadLetter,
+    markRecentOutboundAcked: runtime.markRecentOutboundAcked,
     logOutboxAckSummary: outboxAckLogs.logOutboxAckSummary,
   });