@xmoxmo/bncr 0.2.7 → 0.2.9

package/src/channel.ts

@@ -12,7 +12,6 @@ import {
   listAccountIds,
   normalizeAccountId,
   resolveAccount,
-  resolveDefaultDisplayName,
 } from './core/accounts.ts';
 import { BncrConfigSchema } from './core/config-schema.ts';
 import {
@@ -21,18 +20,33 @@ import {
   clearOutboundCapability,
   findCapabilityConnection,
 } from './core/connection-capability.ts';
+import {
+  getRevalidatedAttemptReason,
+  hasAlternativeLiveConnection as hasAlternativeLiveConnectionFromRuntime,
+  hasRecentInboundReachability as hasRecentInboundReachabilityFromRuntime,
+  isRecentlyReachableConn as isRecentlyReachableConnFromRuntime,
+  resolveRecentInboundConnIds as resolveRecentInboundConnIdsFromRuntime,
+} from './core/connection-reachability.ts';
+import { buildDiagnosticsPayload } from './core/diagnostics.ts';
+import { buildDownlinkHealth as buildDownlinkHealthFromRuntime } from './core/downlink-health.ts';
+import { buildExtendedDiagnostics as buildExtendedDiagnosticsFromRuntime } from './core/extended-diagnostics.ts';
+import { buildFileAckKey } from './core/file-ack.ts';
+import {
+  buildFileTransferAbortPayload,
+  buildFileTransferChunkPayload,
+  buildFileTransferCompletePayload,
+  buildFileTransferInitPayload,
+} from './core/file-transfer-payloads.ts';
+import {
+  matchesTransferOwner as matchesTransferOwnerFromRuntime,
+  observeLeaseState,
+} from './core/lease-state.ts';
+import { emitBncrLog, emitBncrLogLine } from './core/logging.ts';
+import { buildOutboxEnqueueDebugInfo } from './core/outbox-enqueue.ts';
 import {
   buildFileTransferOutboxEntry as buildFileTransferOutboxEntryFromRuntime,
   buildTextOutboxEntry as buildTextOutboxEntryFromRuntime,
 } from './core/outbox-entry-builders.ts';
-import { buildOutboxEnqueueDebugInfo } from './core/outbox-enqueue.ts';
-import {
-  appendDeadLetter,
-  buildDeadLetterEntry,
-  collectDueOutboxEntries,
-} from './core/outbox-queue.ts';
-import { resolveFileTransferGuard } from './core/outbox-file-transfer-guards.ts';
-import { prepareFileTransferRouteSelection } from './core/outbox-file-transfer-prep.ts';
 import {
   buildFileTransferPushOkArgs,
   buildFileTransferPushSuccessArgs,
@@ -41,61 +55,36 @@ import {
   buildFileTransferPushFailureArgs,
   resolveFileTransferFailureState,
 } from './core/outbox-file-transfer-failure.ts';
+import { resolveFileTransferGuard } from './core/outbox-file-transfer-guards.ts';
+import { prepareFileTransferRouteSelection } from './core/outbox-file-transfer-prep.ts';
 import {
   buildFileTransferBroadcastPayload,
   buildFileTransferRouteSelectArgs,
 } from './core/outbox-file-transfer-success.ts';
+import {
+  appendDeadLetter,
+  buildDeadLetterEntry,
+  collectDueOutboxEntries,
+} from './core/outbox-queue.ts';
 import { summarizeOutboxEntry } from './core/outbox-summary.ts';
+import { buildTextPushFailureArgs } from './core/outbox-text-push-failure.ts';
 import { resolveTextPushGuard } from './core/outbox-text-push-guards.ts';
 import { prepareTextPushRouteSelection } from './core/outbox-text-push-prep.ts';
-import { buildTextPushFailureArgs } from './core/outbox-text-push-failure.ts';
 import {
   buildTextPushBroadcastPayload,
   buildTextPushOkArgs,
   buildTextPushRouteSelectArgs,
   buildTextPushSuccessArgs,
 } from './core/outbox-text-push-success.ts';
-import {
-  getRevalidatedAttemptReason,
-  hasAlternativeLiveConnection as hasAlternativeLiveConnectionFromRuntime,
-  hasRecentInboundReachability as hasRecentInboundReachabilityFromRuntime,
-  isRecentlyReachableConn as isRecentlyReachableConnFromRuntime,
-  resolveRecentInboundConnIds as resolveRecentInboundConnIdsFromRuntime,
-} from './core/connection-reachability.ts';
-import { buildDiagnosticsPayload } from './core/diagnostics.ts';
-import { buildDownlinkHealth as buildDownlinkHealthFromRuntime } from './core/downlink-health.ts';
-import { buildExtendedDiagnostics as buildExtendedDiagnosticsFromRuntime } from './core/extended-diagnostics.ts';
-import { observeLeaseState, matchesTransferOwner as matchesTransferOwnerFromRuntime } from './core/lease-state.ts';
-import { emitBncrLog, emitBncrLogLine } from './core/logging.ts';
 import { resolveBncrChannelPolicy, resolveBncrConfigWarnings } from './core/policy.ts';
 import {
-  getOpenClawRuntimeConfig,
-  getOpenClawRuntimeConfigOrDefault,
-} from './openclaw/config-runtime.ts';
-import {
-  loadOpenClawWebMedia,
-  saveOpenClawChannelMediaBuffer,
-  type OpenClawLoadedMedia,
-} from './openclaw/media-runtime.ts';
-import { resolveOpenClawAgentRoute } from './openclaw/routing-runtime.ts';
-import {
-  applyOpenClawAccountNameToChannelSection,
-  createOpenClawDefaultChannelRuntimeState,
-  extractOpenClawToolSend,
-  openClawJsonResult,
-  readOpenClawBooleanParam,
-  readOpenClawJsonFileWithFallback,
-  readOpenClawStringParam,
-  setOpenClawAccountEnabledInConfigSection,
-  writeOpenClawJsonFileAtomically,
-} from './openclaw/sdk-helpers.ts';
-import {
+  appendBoundedRegisterTrace,
+  buildRegisterDriftSnapshot,
+  buildRegisterTraceEntry,
   buildRegisterTraceSummary as buildRegisterTraceSummaryFromEntries,
-  classifyRegisterTrace as classifyRegisterTraceFromStack,
 } from './core/register-trace.ts';
 import {
   buildAccountRuntimeSnapshot,
-  buildAccountStatusSnapshot,
   buildIntegratedDiagnostics as buildIntegratedDiagnosticsFromRuntime,
   buildStatusHeadlineFromRuntime,
   buildStatusMetaFromRuntime,
@@ -103,11 +92,9 @@ import {
 import {
   buildCanonicalBncrSessionKey,
   formatDisplayScope,
-  formatTargetDisplay,
   isLowerHex,
   normalizeInboundSessionKey,
   normalizeStoredSessionKey,
-  parseExplicitTarget,
   parseRouteFromDisplayScope,
   parseRouteFromHexScope,
   parseRouteFromScope,
@@ -127,14 +114,12 @@ import {
   reactBncrMessageAction,
   sendBncrReplyAction,
 } from './messaging/outbound/actions.ts';
-import {
-  buildBncrMediaOutboundFrame,
-  resolveBncrOutboundMessageType,
-} from './messaging/outbound/media.ts';
 import {
   buildEnqueueFromReplyDebugInfo,
   buildFlushDebugInfo,
   buildOutboxAckDebugInfo,
+  buildOutboxDrainSkipDebugInfo,
+  buildOutboxDrainStuckDebugInfo,
   buildOutboxPushOkDebugInfo,
   buildOutboxPushSkipDebugInfo,
   buildOutboxRouteSelectDebugInfo,
@@ -143,6 +128,28 @@ import {
   buildReplyMediaFallbackDebugInfo,
   buildRetryRerouteDebugInfo,
 } from './messaging/outbound/diagnostics.ts';
+import {
+  buildBncrMediaOutboundFrame,
+  resolveBncrOutboundMessageType,
+} from './messaging/outbound/media.ts';
+import {
+  getOpenClawRuntimeConfig,
+  getOpenClawRuntimeConfigOrDefault,
+} from './openclaw/config-runtime.ts';
+import {
+  type OpenClawLoadedMedia,
+  loadOpenClawWebMedia,
+  saveOpenClawChannelMediaBuffer,
+} from './openclaw/media-runtime.ts';
+import { resolveOpenClawAgentRoute } from './openclaw/routing-runtime.ts';
+import {
+  extractOpenClawToolSend,
+  openClawJsonResult,
+  readOpenClawBooleanParam,
+  readOpenClawJsonFileWithFallback,
+  readOpenClawStringParam,
+  writeOpenClawJsonFileAtomically,
+} from './openclaw/sdk-helpers.ts';
 
 function buildInboundAcceptedLifecycleDebugInfo(args: {
   stage: 'accepted';
@@ -276,33 +283,13 @@ function buildInboundResponsePayload(
       };
   }
 }
+import { buildBncrDurableQueuedResult } from './messaging/outbound/durable-queue-adapter.ts';
 import {
-  buildMediaTextFallback,
   type MediaDedupeCacheEntry,
+  buildMediaTextFallback,
   normalizeMessageText,
   normalizeReplyToId,
 } from './messaging/outbound/media-dedupe.ts';
-import {
-  buildReplyTextOutboxEntry,
-  enqueueNormalizedReplyPayload,
-  enqueueReplyMediaFallbackTextEntry,
-  enqueueReplyMediaFileTransferEntry,
-  enqueueSingleReplyMediaEntry,
-  enqueueReplyTextEntry,
-  hasReplyMediaEntries,
-  normalizeReplyPayload,
-  type NormalizedReplyPayload,
-  type ReplyMediaEntriesParams,
-  type ReplyMediaFileTransferParams,
-  type ReplyPayloadInput,
-} from './messaging/outbound/reply-enqueue.ts';
-import {
-  OUTBOUND_DEGRADE_REASON,
-  OUTBOUND_FLUSH_REASON,
-  OUTBOUND_FLUSH_TRIGGER,
-  OUTBOUND_SCHEDULE_SOURCE,
-  OUTBOUND_TERMINAL_REASON,
-} from './messaging/outbound/reasons.ts';
 import {
   buildOutboxOnlineDebugInfo,
   clampOutboxDrainDelay,
@@ -315,17 +302,73 @@ import {
   selectOutboxTargetAccounts,
   updateMinOutboxDelay,
 } from './messaging/outbound/queue-selectors.ts';
+import {
+  OUTBOUND_DEGRADE_REASON,
+  OUTBOUND_FLUSH_REASON,
+  OUTBOUND_FLUSH_TRIGGER,
+  OUTBOUND_SCHEDULE_SOURCE,
+  OUTBOUND_TERMINAL_REASON,
+} from './messaging/outbound/reasons.ts';
+import {
+  type NormalizedReplyPayload,
+  type ReplyMediaEntriesParams,
+  type ReplyMediaFileTransferParams,
+  type ReplyPayloadInput,
+  buildReplyTextOutboxEntry,
+  enqueueNormalizedReplyPayload,
+  enqueueReplyMediaFallbackTextEntry,
+  enqueueReplyMediaFileTransferEntry,
+  enqueueReplyTextEntry,
+  enqueueSingleReplyMediaEntry,
+  hasReplyMediaEntries,
+  normalizeReplyPayload,
+} from './messaging/outbound/reply-enqueue.ts';
 import {
   computePushFailureDecision,
   computeRetryRerouteDecision,
 } from './messaging/outbound/retry-policy.ts';
 import { sendBncrMedia, sendBncrText } from './messaging/outbound/send.ts';
-import { buildBncrDurableQueuedResult } from './messaging/outbound/durable-queue-adapter.ts';
-import { resolveBncrOutboundSessionRoute } from './messaging/outbound/session-route.ts';
+import { BNCR_CHANNEL_CAPABILITIES } from './plugin/capabilities.ts';
+import { BNCR_CONFIG_SURFACE } from './plugin/config.ts';
+import { BNCR_GATEWAY_METHODS } from './plugin/gateway-methods.ts';
+import { createBncrGatewayRuntime } from './plugin/gateway-runtime.ts';
+import { BNCR_MESSAGE_RECEIVE_POLICY } from './plugin/message-policy.ts';
+import { createBncrMessageSend } from './plugin/message-send.ts';
+import { createBncrMessagingSurface } from './plugin/messaging.ts';
+import { BNCR_CHANNEL_META } from './plugin/meta.ts';
+import { createBncrOutboundRuntime } from './plugin/outbound.ts';
+import { BNCR_SETUP_SURFACE } from './plugin/setup.ts';
+import { createBncrStatusSurface } from './plugin/status.ts';
+import {
+  pruneLogDedupeState as pruneLogDedupeStateFromRuntime,
+  shouldEmitDedupLog as shouldEmitDedupLogFromRuntime,
+} from './runtime/log-dedupe.ts';
+import {
+  buildBncrRuntimeAckStrategy,
+  computeBncrRecommendedAckTimeoutMs,
+  computeBncrRecommendedAckTimeoutReason,
+} from './runtime/outbound-ack-timeout.ts';
+import {
+  buildBncrRuntimeFlags,
+  buildBncrRuntimeStatusInput,
+  resolveBncrOutboundAckRequired,
+} from './runtime/outbound-flags.ts';
 import {
-  looksLikeBncrExplicitTarget,
-  resolveBncrOutboundTarget,
-} from './messaging/outbound/target-resolver.ts';
+  applyBncrPushFailureDecisionToEntry,
+  applyBncrRetryRerouteDecisionToEntry,
+  buildBncrAckOkTelemetryPatch,
+  buildBncrAckRetryEntryPatch,
+  buildBncrOutboxFailureEntryPatch,
+  buildBncrOutboxPushSuccessEntryPatch,
+} from './runtime/outbox-transitions.ts';
+import { buildRuntimeStatusSnapshots } from './runtime/status-snapshots.ts';
+import {
+  type ChannelAccountWorkerHandle,
+  clearAllBncrStatusWorkers,
+  clearBncrStatusWorker,
+  startBncrStatusWorker,
+  stopBncrStatusWorker,
+} from './runtime/status-worker.ts';
 const BRIDGE_VERSION = 2;
 const BNCR_PUSH_EVENT = 'plugin.bncr.push';
 const BNCR_FILE_INIT_EVENT = 'plugin.bncr.file.init';
@@ -341,6 +384,9 @@ const MAX_ACCOUNT_ACTIVITY_ENTRIES = 1000;
 const PUSH_DRAIN_INTERVAL_MS = 500;
 const PUSH_DRAIN_ACCOUNT_BUDGET = 5;
 const PUSH_DRAIN_ACCOUNT_TIME_BUDGET_MS = 2_000;
+const PUSH_DRAIN_EXCEPTION_RETRY_LIMIT = 3;
+const PUSH_DRAIN_EXCEPTION_RETRY_DELAY_MS = 1_000;
+const PUSH_DRAIN_STUCK_WARN_MS = 30_000;
 const PUSH_ACK_TIMEOUT_MS = 30_000;
 const ADAPTIVE_ACK_TIMEOUT_DEFAULT_ENABLED = true;
 const RECOMMENDED_ACK_TIMEOUT_MIN_MS = PUSH_ACK_TIMEOUT_MS;
@@ -351,12 +397,11 @@ const ADAPTIVE_ACK_TIMEOUT_LOG_THROTTLE_MS = 5 * 60 * 1000;
 const OUTBOUND_READY_TTL_MS = 30_000;
 const PREFERRED_OUTBOUND_TTL_MS = 12_000;
 const FILE_FORCE_CHUNK = true; // 统一走 WS 分块，保留 base64 仅作兜底
-const LOG_DEDUPE_STATE_TTL_MS = 10 * 60 * 1000;
-const LOG_DEDUPE_STATE_MAX_ENTRIES = 1_000;
 const FILE_INLINE_THRESHOLD = 5 * 1024 * 1024; // fallback 阈值（仅 FILE_FORCE_CHUNK=false 时生效）
 const FILE_CHUNK_SIZE = 256 * 1024; // 256KB
 const INBOUND_FILE_TRANSFER_MAX_BYTES = 50 * 1024 * 1024;
-const INBOUND_FILE_TRANSFER_MAX_CHUNKS = Math.ceil(INBOUND_FILE_TRANSFER_MAX_BYTES / FILE_CHUNK_SIZE) + 1;
+const INBOUND_FILE_TRANSFER_MAX_CHUNKS =
+  Math.ceil(INBOUND_FILE_TRANSFER_MAX_BYTES / FILE_CHUNK_SIZE) + 1;
 const FILE_CHUNK_RETRY = 3;
 const FILE_ACK_TIMEOUT_MS = 30_000;
 const FILE_TRANSFER_ACK_TTL_MS = 30_000;
@@ -389,12 +434,6 @@ type FileSendTransferState = {
   error?: string;
 };
 
-type ChannelAccountWorkerHandle = {
-  timer: NodeJS.Timeout;
-  finish: (reason: string) => void;
-  cleanupAbortListener?: () => void;
-};
-
 type FileRecvTransferState = {
   transferId: string;
   accountId: string;
@@ -528,7 +567,6 @@ function normalizeBncrSendParams(input: {
   };
 }
 
-
 function now() {
   return Date.now();
 }
@@ -725,7 +763,10 @@ class BncrBridgeRuntime {
   private lastLateAckQueueLatencyMsByAccount = new Map<string, number>();
   private lastLateAckPushLatencyMsByAccount = new Map<string, number>();
   private adaptiveAckRecoveryOkCountByAccount = new Map<string, number>();
-  private adaptiveAckTimeoutLogStateByAccount = new Map<string, { at: number; timeoutMs: number; reason: string }>();
+  private adaptiveAckTimeoutLogStateByAccount = new Map<
+    string,
+    { at: number; timeoutMs: number; reason: string }
+  >();
   private channelAccountWorkers = new Map<string, ChannelAccountWorkerHandle>();
   private logDedupeState = new Map<string, { at: number; sig: string }>();
   private canonicalAgentId: string | null = null;
@@ -743,6 +784,9 @@ class BncrBridgeRuntime {
   private saveTimer: NodeJS.Timeout | null = null;
   private pushTimer: NodeJS.Timeout | null = null;
   private pushDrainRunningAccounts = new Set<string>();
+  private pushDrainRunningSinceByAccount = new Map<string, number>();
+  private pushDrainStuckWarnedAtByAccount = new Map<string, number>();
+  private pushDrainExceptionRetryCount = 0;
   private messageAckWaiters = new Map<
     // Refactor boundary note (message ACK runtime):
     // These waiters are part of the outbound message-ack lifecycle, not just a utility map.
@@ -837,27 +881,17 @@ class BncrBridgeRuntime {
   }
 
   private pruneLogDedupeState(currentTime = now()) {
-    for (const [key, entry] of this.logDedupeState.entries()) {
-      if (currentTime - entry.at > LOG_DEDUPE_STATE_TTL_MS) {
-        this.logDedupeState.delete(key);
-      }
-    }
-
-    while (this.logDedupeState.size > LOG_DEDUPE_STATE_MAX_ENTRIES) {
-      const oldestKey = this.logDedupeState.keys().next().value;
-      if (!oldestKey) break;
-      this.logDedupeState.delete(oldestKey);
-    }
+    pruneLogDedupeStateFromRuntime(this.logDedupeState, currentTime);
   }
 
   private shouldEmitDedupLog(key: string, sig: string, windowMs = 5 * 60 * 1000) {
-    const t = now();
-    this.pruneLogDedupeState(t);
-    const prev = this.logDedupeState.get(key) || null;
-    if (prev && prev.sig === sig && t - prev.at < windowMs) return false;
-    this.logDedupeState.set(key, { at: t, sig });
-    this.pruneLogDedupeState(t);
-    return true;
+    return shouldEmitDedupLogFromRuntime({
+      state: this.logDedupeState,
+      key,
+      sig,
+      nowMs: now(),
+      windowMs,
+    });
   }
 
   private logInfoDedup(
@@ -954,39 +988,64 @@ class BncrBridgeRuntime {
     );
   }
 
+  private buildStatusWorkerRuntime() {
+    return {
+      workers: this.channelAccountWorkers,
+      bridgeId: this.bridgeId,
+      hooks: {
+        isOnline: (accountId: string) => this.isOnline(accountId),
+        hasRecentInboundReachability: (accountId: string) =>
+          this.hasRecentInboundReachability(accountId),
+        getLastActivityAt: (accountId: string, previous: Record<string, any>) =>
+          this.lastActivityByAccount.get(accountId) ||
+          this.lastInboundByAccount.get(accountId) ||
+          this.lastOutboundByAccount.get(accountId) ||
+          previous?.lastEventAt ||
+          null,
+        getActiveConnectionKey: (accountId: string) =>
+          this.activeConnectionByAccount.get(accountId) || null,
+        getActiveConnections: (accountId: string) =>
+          Array.from(this.connections.values())
+            .filter((c) => c.accountId === accountId)
+            .map((c) => ({
+              connId: c.connId,
+              clientId: c.clientId,
+              inboundOnly: c.inboundOnly === true,
+              outboundReady: c.outboundReady === true,
+              preferredForOutbound: c.preferredForOutbound === true,
+            })),
+        buildStatusMeta: (accountId: string) => this.buildStatusMeta(accountId),
+        logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) =>
+          this.logInfo(scope, message, options),
+        logInfoDedup: (
+          scope: string | undefined,
+          message: string,
+          options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+        ) => this.logInfoDedup(scope, message, options),
+      },
+    };
+  }
+
   private clearChannelAccountWorker(accountId: string, reason: string) {
-    const worker = this.channelAccountWorkers.get(accountId);
-    if (!worker) return false;
-    worker.finish(reason);
-    this.logInfo(
-      'health',
-      `status-worker cleared ${JSON.stringify({ bridge: this.bridgeId, accountId, reason })}`,
-      { debugOnly: true },
-    );
-    return true;
+    return clearBncrStatusWorker(this.buildStatusWorkerRuntime(), accountId, reason);
   }
 
   private clearAllChannelAccountWorkers(reason: string) {
-    for (const accountId of Array.from(this.channelAccountWorkers.keys())) {
-      this.clearChannelAccountWorker(accountId, reason);
-    }
+    clearAllBncrStatusWorkers(this.buildStatusWorkerRuntime(), reason);
   }
 
   private captureDriftSnapshot(
     summary: ReturnType<BncrBridgeRuntime['buildRegisterTraceSummary']>,
   ) {
-    this.lastDriftSnapshot = {
+    this.lastDriftSnapshot = buildRegisterDriftSnapshot({
       capturedAt: now(),
       registerCount: this.registerCount,
       apiGeneration: this.apiGeneration,
-      postWarmupRegisterCount: summary.postWarmupRegisterCount,
+      summary,
       apiInstanceId: this.lastApiInstanceId,
       registryFingerprint: this.lastRegistryFingerprint,
-      dominantBucket: summary.dominantBucket,
-      sourceBuckets: { ...summary.sourceBuckets },
-      traceWindowSize: this.registerTraceRecent.length,
-      traceRecent: this.registerTraceRecent.map((trace) => ({ ...trace })),
-    };
+      traceRecent: this.registerTraceRecent,
+    });
     this.scheduleSave();
   }
 
@@ -1026,9 +1085,7 @@ class BncrBridgeRuntime {
       .map((line) => line.trim())
       .filter(Boolean)
       .join(' <- ');
-    const stackBucket = classifyRegisterTraceFromStack(stack);
-
-    const trace = {
+    const trace = buildRegisterTraceEntry({
       ts,
       bridgeId: this.bridgeId,
       gatewayPid: this.gatewayPid,
@@ -1040,11 +1097,8 @@ class BncrBridgeRuntime {
       source: this.pluginSource,
       pluginVersion: this.pluginVersion,
       stack,
-      stackBucket,
-    };
-    this.registerTraceRecent.push(trace);
-    if (this.registerTraceRecent.length > 12)
-      this.registerTraceRecent.splice(0, this.registerTraceRecent.length - 12);
+    });
+    appendBoundedRegisterTrace(this.registerTraceRecent, trace, 12);
 
     const summary = this.buildRegisterTraceSummary();
     if (summary.postWarmupRegisterCount > 0) this.captureDriftSnapshot(summary);
@@ -1147,11 +1201,29 @@ class BncrBridgeRuntime {
     return matchesTransferOwnerFromRuntime(params);
   }
 
+  private buildRuntimeSurfaceDiagnostics() {
+    const channelRuntime = (this.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),
+    };
+  }
+
   private buildExtendedDiagnostics(accountId: string) {
     const acc = normalizeAccountId(accountId);
     const diagnostics = this.buildIntegratedDiagnostics(acc) as Record<string, any>;
     return buildExtendedDiagnosticsFromRuntime({
       diagnostics,
+      runtimeSurface: this.buildRuntimeSurfaceDiagnostics(),
       register: {
         bridgeId: this.bridgeId,
         gatewayPid: this.gatewayPid,
@@ -1745,7 +1817,9 @@ class BncrBridgeRuntime {
     const primaryKey = this.activeConnectionByAccount.get(acc);
     const primary = primaryKey ? this.connections.get(primaryKey) : null;
 
-    const isEligible = (conn: BncrConnection | null | undefined): conn is BncrConnection & {
+    const isEligible = (
+      conn: BncrConnection | null | undefined,
+    ): conn is BncrConnection & {
       outboundReadyUntil?: number;
       preferredForOutboundUntil?: number;
       inboundOnly?: boolean;
@@ -1790,10 +1864,13 @@ class BncrBridgeRuntime {
         const sb = candidateScore(b);
         if (sb.preferred !== sa.preferred) return sb.preferred - sa.preferred;
         if (sb.ready !== sa.ready) return sb.ready - sa.ready;
-        if (sa.recentTimeoutPenalty !== sb.recentTimeoutPenalty) return sa.recentTimeoutPenalty - sb.recentTimeoutPenalty;
-        if (sa.pushFailureScore !== sb.pushFailureScore) return sa.pushFailureScore - sb.pushFailureScore;
+        if (sa.recentTimeoutPenalty !== sb.recentTimeoutPenalty)
+          return sa.recentTimeoutPenalty - sb.recentTimeoutPenalty;
+        if (sa.pushFailureScore !== sb.pushFailureScore)
+          return sa.pushFailureScore - sb.pushFailureScore;
         if (sb.lastAckOkAt !== sa.lastAckOkAt) return sb.lastAckOkAt - sa.lastAckOkAt;
-        if (sa.lastPushTimeoutAt !== sb.lastPushTimeoutAt) return sa.lastPushTimeoutAt - sb.lastPushTimeoutAt;
+        if (sa.lastPushTimeoutAt !== sb.lastPushTimeoutAt)
+          return sa.lastPushTimeoutAt - sb.lastPushTimeoutAt;
         if (sb.recentInbound !== sa.recentInbound) return sb.recentInbound - sa.recentInbound;
         if (sb.lastSeenAt !== sa.lastSeenAt) return sb.lastSeenAt - sa.lastSeenAt;
         return sb.connectedAt - sa.connectedAt;
@@ -1841,7 +1918,9 @@ class BncrBridgeRuntime {
     const t = now();
     const connIds = new Set<string>();
 
-    const isEligible = (conn: BncrConnection | null | undefined): conn is BncrConnection & {
+    const isEligible = (
+      conn: BncrConnection | null | undefined,
+    ): conn is BncrConnection & {
       outboundReadyUntil?: number;
       preferredForOutboundUntil?: number;
       inboundOnly?: boolean;
@@ -1889,10 +1968,13 @@ class BncrBridgeRuntime {
         const sb = candidateScore(b);
         if (sb.preferred !== sa.preferred) return sb.preferred - sa.preferred;
         if (sb.ready !== sa.ready) return sb.ready - sa.ready;
-        if (sa.recentTimeoutPenalty !== sb.recentTimeoutPenalty) return sa.recentTimeoutPenalty - sb.recentTimeoutPenalty;
-        if (sa.pushFailureScore !== sb.pushFailureScore) return sa.pushFailureScore - sb.pushFailureScore;
+        if (sa.recentTimeoutPenalty !== sb.recentTimeoutPenalty)
+          return sa.recentTimeoutPenalty - sb.recentTimeoutPenalty;
+        if (sa.pushFailureScore !== sb.pushFailureScore)
+          return sa.pushFailureScore - sb.pushFailureScore;
         if (sb.lastAckOkAt !== sa.lastAckOkAt) return sb.lastAckOkAt - sa.lastAckOkAt;
-        if (sa.lastPushTimeoutAt !== sb.lastPushTimeoutAt) return sa.lastPushTimeoutAt - sb.lastPushTimeoutAt;
+        if (sa.lastPushTimeoutAt !== sb.lastPushTimeoutAt)
+          return sa.lastPushTimeoutAt - sb.lastPushTimeoutAt;
         if (sb.recentInbound !== sa.recentInbound) return sb.recentInbound - sa.recentInbound;
         if (sb.lastSeenAt !== sa.lastSeenAt) return sb.lastSeenAt - sa.lastSeenAt;
         return sb.connectedAt - sa.connectedAt;
@@ -1976,10 +2058,7 @@ class BncrBridgeRuntime {
 
   private tryAdoptTransferOwner(args: {
     accountId: string;
-    transfer:
-      | FileSendTransferState
-      | FileRecvTransferState
-      | undefined;
+    transfer: FileSendTransferState | FileRecvTransferState | undefined;
     connId: string;
     clientId?: string;
   }): boolean {
@@ -2111,6 +2190,7 @@ class BncrBridgeRuntime {
     this.recordOutboxPrePushFailure({
       entry: args.entry,
       lastError: args.guard.lastError,
+      persist: true,
     });
     if (args.guard.reason === 'media-url-missing') {
       this.logOutboxPushFailure({
@@ -2126,9 +2206,12 @@ class BncrBridgeRuntime {
       messageId: args.entry.messageId,
       accountId: args.entry.accountId,
       kind: 'file-transfer',
-      reason: args.guard.reason === 'no-gateway-context' ? 'no-gateway-context' : 'no-active-connection',
+      reason:
+        args.guard.reason === 'no-gateway-context' ? 'no-gateway-context' : 'no-active-connection',
       recentInboundReachable:
-        args.guard.reason === 'no-active-connection' ? args.guard.recentInboundReachable : undefined,
+        args.guard.reason === 'no-active-connection'
+          ? args.guard.recentInboundReachable
+          : undefined,
     });
   }
 
@@ -2421,12 +2504,24 @@ class BncrBridgeRuntime {
       routeSelection: selection,
     });
     if (!guard.ok) {
+      this.recordOutboxPrePushFailure({
+        entry,
+        lastError:
+          guard.reason === 'no-gateway-context'
+            ? 'gateway context unavailable'
+            : 'no active bncr client',
+        persist: true,
+      });
       this.logOutboxPushSkip({
         messageId: entry.messageId,
         accountId: entry.accountId,
         reason: guard.reason,
         recentInboundReachable:
           guard.reason === 'no-active-connection' ? guard.recentInboundReachable : undefined,
+        routeReason: selection.routeReason,
+        connIds: selection.connIds,
+        ownerConnId: selection.ownerConnId,
+        ownerClientId: owner?.clientId,
       });
       return false;
     }
@@ -2458,10 +2553,24 @@ class BncrBridgeRuntime {
     kind?: 'file-transfer';
     reason: string;
     recentInboundReachable?: boolean;
+    routeReason?: string;
+    connIds?: Iterable<string>;
+    ownerConnId?: string;
+    ownerClientId?: string;
   }) {
+    this.logInfo(
+      'outbox push skip',
+      `mid=${args.messageId}|q=${this.outbox.size}|reason=${args.reason}${args.kind ? `|kind=${args.kind}` : ''}`,
+    );
     this.logInfo(
       'outbox',
-      `push-skip ${JSON.stringify(buildOutboxPushSkipDebugInfo(args))}`,
+      `push-skip ${JSON.stringify(
+        buildOutboxPushSkipDebugInfo({
+          ...args,
+          activeConnectionCount: this.activeConnectionCount(args.accountId),
+          connections: this.connections.values(),
+        }),
+      )}`,
       { debugOnly: true },
     );
   }
@@ -2492,11 +2601,9 @@ class BncrBridgeRuntime {
     retryable?: boolean;
     lastError?: string;
   }) {
-    this.logInfo(
-      'outbox',
-      `push-fail ${JSON.stringify(buildPushFailureDebugInfo(args))}`,
-      { debugOnly: true },
-    );
+    this.logInfo('outbox', `push-fail ${JSON.stringify(buildPushFailureDebugInfo(args))}`, {
+      debugOnly: true,
+    });
   }
 
   private logOutboxPushOkSummary(messageId: string) {
@@ -2549,14 +2656,18 @@ class BncrBridgeRuntime {
           sessionKey: args.entry.sessionKey,
           to: formatDisplayScope(args.entry.route),
           kind:
-            isPlainObject(args.entry.payload?._meta) && args.entry.payload?._meta?.kind === 'file-transfer'
+            isPlainObject(args.entry.payload?._meta) &&
+            args.entry.payload?._meta?.kind === 'file-transfer'
               ? 'file-transfer'
               : undefined,
           requireAck: args.requireAck,
           ackResult: args.ackResult,
           ackStage: 'message',
           ackOutcome: args.ackResult,
-          reason: args.ackResult === 'timeout' ? OUTBOUND_TERMINAL_REASON.PUSH_ACK_TIMEOUT : 'message-acked',
+          reason:
+            args.ackResult === 'timeout'
+              ? OUTBOUND_TERMINAL_REASON.PUSH_ACK_TIMEOUT
+              : 'message-acked',
           ackTimeoutMs: typeof args.ackTimeoutMs === 'number' ? args.ackTimeoutMs : undefined,
           adaptiveAckTimeoutEnabled: ADAPTIVE_ACK_TIMEOUT_DEFAULT_ENABLED,
           onlineNow: args.onlineNow,
@@ -2581,16 +2692,13 @@ class BncrBridgeRuntime {
     localNextDelay: number | null;
     ackTimeoutMs?: number | null;
   }) {
-    this.logOutboxAckSummary(
-      args.requireAck ? 'outbox ack timeout' : 'outbox ack retry',
-      {
-        messageId: args.entry.messageId,
-        connId: args.entry.lastPushConnId,
-        clientId: args.entry.lastPushClientId,
-        err: args.requireAck ? undefined : args.entry.lastError,
-        waitMs: args.requireAck ? args.ackTimeoutMs : undefined,
-      },
-    );
+    this.logOutboxAckSummary(args.requireAck ? 'outbox ack timeout' : 'outbox ack retry', {
+      messageId: args.entry.messageId,
+      connId: args.entry.lastPushConnId,
+      clientId: args.entry.lastPushClientId,
+      err: args.requireAck ? undefined : args.entry.lastError,
+      waitMs: args.requireAck ? args.ackTimeoutMs : undefined,
+    });
     this.logInfo(
       'outbox',
       `retry-reroute ${JSON.stringify(
@@ -2626,12 +2734,7 @@ class BncrBridgeRuntime {
     stale: boolean,
     result: { ok: true; movedToDeadLetter?: true; willRetry?: true },
   ) {
-    respond(
-      true,
-      stale
-        ? { ...result, stale: true, staleAccepted: true }
-        : result,
-    );
+    respond(true, stale ? { ...result, stale: true, staleAccepted: true } : result);
   }
 
   private prepareAckHandling(args: {
@@ -2733,19 +2836,18 @@ class BncrBridgeRuntime {
       outboundReady: true,
       preferredForOutbound: true,
     });
-    const ackAt = now();
+    const telemetryPatch = buildBncrAckOkTelemetryPatch({
+      entry: args.entry,
+      ackAt: now(),
+      defaultAckTimeoutMs: PUSH_ACK_TIMEOUT_MS,
+    });
+    const { ackAt, ackQueueLatencyMs, ackPushLatencyMs, lateAccepted } = telemetryPatch;
     this.lastAckOkByAccount.set(args.accountId, ackAt);
-    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;
     this.lastAckQueueLatencyMsByAccount.set(args.accountId, ackQueueLatencyMs);
     if (typeof ackPushLatencyMs === 'number') {
       this.lastAckPushLatencyMsByAccount.set(args.accountId, ackPushLatencyMs);
     }
-    const lateAccepted = args.entry.awaitingRetryPush === true;
-    if (lateAccepted) {
+    if (telemetryPatch.shouldResetAdaptiveAckRecovery) {
       this.adaptiveAckRecoveryOkCountByAccount.set(args.accountId, 0);
       this.lateAckOkCountByAccount.set(
         args.accountId,
@@ -2758,7 +2860,7 @@ class BncrBridgeRuntime {
       }
       args.entry.awaitingRetryPush = false;
       args.entry.lastError = undefined;
-    } else if (typeof ackPushLatencyMs === 'number' && ackPushLatencyMs <= PUSH_ACK_TIMEOUT_MS) {
+    } else if (telemetryPatch.shouldIncrementAdaptiveAckRecovery) {
       this.adaptiveAckRecoveryOkCountByAccount.set(
         args.accountId,
         this.getCounter(this.adaptiveAckRecoveryOkCountByAccount, args.accountId) + 1,
@@ -2800,16 +2902,18 @@ class BncrBridgeRuntime {
     clientId?: string;
     error: string;
   }) {
-    args.entry.nextAttemptAt = now() + 1_000;
-    args.entry.lastError = args.error;
-    args.entry.awaitingRetryPush = true;
-    this.outbox.set(args.messageId, args.entry);
+    const nextEntry = buildBncrAckRetryEntryPatch({
+      entry: args.entry,
+      error: args.error,
+      nextAttemptAt: now() + 1_000,
+    });
+    this.outbox.set(args.messageId, nextEntry);
     this.scheduleSave();
     this.logOutboxAckSummary('outbox ack retry', {
       messageId: args.messageId,
       connId: args.connId,
       clientId: args.clientId,
-      err: args.entry.lastError,
+      err: nextEntry.lastError,
     });
   }
 
@@ -2837,7 +2941,7 @@ class BncrBridgeRuntime {
         entry,
       });
       this.respondAckResult(respond, staleObserved.stale, { ok: true });
-      this.flushPushQueue({
+      this.flushPushQueueBestEffort({
         accountId,
         trigger: OUTBOUND_FLUSH_TRIGGER.ACK_OK,
         reason: OUTBOUND_FLUSH_REASON.MESSAGE_ACKED,
@@ -2978,7 +3082,15 @@ class BncrBridgeRuntime {
     inboundOnly: boolean;
     context: GatewayRequestHandlerOptions['context'];
   }) {
-    const { accountId, connId, clientId, outboundReady, preferredForOutbound, inboundOnly, context } = args;
+    const {
+      accountId,
+      connId,
+      clientId,
+      outboundReady,
+      preferredForOutbound,
+      inboundOnly,
+      context,
+    } = args;
     this.refreshAcceptedFileTransferLiveState({
       accountId,
       connId,
@@ -3017,19 +3129,23 @@ class BncrBridgeRuntime {
     recentInboundReachable: boolean;
     event: string;
   }) {
-    this.logInfo(
-      'outbox',
-      `push ${JSON.stringify(buildOutboxPushOkDebugInfo(args))}`,
-      { debugOnly: true },
-    );
+    this.logInfo('outbox', `push ${JSON.stringify(buildOutboxPushOkDebugInfo(args))}`, {
+      debugOnly: true,
+    });
   }
 
   private recordOutboxPrePushFailure(args: {
     entry: OutboxEntry;
     lastError: string;
+    persist?: boolean;
   }) {
-    args.entry.lastError = args.lastError;
-    this.outbox.set(args.entry.messageId, args.entry);
+    const nextEntry = buildBncrOutboxFailureEntryPatch({
+      entry: args.entry,
+      lastError: args.lastError,
+    });
+    Object.assign(args.entry, nextEntry);
+    this.outbox.set(nextEntry.messageId, args.entry);
+    if (args.persist) this.scheduleSave();
   }
 
   private recordOutboxPushFailure(args: {
@@ -3038,8 +3154,12 @@ class BncrBridgeRuntime {
     fallbackError: string;
     persist?: boolean;
   }) {
-    args.entry.lastError = asString((args.error as any)?.message || args.error || args.fallbackError);
-    this.outbox.set(args.entry.messageId, args.entry);
+    const nextEntry = buildBncrOutboxFailureEntryPatch({
+      entry: args.entry,
+      lastError: asString((args.error as any)?.message || args.error || args.fallbackError),
+    });
+    Object.assign(args.entry, nextEntry);
+    this.outbox.set(nextEntry.messageId, args.entry);
     if (args.persist) this.scheduleSave();
   }
 
@@ -3050,23 +3170,19 @@ class BncrBridgeRuntime {
     ownerClientId?: string;
     clearLastError?: boolean;
   }) {
-    const connIds = Array.from(args.connIds);
-    args.entry.lastPushAt = now();
-    args.entry.lastPushConnId =
-      args.ownerConnId || (connIds.length === 1 ? connIds[0] : undefined);
-    args.entry.lastPushClientId = args.ownerClientId;
-    args.entry.awaitingRetryPush = false;
-    if (!Array.isArray(args.entry.routeAttemptConnIds)) args.entry.routeAttemptConnIds = [];
-    if (
-      args.entry.lastPushConnId &&
-      !args.entry.routeAttemptConnIds.includes(args.entry.lastPushConnId)
-    ) {
-      args.entry.routeAttemptConnIds.push(args.entry.lastPushConnId);
-    }
-    if (args.clearLastError) args.entry.lastError = undefined;
-    this.outbox.set(args.entry.messageId, args.entry);
-    this.lastOutboundByAccount.set(args.entry.accountId, args.entry.lastPushAt);
-    this.markActivity(args.entry.accountId, args.entry.lastPushAt);
+    const pushedAt = now();
+    const nextEntry = buildBncrOutboxPushSuccessEntryPatch({
+      entry: args.entry,
+      connIds: args.connIds,
+      pushedAt,
+      ownerConnId: args.ownerConnId,
+      ownerClientId: args.ownerClientId,
+      clearLastError: args.clearLastError,
+    });
+    Object.assign(args.entry, nextEntry);
+    this.outbox.set(nextEntry.messageId, args.entry);
+    this.lastOutboundByAccount.set(nextEntry.accountId, pushedAt);
+    this.markActivity(nextEntry.accountId, pushedAt);
     this.scheduleSave();
   }
 
@@ -3093,49 +3209,107 @@ class BncrBridgeRuntime {
     this.pushTimer = setTimeout(() => {
       this.pushTimer = null;
       if (this.stopped) return;
-      void this.flushPushQueue({
+      this.flushPushQueueBestEffort({
         trigger: OUTBOUND_FLUSH_TRIGGER.TIMER,
         reason: OUTBOUND_FLUSH_REASON.SCHEDULED_DRAIN,
       });
     }, delay);
   }
 
+  private flushPushQueueBestEffort(args?: {
+    accountId?: string;
+    trigger?: string;
+    reason?: string;
+  }) {
+    void this.flushPushQueue(args)
+      .then(() => {
+        this.pushDrainExceptionRetryCount = 0;
+      })
+      .catch((error) => {
+        const accountId = args?.accountId ? normalizeAccountId(args.accountId) : '';
+        const reason = asString(args?.reason || args?.trigger || 'flush-error');
+        const err = asString((error as any)?.message || error || 'flush-error');
+        const nextRetryCount = this.pushDrainExceptionRetryCount + 1;
+        const willRetry = nextRetryCount <= PUSH_DRAIN_EXCEPTION_RETRY_LIMIT;
+        this.pushDrainExceptionRetryCount = nextRetryCount;
+        this.logError(
+          'outbox drain fail',
+          `accountId=${accountId || '-'}|reason=${reason}|err=${err}|retry=${willRetry ? nextRetryCount : 'false'}|limit=${PUSH_DRAIN_EXCEPTION_RETRY_LIMIT}`,
+        );
+        if (willRetry) {
+          this.schedulePushDrain(PUSH_DRAIN_EXCEPTION_RETRY_DELAY_MS);
+        }
+      });
+  }
+
   private isOutboundAckRequired(accountId?: string) {
-    try {
-      const cfg = getOpenClawRuntimeConfig(this.api);
-      const channelCfg = (cfg as any)?.channels?.[CHANNEL_ID];
-      const accountCfg =
-        accountId && channelCfg?.accounts && typeof channelCfg.accounts === 'object'
-          ? (channelCfg.accounts as Record<string, any>)[normalizeAccountId(accountId)]
-          : null;
-      const scoped = accountCfg?.outboundRequireAck;
-      const global = channelCfg?.outboundRequireAck;
-      if (typeof scoped === 'boolean') return scoped;
-      if (typeof global === 'boolean') return global;
-      return true;
-    } catch {
-      return true;
-    }
+    return resolveBncrOutboundAckRequired({ api: this.api, accountId });
   }
 
   private buildRuntimeFlags(accountId?: string) {
-    let ackPolicySource: 'channel' | 'default' = 'default';
-    try {
-      const cfg = getOpenClawRuntimeConfig(this.api);
-      const global = (cfg as any)?.channels?.[CHANNEL_ID]?.outboundRequireAck;
-      if (typeof global === 'boolean') ackPolicySource = 'channel';
-    } catch {
-      // keep default source
-    }
-    return {
-      outboundRequireAck: this.isOutboundAckRequired(accountId),
-      ackPolicySource,
-      messageAckTimeoutMs: this.resolveMessageAckTimeoutMs(accountId),
+    return buildBncrRuntimeFlags({
+      api: this.api,
+      accountId,
+      resolveMessageAckTimeoutMs: (acc?: string) => this.resolveMessageAckTimeoutMs(acc),
       adaptiveAckTimeoutEnabled: ADAPTIVE_ACK_TIMEOUT_DEFAULT_ENABLED,
       defaultMessageAckTimeoutMs: PUSH_ACK_TIMEOUT_MS,
       fileAckTimeoutMs: FILE_ACK_TIMEOUT_MS,
       debugVerbose: BNCR_DEBUG_VERBOSE,
-    };
+    });
+  }
+
+  private getAccountPendingOutboxEntries(accountId: string) {
+    const acc = normalizeAccountId(accountId);
+    return Array.from(this.outbox.values()).filter((entry) => entry.accountId === acc);
+  }
+
+  private maybeLogOutboxDrainStuck(args: {
+    accountId: string;
+    trigger: string;
+    reason: string;
+  }) {
+    const acc = normalizeAccountId(args.accountId);
+    const startedAt = this.pushDrainRunningSinceByAccount.get(acc) || 0;
+    if (!startedAt) return;
+
+    const t = now();
+    const runningMs = Math.max(0, t - startedAt);
+    if (runningMs < PUSH_DRAIN_STUCK_WARN_MS) return;
+
+    const lastWarnedAt = this.pushDrainStuckWarnedAtByAccount.get(acc) || 0;
+    if (lastWarnedAt && t - lastWarnedAt < PUSH_DRAIN_STUCK_WARN_MS) return;
+
+    const pendingEntries = this.getAccountPendingOutboxEntries(acc);
+    const pending = pendingEntries.length;
+    if (!pending) return;
+
+    this.pushDrainStuckWarnedAtByAccount.set(acc, t);
+    this.logWarn(
+      'outbox drain stuck',
+      `accountId=${acc}|pending=${pending}|runningMs=${runningMs}|waiters=${this.messageAckWaiters.size}/${this.fileAckWaiters.size}`,
+    );
+    this.logInfo(
+      'outbox',
+      `drain-stuck ${JSON.stringify(
+        buildOutboxDrainStuckDebugInfo({
+          bridgeId: this.bridgeId,
+          accountId: acc,
+          reason: args.reason,
+          trigger: args.trigger,
+          outboxSize: this.outbox.size,
+          pending,
+          runningMs,
+          runningSince: startedAt,
+          hasGatewayContext: Boolean(this.gatewayContext),
+          activeConnectionCount: this.activeConnectionCount(acc),
+          messageAckWaiters: this.messageAckWaiters.size,
+          fileAckWaiters: this.fileAckWaiters.size,
+          pendingEntries,
+          connections: this.connections.values(),
+        }),
+      )}`,
+      { debugOnly: true },
+    );
   }
 
   private async flushPushQueue(args?: {
@@ -3195,7 +3369,28 @@ class BncrBridgeRuntime {
     let globalNextDelay: number | null = null;
 
     for (const acc of targetAccounts) {
-      if (!acc || this.pushDrainRunningAccounts.has(acc)) continue;
+      if (!acc) continue;
+      if (this.pushDrainRunningAccounts.has(acc)) {
+        this.logInfo(
+          'outbox',
+          `drain-skip ${JSON.stringify(
+            buildOutboxDrainSkipDebugInfo({
+              bridgeId: this.bridgeId,
+              accountId: acc,
+              reason: 'already-running',
+              outboxSize: this.outbox.size,
+              trigger,
+            }),
+          )}`,
+          { debugOnly: true },
+        );
+        this.maybeLogOutboxDrainStuck({
+          accountId: acc,
+          trigger,
+          reason: reason || 'already-running',
+        });
+        continue;
+      }
       const online = this.isOnline(acc);
       const recentInboundReachable = this.hasRecentInboundReachability(acc);
       this.logInfo(
@@ -3212,6 +3407,8 @@ class BncrBridgeRuntime {
         { debugOnly: true },
       );
       this.pushDrainRunningAccounts.add(acc);
+      this.pushDrainRunningSinceByAccount.set(acc, now());
+      this.pushDrainStuckWarnedAtByAccount.delete(acc);
       try {
         let localNextDelay: number | null = null;
         let processedThisRun = 0;
@@ -3219,7 +3416,10 @@ class BncrBridgeRuntime {
 
         while (true) {
           if (this.stopped) break;
-          if (processedThisRun > 0 && now() - accountDrainStartedAt >= PUSH_DRAIN_ACCOUNT_TIME_BUDGET_MS) {
+          if (
+            processedThisRun > 0 &&
+            now() - accountDrainStartedAt >= PUSH_DRAIN_ACCOUNT_TIME_BUDGET_MS
+          ) {
             localNextDelay = updateMinOutboxDelay(localNextDelay, 0);
             this.logInfo(
               'outbox',
@@ -3286,14 +3486,63 @@ class BncrBridgeRuntime {
 
           const onlineNow = this.isOnline(acc);
           const recentInboundReachable = this.hasRecentInboundReachability(acc);
-          const pushed = await this.tryPushEntry(entry);
+          let pushed = false;
+          try {
+            pushed = await this.tryPushEntry(entry);
+          } catch (error) {
+            const meta = isPlainObject(entry.payload?._meta) ? entry.payload._meta : null;
+            if (meta?.kind === 'file-transfer') {
+              this.handleFileTransferPushFailure({
+                entry,
+                error,
+              });
+            } else {
+              this.handleTextPushFailure({
+                entry,
+                error,
+              });
+            }
+            pushed = false;
+          }
           processedThisRun += 1;
           if (pushed) {
             const requireAck = this.isOutboundAckRequired(acc);
             const ackTimeoutMs = requireAck ? this.resolveMessageAckTimeoutMs(acc) : null;
             let ackResult: 'acked' | 'timeout' = requireAck ? 'timeout' : 'acked';
             if (onlineNow && requireAck) {
-              ackResult = await this.waitForMessageAck(entry.messageId, ackTimeoutMs || PUSH_ACK_TIMEOUT_MS);
+              this.logInfo(
+                'outbox',
+                `ack wait-start ${JSON.stringify(
+                  buildOutboxAckDebugInfo({
+                    messageId: entry.messageId,
+                    accountId: entry.accountId,
+                    sessionKey: entry.sessionKey,
+                    to: formatDisplayScope(entry.route),
+                    kind:
+                      isPlainObject(entry.payload?._meta) &&
+                      entry.payload?._meta?.kind === 'file-transfer'
+                        ? 'file-transfer'
+                        : undefined,
+                    requireAck,
+                    ackResult: 'timeout',
+                    ackStage: 'message',
+                    ackOutcome: 'waiting',
+                    ackTimeoutMs: ackTimeoutMs || PUSH_ACK_TIMEOUT_MS,
+                    adaptiveAckTimeoutEnabled: ADAPTIVE_ACK_TIMEOUT_DEFAULT_ENABLED,
+                    onlineNow,
+                    recentInboundReachable,
+                    connIds: entry.lastPushConnId ? [entry.lastPushConnId] : [],
+                    ownerConnId: entry.lastPushConnId,
+                    ownerClientId: entry.lastPushClientId,
+                    event: BNCR_PUSH_EVENT,
+                  }),
+                )}`,
+                { debugOnly: true },
+              );
+              ackResult = await this.waitForMessageAck(
+                entry.messageId,
+                ackTimeoutMs || PUSH_ACK_TIMEOUT_MS,
+              );
             }
 
             this.logOutboxAckWait({
@@ -3356,14 +3605,8 @@ class BncrBridgeRuntime {
               continue;
             }
 
-            entry.routeAttemptConnIds = decision.attemptedConnIds;
-            entry.fastReroutePending = decision.fastReroutePending;
-            entry.retryCount = decision.nextRetryCount;
-            entry.lastAttemptAt = decision.lastAttemptAt;
-            entry.nextAttemptAt = decision.nextAttemptAt;
-            entry.lastError = decision.lastError;
-            entry.routeAttemptRound = decision.routeAttemptRound;
-            this.outbox.set(entry.messageId, entry);
+            const nextEntry = applyBncrRetryRerouteDecisionToEntry(entry, decision);
+            this.outbox.set(entry.messageId, nextEntry);
             this.scheduleSave();
             if (requireAck) {
               this.lastAckTimeoutByAccount.set(acc, now());
@@ -3377,7 +3620,7 @@ class BncrBridgeRuntime {
             localNextDelay = updateMinOutboxDelay(localNextDelay, wait);
             this.logOutboxAckReroute({
               accountId: acc,
-              entry,
+              entry: nextEntry,
               requireAck,
               currentConnId,
               availableConnIds,
@@ -3408,11 +3651,8 @@ class BncrBridgeRuntime {
             continue;
           }
 
-          entry.retryCount = decision.nextRetryCount;
-          entry.lastAttemptAt = decision.lastAttemptAt;
-          entry.nextAttemptAt = decision.nextAttemptAt;
-          entry.lastError = decision.lastError;
-          this.outbox.set(entry.messageId, entry);
+          const nextEntry = applyBncrPushFailureDecisionToEntry(entry, decision);
+          this.outbox.set(entry.messageId, nextEntry);
           this.scheduleSave();
 
           const wait = computeOutboxRetryWait(decision.nextAttemptAt, t);
@@ -3452,6 +3692,8 @@ class BncrBridgeRuntime {
         }
       } finally {
         this.pushDrainRunningAccounts.delete(acc);
+        this.pushDrainRunningSinceByAccount.delete(acc);
+        this.pushDrainStuckWarnedAtByAccount.delete(acc);
       }
     }
 
@@ -3474,12 +3716,7 @@ class BncrBridgeRuntime {
 
   private async waitForMessageAck(messageId: string, waitMs: number): Promise<'acked' | 'timeout'> {
     const key = asString(messageId).trim();
-    const timeoutMs = clampFiniteNumber(
-      waitMs,
-      0,
-      0,
-      RECOMMENDED_ACK_TIMEOUT_MAX_MS,
-    );
+    const timeoutMs = clampFiniteNumber(waitMs, 0, 0, RECOMMENDED_ACK_TIMEOUT_MAX_MS);
     if (!key || !timeoutMs) return 'timeout';
 
     const existing = this.messageAckWaiters.get(key);
@@ -3581,7 +3818,9 @@ class BncrBridgeRuntime {
     const t = now();
     const prev = this.connections.get(key);
     const previousActiveKey = this.activeConnectionByAccount.get(acc) || null;
-    const previousActiveConn = previousActiveKey ? this.connections.get(previousActiveKey) || null : null;
+    const previousActiveConn = previousActiveKey
+      ? this.connections.get(previousActiveKey) || null
+      : null;
 
     const nextConn = {
       accountId: acc,
@@ -3966,9 +4205,7 @@ class BncrBridgeRuntime {
   }
 
   private fileAckKey(transferId: string, stage: string, chunkIndex?: number): string {
-    const n = Number(chunkIndex);
-    const idx = Number.isInteger(n) && n >= 0 ? String(n) : '-';
-    return `${transferId}|${stage}|${idx}`;
+    return buildFileAckKey({ transferId, stage, chunkIndex });
   }
 
   private fileAckOwnerInfo(transferId: string) {
@@ -4003,8 +4240,9 @@ class BncrBridgeRuntime {
           ackStage: stage,
           ackOutcome: cached.ok ? 'acked' : 'failed',
           waiterReused: false,
-          chunkIndex:
-            Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+          chunkIndex: Number.isFinite(Number(params.chunkIndex))
+            ? Number(params.chunkIndex)
+            : undefined,
           key,
           ...ownerInfo,
           ok: cached.ok,
@@ -4031,8 +4269,9 @@ class BncrBridgeRuntime {
           ackStage: stage,
           ackOutcome: 'waiter-reused',
           waiterReused: true,
-          chunkIndex:
-            Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+          chunkIndex: Number.isFinite(Number(params.chunkIndex))
+            ? Number(params.chunkIndex)
+            : undefined,
           key,
           ...ownerInfo,
         }),
@@ -4050,8 +4289,9 @@ class BncrBridgeRuntime {
         ackStage: stage,
         ackOutcome: 'waiting',
         waiterReused: false,
-        chunkIndex:
-          Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+        chunkIndex: Number.isFinite(Number(params.chunkIndex))
+          ? Number(params.chunkIndex)
+          : undefined,
         key,
         ...ownerInfo,
         timeoutMs,
@@ -4076,8 +4316,9 @@ class BncrBridgeRuntime {
             ackStage: stage,
             ackOutcome: 'timeout',
             waiterReused: false,
-            chunkIndex:
-              Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+            chunkIndex: Number.isFinite(Number(params.chunkIndex))
+              ? Number(params.chunkIndex)
+              : undefined,
             key,
             ...ownerInfo,
             timeoutMs,
@@ -4123,8 +4364,9 @@ class BncrBridgeRuntime {
           ackStage: stage,
           ackOutcome: params.ok ? 'early-acked' : 'early-failed',
           waiterReused: false,
-          chunkIndex:
-            Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+          chunkIndex: Number.isFinite(Number(params.chunkIndex))
+            ? Number(params.chunkIndex)
+            : undefined,
           key,
           ...ownerInfo,
           ok: params.ok,
@@ -4146,8 +4388,9 @@ class BncrBridgeRuntime {
         ackStage: stage,
         ackOutcome: params.ok ? 'acked' : 'failed',
         waiterReused: false,
-        chunkIndex:
-          Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+        chunkIndex: Number.isFinite(Number(params.chunkIndex))
+          ? Number(params.chunkIndex)
+          : undefined,
         key,
         ...ownerInfo,
         ok: params.ok,
@@ -4196,31 +4439,6 @@ class BncrBridgeRuntime {
     return mt || 'file';
   }
 
-
-  private buildRuntimeQueueSnapshot(accountId: string) {
-    const pending = Array.from(this.outbox.values()).filter((v) => v.accountId === accountId).length;
-    const deadLetter = this.deadLetter.filter((v) => v.accountId === accountId).length;
-    const sessionRoutesCount = Array.from(this.sessionRoutes.values()).filter(
-      (v) => v.accountId === accountId,
-    ).length;
-    return {
-      pending,
-      deadLetter,
-      sessionRoutesCount,
-      invalidOutboxSessionKeys: this.countInvalidOutboxSessionKeys(accountId),
-      legacyAccountResidue: this.countLegacyAccountResidue(accountId),
-    };
-  }
-
-  private buildRuntimeEventCounters(accountId: string) {
-    return {
-      connectEvents: this.getCounter(this.connectEventsByAccount, accountId),
-      inboundEvents: this.getCounter(this.inboundEventsByAccount, accountId),
-      activityEvents: this.getCounter(this.activityEventsByAccount, accountId),
-      ackEvents: this.getCounter(this.ackEventsByAccount, accountId),
-    };
-  }
-
   private computeRecommendedAckTimeoutReason(args: {
     lateAckOkCount: number;
     recentAckTimeoutCount: number;
@@ -4230,26 +4448,15 @@ class BncrBridgeRuntime {
     recommendedAckTimeoutMs?: number;
     nowMs?: number;
   }) {
-    if (args.recentAckTimeoutCount <= 0) return 'no-timeout-evidence';
-    if (args.lateAckOkCount <= 0) return 'no-late-ack-evidence';
-    if (typeof args.lastLateAckPushLatencyMs !== 'number') return 'missing-latency';
-    const lastLateAckOkAt = typeof args.lastLateAckOkAt === 'number' ? args.lastLateAckOkAt : null;
-    const nowMs = typeof args.nowMs === 'number' ? args.nowMs : now();
-    if (
-      typeof lastLateAckOkAt === 'number' &&
-      lastLateAckOkAt > 0 &&
-      nowMs - lastLateAckOkAt > ADAPTIVE_ACK_TIMEOUT_OBSERVATION_TTL_MS
-    ) {
-      return 'late-ack-expired';
-    }
-    if (
-      typeof args.adaptiveAckRecoveryOkCount === 'number' &&
-      args.adaptiveAckRecoveryOkCount >= ADAPTIVE_ACK_TIMEOUT_RECOVERY_OK_THRESHOLD
-    ) {
-      return 'recovered';
-    }
-    if (args.recommendedAckTimeoutMs === RECOMMENDED_ACK_TIMEOUT_MAX_MS) return 'capped-max';
-    return 'late-ack-observed';
+    return computeBncrRecommendedAckTimeoutReason({
+      ...args,
+      nowMs: typeof args.nowMs === 'number' ? args.nowMs : now(),
+      defaultAckTimeoutMs: PUSH_ACK_TIMEOUT_MS,
+      minAckTimeoutMs: RECOMMENDED_ACK_TIMEOUT_MIN_MS,
+      maxAckTimeoutMs: RECOMMENDED_ACK_TIMEOUT_MAX_MS,
+      lateAckObservationTtlMs: ADAPTIVE_ACK_TIMEOUT_OBSERVATION_TTL_MS,
+      recoveryOkThreshold: ADAPTIVE_ACK_TIMEOUT_RECOVERY_OK_THRESHOLD,
+    });
   }
 
   private computeRecommendedAckTimeoutMs(args: {
@@ -4260,29 +4467,15 @@ class BncrBridgeRuntime {
     adaptiveAckRecoveryOkCount?: number;
     nowMs?: number;
   }) {
-    const lastLateAckOkAt = typeof args.lastLateAckOkAt === 'number' ? args.lastLateAckOkAt : null;
-    const nowMs = typeof args.nowMs === 'number' ? args.nowMs : now();
-    const lateAckExpired =
-      typeof lastLateAckOkAt === 'number' &&
-      lastLateAckOkAt > 0 &&
-      nowMs - lastLateAckOkAt > ADAPTIVE_ACK_TIMEOUT_OBSERVATION_TTL_MS;
-    const recovered =
-      typeof args.adaptiveAckRecoveryOkCount === 'number' &&
-      args.adaptiveAckRecoveryOkCount >= ADAPTIVE_ACK_TIMEOUT_RECOVERY_OK_THRESHOLD;
-    if (
-      args.lateAckOkCount <= 0 ||
-      args.recentAckTimeoutCount <= 0 ||
-      typeof args.lastLateAckPushLatencyMs !== 'number' ||
-      lateAckExpired ||
-      recovered
-    ) {
-      return PUSH_ACK_TIMEOUT_MS;
-    }
-    const recommended = Math.ceil(args.lastLateAckPushLatencyMs * 1.25);
-    return Math.min(
-      RECOMMENDED_ACK_TIMEOUT_MAX_MS,
-      Math.max(RECOMMENDED_ACK_TIMEOUT_MIN_MS, recommended),
-    );
+    return computeBncrRecommendedAckTimeoutMs({
+      ...args,
+      nowMs: typeof args.nowMs === 'number' ? args.nowMs : now(),
+      defaultAckTimeoutMs: PUSH_ACK_TIMEOUT_MS,
+      minAckTimeoutMs: RECOMMENDED_ACK_TIMEOUT_MIN_MS,
+      maxAckTimeoutMs: RECOMMENDED_ACK_TIMEOUT_MAX_MS,
+      lateAckObservationTtlMs: ADAPTIVE_ACK_TIMEOUT_OBSERVATION_TTL_MS,
+      recoveryOkThreshold: ADAPTIVE_ACK_TIMEOUT_RECOVERY_OK_THRESHOLD,
+    });
   }
 
   private maybeLogAdaptiveAckTimeout(args: {
@@ -4327,7 +4520,10 @@ class BncrBridgeRuntime {
     const recentAckTimeoutCount = this.getCounter(this.ackTimeoutCountByAccount, acc);
     const lastLateAckPushLatencyMs = this.lastLateAckPushLatencyMsByAccount.get(acc) || null;
     const lastLateAckOkAt = this.lastLateAckOkByAccount.get(acc) || null;
-    const adaptiveAckRecoveryOkCount = this.getCounter(this.adaptiveAckRecoveryOkCountByAccount, acc);
+    const adaptiveAckRecoveryOkCount = this.getCounter(
+      this.adaptiveAckRecoveryOkCountByAccount,
+      acc,
+    );
     const nowMs = now();
     const timeoutMs = this.computeRecommendedAckTimeoutMs({
       lateAckOkCount,
@@ -4364,12 +4560,18 @@ class BncrBridgeRuntime {
     const lastLateAckOkAt = this.lastLateAckOkByAccount.get(acc) || null;
     const nowMs = now();
     const lastLateAckAgeMs =
-      typeof lastLateAckOkAt === 'number' && lastLateAckOkAt > 0 ? Math.max(0, nowMs - lastLateAckOkAt) : null;
+      typeof lastLateAckOkAt === 'number' && lastLateAckOkAt > 0
+        ? Math.max(0, nowMs - lastLateAckOkAt)
+        : null;
     const lateAckObservationTtlMs = ADAPTIVE_ACK_TIMEOUT_OBSERVATION_TTL_MS;
     const lateAckObservationExpired =
       typeof lastLateAckAgeMs === 'number' && lastLateAckAgeMs > lateAckObservationTtlMs;
-    const adaptiveAckRecoveryOkCount = this.getCounter(this.adaptiveAckRecoveryOkCountByAccount, acc);
-    const adaptiveAckRecovered = adaptiveAckRecoveryOkCount >= ADAPTIVE_ACK_TIMEOUT_RECOVERY_OK_THRESHOLD;
+    const adaptiveAckRecoveryOkCount = this.getCounter(
+      this.adaptiveAckRecoveryOkCountByAccount,
+      acc,
+    );
+    const adaptiveAckRecovered =
+      adaptiveAckRecoveryOkCount >= ADAPTIVE_ACK_TIMEOUT_RECOVERY_OK_THRESHOLD;
     const recommendedAckTimeoutMs = this.computeRecommendedAckTimeoutMs({
       lateAckOkCount,
       recentAckTimeoutCount,
@@ -4412,44 +4614,42 @@ class BncrBridgeRuntime {
   }
 
   private buildRuntimeAckStrategy(ackObservability: Record<string, any>) {
-    const currentMs = finiteNumberOr(ackObservability.currentAckTimeoutMs, PUSH_ACK_TIMEOUT_MS);
-    const defaultMs = finiteNumberOr(ackObservability.defaultAckTimeoutMs, PUSH_ACK_TIMEOUT_MS);
-    const reason = asString(ackObservability.recommendedAckTimeoutReason || 'unknown') || 'unknown';
-    return {
-      mode: ackObservability.adaptiveAckTimeoutEnabled === true ? 'adaptive' : 'fixed',
-      currentMs,
-      defaultMs,
-      maxMs: RECOMMENDED_ACK_TIMEOUT_MAX_MS,
-      reason,
-      active: currentMs > defaultMs,
-      lastLateAckAgeMs: ackObservability.lastLateAckAgeMs ?? null,
-      lateAckObservationTtlMs: ackObservability.lateAckObservationTtlMs ?? null,
-      recovered: ackObservability.adaptiveAckRecovered === true,
-    };
-  }
-
-  private buildRuntimeActivitySnapshot(accountId: string) {
-    return {
-      activeConnections: this.activeConnectionCount(accountId),
-      lastSession: this.lastSessionByAccount.get(accountId) || null,
-      lastActivityAt: this.lastActivityByAccount.get(accountId) || null,
-      lastInboundAt: this.lastInboundByAccount.get(accountId) || null,
-      lastOutboundAt: this.lastOutboundByAccount.get(accountId) || null,
-    };
+    return buildBncrRuntimeAckStrategy({
+      ackObservability,
+      defaultAckTimeoutMs: PUSH_ACK_TIMEOUT_MS,
+      maxAckTimeoutMs: RECOMMENDED_ACK_TIMEOUT_MAX_MS,
+    });
   }
 
   private buildRuntimeStatusInput(accountId: string, overrides: { running?: boolean } = {}) {
     const acc = normalizeAccountId(accountId);
-    return {
+    const snapshots = buildRuntimeStatusSnapshots({
+      accountId: acc,
+      outboxEntries: this.outbox.values(),
+      deadLetterEntries: this.deadLetter,
+      sessionRouteEntries: this.sessionRoutes.values(),
+      countInvalidOutboxSessionKeys: (snapshotAccountId) =>
+        this.countInvalidOutboxSessionKeys(snapshotAccountId),
+      countLegacyAccountResidue: (snapshotAccountId) =>
+        this.countLegacyAccountResidue(snapshotAccountId),
+      connectEventsByAccount: this.connectEventsByAccount,
+      inboundEventsByAccount: this.inboundEventsByAccount,
+      activityEventsByAccount: this.activityEventsByAccount,
+      ackEventsByAccount: this.ackEventsByAccount,
+      activeConnectionCount: (snapshotAccountId) => this.activeConnectionCount(snapshotAccountId),
+      lastSessionByAccount: this.lastSessionByAccount,
+      lastActivityByAccount: this.lastActivityByAccount,
+      lastInboundByAccount: this.lastInboundByAccount,
+      lastOutboundByAccount: this.lastOutboundByAccount,
+    });
+    return buildBncrRuntimeStatusInput({
       accountId: acc,
       connected: this.isOnline(acc),
-      ...this.buildRuntimeQueueSnapshot(acc),
-      ...this.buildRuntimeEventCounters(acc),
-      ...this.buildRuntimeActivitySnapshot(acc),
+      ...snapshots,
       startedAt: this.startedAt,
       running: overrides.running,
       channelRoot: path.join(process.cwd(), 'plugins', 'bncr'),
-    };
+    });
   }
 
   private buildStatusMeta(accountId: string) {
@@ -4457,7 +4657,9 @@ class BncrBridgeRuntime {
   }
 
   getAccountRuntimeSnapshot(accountId: string) {
-    const snapshot = buildAccountRuntimeSnapshot(this.buildRuntimeStatusInput(accountId, { running: true }));
+    const snapshot = buildAccountRuntimeSnapshot(
+      this.buildRuntimeStatusInput(accountId, { running: true }),
+    );
     const ackObservability = this.buildRuntimeAckObservability(accountId);
     const ackStrategy = this.buildRuntimeAckStrategy(ackObservability);
     return {
@@ -4531,7 +4733,7 @@ class BncrBridgeRuntime {
     this.logOutboundSummary(entry);
     this.outbox.set(entry.messageId, entry);
     this.scheduleSave();
-    this.flushPushQueue(entry.accountId);
+    this.flushPushQueueBestEffort({ accountId: entry.accountId });
   }
 
   private moveToDeadLetter(entry: OutboxEntry, reason: string) {
@@ -4825,34 +5027,6 @@ class BncrBridgeRuntime {
     );
   }
 
-  private buildFileTransferInitPayload(args: {
-    transferId: string;
-    sessionKey: string;
-    route: BncrRoute;
-    fileName: string;
-    mimeType?: string;
-    fileSize: number;
-    chunkSize: number;
-    totalChunks: number;
-    fileSha256: string;
-  }) {
-    return {
-      transferId: args.transferId,
-      direction: 'oc2bncr' as const,
-      sessionKey: args.sessionKey,
-      platform: args.route.platform,
-      groupId: args.route.groupId,
-      userId: args.route.userId,
-      fileName: args.fileName,
-      mimeType: args.mimeType,
-      fileSize: args.fileSize,
-      chunkSize: args.chunkSize,
-      totalChunks: args.totalChunks,
-      fileSha256: args.fileSha256,
-      ts: now(),
-    };
-  }
-
   private buildInitialFileSendTransferState(args: {
     transferId: string;
     accountId: string;
@@ -5043,7 +5217,7 @@ class BncrBridgeRuntime {
 
     ctx.broadcastToConnIds(
       BNCR_FILE_INIT_EVENT,
-      this.buildFileTransferInitPayload({
+      buildFileTransferInitPayload({
         transferId,
         sessionKey: params.sessionKey,
         route: params.route,
@@ -5053,6 +5227,7 @@ class BncrBridgeRuntime {
         chunkSize,
         totalChunks,
         fileSha256,
+        ts: now(),
       }),
       connIds,
     );
@@ -5069,7 +5244,7 @@ class BncrBridgeRuntime {
       for (let attempt = 1; attempt <= 3; attempt++) {
         ctx.broadcastToConnIds(
           BNCR_FILE_CHUNK_EVENT,
-          {
+          buildFileTransferChunkPayload({
             transferId,
             chunkIndex: idx,
             offset: start,
@@ -5077,7 +5252,7 @@ class BncrBridgeRuntime {
             chunkSha256,
             base64: slice.toString('base64'),
             ts: now(),
-          },
+          }),
           connIds,
         );
 
@@ -5125,11 +5300,11 @@ class BncrBridgeRuntime {
         this.fileSendTransfers.set(transferId, st);
         ctx.broadcastToConnIds(
           BNCR_FILE_ABORT_EVENT,
-          {
+          buildFileTransferAbortPayload({
             transferId,
             reason: st.error,
             ts: now(),
-          },
+          }),
           connIds,
         );
         throw new Error(st.error);
@@ -5138,10 +5313,10 @@ class BncrBridgeRuntime {
 
     ctx.broadcastToConnIds(
       BNCR_FILE_COMPLETE_EVENT,
-      {
+      buildFileTransferCompletePayload({
         transferId,
         ts: now(),
-      },
+      }),
       connIds,
     );
 
@@ -5330,7 +5505,7 @@ class BncrBridgeRuntime {
     });
 
     // WS 一旦在线，立即尝试把离线期间积压队列直推出去
-    this.flushPushQueue({
+    this.flushPushQueueBestEffort({
       accountId,
       trigger: OUTBOUND_FLUSH_TRIGGER.CONNECT,
       reason: OUTBOUND_FLUSH_REASON.WS_ONLINE,
@@ -5412,7 +5587,7 @@ class BncrBridgeRuntime {
       deadLetter: this.deadLetter.filter((v) => v.accountId === accountId).length,
       now: now(),
     });
-    this.flushPushQueue({
+    this.flushPushQueueBestEffort({
       accountId,
       trigger: OUTBOUND_FLUSH_TRIGGER.ACTIVITY,
       reason: OUTBOUND_FLUSH_REASON.ACTIVITY_HEARTBEAT,
@@ -5575,8 +5750,21 @@ class BncrBridgeRuntime {
       respond(false, { error: 'transfer not found' });
       return;
     }
+    if (st.status === 'completed') {
+      respond(true, {
+        ok: true,
+        transferId,
+        status: 'completed',
+        path: st.completedPath,
+        ignored: true,
+        terminal: true,
+      });
+      return;
+    }
     if (chunkIndex >= st.totalChunks) {
-      respond(false, { error: `chunkIndex out of range index=${chunkIndex} total=${st.totalChunks}` });
+      respond(false, {
+        error: `chunkIndex out of range index=${chunkIndex} total=${st.totalChunks}`,
+      });
       return;
     }
 
@@ -5778,6 +5966,17 @@ class BncrBridgeRuntime {
       respond(true, { ok: true, transferId, message: 'not-found' });
       return;
     }
+    if (st.status === 'completed') {
+      respond(true, {
+        ok: true,
+        transferId,
+        status: 'completed',
+        path: st.completedPath,
+        ignored: true,
+        terminal: true,
+      });
+      return;
+    }
 
     const staleObserved = this.observeLease('file.abort', params ?? {});
     if (staleObserved.stale) {
@@ -5874,6 +6073,30 @@ class BncrBridgeRuntime {
             ? 'file.abort'
             : 'file.complete';
     const staleObserved = this.observeLease(staleKind, params ?? {});
+    if (st?.status === 'completed' || st?.status === 'aborted') {
+      respond(
+        true,
+        staleObserved.stale
+          ? {
+              ok: true,
+              transferId,
+              stage,
+              state: st.status,
+              stale: true,
+              ignored: true,
+              terminal: true,
+            }
+          : {
+              ok: true,
+              transferId,
+              stage,
+              state: st.status,
+              ignored: true,
+              terminal: true,
+            },
+      );
+      return;
+    }
     if (staleObserved.stale) {
       const sameConn = !!st?.ownerConnId && st.ownerConnId === connId;
       const sameClient =
@@ -6100,7 +6323,7 @@ class BncrBridgeRuntime {
         taskKey: extracted.taskKey ?? null,
       }),
     );
-    this.flushPushQueue({
+    this.flushPushQueueBestEffort({
       accountId,
       trigger: OUTBOUND_FLUSH_TRIGGER.INBOUND,
       reason: OUTBOUND_FLUSH_REASON.INBOUND_ACCEPTED,
@@ -6130,126 +6353,11 @@ class BncrBridgeRuntime {
   };
 
   channelStartAccount = async (ctx: any) => {
-    const accountId = normalizeAccountId(ctx.accountId);
-    this.clearChannelAccountWorker(accountId, 'start-replace');
-
-    const tick = () => {
-      const previous = ctx.getStatus?.() || {};
-      const onlineByConn = this.isOnline(accountId);
-      const recentInboundReachable = this.hasRecentInboundReachability(accountId);
-      const connected = onlineByConn || recentInboundReachable;
-      const lastActAt =
-        this.lastActivityByAccount.get(accountId) ||
-        this.lastInboundByAccount.get(accountId) ||
-        this.lastOutboundByAccount.get(accountId) ||
-        previous?.lastEventAt ||
-        null;
-      const healthSig = JSON.stringify({
-        bridge: this.bridgeId,
-        accountId,
-        connected,
-        onlineByConn,
-        recentInboundReachable,
-        activeConnectionKey: this.activeConnectionByAccount.get(accountId) || null,
-        activeConnections: Array.from(this.connections.values())
-          .filter((c) => c.accountId === accountId)
-          .map((c) => ({
-            connId: c.connId,
-            clientId: c.clientId,
-            inboundOnly: c.inboundOnly === true,
-            outboundReady: c.outboundReady === true,
-            preferredForOutbound: c.preferredForOutbound === true,
-          })),
-      });
-      const conns = Array.from(this.connections.values()).filter((c) => c.accountId === accountId).length;
-      this.logInfoDedup(
-        'health',
-        `status-tick ${accountId}|changed|${connected ? 'linked' : 'configured'}|onlineByConn=${onlineByConn}|recentInboundReachable=${recentInboundReachable}|conns=${conns}`,
-        {
-          key: `health-status-tick:${accountId}`,
-          sig: healthSig,
-        },
-      );
-      this.logInfoDedup('health', `status-tick ${healthSig}`, {
-        key: `health-status-tick-debug:${accountId}`,
-        sig: healthSig,
-        debugOnly: true,
-      });
-
-      ctx.setStatus?.({
-        ...previous,
-        accountId,
-        running: true,
-        connected,
-        lastEventAt: lastActAt,
-        // 状态映射：在线=linked，离线=configured
-        mode: connected ? 'linked' : 'configured',
-        lastError: previous?.lastError ?? null,
-        meta: this.buildStatusMeta(accountId),
-      });
-    };
-
-    tick();
-    const timer = setInterval(tick, 5_000);
-    let worker!: ChannelAccountWorkerHandle;
-    const done = new Promise<void>((resolve) => {
-      let settled = false;
-      const finish = (reason: string) => {
-        if (settled) return;
-        settled = true;
-        const activeWorker = this.channelAccountWorkers.get(accountId);
-        if (activeWorker === worker) {
-          this.channelAccountWorkers.delete(accountId);
-        }
-        clearInterval(timer);
-        worker.cleanupAbortListener?.();
-        worker.cleanupAbortListener = undefined;
-        this.logInfo(
-          'health',
-          `status-worker finished ${JSON.stringify({ bridge: this.bridgeId, accountId, reason })}`,
-          { debugOnly: true },
-        );
-        this.logInfo('health', `status-worker finished ${accountId}|${reason}`);
-        resolve();
-      };
-
-      worker = { timer, finish };
-      this.channelAccountWorkers.set(accountId, worker);
-
-      const onAbort = () => finish('abort');
-      const abortSignal = ctx.abortSignal;
-
-      if (abortSignal?.aborted) {
-        onAbort();
-        return;
-      }
-
-      abortSignal?.addEventListener?.('abort', onAbort, { once: true });
-      if (abortSignal?.removeEventListener) {
-        worker.cleanupAbortListener = () => abortSignal.removeEventListener('abort', onAbort);
-      }
-    });
-    await done;
+    await startBncrStatusWorker(this.buildStatusWorkerRuntime(), ctx);
   };
 
   channelStopAccount = async (ctx: any) => {
-    const accountId = normalizeAccountId(ctx?.accountId);
-    const cleared = this.clearChannelAccountWorker(accountId, 'explicit-stop');
-    const previous = ctx?.getStatus?.() || {};
-    ctx?.setStatus?.({
-      ...previous,
-      accountId,
-      running: false,
-      restartPending: false,
-      lastStopAt: Date.now(),
-      meta: this.buildStatusMeta(accountId),
-    });
-    this.logInfo(
-      'health',
-      `status-stop ${JSON.stringify({ bridge: this.bridgeId, accountId, cleared })}`,
-      { debugOnly: true },
-    );
-    this.logInfo('health', `status-stop ${accountId}|cleared=${cleared}`);
+    await stopBncrStatusWorker(this.buildStatusWorkerRuntime(), ctx);
   };
 
   private logChannelSendEntry(args: {
@@ -6380,7 +6488,9 @@ class BncrBridgeRuntime {
       payload,
       mediaLocalRoots: ctx.mediaLocalRoots,
     });
-    const entries = Array.from(this.outbox.values()).filter((entry) => !before.has(entry.messageId));
+    const entries = Array.from(this.outbox.values()).filter(
+      (entry) => !before.has(entry.messageId),
+    );
     if (!entries.length) {
       throw new Error('bncr channel.message handoff did not enqueue an outbox entry');
     }
@@ -6421,7 +6531,9 @@ class BncrBridgeRuntime {
       asVoice: payload.asVoice === true,
       audioAsVoice: payload.audioAsVoice === true,
       kind: payload.kind,
-      replyToId: asString(payload.replyToId || ctx?.replyToId || ctx?.replyToMessageId || '').trim() || undefined,
+      replyToId:
+        asString(payload.replyToId || ctx?.replyToId || ctx?.replyToMessageId || '').trim() ||
+        undefined,
     });
     return buildBncrDurableQueuedResult({ entry });
   };
@@ -6460,7 +6572,7 @@ export function createBncrChannelPlugin(getBridge: () => BncrBridgeRuntime) {
       };
     },
     supportsAction: ({ action }) => action === 'send',
-    extractToolSend: ({ args })  => extractOpenClawToolSend(args, 'sendMessage'),
+    extractToolSend: ({ args }) => extractOpenClawToolSend(args, 'sendMessage'),
     handleAction: async ({ action, params, accountId, mediaLocalRoots }) => {
       if (action !== 'send')
         throw new Error(`Action ${action} is not supported for provider ${CHANNEL_ID}.`);
@@ -6504,231 +6616,21 @@ export function createBncrChannelPlugin(getBridge: () => BncrBridgeRuntime) {
 
   const plugin = {
     id: CHANNEL_ID,
-    meta: {
-      id: CHANNEL_ID,
-      label: 'Bncr',
-      selectionLabel: 'Bncr Client',
-      docsPath: '/channels/bncr',
-      blurb: 'Bncr Channel.',
-      aliases: ['bncr'],
-    },
+    meta: BNCR_CHANNEL_META,
     actions: messageActions,
     message: {
-      receive: {
-        defaultAckPolicy: 'manual' as const,
-        supportedAckPolicies: ['manual'] as const,
-      },
-      send: {
-        text: async (ctx: any) => getBridge().channelMessageSendText(ctx),
-        media: async (ctx: any) => getBridge().channelMessageSendMedia(ctx),
-        payload: async (ctx: any) => getBridge().channelMessageSendPayload(ctx),
-      },
-    },
-    capabilities: {
-      chatTypes: ['direct'] as ChatType[],
-      media: true,
-      reply: true,
-      nativeCommands: true,
-    },
-    messaging: {
-      // 接收任意标签输入；不在 normalize 阶段做格式门槛，统一下沉到发送前验证。
-      normalizeTarget: (raw: string) => {
-        const input = asString(raw).trim();
-        return input || undefined;
-      },
-      parseExplicitTarget: ({ raw, accountId, cfg }: any) => {
-        const resolvedAccountId = normalizeAccountId(
-          asString(accountId || BNCR_DEFAULT_ACCOUNT_ID),
-        );
-        const runtimeBridge = getBridge();
-        const canonicalAgentId =
-          runtimeBridge.canonicalAgentId ||
-          runtimeBridge.ensureCanonicalAgentId({ cfg, accountId: resolvedAccountId });
-        return parseExplicitTarget(asString(raw).trim(), { canonicalAgentId });
-      },
-      formatTargetDisplay: ({ target }: any) => {
-        return formatTargetDisplay(target);
-      },
-      resolveSessionTarget: ({ id, accountId, cfg }: any) => {
-        const raw = asString(id).trim();
-        if (!raw) return undefined;
-        const resolvedAccountId = normalizeAccountId(
-          asString(accountId || BNCR_DEFAULT_ACCOUNT_ID),
-        );
-        const runtimeBridge = getBridge();
-        const canonicalAgentId =
-          runtimeBridge.canonicalAgentId ||
-          runtimeBridge.ensureCanonicalAgentId({ cfg, accountId: resolvedAccountId });
-
-        let parsed = parseExplicitTarget(raw, { canonicalAgentId });
-        if (!parsed) {
-          const route = runtimeBridge.resolveRouteBySession(raw, resolvedAccountId);
-          if (route) {
-            parsed = parseExplicitTarget(formatDisplayScope(route), { canonicalAgentId });
-          }
-        }
-        return parsed?.displayScope || undefined;
-      },
-      resolveOutboundSessionRoute: (params: any) => {
-        const accountId = normalizeAccountId(
-          asString(params?.accountId || BNCR_DEFAULT_ACCOUNT_ID),
-        );
-        const runtimeBridge = getBridge();
-        const canonicalAgentId =
-          runtimeBridge.canonicalAgentId ||
-          runtimeBridge.ensureCanonicalAgentId({ cfg: params?.cfg, accountId });
-        return resolveBncrOutboundSessionRoute({
-          ...params,
-          canonicalAgentId,
-          resolveRouteBySession: (raw: string, acc: string) =>
-            runtimeBridge.resolveRouteBySession(raw, acc),
-        });
-      },
-      targetResolver: {
-        looksLikeId: (raw: string, normalized?: string) => {
-          return looksLikeBncrExplicitTarget(asString(normalized || raw).trim());
-        },
-        resolveTarget: async ({ accountId, input, normalized }) => {
-          const runtimeBridge = getBridge();
-          const resolved = resolveBncrOutboundTarget({
-            target: asString(normalized || input).trim(),
-            accountId: normalizeAccountId(asString(accountId || BNCR_DEFAULT_ACCOUNT_ID)),
-            resolveRouteBySession: (raw: string, acc: string) =>
-              runtimeBridge.resolveRouteBySession(raw, acc),
-          });
-          if (!resolved) return null;
-          return {
-            to: resolved.displayScope,
-            kind: resolved.kind,
-            display: resolved.displayScope,
-            source: 'normalized' as const,
-          };
-        },
-        hint: 'Standard to=Bncr:<platform>:<group>:<user> or Bncr:<platform>:<user>; sessionKey keeps existing strict/legacy compatibility, canonical sessionKey=agent:<agentId>:bncr:direct:<hex>',
-      },
+      receive: BNCR_MESSAGE_RECEIVE_POLICY,
+      send: createBncrMessageSend(getBridge),
     },
+    capabilities: BNCR_CHANNEL_CAPABILITIES,
+    messaging: createBncrMessagingSurface(getBridge),
     configSchema: BncrConfigSchema,
-    config: {
-      listAccountIds,
-      resolveAccount,
-      setAccountEnabled: ({ cfg, accountId, enabled }: any) =>
-        setOpenClawAccountEnabledInConfigSection({
-          cfg,
-          sectionKey: CHANNEL_ID,
-          accountId,
-          enabled,
-          allowTopLevel: true,
-        }),
-      isEnabled: (account: any, cfg: any) => {
-        const policy = resolveBncrChannelPolicy(cfg?.channels?.[CHANNEL_ID] || {});
-        return policy.enabled !== false && account?.enabled !== false;
-      },
-      isConfigured: () => true,
-      describeAccount: (account: any) => {
-        const displayName = resolveDefaultDisplayName(account?.name, account?.accountId);
-        return {
-          accountId: account.accountId,
-          name: displayName,
-          enabled: account.enabled !== false,
-          configured: true,
-        };
-      },
-    },
-    setup: {
-      applyAccountName: ({ cfg, accountId, name }: any) =>
-        applyOpenClawAccountNameToChannelSection({
-          cfg,
-          channelKey: CHANNEL_ID,
-          accountId,
-          name,
-          alwaysUseAccounts: true,
-        }),
-      applyAccountConfig: ({ cfg, accountId }: any) => {
-        const next = { ...(cfg || {}) } as any;
-        next.channels = next.channels || {};
-        next.channels[CHANNEL_ID] = next.channels[CHANNEL_ID] || {};
-        next.channels[CHANNEL_ID].accounts = next.channels[CHANNEL_ID].accounts || {};
-        next.channels[CHANNEL_ID].accounts[accountId] = {
-          ...(next.channels[CHANNEL_ID].accounts[accountId] || {}),
-          enabled: true,
-        };
-        return next;
-      },
-    },
-    outbound: {
-      deliveryMode: 'gateway' as const,
-      sendText: async (ctx: any) => getBridge().channelSendText(ctx),
-      sendMedia: async (ctx: any) => getBridge().channelSendMedia(ctx),
-      replyAction: async (ctx: any) =>
-        sendBncrReplyAction({
-          accountId: normalizeAccountId(ctx?.accountId),
-          to: asString(ctx?.to || '').trim(),
-          text: asString(ctx?.text || ''),
-          replyToMessageId:
-            asString(ctx?.replyToId || ctx?.replyToMessageId || '').trim() || undefined,
-          sendText: async ({ accountId, to, text }) =>
-            getBridge().channelSendText({ accountId, to, text }),
-        }),
-      deleteAction: async (ctx: any) =>
-        deleteBncrMessageAction({
-          accountId: normalizeAccountId(ctx?.accountId),
-          targetMessageId: asString(ctx?.messageId || ctx?.targetMessageId || '').trim(),
-        }),
-      reactAction: async (ctx: any) =>
-        reactBncrMessageAction({
-          accountId: normalizeAccountId(ctx?.accountId),
-          targetMessageId: asString(ctx?.messageId || ctx?.targetMessageId || '').trim(),
-          emoji: asString(ctx?.emoji || '').trim(),
-        }),
-      editAction: async (ctx: any) =>
-        editBncrMessageAction({
-          accountId: normalizeAccountId(ctx?.accountId),
-          targetMessageId: asString(ctx?.messageId || ctx?.targetMessageId || '').trim(),
-          text: asString(ctx?.text || ''),
-        }),
-    },
-    status: {
-      defaultRuntime: createOpenClawDefaultChannelRuntimeState(BNCR_DEFAULT_ACCOUNT_ID, {
-        mode: 'ws-offline',
-      }),
-      buildChannelSummary: async ({ defaultAccountId }: any) => {
-        return getBridge().getChannelSummary(defaultAccountId || BNCR_DEFAULT_ACCOUNT_ID);
-      },
-      buildAccountSnapshot: async ({ account, runtime }: any) => {
-        const runtimeBridge = getBridge();
-        const rt = runtime || runtimeBridge.getAccountRuntimeSnapshot(account?.accountId);
-        return buildAccountStatusSnapshot({
-          account,
-          runtime: rt,
-          healthSummary: runtimeBridge.getStatusHeadline(account?.accountId),
-          // default 名不可隐藏时，统一展示稳定默认值
-          displayName: resolveDefaultDisplayName(account?.name, account?.accountId),
-        });
-      },
-      resolveAccountState: ({ enabled, configured, account, cfg, runtime }: any) => {
-        if (!enabled) return 'disabled';
-        const resolved = resolveAccount(cfg, account?.accountId);
-        if (!(resolved.enabled && configured)) return 'not configured';
-        const rt = runtime || getBridge().getAccountRuntimeSnapshot(account?.accountId);
-        return rt?.connected ? 'linked' : 'configured';
-      },
-    },
-    gatewayMethods: [
-      'bncr.connect',
-      'bncr.inbound',
-      'bncr.activity',
-      'bncr.ack',
-      'bncr.diagnostics',
-      'bncr.file.init',
-      'bncr.file.chunk',
-      'bncr.file.complete',
-      'bncr.file.abort',
-      'bncr.file.ack',
-    ],
-    gateway: {
-      startAccount: async (ctx: any) => getBridge().channelStartAccount(ctx),
-      stopAccount: async (ctx: any) => getBridge().channelStopAccount(ctx),
-    },
+    config: BNCR_CONFIG_SURFACE,
+    setup: BNCR_SETUP_SURFACE,
+    outbound: createBncrOutboundRuntime(getBridge),
+    status: createBncrStatusSurface(getBridge),
+    gatewayMethods: BNCR_GATEWAY_METHODS,
+    gateway: createBncrGatewayRuntime(getBridge),
   };
 
   return plugin;