@xmoxmo/bncr 0.3.3 → 0.3.5

package/src/messaging/outbound/reasons.ts

@@ -38,6 +38,8 @@ 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',
+  // Pre-push guard deferred delivery before an actual send attempt.
+  PRE_PUSH_GUARD_WAIT: 'pre-push-guard-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.

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

@@ -1,7 +1,10 @@
 import type { BncrRoute, OutboxEntry } from '../../core/types.ts';
 import { buildReplyMediaFallbackDebugInfo } from './diagnostics.ts';
+import type { OutboundReplyTargetPolicy } from './reply-target-policy.ts';
 import { normalizeOutboundReplyToId } from './reply-target-policy.ts';
 
+export type { OutboundReplyTargetPolicy } from './reply-target-policy.ts';
+
 export type ReplyPayloadInput = {
   text?: string;
   mediaUrl?: string;
@@ -21,6 +24,7 @@ export type NormalizedReplyPayload = {
   audioAsVoice: boolean;
   kind?: 'tool' | 'block' | 'final';
   replyToId: string;
+  replyTargetPolicy: OutboundReplyTargetPolicy;
 };
 
 export type ReplyMediaEntriesParams = {
@@ -51,6 +55,7 @@ export type ReplyMediaFileTransferParams = {
   audioAsVoice: boolean;
   kind?: 'tool' | 'block' | 'final';
   replyToId: string;
+  replyTargetPolicy: OutboundReplyTargetPolicy;
   createdAt: number;
 };
 
@@ -70,6 +75,7 @@ export type ReplyMediaFallbackTextEntryParams = {
   mediaUrl: string;
   kind?: 'tool' | 'block' | 'final';
   replyToId: string;
+  replyTargetPolicy: OutboundReplyTargetPolicy;
   fallback: { text: string; reason: string };
 };
 
@@ -85,6 +91,7 @@ export function buildReplyTextOutboxEntry(
     text: string;
     kind?: 'tool' | 'block' | 'final';
     replyToId: string;
+    replyTargetPolicy: OutboundReplyTargetPolicy;
   },
   helpers: {
     buildTextOutboxEntry: (args: {
@@ -94,6 +101,7 @@ export function buildReplyTextOutboxEntry(
       text: string;
       kind?: 'tool' | 'block' | 'final';
       replyToId?: string;
+      replyTargetPolicy?: OutboundReplyTargetPolicy;
     }) => OutboxEntry;
   },
 ): OutboxEntry {
@@ -104,6 +112,7 @@ export function buildReplyTextOutboxEntry(
     text: params.text,
     kind: params.kind,
     replyToId: params.replyToId || undefined,
+    replyTargetPolicy: params.replyTargetPolicy,
   });
 }
 
@@ -123,6 +132,7 @@ export function enqueueReplyTextEntry(
       text: string;
       kind?: 'tool' | 'block' | 'final';
       replyToId?: string;
+      replyTargetPolicy?: OutboundReplyTargetPolicy;
     }) => OutboxEntry;
   },
 ): void {
@@ -137,6 +147,7 @@ export function enqueueReplyTextEntry(
         text: params.payload.text,
         kind: params.payload.kind,
         replyToId: params.payload.replyToId,
+        replyTargetPolicy: params.payload.replyTargetPolicy,
       },
       { buildTextOutboxEntry: helpers.buildTextOutboxEntry },
     ),
