@xmoxmo/bncr 0.2.3 → 0.2.4

package/src/channel.ts

@@ -83,6 +83,8 @@ 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;
+const OUTBOUND_READY_TTL_MS = 30_000;
+const PREFERRED_OUTBOUND_TTL_MS = 12_000;
 const FILE_FORCE_CHUNK = true; // 统一走 WS 分块，保留 base64 仅作兜底
 const FILE_INLINE_THRESHOLD = 5 * 1024 * 1024; // fallback 阈值（仅 FILE_FORCE_CHUNK=false 时生效）
 const FILE_CHUNK_SIZE = 256 * 1024; // 256KB
@@ -246,6 +248,49 @@ function normalizeBncrSendParams(input: {
   };
 }
 
+type MediaDedupeCacheEntry = {
+  mediaUrl: string;
+  text: string;
+  replyToId: string;
+  createdAt: number;
+};
+
+function normalizeReplyToId(value: unknown): string {
+  return asString(value || '').trim();
+}
+
+function normalizeMessageText(value: unknown): string {
+  return asString(value || '').trim();
+}
+
+function shouldTreatReplyToAsSame(currentReplyToId: string, previousReplyToId: string): boolean {
+  if (!currentReplyToId || !previousReplyToId) return true;
+  return currentReplyToId === previousReplyToId;
+}
+
+function buildMediaTextFallback(params: {
+  currentText: string;
+  previousText: string;
+  currentReplyToId: string;
+  previousReplyToId: string;
+}): { text: string; reason: 'same-text-sent-checkmark' | 'text-changed-downgrade' } | null {
+  if (!shouldTreatReplyToAsSame(params.currentReplyToId, params.previousReplyToId)) {
+    return null;
+  }
+
+  if (params.currentText && params.currentText !== params.previousText) {
+    return {
+      text: params.currentText,
+      reason: 'text-changed-downgrade',
+    };
+  }
+
+  return {
+    text: '✅已发送',
+    reason: 'same-text-sent-checkmark',
+  };
+}
+
 function now() {
   return Date.now();
 }
