@xmoxmo/bncr 0.2.5 → 0.2.7

package/src/messaging/inbound/gate.ts

@@ -1,6 +1,10 @@
 import { normalizeAccountId } from '../../core/accounts.ts';
 import { resolveBncrChannelPolicy } from '../../core/policy.ts';
 import { buildDisplayScopeCandidates } from '../../core/targets.ts';
+import {
+  defineOpenClawStableChannelIngressIdentity,
+  resolveOpenClawChannelMessageIngress,
+} from '../../openclaw/ingress-runtime.ts';
 
 export type BncrGateResult = { allowed: true } | { allowed: false; reason: string };
 
@@ -10,13 +14,40 @@ function asString(v: unknown, fallback = ''): string {
   return String(v);
 }
 
-function matchesAllowList(list: string[], candidates: string[]): boolean {
-  if (!list.length) return false;
-  const normalized = new Set(list.map((x) => asString(x).trim()).filter(Boolean));
-  return candidates.some((x) => normalized.has(asString(x).trim()));
+const bncrIngressIdentity = defineOpenClawStableChannelIngressIdentity({
+  key: 'displayScope',
+  kind: 'plugin:bncr-display-scope',
+  normalize: (value: string) => asString(value).trim() || null,
+  sensitivity: 'pii',
+  entryIdPrefix: 'bncr-allow',
+  aliases: [
+    {
+      key: 'routeKey',
+      kind: 'plugin:bncr-route-key',
+      normalize: (value: string) => asString(value).trim() || null,
+      sensitivity: 'pii',
+    },
+  ],
+});
+
+function gateReasonFromIngress(reasonCode?: string): string {
+  switch (reasonCode) {
+    case 'dm_policy_disabled':
+      return 'dm disabled';
+    case 'dm_policy_not_allowlisted':
+    case 'dm_policy_pairing_required':
+      return 'dm allowlist blocked';
+    case 'group_policy_disabled':
+      return 'group disabled';
+    case 'group_policy_not_allowlisted':
+    case 'group_policy_empty_allowlist':
+      return 'group allowlist blocked';
+    default:
+      return reasonCode || 'ingress blocked';
+  }
 }
 
-export function checkBncrMessageGate(params: {
+export async function checkBncrMessageGate(params: {
   parsed: any;
   cfg: any;
   account: { accountId: string; enabled?: boolean };
@@ -34,31 +65,40 @@ export function checkBncrMessageGate(params: {
   const route = parsed?.route;
   const isGroup = asString(route?.groupId || '0') !== '0';
 
-  if (!isGroup && policy.dmPolicy === 'disabled') {
-    return { allowed: false, reason: 'dm disabled' };
-  }
-
-  if (isGroup && policy.groupPolicy === 'disabled') {
-    return { allowed: false, reason: 'group disabled' };
-  }
-
   const candidates = buildDisplayScopeCandidates(route);
-
-  if (!isGroup && policy.dmPolicy === 'allowlist') {
-    if (!matchesAllowList(policy.allowFrom, candidates)) {
-      return { allowed: false, reason: 'dm allowlist blocked' };
-    }
-  }
-
-  if (isGroup && policy.groupPolicy === 'allowlist') {
-    if (!matchesAllowList(policy.groupAllowFrom, candidates)) {
-      return { allowed: false, reason: 'group allowlist blocked' };
-    }
-  }
+  const displayScope = candidates[0] || '';
+  const routeKey = candidates.find((candidate) => candidate !== displayScope) || displayScope;
 
   // requireMention 默认值为 false。
   // 设计目标：当它未来真正生效时，含义是“群消息只有在明确提到机器人时才允许进入处理链”。
   // 但当前 parse 层尚未稳定提取 mentions，上游客户端也未统一透传 mention 信号，
   // 因此现阶段即使配置为 true，也仍不做实际拦截，避免出现半实现状态。
-  return { allowed: true };
+  const resolved = await resolveOpenClawChannelMessageIngress({
+    channelId: 'bncr',
+    accountId,
+    identity: bncrIngressIdentity,
+    subject: {
+      stableId: displayScope,
+      aliases: { routeKey },
+    },
+    conversation: {
+      kind: isGroup ? 'group' : 'direct',
+      id: isGroup ? asString(route?.groupId) : asString(route?.userId || displayScope),
+    },
+    event: { kind: 'message', authMode: 'inbound', mayPair: !isGroup },
+    policy: {
+      dmPolicy: policy.dmPolicy,
+      groupPolicy: policy.groupPolicy,
+      groupAllowFromFallbackToAllowFrom: false,
+    },
+    allowFrom: policy.dmPolicy === 'open' ? ['*', ...policy.allowFrom] : policy.allowFrom,
+    groupAllowFrom: policy.groupAllowFrom,
+    accessGroups: cfg?.accessGroups,
+  });
+
+  if (resolved.ingress.admission === 'dispatch' || resolved.ingress.admission === 'observe') {
+    return { allowed: true };
+  }
+
+  return { allowed: false, reason: gateReasonFromIngress(resolved.ingress.reasonCode) };
 }

package/src/messaging/inbound/parse.ts

@@ -36,6 +36,10 @@ export function inboundDedupKey(params: {
 }
 
 export function resolveChatType(_route: BncrRoute): 'direct' | 'group' {
+  // Compatibility boundary: bncr currently records and dispatches all conversations as direct
+  // sessions even when the display scope contains a group id. Do not change this to true
+  // group semantics without updating session routing, reply target policy, and requireMention
+  // behavior together.
   return 'direct';
 }
 
@@ -45,6 +49,9 @@ export function parseBncrInboundParams(params: any) {
   const groupId = asString(params?.groupId || '0').trim() || '0';
   const userId = asString(params?.userId || '').trim();
   const sessionKeyfromroute = asString(params?.sessionKey || '').trim();
+  const providedOriginatingTo = asString(
+    params?.originatingTo || params?.providedOriginatingTo || params?.to || '',
+  ).trim() || undefined;
   const clientId = asString(params?.clientId || '').trim() || undefined;
 
   const route: BncrRoute = {
@@ -84,6 +91,7 @@ export function parseBncrInboundParams(params: any) {
     groupId,
     userId,
     sessionKeyfromroute,
+    providedOriginatingTo,
     clientId,
     route,
     text,

package/src/messaging/inbound/runtime-compat.ts

@@ -0,0 +1,39 @@
+import { emitBncrLogLine } from '../../core/logging.ts';
+
+type ChannelRuntimeCompat = {
+  buildContext: (...args: any[]) => any;
+  run: (...args: any[]) => Promise<any> | any;
+  runPreparedReply?: (...args: any[]) => Promise<any> | any;
+  dispatchReply?: (...args: any[]) => Promise<any> | any;
+};
+
+let warnedLegacyTurnRuntime = false;
+
+export function resolveBncrChannelInboundRuntime(api: any): ChannelRuntimeCompat {
+  const channelRuntime = api?.runtime?.channel;
+  const inboundRuntime = channelRuntime?.inbound;
+  if (inboundRuntime?.buildContext && inboundRuntime?.run) {
+    return inboundRuntime;
+  }
+
+  const legacyTurnRuntime = channelRuntime?.turn;
+  if (legacyTurnRuntime?.buildContext && legacyTurnRuntime?.run) {
+    if (!warnedLegacyTurnRuntime) {
+      warnedLegacyTurnRuntime = true;
+      emitBncrLogLine(
+        'warn',
+        '[bncr] using legacy runtime.channel.turn compatibility path; upgrade path prefers runtime.channel.inbound',
+      );
+    }
+    return {
+      buildContext: legacyTurnRuntime.buildContext,
+      run: legacyTurnRuntime.run,
+      runPreparedReply: legacyTurnRuntime.runPrepared,
+      dispatchReply: legacyTurnRuntime.dispatchAssembled ?? legacyTurnRuntime.runAssembled,
+    };
+  }
+
+  throw new Error(
+    'OpenClaw channel inbound runtime is unavailable: expected runtime.channel.inbound.* or legacy runtime.channel.turn.*',
+  );
+}

package/src/messaging/inbound/session-label.ts

@@ -0,0 +1,115 @@
+import { emitBncrLogLine } from '../../core/logging.ts';
+import {
+  recordBncrSessionMetaFromInbound,
+  updateBncrSessionStoreEntry,
+} from '../../openclaw/inbound-session-runtime.ts';
+
+type RecordInboundSessionFn = (args: any) => Promise<unknown> | unknown;
+
+export function buildBncrInboundSessionIdentityPatch(args: {
+  channelId: string;
+  accountId: string;
+  chatType: 'direct' | 'group';
+  displayTo: string;
+  senderId: string;
+}) {
+  const { channelId, accountId, chatType, displayTo, senderId } = args;
+  return {
+    label: displayTo,
+    channel: channelId,
+    chatType,
+    origin: {
+      label: displayTo,
+      provider: channelId,
+      surface: channelId,
+      chatType,
+      from: senderId,
+      to: displayTo,
+      accountId,
+    },
+    deliveryContext: {
+      channel: channelId,
+      to: displayTo,
+      accountId,
+    },
+    route: {
+      channel: channelId,
+      accountId,
+      target: { to: displayTo },
+    },
+    lastTo: displayTo,
+  };
+}
+
+function normalizeNonEmptyString(value: unknown): string | null {
+  const normalized = String(value ?? '').trim();
+  return normalized || null;
+}
+
+export async function correctBncrInboundSessionLabel(args: {
+  storePath: string;
+  sessionKey: string;
+  expectedLabel: string;
+}) {
+  const storePath = normalizeNonEmptyString(args.storePath);
+  const sessionKey = normalizeNonEmptyString(args.sessionKey);
+  const expectedLabel = normalizeNonEmptyString(args.expectedLabel);
+  if (!storePath || !sessionKey || !expectedLabel) return;
+
+  try {
+    await updateBncrSessionStoreEntry({
+      storePath,
+      sessionKey,
+      update: (entry: any) => {
+        if (entry?.label === expectedLabel) return null;
+        return { label: expectedLabel };
+      },
+    });
+  } catch (err) {
+    emitBncrLogLine('warn', `[bncr] inbound session label correction failed: ${String(err)}`);
+  }
+}
+
+export async function recordAndPatchBncrInboundSessionEntry(args: {
+  storePath: string;
+  sessionKey: string;
+  ctx?: Record<string, unknown>;
+  patch: Record<string, unknown>;
+}) {
+  const storePath = normalizeNonEmptyString(args.storePath);
+  const sessionKey = normalizeNonEmptyString(args.sessionKey);
+  if (!storePath || !sessionKey) return;
+
+  try {
+    if (args.ctx) {
+      await recordBncrSessionMetaFromInbound({
+        storePath,
+        sessionKey,
+        ctx: args.ctx as any,
+        createIfMissing: true,
+      });
+    }
+    await updateBncrSessionStoreEntry({
+      storePath,
+      sessionKey,
+      update: () => args.patch,
+    });
+  } catch (err) {
+    emitBncrLogLine('warn', `[bncr] inbound session patch failed: ${String(err)}`);
+  }
+}
+
+export function wrapBncrInboundRecordSessionLabelCorrection(args: {
+  recordInboundSession: RecordInboundSessionFn;
+  expectedLabel: string;
+}): RecordInboundSessionFn {
+  return async (recordArgs: any) => {
+    const result = await args.recordInboundSession(recordArgs);
+    await correctBncrInboundSessionLabel({
+      storePath: recordArgs?.storePath,
+      sessionKey: recordArgs?.sessionKey,
+      expectedLabel: args.expectedLabel,
+    });
+    return result;
+  };
+}

package/src/messaging/outbound/diagnostics.ts

@@ -119,15 +119,31 @@ export function buildOutboxAckDebugInfo(args: {
   connIds?: Iterable<string>;
   ownerConnId?: string;
   ownerClientId?: string;
+  sessionKey?: string;
+  to?: string;
+  ackStage?: string;
+  ackOutcome?: string;
+  reason?: string;
   kind?: string;
   event?: string;
+  ackTimeoutMs?: number;
+  adaptiveAckTimeoutEnabled?: boolean;
 }) {
   return {
     messageId: args.messageId,
     accountId: args.accountId,
+    ...(args.sessionKey ? { sessionKey: args.sessionKey } : {}),
+    ...(args.to ? { to: args.to } : {}),
     ...(args.kind ? { kind: args.kind } : {}),
     requireAck: args.requireAck,
     ackResult: args.ackResult,
+    ackStage: args.ackStage || 'message',
+    ackOutcome: args.ackOutcome || args.ackResult,
+    ...(args.reason ? { reason: args.reason } : {}),
+    ...(typeof args.ackTimeoutMs === 'number' ? { ackTimeoutMs: args.ackTimeoutMs } : {}),
+    ...(typeof args.adaptiveAckTimeoutEnabled === 'boolean'
+      ? { adaptiveAckTimeoutEnabled: args.adaptiveAckTimeoutEnabled }
+      : {}),
     onlineNow: args.onlineNow,
     recentInboundReachable: args.recentInboundReachable,
     ...(args.connIds ? { connIds: Array.from(args.connIds) } : {}),

package/src/messaging/outbound/durable-message-adapter.ts

@@ -0,0 +1,107 @@
+import { defineChannelMessageAdapter } from 'openclaw/plugin-sdk/channel-outbound';
+import type {
+  ChannelMessageAdapterShape,
+  ChannelMessageSendMediaContext,
+  ChannelMessageSendPayloadContext,
+  ChannelMessageSendResult,
+  ChannelMessageSendTextContext,
+} from 'openclaw/plugin-sdk/channel-outbound';
+
+import { buildFileTransferOutboxEntry, buildTextOutboxEntry } from '../../core/outbox-entry-builders.ts';
+import type { BncrRoute, OutboxEntry } from '../../core/types.ts';
+import { buildBncrDurableQueuedResult } from './durable-queue-adapter.ts';
+
+export type BncrDurableMessageQueuedAdapterDeps<TConfig = unknown> = {
+  enqueueText: (ctx: ChannelMessageSendTextContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
+  enqueueMedia?: (ctx: ChannelMessageSendMediaContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
+  enqueuePayload?: (ctx: ChannelMessageSendPayloadContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
+  now?: () => number;
+};
+
+export type BncrDurableMessageQueuedAdapterBuilderDeps<TConfig = unknown> = {
+  createMessageId: () => string;
+  now: () => number;
+  normalizeAccountId: (accountId?: string | null) => string;
+  normalizeReplyToId: (value?: string | null) => string;
+  resolveTarget: (ctx: ChannelMessageSendTextContext<TConfig>) => {
+    route: BncrRoute;
+    sessionKey: string;
+    accountId?: string | null;
+  };
+  filePushEvent?: string;
+};
+
+// This adapter intentionally models only the OpenClaw -> bncr-plugin handoff.
+// Once a message is accepted into bncr's own outbox, OpenClaw should stop managing it;
+// client/platform ACK, retry, and deadLetter remain owned by the bncr service framework.
+export function createBncrDurableMessageQueuedAdapter<TConfig = unknown>(
+  deps: BncrDurableMessageQueuedAdapterDeps<TConfig>,
+): ChannelMessageAdapterShape<TConfig, ChannelMessageSendResult> {
+  return defineChannelMessageAdapter({
+    id: 'bncr-queued-outbox',
+    receive: {
+      defaultAckPolicy: 'manual',
+      supportedAckPolicies: ['manual'],
+    },
+    send: {
+      text: async (ctx) => toChannelMessageSendResult(await deps.enqueueText(ctx), deps.now),
+      media: deps.enqueueMedia
+        ? async (ctx) => toChannelMessageSendResult(await deps.enqueueMedia?.(ctx), deps.now)
+        : undefined,
+      payload: deps.enqueuePayload
+        ? async (ctx) => toChannelMessageSendResult(await deps.enqueuePayload?.(ctx), deps.now)
+        : undefined,
+    },
+  });
+}
+
+export function createBncrDurableMessageQueuedAdapterFromBuilders<TConfig = unknown>(
+  deps: BncrDurableMessageQueuedAdapterBuilderDeps<TConfig>,
+): ChannelMessageAdapterShape<TConfig, ChannelMessageSendResult> {
+  return createBncrDurableMessageQueuedAdapter<TConfig>({
+    now: deps.now,
+    enqueueText: (ctx) => {
+      const resolved = deps.resolveTarget(ctx);
+      return buildTextOutboxEntry({
+        createMessageId: deps.createMessageId,
+        now: deps.now,
+        normalizeAccountId: deps.normalizeAccountId,
+        normalizeReplyToId: deps.normalizeReplyToId,
+        accountId: resolved.accountId ?? ctx.accountId ?? undefined,
+        sessionKey: resolved.sessionKey,
+        route: resolved.route,
+        text: ctx.text,
+        kind: 'final',
+        replyToId: ctx.replyToId ?? undefined,
+      });
+    },
+    enqueueMedia: (ctx) => {
+      const resolved = deps.resolveTarget(ctx);
+      return buildFileTransferOutboxEntry({
+        createMessageId: deps.createMessageId,
+        now: deps.now,
+        normalizeAccountId: deps.normalizeAccountId,
+        pushEvent: deps.filePushEvent ?? 'bncr.file.push',
+        accountId: resolved.accountId ?? ctx.accountId ?? undefined,
+        sessionKey: resolved.sessionKey,
+        route: resolved.route,
+        mediaUrl: ctx.mediaUrl,
+        mediaLocalRoots: ctx.mediaLocalRoots,
+        text: ctx.text,
+        asVoice: ctx.audioAsVoice,
+        audioAsVoice: ctx.audioAsVoice,
+        kind: 'final',
+        replyToId: ctx.replyToId ?? undefined,
+      });
+    },
+  });
+}
+
+function toChannelMessageSendResult(entry: OutboxEntry | undefined, now?: () => number): ChannelMessageSendResult {
+  if (!entry) throw new Error('bncr durable message adapter did not receive an outbox entry');
+  const queued = buildBncrDurableQueuedResult({ entry, sentAt: now?.() });
+  return {
+    receipt: queued.receipt as any,
+    messageId: queued.receipt.primaryPlatformMessageId,
+  };
+}

package/src/messaging/outbound/durable-queue-adapter.ts

@@ -0,0 +1,157 @@
+import type { BncrRoute, OutboxEntry } from '../../core/types.ts';
+import { normalizeOutboundReplyToId } from './reply-target-policy.ts';
+
+export type BncrDurableQueuedReceipt = {
+  primaryPlatformMessageId: string;
+  platformMessageIds: string[];
+  parts: Array<{
+    platformMessageId: string;
+    kind: 'text' | 'media' | 'voice' | 'unknown';
+    index: number;
+    threadId?: string;
+    replyToId?: string;
+    raw: {
+      channel: 'bncr';
+      channelId: 'bncr';
+      messageId: string;
+      chatId: string;
+      conversationId: string;
+      timestamp: number;
+      meta: BncrDurableQueuedReceiptMeta;
+    };
+  }>;
+  threadId?: string;
+  replyToId?: string;
+  sentAt: number;
+  raw: Array<{
+    channel: 'bncr';
+    channelId: 'bncr';
+    messageId: string;
+    chatId: string;
+    conversationId: string;
+    timestamp: number;
+    meta: BncrDurableQueuedReceiptMeta;
+  }>;
+};
+
+export type BncrDurableQueuedReceiptMeta = {
+  status: 'accepted';
+  deliveryStage: 'queued';
+  queue: 'bncr.outbox';
+  finalAckManagedBy: 'bncr-outbox';
+  ackSemantics: 'plugin-accepted-not-client-acked';
+  accountId: string;
+  sessionKey: string;
+  route: BncrRoute;
+  outboxPayloadType?: string;
+};
+
+export type BncrDurableQueuedResult = {
+  status: 'sent';
+  results: Array<{
+    channel: 'bncr';
+    channelId: 'bncr';
+    messageId: string;
+    chatId: string;
+    conversationId: string;
+    timestamp: number;
+    meta: BncrDurableQueuedReceiptMeta;
+  }>;
+  receipt: BncrDurableQueuedReceipt;
+  payloadOutcomes: Array<{
+    index: number;
+    status: 'sent';
+    results: BncrDurableQueuedResult['results'];
+  }>;
+};
+
+export function buildBncrDurableQueuedResult(args: {
+  entry: OutboxEntry;
+  index?: number;
+  threadId?: string;
+  replyToId?: string;
+  sentAt?: number;
+}): BncrDurableQueuedResult {
+  const sentAt = Number.isFinite(args.sentAt) ? Number(args.sentAt) : args.entry.createdAt;
+  const platformMessageId = args.entry.messageId;
+  const replyToId = normalizeOutboundReplyToId({ replyToId: args.replyToId ?? extractReplyToId(args.entry) }) || undefined;
+  const chatId = formatQueuedReceiptChatId(args.entry.route);
+  const meta: BncrDurableQueuedReceiptMeta = {
+    status: 'accepted',
+    deliveryStage: 'queued',
+    queue: 'bncr.outbox',
+    finalAckManagedBy: 'bncr-outbox',
+    ackSemantics: 'plugin-accepted-not-client-acked',
+    accountId: args.entry.accountId,
+    sessionKey: args.entry.sessionKey,
+    route: args.entry.route,
+    outboxPayloadType: extractPayloadType(args.entry),
+  };
+  const result = {
+    channel: 'bncr' as const,
+    channelId: 'bncr' as const,
+    messageId: platformMessageId,
+    chatId,
+    conversationId: args.entry.sessionKey,
+    timestamp: sentAt,
+    meta,
+  };
+  const receipt: BncrDurableQueuedReceipt = {
+    primaryPlatformMessageId: platformMessageId,
+    platformMessageIds: [platformMessageId],
+    parts: [
+      {
+        platformMessageId,
+        kind: inferReceiptKind(args.entry),
+        index: args.index ?? 0,
+        threadId: args.threadId,
+        replyToId,
+        raw: result,
+      },
+    ],
+    threadId: args.threadId,
+    replyToId,
+    sentAt,
+    raw: [result],
+  };
+  return {
+    status: 'sent',
+    results: [result],
+    receipt,
+    payloadOutcomes: [
+      {
+        index: args.index ?? 0,
+        status: 'sent',
+        results: [result],
+      },
+    ],
+  };
+}
+
+function extractPayloadType(entry: OutboxEntry): string | undefined {
+  const payload = entry.payload as any;
+  return typeof payload?.type === 'string' ? payload.type : undefined;
+}
+
+function extractReplyToId(entry: OutboxEntry): string | undefined {
+  const payload = entry.payload as any;
+  const metaReply = payload?._meta?.replyToId;
+  const replyToId = payload?.replyToId ?? metaReply;
+  return typeof replyToId === 'string' ? replyToId : undefined;
+}
+
+function inferReceiptKind(entry: OutboxEntry): 'text' | 'media' | 'voice' | 'unknown' {
+  const payload = entry.payload as any;
+  if (payload?._meta?.kind === 'file-transfer') {
+    if (payload?._meta?.asVoice === true || payload?._meta?.audioAsVoice === true) return 'voice';
+    return 'media';
+  }
+  if (payload?.message?.type === 'text') return 'text';
+  return 'unknown';
+}
+
+function formatQueuedReceiptChatId(route: BncrRoute): string {
+  const platform = route.platform || 'unknown';
+  if (route.groupId) return `Bncr:${platform}:${route.groupId}:${route.userId}`;
+  return `Bncr:${platform}:${route.userId}`;
+}

package/src/messaging/outbound/media.ts

@@ -1,3 +1,5 @@
+import { normalizeOutboundReplyToId } from './reply-target-policy.ts';
+
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
   if (v == null) return fallback;
@@ -64,7 +66,7 @@ export function buildBncrMediaOutboundFrame(params: {
     messageId: params.messageId,
     idempotencyKey: params.messageId,
     sessionKey: params.sessionKey,
-    replyToId: asString(params.replyToId || '').trim() || undefined,
+    replyToId: normalizeOutboundReplyToId({ kind: params.kind, replyToId: params.replyToId }) || undefined,
     message: {
       platform: params.route.platform,
       groupId: params.route.groupId,

package/src/messaging/outbound/queue-selectors.ts

@@ -25,8 +25,13 @@ export type OutboxFileTransferRouteSelection = {
   ownerConnId?: string;
 };
 
+function finiteNumberOr(value: unknown, fallback: number): number {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
 export function computeOutboxRetryWait(nextAttemptAt: number, nowMs: number): number {
-  return Math.max(0, Number(nextAttemptAt || 0) - nowMs);
+  return Math.max(0, finiteNumberOr(nextAttemptAt, 0) - finiteNumberOr(nowMs, 0));
 }
 
 export function updateMinOutboxDelay(currentDelay: number | null, candidateDelay: number | null): number | null {
@@ -35,7 +40,7 @@ export function updateMinOutboxDelay(currentDelay: number | null, candidateDelay
 }
 
 export function clampOutboxDrainDelay(delayMs: number): number {
-  return Math.max(0, Math.min(Number(delayMs || 0), 30_000));
+  return Math.max(0, Math.min(finiteNumberOr(delayMs, 0), 30_000));
 }
 
 export function selectOutboxTargetAccounts(args: {

package/src/messaging/outbound/reasons.ts

@@ -38,6 +38,10 @@ export const OUTBOUND_SCHEDULE_SOURCE = {
   RETRY_REROUTE_WAIT: 'retry-reroute-wait',
   // Direct push failure kept entry in outbox and scheduled backoff.
   PUSH_FAIL_WAIT: 'push-fail-wait',
+  // Per-account flush processed its single-run item budget and yielded to the next drain.
+  ACCOUNT_BUDGET_YIELD: 'account-budget-yield',
+  // Per-account flush spent its single-run time budget and yielded to the next drain.
+  ACCOUNT_TIME_BUDGET_YIELD: 'account-time-budget-yield',
   // Account-local next delay was merged into bridge-global next delay.
   ACCOUNT_NEXT_DELAY_MERGE: 'account-next-delay-merge',
   // flushPushQueue(...) finished and armed the next bridge-level drain.

package/src/messaging/outbound/reply-enqueue.ts

@@ -1,6 +1,6 @@
 import type { BncrRoute, OutboxEntry } from '../../core/types.ts';
 import { buildReplyMediaFallbackDebugInfo } from './diagnostics.ts';
-import { normalizeReplyToId } from './media-dedupe.ts';
+import { normalizeOutboundReplyToId } from './reply-target-policy.ts';
 
 export type ReplyPayloadInput = {
   text?: string;
@@ -324,6 +324,6 @@ export function normalizeReplyPayload(
     asVoice: payload?.asVoice === true,
     audioAsVoice: payload?.audioAsVoice === true,
     kind: payload?.kind,
-    replyToId: normalizeReplyToId(payload?.replyToId),
+    replyToId: normalizeOutboundReplyToId({ kind: payload?.kind, replyToId: payload?.replyToId }),
   };
 }

package/src/messaging/outbound/reply-target-policy.ts

@@ -0,0 +1,13 @@
+import { normalizeReplyToId } from './media-dedupe.ts';
+
+export type OutboundReplyKind = 'tool' | 'block' | 'final';
+
+const STRIP_TOOL_REPLY_TO_ID = true;
+
+export function normalizeOutboundReplyToId(params: {
+  kind?: OutboundReplyKind;
+  replyToId?: string | null;
+}) {
+  if (params.kind === 'tool' && STRIP_TOOL_REPLY_TO_ID) return '';
+  return normalizeReplyToId(params.replyToId);
+}