@@ -146,7 +157,11 @@ export function enqueueReplyTextEntry(
 export function enqueueReplyMediaFallbackTextEntry(
   params: ReplyMediaFallbackTextEntryParams,
   helpers: {
-    logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+    logInfo: (
+      scope: string | undefined,
+      message: string,
+      options?: { debugOnly?: boolean },
+    ) => void;
     enqueueOutbound: (entry: OutboxEntry) => void;
     buildTextOutboxEntry: (args: {
       accountId: string;
@@ -155,6 +170,7 @@ export function enqueueReplyMediaFallbackTextEntry(
       text: string;
       kind?: 'tool' | 'block' | 'final';
       replyToId?: string;
+      replyTargetPolicy?: OutboundReplyTargetPolicy;
     }) => OutboxEntry;
   },
 ): void {
@@ -172,6 +188,7 @@ export function enqueueReplyMediaFallbackTextEntry(
         text: params.fallback.text,
         kind: params.kind,
         replyToId: params.replyToId,
+        replyTargetPolicy: params.replyTargetPolicy,
       },
       { buildTextOutboxEntry: helpers.buildTextOutboxEntry },
     ),
@@ -193,6 +210,7 @@ export function enqueueReplyMediaFileTransferEntry(
       audioAsVoice: boolean;
       kind?: 'tool' | 'block' | 'final';
       replyToId?: string;
+      replyTargetPolicy?: OutboundReplyTargetPolicy;
     }) => OutboxEntry;
     rememberRecentMediaSend: (args: {
       sessionKey: string;
@@ -215,6 +233,7 @@ export function enqueueReplyMediaFileTransferEntry(
       audioAsVoice: params.audioAsVoice,
       kind: params.kind,
       replyToId: params.replyToId || undefined,
+      replyTargetPolicy: params.replyTargetPolicy,
     }),
   );
   helpers.rememberRecentMediaSend({
@@ -241,6 +260,7 @@ export function enqueueSingleReplyMediaEntry(
       mediaUrl: params.mediaUrl,
       kind: params.params.payload.kind,
       replyToId: params.params.payload.replyToId,
+      replyTargetPolicy: params.params.payload.replyTargetPolicy,
       fallback: params.fallback,
     });
     return;
@@ -258,6 +278,7 @@ export function enqueueSingleReplyMediaEntry(
     audioAsVoice: params.params.payload.audioAsVoice,
     kind: params.params.payload.kind,
     replyToId: params.params.payload.replyToId,
+    replyTargetPolicy: params.params.payload.replyTargetPolicy,
     createdAt: params.currentTime,
   });
 }
