@xmoxmo/bncr 0.2.1 → 0.2.3

package/src/channel.ts

@@ -73,8 +73,13 @@ import {
   resolveBncrOutboundTarget,
 } from './messaging/outbound/target-resolver.ts';
 const BRIDGE_VERSION = 2;
-const BNCR_PUSH_EVENT = 'bncr.push';
+const BNCR_PUSH_EVENT = 'plugin.bncr.push';
+const BNCR_FILE_INIT_EVENT = 'plugin.bncr.file.init';
+const BNCR_FILE_CHUNK_EVENT = 'plugin.bncr.file.chunk';
+const BNCR_FILE_COMPLETE_EVENT = 'plugin.bncr.file.complete';
+const BNCR_FILE_ABORT_EVENT = 'plugin.bncr.file.abort';
 const CONNECT_TTL_MS = 120_000;
+const RECENT_INBOUND_SEND_WINDOW_MS = 60_000;
 const MAX_RETRY = 10;
 const PUSH_DRAIN_INTERVAL_MS = 500;
 const PUSH_ACK_TIMEOUT_MS = 30_000;
@@ -103,6 +108,8 @@ type FileSendTransferState = {
   status: 'init' | 'transferring' | 'completed' | 'aborted';
   ackedChunks: Set<number>;
   failedChunks: Map<number, string>;
+  ownerConnId?: string;
+  ownerClientId?: string;
   completedPath?: string;
   error?: string;
 };
@@ -122,10 +129,18 @@ type FileRecvTransferState = {
   status: 'init' | 'transferring' | 'completed' | 'aborted';
   bufferByChunk: Map<number, Buffer>;
   receivedChunks: Set<number>;
+  ownerConnId?: string;
+  ownerClientId?: string;
   completedPath?: string;
   error?: string;
 };
 
+type FileAckPayloadState = {
+  payload: Record<string, unknown>;
+  ok: boolean;
+  at: number;
+};
+
 type ChatType = 'direct' | 'group' | (string & {});
 
 type ChannelMessageActionAdapter = {
@@ -181,6 +196,56 @@ type PersistedState = {
   } | null;
 };
 
+type NormalizedBncrSendParams = {
+  to: string;
+  accountId: string;
+  message: string;
+  caption: string;
+  mediaUrl?: string;
+  asVoice: boolean;
+  audioAsVoice: boolean;
+};
+
+function normalizeBncrSendParams(input: {
+  params: unknown;
+  accountId: string;
+}): NormalizedBncrSendParams {
+  const paramsObj = isPlainObject(input.params) ? input.params : {};
+  const to = readStringParam(paramsObj, 'to', { required: true });
+  const resolvedAccountId = normalizeAccountId(
+    readStringParam(paramsObj, 'accountId') ?? input.accountId,
+  );
+
+  const message = readStringParam(paramsObj, 'message', { allowEmpty: true }) ?? '';
+  const caption = readStringParam(paramsObj, 'caption', { allowEmpty: true }) ?? '';
+  const mediaUrl =
+    readStringParam(paramsObj, 'media', { trim: false }) ??
+    readStringParam(paramsObj, 'path', { trim: false }) ??
+    readStringParam(paramsObj, 'filePath', { trim: false }) ??
+    readStringParam(paramsObj, 'mediaUrl', { trim: false });
+  const asVoice = readBooleanParam(paramsObj, 'asVoice') ?? false;
+  const audioAsVoice = readBooleanParam(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,
+  };
+}
+
 function now() {
   return Date.now();
 }