@@ -333,6 +378,7 @@ class BncrBridgeRuntime {
   private api: OpenClawPluginApi;
   private statePath: string | null = null;
   private bridgeId = `${process.pid}-${Math.random().toString(16).slice(2, 8)}`;
+  private recentMediaDedupeBySession = new Map<string, Map<string, MediaDedupeCacheEntry>>();
   private gatewayPid = process.pid;
   private registerCount = 0;
   private apiGeneration = 0;
@@ -410,6 +456,7 @@ class BncrBridgeRuntime {
   private lastInboundByAccount = new Map<string, number>();
   private lastOutboundByAccount = new Map<string, number>();
   private channelAccountTimers = new Map<string, NodeJS.Timeout>();
+  private logDedupeState = new Map<string, { at: number; sig: string }>();
   private canonicalAgentId: string | null = null;
   private canonicalAgentSource: 'startup' | 'runtime' | 'fallback-main' | null = null;
   private canonicalAgentResolvedAt: number | null = null;
@@ -470,6 +517,102 @@ class BncrBridgeRuntime {
     emitBncrLog('error', scope, message, options, () => this.isDebugEnabled());
   }
 
+  private buildDebugJsonMessage(event: string, payload: Record<string, unknown>) {
+    return `${event} ${JSON.stringify(payload)}`;
+  }
+
+  private logInfoJson(
+    scope: string | undefined,
+    event: string,
+    payload: Record<string, unknown>,
+    options?: { debugOnly?: boolean },
+  ) {
+    this.logInfo(scope, this.buildDebugJsonMessage(event, payload), options);
+  }
+
+  private logWarnJson(
+    scope: string | undefined,
+    event: string,
+    payload: Record<string, unknown>,
+    options?: { debugOnly?: boolean },
+  ) {
+    this.logWarn(scope, this.buildDebugJsonMessage(event, payload), options);
+  }
+
+  private logErrorJson(
+    scope: string | undefined,
+    event: string,
+    payload: Record<string, unknown>,
+    options?: { debugOnly?: boolean },
+  ) {
+    this.logError(scope, this.buildDebugJsonMessage(event, payload), options);
+  }
+
+  private shouldEmitDedupLog(key: string, sig: string, windowMs = 5 * 60 * 1000) {
+    const t = now();
+    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 });
+    return true;
+  }
+
+  private logInfoDedup(
+    scope: string | undefined,
+    message: string,
+    options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+  ) {
+    if (!this.shouldEmitDedupLog(options.key, options.sig, options.windowMs)) return;
+    this.logInfo(scope, message, { debugOnly: options.debugOnly });
+  }
+
+  private logWarnDedup(
+    scope: string | undefined,
+    message: string,
+    options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+  ) {
+    if (!this.shouldEmitDedupLog(options.key, options.sig, options.windowMs)) return;
+    this.logWarn(scope, message, { debugOnly: options.debugOnly });
+  }
+
+  private logErrorDedup(
+    scope: string | undefined,
+    message: string,
+    options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+  ) {
+    if (!this.shouldEmitDedupLog(options.key, options.sig, options.windowMs)) return;
+    this.logError(scope, message, { debugOnly: options.debugOnly });
+  }
+
+  private logInfoDedupJson(
+    scope: string | undefined,
+    event: string,
+    payload: Record<string, unknown>,
+    options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+  ) {
+    if (!this.shouldEmitDedupLog(options.key, options.sig, options.windowMs)) return;
+    this.logInfoJson(scope, event, payload, { debugOnly: options.debugOnly });
+  }
+
+  private logWarnDedupJson(
+    scope: string | undefined,
+    event: string,
+    payload: Record<string, unknown>,
+    options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+  ) {
+    if (!this.shouldEmitDedupLog(options.key, options.sig, options.windowMs)) return;
+    this.logWarnJson(scope, event, payload, { debugOnly: options.debugOnly });
+  }
+
+  private logErrorDedupJson(
+    scope: string | undefined,
+    event: string,
+    payload: Record<string, unknown>,
+    options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+  ) {
+    if (!this.shouldEmitDedupLog(options.key, options.sig, options.windowMs)) return;
+    this.logErrorJson(scope, event, payload, { debugOnly: options.debugOnly });
+  }
+
   private summarizeTextPreview(raw: string, limit = 8) {
     const compact = asString(raw || '')
       .replace(/\s+/g, ' ')
@@ -790,7 +933,8 @@ class BncrBridgeRuntime {
   }
 
   private buildExtendedDiagnostics(accountId: string) {
-    const diagnostics = this.buildIntegratedDiagnostics(accountId) as Record<string, any>;
+    const acc = normalizeAccountId(accountId);
+    const diagnostics = this.buildIntegratedDiagnostics(acc) as Record<string, any>;
     return {
       ...diagnostics,
       register: {
@@ -810,7 +954,7 @@ class BncrBridgeRuntime {
         lastDriftSnapshot: this.lastDriftSnapshot,
       },
       connection: {
-        active: this.activeConnectionCount(accountId),
+        active: this.activeConnectionCount(acc),
         primaryLeaseId: this.primaryLeaseId,
         primaryEpoch: this.connectionEpoch || null,
         acceptedConnections: this.acceptedConnections,
@@ -1338,11 +1482,92 @@ class BncrBridgeRuntime {
     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;
+    const primary = primaryKey ? this.connections.get(primaryKey) : null;
+
+    const isEligible = (conn: BncrConnection | null | undefined): conn is BncrConnection & {
+      outboundReadyUntil?: number;
+      preferredForOutboundUntil?: number;
+      inboundOnly?: boolean;
+    } => {
+      if (!conn?.connId) return false;
+      if (t - conn.lastSeenAt > CONNECT_TTL_MS) return false;
+      if ((conn as any).inboundOnly === true) return false;
+      return true;
+    };
+
+    const recentInboundConnIds = this.resolveRecentInboundConnIds(acc);
+    const candidateScore = (conn: BncrConnection) => {
+      const preferredForOutboundUntil = Number((conn as any).preferredForOutboundUntil || 0);
+      const outboundReadyUntil = Number((conn as any).outboundReadyUntil || 0);
+      const lastPushTimeoutAt = Number((conn as any).lastPushTimeoutAt || 0);
+      const lastAckOkAt = Number((conn as any).lastAckOkAt || 0);
+      const pushFailureScore = Number((conn as any).pushFailureScore || 0);
+      const recentTimeoutPenalty = lastPushTimeoutAt > 0 && t - lastPushTimeoutAt <= 30_000 ? 1 : 0;
+      return {
+        preferred: preferredForOutboundUntil > t ? 1 : 0,
+        ready: outboundReadyUntil > t ? 1 : 0,
+        recentInbound: recentInboundConnIds.has(conn.connId) ? 1 : 0,
+        recentTimeoutPenalty,
+        pushFailureScore,
+        lastAckOkAt,
+        lastPushTimeoutAt,
+        lastSeenAt: conn.lastSeenAt,
+        connectedAt: conn.connectedAt,
+      };
+    };
+
+    if (isEligible(primary)) {
+      const score = candidateScore(primary);
+      if (score.preferred || score.ready) return primary;
+    }
+
+    const candidates = Array.from(this.connections.values())
+      .filter((c): c is BncrConnection => c.accountId === acc)
+      .filter((c) => isEligible(c))
+      .sort((a, b) => {
+        const sa = candidateScore(a);
+        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 (sb.lastAckOkAt !== sa.lastAckOkAt) return sb.lastAckOkAt - sa.lastAckOkAt;
+        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;
+      });
+
+    const next = candidates[0] || null;
+    if (!next) return null;
+
+    const nextKey = this.connectionKey(acc, next.clientId);
+    if (primaryKey !== nextKey) {
+      this.activeConnectionByAccount.set(acc, nextKey);
+      this.logInfo(
+        'connection',
+        `owner:promote ${JSON.stringify({
+          bridge: this.bridgeId,
+          accountId: acc,
+          previousActiveKey: primaryKey || null,
+          previousActiveConn: primary || null,
+          nextActiveKey: nextKey,
+          nextActiveConn: {
+            connId: next.connId,
+            clientId: next.clientId,
+            connectedAt: next.connectedAt,
+            lastSeenAt: next.lastSeenAt,
+            outboundReadyUntil: (next as any).outboundReadyUntil || null,
+            preferredForOutboundUntil: (next as any).preferredForOutboundUntil || null,
+            inboundOnly: (next as any).inboundOnly === true,
+          },
+          reason: 'better-outbound-candidate',
+        })}`,
+        { debugOnly: true },
+      );
+    }
+
+    return next;
   }
 
   private resolvePushConnIds(accountId: string): Set<string> {
@@ -1350,14 +1575,67 @@ class BncrBridgeRuntime {
     const t = now();
     const connIds = new Set<string>();
 
+    const isEligible = (conn: BncrConnection | null | undefined): conn is BncrConnection & {
+      outboundReadyUntil?: number;
+      preferredForOutboundUntil?: number;
+      inboundOnly?: boolean;
+    } => {
+      if (!conn?.connId) return false;
+      if (t - conn.lastSeenAt > CONNECT_TTL_MS) return false;
+      if ((conn as any).inboundOnly === true) return false;
+      return true;
+    };
+
+    const recentInboundConnIds = this.resolveRecentInboundConnIds(acc);
+    const candidateScore = (conn: BncrConnection) => {
+      const preferredForOutboundUntil = Number((conn as any).preferredForOutboundUntil || 0);
+      const outboundReadyUntil = Number((conn as any).outboundReadyUntil || 0);
+      const lastPushTimeoutAt = Number((conn as any).lastPushTimeoutAt || 0);
+      const lastAckOkAt = Number((conn as any).lastAckOkAt || 0);
+      const pushFailureScore = Number((conn as any).pushFailureScore || 0);
+      const recentTimeoutPenalty = lastPushTimeoutAt > 0 && t - lastPushTimeoutAt <= 30_000 ? 1 : 0;
+      return {
+        preferred: preferredForOutboundUntil > t ? 1 : 0,
+        ready: outboundReadyUntil > t ? 1 : 0,
+        recentInbound: recentInboundConnIds.has(conn.connId) ? 1 : 0,
+        recentTimeoutPenalty,
+        pushFailureScore,
+        lastAckOkAt,
+        lastPushTimeoutAt,
+        lastSeenAt: conn.lastSeenAt,
+        connectedAt: conn.connectedAt,
+      };
+    };
+
     const primaryKey = this.activeConnectionByAccount.get(acc);
     if (primaryKey) {
       const primary = this.connections.get(primaryKey);
-      if (primary?.connId && t - primary.lastSeenAt <= CONNECT_TTL_MS) {
+      if (isEligible(primary)) {
         connIds.add(primary.connId);
       }
     }
 
+    const candidates = Array.from(this.connections.values())
+      .filter((c): c is BncrConnection => c.accountId === acc)
+      .filter((c) => isEligible(c))
+      .sort((a, b) => {
+        const sa = candidateScore(a);
+        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 (sb.lastAckOkAt !== sa.lastAckOkAt) return sb.lastAckOkAt - sa.lastAckOkAt;
+        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;
+      });
+
+    for (const c of candidates) {
+      connIds.add(c.connId);
+    }
+
     if (connIds.size > 0) return connIds;
 
     for (const c of this.connections.values()) {
@@ -1413,6 +1691,73 @@ class BncrBridgeRuntime {
     return true;
   }
 
+  private isRevalidatedAttemptedConn(entry: OutboxEntry, connId: string): boolean {
+    const targetConnId = asString(connId || '').trim();
+    if (!targetConnId) return false;
+
+    const acc = normalizeAccountId(entry.accountId);
+    const t = now();
+    const lastAttemptAt = Number(entry.lastAttemptAt || 0);
+    const recentInboundReachable = this.hasRecentInboundReachability(acc);
+
+    for (const conn of this.connections.values()) {
+      if (conn.accountId !== acc) continue;
+      if (conn.connId !== targetConnId) continue;
+      if (t - conn.lastSeenAt > CONNECT_TTL_MS) continue;
+      if ((conn as any).inboundOnly === true) continue;
+
+      const preferredForOutboundUntil = Number((conn as any).preferredForOutboundUntil || 0);
+      const outboundReadyUntil = Number((conn as any).outboundReadyUntil || 0);
+      const lastAckOkAt = Number((conn as any).lastAckOkAt || 0);
+      const lastPushTimeoutAt = Number((conn as any).lastPushTimeoutAt || 0);
+
+      const revalidatedByPreferred = preferredForOutboundUntil > t;
+      const revalidatedByReady = outboundReadyUntil > t;
+      const revalidatedByAck = lastAckOkAt > 0 && lastAckOkAt > lastAttemptAt;
+      const revalidatedByFreshReachability =
+        recentInboundReachable &&
+        lastPushTimeoutAt > 0 &&
+        lastPushTimeoutAt <= lastAttemptAt &&
+        conn.lastSeenAt > lastPushTimeoutAt;
+
+      const revalidated =
+        revalidatedByPreferred ||
+        revalidatedByReady ||
+        revalidatedByAck ||
+        revalidatedByFreshReachability;
+
+      if (revalidated) {
+        this.logInfo(
+          'outbox',
+          `revalidated-retry ${JSON.stringify({
+            messageId: entry.messageId,
+            accountId: acc,
+            connId: targetConnId,
+            reason: revalidatedByAck
+              ? 'ack-after-last-attempt'
+              : revalidatedByPreferred
+                ? 'preferred-ttl'
+                : revalidatedByReady
+                  ? 'ready-ttl'
+                  : 'fresh-reachability',
+            lastAttemptAt,
+            lastAckOkAt: lastAckOkAt || null,
+            lastPushTimeoutAt: lastPushTimeoutAt || null,
+            outboundReadyUntil: outboundReadyUntil || null,
+            preferredForOutboundUntil: preferredForOutboundUntil || null,
+            lastSeenAt: conn.lastSeenAt,
+            recentInboundReachable,
+          })}`,
+          { debugOnly: true },
+        );
+      }
+
+      return revalidated;
+    }
+
+    return false;
+  }
+
   private tryAdoptTransferOwner(args: {
     accountId: string;
     transfer:
@@ -1494,6 +1839,114 @@ class BncrBridgeRuntime {
     };
   }
 
+  private pruneMediaDedupeCache(sessionKey: string, currentTime = now()) {
+    const sessionCache = this.recentMediaDedupeBySession.get(sessionKey);
+    if (!sessionCache) return;
+
+    for (const [mediaUrl, entry] of sessionCache.entries()) {
+      if (currentTime - entry.createdAt > 10_000) {
+        sessionCache.delete(mediaUrl);
+      }
+    }
+
+    if (sessionCache.size === 0) {
+      this.recentMediaDedupeBySession.delete(sessionKey);
+    }
+  }
+
+  private rememberRecentMediaSend(params: {
+    sessionKey: string;
+    mediaUrl: string;
+    text: string;
+    replyToId: string;
+    createdAt?: number;
+  }) {
+    const sessionKey = asString(params.sessionKey || '').trim();
+    const mediaUrl = asString(params.mediaUrl || '').trim();
+    if (!sessionKey || !mediaUrl) return;
+
+    const createdAt = typeof params.createdAt === 'number' ? params.createdAt : now();
+    this.pruneMediaDedupeCache(sessionKey, createdAt);
+    let sessionCache = this.recentMediaDedupeBySession.get(sessionKey);
+    if (!sessionCache) {
+      sessionCache = new Map<string, MediaDedupeCacheEntry>();
+      this.recentMediaDedupeBySession.set(sessionKey, sessionCache);
+    }
+    sessionCache.set(mediaUrl, {
+      mediaUrl,
+      text: normalizeMessageText(params.text),
+      replyToId: normalizeReplyToId(params.replyToId),
+      createdAt,
+    });
+  }
+
+  private tryBuildMediaDedupeFallback(params: {
+    sessionKey: string;
+    mediaUrl: string;
+    text: string;
+    replyToId: string;
+    currentTime?: number;
+  }): { text: string; reason: 'same-text-sent-checkmark' | 'text-changed-downgrade' } | null {
+    const sessionKey = asString(params.sessionKey || '').trim();
+    const mediaUrl = asString(params.mediaUrl || '').trim();
+    if (!sessionKey || !mediaUrl) return null;
+
+    const currentTime = typeof params.currentTime === 'number' ? params.currentTime : now();
+    this.pruneMediaDedupeCache(sessionKey, currentTime);
+    const sessionCache = this.recentMediaDedupeBySession.get(sessionKey);
+    const previous = sessionCache?.get(mediaUrl);
+    if (!previous) return null;
+    if (currentTime - previous.createdAt > 10_000) return null;
+
+    return buildMediaTextFallback({
+      currentText: normalizeMessageText(params.text),
+      previousText: previous.text,
+      currentReplyToId: normalizeReplyToId(params.replyToId),
+      previousReplyToId: previous.replyToId,
+    });
+  }
+
+  private buildTextOutboxEntry(params: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    text: string;
+    kind?: 'tool' | 'block' | 'final';
+    replyToId?: string;
+  }): OutboxEntry {
+    const messageId = randomUUID();
+    const frame = {
+      type: 'message.outbound',
+      messageId,
+      idempotencyKey: messageId,
+      sessionKey: params.sessionKey,
+      replyToId: normalizeReplyToId(params.replyToId) || undefined,
+      message: {
+        platform: params.route.platform,
+        groupId: params.route.groupId,
+        userId: params.route.userId,
+        type: 'text',
+        kind: params.kind,
+        msg: params.text,
+        path: '',
+        base64: '',
+        fileName: '',
+      },
+      ts: now(),
+    };
+
+    return {
+      messageId,
+      accountId: normalizeAccountId(params.accountId),
+      sessionKey: params.sessionKey,
+      route: params.route,
+      payload: frame,
+      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') {
@@ -1514,13 +1967,39 @@ class BncrBridgeRuntime {
         return false;
       }
 
+      const attemptedConnIds = new Set(
+        Array.isArray(entry.routeAttemptConnIds)
+          ? entry.routeAttemptConnIds.filter((v): v is string => typeof v === 'string' && !!v)
+          : [],
+      );
+      const routeCandidates = Array.from(this.resolvePushConnIds(entry.accountId));
+      const filteredCandidates = routeCandidates.filter(
+        (connId) =>
+          !attemptedConnIds.has(connId) || this.isRevalidatedAttemptedConn(entry, connId),
+      );
       const owner = this.resolveOutboxPushOwner(entry.accountId);
-      let connIds = owner?.connId
-        ? new Set([owner.connId])
-        : this.resolvePushConnIds(entry.accountId);
+      const ownerConnId = owner?.connId && !attemptedConnIds.has(owner.connId) ? owner.connId : undefined;
+      let connIds = ownerConnId
+        ? new Set([ownerConnId])
+        : new Set(filteredCandidates.length ? filteredCandidates : routeCandidates);
       const recentInboundReachable = this.hasRecentInboundReachability(entry.accountId);
+      const routeReason = ownerConnId
+        ? 'owner'
+        : connIds.size > 0
+          ? filteredCandidates.length > 0
+            ? 'active-connections'
+            : 'active-connections-reused'
+          : recentInboundReachable
+            ? 'recent-inbound-fallback'
+            : 'none';
       if (!connIds.size && recentInboundReachable) {
-        connIds = this.resolveRecentInboundConnIds(entry.accountId);
+        const recentInboundConnIds = Array.from(this.resolveRecentInboundConnIds(entry.accountId));
+        const filteredRecentInboundConnIds = recentInboundConnIds.filter(
+          (connId) => !attemptedConnIds.has(connId),
+        );
+        connIds = new Set(
+          filteredRecentInboundConnIds.length > 0 ? filteredRecentInboundConnIds : recentInboundConnIds,
+        );
       }
       if (!connIds.size) {
         entry.lastError = 'no active bncr client for file chunk transfer';
@@ -1598,15 +2077,35 @@ class BncrBridgeRuntime {
           },
           connIds,
         );
+        this.logInfo(
+          'outbox',
+          `route-select ${JSON.stringify({
+            messageId: entry.messageId,
+            accountId: entry.accountId,
+            kind: 'file-transfer',
+            routeReason,
+            connIds: Array.from(connIds),
+            ownerConnId: owner?.connId || '',
+            ownerClientId: owner?.clientId || '',
+            recentInboundReachable,
+            event: BNCR_PUSH_EVENT,
+          })}`,
+          { debugOnly: true },
+        );
         entry.lastPushAt = now();
         entry.lastPushConnId =
           owner?.connId || (connIds.size === 1 ? Array.from(connIds)[0] : undefined);
         entry.lastPushClientId = owner?.clientId;
+        if (!Array.isArray(entry.routeAttemptConnIds)) entry.routeAttemptConnIds = [];
+        if (entry.lastPushConnId && !entry.routeAttemptConnIds.includes(entry.lastPushConnId)) {
+          entry.routeAttemptConnIds.push(entry.lastPushConnId);
+        }
         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', `mid=${entry.messageId}|q=${this.outbox.size}`);
         this.logInfo(
           'outbox',
           `push-ok ${JSON.stringify({
@@ -1626,6 +2125,10 @@ class BncrBridgeRuntime {
         entry.lastError = asString((error as any)?.message || error || 'file-transfer-error');
         this.outbox.set(entry.messageId, entry);
         this.scheduleSave();
+        this.logInfo(
+          'outbox push fail',
+          `mid=${entry.messageId}|q=${this.outbox.size}|err=${entry.lastError}`,
+        );
         this.logInfo(
           'outbox',
           `push-fail ${JSON.stringify({
@@ -1658,13 +2161,42 @@ class BncrBridgeRuntime {
       return false;
     }
 
+    const attemptedConnIds = new Set(
+      Array.isArray(entry.routeAttemptConnIds)
+        ? entry.routeAttemptConnIds.filter((v): v is string => typeof v === 'string' && !!v)
+        : [],
+    );
+    const routeCandidates = Array.from(this.resolvePushConnIds(entry.accountId));
+    const unattemptedCandidates = routeCandidates.filter((connId) => !attemptedConnIds.has(connId));
+    const revalidatedCandidates = routeCandidates.filter(
+      (connId) => attemptedConnIds.has(connId) && this.isRevalidatedAttemptedConn(entry, connId),
+    );
+    const preferredCandidates = unattemptedCandidates.length > 0 ? unattemptedCandidates : routeCandidates;
     const owner = this.resolveOutboxPushOwner(entry.accountId);
-    let connIds = owner?.connId
-      ? new Set([owner.connId])
-      : this.resolvePushConnIds(entry.accountId);
+    const ownerConnId = owner?.connId && preferredCandidates.includes(owner.connId) ? owner.connId : undefined;
+    let connIds = ownerConnId ? new Set([ownerConnId]) : new Set(preferredCandidates);
     const recentInboundReachable = this.hasRecentInboundReachability(entry.accountId);
+    const routeReason = ownerConnId
+      ? 'owner'
+      : connIds.size > 0
+        ? unattemptedCandidates.length > 0
+          ? 'active-connections-unattempted-first'
+          : revalidatedCandidates.length > 0
+            ? 'active-connections-revalidated'
+            : 'active-connections-all-visible'
+        : recentInboundReachable
+          ? 'recent-inbound-fallback'
+          : 'none';
     if (!connIds.size && recentInboundReachable) {
-      connIds = this.resolveRecentInboundConnIds(entry.accountId);
+      const recentInboundConnIds = Array.from(this.resolveRecentInboundConnIds(entry.accountId));
+      const unattemptedRecentInboundConnIds = recentInboundConnIds.filter(
+        (connId) => !attemptedConnIds.has(connId),
+      );
+      connIds = new Set(
+        unattemptedRecentInboundConnIds.length > 0
+          ? unattemptedRecentInboundConnIds
+          : recentInboundConnIds,
+      );
     }
     if (!connIds.size) {
       this.logInfo(
@@ -1687,11 +2219,30 @@ class BncrBridgeRuntime {
       };
 
       ctx.broadcastToConnIds(BNCR_PUSH_EVENT, payload, connIds);
+      this.logInfo(
+        'outbox',
+        `route-select ${JSON.stringify({
+          messageId: entry.messageId,
+          accountId: entry.accountId,
+          routeReason,
+          connIds: Array.from(connIds),
+          ownerConnId: owner?.connId || '',
+          ownerClientId: owner?.clientId || '',
+          recentInboundReachable,
+          event: BNCR_PUSH_EVENT,
+        })}`,
+        { debugOnly: true },
+      );
       entry.lastPushAt = now();
       entry.lastPushConnId =
-        owner?.connId || (connIds.size === 1 ? Array.from(connIds)[0] : undefined);
-      entry.lastPushClientId = owner?.clientId;
+        ownerConnId || (connIds.size === 1 ? Array.from(connIds)[0] : undefined);
+      entry.lastPushClientId = ownerConnId ? owner?.clientId : undefined;
+      if (!Array.isArray(entry.routeAttemptConnIds)) entry.routeAttemptConnIds = [];
+      if (entry.lastPushConnId && !entry.routeAttemptConnIds.includes(entry.lastPushConnId)) {
+        entry.routeAttemptConnIds.push(entry.lastPushConnId);
+      }
       this.outbox.set(entry.messageId, entry);
+      this.logInfo('outbox push ok', `mid=${entry.messageId}|q=${this.outbox.size}`);
       this.logInfo(
         'outbox',
         `push-ok ${JSON.stringify({
@@ -1712,6 +2263,7 @@ class BncrBridgeRuntime {
     } catch (error) {
       entry.lastError = asString((error as any)?.message || error || 'push-error');
       this.outbox.set(entry.messageId, entry);
+      this.logInfo('outbox push fail', `mid=${entry.messageId}|q=${this.outbox.size}|err=${entry.lastError}`);
       this.logInfo(
         'outbox',
         `push-fail ${JSON.stringify({
@@ -1730,7 +2282,7 @@ class BncrBridgeRuntime {
     const delay = Math.max(0, Math.min(Number(delayMs || 0), 30_000));
     this.pushTimer = setTimeout(() => {
       this.pushTimer = null;
-      void this.flushPushQueue();
+      void this.flushPushQueue({ trigger: 'timer', reason: 'scheduled-drain' });
     }, delay);
   }
 
@@ -1770,8 +2322,14 @@ class BncrBridgeRuntime {
     };
   }
 
-  private async flushPushQueue(accountId?: string): Promise<void> {
-    const filterAcc = accountId ? normalizeAccountId(accountId) : null;
+  private async flushPushQueue(args?: {
+    accountId?: string;
+    trigger?: string;
+    reason?: string;
+  }): Promise<void> {
+    const filterAcc = args?.accountId ? normalizeAccountId(args.accountId) : null;
+    const trigger = asString(args?.trigger || '').trim() || 'manual';
+    const reason = asString(args?.reason || '').trim() || undefined;
     const targetAccounts = filterAcc
       ? [filterAcc]
       : Array.from(
@@ -1786,6 +2344,8 @@ class BncrBridgeRuntime {
         accountId: filterAcc,
         targetAccounts,
         outboxSize: this.outbox.size,
+        trigger,
+        reason,
       })}`,
       { debugOnly: true },
     );
@@ -1831,7 +2391,8 @@ class BncrBridgeRuntime {
             break;
           }
 
-          const onlineNow = this.isOnline(acc) || this.hasRecentInboundReachability(acc);
+          const onlineNow = this.isOnline(acc);
+          const recentInboundReachable = this.hasRecentInboundReachability(acc);
           const pushed = await this.tryPushEntry(entry);
           if (pushed) {
             const requireAck = this.isOutboundAckRequired(acc);
@@ -1848,6 +2409,7 @@ class BncrBridgeRuntime {
                 requireAck,
                 ackResult,
                 onlineNow,
+                recentInboundReachable,
               })}`,
               { debugOnly: true },
             );
@@ -1862,19 +2424,72 @@ class BncrBridgeRuntime {
               continue;
             }
 
+            if (entry.lastPushConnId || entry.lastPushClientId) {
+              this.degradeOutboundCapability({
+                accountId: acc,
+                connId: entry.lastPushConnId || undefined,
+                clientId: entry.lastPushClientId || undefined,
+                reason: requireAck ? 'ack-timeout' : 'push-unconfirmed',
+              });
+            }
+
+            const attemptedConnIds = Array.isArray(entry.routeAttemptConnIds)
+              ? entry.routeAttemptConnIds.filter((v): v is string => typeof v === 'string' && !!v)
+              : [];
+            const currentConnId = asString(entry.lastPushConnId || '').trim();
+            if (currentConnId && !attemptedConnIds.includes(currentConnId)) attemptedConnIds.push(currentConnId);
+            const availableConnIds = Array.from(this.resolvePushConnIds(acc));
+            const revalidatedConnIds = attemptedConnIds.filter((connId) =>
+              this.isRevalidatedAttemptedConn(entry, connId),
+            );
+            const hasUntriedAlternative = availableConnIds.some((connId) => !attemptedConnIds.includes(connId));
+            const shouldFastReroute = requireAck && entry.fastReroutePending !== true && hasUntriedAlternative;
+
+            entry.routeAttemptConnIds = attemptedConnIds;
+            if (shouldFastReroute) entry.fastReroutePending = true;
+
             entry.retryCount += 1;
             entry.lastAttemptAt = now();
             if (entry.retryCount > MAX_RETRY) {
+              this.logInfo(
+                'outbox ack fatal',
+                `mid=${entry.messageId}|q=${this.outbox.size}|err=${entry.lastError || (requireAck ? 'push-ack-timeout' : 'push-delivery-unconfirmed')}`,
+              );
               this.moveToDeadLetter(
                 entry,
                 entry.lastError || (requireAck ? 'push-ack-timeout' : 'push-delivery-unconfirmed'),
               );
               continue;
             }
-            entry.nextAttemptAt = now() + backoffMs(entry.retryCount);
+            entry.nextAttemptAt = shouldFastReroute ? now() + 1_000 : now() + backoffMs(entry.retryCount);
             entry.lastError = requireAck ? 'push-ack-timeout' : 'push-delivery-unconfirmed';
+            if (!hasUntriedAlternative) {
+              entry.routeAttemptConnIds = [];
+              entry.routeAttemptRound = Number(entry.routeAttemptRound || 0) + 1;
+              entry.fastReroutePending = false;
+            }
             this.outbox.set(entry.messageId, entry);
             this.scheduleSave();
+            this.logInfo(
+              requireAck ? 'outbox ack timeout' : 'outbox ack retry',
+              `mid=${entry.messageId}|q=${this.outbox.size}${requireAck ? '' : `|err=${entry.lastError}`}`,
+            );
+            this.logInfo(
+              'outbox',
+              `retry-reroute ${JSON.stringify({
+                messageId: entry.messageId,
+                accountId: acc,
+                currentConnId,
+                attemptedConnIds,
+                availableConnIds,
+                revalidatedConnIds,
+                hasUntriedAlternative,
+                shouldFastReroute,
+                routeAttemptRound: entry.routeAttemptRound || 0,
+                nextAttemptAt: entry.nextAttemptAt,
+              })}`,
+              { debugOnly: true },
+            );
 
             const wait = Math.max(0, entry.nextAttemptAt - now());
             localNextDelay = localNextDelay == null ? wait : Math.min(localNextDelay, wait);
@@ -1994,27 +2609,47 @@ class BncrBridgeRuntime {
     const previousActiveKey = this.activeConnectionByAccount.get(acc) || null;
     const previousActiveConn = previousActiveKey ? this.connections.get(previousActiveKey) || null : null;
 
-    const nextConn: BncrConnection = {
+    const nextConn = {
       accountId: acc,
       connId,
       clientId: asString(clientId || '').trim() || undefined,
       connectedAt: prev?.connectedAt || t,
       lastSeenAt: t,
+      outboundReadyUntil: (prev as any)?.outboundReadyUntil,
+      preferredForOutboundUntil: (prev as any)?.preferredForOutboundUntil,
+      inboundOnly: (prev as any)?.inboundOnly,
+    } as BncrConnection & {
+      outboundReadyUntil?: number;
+      preferredForOutboundUntil?: number;
+      inboundOnly?: boolean;
     };
 
-    this.connections.set(key, nextConn);
-    this.logInfo(
-      'connection',
-      `seen ${JSON.stringify({
-        bridge: this.bridgeId,
-        accountId: acc,
-        connId,
-        clientId: nextConn.clientId,
-        connectedAt: nextConn.connectedAt,
-        lastSeenAt: nextConn.lastSeenAt,
-      })}`,
-      { debugOnly: true },
-    );
+    this.connections.set(key, nextConn as BncrConnection);
+    const connectionSeenPayload = {
+      bridge: this.bridgeId,
+      accountId: acc,
+      connId,
+      clientId: nextConn.clientId,
+      connectedAt: nextConn.connectedAt,
+      lastSeenAt: nextConn.lastSeenAt,
+      outboundReadyUntil: nextConn.outboundReadyUntil || null,
+      preferredForOutboundUntil: nextConn.preferredForOutboundUntil || null,
+      inboundOnly: nextConn.inboundOnly === true,
+    };
+    const connectionSeenSig = JSON.stringify({
+      bridge: this.bridgeId,
+      accountId: acc,
+      connId,
+      clientId: nextConn.clientId || null,
+      inboundOnly: nextConn.inboundOnly === true,
+      outboundReadyActive: Number(nextConn.outboundReadyUntil || 0) > t,
+      preferredForOutboundActive: Number(nextConn.preferredForOutboundUntil || 0) > t,
+    });
+    this.logInfoDedupJson('connection', 'seen', connectionSeenPayload, {
+      key: `connection-seen:${acc}:${nextConn.clientId || connId}`,
+      sig: connectionSeenSig,
+      debugOnly: true,
+    });
 
     const current = this.activeConnectionByAccount.get(acc);
     if (!current) {
@@ -2036,6 +2671,9 @@ class BncrBridgeRuntime {
               clientId: c.clientId,
               connectedAt: c.connectedAt,
               lastSeenAt: c.lastSeenAt,
+              outboundReadyUntil: (c as any).outboundReadyUntil || null,
+              preferredForOutboundUntil: (c as any).preferredForOutboundUntil || null,
+              inboundOnly: (c as any).inboundOnly === true,
             })),
         })}`,
         { debugOnly: true },
@@ -2044,22 +2682,14 @@ class BncrBridgeRuntime {
     }
 
     const curConn = this.connections.get(current);
-    if (
-      !curConn ||
-      t - curConn.lastSeenAt > CONNECT_TTL_MS ||
-      nextConn.connectedAt >= curConn.connectedAt
-    ) {
+    if (!curConn || t - curConn.lastSeenAt > CONNECT_TTL_MS) {
       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',
+          reason: !curConn ? 'current-missing' : 'current-stale',
           previousActiveKey,
           previousActiveConn,
           nextActiveKey: key,
@@ -2071,6 +2701,9 @@ class BncrBridgeRuntime {
               clientId: c.clientId,
               connectedAt: c.connectedAt,
               lastSeenAt: c.lastSeenAt,
+              outboundReadyUntil: (c as any).outboundReadyUntil || null,
+              preferredForOutboundUntil: (c as any).preferredForOutboundUntil || null,
+              inboundOnly: (c as any).inboundOnly === true,
             })),
         })}`,
         { debugOnly: true },
@@ -2078,6 +2711,180 @@ class BncrBridgeRuntime {
     }
   }
 
+  private markOutboundCapability(args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    outboundReady?: boolean;
+    preferredForOutbound?: boolean;
+    inboundOnly?: boolean;
+    at?: number;
+  }) {
+    const acc = normalizeAccountId(args.accountId);
+    const key = this.connectionKey(acc, args.clientId);
+    const t = Number(args.at || now());
+    const current = this.connections.get(key) as (BncrConnection & {
+      outboundReadyUntil?: number;
+      preferredForOutboundUntil?: number;
+      inboundOnly?: boolean;
+    }) | undefined;
+    if (!current || current.connId !== args.connId) return;
+
+    if (args.inboundOnly === true) {
+      current.inboundOnly = true;
+      current.outboundReadyUntil = undefined;
+      current.preferredForOutboundUntil = undefined;
+    } else {
+      if (typeof args.inboundOnly === 'boolean') current.inboundOnly = false;
+      if (args.outboundReady === true || args.preferredForOutbound === true) {
+        current.outboundReadyUntil = t + OUTBOUND_READY_TTL_MS;
+      }
+      if (args.preferredForOutbound === true) {
+        current.preferredForOutboundUntil = t + PREFERRED_OUTBOUND_TTL_MS;
+      }
+    }
+
+    this.connections.set(key, current as BncrConnection);
+    const connectionCapabilityPayload = {
+      bridge: this.bridgeId,
+      accountId: acc,
+      connId: current.connId,
+      clientId: current.clientId,
+      outboundReady: args.outboundReady === true,
+      preferredForOutbound: args.preferredForOutbound === true,
+      inboundOnly: current.inboundOnly === true,
+      outboundReadyUntil: current.outboundReadyUntil || null,
+      preferredForOutboundUntil: current.preferredForOutboundUntil || null,
+    };
+    const connectionCapabilitySig = JSON.stringify({
+      bridge: this.bridgeId,
+      accountId: acc,
+      connId: current.connId,
+      clientId: current.clientId || null,
+      outboundReady: args.outboundReady === true,
+      preferredForOutbound: args.preferredForOutbound === true,
+      inboundOnly: current.inboundOnly === true,
+      outboundReadyActive: Number(current.outboundReadyUntil || 0) > t,
+      preferredForOutboundActive: Number(current.preferredForOutboundUntil || 0) > t,
+    });
+    this.logInfoDedupJson('connection', 'capability', connectionCapabilityPayload, {
+      key: `connection-capability:${acc}:${current.clientId || current.connId}`,
+      sig: connectionCapabilitySig,
+      debugOnly: true,
+    });
+  }
+
+  private hasAlternativeLiveConnection(
+    accountId: string,
+    currentConnId?: string,
+    currentClientId?: string,
+  ): boolean {
+    const acc = normalizeAccountId(accountId);
+    const t = now();
+    const currentConn = asString(currentConnId || '').trim();
+    const currentClient = asString(currentClientId || '').trim() || undefined;
+
+    for (const conn of this.connections.values()) {
+      if (conn.accountId !== acc) continue;
+      if (!conn.connId) continue;
+      if (t - conn.lastSeenAt > CONNECT_TTL_MS) continue;
+      const sameConn = !!currentConn && conn.connId === currentConn;
+      const sameClient = !currentConn && !!currentClient && conn.clientId === currentClient;
+      if (sameConn || sameClient) continue;
+      return true;
+    }
+    return false;
+  }
+
+  private degradeOutboundCapability(args: {
+    accountId: string;
+    connId?: string;
+    clientId?: string;
+    reason: string;
+    at?: number;
+  }) {
+    const acc = normalizeAccountId(args.accountId);
+    const t = Number(args.at || now());
+    const hasAlternativeLiveConnection = this.hasAlternativeLiveConnection(
+      acc,
+      args.connId,
+      args.clientId,
+    );
+    const currentKey = this.activeConnectionByAccount.get(acc) || null;
+    let matchedKey: string | null = null;
+    let matchedConn: (BncrConnection & {
+      outboundReadyUntil?: number;
+      preferredForOutboundUntil?: number;
+      inboundOnly?: boolean;
+    }) | null = null;
+
+    for (const [key, conn] of this.connections.entries()) {
+      if (conn.accountId !== acc) continue;
+      if (args.connId && conn.connId !== args.connId) continue;
+      if (args.clientId && conn.clientId !== args.clientId) continue;
+      matchedKey = key;
+      matchedConn = conn as BncrConnection & {
+        outboundReadyUntil?: number;
+        preferredForOutboundUntil?: number;
+        inboundOnly?: boolean;
+      };
+      break;
+    }
+
+    if (!matchedKey || !matchedConn) return;
+
+    const before = {
+      outboundReadyUntil: matchedConn.outboundReadyUntil || null,
+      preferredForOutboundUntil: matchedConn.preferredForOutboundUntil || null,
+      inboundOnly: matchedConn.inboundOnly === true,
+    };
+
+    if (!hasAlternativeLiveConnection) {
+      this.logInfo(
+        'connection',
+        `outbound-degrade skip ${JSON.stringify({
+          bridge: this.bridgeId,
+          accountId: acc,
+          connId: matchedConn.connId,
+          clientId: matchedConn.clientId,
+          reason: args.reason,
+          at: t,
+          currentActiveKey: currentKey,
+          degradedKey: matchedKey,
+          skipReason: 'no-alternative-live-connection',
+          before,
+        })}`,
+        { debugOnly: true },
+      );
+      return;
+    }
+
+    matchedConn.outboundReadyUntil = undefined;
+    matchedConn.preferredForOutboundUntil = undefined;
+    this.connections.set(matchedKey, matchedConn as BncrConnection);
+
+    this.logInfo(
+      'connection',
+      `outbound-degrade ${JSON.stringify({
+        bridge: this.bridgeId,
+        accountId: acc,
+        connId: matchedConn.connId,
+        clientId: matchedConn.clientId,
+        reason: args.reason,
+        at: t,
+        currentActiveKey: currentKey,
+        degradedKey: matchedKey,
+        before,
+        after: {
+          outboundReadyUntil: matchedConn.outboundReadyUntil || null,
+          preferredForOutboundUntil: matchedConn.preferredForOutboundUntil || null,
+          inboundOnly: matchedConn.inboundOnly === true,
+        },
+      })}`,
+      { debugOnly: true },
+    );
+  }
+
   private isOnline(accountId: string): boolean {
     const acc = normalizeAccountId(accountId);
     const t = now();
@@ -2980,6 +3787,29 @@ class BncrBridgeRuntime {
   }) {
     const { accountId, sessionKey, route, payload, mediaLocalRoots } = params;
 
+    this.logInfo(
+      'outbound',
+      `enqueue-from-reply ${JSON.stringify({
+        accountId,
+        sessionKey,
+        route: {
+          platform: route?.platform,
+          groupId: route?.groupId,
+          userId: route?.userId,
+        },
+        payload: {
+          text: asString(payload?.text || ''),
+          mediaUrl: asString(payload?.mediaUrl || ''),
+          mediaUrls: Array.isArray(payload?.mediaUrls) ? payload.mediaUrls : undefined,
+          asVoice: payload?.asVoice === true,
+          audioAsVoice: payload?.audioAsVoice === true,
+          kind: payload?.kind,
+          replyToId: asString(payload?.replyToId || ''),
+        },
+      })}`,
+      { debugOnly: true },
+    );
+
     const mediaList = payload.mediaUrls?.length
       ? payload.mediaUrls
       : payload.mediaUrl
@@ -2988,21 +3818,68 @@ class BncrBridgeRuntime {
 
     if (mediaList.length > 0) {
       let first = true;
+      const currentTime = now();
       for (const mediaUrl of mediaList) {
+        const normalizedMediaUrl = asString(mediaUrl || '').trim();
+        if (!normalizedMediaUrl) continue;
+
+        const normalizedText = normalizeMessageText(first ? payload.text : '');
+        const normalizedReplyToId = normalizeReplyToId(payload.replyToId);
+        const fallback = this.tryBuildMediaDedupeFallback({
+          sessionKey,
+          mediaUrl: normalizedMediaUrl,
+          text: normalizedText,
+          replyToId: normalizedReplyToId,
+          currentTime,
+        });
+
+        if (fallback !== null) {
+          this.logInfo(
+            'outbound',
+            `media-dedupe-hit ${JSON.stringify({
+              sessionKey,
+              mediaUrl: normalizedMediaUrl,
+              replyToId: normalizedReplyToId || undefined,
+              fallbackText: fallback.text,
+              reason: fallback.reason,
+            })}`,
+            { debugOnly: true },
+          );
+          this.enqueueOutbound(
+            this.buildTextOutboxEntry({
+              accountId,
+              sessionKey,
+              route,
+              text: fallback.text,
+              kind: payload.kind,
+              replyToId: normalizedReplyToId || undefined,
+            }),
+          );
+          first = false;
+          continue;
+        }
+
         this.enqueueOutbound(
           this.buildFileTransferOutboxEntry({
             accountId,
             sessionKey,
             route,
-            mediaUrl,
+            mediaUrl: normalizedMediaUrl,
             mediaLocalRoots,
             text: first ? asString(payload.text || '') : '',
             asVoice: payload.asVoice,
             audioAsVoice: payload.audioAsVoice,
             kind: payload.kind,
-            replyToId: asString(payload.replyToId || '').trim() || undefined,
+            replyToId: normalizedReplyToId || undefined,
           }),
         );
+        this.rememberRecentMediaSend({
+          sessionKey,
+          mediaUrl: normalizedMediaUrl,
+          text: normalizedText,
+          replyToId: normalizedReplyToId,
+          createdAt: currentTime,
+        });
         first = false;
       }
       return;
@@ -3011,37 +3888,16 @@ class BncrBridgeRuntime {
     const text = asString(payload.text || '').trim();
     if (!text) return;
 
-    const messageId = randomUUID();
-    const frame = {
-      type: 'message.outbound',
-      messageId,
-      idempotencyKey: messageId,
-      sessionKey,
-      replyToId: asString(payload.replyToId || '').trim() || undefined,
-      message: {
-        platform: route.platform,
-        groupId: route.groupId,
-        userId: route.userId,
-        type: 'text',
+    this.enqueueOutbound(
+      this.buildTextOutboxEntry({
+        accountId,
+        sessionKey,
+        route,
+        text,
         kind: payload.kind,
-        msg: text,
-        path: '',
-        base64: '',
-        fileName: '',
-      },
-      ts: now(),
-    };
-
-    this.enqueueOutbound({
-      messageId,
-      accountId: normalizeAccountId(accountId),
-      sessionKey,
-      route,
-      payload: frame,
-      createdAt: now(),
-      retryCount: 0,
-      nextAttemptAt: now(),
-    });
+        replyToId: asString(payload.replyToId || '').trim() || undefined,
+      }),
+    );
   }
 
   handleConnect = async ({ params, respond, client, context }: GatewayRequestHandlerOptions) => {
@@ -3049,6 +3905,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;
+    const outboundReady = (params as any)?.outboundReady === true;
+    const preferredForOutbound = (params as any)?.preferredForOutbound === true;
+    const inboundOnly = (params as any)?.inboundOnly === true;
 
     this.logInfo(
       'connection',
@@ -3057,6 +3916,9 @@ class BncrBridgeRuntime {
         accountId,
         connId,
         clientId,
+        outboundReady,
+        preferredForOutbound,
+        inboundOnly,
         hasContext: Boolean(context),
       })}`,
       { debugOnly: true },
@@ -3064,6 +3926,14 @@ class BncrBridgeRuntime {
 
     this.rememberGatewayContext(context);
     this.markSeen(accountId, connId, clientId);
+    this.markOutboundCapability({
+      accountId,
+      connId,
+      clientId,
+      outboundReady,
+      preferredForOutbound,
+      inboundOnly,
+    });
     this.markActivity(accountId);
     this.incrementCounter(this.connectEventsByAccount, accountId);
     const lease = this.acceptConnection();
@@ -3094,7 +3964,7 @@ class BncrBridgeRuntime {
     });
 
     // WS 一旦在线，立即尝试把离线期间积压队列直推出去
-    this.flushPushQueue(accountId);
+    this.flushPushQueue({ accountId, trigger: 'connect', reason: 'ws-online' });
   };
 
   handleAck = async ({ params, respond, client, context }: GatewayRequestHandlerOptions) => {
@@ -3160,19 +4030,29 @@ class BncrBridgeRuntime {
     const fatal = params?.fatal === true;
 
     if (ok) {
+      this.markOutboundCapability({
+        accountId,
+        connId,
+        clientId,
+        outboundReady: true,
+        preferredForOutbound: true,
+      });
       this.outbox.delete(messageId);
       this.scheduleSave();
       this.resolveMessageAck(messageId, 'acked');
+      this.logInfo('outbox ack ok', `mid=${messageId}|q=${this.outbox.size}`);
       respond(
         true,
         staleObserved.stale ? { ok: true, stale: true, staleAccepted: true } : { ok: true },
       );
-      this.flushPushQueue(accountId);
+      this.flushPushQueue({ accountId, trigger: 'ack-ok', reason: 'message-acked' });
       return;
     }
 
     if (fatal) {
-      this.moveToDeadLetter(entry, asString(params?.error || 'fatal-ack'));
+      const error = asString(params?.error || 'fatal-ack');
+      this.moveToDeadLetter(entry, error);
+      this.logInfo('outbox ack fatal', `mid=${messageId}|q=${this.outbox.size}|err=${error}`);
       respond(
         true,
         staleObserved.stale
@@ -3186,6 +4066,7 @@ class BncrBridgeRuntime {
     entry.lastError = asString(params?.error || 'retryable-ack');
     this.outbox.set(messageId, entry);
     this.scheduleSave();
+    this.logInfo('outbox ack retry', `mid=${messageId}|q=${this.outbox.size}|err=${entry.lastError}`);
 
     respond(
       true,
@@ -3200,6 +4081,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;
+    const outboundReady = (params as any)?.outboundReady === true;
+    const preferredForOutbound = (params as any)?.preferredForOutbound === true;
+    const inboundOnly = (params as any)?.inboundOnly === true;
     if (
       this.shouldIgnoreStaleEvent({
         kind: 'activity',
@@ -3220,12 +4104,23 @@ class BncrBridgeRuntime {
         accountId,
         connId,
         clientId,
+        outboundReady,
+        preferredForOutbound,
+        inboundOnly,
         hasContext: Boolean(context),
       })}`,
       { debugOnly: true },
     );
     this.rememberGatewayContext(context);
     this.markSeen(accountId, connId, clientId);
+    this.markOutboundCapability({
+      accountId,
+      connId,
+      clientId,
+      outboundReady,
+      preferredForOutbound,
+      inboundOnly,
+    });
     this.markActivity(accountId);
     this.incrementCounter(this.activityEventsByAccount, accountId);
 
@@ -3239,7 +4134,7 @@ class BncrBridgeRuntime {
       deadLetter: this.deadLetter.filter((v) => v.accountId === accountId).length,
       now: now(),
     });
-    this.flushPushQueue(accountId);
+    this.flushPushQueue({ accountId, trigger: 'activity', reason: 'activity-heartbeat' });
   };
 
   handleDiagnostics = async ({ params, respond }: GatewayRequestHandlerOptions) => {
@@ -3772,6 +4667,9 @@ class BncrBridgeRuntime {
     } = parsed;
     const connId = asString(client?.connId || '').trim() || `no-conn-${Date.now()}`;
     const clientId = asString((params as any)?.clientId || '').trim() || undefined;
+    const outboundReady = (params as any)?.outboundReady === true;
+    const preferredForOutbound = (params as any)?.preferredForOutbound === true;
+    const inboundOnly = (params as any)?.inboundOnly === true;
     if (
       this.shouldIgnoreStaleEvent({
         kind: 'inbound',
@@ -3792,6 +4690,14 @@ class BncrBridgeRuntime {
     }
     this.rememberGatewayContext(context);
     this.markSeen(accountId, connId, clientId);
+    this.markOutboundCapability({
+      accountId,
+      connId,
+      clientId,
+      outboundReady,
+      preferredForOutbound,
+      inboundOnly,
+    });
     this.markActivity(accountId);
     this.logInfo(
       'inbound',
@@ -3801,6 +4707,9 @@ class BncrBridgeRuntime {
         accountId,
         connId,
         clientId,
+        outboundReady,
+        preferredForOutbound,
+        inboundOnly,
         onlineAfterSeen: this.isOnline(accountId),
         recentInboundReachable: this.hasRecentInboundReachability(accountId),
         activeConnectionKey: this.activeConnectionByAccount.get(accountId) || null,
@@ -3897,7 +4806,7 @@ class BncrBridgeRuntime {
       msgId: msgId ?? null,
       taskKey: extracted.taskKey ?? null,
     });
-    this.flushPushQueue(accountId);
+    this.flushPushQueue({ accountId, trigger: 'inbound', reason: 'inbound-accepted' });
 
     void dispatchBncrInbound({
       api: this.api,
@@ -3937,30 +4846,37 @@ class BncrBridgeRuntime {
         this.lastOutboundByAccount.get(accountId) ||
         previous?.lastEventAt ||
         null;
-      this.logInfo(
+      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 ${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 },
+        `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,
@@ -3996,6 +4912,7 @@ class BncrBridgeRuntime {
           `status-worker finished ${JSON.stringify({ bridge: this.bridgeId, accountId, reason })}`,
           { debugOnly: true },
         );
+        this.logInfo('health', `status-worker finished ${accountId}|${reason}`);
         resolve();
       };
 
@@ -4027,6 +4944,7 @@ class BncrBridgeRuntime {
       `status-stop ${JSON.stringify({ bridge: this.bridgeId, accountId, cleared })}`,
       { debugOnly: true },
     );
+    this.logInfo('health', `status-stop ${accountId}|cleared=${cleared}`);
   };
 
   channelSendText = async (ctx: any) => {
@@ -4103,6 +5021,7 @@ class BncrBridgeRuntime {
       to,
       text: asString(ctx.text || ''),
       mediaUrl: asString(ctx.mediaUrl || ''),
+      mediaUrls: Array.isArray(ctx?.mediaUrls) ? ctx.mediaUrls : undefined,
       asVoice,
       audioAsVoice,
       replyToId: asString(ctx?.replyToId || ctx?.replyToMessageId || '').trim() || undefined,