@@ -310,6 +331,7 @@ export function enqueueNormalizedReplyPayload(
 export function normalizeReplyPayload(
   payload: ReplyPayloadInput,
   helpers: { asString: (value: unknown, fallback?: string) => string },
+  options?: { replyTargetPolicy?: OutboundReplyTargetPolicy },
 ): NormalizedReplyPayload {
   const text = helpers.asString(payload?.text || '').trim();
   const mediaUrl = helpers.asString(payload?.mediaUrl || '').trim();
@@ -324,6 +346,11 @@ export function normalizeReplyPayload(
     asVoice: payload?.asVoice === true,
     audioAsVoice: payload?.audioAsVoice === true,
     kind: payload?.kind,
-    replyToId: normalizeOutboundReplyToId({ kind: payload?.kind, replyToId: payload?.replyToId }),
+    replyTargetPolicy: options?.replyTargetPolicy ?? 'agent-default',
+    replyToId: normalizeOutboundReplyToId({
+      kind: payload?.kind,
+      replyToId: payload?.replyToId,
+      replyTargetPolicy: options?.replyTargetPolicy,
+    }),
   };
 }

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

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

package/src/messaging/outbound/retry-policy.ts

@@ -1,5 +1,3 @@
-import type { BncrRoute } from '../../channel.ts';
-
 function finiteNonNegativeIntegerOr(value: unknown, fallback: number): number {
   const n = Number(value);
   if (!Number.isFinite(n) || n < 0) return fallback;
@@ -48,14 +46,18 @@ export function computeRetryRerouteDecision(
     ? input.attemptedConnIds.filter((v): v is string => typeof v === 'string' && !!v)
     : [];
   const currentConnId = `${input.currentConnId || ''}`.trim();
-  if (currentConnId && !attemptedConnIds.includes(currentConnId)) attemptedConnIds.push(currentConnId);
+  if (currentConnId && !attemptedConnIds.includes(currentConnId))
+    attemptedConnIds.push(currentConnId);
 
   const availableConnIds = Array.isArray(input.availableConnIds)
     ? input.availableConnIds.filter((v): v is string => typeof v === 'string' && !!v)
     : [];
   const revalidatedConnIds = attemptedConnIds.filter((connId) => availableConnIds.includes(connId));
-  const hasUntriedAlternative = availableConnIds.some((connId) => !attemptedConnIds.includes(connId));
-  const shouldFastReroute = input.requireAck && input.currentFastReroutePending !== true && hasUntriedAlternative;
+  const hasUntriedAlternative = availableConnIds.some(
+    (connId) => !attemptedConnIds.includes(connId),
+  );
+  const shouldFastReroute =
+    input.requireAck && input.currentFastReroutePending !== true && hasUntriedAlternative;
 
   const currentRetryCount = finiteNonNegativeIntegerOr(input.currentRetryCount, 0);
   const currentRouteAttemptRound = finiteNonNegativeIntegerOr(input.currentRouteAttemptRound, 0);
@@ -73,10 +75,16 @@ export function computeRetryRerouteDecision(
     };
   }
 
-  const nextAttemptAt = shouldFastReroute ? input.nowMs + 1_000 : input.nowMs + deps.backoffMs(nextRetryCount);
+  const nextAttemptAt = shouldFastReroute
+    ? input.nowMs + 1_000
+    : input.nowMs + deps.backoffMs(nextRetryCount);
   const lastError = input.requireAck ? 'push-ack-timeout' : 'push-delivery-unconfirmed';
-  const routeAttemptRound = hasUntriedAlternative ? currentRouteAttemptRound : currentRouteAttemptRound + 1;
-  const fastReroutePending = hasUntriedAlternative ? shouldFastReroute || input.currentFastReroutePending === true : false;
+  const routeAttemptRound = hasUntriedAlternative
+    ? currentRouteAttemptRound
+    : currentRouteAttemptRound + 1;
+  const fastReroutePending = hasUntriedAlternative
+    ? shouldFastReroute || input.currentFastReroutePending === true
+    : false;
 
   return {
     kind: 'retry',

package/src/messaging/outbound/send-params.ts

@@ -0,0 +1,56 @@
+import { normalizeAccountId } from '../../core/accounts.ts';
+import { readOpenClawBooleanParam, readOpenClawStringParam } from '../../openclaw/sdk-helpers.ts';
+
+export type NormalizedBncrSendParams = {
+  to: string;
+  accountId: string;
+  message: string;
+  caption: string;
+  mediaUrl?: string;
+  asVoice: boolean;
+  audioAsVoice: boolean;
+};
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function normalizeBncrSendParams(input: {
+  params: unknown;
+  accountId: string;
+}): NormalizedBncrSendParams {
+  const paramsObj = isPlainObject(input.params) ? input.params : {};
+  const to = readOpenClawStringParam(paramsObj, 'to', { required: true });
+  const resolvedAccountId = normalizeAccountId(
+    readOpenClawStringParam(paramsObj, 'accountId') ?? input.accountId,
+  );
+
+  const message = readOpenClawStringParam(paramsObj, 'message', { allowEmpty: true }) ?? '';
+  const caption = readOpenClawStringParam(paramsObj, 'caption', { allowEmpty: true }) ?? '';
+  const mediaUrl =
+    readOpenClawStringParam(paramsObj, 'media', { trim: false }) ??
+    readOpenClawStringParam(paramsObj, 'path', { trim: false }) ??
+    readOpenClawStringParam(paramsObj, 'filePath', { trim: false }) ??
+    readOpenClawStringParam(paramsObj, 'mediaUrl', { trim: false });
+  const asVoice = readOpenClawBooleanParam(paramsObj, 'asVoice') ?? false;
+  const audioAsVoice = readOpenClawBooleanParam(paramsObj, 'audioAsVoice') ?? false;
+
+  if (asVoice && !mediaUrl) throw new Error('send voice requires media path');
+
+  const normalizedMessage = mediaUrl ? '' : message || caption || '';
+  const normalizedCaption = mediaUrl ? caption || message || '' : '';
+
+  if (!normalizedMessage.trim() && !normalizedCaption.trim() && !mediaUrl) {
+    throw new Error('send requires message or media');
+  }
+
+  return {
+    to,
+    accountId: resolvedAccountId,
+    message: normalizedMessage,
+    caption: normalizedCaption,
+    mediaUrl: mediaUrl || undefined,
+    asVoice,
+    audioAsVoice,
+  };
+}

package/src/messaging/outbound/session-route.ts

@@ -1,4 +1,3 @@
-import { buildOpenClawChannelOutboundSessionRoute } from '../../openclaw/session-route-runtime.ts';
 import {
   buildCanonicalBncrSessionKey,
   formatDisplayScope,
@@ -7,6 +6,7 @@ import {
   routeScopeToHex,
 } from '../../core/targets.ts';
 import type { BncrRoute } from '../../core/types.ts';
+import { buildOpenClawChannelOutboundSessionRoute } from '../../openclaw/session-route-runtime.ts';
 
 type ResolveBncrOutboundSessionRouteParams = {
   cfg: any;

package/src/openclaw/reply-runtime.ts

@@ -44,10 +44,7 @@ function resolveReplyApi(api: RuntimeApiHolder): RuntimeReplyApi {
   return reply;
 }
 
-export function resolveOpenClawEnvelopeFormatOptions(
-  api: RuntimeApiHolder,
-  cfg: unknown,
-): unknown {
+export function resolveOpenClawEnvelopeFormatOptions(api: RuntimeApiHolder, cfg: unknown): unknown {
   const reply = resolveReplyApi(api);
   if (typeof reply.resolveEnvelopeFormatOptions !== 'function') {
     throw new Error('OpenClaw channel reply resolveEnvelopeFormatOptions API is unavailable');
@@ -98,7 +95,9 @@ export async function dispatchOpenClawReplyWithBufferedBlockDispatcher(
 ): Promise<unknown> {
   const reply = resolveReplyApi(api);
   if (typeof reply.dispatchReplyWithBufferedBlockDispatcher !== 'function') {
-    throw new Error('OpenClaw channel reply dispatchReplyWithBufferedBlockDispatcher API is unavailable');
+    throw new Error(
+      'OpenClaw channel reply dispatchReplyWithBufferedBlockDispatcher API is unavailable',
+    );
   }
   return reply.dispatchReplyWithBufferedBlockDispatcher(params);
 }

package/src/openclaw/routing-runtime.ts

@@ -45,4 +45,3 @@ export function resolveOpenClawInboundLastRouteSessionKey(params: {
 }): string {
   return resolveInboundLastRouteSessionKey(params as any);
 }
-

package/src/openclaw/runtime-surface.ts

@@ -0,0 +1,29 @@
+export type OpenClawChannelRuntimeSurfaceDiagnostics = {
+  channel: {
+    inbound: boolean;
+    media: boolean;
+    reply: boolean;
+    routing: boolean;
+    session: boolean;
+  };
+  missing: string[];
+};
+
+export function buildOpenClawChannelRuntimeSurfaceDiagnostics(
+  api: unknown,
+): OpenClawChannelRuntimeSurfaceDiagnostics {
+  const channelRuntime = (api as any)?.runtime?.channel;
+  const surfaces = {
+    inbound: Boolean(channelRuntime?.inbound),
+    media: Boolean(channelRuntime?.media),
+    reply: Boolean(channelRuntime?.reply),
+    routing: Boolean(channelRuntime?.routing),
+    session: Boolean(channelRuntime?.session),
+  };
+  return {
+    channel: surfaces,
+    missing: Object.entries(surfaces)
+      .filter(([, present]) => !present)
+      .map(([name]) => name),
+  };
+}

package/src/openclaw/sdk-helpers.ts

@@ -4,7 +4,10 @@ import {
   jsonResult as sdkJsonResult,
   setAccountEnabledInConfigSection as sdkSetAccountEnabledInConfigSection,
 } from 'openclaw/plugin-sdk/core';
-import { readJsonFileWithFallback as sdkReadJsonFileWithFallback, writeJsonFileAtomically as sdkWriteJsonFileAtomically } from 'openclaw/plugin-sdk/json-store';
+import {
+  readJsonFileWithFallback as sdkReadJsonFileWithFallback,
+  writeJsonFileAtomically as sdkWriteJsonFileAtomically,
+} from 'openclaw/plugin-sdk/json-store';
 import { readStringParam as sdkReadStringParam } from 'openclaw/plugin-sdk/param-readers';
 import { createDefaultChannelRuntimeState as sdkCreateDefaultChannelRuntimeState } from 'openclaw/plugin-sdk/status-helpers';
 import { extractToolSend as sdkExtractToolSend } from 'openclaw/plugin-sdk/tool-send';

package/src/plugin/gateway-methods.ts

@@ -4,6 +4,8 @@ export const BNCR_GATEWAY_METHODS = [
   'bncr.activity',
   'bncr.ack',
   'bncr.diagnostics',
+  'bncr.deadLetter.inspect',
+  'bncr.deadLetter.prune',
   'bncr.file.init',
   'bncr.file.chunk',
   'bncr.file.complete',

package/src/plugin/messaging.ts

@@ -1,9 +1,5 @@
 import { BNCR_DEFAULT_ACCOUNT_ID, normalizeAccountId } from '../core/accounts.ts';
-import {
-  formatDisplayScope,
-  formatTargetDisplay,
-  parseExplicitTarget,
-} from '../core/targets.ts';
+import { formatDisplayScope, formatTargetDisplay, parseExplicitTarget } from '../core/targets.ts';
 import { resolveBncrOutboundSessionRoute } from '../messaging/outbound/session-route.ts';
 import {
   looksLikeBncrExplicitTarget,
@@ -38,10 +34,7 @@ function resolveMessagingCanonicalAgentId(
   cfg: any,
   accountId: string,
 ) {
-  return (
-    runtimeBridge.canonicalAgentId ||
-    runtimeBridge.ensureCanonicalAgentId({ cfg, accountId })
-  );
+  return runtimeBridge.canonicalAgentId || runtimeBridge.ensureCanonicalAgentId({ cfg, accountId });
 }
 
 export function createBncrMessagingExplicitTargetParser(

package/src/plugin/status.ts

@@ -1,4 +1,8 @@
-import { BNCR_DEFAULT_ACCOUNT_ID, resolveAccount, resolveDefaultDisplayName } from '../core/accounts.ts';
+import {
+  BNCR_DEFAULT_ACCOUNT_ID,
+  resolveAccount,
+  resolveDefaultDisplayName,
+} from '../core/accounts.ts';
 import { buildAccountStatusSnapshot } from '../core/status.ts';
 import { createOpenClawDefaultChannelRuntimeState } from '../openclaw/sdk-helpers.ts';
 
@@ -18,13 +22,19 @@ export function createBncrStatusSurface(getBridge: () => BncrStatusBridge) {
     },
     buildAccountSnapshot: async ({ account, runtime }: any) => {
       const runtimeBridge = getBridge();
-      const rt = runtime || runtimeBridge.getAccountRuntimeSnapshot(account?.accountId);
+      const accountId = account?.accountId || BNCR_DEFAULT_ACCOUNT_ID;
+      const snapshotAccount = {
+        accountId,
+        name: account?.name,
+        enabled: account?.enabled,
+      };
+      const rt = runtime || runtimeBridge.getAccountRuntimeSnapshot(accountId);
       return buildAccountStatusSnapshot({
-        account,
+        account: snapshotAccount,
         runtime: rt,
-        healthSummary: runtimeBridge.getStatusHeadline(account?.accountId),
+        healthSummary: runtimeBridge.getStatusHeadline(accountId),
         // default 名不可隐藏时，统一展示稳定默认值
-        displayName: resolveDefaultDisplayName(account?.name, account?.accountId),
+        displayName: resolveDefaultDisplayName(account?.name, accountId),
       });
     },
     resolveAccountState: ({ enabled, configured, account, cfg, runtime }: any) => {

package/src/runtime/outbound-ack-timeout.ts

@@ -65,6 +65,15 @@ export function computeBncrRecommendedAckTimeoutMs(args: ComputeBncrRecommendedA
   return Math.min(args.maxAckTimeoutMs, Math.max(args.minAckTimeoutMs, recommended));
 }
 
+export function resolveBncrRuntimeAckTimeoutDecision(args: ComputeBncrRecommendedAckTimeoutArgs) {
+  const timeoutMs = computeBncrRecommendedAckTimeoutMs(args);
+  const reason = computeBncrRecommendedAckTimeoutReason({
+    ...args,
+    recommendedAckTimeoutMs: timeoutMs,
+  });
+  return { timeoutMs, reason };
+}
+
 function finiteNumberOr(value: unknown, fallback: number) {
   return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
@@ -94,3 +103,67 @@ export function buildBncrRuntimeAckStrategy(args: {
     recovered: ackObservability.adaptiveAckRecovered === true,
   };
 }
+
+export function buildBncrRuntimeAckObservability(args: {
+  lastAckOkAt: number | null;
+  lastAckTimeoutAt: number | null;
+  recentAckTimeoutCount: number;
+  lateAckOkCount: number;
+  lastLateAckOkAt: number | null;
+  adaptiveAckRecoveryOkCount: number;
+  lastAckQueueLatencyMs: number | null;
+  lastAckPushLatencyMs: number | null;
+  lastLateAckQueueLatencyMs: number | null;
+  lastLateAckPushLatencyMs: number | null;
+  adaptiveAckTimeoutEnabled: boolean;
+  defaultAckTimeoutMs: number;
+  currentAckTimeoutMs: number;
+  minAckTimeoutMs: number;
+  maxAckTimeoutMs: number;
+  lateAckObservationTtlMs: number;
+  recoveryOkThreshold: number;
+  nowMs: number;
+}) {
+  const lastLateAckAgeMs =
+    typeof args.lastLateAckOkAt === 'number' && args.lastLateAckOkAt > 0
+      ? Math.max(0, args.nowMs - args.lastLateAckOkAt)
+      : null;
+  const lateAckObservationExpired =
+    typeof lastLateAckAgeMs === 'number' && lastLateAckAgeMs > args.lateAckObservationTtlMs;
+  const adaptiveAckRecovered = args.adaptiveAckRecoveryOkCount >= args.recoveryOkThreshold;
+  const ackTimeoutDecision = resolveBncrRuntimeAckTimeoutDecision({
+    lateAckOkCount: args.lateAckOkCount,
+    recentAckTimeoutCount: args.recentAckTimeoutCount,
+    lastLateAckPushLatencyMs: args.lastLateAckPushLatencyMs,
+    lastLateAckOkAt: args.lastLateAckOkAt,
+    adaptiveAckRecoveryOkCount: args.adaptiveAckRecoveryOkCount,
+    nowMs: args.nowMs,
+    defaultAckTimeoutMs: args.defaultAckTimeoutMs,
+    minAckTimeoutMs: args.minAckTimeoutMs,
+    maxAckTimeoutMs: args.maxAckTimeoutMs,
+    lateAckObservationTtlMs: args.lateAckObservationTtlMs,
+    recoveryOkThreshold: args.recoveryOkThreshold,
+  });
+  return {
+    lastAckOkAt: args.lastAckOkAt,
+    lastAckTimeoutAt: args.lastAckTimeoutAt,
+    recentAckTimeoutCount: args.recentAckTimeoutCount,
+    lateAckOkCount: args.lateAckOkCount,
+    lastLateAckOkAt: args.lastLateAckOkAt,
+    lastLateAckAgeMs,
+    lateAckObservationTtlMs: args.lateAckObservationTtlMs,
+    lateAckObservationExpired,
+    adaptiveAckRecoveryOkCount: args.adaptiveAckRecoveryOkCount,
+    adaptiveAckRecoveryOkThreshold: args.recoveryOkThreshold,
+    adaptiveAckRecovered,
+    lastAckQueueLatencyMs: args.lastAckQueueLatencyMs,
+    lastAckPushLatencyMs: args.lastAckPushLatencyMs,
+    lastLateAckQueueLatencyMs: args.lastLateAckQueueLatencyMs,
+    lastLateAckPushLatencyMs: args.lastLateAckPushLatencyMs,
+    adaptiveAckTimeoutEnabled: args.adaptiveAckTimeoutEnabled,
+    defaultAckTimeoutMs: args.defaultAckTimeoutMs,
+    currentAckTimeoutMs: args.currentAckTimeoutMs,
+    recommendedAckTimeoutMs: ackTimeoutDecision.timeoutMs,
+    recommendedAckTimeoutReason: ackTimeoutDecision.reason,
+  };
+}

package/src/runtime/outbound-flags.ts

@@ -1,4 +1,4 @@
-import { CHANNEL_ID, BNCR_DEFAULT_ACCOUNT_ID, normalizeAccountId } from '../core/accounts.ts';
+import { BNCR_DEFAULT_ACCOUNT_ID, CHANNEL_ID, normalizeAccountId } from '../core/accounts.ts';
 import { getOpenClawRuntimeConfig } from '../openclaw/config-runtime.ts';
 
 type RuntimeApiHolder = { api: unknown };

package/src/runtime/outbox-transitions.ts

@@ -103,9 +103,7 @@ export function buildBncrAckOkTelemetryPatch(args: {
   const defaultAckTimeoutMs = Math.max(0, finiteNumberOr(args.defaultAckTimeoutMs, 0));
   const ackQueueLatencyMs = Math.max(0, ackAt - finiteNumberOr(args.entry.createdAt, ackAt));
   const ackPushLatencyMs =
-    typeof args.entry.lastPushAt === 'number'
-      ? Math.max(0, ackAt - args.entry.lastPushAt)
-      : null;
+    typeof args.entry.lastPushAt === 'number' ? Math.max(0, ackAt - args.entry.lastPushAt) : null;
   const lateAccepted = args.entry.awaitingRetryPush === true;
   return {
     ackAt,
@@ -114,6 +112,8 @@ export function buildBncrAckOkTelemetryPatch(args: {
     lateAccepted,
     shouldResetAdaptiveAckRecovery: lateAccepted,
     shouldIncrementAdaptiveAckRecovery:
-      !lateAccepted && typeof ackPushLatencyMs === 'number' && ackPushLatencyMs <= defaultAckTimeoutMs,
+      !lateAccepted &&
+      typeof ackPushLatencyMs === 'number' &&
+      ackPushLatencyMs <= defaultAckTimeoutMs,
   };
 }

package/src/runtime/register-trace-runtime.ts

@@ -0,0 +1,102 @@
+import {
+  appendBoundedRegisterTrace,
+  buildRegisterDriftSnapshot,
+  buildRegisterTraceEntry,
+  buildRegisterTraceSummary,
+  type RegisterDriftSnapshot,
+  type RegisterTraceEntry,
+  type RegisterTraceSummary,
+} from '../core/register-trace.ts';
+
+export type RegisterTraceRuntimeState = {
+  registerCount: number;
+  apiGeneration: number;
+  firstRegisterAt: number | null;
+  lastRegisterAt: number | null;
+  lastApiRebindAt: number | null;
+  pluginSource: string | null;
+  pluginVersion: string | null;
+  lastApiInstanceId: string | null;
+  lastRegistryFingerprint: string | null;
+  lastDriftSnapshot: RegisterDriftSnapshot | null;
+  registerTraceRecent: RegisterTraceEntry[];
+};
+
+export type RegisterTraceRuntimeMeta = {
+  source?: string;
+  pluginVersion?: string;
+  apiRebound?: boolean;
+  apiInstanceId?: string;
+  registryFingerprint?: string;
+};
+
+export function buildRegisterTraceRuntimeSummary(args: {
+  state: Pick<RegisterTraceRuntimeState, 'registerTraceRecent' | 'firstRegisterAt'>;
+  warmupWindowMs: number;
+}): RegisterTraceSummary {
+  return buildRegisterTraceSummary({
+    traceRecent: args.state.registerTraceRecent,
+    firstRegisterAt: args.state.firstRegisterAt,
+    warmupWindowMs: args.warmupWindowMs,
+  });
+}
+
+export function noteRegisterTraceRuntime(args: {
+  state: RegisterTraceRuntimeState;
+  meta: RegisterTraceRuntimeMeta;
+  ts: number;
+  stack: string;
+  bridgeId: string;
+  gatewayPid: number;
+  warmupWindowMs: number;
+  maxTraceEntries?: number;
+}): { trace: RegisterTraceEntry; summary: RegisterTraceSummary; capturedDriftSnapshot: boolean } {
+  const { state, meta } = args;
+  state.registerCount += 1;
+  if (state.firstRegisterAt == null) state.firstRegisterAt = args.ts;
+  state.lastRegisterAt = args.ts;
+  if (meta.apiRebound) {
+    state.apiGeneration += 1;
+    state.lastApiRebindAt = args.ts;
+  } else if (state.registerCount === 1 && state.apiGeneration === 0) {
+    state.apiGeneration = 1;
+  }
+  if (meta.source) state.pluginSource = meta.source;
+  if (meta.pluginVersion) state.pluginVersion = meta.pluginVersion;
+  if (meta.apiInstanceId) state.lastApiInstanceId = meta.apiInstanceId;
+  if (meta.registryFingerprint) state.lastRegistryFingerprint = meta.registryFingerprint;
+
+  const trace = buildRegisterTraceEntry({
+    ts: args.ts,
+    bridgeId: args.bridgeId,
+    gatewayPid: args.gatewayPid,
+    registerCount: state.registerCount,
+    apiGeneration: state.apiGeneration,
+    apiRebound: meta.apiRebound === true,
+    apiInstanceId: state.lastApiInstanceId,
+    registryFingerprint: state.lastRegistryFingerprint,
+    source: state.pluginSource,
+    pluginVersion: state.pluginVersion,
+    stack: args.stack,
+  });
+  appendBoundedRegisterTrace(state.registerTraceRecent, trace, args.maxTraceEntries ?? 12);
+
+  const summary = buildRegisterTraceRuntimeSummary({
+    state,
+    warmupWindowMs: args.warmupWindowMs,
+  });
+  const capturedDriftSnapshot = summary.postWarmupRegisterCount > 0;
+  if (capturedDriftSnapshot) {
+    state.lastDriftSnapshot = buildRegisterDriftSnapshot({
+      capturedAt: args.ts,
+      registerCount: state.registerCount,
+      apiGeneration: state.apiGeneration,
+      summary,
+      apiInstanceId: state.lastApiInstanceId,
+      registryFingerprint: state.lastRegistryFingerprint,
+      traceRecent: state.registerTraceRecent,
+    });
+  }
+
+  return { trace, summary, capturedDriftSnapshot };
+}