@xmoxmo/bncr 0.5.9 → 0.6.1

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

@@ -0,0 +1,236 @@
+import type {
+  BncrOutboundReplayEntry,
+  BncrOutboundReplayMediaEntry,
+  BncrOutboundReplayStatus,
+  OutboxEntry,
+} from '../../core/types.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;
+  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;
+
+  recordOutboundReplayEntry({
+    cache: args.cache,
+    cacheKey,
+    entry: {
+      sender: args.sender,
+      ...(args.senderId ? { senderId: args.senderId } : {}),
+      body,
+      timestamp: Date.now(),
+      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;
+  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);
+}
+
+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/turn-context.ts

@@ -20,6 +20,7 @@ import {
   buildBncrGroupContextFromEntries,
   collectBncrHistoryMediaFromEntries,
 } from './group-history.ts';
+import type { BncrOutboundReplayEntry } from './outbound-replay-cache.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 
 function parseSlashCommandName(body: string): string | undefined {
@@ -78,6 +79,7 @@ export function buildBncrInboundTurnContext(args: {
   historyLimit?: number;
   silentHistoryFlush?: boolean;
   pendingHistoryEntries?: readonly BncrHistoryEntry[];
+  outboundReplayEntries?: readonly BncrOutboundReplayEntry[];
 }): BncrInboundContextPayload | Promise<BncrInboundContextPayload> {
   const {
     api,
@@ -98,7 +100,13 @@ 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 flushSenderId = 'bncr-history-system';
   const flushSenderName = 'Bncr History System';
   const flushRawBody =
@@ -123,11 +131,11 @@ 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,
         sender: entry.sender,
         senderId: entry.senderId,
@@ -155,7 +163,7 @@ export function buildBncrInboundTurnContext(args: {
     bridgeSenderName,
     senderIsOwner,
     senderIsAuthorized,
-    pendingHistoryContext,
+    pendingHistoryContext: structuredContextEntries,
   });
   const promptVisibleContextFacts = buildBncrPromptVisibleContextFacts(structuredContextFacts);
   const supplementalUntrustedContext = [
@@ -177,10 +185,10 @@ export function buildBncrInboundTurnContext(args: {
   const wasMentioned = parsed.isBotMentioned === true || platformWantsReply;
   const isAuthorizedTextCommand = Boolean(ownerAllowFrom?.length);
   const bodyForAgent =
-    shouldDispatch && pendingHistoryEntries.length > 0
+    shouldDispatch && contextEntries.length > 0
       ? buildBncrGroupContextFromEntries({
           api,
-          entries: pendingHistoryEntries,
+          entries: contextEntries,
           channelLabel: resolution.canonicalTo,
           currentTimestamp: Date.now(),
           previousTimestamp: readBncrSessionUpdatedAt(api, {
@@ -199,7 +207,7 @@ export function buildBncrInboundTurnContext(args: {
     kind: item.kind,
     messageId: msgId ?? undefined,
   }));
-  const media = [...pendingHistoryMedia, ...currentTurnMedia];
+  const media = [...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,
   });
 

package/src/plugin/bridge-call.ts

@@ -0,0 +1,168 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrRecentOutboundEntry } from '../core/types.ts';
+import type { BncrStatusRuntimeSnapshot } from './channel-runtime-types.ts';
+
+export const BNCR_LOCAL_BRIDGE_METHODS = [
+  'bncr.methods',
+  'bncr.status.channel',
+  'bncr.status.account',
+  'bncr.status.headline',
+  'bncr.outbound.recent',
+  'bncr.diagnostics',
+  'bncr.deadLetter.inspect',
+  'bncr.deadLetter.prune',
+] as const;
+
+export type BncrBridgeCallDiagnosticsBridge = {
+  diagnostics: (args: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  deadLetterInspect: (args: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  deadLetterPrune: (args: Record<string, unknown>) => Promise<Record<string, unknown>>;
+};
+
+export type BncrBridgeCallBridge = {
+  call: (
+    method: string,
+    args: Record<string, unknown>,
+    accountId?: string,
+  ) => Promise<Record<string, unknown>>;
+};
+
+export type BncrBridgeCallRecentOutboundBridge = {
+  listRecentOutbound: (sessionKey: string) => BncrRecentOutboundEntry[];
+  listRecentOutboundByAccount: (accountId: string) => BncrRecentOutboundEntry[];
+};
+
+/**
+ * Runs a gateway-style handler with a captured respond callback so local
+ * diagnostics/dead-letter handlers can be exposed through the message tool.
+ */
+export async function invokeBncrBridgeGatewayHandler(
+  handler: (ctx: GatewayRequestHandlerOptions) => Promise<void>,
+  args: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  let ok = false;
+  let payload: unknown;
+  const ctx = {
+    params: args,
+    respond: (accepted: boolean, value: unknown) => {
+      ok = accepted;
+      payload = value;
+    },
+  } as unknown as GatewayRequestHandlerOptions;
+
+  await handler(ctx);
+
+  if (!ok) {
+    const message =
+      payload &&
+      typeof payload === 'object' &&
+      typeof (payload as { message?: unknown }).message === 'string'
+        ? (payload as { message: string }).message
+        : 'bridge handler rejected request';
+    throw new Error(message);
+  }
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw new Error('bridge handler returned an invalid payload');
+  }
+  return payload as Record<string, unknown>;
+}
+
+/**
+ * Local methods run inside the plugin process; any other method is forwarded
+ * dynamically to the OpenClawClient RPC bridge.
+ */
+export function createBncrBridgeCallBridge(runtime: {
+  defaultAccountId: string;
+  getStatusBridge: () => {
+    getChannelSummary: (
+      defaultAccountId: string,
+    ) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    getAccountRuntimeSnapshot: (accountId?: string) => BncrStatusRuntimeSnapshot;
+    getStatusHeadline: (accountId?: string) => string;
+  };
+  getDiagnosticsBridge: () => BncrBridgeCallDiagnosticsBridge;
+  getRecentOutboundBridge: () => BncrBridgeCallRecentOutboundBridge;
+  callClientRpc: (
+    method: string,
+    args: Record<string, unknown>,
+    accountId: string,
+  ) => Promise<Record<string, unknown>>;
+}): BncrBridgeCallBridge {
+  const resolveAccountId = (args: Record<string, unknown>, accountId?: string) => {
+    const argsAccountId = typeof args.accountId === 'string' ? args.accountId.trim() : '';
+    return accountId || argsAccountId || runtime.defaultAccountId;
+  };
+
+  const localHandlers: Record<
+    string,
+    (args: Record<string, unknown>, accountId: string) => Promise<Record<string, unknown>>
+  > = {
+    'bncr.methods': async (_args, accountId) => {
+      const localMethods = [...BNCR_LOCAL_BRIDGE_METHODS];
+      let clientMethods: string[] = [];
+      let clientError: string | null = null;
+      try {
+        const clientResult = await runtime.callClientRpc('bncr.methods', { accountId }, accountId);
+        const raw = (clientResult as { result?: { methods?: unknown } })?.result?.methods;
+        clientMethods = Array.isArray(raw)
+          ? raw.filter((item): item is string => typeof item === 'string')
+          : [];
+      } catch (error) {
+        clientError = error instanceof Error ? error.message : String(error);
+      }
+      return {
+        methods: [...new Set([...localMethods, ...clientMethods])],
+        ...(clientError ? { clientError } : {}),
+      };
+    },
+    'bncr.status.channel': async (_args, accountId) => ({
+      value: await runtime.getStatusBridge().getChannelSummary(accountId),
+    }),
+    'bncr.status.account': async (_args, accountId) => ({
+      value: runtime.getStatusBridge().getAccountRuntimeSnapshot(accountId),
+    }),
+    'bncr.status.headline': async (_args, accountId) => ({
+      value: runtime.getStatusBridge().getStatusHeadline(accountId),
+    }),
+    'bncr.outbound.recent': async (args, accountId) => {
+      const sessionKey = typeof args.sessionKey === 'string' ? args.sessionKey.trim() : '';
+      const rawLimit = typeof args.limit === 'number' ? args.limit : Number(args.limit);
+      const limit = Number.isFinite(rawLimit) ? Math.max(1, Math.floor(rawLimit)) : undefined;
+      const recentBridge = runtime.getRecentOutboundBridge();
+      const entries = sessionKey
+        ? recentBridge.listRecentOutbound(sessionKey)
+        : recentBridge.listRecentOutboundByAccount(accountId);
+      return {
+        accountId,
+        sessionKey: sessionKey || undefined,
+        limit,
+        total: entries.length,
+        entries: typeof limit === 'number' ? entries.slice(0, limit) : entries,
+        now: Date.now(),
+      };
+    },
+    'bncr.diagnostics': (args) => runtime.getDiagnosticsBridge().diagnostics(args),
+    'bncr.deadLetter.inspect': (args) => runtime.getDiagnosticsBridge().deadLetterInspect(args),
+    'bncr.deadLetter.prune': (args) => runtime.getDiagnosticsBridge().deadLetterPrune(args),
+  };
+
+  return {
+    call: async (method, args, accountId) => {
+      const normalizedMethod = String(method || '').trim();
+      if (!normalizedMethod) {
+        throw new Error('bridge method is required');
+      }
+      const normalizedArgs = args ?? {};
+      const resolvedAccountId = resolveAccountId(normalizedArgs, accountId);
+      const localHandler = localHandlers[normalizedMethod];
+      if (localHandler) {
+        return {
+          ok: true,
+          method: normalizedMethod,
+          result: await localHandler(normalizedArgs, resolvedAccountId),
+        };
+      }
+      return runtime.callClientRpc(normalizedMethod, normalizedArgs, resolvedAccountId);
+    },
+  };
+}

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

@@ -6,7 +6,12 @@ import {
   collectDueOutboxEntries,
 } from '../core/outbox-queue.ts';
 import { formatDisplayScope } from '../core/targets.ts';
-import type { OutboxEntry } from '../core/types.ts';
+import type { BncrRecentOutboundEntry, OutboxEntry } from '../core/types.ts';
+import {
+  type BncrOutboundReplayCache,
+  type BncrOutboundReplayEntry,
+  recordBncrOutboundReplay,
+} from '../messaging/inbound/outbound-replay-cache.ts';
 import {
   buildBncrOutboxFailureEntryPatch,
   buildBncrOutboxPushSuccessEntryPatch,
@@ -36,6 +41,9 @@ export function createBncrBridgeOutboxFacade(runtime: {
   lastPrePushGuardSkipReasonByAccount: Map<string, string>;
   deadLetterSinceStartByAccount: Map<string, number>;
   lastOutboundByAccount: Map<string, number>;
+  outboundReplayCache?: BncrOutboundReplayCache;
+  resolveOutboundSender?: (entry: OutboxEntry) => { sender: string; senderId?: string };
+  isOutboundAckRequired?: (accountId: string) => boolean;
   scheduleSave: () => void;
   flushPushQueueBestEffort: (args?: {
     accountId?: string;
@@ -48,6 +56,25 @@ export function createBncrBridgeOutboxFacade(runtime: {
   resolveMessageAck: (messageId: string, result?: 'acked' | 'timeout') => boolean;
   markActivity: (accountId: string, at?: number) => void;
 }) {
+  const recordOutboundMessage = (entry: OutboxEntry, status: 'pushed' | 'acked') => {
+    if (!runtime.outboundReplayCache) return;
+    const senderInfo = runtime.resolveOutboundSender?.(entry) ?? {
+      sender: entry.accountId,
+      senderId: entry.accountId,
+    };
+    recordBncrOutboundReplay({
+      cache: runtime.outboundReplayCache,
+      entry,
+      sender: senderInfo.sender,
+      senderId: senderInfo.senderId,
+      status,
+    });
+  };
+
+  const markRecentOutboundAcked = (entry: OutboxEntry) => {
+    recordOutboundMessage(entry, 'acked');
+  };
+
   const recordOutboxPrePushFailure = (args: {
     entry: OutboxEntry;
     lastError: string;
@@ -120,6 +147,9 @@ export function createBncrBridgeOutboxFacade(runtime: {
     });
     Object.assign(args.entry, nextEntry);
     runtime.outbox.set(nextEntry.messageId, args.entry);
+    if (runtime.isOutboundAckRequired?.(args.entry.accountId) === false) {
+      recordOutboundMessage(args.entry, 'pushed');
+    }
     runtime.lastOutboundByAccount.set(nextEntry.accountId, pushedAt);
     runtime.markActivity(nextEntry.accountId, pushedAt);
     runtime.scheduleSave();
@@ -181,6 +211,41 @@ export function createBncrBridgeOutboxFacade(runtime: {
     return result.duePayloads;
   };
 
+  const buildRecentOutboundEntry = (
+    cacheKey: string,
+    replay: BncrOutboundReplayEntry,
+  ): BncrRecentOutboundEntry => {
+    const keyParts = cacheKey.split(':');
+    const accountId = replay.accountId || keyParts[0] || '';
+    const route = replay.route
+      ? replay.route
+      : keyParts[1] && keyParts[2]
+        ? keyParts[2].startsWith('-')
+          ? { platform: keyParts[1], groupId: keyParts[2], userId: '0' }
+          : { platform: keyParts[1], groupId: '0', userId: keyParts[2] }
+        : { platform: '', groupId: '0', userId: '0' };
+    return {
+      messageId: replay.messageId || '',
+      accountId,
+      sessionKey: replay.sessionKey || '',
+      route,
+      ...(replay.type ? { type: replay.type } : {}),
+      ...(replay.type ? { kind: replay.type } : {}),
+      text: replay.body,
+      ...(replay.mediaUrl ? { mediaUrl: replay.mediaUrl } : {}),
+      createdAt: replay.createdAt ?? replay.timestamp ?? runtime.now(),
+      ...(replay.timestamp ? { lastPushAt: replay.timestamp } : {}),
+      status: replay.status === 'acked' ? 'acked' : 'pushed',
+    };
+  };
+
+  const listReplayEntries = () => {
+    if (!runtime.outboundReplayCache) return [];
+    return Array.from(runtime.outboundReplayCache.entries()).flatMap(([cacheKey, entries]) =>
+      entries.map((entry) => buildRecentOutboundEntry(cacheKey, entry)),
+    );
+  };
+
   return {
     recordOutboxPrePushFailure,
     recordPrePushGuardSkip,
@@ -190,5 +255,18 @@ export function createBncrBridgeOutboxFacade(runtime: {
     enqueueOutbound,
     moveToDeadLetter,
     collectDue,
+    listRecentOutbound: (sessionKey: string) => {
+      const normalized = runtime.asString(sessionKey || '').trim();
+      return listReplayEntries()
+        .filter((entry) => entry.sessionKey === normalized)
+        .sort((a, b) => b.createdAt - a.createdAt);
+    },
+    listRecentOutboundByAccount: (accountId: string) => {
+      const normalized = runtime.normalizeAccountId(accountId);
+      return listReplayEntries()
+        .filter((entry) => entry.accountId === normalized)
+        .sort((a, b) => b.createdAt - a.createdAt);
+    },
+    markRecentOutboundAcked,
   };
 }

package/src/plugin/channel-components.ts

@@ -6,6 +6,7 @@ import type { BncrRoute } from '../core/types.ts';
 import type { BncrInboundParamsInput } from '../messaging/inbound/contracts.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';
 import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
@@ -211,6 +212,7 @@ export function createBncrInboundHandlersComponent(runtime: {
   defaultPublicAgentId: Parameters<typeof createBncrInboundHandlers>[0]['defaultPublicAgentId'];
   sceneRegistry: Parameters<typeof createBncrInboundHandlers>[0]['sceneRegistry'];
   groupHistories: BncrGroupHistoryMap;
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlers
   >[0]['prepareInboundAcceptance'];
@@ -256,6 +258,7 @@ export function createBncrInboundHandlersComponent(runtime: {
     defaultPublicAgentId: runtime.defaultPublicAgentId,
     sceneRegistry: runtime.sceneRegistry,
     groupHistories: runtime.groupHistories,
+    outboundReplayCache: runtime.outboundReplayCache,
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     formatDisplayScope,
     logInboundSummary: runtime.logInboundSummary,
@@ -275,6 +278,7 @@ export function createBncrInboundHandlersComponent(runtime: {
       shouldAccumulate,
       sceneRegistry,
       groupHistories,
+      outboundReplayCache,
       defaultAdminAgentId,
       defaultPublicAgentId,
       now,
@@ -290,6 +294,7 @@ export function createBncrInboundHandlersComponent(runtime: {
         shouldAccumulate,
         sceneRegistry,
         groupHistories,
+        outboundReplayCache,
         defaultAdminAgentId,
         defaultPublicAgentId,
         now,