@@ -191,6 +256,10 @@ function asString(v: unknown, fallback = ''): string {
   return String(v);
 }
 
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 function backoffMs(retryCount: number): number {
   // 1s,2s,4s,8s... capped by retry count checks
   return Math.max(1_000, 1_000 * 2 ** Math.max(0, retryCount - 1));
@@ -340,6 +409,7 @@ class BncrBridgeRuntime {
   private lastActivityByAccount = new Map<string, number>();
   private lastInboundByAccount = new Map<string, number>();
   private lastOutboundByAccount = new Map<string, number>();
+  private channelAccountTimers = new Map<string, NodeJS.Timeout>();
   private canonicalAgentId: string | null = null;
   private canonicalAgentSource: 'startup' | 'runtime' | 'fallback-main' | null = null;
   private canonicalAgentResolvedAt: number | null = null;
@@ -354,7 +424,13 @@ class BncrBridgeRuntime {
   private saveTimer: NodeJS.Timeout | null = null;
   private pushTimer: NodeJS.Timeout | null = null;
   private pushDrainRunningAccounts = new Set<string>();
-  private waiters = new Map<string, Array<() => void>>();
+  private messageAckWaiters = new Map<
+    string,
+    {
+      resolve: (result: 'acked' | 'timeout') => void;
+      timer: NodeJS.Timeout;
+    }
+  >();
   private gatewayContext: GatewayRequestHandlerOptions['context'] | null = null;
 
   // 文件互传状态（V1：尽力而为，重连不续传）
@@ -368,6 +444,7 @@ class BncrBridgeRuntime {
       timer: NodeJS.Timeout;
     }
   >();
+  private earlyFileAcks = new Map<string, FileAckPayloadState>();
 
   constructor(api: OpenClawPluginApi) {
     this.api = api;
@@ -426,6 +503,19 @@ class BncrBridgeRuntime {
     this.logInfo('outbound', [type, this.summarizeScope(entry.route), preview].join('|'));
   }
 
+  private clearChannelAccountWorker(accountId: string, reason: string) {
+    const timer = this.channelAccountTimers.get(accountId);
+    if (!timer) return false;
+    clearInterval(timer);
+    this.channelAccountTimers.delete(accountId);
+    this.logInfo(
+      'health',
+      `status-worker cleared ${JSON.stringify({ bridge: this.bridgeId, accountId, reason })}`,
+      { debugOnly: true },
+    );
+    return true;
+  }
+
   private classifyRegisterTrace(stack: string) {
     if (
       stack.includes('prepareSecretsRuntimeSnapshot') ||
@@ -660,6 +750,45 @@ class BncrBridgeRuntime {
     return { stale: true, reason: 'mismatch' as const };
   }
 
+  private shouldIgnoreStaleEvent(params: {
+    kind:
+      | 'inbound'
+      | 'activity'
+      | 'ack'
+      | 'file.init'
+      | 'file.chunk'
+      | 'file.complete'
+      | 'file.abort';
+    payload: { leaseId?: string; connectionEpoch?: number };
+    accountId: string;
+    connId: string;
+    clientId?: string;
+  }) {
+    const observed = this.observeLease(params.kind, params.payload);
+    if (!observed.stale) return false;
+    this.logWarn(
+      'stale',
+      `ignore kind=${params.kind} accountId=${params.accountId} connId=${params.connId} clientId=${params.clientId || '-'} reason=${observed.reason}`,
+      { debugOnly: true },
+    );
+    return true;
+  }
+
+  private matchesTransferOwner(params: {
+    ownerConnId?: string;
+    ownerClientId?: string;
+    connId: string;
+    clientId?: string;
+  }) {
+    const sameConn = !!params.ownerConnId && params.ownerConnId === params.connId;
+    const sameClient =
+      !params.ownerConnId &&
+      !!params.ownerClientId &&
+      !!params.clientId &&
+      params.ownerClientId === params.clientId;
+    return sameConn || sameClient;
+  }
+
   private buildExtendedDiagnostics(accountId: string) {
     const diagnostics = this.buildIntegratedDiagnostics(accountId) as Record<string, any>;
     return {
@@ -722,7 +851,7 @@ class BncrBridgeRuntime {
     this.statePath = path.join(ctx.stateDir, 'bncr-bridge-state.json');
     await this.loadState();
     try {
-      const cfg = await this.api.runtime.config.loadConfig();
+      const cfg = this.api.runtime.config.current();
       this.initializeCanonicalAgentId(cfg);
     } catch {
       // ignore startup canonical agent initialization errors
@@ -750,6 +879,26 @@ class BncrBridgeRuntime {
     this.logInfo('debug', 'service stopped', { debugOnly: true });
   };
 
+  shutdown() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    if (this.pushTimer) {
+      clearTimeout(this.pushTimer);
+      this.pushTimer = null;
+    }
+    for (const waiter of this.messageAckWaiters.values()) {
+      clearTimeout(waiter.timer);
+    }
+    this.messageAckWaiters.clear();
+    for (const waiter of this.fileAckWaiters.values()) {
+      clearTimeout(waiter.timer);
+    }
+    this.fileAckWaiters.clear();
+    this.earlyFileAcks.clear();
+  }
+
   private scheduleSave() {
     if (this.saveTimer) return;
     this.saveTimer = setTimeout(() => {
@@ -769,7 +918,7 @@ class BncrBridgeRuntime {
 
   private async refreshDebugFlagFromConfig(options?: { forceLog?: boolean }) {
     try {
-      const cfg = await this.api.runtime.config.loadConfig();
+      const cfg = this.api.runtime.config.current();
       const raw = (cfg as any)?.channels?.[CHANNEL_ID]?.debug?.verbose;
       const next = typeof raw === 'boolean' ? raw : false;
       const changed = next !== BNCR_DEBUG_VERBOSE;
@@ -1170,18 +1319,32 @@ class BncrBridgeRuntime {
     await writeJsonFileAtomically(this.statePath, data);
   }
 
-  private wakeAccountWaiters(accountId: string) {
-    const key = normalizeAccountId(accountId);
-    const waits = this.waiters.get(key);
-    if (!waits?.length) return;
-    this.waiters.delete(key);
-    for (const resolve of waits) resolve();
+  private resolveMessageAck(messageId: string, result: 'acked' | 'timeout' = 'acked') {
+    const key = asString(messageId).trim();
+    if (!key) return false;
+    const waiter = this.messageAckWaiters.get(key);
+    if (!waiter) return false;
+    this.messageAckWaiters.delete(key);
+    clearTimeout(waiter.timer);
+    waiter.resolve(result);
+    return true;
   }
 
   private rememberGatewayContext(context: GatewayRequestHandlerOptions['context']) {
     if (context) this.gatewayContext = context;
   }
 
+  private resolveOutboxPushOwner(accountId: string): BncrConnection | null {
+    const acc = normalizeAccountId(accountId);
+    const t = now();
+    const primaryKey = this.activeConnectionByAccount.get(acc);
+    if (!primaryKey) return null;
+    const primary = this.connections.get(primaryKey);
+    if (!primary?.connId) return null;
+    if (t - primary.lastSeenAt > CONNECT_TTL_MS) return null;
+    return primary;
+  }
+
   private resolvePushConnIds(accountId: string): Set<string> {
     const acc = normalizeAccountId(accountId);
     const t = now();
@@ -1207,7 +1370,280 @@ class BncrBridgeRuntime {
     return connIds;
   }
 
-  private tryPushEntry(entry: OutboxEntry): boolean {
+  private hasRecentInboundReachability(accountId: string): boolean {
+    const acc = normalizeAccountId(accountId);
+    const t = now();
+    const lastInboundAt = this.lastInboundByAccount.get(acc) || 0;
+    const lastActivityAt = this.lastActivityByAccount.get(acc) || 0;
+    const lastReachableAt = Math.max(lastInboundAt, lastActivityAt);
+    return lastReachableAt > 0 && t - lastReachableAt <= RECENT_INBOUND_SEND_WINDOW_MS;
+  }
+
+  private resolveRecentInboundConnIds(accountId: string): Set<string> {
+    const acc = normalizeAccountId(accountId);
+    const t = now();
+    const connIds = new Set<string>();
+    if (!this.hasRecentInboundReachability(acc)) return connIds;
+
+    for (const c of this.connections.values()) {
+      if (c.accountId !== acc) continue;
+      if (!c.connId) continue;
+      if (t - c.lastSeenAt > CONNECT_TTL_MS * 2) continue;
+      connIds.add(c.connId);
+    }
+
+    return connIds;
+  }
+
+  private isRecentlyReachableConn(accountId: string, connId?: string, clientId?: string): boolean {
+    const acc = normalizeAccountId(accountId);
+    const cid = asString(connId || '').trim();
+    const client = asString(clientId || '').trim() || undefined;
+    if (!cid) return false;
+
+    const recentConnIds = this.resolveRecentInboundConnIds(acc);
+    if (recentConnIds.has(cid)) return true;
+
+    const activeKey = this.activeConnectionByAccount.get(acc);
+    if (!activeKey) return false;
+    const active = this.connections.get(activeKey);
+    if (!active?.connId) return false;
+    if (active.connId !== cid) return false;
+    if (client && active.clientId && active.clientId !== client) return false;
+    return true;
+  }
+
+  private tryAdoptTransferOwner(args: {
+    accountId: string;
+    transfer:
+      | FileSendTransferState
+      | FileRecvTransferState
+      | undefined;
+    connId: string;
+    clientId?: string;
+  }): boolean {
+    const { accountId, transfer, connId, clientId } = args;
+    if (!transfer) return false;
+    if (!this.hasRecentInboundReachability(accountId)) return false;
+    if (!this.isRecentlyReachableConn(accountId, connId, clientId)) return false;
+
+    transfer.ownerConnId = connId;
+    transfer.ownerClientId = asString(clientId || '').trim() || undefined;
+    return true;
+  }
+
+  private isRetryableFileTransferError(error: unknown): boolean {
+    const msg = asString((error as any)?.message || error || '')
+      .trim()
+      .toLowerCase();
+    if (!msg) return true;
+
+    const retryableMarkers = [
+      'gateway context unavailable',
+      'no active bncr client for file chunk transfer',
+      'chunk ack timeout',
+      'complete ack timeout',
+      'transfer state missing',
+      'transfer aborted',
+      'temporarily unavailable',
+      'timeout',
+      'econn',
+      'socket',
+      'network',
+    ];
+
+    return retryableMarkers.some((marker) => msg.includes(marker));
+  }
+
+  private buildFileTransferOutboxEntry(params: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    mediaUrl: string;
+    mediaLocalRoots?: readonly string[];
+    text?: string;
+    asVoice?: boolean;
+    audioAsVoice?: boolean;
+    kind?: 'tool' | 'block' | 'final';
+    replyToId?: string;
+  }): OutboxEntry {
+    const messageId = randomUUID();
+    return {
+      messageId,
+      accountId: normalizeAccountId(params.accountId),
+      sessionKey: params.sessionKey,
+      route: params.route,
+      payload: {
+        type: 'message.outbound',
+        sessionKey: params.sessionKey,
+        _meta: {
+          kind: 'file-transfer',
+          mediaUrl: params.mediaUrl,
+          mediaLocalRoots: params.mediaLocalRoots ? Array.from(params.mediaLocalRoots) : undefined,
+          text: asString(params.text || ''),
+          asVoice: params.asVoice === true,
+          audioAsVoice: params.audioAsVoice === true,
+          finalEvent: BNCR_PUSH_EVENT,
+          replyToId: asString(params.replyToId || '').trim() || undefined,
+          messageKind: params.kind,
+        },
+      },
+      createdAt: now(),
+      retryCount: 0,
+      nextAttemptAt: now(),
+    };
+  }
+
+  private async tryPushEntry(entry: OutboxEntry): Promise<boolean> {
+    const meta = isPlainObject(entry.payload?._meta) ? entry.payload._meta : null;
+    if (meta?.kind === 'file-transfer') {
+      const ctx = this.gatewayContext;
+      if (!ctx) {
+        entry.lastError = 'gateway context unavailable';
+        this.outbox.set(entry.messageId, entry);
+        this.logInfo(
+          'outbox',
+          `push-skip ${JSON.stringify({
+            messageId: entry.messageId,
+            accountId: entry.accountId,
+            kind: 'file-transfer',
+            reason: 'no-gateway-context',
+          })}`,
+          { debugOnly: true },
+        );
+        return false;
+      }
+
+      const owner = this.resolveOutboxPushOwner(entry.accountId);
+      let connIds = owner?.connId
+        ? new Set([owner.connId])
+        : this.resolvePushConnIds(entry.accountId);
+      const recentInboundReachable = this.hasRecentInboundReachability(entry.accountId);
+      if (!connIds.size && recentInboundReachable) {
+        connIds = this.resolveRecentInboundConnIds(entry.accountId);
+      }
+      if (!connIds.size) {
+        entry.lastError = 'no active bncr client for file chunk transfer';
+        this.outbox.set(entry.messageId, entry);
+        this.logInfo(
+          'outbox',
+          `push-skip ${JSON.stringify({
+            messageId: entry.messageId,
+            accountId: entry.accountId,
+            kind: 'file-transfer',
+            reason: 'no-active-connection',
+            recentInboundReachable,
+          })}`,
+          { debugOnly: true },
+        );
+        return false;
+      }
+
+      const mediaUrl = asString(meta.mediaUrl || '').trim();
+      if (!mediaUrl) {
+        entry.lastError = 'file transfer mediaUrl missing';
+        this.outbox.set(entry.messageId, entry);
+        this.logInfo(
+          'outbox',
+          `push-fail ${JSON.stringify({
+            messageId: entry.messageId,
+            accountId: entry.accountId,
+            kind: 'file-transfer',
+            error: entry.lastError,
+          })}`,
+          { debugOnly: true },
+        );
+        return false;
+      }
+
+      try {
+        const media = await this.transferMediaToBncrClient({
+          accountId: entry.accountId,
+          sessionKey: entry.sessionKey,
+          route: entry.route,
+          mediaUrl,
+          mediaLocalRoots: Array.isArray(meta.mediaLocalRoots)
+            ? meta.mediaLocalRoots.filter((v): v is string => typeof v === 'string')
+            : undefined,
+        });
+        const wantsVoice = meta.asVoice === true || meta.audioAsVoice === true;
+        const frame = buildBncrMediaOutboundFrame({
+          messageId: entry.messageId,
+          sessionKey: entry.sessionKey,
+          route: entry.route,
+          media,
+          mediaUrl,
+          mediaMsg: asString(meta.text || ''),
+          fileName: resolveOutboundFileName({
+            mediaUrl,
+            fileName: media.fileName,
+            mimeType: media.mimeType,
+          }),
+          hintedType: wantsVoice ? 'voice' : undefined,
+          kind:
+            meta.messageKind === 'tool' ||
+            meta.messageKind === 'block' ||
+            meta.messageKind === 'final'
+              ? meta.messageKind
+              : undefined,
+          replyToId: asString(meta.replyToId || '').trim() || undefined,
+          now: now(),
+        });
+
+        ctx.broadcastToConnIds(
+          BNCR_PUSH_EVENT,
+          {
+            ...frame,
+            idempotencyKey: entry.messageId,
+          },
+          connIds,
+        );
+        entry.lastPushAt = now();
+        entry.lastPushConnId =
+          owner?.connId || (connIds.size === 1 ? Array.from(connIds)[0] : undefined);
+        entry.lastPushClientId = owner?.clientId;
+        entry.lastError = undefined;
+        this.outbox.set(entry.messageId, entry);
+        this.lastOutboundByAccount.set(entry.accountId, entry.lastPushAt);
+        this.markActivity(entry.accountId, entry.lastPushAt);
+        this.scheduleSave();
+        this.logInfo(
+          'outbox',
+          `push-ok ${JSON.stringify({
+            messageId: entry.messageId,
+            accountId: entry.accountId,
+            kind: 'file-transfer',
+            connIds: Array.from(connIds),
+            ownerConnId: entry.lastPushConnId || '',
+            ownerClientId: entry.lastPushClientId || '',
+            recentInboundReachable,
+            event: BNCR_PUSH_EVENT,
+          })}`,
+          { debugOnly: true },
+        );
+        return true;
+      } catch (error) {
+        entry.lastError = asString((error as any)?.message || error || 'file-transfer-error');
+        this.outbox.set(entry.messageId, entry);
+        this.scheduleSave();
+        this.logInfo(
+          'outbox',
+          `push-fail ${JSON.stringify({
+            messageId: entry.messageId,
+            accountId: entry.accountId,
+            kind: 'file-transfer',
+            retryable: this.isRetryableFileTransferError(error),
+            error: entry.lastError,
+          })}`,
+          { debugOnly: true },
+        );
+        if (!this.isRetryableFileTransferError(error)) {
+          this.moveToDeadLetter(entry, entry.lastError || 'file-transfer-failed');
+        }
+        return false;
+      }
+    }
+
     const ctx = this.gatewayContext;
     if (!ctx) {
       this.logInfo(
@@ -1222,7 +1658,14 @@ class BncrBridgeRuntime {
       return false;
     }
 
-    const connIds = this.resolvePushConnIds(entry.accountId);
+    const owner = this.resolveOutboxPushOwner(entry.accountId);
+    let connIds = owner?.connId
+      ? new Set([owner.connId])
+      : this.resolvePushConnIds(entry.accountId);
+    const recentInboundReachable = this.hasRecentInboundReachability(entry.accountId);
+    if (!connIds.size && recentInboundReachable) {
+      connIds = this.resolveRecentInboundConnIds(entry.accountId);
+    }
     if (!connIds.size) {
       this.logInfo(
         'outbox',
@@ -1230,6 +1673,7 @@ class BncrBridgeRuntime {
           messageId: entry.messageId,
           accountId: entry.accountId,
           reason: 'no-active-connection',
+          recentInboundReachable,
         })}`,
         { debugOnly: true },
       );
@@ -1243,18 +1687,26 @@ class BncrBridgeRuntime {
       };
 
       ctx.broadcastToConnIds(BNCR_PUSH_EVENT, payload, connIds);
+      entry.lastPushAt = now();
+      entry.lastPushConnId =
+        owner?.connId || (connIds.size === 1 ? Array.from(connIds)[0] : undefined);
+      entry.lastPushClientId = owner?.clientId;
+      this.outbox.set(entry.messageId, entry);
       this.logInfo(
         'outbox',
         `push-ok ${JSON.stringify({
           messageId: entry.messageId,
           accountId: entry.accountId,
           connIds: Array.from(connIds),
+          ownerConnId: entry.lastPushConnId || '',
+          ownerClientId: entry.lastPushClientId || '',
+          recentInboundReachable,
           event: BNCR_PUSH_EVENT,
         })}`,
         { debugOnly: true },
       );
-      this.lastOutboundByAccount.set(entry.accountId, now());
-      this.markActivity(entry.accountId);
+      this.lastOutboundByAccount.set(entry.accountId, entry.lastPushAt);
+      this.markActivity(entry.accountId, entry.lastPushAt);
       this.scheduleSave();
       return true;
     } catch (error) {
@@ -1282,6 +1734,42 @@ class BncrBridgeRuntime {
     }, delay);
   }
 
+  private isOutboundAckRequired(accountId?: string) {
+    try {
+      const cfg = this.api.runtime.config.current();
+      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;
+    }
+  }
+
+  private buildRuntimeFlags(accountId?: string) {
+    let ackPolicySource: 'channel' | 'default' = 'default';
+    try {
+      const cfg = this.api.runtime.config.current();
+      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: PUSH_ACK_TIMEOUT_MS,
+      fileAckTimeoutMs: FILE_ACK_TIMEOUT_MS,
+      debugVerbose: BNCR_DEBUG_VERBOSE,
+    };
+  }
+
   private async flushPushQueue(accountId?: string): Promise<void> {
     const filterAcc = accountId ? normalizeAccountId(accountId) : null;
     const targetAccounts = filterAcc
@@ -1307,12 +1795,14 @@ class BncrBridgeRuntime {
     for (const acc of targetAccounts) {
       if (!acc || this.pushDrainRunningAccounts.has(acc)) continue;
       const online = this.isOnline(acc);
+      const recentInboundReachable = this.hasRecentInboundReachability(acc);
       this.logInfo(
         'outbox',
         `online ${JSON.stringify({
           bridge: this.bridgeId,
           accountId: acc,
           online,
+          recentInboundReachable,
           connections: Array.from(this.connections.values()).map((c) => ({
             accountId: c.accountId,
             connId: c.connId,
@@ -1341,26 +1831,48 @@ class BncrBridgeRuntime {
             break;
           }
 
-          const onlineNow = this.isOnline(acc);
-          const pushed = this.tryPushEntry(entry);
+          const onlineNow = this.isOnline(acc) || this.hasRecentInboundReachability(acc);
+          const pushed = await this.tryPushEntry(entry);
           if (pushed) {
-            if (onlineNow) {
-              await this.waitForOutbound(acc, PUSH_ACK_TIMEOUT_MS);
+            const requireAck = this.isOutboundAckRequired(acc);
+            let ackResult: 'acked' | 'timeout' = requireAck ? 'timeout' : 'acked';
+            if (onlineNow && requireAck) {
+              ackResult = await this.waitForMessageAck(entry.messageId, PUSH_ACK_TIMEOUT_MS);
             }
 
+            this.logInfo(
+              'outbox',
+              `ack ${JSON.stringify({
+                messageId: entry.messageId,
+                accountId: entry.accountId,
+                requireAck,
+                ackResult,
+                onlineNow,
+              })}`,
+              { debugOnly: true },
+            );
+
             if (!this.outbox.has(entry.messageId)) {
               await this.sleepMs(PUSH_DRAIN_INTERVAL_MS);
               continue;
             }
 
+            if (onlineNow && (!requireAck || ackResult !== 'timeout')) {
+              await this.sleepMs(PUSH_DRAIN_INTERVAL_MS);
+              continue;
+            }
+
             entry.retryCount += 1;
             entry.lastAttemptAt = now();
             if (entry.retryCount > MAX_RETRY) {
-              this.moveToDeadLetter(entry, entry.lastError || 'push-ack-timeout');
+              this.moveToDeadLetter(
+                entry,
+                entry.lastError || (requireAck ? 'push-ack-timeout' : 'push-delivery-unconfirmed'),
+              );
               continue;
             }
             entry.nextAttemptAt = now() + backoffMs(entry.retryCount);
-            entry.lastError = entry.lastError || 'push-ack-timeout';
+            entry.lastError = requireAck ? 'push-ack-timeout' : 'push-delivery-unconfirmed';
             this.outbox.set(entry.messageId, entry);
             this.scheduleSave();
 
@@ -1370,6 +1882,11 @@ class BncrBridgeRuntime {
             break;
           }
 
+          if (!this.outbox.has(entry.messageId)) {
+            await this.sleepMs(PUSH_DRAIN_INTERVAL_MS);
+            continue;
+          }
+
           const nextAttempt = entry.retryCount + 1;
           if (nextAttempt > MAX_RETRY) {
             this.moveToDeadLetter(entry, entry.lastError || 'push-retry-limit');
@@ -1400,29 +1917,18 @@ class BncrBridgeRuntime {
     if (globalNextDelay != null) this.schedulePushDrain(globalNextDelay);
   }
 
-  private async waitForOutbound(accountId: string, waitMs: number): Promise<void> {
-    const key = normalizeAccountId(accountId);
+  private async waitForMessageAck(messageId: string, waitMs: number): Promise<'acked' | 'timeout'> {
+    const key = asString(messageId).trim();
     const timeoutMs = Math.max(0, Math.min(waitMs, 25_000));
-    if (!timeoutMs) return;
+    if (!key || !timeoutMs) return 'timeout';
 
-    await new Promise<void>((resolve) => {
+    return await new Promise<'acked' | 'timeout'>((resolve) => {
       const timer = setTimeout(() => {
-        const arr = this.waiters.get(key) || [];
-        this.waiters.set(
-          key,
-          arr.filter((fn) => fn !== done),
-        );
-        resolve();
+        this.messageAckWaiters.delete(key);
+        resolve('timeout');
       }, timeoutMs);
 
-      const done = () => {
-        clearTimeout(timer);
-        resolve();
-      };
-
-      const arr = this.waiters.get(key) || [];
-      arr.push(done);
-      this.waiters.set(key, arr);
+      this.messageAckWaiters.set(key, { resolve, timer });
     });
   }
 
@@ -1473,6 +1979,9 @@ class BncrBridgeRuntime {
     for (const [id, st] of this.fileRecvTransfers.entries()) {
       if (t - st.startedAt > FILE_TRANSFER_KEEP_MS) this.fileRecvTransfers.delete(id);
     }
+    for (const [key, ack] of this.earlyFileAcks.entries()) {
+      if (t - ack.at > FILE_TRANSFER_ACK_TTL_MS) this.earlyFileAcks.delete(key);
+    }
   }
 
   private markSeen(accountId: string, connId: string, clientId?: string) {
@@ -1482,6 +1991,8 @@ class BncrBridgeRuntime {
     const key = this.connectionKey(acc, clientId);
     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 nextConn: BncrConnection = {
       accountId: acc,
@@ -1508,6 +2019,27 @@ class BncrBridgeRuntime {
     const current = this.activeConnectionByAccount.get(acc);
     if (!current) {
       this.activeConnectionByAccount.set(acc, key);
+      this.logInfo(
+        'connection',
+        `seen:promote ${JSON.stringify({
+          bridge: this.bridgeId,
+          accountId: acc,
+          reason: 'no-current-active',
+          previousActiveKey,
+          previousActiveConn,
+          nextActiveKey: key,
+          nextActiveConn: nextConn,
+          activeConnections: Array.from(this.connections.values())
+            .filter((c) => c.accountId === acc)
+            .map((c) => ({
+              connId: c.connId,
+              clientId: c.clientId,
+              connectedAt: c.connectedAt,
+              lastSeenAt: c.lastSeenAt,
+            })),
+        })}`,
+        { debugOnly: true },
+      );
       return;
     }
 
@@ -1518,6 +2050,31 @@ class BncrBridgeRuntime {
       nextConn.connectedAt >= curConn.connectedAt
     ) {
       this.activeConnectionByAccount.set(acc, key);
+      this.logInfo(
+        'connection',
+        `seen:promote ${JSON.stringify({
+          bridge: this.bridgeId,
+          accountId: acc,
+          reason: !curConn
+            ? 'current-missing'
+            : t - curConn.lastSeenAt > CONNECT_TTL_MS
+              ? 'current-stale'
+              : 'newer-or-equal-connectedAt',
+          previousActiveKey,
+          previousActiveConn,
+          nextActiveKey: key,
+          nextActiveConn: nextConn,
+          activeConnections: Array.from(this.connections.values())
+            .filter((c) => c.accountId === acc)
+            .map((c) => ({
+              connId: c.connId,
+              clientId: c.clientId,
+              connectedAt: c.connectedAt,
+              lastSeenAt: c.lastSeenAt,
+            })),
+        })}`,
+        { debugOnly: true },
+      );
     }
   }
 
@@ -1681,9 +2238,61 @@ class BncrBridgeRuntime {
       Math.min(Number(params.timeoutMs || FILE_ACK_TIMEOUT_MS), 120_000),
     );
 
+    const cached = this.earlyFileAcks.get(key);
+    if (cached) {
+      this.earlyFileAcks.delete(key);
+      this.logInfo(
+        'file-ack-cache-hit',
+        JSON.stringify({
+          bridge: this.bridgeId,
+          transferId,
+          stage,
+          chunkIndex:
+            Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+          key,
+          ok: cached.ok,
+          payload: cached.payload,
+        }),
+        { debugOnly: true },
+      );
+      if (cached.ok) return Promise.resolve(cached.payload);
+      return Promise.reject(
+        new Error(
+          asString(cached.payload?.errorMessage || cached.payload?.error || 'file ack failed'),
+        ),
+      );
+    }
+
+    this.logInfo(
+      'file-ack-wait',
+      JSON.stringify({
+        bridge: this.bridgeId,
+        transferId,
+        stage,
+        chunkIndex:
+          Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+        key,
+        timeoutMs,
+      }),
+      { debugOnly: true },
+    );
+
     return new Promise<Record<string, unknown>>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.fileAckWaiters.delete(key);
+        this.logWarn(
+          'file-ack-timeout',
+          JSON.stringify({
+            bridge: this.bridgeId,
+            transferId,
+            stage,
+            chunkIndex:
+              Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+            key,
+            timeoutMs,
+          }),
+          { debugOnly: true },
+        );
         reject(new Error(`file ack timeout: ${key}`));
       }, timeoutMs);
       this.fileAckWaiters.set(key, { resolve, reject, timer });
@@ -1701,9 +2310,45 @@ class BncrBridgeRuntime {
     const stage = asString(params.stage).trim();
     const key = this.fileAckKey(transferId, stage, params.chunkIndex);
     const waiter = this.fileAckWaiters.get(key);
-    if (!waiter) return false;
+    if (!waiter) {
+      this.earlyFileAcks.set(key, {
+        payload: params.payload,
+        ok: params.ok,
+        at: now(),
+      });
+      this.logInfo(
+        'file-ack-early-cache',
+        JSON.stringify({
+          bridge: this.bridgeId,
+          transferId,
+          stage,
+          chunkIndex:
+            Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+          key,
+          ok: params.ok,
+          payload: params.payload,
+          cached: true,
+        }),
+        { debugOnly: true },
+      );
+      return false;
+    }
     this.fileAckWaiters.delete(key);
     clearTimeout(waiter.timer);
+    this.logInfo(
+      'file-ack-resolve',
+      JSON.stringify({
+        bridge: this.bridgeId,
+        transferId,
+        stage,
+        chunkIndex:
+          Number.isFinite(Number(params.chunkIndex)) ? Number(params.chunkIndex) : undefined,
+        key,
+        ok: params.ok,
+        payload: params.payload,
+      }),
+      { debugOnly: true },
+    );
     if (params.ok) waiter.resolve(params.payload);
     else
       waiter.reject(
@@ -1723,7 +2368,17 @@ class BncrBridgeRuntime {
     if (!connIds.size || !this.gatewayContext) {
       throw new Error(`no active bncr connection for account=${accountId}`);
     }
-    this.gatewayContext.broadcastToConnIds(event, payload, connIds);
+    const normalizedEvent =
+      event === 'bncr.file.init'
+        ? BNCR_FILE_INIT_EVENT
+        : event === 'bncr.file.chunk'
+          ? BNCR_FILE_CHUNK_EVENT
+          : event === 'bncr.file.complete'
+            ? BNCR_FILE_COMPLETE_EVENT
+            : event === 'bncr.file.abort'
+              ? BNCR_FILE_ABORT_EVENT
+              : event;
+    this.gatewayContext.broadcastToConnIds(normalizedEvent, payload, connIds);
   }
 
   private resolveInboundFileType(mimeType: string, fileName: string): string {
@@ -1890,7 +2545,6 @@ class BncrBridgeRuntime {
     this.logOutboundSummary(entry);
     this.outbox.set(entry.messageId, entry);
     this.scheduleSave();
-    this.wakeAccountWaiters(entry.accountId);
     this.flushPushQueue(entry.accountId);
   }
 
@@ -1902,6 +2556,7 @@ class BncrBridgeRuntime {
     this.deadLetter.push(dead);
     if (this.deadLetter.length > 1000) this.deadLetter = this.deadLetter.slice(-1000);
     this.outbox.delete(entry.messageId);
+    this.resolveMessageAck(entry.messageId, 'timeout');
     this.scheduleSave();
   }
 
@@ -2067,9 +2722,46 @@ class BncrBridgeRuntime {
     }
 
     const ctx = this.gatewayContext;
+    const owner = this.resolveOutboxPushOwner(params.accountId);
+    const recentInboundReachable = this.hasRecentInboundReachability(params.accountId);
+    const directConnIds = this.resolvePushConnIds(params.accountId);
+    const recentConnIds = recentInboundReachable
+      ? this.resolveRecentInboundConnIds(params.accountId)
+      : new Set<string>();
+    const accountId = normalizeAccountId(params.accountId);
+    const activeConnectionKey = this.activeConnectionByAccount.get(accountId) || null;
+    const accountConnections = Array.from(this.connections.values())
+      .filter((c) => c.accountId === accountId)
+      .map((c) => ({
+        connId: c.connId,
+        clientId: c.clientId,
+        connectedAt: c.connectedAt,
+        lastSeenAt: c.lastSeenAt,
+      }));
+    this.logInfo(
+      'file-chunk-diag',
+      JSON.stringify({
+        bridge: this.bridgeId,
+        accountId,
+        sessionKey: params.sessionKey,
+        mediaUrl: params.mediaUrl,
+        hasGatewayContext: Boolean(ctx),
+        activeConnectionKey,
+        ownerConnId: owner?.connId || null,
+        ownerClientId: owner?.clientId || null,
+        directConnIds: Array.from(directConnIds),
+        recentInboundReachable,
+        recentConnIds: Array.from(recentConnIds),
+        accountConnections,
+      }),
+      { debugOnly: true },
+    );
     if (!ctx) throw new Error('gateway context unavailable');
 
-    const connIds = this.resolvePushConnIds(params.accountId);
+    let connIds = directConnIds;
+    if (!connIds.size && recentInboundReachable) {
+      connIds = recentConnIds;
+    }
     if (!connIds.size) throw new Error('no active bncr client for file chunk transfer');
 
     const transferId = randomUUID();
@@ -2077,6 +2769,26 @@ class BncrBridgeRuntime {
     const totalChunks = Math.ceil(size / chunkSize);
     const fileSha256 = createHash('sha256').update(loaded.buffer).digest('hex');
 
+    this.logInfo(
+      'file-transfer-start',
+      JSON.stringify({
+        bridge: this.bridgeId,
+        transferId,
+        accountId,
+        sessionKey: params.sessionKey,
+        mediaUrl: params.mediaUrl,
+        fileName,
+        mimeType,
+        fileSize: size,
+        chunkSize,
+        totalChunks,
+        connIds: Array.from(connIds),
+        ownerConnId: owner?.connId || null,
+        ownerClientId: owner?.clientId || null,
+      }),
+      { debugOnly: true },
+    );
+
     const st: FileSendTransferState = {
       transferId,
       accountId: normalizeAccountId(params.accountId),
@@ -2092,11 +2804,13 @@ class BncrBridgeRuntime {
       status: 'init',
       ackedChunks: new Set(),
       failedChunks: new Map(),
+      ownerConnId: owner?.connId,
+      ownerClientId: owner?.clientId,
     };
     this.fileSendTransfers.set(transferId, st);
 
     ctx.broadcastToConnIds(
-      'bncr.file.init',
+      BNCR_FILE_INIT_EVENT,
       {
         transferId,
         direction: 'oc2bncr',
@@ -2126,7 +2840,7 @@ class BncrBridgeRuntime {
       let lastErr: unknown = null;
       for (let attempt = 1; attempt <= 3; attempt++) {
         ctx.broadcastToConnIds(
-          'bncr.file.chunk',
+          BNCR_FILE_CHUNK_EVENT,
           {
             transferId,
             chunkIndex: idx,
@@ -2139,16 +2853,54 @@ class BncrBridgeRuntime {
           connIds,
         );
 
+        this.logInfo(
+          'file-transfer-chunk-send',
+          JSON.stringify({
+            bridge: this.bridgeId,
+            transferId,
+            accountId,
+            chunkIndex: idx,
+            attempt,
+            offset: start,
+            size: slice.byteLength,
+            connIds: Array.from(connIds),
+          }),
+          { debugOnly: true },
+        );
+
         try {
           await this.waitChunkAck({
             transferId,
             chunkIndex: idx,
             timeoutMs: FILE_TRANSFER_ACK_TTL_MS,
           });
+          this.logInfo(
+            'file-transfer-chunk-ack',
+            JSON.stringify({
+              bridge: this.bridgeId,
+              transferId,
+              accountId,
+              chunkIndex: idx,
+              attempt,
+            }),
+            { debugOnly: true },
+          );
           ok = true;
           break;
         } catch (err) {
           lastErr = err;
+          this.logWarn(
+            'file-transfer-chunk-ack-fail',
+            JSON.stringify({
+              bridge: this.bridgeId,
+              transferId,
+              accountId,
+              chunkIndex: idx,
+              attempt,
+              error: asString((err as Error)?.message || err),
+            }),
+            { debugOnly: true },
+          );
           await this.sleepMs(150 * attempt);
         }
       }
@@ -2158,7 +2910,7 @@ class BncrBridgeRuntime {
         st.error = String((lastErr as any)?.message || lastErr || `chunk-${idx}-failed`);
         this.fileSendTransfers.set(transferId, st);
         ctx.broadcastToConnIds(
-          'bncr.file.abort',
+          BNCR_FILE_ABORT_EVENT,
           {
             transferId,
             reason: st.error,
@@ -2171,7 +2923,7 @@ class BncrBridgeRuntime {
     }
 
     ctx.broadcastToConnIds(
-      'bncr.file.complete',
+      BNCR_FILE_COMPLETE_EVENT,
       {
         transferId,
         ts: now(),
@@ -2179,8 +2931,30 @@ class BncrBridgeRuntime {
       connIds,
     );
 
+    this.logInfo(
+      'file-transfer-complete-send',
+      JSON.stringify({
+        bridge: this.bridgeId,
+        transferId,
+        accountId,
+        connIds: Array.from(connIds),
+      }),
+      { debugOnly: true },
+    );
+
     const done = await this.waitCompleteAck({ transferId, timeoutMs: 60_000 });
 
+    this.logInfo(
+      'file-transfer-complete-ack',
+      JSON.stringify({
+        bridge: this.bridgeId,
+        transferId,
+        accountId,
+        payload: done,
+      }),
+      { debugOnly: true },
+    );
+
     return {
       mode: 'chunk',
       mimeType,
@@ -2215,44 +2989,20 @@ class BncrBridgeRuntime {
     if (mediaList.length > 0) {
       let first = true;
       for (const mediaUrl of mediaList) {
-        const media = await this.transferMediaToBncrClient({
-          accountId,
-          sessionKey,
-          route,
-          mediaUrl,
-          mediaLocalRoots,
-        });
-        const messageId = randomUUID();
-        const mediaMsg = first ? asString(payload.text || '') : '';
-        const wantsVoice = payload.asVoice === true || payload.audioAsVoice === true;
-        const frame = buildBncrMediaOutboundFrame({
-          messageId,
-          sessionKey,
-          route,
-          media,
-          mediaUrl,
-          mediaMsg,
-          fileName: resolveOutboundFileName({
+        this.enqueueOutbound(
+          this.buildFileTransferOutboxEntry({
+            accountId,
+            sessionKey,
+            route,
             mediaUrl,
-            fileName: media.fileName,
-            mimeType: media.mimeType,
+            mediaLocalRoots,
+            text: first ? asString(payload.text || '') : '',
+            asVoice: payload.asVoice,
+            audioAsVoice: payload.audioAsVoice,
+            kind: payload.kind,
+            replyToId: asString(payload.replyToId || '').trim() || undefined,
           }),
-          hintedType: wantsVoice ? 'voice' : undefined,
-          kind: payload.kind,
-          replyToId: asString(payload.replyToId || '').trim() || undefined,
-          now: now(),
-        });
-
-        this.enqueueOutbound({
-          messageId,
-          accountId: normalizeAccountId(accountId),
-          sessionKey,
-          route,
-          payload: frame,
-          createdAt: now(),
-          retryCount: 0,
-          nextAttemptAt: now(),
-        });
+        );
         first = false;
       }
       return;
@@ -2329,6 +3079,11 @@ class BncrBridgeRuntime {
       pending: Array.from(this.outbox.values()).filter((v) => v.accountId === accountId).length,
       deadLetter: this.deadLetter.filter((v) => v.accountId === accountId).length,
       diagnostics: this.buildExtendedDiagnostics(accountId),
+      runtimeFlags: this.buildRuntimeFlags(accountId),
+      waiters: {
+        messageAck: this.messageAckWaiters.size,
+        fileAck: this.fileAckWaiters.size,
+      },
       leaseId: lease.leaseId,
       connectionEpoch: lease.connectionEpoch,
       protocolVersion: 2,
@@ -2347,13 +3102,9 @@ class BncrBridgeRuntime {
     const accountId = normalizeAccountId(asString(params?.accountId || ''));
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
-    this.rememberGatewayContext(context);
-    this.markSeen(accountId, connId, clientId);
-    this.observeLease('ack', params ?? {});
-    this.lastAckAtGlobal = now();
-    this.incrementCounter(this.ackEventsByAccount, accountId);
-
     const messageId = asString(params?.messageId || '').trim();
+    const staleObserved = this.observeLease('ack', params ?? {});
+
     this.logInfo(
       'outbox',
       `ack ${JSON.stringify({
@@ -2362,6 +3113,7 @@ class BncrBridgeRuntime {
         ok: params?.ok !== false,
         fatal: params?.fatal === true,
         error: asString(params?.error || ''),
+        stale: staleObserved.stale,
       })}`,
       { debugOnly: true },
     );
@@ -2372,7 +3124,7 @@ class BncrBridgeRuntime {
 
     const entry = this.outbox.get(messageId);
     if (!entry) {
-      respond(true, { ok: true, message: 'already-acked-or-missing' });
+      respond(true, { ok: true, message: 'already-acked-or-missing', stale: staleObserved.stale });
       return;
     }
 
@@ -2381,20 +3133,52 @@ class BncrBridgeRuntime {
       return;
     }
 
+    if (staleObserved.stale) {
+      const sameConn = !!entry.lastPushConnId && entry.lastPushConnId === connId;
+      const sameClient =
+        !entry.lastPushConnId &&
+        !!entry.lastPushClientId &&
+        !!clientId &&
+        entry.lastPushClientId === clientId;
+      if (!(sameConn || sameClient)) {
+        this.logWarn(
+          'stale',
+          `ignore kind=ack accountId=${accountId} connId=${connId} clientId=${clientId || '-'} messageId=${messageId} reason=owner-mismatch lastPushConnId=${entry.lastPushConnId || '-'} lastPushClientId=${entry.lastPushClientId || '-'}`,
+          { debugOnly: true },
+        );
+        respond(true, { ok: true, stale: true, ignored: true });
+        return;
+      }
+    } else {
+      this.rememberGatewayContext(context);
+      this.markSeen(accountId, connId, clientId);
+    }
+    this.lastAckAtGlobal = now();
+    this.incrementCounter(this.ackEventsByAccount, accountId);
+
     const ok = params?.ok !== false;
     const fatal = params?.fatal === true;
 
     if (ok) {
       this.outbox.delete(messageId);
       this.scheduleSave();
-      this.wakeAccountWaiters(accountId);
-      respond(true, { ok: true });
+      this.resolveMessageAck(messageId, 'acked');
+      respond(
+        true,
+        staleObserved.stale ? { ok: true, stale: true, staleAccepted: true } : { ok: true },
+      );
+      this.flushPushQueue(accountId);
       return;
     }
 
     if (fatal) {
       this.moveToDeadLetter(entry, asString(params?.error || 'fatal-ack'));
-      respond(true, { ok: true, movedToDeadLetter: true });
+      respond(
+        true,
+        staleObserved.stale
+          ? { ok: true, movedToDeadLetter: true, stale: true, staleAccepted: true }
+          : { ok: true, movedToDeadLetter: true },
+      );
       return;
     }
 
@@ -2403,7 +3187,12 @@ class BncrBridgeRuntime {
     this.outbox.set(messageId, entry);
     this.scheduleSave();
 
-    respond(true, { ok: true, willRetry: true });
+    respond(
+      true,
+      staleObserved.stale
+        ? { ok: true, willRetry: true, stale: true, staleAccepted: true }
+        : { ok: true, willRetry: true },
+    );
   };
 
   handleActivity = async ({ params, respond, client, context }: GatewayRequestHandlerOptions) => {
@@ -2411,7 +3200,18 @@ class BncrBridgeRuntime {
     const accountId = normalizeAccountId(asString(params?.accountId || ''));
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
-    this.observeLease('activity', params ?? {});
+    if (
+      this.shouldIgnoreStaleEvent({
+        kind: 'activity',
+        payload: params ?? {},
+        accountId,
+        connId,
+        clientId,
+      })
+    ) {
+      respond(true, { accountId, ok: true, event: 'activity', stale: true, ignored: true });
+      return;
+    }
     this.lastActivityAtGlobal = now();
     this.logInfo(
       'activity',
@@ -2439,11 +3239,12 @@ class BncrBridgeRuntime {
       deadLetter: this.deadLetter.filter((v) => v.accountId === accountId).length,
       now: now(),
     });
+    this.flushPushQueue(accountId);
   };
 
   handleDiagnostics = async ({ params, respond }: GatewayRequestHandlerOptions) => {
     const accountId = normalizeAccountId(asString(params?.accountId || ''));
-    const cfg = await this.api.runtime.config.loadConfig();
+    const cfg = this.api.runtime.config.current();
     const runtime = this.getAccountRuntimeSnapshot(accountId);
     const diagnostics = this.buildExtendedDiagnostics(accountId);
     const permissions = buildBncrPermissionSummary(cfg ?? {});
@@ -2468,6 +3269,11 @@ class BncrBridgeRuntime {
       accountId,
       runtime,
       diagnostics,
+      runtimeFlags: this.buildRuntimeFlags(accountId),
+      waiters: {
+        messageAck: this.messageAckWaiters.size,
+        fileAck: this.fileAckWaiters.size,
+      },
       permissions,
       probe,
       now: now(),
@@ -2478,9 +3284,20 @@ class BncrBridgeRuntime {
     const accountId = normalizeAccountId(asString(params?.accountId || ''));
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
+    if (
+      this.shouldIgnoreStaleEvent({
+        kind: 'file.init',
+        payload: params ?? {},
+        accountId,
+        connId,
+        clientId,
+      })
+    ) {
+      respond(true, { ok: true, stale: true, ignored: true });
+      return;
+    }
     this.rememberGatewayContext(context);
     this.markSeen(accountId, connId, clientId);
-    this.observeLease('file.init', params ?? {});
     this.markActivity(accountId);
 
     const transferId = asString(params?.transferId || '').trim();
@@ -2536,6 +3353,8 @@ class BncrBridgeRuntime {
       status: 'init',
       bufferByChunk: new Map(),
       receivedChunks: new Set(),
+      ownerConnId: connId,
+      ownerClientId: clientId,
     });
 
     respond(true, {
@@ -2549,10 +3368,6 @@ class BncrBridgeRuntime {
     const accountId = normalizeAccountId(asString(params?.accountId || ''));
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
-    this.rememberGatewayContext(context);
-    this.markSeen(accountId, connId, clientId);
-    this.observeLease('file.chunk', params ?? {});
-    this.markActivity(accountId);
 
     const transferId = asString(params?.transferId || '').trim();
     const chunkIndex = Number(params?.chunkIndex ?? -1);
@@ -2572,6 +3387,30 @@ class BncrBridgeRuntime {
       return;
     }
 
+    const staleObserved = this.observeLease('file.chunk', params ?? {});
+    if (staleObserved.stale) {
+      if (
+        !this.matchesTransferOwner({
+          ownerConnId: st.ownerConnId,
+          ownerClientId: st.ownerClientId,
+          connId,
+          clientId,
+        })
+      ) {
+        this.logWarn(
+          'stale',
+          `ignore kind=file.chunk accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId} reason=owner-mismatch ownerConnId=${st.ownerConnId || '-'} ownerClientId=${st.ownerClientId || '-'}`,
+          { debugOnly: true },
+        );
+        respond(true, { ok: true, stale: true, ignored: true });
+        return;
+      }
+    } else {
+      this.rememberGatewayContext(context);
+      this.markSeen(accountId, connId, clientId);
+      this.markActivity(accountId);
+    }
+
     try {
       const buf = Buffer.from(base64, 'base64');
       if (size > 0 && buf.length !== size) {
@@ -2586,14 +3425,28 @@ class BncrBridgeRuntime {
       st.status = 'transferring';
       this.fileRecvTransfers.set(transferId, st);
 
-      respond(true, {
-        ok: true,
-        transferId,
-        chunkIndex,
-        offset,
-        received: st.receivedChunks.size,
-        totalChunks: st.totalChunks,
-      });
+      respond(
+        true,
+        staleObserved.stale
+          ? {
+              ok: true,
+              transferId,
+              chunkIndex,
+              offset,
+              received: st.receivedChunks.size,
+              totalChunks: st.totalChunks,
+              stale: true,
+              staleAccepted: true,
+            }
+          : {
+              ok: true,
+              transferId,
+              chunkIndex,
+              offset,
+              received: st.receivedChunks.size,
+              totalChunks: st.totalChunks,
+            },
+      );
     } catch (error) {
       respond(false, { error: String((error as any)?.message || error || 'chunk invalid') });
     }
@@ -2608,10 +3461,6 @@ class BncrBridgeRuntime {
     const accountId = normalizeAccountId(asString(params?.accountId || ''));
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
-    this.rememberGatewayContext(context);
-    this.markSeen(accountId, connId, clientId);
-    this.observeLease('file.complete', params ?? {});
-    this.markActivity(accountId);
 
     const transferId = asString(params?.transferId || '').trim();
     if (!transferId) {
@@ -2625,6 +3474,30 @@ class BncrBridgeRuntime {
       return;
     }
 
+    const staleObserved = this.observeLease('file.complete', params ?? {});
+    if (staleObserved.stale) {
+      if (
+        !this.matchesTransferOwner({
+          ownerConnId: st.ownerConnId,
+          ownerClientId: st.ownerClientId,
+          connId,
+          clientId,
+        })
+      ) {
+        this.logWarn(
+          'stale',
+          `ignore kind=file.complete accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId} reason=owner-mismatch ownerConnId=${st.ownerConnId || '-'} ownerClientId=${st.ownerClientId || '-'}`,
+          { debugOnly: true },
+        );
+        respond(true, { ok: true, stale: true, ignored: true });
+        return;
+      }
+    } else {
+      this.rememberGatewayContext(context);
+      this.markSeen(accountId, connId, clientId);
+      this.markActivity(accountId);
+    }
+
     try {
       if (st.receivedChunks.size < st.totalChunks) {
         throw new Error(
@@ -2655,15 +3528,30 @@ class BncrBridgeRuntime {
       st.status = 'completed';
       this.fileRecvTransfers.set(transferId, st);
 
-      respond(true, {
-        ok: true,
-        transferId,
-        path: saved.path,
-        size: merged.length,
-        fileName: st.fileName,
-        mimeType: st.mimeType,
-        fileSha256: digest,
-      });
+      respond(
+        true,
+        staleObserved.stale
+          ? {
+              ok: true,
+              transferId,
+              path: saved.path,
+              size: merged.length,
+              fileName: st.fileName,
+              mimeType: st.mimeType,
+              fileSha256: digest,
+              stale: true,
+              staleAccepted: true,
+            }
+          : {
+              ok: true,
+              transferId,
+              path: saved.path,
+              size: merged.length,
+              fileName: st.fileName,
+              mimeType: st.mimeType,
+              fileSha256: digest,
+            },
+      );
     } catch (error) {
       st.status = 'aborted';
       st.error = String((error as any)?.message || error || 'complete failed');
@@ -2676,10 +3564,6 @@ class BncrBridgeRuntime {
     const accountId = normalizeAccountId(asString(params?.accountId || ''));
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
-    this.rememberGatewayContext(context);
-    this.markSeen(accountId, connId, clientId);
-    this.observeLease('file.abort', params ?? {});
-    this.markActivity(accountId);
 
     const transferId = asString(params?.transferId || '').trim();
     if (!transferId) {
@@ -2693,36 +3577,122 @@ class BncrBridgeRuntime {
       return;
     }
 
+    const staleObserved = this.observeLease('file.abort', params ?? {});
+    if (staleObserved.stale) {
+      if (
+        !this.matchesTransferOwner({
+          ownerConnId: st.ownerConnId,
+          ownerClientId: st.ownerClientId,
+          connId,
+          clientId,
+        })
+      ) {
+        this.logWarn(
+          'stale',
+          `ignore kind=file.abort accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId} reason=owner-mismatch ownerConnId=${st.ownerConnId || '-'} ownerClientId=${st.ownerClientId || '-'}`,
+          { debugOnly: true },
+        );
+        respond(true, { ok: true, stale: true, ignored: true });
+        return;
+      }
+    } else {
+      this.rememberGatewayContext(context);
+      this.markSeen(accountId, connId, clientId);
+      this.markActivity(accountId);
+    }
+
     st.status = 'aborted';
     st.error = asString(params?.reason || 'aborted');
     this.fileRecvTransfers.set(transferId, st);
 
-    respond(true, {
-      ok: true,
-      transferId,
-      status: 'aborted',
-    });
+    respond(
+      true,
+      staleObserved.stale
+        ? {
+            ok: true,
+            transferId,
+            status: 'aborted',
+            stale: true,
+            staleAccepted: true,
+          }
+        : {
+            ok: true,
+            transferId,
+            status: 'aborted',
+          },
+    );
   };
 
   handleFileAck = async ({ params, respond, client, context }: GatewayRequestHandlerOptions) => {
     const accountId = normalizeAccountId(asString(params?.accountId || ''));
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
-    this.rememberGatewayContext(context);
-    this.markSeen(accountId, connId, clientId);
-    this.markActivity(accountId);
 
     const transferId = asString(params?.transferId || '').trim();
     const stage = asString(params?.stage || '').trim();
     const ok = params?.ok !== false;
     const chunkIndex = Number(params?.chunkIndex ?? -1);
 
+    this.logInfo(
+      'file-ack-inbound',
+      JSON.stringify({
+        bridge: this.bridgeId,
+        accountId,
+        connId,
+        clientId: clientId || null,
+        transferId,
+        stage,
+        ok,
+        chunkIndex: chunkIndex >= 0 ? chunkIndex : undefined,
+        errorCode: asString(params?.errorCode || ''),
+        errorMessage: asString(params?.errorMessage || ''),
+        path: asString(params?.path || '').trim(),
+      }),
+      { debugOnly: true },
+    );
+
     if (!transferId || !stage) {
       respond(false, { error: 'transferId/stage required' });
       return;
     }
 
     const st = this.fileSendTransfers.get(transferId);
+    const staleKind =
+      stage === 'init'
+        ? 'file.init'
+        : stage === 'chunk'
+          ? 'file.chunk'
+          : stage === 'abort'
+            ? 'file.abort'
+            : 'file.complete';
+    const staleObserved = this.observeLease(staleKind, params ?? {});
+    if (staleObserved.stale) {
+      const sameConn = !!st?.ownerConnId && st.ownerConnId === connId;
+      const sameClient =
+        !st?.ownerConnId && !!st?.ownerClientId && !!clientId && st.ownerClientId === clientId;
+      const adopted =
+        !(sameConn || sameClient) &&
+        this.tryAdoptTransferOwner({
+          accountId,
+          transfer: st,
+          connId,
+          clientId,
+        });
+      if (!(sameConn || sameClient || adopted)) {
+        this.logWarn(
+          'stale',
+          `ignore kind=file.ack accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId} stage=${stage} reason=owner-mismatch ownerConnId=${st?.ownerConnId || '-'} ownerClientId=${st?.ownerClientId || '-'}`,
+          { debugOnly: true },
+        );
+        respond(true, { ok: true, stale: true, ignored: true });
+        return;
+      }
+    } else {
+      this.rememberGatewayContext(context);
+      this.markSeen(accountId, connId, clientId);
+      this.markActivity(accountId);
+    }
+
     if (st) {
       if (!ok) {
         const code = asString(params?.errorCode || 'ACK_FAILED');
@@ -2759,12 +3729,24 @@ class BncrBridgeRuntime {
       ok,
     });
 
-    respond(true, {
-      ok: true,
-      transferId,
-      stage,
-      state: st?.status || 'late',
-    });
+    respond(
+      true,
+      staleObserved.stale
+        ? {
+            ok: true,
+            transferId,
+            stage,
+            state: st?.status || 'late',
+            stale: true,
+            staleAccepted: true,
+          }
+        : {
+            ok: true,
+            transferId,
+            stage,
+            state: st?.status || 'late',
+          },
+    );
   };
 
   handleInbound = async ({ params, respond, client, context }: GatewayRequestHandlerOptions) => {
@@ -2790,10 +3772,49 @@ class BncrBridgeRuntime {
     } = parsed;
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
+    if (
+      this.shouldIgnoreStaleEvent({
+        kind: 'inbound',
+        payload: params ?? {},
+        accountId,
+        connId,
+        clientId,
+      })
+    ) {
+      respond(true, {
+        accepted: false,
+        stale: true,
+        ignored: true,
+        accountId,
+        msgId: msgId ?? null,
+      });
+      return;
+    }
     this.rememberGatewayContext(context);
     this.markSeen(accountId, connId, clientId);
-    this.observeLease('inbound', params ?? {});
     this.markActivity(accountId);
+    this.logInfo(
+      'inbound',
+      `lifecycle ${JSON.stringify({
+        stage: 'accepted',
+        bridge: this.bridgeId,
+        accountId,
+        connId,
+        clientId,
+        onlineAfterSeen: this.isOnline(accountId),
+        recentInboundReachable: this.hasRecentInboundReachability(accountId),
+        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,
+            connectedAt: c.connectedAt,
+            lastSeenAt: c.lastSeenAt,
+          })),
+      })}`,
+      { debugOnly: true },
+    );
     this.lastInboundAtGlobal = now();
     this.incrementCounter(this.inboundEventsByAccount, accountId);
 
@@ -2811,7 +3832,7 @@ class BncrBridgeRuntime {
       return;
     }
 
-    const cfg = await this.api.runtime.config.loadConfig();
+    const cfg = this.api.runtime.config.current();
     const gate = checkBncrMessageGate({
       parsed,
       cfg,
@@ -2876,6 +3897,7 @@ class BncrBridgeRuntime {
       msgId: msgId ?? null,
       taskKey: extracted.taskKey ?? null,
     });
+    this.flushPushQueue(accountId);
 
     void dispatchBncrInbound({
       api: this.api,
@@ -2902,11 +3924,43 @@ class BncrBridgeRuntime {
 
   channelStartAccount = async (ctx: any) => {
     const accountId = normalizeAccountId(ctx.accountId);
+    this.clearChannelAccountWorker(accountId, 'start-replace');
 
     const tick = () => {
-      const connected = this.isOnline(accountId);
       const previous = ctx.getStatus?.() || {};
-      const lastActAt = this.lastActivityByAccount.get(accountId) || previous?.lastEventAt || null;
+      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;
+      this.logInfo(
+        'health',
+        `status-tick ${JSON.stringify({
+          bridge: this.bridgeId,
+          accountId,
+          connected,
+          onlineByConn,
+          recentInboundReachable,
+          lastActivityAt: this.lastActivityByAccount.get(accountId) || null,
+          lastInboundAt: this.lastInboundByAccount.get(accountId) || null,
+          lastOutboundAt: this.lastOutboundByAccount.get(accountId) || null,
+          chosenLastEventAt: lastActAt,
+          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,
+              connectedAt: c.connectedAt,
+              lastSeenAt: c.lastSeenAt,
+            })),
+        })}`,
+        { debugOnly: true },
+      );
 
       ctx.setStatus?.({
         ...previous,
@@ -2923,13 +3977,30 @@ class BncrBridgeRuntime {
 
     tick();
     const timer = setInterval(tick, 5_000);
+    this.channelAccountTimers.set(accountId, timer);
 
     await new Promise<void>((resolve) => {
-      const onAbort = () => {
-        clearInterval(timer);
+      let settled = false;
+      const finish = (reason: string) => {
+        if (settled) return;
+        settled = true;
+        const activeTimer = this.channelAccountTimers.get(accountId);
+        if (activeTimer === timer) {
+          clearInterval(timer);
+          this.channelAccountTimers.delete(accountId);
+        } else {
+          clearInterval(timer);
+        }
+        this.logInfo(
+          'health',
+          `status-worker finished ${JSON.stringify({ bridge: this.bridgeId, accountId, reason })}`,
+          { debugOnly: true },
+        );
         resolve();
       };
 
+      const onAbort = () => finish('abort');
+
       if (ctx.abortSignal?.aborted) {
         onAbort();
         return;
@@ -2939,8 +4010,23 @@ class BncrBridgeRuntime {
     });
   };
 
-  channelStopAccount = async (_ctx: any) => {
-    // no-op
+  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 },
+    );
   };
 
   channelSendText = async (ctx: any) => {
@@ -3034,7 +4120,7 @@ export function createBncrBridge(api: OpenClawPluginApi) {
   return new BncrBridgeRuntime(api);
 }
 
-export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
+export function createBncrChannelPlugin(getBridge: () => BncrBridgeRuntime) {
   const messageActions: ChannelMessageActionAdapter = {
     describeMessageTool: ({ cfg }) => {
       const channelCfg = cfg?.channels?.[CHANNEL_ID];
@@ -3046,9 +4132,10 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
           (accountId) => resolveAccount(cfg, accountId).enabled !== false,
         );
 
+      const runtimeBridge = getBridge();
       const hasConnectedRuntime = listAccountIds(cfg).some((accountId) => {
         const resolved = resolveAccount(cfg, accountId);
-        const runtime = bridge.getAccountRuntimeSnapshot(resolved.accountId);
+        const runtime = runtimeBridge.getAccountRuntimeSnapshot(resolved.accountId);
         return Boolean(runtime?.connected);
       });
 
@@ -3066,49 +4153,37 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
     handleAction: async ({ action, params, accountId, mediaLocalRoots }) => {
       if (action !== 'send')
         throw new Error(`Action ${action} is not supported for provider ${CHANNEL_ID}.`);
-      const to = readStringParam(params, 'to', { required: true });
-      const message = readStringParam(params, 'message', { allowEmpty: true }) ?? '';
-      const caption = readStringParam(params, 'caption', { allowEmpty: true }) ?? '';
-      const content = message || caption || '';
-      const mediaUrl =
-        readStringParam(params, 'media', { trim: false }) ??
-        readStringParam(params, 'path', { trim: false }) ??
-        readStringParam(params, 'filePath', { trim: false }) ??
-        readStringParam(params, 'mediaUrl', { trim: false });
-      const asVoice = readBooleanParam(params, 'asVoice') ?? false;
-      const audioAsVoice = readBooleanParam(params, 'audioAsVoice') ?? false;
-      const resolvedAccountId = normalizeAccountId(
-        readStringParam(params, 'accountId') ?? accountId,
-      );
-
-      if (!content.trim() && !mediaUrl) throw new Error('send requires text or media');
+      const normalized = normalizeBncrSendParams({ params, accountId });
 
-      const result = mediaUrl
+      const runtimeBridge = getBridge();
+      const result = normalized.mediaUrl
         ? await sendBncrMedia({
             channelId: CHANNEL_ID,
-            accountId: resolvedAccountId,
-            to,
-            text: content,
-            mediaUrl,
-            asVoice,
-            audioAsVoice,
+            accountId: normalized.accountId,
+            to: normalized.to,
+            text: normalized.caption,
+            mediaUrl: normalized.mediaUrl,
+            asVoice: normalized.asVoice,
+            audioAsVoice: normalized.audioAsVoice,
             mediaLocalRoots,
-            resolveVerifiedTarget: (to, accountId) => bridge.resolveVerifiedTarget(to, accountId),
+            resolveVerifiedTarget: (to, accountId) =>
+              runtimeBridge.resolveVerifiedTarget(to, accountId),
             rememberSessionRoute: (sessionKey, accountId, route) =>
-              bridge.rememberSessionRoute(sessionKey, accountId, route),
-            enqueueFromReply: (args) => bridge.enqueueFromReply(args as any),
+              runtimeBridge.rememberSessionRoute(sessionKey, accountId, route),
+            enqueueFromReply: (args) => runtimeBridge.enqueueFromReply(args as any),
             createMessageId: () => randomUUID(),
           })
         : await sendBncrText({
             channelId: CHANNEL_ID,
-            accountId: resolvedAccountId,
-            to,
-            text: content,
+            accountId: normalized.accountId,
+            to: normalized.to,
+            text: normalized.message,
             mediaLocalRoots,
-            resolveVerifiedTarget: (to, accountId) => bridge.resolveVerifiedTarget(to, accountId),
+            resolveVerifiedTarget: (to, accountId) =>
+              runtimeBridge.resolveVerifiedTarget(to, accountId),
             rememberSessionRoute: (sessionKey, accountId, route) =>
-              bridge.rememberSessionRoute(sessionKey, accountId, route),
-            enqueueFromReply: (args) => bridge.enqueueFromReply(args as any),
+              runtimeBridge.rememberSessionRoute(sessionKey, accountId, route),
+            enqueueFromReply: (args) => runtimeBridge.enqueueFromReply(args as any),
             createMessageId: () => randomUUID(),
           });
 
@@ -3143,9 +4218,10 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
         const resolvedAccountId = normalizeAccountId(
           asString(accountId || BNCR_DEFAULT_ACCOUNT_ID),
         );
+        const runtimeBridge = getBridge();
         const canonicalAgentId =
-          bridge.canonicalAgentId ||
-          bridge.ensureCanonicalAgentId({ cfg, accountId: resolvedAccountId });
+          runtimeBridge.canonicalAgentId ||
+          runtimeBridge.ensureCanonicalAgentId({ cfg, accountId: resolvedAccountId });
         return parseExplicitTarget(asString(raw).trim(), { canonicalAgentId });
       },
       formatTargetDisplay: ({ target }: any) => {
@@ -3157,13 +4233,14 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
         const resolvedAccountId = normalizeAccountId(
           asString(accountId || BNCR_DEFAULT_ACCOUNT_ID),
         );
+        const runtimeBridge = getBridge();
         const canonicalAgentId =
-          bridge.canonicalAgentId ||
-          bridge.ensureCanonicalAgentId({ cfg, accountId: resolvedAccountId });
+          runtimeBridge.canonicalAgentId ||
+          runtimeBridge.ensureCanonicalAgentId({ cfg, accountId: resolvedAccountId });
 
         let parsed = parseExplicitTarget(raw, { canonicalAgentId });
         if (!parsed) {
-          const route = bridge.resolveRouteBySession(raw, resolvedAccountId);
+          const route = runtimeBridge.resolveRouteBySession(raw, resolvedAccountId);
           if (route) {
             parsed = parseExplicitTarget(formatDisplayScope(route), { canonicalAgentId });
           }
@@ -3174,13 +4251,15 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
         const accountId = normalizeAccountId(
           asString(params?.accountId || BNCR_DEFAULT_ACCOUNT_ID),
         );
+        const runtimeBridge = getBridge();
         const canonicalAgentId =
-          bridge.canonicalAgentId || bridge.ensureCanonicalAgentId({ cfg: params?.cfg, accountId });
+          runtimeBridge.canonicalAgentId ||
+          runtimeBridge.ensureCanonicalAgentId({ cfg: params?.cfg, accountId });
         return resolveBncrOutboundSessionRoute({
           ...params,
           canonicalAgentId,
           resolveRouteBySession: (raw: string, acc: string) =>
-            bridge.resolveRouteBySession(raw, acc),
+            runtimeBridge.resolveRouteBySession(raw, acc),
         });
       },
       targetResolver: {
@@ -3188,11 +4267,12 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
           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) =>
-              this.resolveRouteBySession(raw, acc),
+              runtimeBridge.resolveRouteBySession(raw, acc),
           });
           if (!resolved) return null;
           return {
@@ -3255,8 +4335,8 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
     },
     outbound: {
       deliveryMode: 'gateway' as const,
-      sendText: bridge.channelSendText,
-      sendMedia: bridge.channelSendMedia,
+      sendText: async (ctx: any) => getBridge().channelSendText(ctx),
+      sendMedia: async (ctx: any) => getBridge().channelSendMedia(ctx),
       replyAction: async (ctx: any) =>
         sendBncrReplyAction({
           accountId: normalizeAccountId(ctx?.accountId),
@@ -3265,7 +4345,7 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
           replyToMessageId:
             asString(ctx?.replyToId || ctx?.replyToMessageId || '').trim() || undefined,
           sendText: async ({ accountId, to, text }) =>
-            bridge.channelSendText({ accountId, to, text }),
+            getBridge().channelSendText({ accountId, to, text }),
         }),
       deleteAction: async (ctx: any) =>
         deleteBncrMessageAction({
@@ -3290,10 +4370,11 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
         mode: 'ws-offline',
       }),
       buildChannelSummary: async ({ defaultAccountId }: any) => {
-        return bridge.getChannelSummary(defaultAccountId || BNCR_DEFAULT_ACCOUNT_ID);
+        return getBridge().getChannelSummary(defaultAccountId || BNCR_DEFAULT_ACCOUNT_ID);
       },
       buildAccountSnapshot: async ({ account, runtime }: any) => {
-        const rt = runtime || bridge.getAccountRuntimeSnapshot(account?.accountId);
+        const runtimeBridge = getBridge();
+        const rt = runtime || runtimeBridge.getAccountRuntimeSnapshot(account?.accountId);
         const meta = rt?.meta || {};
 
         const pending = Number(rt?.pending ?? meta.pending ?? 0);
@@ -3328,7 +4409,7 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
           mode: normalizedMode,
           pending,
           deadLetter,
-          healthSummary: bridge.getStatusHeadline(account?.accountId),
+          healthSummary: runtimeBridge.getStatusHeadline(account?.accountId),
           lastSessionKey,
           lastSessionScope,
           lastSessionAt,
@@ -3346,7 +4427,7 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
         if (!enabled) return 'disabled';
         const resolved = resolveAccount(cfg, account?.accountId);
         if (!(resolved.enabled && configured)) return 'not configured';
-        const rt = runtime || bridge.getAccountRuntimeSnapshot(account?.accountId);
+        const rt = runtime || getBridge().getAccountRuntimeSnapshot(account?.accountId);
         return rt?.connected ? 'linked' : 'configured';
       },
     },
@@ -3363,8 +4444,8 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
       'bncr.file.ack',
     ],
     gateway: {
-      startAccount: bridge.channelStartAccount,
-      stopAccount: bridge.channelStopAccount,
+      startAccount: async (ctx: any) => getBridge().channelStartAccount(ctx),
+      stopAccount: async (ctx: any) => getBridge().channelStopAccount(ctx),
     },
   };