package vip.mate.channel.wecom;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import reactor.core.publisher.Flux;
import vip.mate.agent.AgentService.StreamDelta;
import vip.mate.channel.AbstractChannelAdapter;
import vip.mate.channel.ChannelMessage;
import vip.mate.channel.ChannelMessageRouter;
import vip.mate.channel.StreamingChannelAdapter;
import vip.mate.workspace.core.service.ChatUploadLocationResolver;
import vip.mate.channel.ExponentialBackoff;
import vip.mate.channel.media.InboundMediaDownloader;
import vip.mate.channel.model.ChannelEntity;
import vip.mate.channel.wecom.cards.tool_guard.ToolGuardCardRenderer;
import vip.mate.workspace.conversation.model.MessageContentPart;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.WebSocket;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 企业微信智能机器人渠道适配器 — WebSocket 长连接模式
 * <p>
 * 基于企业微信「智能机器人」API 长连接协议（wecom-aibot-python-sdk 逆向）：
 * <ul>
 *   <li>WebSocket 连接 wss://openws.work.weixin.qq.com</li>
 *   <li>bot_id + secret 认证（aibot_subscribe 帧）</li>
 *   <li>30 秒心跳（ping 帧）</li>
 *   <li>aibot_msg_callback / aibot_event_callback 消息推送</li>
 *   <li>reply_stream 流式回复（覆盖更新"思考中..."）</li>
 *   <li>send_message 主动推送</li>
 * </ul>
 * <p>
 * 用户在企业微信后台创建「智能机器人」→ 选择「API 模式 → 配置长连接」
 * → 获得 bot_id 和 secret → 填入 MateClaw → 启动即可对话。
 * 无需公网 IP，无需回调 URL。
 * <p>
 * 配置项（configJson）：
 * <ul>
 *   <li>bot_id: 机器人 ID</li>
 *   <li>secret: 机器人 Secret</li>
 *   <li>welcome_text: 欢迎消息（可选）</li>
 *   <li>media_download_enabled: 是否下载媒体文件（默认 true）</li>
 *   <li>media_dir: 媒体文件保存目录（默认 data/media）</li>
 *   <li>stream_progress: 处理期间是否在气泡内展示实时进度（默认 true；
 *       false 退化为"累积后一次性发送"）</li>
 *   <li>progress_interval_ms: 进度覆写最小间隔（默认 500ms）</li>
 *   <li>filter_thinking: false 时思考内容流式进入进度气泡（默认 true）</li>
 *   <li>filter_tool_messages: false 时每次工具调用发独立留痕消息（默认 true）</li>
 * </ul>
 *
 * @author MateClaw Team
 */
@Slf4j
public class WeComChannelAdapter extends AbstractChannelAdapter implements StreamingChannelAdapter {

    public static final String CHANNEL_TYPE = "wecom";

    /** 企业微信智能机器人 WebSocket 地址 */
    private static final String DEFAULT_WS_URL = "wss://openws.work.weixin.qq.com";

    /** 心跳间隔 30 秒 */
    private static final long HEARTBEAT_INTERVAL_MS = 30_000;

    /** 连续未收到 pong 的最大次数（超过则认为连接已死） */
    private static final int MAX_MISSED_PONG = 2;

    /** 回复 ACK 等待超时 5 秒 */
    private static final long REPLY_ACK_TIMEOUT_MS = 5_000;

    /** 消息去重：最大记录数 */
    private static final int PROCESSED_IDS_MAX = 2000;

    // ==================== WebSocket 命令常量 ====================

    private static final String CMD_SUBSCRIBE = "aibot_subscribe";
    private static final String CMD_HEARTBEAT = "ping";
    private static final String CMD_RESPONSE = "aibot_respond_msg";
    private static final String CMD_RESPONSE_WELCOME = "aibot_respond_welcome_msg";
    /**
     * Update an interactive template card. Source-verified against the
     * aibot SDK at {@code aibot/types.py:81} (RESPONSE_UPDATE constant)
     * — used by {@link #updateTemplateCard} to replace a posted card
     * within the 5-second window WeCom enforces after a button click.
     */
    private static final String CMD_RESPONSE_UPDATE = "aibot_respond_update_msg";
    private static final String CMD_SEND_MSG = "aibot_send_msg";
    private static final String CMD_CALLBACK = "aibot_msg_callback";
    private static final String CMD_EVENT_CALLBACK = "aibot_event_callback";

    // ==================== 媒体上传命令常量 ====================

    private static final String CMD_UPLOAD_INIT = "aibot_upload_media_init";
    private static final String CMD_UPLOAD_CHUNK = "aibot_upload_media_chunk";
    private static final String CMD_UPLOAD_FINISH = "aibot_upload_media_finish";

    /** 上传分块大小：512KB */
    private static final int UPLOAD_CHUNK_SIZE = 512 * 1024;

    /** 上传 ACK 超时：30 秒（大文件上传需要更长超时） */
    private static final long UPLOAD_ACK_TIMEOUT_MS = 30_000;

    // ==================== 运行时状态 ====================

    private HttpClient httpClient;
    private volatile WebSocket webSocket;
    private volatile Thread wsThread;

    /** 心跳定时任务 */
    private volatile ScheduledFuture<?> heartbeatFuture;

    /** 连续未收到 pong 的计数 */
    private final AtomicInteger missedPongCount = new AtomicInteger(0);

    /** 消息去重集合 */
    private final Set<String> processedMessageIds = ConcurrentHashMap.newKeySet();

    /** 回复 ACK 等待：reqId -> CompletableFuture（在 reqIdWorker 串行内 put，避免同 reqId 多次发送时撞 key） */
    private final ConcurrentHashMap<String, CompletableFuture<Map<String, Object>>> pendingAcks = new ConcurrentHashMap<>();

    /**
     * Per-reqId 串行回复队列状态。Key=reqId，value 是 {@link ReplyQueueState}
     * 包装的 (queue, closed) 二元组，用来在 idle-close 与 late-offer 之间提供
     * compute-bin-lock 级原子化（RFC-32 §2.4.1 a-2 / R-5 修正）。
     *
     * <p>{@code closed} 是防御性标志位：worker 在 idle compute 退出时会把 entry
     * 从 map 删掉，所以正常路径上 enqueue 看不到一个"closed=true 还在 map 里"的
     * state；保留这个标志为未来重构兜底，避免任何破坏"close = remove entry"
     * 耦合的改动让 silent drop 复活。
     */
    private final ConcurrentHashMap<String, ReplyQueueState> replyQueues = new ConcurrentHashMap<>();

    /**
     * 回复队列 worker 池。volatile + 非 final 是 RFC-32 §2.4.1 a-1 / R-2 修正
     * 的一部分：stop/重连时需要 {@link ExecutorService#shutdownNow()} 中断
     * worker 阻塞中的 {@code queue.poll(60s)}，但 cached pool 一旦 shutdown
     * 就不能重用，所以必须能在 {@link #ensureReplyExecutor()} 里重建。
     */
    private volatile ExecutorService replyExecutor;

    /**
     * Lifecycle gate：控制 {@link #sendFrameWithAck} 是否接受新任务。
     *
     * <p>必须由 <b>transport-ready 信号</b> 触发置 true（即认证成功后的
     * {@link #markReady()}），而不是 executor-ready（{@link #ensureReplyExecutor()}）。
     * 否则会出现"executor 活的、accepting=true、但 webSocket=null"的窗口——
     * worker 调 {@link #sendFrame} 看到 {@code webSocket==null} 就 warn 后默默 return，
     * 让 caller 等 5s 假超时（RFC-32 §2.4.1 a-1 / R-7 修正）。
     */
    private final AtomicBoolean replyQueueAccepting = new AtomicBoolean(false);

    /**
     * Idle-timeout (ms) for the per-reqId worker's {@code queue.poll}.
     * Default 60s in production; tests in the same package may lower
     * this to the millisecond range to surface idle-close vs late-offer
     * races without waiting a real minute (RFC-32 §3.0 S-3 stress).
     *
     * <p><b>Package-private on purpose</b> — not exposed via getter or
     * setter; tests assign it directly. Production code never writes
     * to this field.
     */
    @SuppressWarnings("PackageVisibleField")
    volatile long workerIdleTimeoutMs = 60_000L;

    /**
     * Per-reqId 回复队列状态。
     *
     * @param queue  串行回复任务队列
     * @param closed 防御性 closed 标志（详见 {@link #replyQueues} 注释）
     */
    private record ReplyQueueState(
            LinkedBlockingQueue<ReplyTask> queue,
            AtomicBoolean closed
    ) {
        static ReplyQueueState fresh() {
            return new ReplyQueueState(new LinkedBlockingQueue<>(), new AtomicBoolean(false));
        }
    }

    /** WebSocket 消息碎片缓冲区 */
    private final StringBuilder wsBuffer = new StringBuilder();

    /**
     * Raw-byte accumulator for fragmented binary WS frames. Bytes are only
     * decoded (as UTF-8) once the final fragment arrives — decoding each
     * fragment separately would corrupt any multi-byte character split
     * across a fragment boundary. Accessed only from the JDK WebSocket
     * listener callbacks, which are delivered serially per socket.
     */
    private final ByteArrayOutputStream wsBinaryBuffer = new ByteArrayOutputStream();

    /** 请求 ID 计数器 */
    private final AtomicInteger reqIdCounter = new AtomicInteger(0);

    /** 记录消息中 reqId -> frame 的映射，用于 reply_stream 回复 */
    private final ConcurrentHashMap<String, Map<String, Object>> pendingFrames = new ConcurrentHashMap<>();

    /** 媒体上传串行锁（每个适配器实例同一时间只允许一个上传） */
    private final Semaphore uploadLock = new Semaphore(1);

    /** 回复上下文：replyToken -> (frameReqId, processingStreamId)，用于 sendContentParts 回写 */
    private final ConcurrentHashMap<String, WeComReplyContext> replyContexts = new ConcurrentHashMap<>();

    /**
     * Group-chat reply-slot fallback cache: {@code chatId → most recent
     * inbound frameReqId from that group}.
     * <p>
     * The WeCom AI Bot platform <strong>blocks {@code aibot_send_msg} in
     * group chats</strong> — proactive pushes (cron summaries,
     * image-generation completions, TTS audio, async-task forwards) must
     * ride {@code aibot_respond_msg} bound to <em>some</em> prior frame
     * id. Without this cache every group push silently failed:
     * {@code sendMessageToChat} fell through to {@code aibot_send_msg},
     * the platform rejected it, the user saw nothing.
     * <p>
     * Populated for group inbound frames only — single-chat
     * {@code aibot_send_msg} still works, so we don't need a cached
     * reqId there. {@link #pickGroupReplyReqId(String)} returns the
     * cached id (or null when there's never been a group inbound), and
     * the proactive send paths fall through to {@code aibot_send_msg}
     * when null.
     * <p>
     * Bounded LRU at {@link #LAST_CHAT_REQ_IDS_MAX_SIZE} via insertion-
     * order eviction — long-lived bots in many groups don't unbounded-grow.
     */
    private final ConcurrentHashMap<String, String> lastChatReqIds = new ConcurrentHashMap<>();

    /** Max chat-id entries to keep in {@link #lastChatReqIds} before evicting. */
    private static final int LAST_CHAT_REQ_IDS_MAX_SIZE = 1000;

    private record WeComReplyContext(String frameReqId, String processingStreamId) {}

    /**
     * Single-flight guard for failure signals. JDK WebSocket can fire onClose
     * AND onError for the same outage, plus connect-exception and heartbeat
     * timeout, all routing to the disconnect path. The first one wins; the
     * rest are deduped. Cleared at the start of each new connect attempt and
     * after auth_succeed in markReady().
     */
    private final AtomicBoolean disconnectInflight = new AtomicBoolean(false);

    /**
     * Approval-notification renderer. Held for symmetry with other channel
     * adapters; the WeCom override of {@link #sendApprovalNotice} delegates
     * card rendering to {@link #cardDispatcher} but still uses this service
     * to build the {@link vip.mate.channel.notification.ApprovalNotice}
     * data carrier. Null-tolerant: if Spring DI fails (test contexts), the
     * default text-approval fallback still works.
     */
    @SuppressWarnings("unused")  // consumed via card dispatcher's tool_guard kind in PR-1
    private final vip.mate.channel.notification.ApprovalNotificationService approvalNotificationService;

    /**
     * WeCom interactive-card dispatcher (PR-1).
     *
     * <p>Routes outbound approval notices to a {@code button_interaction}
     * card via tool_guard renderer, and inbound {@code template_card_event}
     * frames to the matching handler by task_id prefix. Null-tolerant for
     * test contexts (the {@link #sendApprovalNotice} override falls back
     * to the abstract-class text path when the dispatcher is missing).
     */
    private final vip.mate.channel.wecom.cards.WeComCardDispatcher cardDispatcher;

    /**
     * Refreshes the "🤔 思考中..." processing-stream chunk every 20s and
     * force-finishes after 180s, so WeCom's server-side stream slot
     * doesn't drop while a long-running agent task is still computing
     * (RFC-32 §2.1.2 / R-7 / B-5). Null-tolerant: if missing (test DI
     * gap), placeholder still appears once but is not refreshed.
     */
    private final WeComKeepaliveScheduler keepaliveScheduler;

    /**
     * In-memory cache of bytes generated by tools like
     * {@code DocxRenderTool} / {@code PptxRenderTool}. The agent emits a
     * {@code /api/v1/files/generated/{id}} URL referencing this cache; the
     * channel layer resolves that URL back to bytes and uploads them as a
     * native WeCom file message so the user actually receives a tappable
     * document instead of an unopenable link. Null-tolerant: if missing
     * (older constructor / test DI gap), URL stays inline as plain markdown
     * which renders as a non-interactive link in the bubble.
     */
    private final vip.mate.tool.document.GeneratedFileCache generatedFileCache;

    /**
     * Workspace/agent-aware upload-root resolver, set by the production factory.
     * Null in unit tests (the legacy {@code data/chat-uploads} default applies).
     */
    private vip.mate.workspace.core.service.ChatUploadLocationResolver chatUploadLocationResolver;

    public WeComChannelAdapter(ChannelEntity channelEntity,
                               ChannelMessageRouter messageRouter,
                               ObjectMapper objectMapper,
                               vip.mate.channel.notification.ApprovalNotificationService approvalNotificationService,
                               vip.mate.channel.wecom.cards.WeComCardDispatcher cardDispatcher,
                               WeComKeepaliveScheduler keepaliveScheduler) {
        this(channelEntity, messageRouter, objectMapper, approvalNotificationService,
                cardDispatcher, keepaliveScheduler, null);
    }

    public WeComChannelAdapter(ChannelEntity channelEntity,
                               ChannelMessageRouter messageRouter,
                               ObjectMapper objectMapper,
                               vip.mate.channel.notification.ApprovalNotificationService approvalNotificationService,
                               vip.mate.channel.wecom.cards.WeComCardDispatcher cardDispatcher,
                               WeComKeepaliveScheduler keepaliveScheduler,
                               vip.mate.tool.document.GeneratedFileCache generatedFileCache) {
        this(channelEntity, messageRouter, objectMapper, approvalNotificationService,
                cardDispatcher, keepaliveScheduler, generatedFileCache, null);
    }

    /**
     * Full constructor used by the production factory (ChannelManager). The
     * trailing {@code chatUploadLocationResolver} enables workspace/agent-aware
     * attachment storage; {@code null} keeps the legacy {@code data/chat-uploads}
     * behaviour.
     */
    public WeComChannelAdapter(ChannelEntity channelEntity,
                               ChannelMessageRouter messageRouter,
                               ObjectMapper objectMapper,
                               vip.mate.channel.notification.ApprovalNotificationService approvalNotificationService,
                               vip.mate.channel.wecom.cards.WeComCardDispatcher cardDispatcher,
                               WeComKeepaliveScheduler keepaliveScheduler,
                               vip.mate.tool.document.GeneratedFileCache generatedFileCache,
                               vip.mate.workspace.core.service.ChatUploadLocationResolver chatUploadLocationResolver) {
        super(channelEntity, messageRouter, objectMapper);
        this.approvalNotificationService = approvalNotificationService;
        this.cardDispatcher = cardDispatcher;
        this.keepaliveScheduler = keepaliveScheduler;
        this.generatedFileCache = generatedFileCache;
        this.chatUploadLocationResolver = chatUploadLocationResolver;
        // Default to 8 bounded attempts (~4 minutes total at 2s..30s exponential)
        // so the UI eventually settles in ERROR instead of getting stuck in
        // RECONNECTING forever. User config still overrides (-1 = infinite).
        int maxAttempts = 8;
        Object val = config.get("max_reconnect_attempts");
        if (val instanceof Number n) {
            maxAttempts = n.intValue();
        } else if (val instanceof String s) {
            try { maxAttempts = Integer.parseInt(s); } catch (NumberFormatException ignored) {}
        }
        this.backoff = new ExponentialBackoff(2000, 30000, 2.0, maxAttempts);
    }

    // ==================== 生命周期 ====================

    @Override
    protected void doStart() {
        String botId = getConfigString("bot_id");
        String secret = getConfigString("secret");

        if (botId == null || botId.isBlank() || secret == null || secret.isBlank()) {
            throw new IllegalStateException("WeCom bot channel requires bot_id and secret in configJson");
        }

        this.httpClient = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        // Build the reply-queue worker pool BEFORE the WS handshake kicks off, so
        // any inbound auth_succeed → markReady → openReplyQueue path finds a live
        // executor to schedule against. The gate stays closed until markReady runs.
        ensureReplyExecutor();

        connectWebSocket(botId, secret);

        log.info("[wecom] WeCom bot channel initialized: botId={}, maxReconnectAttempts={}",
                botId.length() > 12 ? botId.substring(0, 12) + "..." : botId, backoff.getMaxAttempts());
    }

    @Override
    protected void doStop() {
        releaseConnectionResources("stopped");
        // doStop also clears history that survives reconnects (processedMessageIds)
        processedMessageIds.clear();
        log.info("[wecom] WeCom bot channel stopped");
    }

    @Override
    protected void doReconnect() {
        log.info("[wecom] Reconnecting WebSocket...");
        releaseConnectionResources("reconnecting");

        // releaseConnectionResources nulls httpClient — rebuild a fresh one.
        // This is the core fix: each reconnect starts from a clean SSL/I-O
        // surface, mirroring what manual stop+start has been doing in the field.
        this.httpClient = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        // Re-arm the reply-queue worker pool BEFORE attempting the new
        // handshake. accepting flag stays false until the new connection's
        // auth_succeed fires markReady → openReplyQueue.
        ensureReplyExecutor();

        String botId = getConfigString("bot_id");
        String secret = getConfigString("secret");
        connectWebSocket(botId, secret);
    }

    /**
     * Release every per-connection resource so a fresh HttpClient + WebSocket
     * are always built next. Shared by doStop (channel teardown) and
     * doReconnect (auto-recovery cycle).
     *
     * <p>Why drop {@code httpClient} too: the JDK HttpClient caches SSL
     * sessions and keeps an async selector loop. After certain WS error paths
     * the SSL session can be poisoned, causing every subsequent handshake to
     * be RST'd by the server ("Remote host terminated the handshake"). Dropping
     * the client forces a clean rebuild — this is exactly what manual
     * "Disable + Enable" did to recover.
     */
    private void releaseConnectionResources(String reason) {
        // ============================================================================
        // RFC-32 §2.4.1 a-3 / R-6 + R-8 修正：必须按 step 0~4 顺序，不是尾部追加。
        // step 0 (replyQueueAccepting=false) 必须在 ws.close()/wsThread.join() 之前；
        // 否则在 ws teardown 期间还会有 keepalive / 最终回复 / proactiveSend 漏进 enqueue。
        // ============================================================================

        // ---- Step 0：先关 lifecycle gate，让任何后续 sendFrameWithAck 立刻 fast-fail ----
        replyQueueAccepting.set(false);

        // ---- 现有的 ws/heartbeat teardown（功能未变；插在 step 0 之后、step 1 之前） ----
        if (heartbeatFuture != null) {
            heartbeatFuture.cancel(false);
            heartbeatFuture = null;
        }
        if (webSocket != null) {
            try {
                webSocket.sendClose(WebSocket.NORMAL_CLOSURE, reason)
                        .orTimeout(2, TimeUnit.SECONDS)
                        .exceptionally(ex -> null)
                        .join();
            } catch (Exception e) {
                log.debug("[wecom] release: ws close: {}", e.getMessage());
            }
            webSocket = null;
        }
        if (wsThread != null) {
            wsThread.interrupt();
            try {
                wsThread.join(3000);
            } catch (InterruptedException ignored) {
                Thread.currentThread().interrupt();
            }
            wsThread = null;
        }

        // ---- Step 1：第一次 drain replyQueues ----
        // forEach 是 weakly-consistent 迭代器，可能错过 step 0 之前刚提交但还没出 compute
        // 的 enqueue —— step 3 会再 drain 一次兜底。
        replyQueues.forEach((rid, state) -> {
            state.closed().set(true);
            ReplyTask t;
            while ((t = state.queue().poll()) != null) {
                if (!t.future().isDone()) {
                    t.future().completeExceptionally(new IllegalStateException("Channel " + reason));
                }
            }
        });

        // ---- Step 2：shutdownNow 中断 worker 阻塞中的 poll(60s) + 拒绝后续 submit ----
        ExecutorService oldExecutor = this.replyExecutor;
        if (oldExecutor != null) {
            oldExecutor.shutdownNow();
            this.replyExecutor = null;
        }

        // ---- Step 3：second drain，捕获 step 1 与 step 2 之间的窗口期残留 ----
        // 此刻 shutdownNow 已经把任何新 fresh state 的 worker 拒掉，drain 是它们唯一退路。
        replyQueues.forEach((rid, state) -> {
            state.closed().set(true);
            ReplyTask t;
            while ((t = state.queue().poll()) != null) {
                if (!t.future().isDone()) {
                    t.future().completeExceptionally(new IllegalStateException("Channel " + reason));
                }
            }
        });
        replyQueues.clear();

        // ---- Step 4：pendingAcks 残留 ----
        pendingAcks.forEach((k, f) -> {
            if (!f.isDone()) {
                f.completeExceptionally(new IllegalStateException("Channel " + reason));
            }
        });
        pendingAcks.clear();

        // ---- 其他 per-connection 状态 ----
        pendingFrames.clear();
        replyContexts.clear();
        streamLastContent.clear();
        // 断线时可能残留半截帧碎片，清空以免污染下一个连接的首帧
        wsBuffer.setLength(0);
        wsBinaryBuffer.reset();
        if (keepaliveScheduler != null) {
            keepaliveScheduler.shutdownAll();
        }
        missedPongCount.set(0);

        this.httpClient = null;
    }

    // ====================================================================
    // RFC-32 §2.0.5 / §2.4.1 a-1: lifecycle gate plumbing
    // ====================================================================

    /**
     * (Re)build the worker pool. Called from {@link #doStart()} and
     * {@link #doReconnect()}. <b>Does not</b> touch the {@link #replyQueueAccepting}
     * gate — that flag is controlled by the transport-ready signal
     * ({@link #markReady()}). See §2.4.1 a-1 / R-7.
     */
    private void ensureReplyExecutor() {
        if (replyExecutor == null || replyExecutor.isShutdown()) {
            replyExecutor = Executors.newCachedThreadPool(r -> {
                Thread t = new Thread(r, "wecom-reply");
                t.setDaemon(true);
                return t;
            });
        }
    }

    /**
     * Open the {@link #replyQueueAccepting} lifecycle gate. <b>Only</b>
     * called from {@link #markReady()} after auth_succeed. Until this
     * runs, every {@link #sendFrameWithAck} call fast-fails the caller's
     * future with {@link IllegalStateException}.
     */
    private void openReplyQueue() {
        replyQueueAccepting.set(true);
    }

    /**
     * Per-reqId serial worker. Started lazily by
     * {@link #sendFrameWithAck} when a fresh {@link ReplyQueueState} is
     * created. Exits when:
     * <ul>
     *   <li>queue is idle for 60s and atomically closes via compute
     *       (so any concurrent late-offer is observed and we stay alive)</li>
     *   <li>{@code running} flips to false</li>
     *   <li>worker thread is interrupted (e.g. by
     *       {@link ExecutorService#shutdownNow()})</li>
     * </ul>
     *
     * <p>The compute-based idle-close fixes the TOCTOU race called out
     * in RFC-32 §2.4.1 a-2 / R-5: enqueue's {@code compute} and
     * worker's idle-close {@code compute} share the same bin lock,
     * so offer and remove never interleave on the same key.
     */
    private void reqIdWorker(String reqId, ReplyQueueState state) {
        while (running.get() && !Thread.currentThread().isInterrupted()) {
            ReplyTask task;
            try {
                task = state.queue().poll(workerIdleTimeoutMs, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;  // fall through to drainStateExceptionally + return
            }

            if (task == null) {
                // Atomic close — serialized against sendFrameWithAck.compute on
                // the same reqId by ConcurrentHashMap's bin lock.
                ReplyQueueState afterClose = replyQueues.compute(reqId, (k, current) -> {
                    if (current != state) return current;                 // (c) replaced — defensive exit
                    if (!current.queue().isEmpty()) return current;       // (b) late offer — stay alive
                    current.closed().set(true);                            // (a) truly idle — close
                    return null;                                           // (a) remove entry
                });
                if (afterClose != state) return;  // (a) or (c) — exit
                continue;                          // (b) — keep going
            }

            try {
                pendingAcks.put(reqId, task.future());
                // orTimeout 5s 兜底，whenComplete 在完成时清 pendingAcks。
                // 用 (key, value) 双参 remove 避免误删后续 task 的注册。
                task.future().orTimeout(REPLY_ACK_TIMEOUT_MS, TimeUnit.MILLISECONDS)
                        .whenComplete((r, ex) -> pendingAcks.remove(reqId, task.future()));
                sendFrame(task.frame());
                task.future().join();   // serialize: don't dequeue next until this is done
            } catch (CompletionException ce) {
                // join() 抛的是 orTimeout 注入的异常（典型：TimeoutException）——
                // task.future 已经 complete，无需手动 fail
                log.debug("[wecom] reply task ACK failed for reqId={}: {}", reqId, ce.getCause());
            } catch (Exception e) {
                // sendFrame 同步抛 → ACK 永远不会到 → 必须显式 fail，否则 caller future 永久 pending
                if (!task.future().isDone()) {
                    task.future().completeExceptionally(e);
                }
                pendingAcks.remove(reqId, task.future());
                log.debug("[wecom] reply task send failed for reqId={}: {}", reqId, e.getMessage());
            }
        }

        // running=false / interrupted: mark closed + drain leftover
        state.closed().set(true);
        drainStateExceptionally(reqId, state, "channel stopped");
    }

    /**
     * Drain remaining tasks in a {@link ReplyQueueState} and best-effort
     * remove the entry from {@link #replyQueues}. Used by worker exit
     * paths (running=false / interrupt). For {@link #releaseConnectionResources}
     * the drain is inlined (step 1 / step 3) to keep the ordering proof local.
     */
    private void drainStateExceptionally(String reqId, ReplyQueueState state, String reason) {
        ReplyTask t;
        while ((t = state.queue().poll()) != null) {
            if (!t.future().isDone()) {
                t.future().completeExceptionally(new IllegalStateException(reason));
            }
        }
        replyQueues.remove(reqId, state);
    }

    // ==================== WebSocket 连接 ====================

    /**
     * 在守护线程中建立 WebSocket 连接
     */
    private void connectWebSocket(String botId, String secret) {
        // Fresh attempt — allow new failure signals to register again.
        disconnectInflight.set(false);

        wsThread = new Thread(() -> {
            try {
                log.info("[wecom] WebSocket connecting to {}...", DEFAULT_WS_URL);

                CompletableFuture<WebSocket> wsFuture = httpClient.newWebSocketBuilder()
                        .connectTimeout(Duration.ofSeconds(15))
                        .buildAsync(URI.create(DEFAULT_WS_URL), new WeComWebSocketListener());

                webSocket = wsFuture.get(20, TimeUnit.SECONDS);
                log.info("[wecom] WebSocket connected, sending auth...");

                // 发送认证帧
                sendAuth(botId, secret);

            } catch (Exception e) {
                log.error("[wecom] WebSocket connection failed: {}", e.getMessage(), e);
                handleFailure("WebSocket connection failed: " + e.getMessage());
            }
        }, "wecom-ws-" + channelEntity.getId());
        wsThread.setDaemon(true);
        wsThread.start();
    }

    /**
     * Single-flight failure handler. JDK WebSocket can fire onClose AND
     * onError for the same outage, plus connect-exception and heartbeat
     * timeout, all wanting to trigger reconnect. Without dedup this fans out
     * into 2-4 concurrent reconnect attempts, which collide on shared state
     * (httpClient, wsThread) and amplify failure into a storm.
     *
     * <p>Only the first signal of a given outage gets through; later signals
     * are logged at debug level and dropped. The flag is cleared at the start
     * of each new connect attempt and on auth success (markReady).
     */
    private void handleFailure(String reason) {
        if (!disconnectInflight.compareAndSet(false, true)) {
            log.debug("[wecom] handleFailure dedup: {}", reason);
            return;
        }
        if (!running.get()) {
            return;
        }
        onDisconnected(reason);
    }

    /**
     * Suppressed at the framework's call site. {@link AbstractChannelAdapter}
     * invokes this immediately after {@code doReconnect()} returns, but our
     * doReconnect only fire-and-forget schedules an async WS connect — the
     * connection isn't actually ready yet. Letting the framework reset
     * {@code backoff} here causes attempts to stall at #1 forever.
     *
     * <p>Real reset happens in {@link #markReady()} when the WeCom
     * {@code aibot_subscribe} auth response confirms the session is up.
     */
    @Override
    protected void onReconnectSuccess() {
        // intentionally empty
    }

    /**
     * Called when WeCom auth_succeed frame is received — the only point at
     * which the connection is genuinely usable. Resets backoff and clears
     * the failure dedup flag so the next outage (if any) can register.
     *
     * <p>RFC-080 follow-up: also cancels {@code reconnectFuture}. A stale
     * failure signal (e.g. the previous socket's async onError fired AFTER
     * connectWebSocket reset the dedup flag) can schedule a ghost reconnect
     * while this attempt is still in flight. Without canceling, that ghost
     * fires 2s later and tears down the freshly-authenticated connection,
     * producing the self-sustaining loop. Per-listener identity dedup catches
     * most cases; this is the belt-and-suspenders for any signal that still
     * gets through.
     */
    private void markReady() {
        super.onReconnectSuccess();
        if (reconnectFuture != null) {
            reconnectFuture.cancel(false);
            reconnectFuture = null;
        }
        disconnectInflight.set(false);
        // RFC-32 §2.4.1 a-1 / R-7: only NOW does sendFrameWithAck start
        // accepting tasks — auth_succeed has just been observed and the
        // WS is the canonical "transport ready" anchor.
        openReplyQueue();
    }

    /**
     * WebSocket 监听器：接收消息帧并分发处理。
     *
     * <p>RFC-080 follow-up: dedup by socket identity. The {@code disconnectInflight}
     * flag is per-channel and gets reset by {@link #connectWebSocket} as soon as a
     * new attempt starts. But the previous socket's onClose/onError can fire
     * asynchronously on a JDK HttpClient worker tens of milliseconds AFTER we have
     * already called sendClose+rebuilt and reset the flag. Without per-socket
     * dedup that stale signal slips through, schedules a ghost reconnect, and
     * tears down the freshly-established healthy connection 2s later — producing
     * the self-sustaining 2-second loop observed in the field.
     *
     * <p>Each listener instance compares the {@code WebSocket} argument against
     * {@link #webSocket} and ignores callbacks for sockets that have already
     * been replaced or released.
     */
    private class WeComWebSocketListener implements WebSocket.Listener {

        @Override
        public void onOpen(WebSocket webSocket) {
            log.debug("[wecom] WebSocket onOpen");
            webSocket.request(1);
        }

        @Override
        public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
            if (webSocket != WeComChannelAdapter.this.webSocket) {
                return null;
            }
            wsBuffer.append(data);
            if (last) {
                String fullMessage = wsBuffer.toString();
                wsBuffer.setLength(0);
                handleWebSocketFrame(fullMessage);
            }
            webSocket.request(1);
            return null;
        }

        @Override
        public CompletionStage<?> onBinary(WebSocket webSocket, ByteBuffer data, boolean last) {
            if (webSocket != WeComChannelAdapter.this.webSocket) {
                return null;
            }
            byte[] bytes = new byte[data.remaining()];
            data.get(bytes);
            wsBinaryBuffer.write(bytes, 0, bytes.length);
            if (last) {
                wsBuffer.append(new String(wsBinaryBuffer.toByteArray(), StandardCharsets.UTF_8));
                wsBinaryBuffer.reset();
                String fullMessage = wsBuffer.toString();
                wsBuffer.setLength(0);
                handleWebSocketFrame(fullMessage);
            }
            webSocket.request(1);
            return null;
        }

        @Override
        public CompletionStage<?> onClose(WebSocket webSocket, int statusCode, String reason) {
            if (webSocket != WeComChannelAdapter.this.webSocket) {
                log.debug("[wecom] stale onClose ignored: code={}, reason={}", statusCode, reason);
                return null;
            }
            log.warn("[wecom] WebSocket closed: code={}, reason={}", statusCode, reason);
            handleFailure("WebSocket closed: code=" + statusCode + ", reason=" + reason);
            return null;
        }

        @Override
        public void onError(WebSocket webSocket, Throwable error) {
            if (webSocket != WeComChannelAdapter.this.webSocket) {
                log.debug("[wecom] stale onError ignored: {}", error.getMessage());
                return;
            }
            log.error("[wecom] WebSocket error: {}", error.getMessage());
            handleFailure("WebSocket error: " + error.getMessage());
        }
    }

    // ==================== 帧处理 ====================

    /**
     * 处理收到的 WebSocket JSON 帧
     */
    @SuppressWarnings("unchecked")
    private void handleWebSocketFrame(String jsonStr) {
        try {
            Map<String, Object> frame = objectMapper.readValue(jsonStr, Map.class);
            String cmd = (String) frame.get("cmd");

            // 消息推送
            if (CMD_CALLBACK.equals(cmd)) {
                handleMessageCallback(frame);
                return;
            }

            // 事件推送
            if (CMD_EVENT_CALLBACK.equals(cmd)) {
                handleEventCallback(frame);
                return;
            }

            // 无 cmd 的帧：认证响应、心跳响应或回复 ACK
            Map<String, Object> headers = (Map<String, Object>) frame.getOrDefault("headers", Map.of());
            String reqId = (String) headers.getOrDefault("req_id", "");

            // 检查是否是回复消息的 ACK
            CompletableFuture<Map<String, Object>> ackFuture = pendingAcks.remove(reqId);
            if (ackFuture != null) {
                Integer errcode = frame.get("errcode") instanceof Number n ? n.intValue() : null;
                if (errcode != null && errcode != 0) {
                    ackFuture.completeExceptionally(new RuntimeException(
                            "Reply ACK error: errcode=" + errcode + ", errmsg=" + frame.get("errmsg")));
                } else {
                    ackFuture.complete(frame);
                }
                return;
            }

            // 认证响应
            if (reqId.startsWith(CMD_SUBSCRIBE)) {
                Integer errcode = frame.get("errcode") instanceof Number n ? n.intValue() : null;
                if (errcode != null && errcode != 0) {
                    log.error("[wecom] Authentication failed: errcode={}, errmsg={}", errcode, frame.get("errmsg"));
                    lastError = "Authentication failed: " + frame.get("errmsg");
                    // RFC-080 §8 follow-up: route auth_succeed errcode!=0 through
                    // the same single-flight failure path the transport-level
                    // failures use. Without this the WS stays open as a zombie
                    // (no heartbeat, no reconnect) and connectionState stays
                    // CONNECTED — the UI then shows "已连接" while no message
                    // can ever arrive. Letting handleFailure run flips the state
                    // to RECONNECTING and (after maxAttempts) to ERROR so the
                    // green dot stops lying.
                    handleFailure("Authentication failed: errcode=" + errcode
                            + ", errmsg=" + frame.get("errmsg"));
                    return;
                }
                log.info("[wecom] Authentication successful");
                missedPongCount.set(0);
                markReady();
                startHeartbeat();
                return;
            }

            // 心跳响应
            if (reqId.startsWith(CMD_HEARTBEAT)) {
                Integer errcode = frame.get("errcode") instanceof Number n ? n.intValue() : null;
                if (errcode != null && errcode != 0) {
                    log.warn("[wecom] Heartbeat ACK error: errcode={}", errcode);
                    return;
                }
                missedPongCount.set(0);
                log.debug("[wecom] Heartbeat ACK received");
                return;
            }

            log.debug("[wecom] Received unknown frame: {}", jsonStr.length() > 200 ? jsonStr.substring(0, 200) : jsonStr);

        } catch (Exception e) {
            log.error("[wecom] Failed to handle WebSocket frame: {}", e.getMessage(), e);
        }
    }

    // ==================== 认证 & 心跳 ====================

    private void sendAuth(String botId, String secret) {
        String reqId = generateReqId(CMD_SUBSCRIBE);
        Map<String, Object> frame = Map.of(
                "cmd", CMD_SUBSCRIBE,
                "headers", Map.of("req_id", reqId),
                "body", Map.of("bot_id", botId, "secret", secret)
        );
        sendFrame(frame);
        log.info("[wecom] Auth frame sent");
    }

    private void startHeartbeat() {
        if (heartbeatFuture != null) {
            heartbeatFuture.cancel(false);
        }
        heartbeatFuture = ensureReconnectScheduler().scheduleAtFixedRate(() -> {
            if (!running.get()) return;
            try {
                sendHeartbeat();
            } catch (Exception e) {
                log.warn("[wecom] Heartbeat send failed: {}", e.getMessage());
            }
        }, HEARTBEAT_INTERVAL_MS, HEARTBEAT_INTERVAL_MS, TimeUnit.MILLISECONDS);
        log.debug("[wecom] Heartbeat started (interval={}ms)", HEARTBEAT_INTERVAL_MS);
    }

    private void sendHeartbeat() {
        if (missedPongCount.get() >= MAX_MISSED_PONG) {
            log.warn("[wecom] No heartbeat ACK for {} consecutive pings, connection considered dead",
                    missedPongCount.get());
            if (heartbeatFuture != null) {
                heartbeatFuture.cancel(false);
                heartbeatFuture = null;
            }
            handleFailure("Heartbeat timeout: " + missedPongCount.get() + " missed pongs");
            return;
        }

        missedPongCount.incrementAndGet();
        String reqId = generateReqId(CMD_HEARTBEAT);
        sendFrame(Map.of(
                "cmd", CMD_HEARTBEAT,
                "headers", Map.of("req_id", reqId)
        ));
        log.debug("[wecom] Heartbeat sent (missed={})", missedPongCount.get());
    }

    // ==================== 消息接收 ====================

    /**
     * 处理消息推送回调 (aibot_msg_callback)
     */
    @SuppressWarnings("unchecked")
    private void handleMessageCallback(Map<String, Object> frame) {
        try {
            Map<String, Object> body = (Map<String, Object>) frame.getOrDefault("body", Map.of());
            Map<String, Object> headers = (Map<String, Object>) frame.getOrDefault("headers", Map.of());
            String frameReqId = (String) headers.getOrDefault("req_id", "");

            String msgType = (String) body.getOrDefault("msgtype", "");
            Map<String, Object> fromMap = (Map<String, Object>) body.getOrDefault("from", Map.of());
            String senderId = (String) fromMap.getOrDefault("userid", "");
            String chatId = (String) body.getOrDefault("chatid", "");
            String chatType = (String) body.getOrDefault("chattype", "single");
            String msgId = (String) body.getOrDefault("msgid", "");

            // 补充 msgId（如果为空则用 senderId + send_time 合成）
            if (msgId.isBlank()) {
                msgId = senderId + "_" + body.getOrDefault("send_time", System.currentTimeMillis());
            }

            // 消息去重
            if (!msgId.isBlank() && !processedMessageIds.add(msgId)) {
                log.debug("[wecom] Duplicate msgId: {}, skipping", msgId);
                return;
            }
            // 去重集合超限清理
            if (processedMessageIds.size() > PROCESSED_IDS_MAX) {
                int toRemove = processedMessageIds.size() / 2;
                var it = processedMessageIds.iterator();
                while (it.hasNext() && toRemove > 0) { it.next(); it.remove(); toRemove--; }
            }

            // 保存 frame 用于 reply_stream
            pendingFrames.put(frameReqId, frame);

            List<MessageContentPart> contentParts = new ArrayList<>();
            String textContent = null;
            boolean hasVoice = false;

            switch (msgType) {
                case "text" -> {
                    Map<String, Object> textBody = (Map<String, Object>) body.getOrDefault("text", Map.of());
                    textContent = ((String) textBody.getOrDefault("content", "")).trim();
                    if (!textContent.isBlank()) {
                        contentParts.add(MessageContentPart.text(textContent));
                    }
                }
                case "image" -> {
                    Map<String, Object> imgBody = (Map<String, Object>) body.getOrDefault("image", Map.of());
                    String url = (String) imgBody.getOrDefault("url", "");
                    String aesKey = (String) imgBody.getOrDefault("aeskey", "");
                    String inboundConvId = inboundConversationId(senderId, chatId, chatType, channelEntity != null ? channelEntity.getId() : null);
                    if (!url.isBlank()) {
                        contentParts.add(buildInboundImagePart(url, aesKey, msgId, "image.jpg", inboundConvId));
                    }
                    textContent = "[图片]";
                }
                case "voice" -> {
                    hasVoice = true;
                    Map<String, Object> voiceBody = (Map<String, Object>) body.getOrDefault("voice", Map.of());
                    String asrText = ((String) voiceBody.getOrDefault("content", "")).trim();
                    if (!asrText.isBlank()) {
                        contentParts.add(MessageContentPart.text(asrText));
                        textContent = asrText;
                    } else {
                        textContent = "[语音消息]";
                    }
                }
                case "file" -> {
                    Map<String, Object> fileBody = (Map<String, Object>) body.getOrDefault("file", Map.of());
                    String url = (String) fileBody.getOrDefault("url", "");
                    String aesKey = (String) fileBody.getOrDefault("aeskey", "");
                    // WeCom sometimes omits filename for forwarded files. Try a
                    // few fallback keys before giving up to "file.bin"; the
                    // magic-byte sniffer in downloadInboundMedia will fix the
                    // extension either way, but having something user-readable
                    // here keeps the bubble title meaningful.
                    String filename = (String) fileBody.getOrDefault("filename",
                            fileBody.getOrDefault("file_name",
                                    fileBody.getOrDefault("name", "file.bin")));
                    String fileConvId = inboundConversationId(senderId, chatId, chatType, channelEntity != null ? channelEntity.getId() : null);
                    if (!url.isBlank()) {
                        MessageContentPart filePart = buildInboundFilePart(
                                url, aesKey, msgId, filename, fileConvId);
                        contentParts.add(filePart);
                        // Surface the corrected filename (with proper extension)
                        // back into the [文件: X] text marker the agent sees.
                        if (filePart.getFileName() != null && !filePart.getFileName().isBlank()) {
                            filename = filePart.getFileName();
                        }
                    }
                    textContent = "[文件: " + filename + "]";
                }
                case "mixed" -> {
                    Map<String, Object> mixedBody = (Map<String, Object>) body.getOrDefault("mixed", Map.of());
                    List<Map<String, Object>> items = (List<Map<String, Object>>) mixedBody.getOrDefault("msg_item", List.of());
                    StringBuilder textBuilder = new StringBuilder();
                    for (Map<String, Object> item : items) {
                        String itemType = (String) item.getOrDefault("msgtype", "");
                        if ("text".equals(itemType)) {
                            Map<String, Object> t = (Map<String, Object>) item.getOrDefault("text", Map.of());
                            String txt = ((String) t.getOrDefault("content", "")).trim();
                            if (!txt.isBlank()) {
                                textBuilder.append(txt).append('\n');
                            }
                        } else if ("image".equals(itemType)) {
                            // 与独立 image 消息对齐：下载 + AES 解密
                            Map<String, Object> img = (Map<String, Object>) item.getOrDefault("image", Map.of());
                            String url = (String) img.getOrDefault("url", "");
                            String aesKey = (String) img.getOrDefault("aeskey", "");
                            String mixedConvId = inboundConversationId(senderId, chatId, chatType, channelEntity != null ? channelEntity.getId() : null);
                            if (!url.isBlank()) {
                                contentParts.add(buildInboundImagePart(
                                        url, aesKey, msgId, "mixed_image.jpg", mixedConvId));
                            }
                        } else if ("voice".equals(itemType)) {
                            Map<String, Object> v = (Map<String, Object>) item.getOrDefault("voice", Map.of());
                            String asrText = ((String) v.getOrDefault("content", "")).trim();
                            if (!asrText.isBlank()) {
                                hasVoice = true;
                                textBuilder.append(asrText).append('\n');
                            }
                        }
                    }
                    textContent = textBuilder.toString().trim();
                    if (!textContent.isBlank()) {
                        contentParts.add(0, MessageContentPart.text(textContent));
                    }
                }
                case "appmsg" -> {
                    // Forwarded WeCom complex messages: PDF / Word / Excel
                    // transfers, public-account article links, miniprogram
                    // cards. Without this branch every forwarded PDF /
                    // article / miniprogram fell into default and got
                    // silently dropped — bot looked dumb to users.
                    AppmsgContent appmsg = extractAppmsgContent(body, msgId, senderId, chatId, chatType);
                    if (appmsg.text() != null && !appmsg.text().isBlank()) {
                        textContent = appmsg.text();
                        contentParts.add(0, MessageContentPart.text(textContent));
                    }
                    contentParts.addAll(appmsg.attachedParts());
                }
                default -> {
                    log.debug("[wecom] Ignoring unsupported message type: {}", msgType);
                    return;
                }
            }

            // Apply any quoted-message context. The "quote" field appears at
            // body level alongside the new message regardless of outer
            // msgtype — without parsing it, the agent only sees the user's
            // current text and silently loses the conversational reference
            // ("user quoted the bot's previous image and asked '什么意思'"
            // arrives as bare "什么意思", agent goes off-topic).
            QuoteContext quote = extractQuoteContext(body, msgId, senderId, chatId, chatType);
            if (quote != null && !quote.isEmpty()) {
                String prefixedText = quote.prefix()
                        + (textContent != null && !textContent.isBlank() ? textContent : "");
                textContent = prefixedText;

                // Find an existing text part (text/voice cases produce one)
                // and overwrite it with the prefixed text. Also pull it to
                // the front so agent reading order starts with quote prefix.
                boolean updated = false;
                for (int i = 0; i < contentParts.size(); i++) {
                    if ("text".equals(contentParts.get(i).getType())) {
                        contentParts.set(i, MessageContentPart.text(prefixedText));
                        if (i != 0) {
                            MessageContentPart promoted = contentParts.remove(i);
                            contentParts.add(0, promoted);
                        }
                        updated = true;
                        break;
                    }
                }
                if (!updated) {
                    // image/file/mixed cases without a text part — insert one.
                    contentParts.add(0, MessageContentPart.text(prefixedText));
                }
                // Quoted media (image/file the user referenced) goes right
                // after the text prefix so the agent reads:
                //   prefix → quoted media → user's own media (if any)
                if (!quote.attachedParts().isEmpty()) {
                    contentParts.addAll(1, quote.attachedParts());
                }
                log.debug("[wecom] Applied quote context: prefixLen={}, attachedParts={}",
                        quote.prefix().length(), quote.attachedParts().size());
            }

            if (contentParts.isEmpty()) {
                if (textContent != null && !textContent.isBlank()) {
                    contentParts.add(MessageContentPart.text(textContent));
                } else {
                    return;
                }
            }

            // 发送"🤔 思考中..."处理指示器
            String processingStreamId = "";
            if (textContent != null && !textContent.isBlank()) {
                processingStreamId = generateReqId("stream");
                try {
                    replyStream(frameReqId, processingStreamId, "🤔 思考中...", false);
                } catch (Exception e) {
                    log.debug("[wecom] Failed to send processing indicator: {}", e.getMessage());
                }
            }

            boolean isGroup = "group".equals(chatType);
            String effectiveChatId = isGroup ? chatId : null;

            // Cache the group's most recent inbound frameReqId so future
            // proactive pushes into this group can ride aibot_respond_msg
            // (the AI bot platform blocks aibot_send_msg in groups —
            // without this cache async-task completions and cron summaries
            // silently fail to deliver).
            if (isGroup && chatId != null && !chatId.isBlank()
                    && frameReqId != null && !frameReqId.isBlank()) {
                rememberGroupReplyReqId(chatId, frameReqId);
            }

            // conversationId 格式：wecom:{userid} 或 wecom:group:{chatid}
            // 由 ChannelMessageRouter.buildConversationId() 根据 channelType + chatId/senderId 构建

            ChannelMessage channelMessage = ChannelMessage.builder()
                    .messageId(msgId)
                    .channelType(CHANNEL_TYPE)
                    .senderId(senderId)
                    .senderName(senderId)
                    .chatId(effectiveChatId)
                    .content(textContent != null ? textContent.trim() : "")
                    .contentType(msgType)
                    .contentParts(contentParts)
                    .inputMode(hasVoice ? "voice" : "text")
                    .timestamp(LocalDateTime.now())
                    .replyToken(isGroup ? chatId : senderId)
                    .rawPayload(Map.of(
                            "wecom_frame_req_id", frameReqId,
                            "wecom_processing_stream_id", processingStreamId,
                            "wecom_chat_type", chatType,
                            "wecom_chatid", chatId
                    ))
                    .build();

            // 保存回复上下文，供 sendContentParts / renderAndSend 使用
            String replyToken = isGroup ? chatId : senderId;
            replyContexts.put(replyToken, new WeComReplyContext(frameReqId, processingStreamId));

            // PR-1: launch keepalive for the processing stream so long-running agent
            // tasks (>60s) keep their stream slot alive — without this, WeCom's
            // server-side TTL drops the slot and the eventual real reply gets
            // silently rejected. RFC-32 §2.1.2 / R-7 / B-5.
            if (keepaliveScheduler != null
                    && processingStreamId != null && !processingStreamId.isBlank()) {
                try {
                    keepaliveScheduler.start(this, frameReqId, processingStreamId, replyToken);
                } catch (Exception e) {
                    log.debug("[wecom] keepalive start failed: {}", e.getMessage());
                }
            }

            log.info("[wecom] Received message: sender={}, chatType={}, msgType={}, textLen={}",
                    senderId.length() > 20 ? senderId.substring(0, 20) : senderId,
                    chatType, msgType,
                    textContent != null ? textContent.length() : 0);

            onMessage(channelMessage);

        } catch (Exception e) {
            log.error("[wecom] Failed to handle message callback: {}", e.getMessage(), e);
        }
    }

    /**
     * 处理事件推送回调 (aibot_event_callback)
     */
    @SuppressWarnings("unchecked")
    private void handleEventCallback(Map<String, Object> frame) {
        try {
            Map<String, Object> body = (Map<String, Object>) frame.getOrDefault("body", Map.of());
            Map<String, Object> event = body.get("event") instanceof Map<?, ?> m ? (Map<String, Object>) m : Map.of();
            String eventType = (String) event.getOrDefault("eventtype", "");

            if ("enter_chat".equals(eventType)) {
                String welcomeText = getConfigString("welcome_text", "");
                if (!welcomeText.isBlank()) {
                    try {
                        Map<String, Object> headers = (Map<String, Object>) frame.getOrDefault("headers", Map.of());
                        String reqId = (String) headers.getOrDefault("req_id", "");
                        replyWelcome(reqId, welcomeText);
                        log.info("[wecom] Welcome message sent");
                    } catch (Exception e) {
                        log.warn("[wecom] Failed to send welcome message: {}", e.getMessage());
                    }
                }
                return;
            }

            if ("template_card_event".equals(eventType)) {
                handleTemplateCardEvent(frame, body, event);
                return;
            }

            log.debug("[wecom] Ignoring event type: {}", eventType);
        } catch (Exception e) {
            log.error("[wecom] Failed to handle event callback: {}", e.getMessage(), e);
        }
    }

    /**
     * Route an inbound {@code template_card_event} (a button click on a
     * card we previously sent) to the correct
     * {@link vip.mate.channel.wecom.cards.WeComCardKind} based on the
     * task_id prefix. Each card kind owns its own validation +
     * resolved-state render + command-injection logic.
     *
     * <p><b>5-second window</b>: WeCom requires the
     * {@code aibot_respond_update_msg} for this event to be sent inside
     * 5s. Handlers therefore run synchronously here; the heavy work
     * (e.g. agent re-execution) is deferred to the router's normal
     * processMessage path via {@link #injectSyntheticMessage}.
     */
    @SuppressWarnings("unchecked")
    private void handleTemplateCardEvent(Map<String, Object> frame,
                                         Map<String, Object> body,
                                         Map<String, Object> event) {
        if (cardDispatcher == null) {
            log.debug("[wecom] template_card_event ignored: dispatcher not wired");
            return;
        }
        Map<String, Object> tce = event.get("template_card_event") instanceof Map<?, ?> m
                ? (Map<String, Object>) m
                : (Map<String, Object>) event;  // some firmware nests directly under event
        String taskId = (String) tce.getOrDefault("task_id", "");
        if (taskId.isBlank()) {
            log.debug("[wecom] template_card_event missing task_id, ignoring");
            return;
        }

        var kindOpt = cardDispatcher.lookupByTaskId(taskId);
        if (kindOpt.isEmpty()) {
            log.warn("[wecom] No registered card kind matches task_id={}, ignoring", taskId);
            return;
        }

        Map<String, Object> fromBlock = body.get("from") instanceof Map<?, ?> fm
                ? (Map<String, Object>) fm
                : Map.of();
        try {
            kindOpt.get().handler().handle(this, frame, tce, fromBlock);
        } catch (Exception e) {
            log.error("[wecom] template_card_event handler ({}) threw: {}",
                    kindOpt.get().name(), e.getMessage(), e);
        }
    }

    // ==================== 消息发送 ====================

    /**
     * Render an approval notice as a WeCom {@code button_interaction}
     * card and post it via the active reply context, instead of the
     * abstract-class default text path.
     *
     * <p>Falls back to {@code super.sendApprovalNotice} (markdown text)
     * in three failure modes:
     * <ol>
     *   <li>No card dispatcher available (DI did not wire it — usually
     *       a test / hot-swap context)</li>
     *   <li>No active {@link WeComReplyContext} for {@code targetId} —
     *       proactive paths (cron without a recent inbound message)
     *       cannot post a card because WeCom AI Bots reject
     *       {@code aibot_send_msg + template_card}; fall back to text
     *       so the user still sees the approval</li>
     *   <li>{@link CardOversizedException} thrown by the renderer
     *       (button.key payload &gt; 1024 bytes)</li>
     * </ol>
     *
     * <p>The card is sent via {@link #replyTemplateCard} bound to the
     * inbound frame's {@code req_id} that
     * {@link #handleMessageCallback} stashed in {@link #replyContexts}.
     */
    @Override
    public boolean usesInteractiveApprovalCards() {
        // Same gate as sendApprovalNotice below — without the dispatcher
        // wired we fall back to the inherited text path, and the router
        // should treat unrelated follow-up messages as implicit deny
        // (existing behaviour).
        return cardDispatcher != null;
    }

    @Override
    public void sendApprovalNotice(String targetId,
            vip.mate.channel.notification.ApprovalNotice notice) {
        if (cardDispatcher == null) {
            super.sendApprovalNotice(targetId, notice);
            return;
        }
        WeComReplyContext ctx = replyContexts.get(targetId);
        if (ctx == null || ctx.frameReqId() == null || ctx.frameReqId().isBlank()) {
            // No bound reply context — fall back to text. Most common in
            // proactive paths (cron-triggered approvals) which WeCom AI
            // Bot rejects for cards anyway.
            super.sendApprovalNotice(targetId, notice);
            return;
        }
        var kindOpt = cardDispatcher.lookupByMessageType(
                vip.mate.channel.wecom.cards.tool_guard.ToolGuardCardKindFactory.MESSAGE_TYPE);
        if (kindOpt.isEmpty()) {
            super.sendApprovalNotice(targetId, notice);
            return;
        }
        try {
            Map<String, Object> card = kindOpt.get().renderer().render(notice);
            replyTemplateCard(ctx.frameReqId(), card);
        } catch (vip.mate.channel.cards.CardOversizedException oversized) {
            log.warn("[wecom] approval card oversized, falling back to text: {}", oversized.getMessage());
            super.sendApprovalNotice(targetId, notice);
        } catch (Exception e) {
            log.warn("[wecom] approval card render/send failed, falling back to text: {}", e.getMessage());
            super.sendApprovalNotice(targetId, notice);
        }
    }

    // ==================== StreamingChannelAdapter ====================

    /** Minimum interval between progress overwrites of the stream bubble. */
    private static final long PROGRESS_MIN_INTERVAL_MS = 500;

    /** Max chars of a tool-argument summary in a standalone tool message. */
    private static final int TOOL_ARGS_SUMMARY_MAX = 120;

    /**
     * 流式处理 Agent 事件并渲染到企业微信
     * <p>
     * 渲染策略：复用入站时发出的 "🤔 思考中..." reply_stream 气泡，随
     * agent 事件（思考、工具调用、计划步骤、内容产出）持续覆写为实时进度，
     * 流结束后原地渐变为最终答案（走 renderAndSend 的分段逻辑）。
     * <ul>
     *   <li>覆写节流 {@link #PROGRESS_MIN_INTERVAL_MS}；工具/审批等关键事件立即刷新</li>
     *   <li>静默期由 {@link WeComKeepaliveScheduler} 每 20s 用进度快照续期</li>
     *   <li>{@code stream_progress=false} 或无可用气泡（语音入站等）时退化为
     *       "累积后一次性发送"，与改造前行为一致</li>
     *   <li>{@code filter_tool_messages=false} 时，每次工具调用另发独立消息留痕</li>
     *   <li>{@code filter_thinking=false} 时，思考内容以引用块进入进度气泡</li>
     * </ul>
     */
    @Override
    public String processStream(Flux<StreamDelta> stream, ChannelMessage message, String conversationId) {
        String replyTarget = message.getReplyToken() != null ? message.getReplyToken()
                : (message.getChatId() != null ? message.getChatId() : message.getSenderId());
        WeComReplyContext ctx = replyContexts.get(replyTarget);
        boolean progressEnabled = getConfigBoolean("stream_progress", true);
        boolean bubbleUsable = ctx != null && ctx.processingStreamId() != null
                && !ctx.processingStreamId().isBlank()
                && ctx.frameReqId() != null && !ctx.frameReqId().isBlank();

        StringBuilder contentAccumulator = new StringBuilder();
        StreamOutcome outcome;
        if (!progressEnabled || !bubbleUsable) {
            // Degraded path — accumulate content only and send once at the end.
            // segmentOnly narration is excluded: gluing it into the reply is
            // what makes the same paragraph reach the user two or three times.
            stream.doOnNext(delta -> {
                        if (StreamingChannelAdapter.contributesToFinalContent(delta)) {
                            contentAccumulator.append(delta.content());
                        }
                    })
                    .blockLast(Duration.ofMinutes(10));
            outcome = new StreamOutcome(null, false);
        } else {
            outcome = consumeWithProgress(stream, message, replyTarget, ctx, contentAccumulator);
        }

        String finalContent = contentAccumulator.toString();

        // The newest narration was held back until the answer was known: when
        // a turn's closing narration and its final answer are the same text
        // (routine once the answer is short — the model restates it before the
        // last tool call), publishing both puts the identical bubble on screen
        // twice. Same text → drop the narration, the final answer covers it.
        String pendingNarration = outcome.pendingNarration();
        if (!finalContent.isBlank()) {
            if (pendingNarration != null && !sameOutboundText(pendingNarration, finalContent)) {
                publishNarrationBubble(replyTarget, pendingNarration);
            }
            renderAndSend(replyTarget, finalContent);
        } else if (pendingNarration != null) {
            // No final answer at all — the held-back narration is everything
            // the user gets, so it closes the live bubble in place instead of
            // being dropped. Not returned: narration never becomes persisted
            // content.
            renderAndSend(replyTarget, pendingNarration);
        } else {
            // Nothing to render. Without this the live bubble would sit at
            // "🤔 思考中…" with the tool trail under it forever, because only
            // renderAndSend ever finishes it.
            closeIdleProgressBubble(replyTarget, outcome.approvalPending());
        }
        return finalContent;
    }

    /**
     * What {@link #consumeWithProgress} learned while draining the stream, but
     * which only {@link #processStream} can act on (it needs the final answer
     * first).
     *
     * @param pendingNarration the last per-stage narration, still unpublished
     * @param approvalPending  a tool call is parked on human approval
     */
    private record StreamOutcome(String pendingNarration, boolean approvalPending) {}

    /** Compare two outbound texts the way the user sees them (post-filter, trimmed). */
    private boolean sameOutboundText(String a, String b) {
        if (a == null || b == null) {
            return false;
        }
        String left = filterOutboundContent(a).trim();
        String right = filterOutboundContent(b).trim();
        return !left.isEmpty() && left.equals(right);
    }

    /**
     * Finish the live progress bubble when the turn produced no text at all
     * (approval park, user stop, empty answer). Leaving it open strands a
     * permanent "思考中…" bubble carrying the whole tool trail.
     */
    private void closeIdleProgressBubble(String replyTarget, boolean approvalPending) {
        WeComReplyContext ctx = replyContexts.get(replyTarget);
        if (ctx == null || ctx.processingStreamId() == null || ctx.processingStreamId().isBlank()) {
            return;
        }
        renderAndSend(replyTarget, approvalPending
                ? "⏸️ 已暂停，等待工具审批。"
                : "（本轮没有产生回复内容）");
    }

    /**
     * Finalize the live progress bubble with a narration, or send the
     * narration as a plain message when no bubble is available (the keepalive
     * force-finish at the 180s ceiling evicts the reply context).
     */
    private void publishNarrationBubble(String replyTarget, String narration) {
        WeComReplyContext ctx = replyContexts.get(replyTarget);
        if (ctx != null) {
            rollProgressBubble(replyTarget, ctx, narration, null);
        } else {
            sendMessage(replyTarget, narration);
        }
    }

    /** Event-driven progress rendering into the processing-stream bubble, with per-stage bubble rolling. */
    private StreamOutcome consumeWithProgress(Flux<StreamDelta> stream, ChannelMessage message,
                                              String replyTarget, WeComReplyContext initialCtx,
                                              StringBuilder contentAccumulator) {
        boolean showThinking = !getConfigBoolean("filter_thinking", true);
        boolean standaloneToolMessages = !getConfigBoolean("filter_tool_messages", true);
        long minIntervalMs = getConfigLong("progress_interval_ms", PROGRESS_MIN_INTERVAL_MS);

        WeComProgressRenderer progress = new WeComProgressRenderer(
                System.currentTimeMillis(), showThinking, standaloneToolMessages);
        if (keepaliveScheduler != null) {
            // Silent stretches (long LLM calls with no events) keep showing a
            // fresh elapsed-time snapshot instead of the static placeholder.
            keepaliveScheduler.attachTextSupplier(initialCtx.processingStreamId(), progress::snapshot);
        }

        // The live progress bubble rolls forward on every stage narration:
        // the current stream is finished with the narration text (making it
        // a permanent bubble in place) and a fresh stream id opens below it
        // as the new progress bubble, so chat chronology stays intact and
        // the final answer always lands in the newest bubble.
        AtomicReference<WeComReplyContext> liveCtx = new AtomicReference<>(initialCtx);
        AtomicReference<String> pendingNarration = new AtomicReference<>();
        final long[] lastFlushAt = {0L};
        stream.doOnNext(delta -> {
            boolean flushNow = false;
            if (delta.isEvent()) {
                flushNow = progress.onEvent(delta.eventType(), delta.eventData());
                if (standaloneToolMessages) {
                    maybeSendToolEventMessage(replyTarget, delta.eventType(), delta.eventData());
                }
            } else if (delta.segmentOnly()) {
                // Per-stage narration ("我来查一下…"), emitted once per agent
                // loop iteration. Each becomes its own permanent bubble and is
                // excluded from the final answer: glued together they read as
                // a wall of text, and persisted they pollute the next turn's
                // LLM history with unanswered chain-of-thought.
                //
                // Publishing lags one narration behind: the newest one is only
                // staged (visible live in the bubble, not yet finalized) so
                // processStream can still drop it if the final answer turns out
                // to be the same text. Without the lag the user reads the same
                // paragraph in two adjacent bubbles.
                String narration = delta.content() != null ? delta.content().trim() : "";
                if (!narration.isEmpty()) {
                    String previous = pendingNarration.getAndSet(narration);
                    progress.onNarration(narration);
                    if (previous != null) {
                        WeComReplyContext ctx = liveCtx.get();
                        if (replyContexts.get(replyTarget) == ctx) {
                            liveCtx.set(rollProgressBubble(replyTarget, ctx, previous, progress));
                        } else {
                            // Bubble already force-finished (180s ceiling) — the
                            // narration still goes out as a plain message.
                            sendMessage(replyTarget, previous);
                        }
                    }
                    flushNow = true;
                }
            } else {
                if (delta.thinking() != null) {
                    progress.onThinkingDelta(delta.thinking());
                }
                if (delta.content() != null) {
                    contentAccumulator.append(delta.content());
                    progress.onContentDelta(delta.content());
                }
            }
            long now = System.currentTimeMillis();
            if (!flushNow && now - lastFlushAt[0] < minIntervalMs) {
                return;
            }
            WeComReplyContext ctx = liveCtx.get();
            // The keepalive force-finish (180s ceiling) evicts the reply
            // context; once that happens the stream slot is closed and
            // further overwrites would be silently rejected — stop pushing.
            if (replyContexts.get(replyTarget) != ctx) {
                return;
            }
            lastFlushAt[0] = now;
            try {
                replyStream(ctx.frameReqId(), ctx.processingStreamId(), progress.snapshot(), false);
            } catch (Exception e) {
                // Reset the throttle window so the next delta retries the
                // overwrite immediately instead of waiting out the min
                // interval — a failed push means the bubble is stale.
                lastFlushAt[0] = 0L;
                log.debug("[wecom] progress overwrite failed: {}", e.getMessage());
            }
        }).blockLast(Duration.ofMinutes(10));

        return new StreamOutcome(pendingNarration.get(), progress.isApprovalPending());
    }

    /**
     * Finalize the current progress bubble with a stage narration and open a
     * fresh stream as the next progress bubble.
     * <p>
     * The narration goes through the channel renderer (thinking/tool-tag
     * filters, table formatting, length split): the first segment overwrites
     * the current bubble with {@code finish=true}, overflow segments ride
     * plain messages. The replacement context is registered in
     * {@link #replyContexts} so {@code renderAndSend} / approval cards keep
     * working against the newest bubble, and keepalive restarts on the new
     * stream with the live progress snapshot.
     *
     * @param progress live progress renderer, or {@code null} when the stream
     *                 has already finished (the replacement bubble is then a
     *                 bare slot for {@code renderAndSend}, with no keepalive)
     */
    private WeComReplyContext rollProgressBubble(String replyTarget, WeComReplyContext ctx,
                                                 String narration, WeComProgressRenderer progress) {
        boolean filterThinking = getConfigBoolean("filter_thinking", true);
        boolean filterToolMessages = getConfigBoolean("filter_tool_messages", true);
        String format = getConfigString("message_format", "auto");
        int maxLen = vip.mate.channel.ChannelMessageRenderer.PLATFORM_LIMITS
                .getOrDefault(getChannelType(), 2048);
        List<String> segments = vip.mate.channel.ChannelMessageRenderer.renderForChannel(
                narration, filterThinking, filterToolMessages, format, maxLen);
        if (segments.isEmpty()) {
            // Narration entirely filtered away — keep the current bubble.
            return ctx;
        }
        if (keepaliveScheduler != null) {
            // Stop before the finish chunk so a refresh tick can't race it
            // on the same stream.
            keepaliveScheduler.stop(ctx.processingStreamId());
        }
        boolean first = true;
        for (String rawSegment : segments) {
            String segment = formatMarkdownTables(rawSegment);
            if (first) {
                first = false;
                try {
                    replyStream(ctx.frameReqId(), ctx.processingStreamId(), segment, true);
                } catch (Exception e) {
                    log.debug("[wecom] stage bubble finalize failed: {}", e.getMessage());
                }
            } else {
                sendMessage(replyTarget, segment);
            }
        }

        String nextStreamId = generateReqId("stream");
        WeComReplyContext next = new WeComReplyContext(ctx.frameReqId(), nextStreamId);
        replyContexts.put(replyTarget, next);
        try {
            replyStream(ctx.frameReqId(), nextStreamId,
                    progress != null ? progress.snapshot() : "✍️ 正在整理…", false);
        } catch (Exception e) {
            log.debug("[wecom] next progress bubble open failed: {}", e.getMessage());
        }
        if (progress != null && keepaliveScheduler != null) {
            try {
                keepaliveScheduler.start(this, ctx.frameReqId(), nextStreamId, replyTarget);
                keepaliveScheduler.attachTextSupplier(nextStreamId, progress::snapshot);
            } catch (Exception e) {
                log.debug("[wecom] keepalive restart failed: {}", e.getMessage());
            }
        }
        return next;
    }

    /**
     * Standalone tool-call trace messages, sent only when the channel's
     * {@code filter_tool_messages} toggle is off: the user opted into seeing
     * the tool trail as persistent bubbles (the progress bubble alone is
     * transient — the final answer overwrites it).
     */
    private void maybeSendToolEventMessage(String replyTarget, String eventType,
                                           Map<String, Object> data) {
        if (data == null || eventType == null) {
            return;
        }
        Object toolName = data.get("toolName");
        if (toolName == null) {
            return;
        }
        try {
            switch (eventType) {
                case "tool_call_started" -> {
                    String args = summarizeToolArgs(data.get("arguments"));
                    sendMessage(replyTarget, "🔧 调用工具 `" + toolName + "`"
                            + (args.isEmpty() ? "" : "\n> " + args));
                }
                case "tool_call_completed" -> {
                    boolean success = !Boolean.FALSE.equals(data.get("success"));
                    sendMessage(replyTarget, (success ? "✅ `" : "❌ `") + toolName
                            + (success ? "` 完成" : "` 失败"));
                }
                default -> {
                    // Other events carry no standalone tool trace.
                }
            }
        } catch (Exception e) {
            log.debug("[wecom] tool trace message failed: {}", e.getMessage());
        }
    }

    private static String summarizeToolArgs(Object arguments) {
        if (arguments == null) {
            return "";
        }
        String text = arguments.toString().replaceAll("\\s+", " ").trim();
        if (text.isEmpty() || "{}".equals(text)) {
            return "";
        }
        return text.length() > TOOL_ARGS_SUMMARY_MAX
                ? text.substring(0, TOOL_ARGS_SUMMARY_MAX) + "…"
                : text;
    }

    @Override
    public void sendMessage(String targetId, String content) {
        if (webSocket == null) {
            log.warn("[wecom] Channel not started, cannot send message");
            return;
        }

        // 无 frame 上下文的通用发送入口（cron/异步通知等主动推送场景）。
        // 带 WeComReplyContext 的回复路径（renderAndSend / sendContentParts）
        // 已直接绑定入站 frame 发送，不再落到这里；此处保留
        // send_message 主动推送 + 群聊缓存 reqId 兜底。
        sendMessageToChat(targetId, content);
    }

    /**
     * 通过 WebSocket send_message 命令主动推送消息。
     * <p>
     * Group fallback: WeCom AI Bot platform rejects {@code aibot_send_msg}
     * in group chats. When {@code chatId} matches a known group (via
     * {@link #pickGroupReplyReqId}), ride a cached inbound reqId via
     * {@code aibot_respond_msg} instead. Single chats still use
     * {@code aibot_send_msg} (which the platform allows).
     */
    private void sendMessageToChat(String chatId, String content) {
        if (webSocket == null || content == null || content.isBlank()) return;
        Map<String, Object> textBody = Map.of(
                "msgtype", "markdown",
                "markdown", Map.of("content", content)
        );
        sendOutboundFrame(chatId, textBody);
    }

    /**
     * Send a body via either {@code aibot_respond_msg} (groups, using a
     * cached inbound reqId) or {@code aibot_send_msg} (single chats).
     * <p>
     * Centralised so {@link #sendMessageToChat} (text) and
     * {@link #sendMediaMessage} (image/file/voice/video) share the same
     * group-vs-single dispatch — without this, every new outbound path
     * had to remember the group rule, and several didn't.
     */
    private void sendOutboundFrame(String chatId, Map<String, Object> bodyWithMsgtype) {
        if (webSocket == null || chatId == null || chatId.isBlank()) return;
        try {
            String groupReplyReqId = pickGroupReplyReqId(chatId);
            if (groupReplyReqId != null) {
                // Group chat — ride aibot_respond_msg with the cached reqId.
                // The body for respond_msg does NOT include "chatid" — the
                // server infers the target from the original frame's reqId.
                Map<String, Object> frame = Map.of(
                        "cmd", CMD_RESPONSE,
                        "headers", Map.of("req_id", groupReplyReqId),
                        "body", bodyWithMsgtype
                );
                sendFrameWithAck(groupReplyReqId, frame);
                log.debug("[wecom] Group send via aibot_respond_msg: chatId={}, reqId={}",
                        chatId, groupReplyReqId);
            } else {
                // Single chat — aibot_send_msg accepts a chatid field.
                Map<String, Object> withChatId = new LinkedHashMap<>(bodyWithMsgtype);
                withChatId.put("chatid", chatId);
                String reqId = generateReqId(CMD_SEND_MSG);
                Map<String, Object> frame = Map.of(
                        "cmd", CMD_SEND_MSG,
                        "headers", Map.of("req_id", reqId),
                        "body", withChatId
                );
                sendFrameWithAck(reqId, frame);
            }
        } catch (Exception e) {
            log.error("[wecom] Failed to send outbound frame to {}: {}", chatId, e.getMessage(), e);
        }
    }

    /**
     * Record the most recent inbound frameReqId for a group chat. Bounded
     * LRU: when over {@link #LAST_CHAT_REQ_IDS_MAX_SIZE} we evict the
     * oldest insertion-order key (ConcurrentHashMap iteration is
     * insertion-order-ish for small maps and good enough — the cache
     * exists to bound memory, not to be perfectly LRU).
     */
    private void rememberGroupReplyReqId(String chatId, String frameReqId) {
        lastChatReqIds.put(chatId, frameReqId);
        while (lastChatReqIds.size() > LAST_CHAT_REQ_IDS_MAX_SIZE) {
            // Pop one entry — any will do for memory bounding.
            var it = lastChatReqIds.keySet().iterator();
            if (it.hasNext()) {
                String victim = it.next();
                lastChatReqIds.remove(victim);
            } else break;
        }
    }

    /**
     * Look up the cached reply reqId for a group chat. Returns null when
     * the chatId isn't a known group (single chats, or no inbound seen
     * yet) — callers fall back to {@code aibot_send_msg}.
     * <p>
     * Package-private for test access.
     */
    String pickGroupReplyReqId(String chatId) {
        if (chatId == null || chatId.isBlank()) return null;
        return lastChatReqIds.get(chatId);
    }

    /**
     * 覆写 renderAndSend：如果有 processing_stream_id 则用 reply_stream 覆盖"思考中..."
     */
    @Override
    public void renderAndSend(String targetId, String content) {
        // 消费回复上下文（如果有的话）
        WeComReplyContext ctx = replyContexts.remove(targetId);
        // Stop keepalive before we send the real reply: avoids racing the next
        // refresh tick against this finish=true chunk on the same stream.
        // No-op if force-finish already evicted the entry.
        if (keepaliveScheduler != null && ctx != null && ctx.processingStreamId() != null) {
            keepaliveScheduler.stop(ctx.processingStreamId());
        }

        // Sniff `/api/v1/files/generated/{id}` URLs out of the agent's text
        // BEFORE rendering. Each hit gets upgraded to a native WeCom file
        // message via the chunked upload API; the URL in the text is replaced
        // with a "📎 filename" marker so the bubble doesn't repeat itself.
        // Without this, a generated docx/pptx would arrive as a markdown link
        // the user can't open inside WeCom (no public access + JWT required).
        List<UploadJob> uploadJobs = new ArrayList<>();
        String rewrittenContent = sniffGeneratedFiles(content, uploadJobs);

        // 先进行正常的内容渲染（过滤 thinking、分割长文本）
        boolean filterThinking = getConfigBoolean("filter_thinking", true);
        boolean filterToolMessages = getConfigBoolean("filter_tool_messages", true);
        String format = getConfigString("message_format", "auto");
        int maxLen = vip.mate.channel.ChannelMessageRenderer.PLATFORM_LIMITS.getOrDefault(getChannelType(), 2048);

        List<String> segments = vip.mate.channel.ChannelMessageRenderer.renderForChannel(
                rewrittenContent, filterThinking, filterToolMessages, format, maxLen);

        boolean first = true;
        for (String rawSegment : segments) {
            // WeCom 专用：格式化 Markdown 表格，统一列宽后在企微渲染正确
            String segment = formatMarkdownTables(rawSegment);
            // 第一条分段用 processingStreamId 覆盖"思考中..."
            if (first && ctx != null && ctx.processingStreamId() != null
                    && !ctx.processingStreamId().isBlank()) {
                replyStream(ctx.frameReqId(), ctx.processingStreamId(), segment, true);
                first = false;
            } else if (ctx != null && ctx.frameReqId() != null && !ctx.frameReqId().isBlank()) {
                // 后续分段绑定同一入站 frame 回复——群聊拒收主动推送，
                // 走 frame 回复在群聊/单聊都可达且保持顺序
                replyMarkdown(ctx.frameReqId(), segment);
            } else {
                sendMessage(targetId, segment);
            }
        }

        // Upload + dispatch any generated files we sniffed out. Done after the
        // text bubble so the order in the IM client mirrors the markdown:
        // explanatory text first, then the actual file card the user can tap.
        // Use the original frameReqId once for the first attachment (so it
        // rides the reply path) and active-push for the rest.
        if (!uploadJobs.isEmpty()) {
            String frameReqId = ctx != null ? ctx.frameReqId() : null;
            for (int i = 0; i < uploadJobs.size(); i++) {
                UploadJob job = uploadJobs.get(i);
                String mediaId = uploadMedia(job.bytes(), job.fileName(), job.mediaType());
                if (mediaId == null) {
                    log.warn("[wecom] Generated-file upload failed: {} ({} bytes)",
                            job.fileName(), job.bytes().length);
                    continue;
                }
                // Only the first attachment can use the inbound frameReqId
                // reply slot; subsequent attachments must go via active-push.
                String replyReqId = (i == 0) ? frameReqId : null;
                sendMediaMessage(targetId, mediaId, job.mediaType(), replyReqId);
            }
        }
    }

    /** Carries one to-be-uploaded generated file from {@link #sniffGeneratedFiles}. */
    private record UploadJob(byte[] bytes, String fileName, String mediaType) {}

    /**
     * URL pattern for the in-memory generated-file cache served by
     * {@code GeneratedFileController}. Lives in the channel layer because
     * each adapter rewrites the URL to a channel-native attachment.
     */
    private static final java.util.regex.Pattern GENERATED_URL_PATTERN =
            java.util.regex.Pattern.compile("(?:https?://[^/\\s)\\]]+)?/api/v1/files/generated/([a-zA-Z0-9-]+)");

    /**
     * Scan the agent's text for {@code /api/v1/files/generated/{id}} URLs;
     * for each hit, look up the cached bytes and queue an {@link UploadJob}.
     * Replaces the URL in the returned text with a "📎 filename" marker so
     * the bubble shows the file name without dangling an unopenable link.
     * Cache misses (entry expired or never existed) leave the URL untouched
     * — the user can still try clicking from the Web mirror's history view.
     */
    private String sniffGeneratedFiles(String text, List<UploadJob> jobs) {
        if (text == null || text.isEmpty() || generatedFileCache == null) return text;
        java.util.regex.Matcher m = GENERATED_URL_PATTERN.matcher(text);
        StringBuilder out = new StringBuilder();
        while (m.find()) {
            String id = m.group(1);
            var entry = generatedFileCache.get(id).orElse(null);
            if (entry != null) {
                String mediaType = isImageMime(entry.mimeType()) ? "image" : "file";
                jobs.add(new UploadJob(entry.bytes(), entry.filename(), mediaType));
                m.appendReplacement(out,
                        java.util.regex.Matcher.quoteReplacement("📎 " + entry.filename()));
            } else {
                // Cache miss has two real-world causes, both surfaced with
                // the same retry hint so the user just resubmits:
                //   1) LLM hallucinated a UUID-shaped string instead of
                //      calling a render tool — IDs like
                //      "a1b2c3d4-e5f6-7890-abcd-ef1234567890" with sequential
                //      hex are textbook fakes. {@code GeneratedFileCache}
                //      logs every real {@code put}, so its absence here is
                //      proof the file was never generated this turn.
                //   2) Cache entry expired (10-min TTL) before the IM
                //      client got around to clicking, or was wiped on
                //      JVM restart.
                // Without this replacement, users tap a markdown link that
                // returns 404 and the IM client saves the error body as a
                // ".docx" — they then "open" what is actually an HTML 404
                // page and report "file is corrupted".
                log.warn("[wecom] Generated-file cache miss for id={} — likely LLM skipped the render tool and wrote a fake URL (toolCallCount=0 in this turn). Bubble will show retry hint.",
                        id);
                m.appendReplacement(out, java.util.regex.Matcher.quoteReplacement(
                        "⚠️ 文件未真正生成（模型未调用文档生成工具），请重新发送请求"));
            }
        }
        m.appendTail(out);
        return out.toString();
    }

    private static boolean isImageMime(String mimeType) {
        return mimeType != null && mimeType.toLowerCase().startsWith("image/");
    }

    @Override
    public void sendContentParts(String targetId, List<MessageContentPart> parts) {
        WeComReplyContext ctx = replyContexts.remove(targetId);
        if (keepaliveScheduler != null && ctx != null && ctx.processingStreamId() != null) {
            keepaliveScheduler.stop(ctx.processingStreamId());
        }
        boolean sentText = false;
        boolean firstText = true;

        // Mirror renderAndSend's sniff so contentParts-mode replies also
        // upgrade /api/v1/files/generated/{id} URLs into native WeCom file
        // attachments. Text parts get the URL replaced with "📎 filename";
        // the actual bytes are queued for native upload after all parts are
        // dispatched (preserves the "text first, attachments after" ordering).
        List<UploadJob> uploadJobs = new ArrayList<>();

        for (MessageContentPart part : parts) {
            if (part == null) continue;
            try {
                switch (part.getType()) {
                    case "text" -> {
                        String txt = part.getText();
                        if (txt != null && !txt.isBlank()) {
                            String rewritten = sniffGeneratedFiles(txt, uploadJobs);
                            // 第一条文本用 processingStreamId 覆盖"思考中..."
                            if (firstText && ctx != null && ctx.processingStreamId() != null
                                    && !ctx.processingStreamId().isBlank()) {
                                replyStream(ctx.frameReqId(), ctx.processingStreamId(), rewritten, true);
                                firstText = false;
                            } else if (ctx != null && ctx.frameReqId() != null
                                    && !ctx.frameReqId().isBlank()) {
                                // 后续文本绑定同一入站 frame 回复（群聊拒收主动推送）
                                replyMarkdown(ctx.frameReqId(), rewritten);
                            } else {
                                sendMessage(targetId, rewritten);
                            }
                            sentText = true;
                        }
                    }
                    case "refusal" -> {
                        // 模型拒绝回复（如内容策略限制），以文本形式发送
                        String refusalText = part.getText();
                        if (refusalText != null && !refusalText.isBlank()) {
                            sendMessage(targetId, "⚠️ " + refusalText);
                            sentText = true;
                        }
                    }
                    case "image" -> sendImagePart(targetId, part, ctx);
                    case "audio" -> sendAudioPart(targetId, part, ctx);
                    case "file" -> sendFilePart(targetId, part, ctx);
                    default -> {
                        if (part.getText() != null) {
                            sendMessage(targetId, part.getText());
                            sentText = true;
                        }
                    }
                }
            } catch (Exception e) {
                log.error("[wecom] Failed to send content part ({}): {}", part.getType(), e.getMessage());
                sendFallbackText(targetId, part);
            }
        }

        // 如果没有发送文本但有处理指示器，清除"思考中..."
        if (!sentText && ctx != null && ctx.processingStreamId() != null
                && !ctx.processingStreamId().isBlank()) {
            try {
                replyStream(ctx.frameReqId(), ctx.processingStreamId(), "✅ Done", true);
            } catch (Exception e) {
                log.debug("[wecom] Failed to clear processing indicator: {}", e.getMessage());
            }
        }

        // After all parts are dispatched, upload any generated files we
        // sniffed out of text parts. First attachment rides the inbound
        // frameReqId reply slot; subsequent ones go via active-push. Mirror
        // the ordering used in renderAndSend so the user sees text bubble
        // first, then the actual file card.
        if (!uploadJobs.isEmpty()) {
            String frameReqId = ctx != null ? ctx.frameReqId() : null;
            for (int i = 0; i < uploadJobs.size(); i++) {
                UploadJob job = uploadJobs.get(i);
                String mediaId = uploadMedia(job.bytes(), job.fileName(), job.mediaType());
                if (mediaId == null) {
                    log.warn("[wecom] Generated-file upload failed: {} ({} bytes)",
                            job.fileName(), job.bytes().length);
                    continue;
                }
                String replyReqId = (i == 0) ? frameReqId : null;
                sendMediaMessage(targetId, mediaId, job.mediaType(), replyReqId);
            }
        }
    }

    /**
     * 发送图片部分：压缩 → 大小预校验 → 上传 → 发送 media_id
     */
    private void sendImagePart(String targetId, MessageContentPart part, WeComReplyContext ctx) {
        byte[] imageBytes = resolveFileBytes(part);
        if (imageBytes == null) {
            sendFallbackText(targetId, part);
            return;
        }

        String fileName = part.getFileName() != null ? part.getFileName() : "image.jpg";
        imageBytes = WeComImageCompressor.compressIfNeeded(imageBytes, fileName);

        WeComUploadLimitDecision decision = applyWeComUploadLimits(
                imageBytes.length, "image", part.getContentType());
        if (decision.rejected()) {
            log.warn("[wecom] Image upload rejected: {} ({} bytes) — {}",
                    fileName, imageBytes.length, decision.rejectReason());
            sendMessageToChat(targetId, "⚠️ " + decision.rejectReason());
            return;
        }

        String mediaId = uploadMedia(imageBytes, fileName, decision.finalMediaType());
        if (mediaId != null) {
            String frameReqId = ctx != null ? ctx.frameReqId() : null;
            sendMediaMessage(targetId, mediaId, decision.finalMediaType(), frameReqId);
            if (decision.downgraded()) {
                sendMessageToChat(targetId, "ℹ️ " + decision.downgradeNote());
            }
        } else {
            sendFallbackText(targetId, part);
        }
    }

    /**
     * 发送文件部分：大小预校验 → 上传 → 发送 media_id
     */
    private void sendFilePart(String targetId, MessageContentPart part, WeComReplyContext ctx) {
        byte[] fileBytes = resolveFileBytes(part);
        if (fileBytes == null) {
            sendFallbackText(targetId, part);
            return;
        }

        String fileName = part.getFileName() != null ? part.getFileName() : "file.bin";
        WeComUploadLimitDecision decision = applyWeComUploadLimits(
                fileBytes.length, "file", part.getContentType());
        if (decision.rejected()) {
            log.warn("[wecom] File upload rejected: {} ({} bytes) — {}",
                    fileName, fileBytes.length, decision.rejectReason());
            sendMessageToChat(targetId, "⚠️ " + decision.rejectReason());
            return;
        }

        String mediaId = uploadMedia(fileBytes, fileName, decision.finalMediaType());
        if (mediaId != null) {
            String frameReqId = ctx != null ? ctx.frameReqId() : null;
            sendMediaMessage(targetId, mediaId, decision.finalMediaType(), frameReqId);
        } else {
            sendFallbackText(targetId, part);
        }
    }

    /**
     * 发送音频部分：读取字节 → 大小+格式预校验 → 上传 → 发送。
     * <p>
     * WeCom 原生语音消息要求 AMR 格式 + ≤ 2 MB。预校验里非 AMR 或超 2 MB
     * 自动降级为 file（文件卡片，可点击下载播放）+ 给用户一行说明
     * 提示——避免用户期待"语音气泡"但收到一个 .mp3 文件却不知道为啥。
     */
    private void sendAudioPart(String targetId, MessageContentPart part, WeComReplyContext ctx) {
        byte[] audioBytes = resolveFileBytes(part);
        if (audioBytes == null) {
            sendFallbackText(targetId, part);
            return;
        }

        String fileName = part.getFileName() != null ? part.getFileName() : "voice_reply.mp3";
        boolean isAmr = fileName.toLowerCase().endsWith(".amr");
        // Pre-decide native voice vs file based on extension; the limits
        // checker can still downgrade voice→file if size exceeds 2MB.
        String requestedType = isAmr ? "voice" : "file";
        String contentTypeHint = part.getContentType();
        if (contentTypeHint == null && isAmr) contentTypeHint = "audio/amr";

        WeComUploadLimitDecision decision = applyWeComUploadLimits(
                audioBytes.length, requestedType, contentTypeHint);
        if (decision.rejected()) {
            log.warn("[wecom] Audio upload rejected: {} ({} bytes) — {}",
                    fileName, audioBytes.length, decision.rejectReason());
            sendMessageToChat(targetId, "⚠️ " + decision.rejectReason());
            return;
        }

        String mediaId = uploadMedia(audioBytes, fileName, decision.finalMediaType());
        if (mediaId != null) {
            String frameReqId = ctx != null ? ctx.frameReqId() : null;
            sendMediaMessage(targetId, mediaId, decision.finalMediaType(), frameReqId);
            log.info("[wecom] Audio sent as {}: {} ({}KB)",
                    decision.finalMediaType(), fileName, audioBytes.length / 1024);
            if (decision.downgraded()) {
                sendMessageToChat(targetId, "ℹ️ " + decision.downgradeNote());
            }
        } else {
            sendFallbackText(targetId, part);
        }
    }

    /**
     * 从 MessageContentPart 解析文件字节：优先本地路径，其次 URL 下载
     */
    private byte[] resolveFileBytes(MessageContentPart part) {
        // 本地路径
        if (part.getPath() != null && !part.getPath().isBlank()) {
            try {
                Path p = Path.of(part.getPath());
                if (Files.exists(p)) {
                    return Files.readAllBytes(p);
                }
            } catch (Exception e) {
                log.debug("[wecom] Failed to read local file {}: {}", part.getPath(), e.getMessage());
            }
        }
        // URL 下载
        String url = part.getFileUrl();
        if (url != null && !url.isBlank() && httpClient != null) {
            try {
                HttpRequest request = HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .timeout(Duration.ofSeconds(30))
                        .GET()
                        .build();
                HttpResponse<byte[]> response = httpClient.send(request, HttpResponse.BodyHandlers.ofByteArray());
                if (response.statusCode() == 200) {
                    return response.body();
                }
            } catch (Exception e) {
                log.debug("[wecom] Failed to download file from {}: {}", url, e.getMessage());
            }
        }
        return null;
    }

    /**
     * 降级发送：上传失败时退回 Markdown 文本
     */
    private void sendFallbackText(String targetId, MessageContentPart part) {
        switch (part.getType()) {
            case "image" -> {
                String url = part.getFileUrl() != null ? part.getFileUrl() : part.getMediaId();
                if (url != null) sendMessage(targetId, "![image](" + url + ")");
            }
            case "file" -> {
                String name = part.getFileName() != null ? part.getFileName() : "file";
                sendMessage(targetId, "[文件: " + name + "]");
            }
            case "audio" -> sendMessage(targetId, "[语音回复]");
            default -> { if (part.getText() != null) sendMessage(targetId, part.getText()); }
        }
    }

    // ==================== reply_stream 协议实现 ====================

    /**
     * 发送流式回复（reply_stream）
     * <p>
     * 通过 WebSocket 回复通道，使用相同 stream_id 可以覆盖更新已发送的消息。
     *
     * @param originalReqId 原始消息的 reqId（用于路由回复）
     * @param streamId      流式消息 ID（相同 ID 会覆盖之前的消息）
     * @param content       回复内容（支持 Markdown）
     * @param finish        是否结束流式消息
     */
    private void replyStream(String originalReqId, String streamId, String content, boolean finish) {
        replyStream(originalReqId, streamId, content, finish, null);
    }

    /**
     * Streaming reply with optional WeCom feedback id attached on the
     * final chunk (PR-2 hook installed in PR-0 so the protocol surface
     * is stable).
     *
     * <p>Per WeCom AI Bot protocol (verified against the langbot
     * reference implementation), {@code feedback.id} is only meaningful
     * on the chunk where {@code finish=true}. We accept the parameter
     * on every chunk for ergonomics but only emit the JSON field on
     * the finishing chunk to avoid surfacing it where the server
     * would ignore it.
     *
     * <p>Callers that don't need feedback collection pass {@code null}
     * for {@code feedbackId} (or use the legacy 4-arg overload).
     */
    private void replyStream(String originalReqId, String streamId, String content,
                             boolean finish, String feedbackId) {
        // PR-1 chunk dedup: skip the network round-trip when a non-final chunk
        // has the exact same content as the previous one for the same streamId.
        // Tool-call argument streaming in particular emits many redundant chunks
        // (each token re-flushes the partial JSON args) that would otherwise
        // flicker the IM client. The final chunk (finish=true) ALWAYS goes
        // through so WeCom closes the slot cleanly. RFC-32 §2.1.3.
        if (!finish) {
            String content_safe = content == null ? "" : content;
            String prev = streamLastContent.get(streamId);
            if (content_safe.equals(prev)) {
                return;
            }
            streamLastContent.put(streamId, content_safe);
        } else {
            // Final chunk consumes the dedup slot.
            streamLastContent.remove(streamId);
        }

        Map<String, Object> streamBody = new LinkedHashMap<>();
        streamBody.put("id", streamId);
        streamBody.put("finish", finish);
        streamBody.put("content", content);
        if (finish && feedbackId != null && !feedbackId.isBlank()) {
            streamBody.put("feedback", Map.of("id", feedbackId));
        }

        Map<String, Object> body = Map.of(
                "msgtype", "stream",
                "stream", streamBody
        );

        Map<String, Object> frame = Map.of(
                "cmd", CMD_RESPONSE,
                "headers", Map.of("req_id", originalReqId),
                "body", body
        );

        sendFrameWithAck(originalReqId, frame);
    }

    /**
     * Per-streamId last-content cache for chunk dedup. Bounded only by
     * the number of in-flight streams (a small handful in practice);
     * cleared on each finish=true chunk and on connection release.
     */
    private final ConcurrentHashMap<String, String> streamLastContent = new ConcurrentHashMap<>();

    /**
     * Send a markdown bubble bound to an inbound frame via
     * {@code aibot_respond_msg}.
     *
     * <p>Used for reply segments after the first when a live
     * {@link WeComReplyContext} exists: the platform rejects
     * {@code aibot_send_msg} in group chats, so segments pushed actively
     * would silently vanish there. Riding the inbound frame's reply slot
     * works in both group and single chats, and keeps segment ordering
     * behind the stream bubble (same per-reqId serial worker queue).
     *
     * <p>Failures are logged, not propagated — one bad segment must not
     * abort the remaining segments of a long reply.
     */
    private void replyMarkdown(String frameReqId, String content) {
        if (frameReqId == null || frameReqId.isBlank()
                || content == null || content.isBlank()) {
            return;
        }
        try {
            Map<String, Object> body = Map.of(
                    "msgtype", "markdown",
                    "markdown", Map.of("content", content)
            );
            Map<String, Object> frame = Map.of(
                    "cmd", CMD_RESPONSE,
                    "headers", Map.of("req_id", frameReqId),
                    "body", body
            );
            sendFrameWithAck(frameReqId, frame);
        } catch (Exception e) {
            log.error("[wecom] Failed to send reply segment via frame {}: {}",
                    frameReqId, e.getMessage());
        }
    }

    // ==================== 上传大小预校验（WeCom 平台限制） ====================

    /** WeCom hard limits — verified empirically; sources differ slightly. */
    static final long IMAGE_MAX_BYTES = 10L * 1024 * 1024;   // 10 MB
    static final long VIDEO_MAX_BYTES = 10L * 1024 * 1024;   // 10 MB
    static final long VOICE_MAX_BYTES =  2L * 1024 * 1024;   // 2 MB
    static final long FILE_MAX_BYTES  = 20L * 1024 * 1024;   // 20 MB (absolute cap)
    static final Set<String> VOICE_SUPPORTED_MIMES = Set.of("audio/amr");

    /**
     * Decision result for {@link #applyWeComUploadLimits}.
     *
     * @param finalMediaType  effective media type after auto-downgrade
     *                        (image / video / voice could become "file"
     *                        when oversized or unsupported)
     * @param rejected        true → don't upload at all; surface
     *                        {@code rejectReason} to the user instead
     * @param rejectReason    human-readable reason when {@code rejected}
     * @param downgraded      true → uploaded as {@code finalMediaType}
     *                        but caller should append a notice to the
     *                        bubble explaining why it's not native
     * @param downgradeNote   user-friendly note when {@code downgraded}
     */
    record WeComUploadLimitDecision(String finalMediaType, boolean rejected,
                                    String rejectReason, boolean downgraded,
                                    String downgradeNote) {
        static WeComUploadLimitDecision pass(String mediaType) {
            return new WeComUploadLimitDecision(mediaType, false, null, false, null);
        }
    }

    /**
     * Pre-validate an outbound upload against WeCom's per-media-type limits
     * and decide whether to upload as-is, downgrade to {@code file}, or
     * reject outright. Mirrors the strategy proven in production by
     * comparable Java/Python WeCom integrations:
     * <ul>
     *   <li>Files over 20 MB → reject — even {@code msgtype=file} can't
     *       carry them.</li>
     *   <li>Image &gt; 10 MB → downgrade to file (still delivers, just as
     *       a tappable card instead of an inline preview).</li>
     *   <li>Video &gt; 10 MB → downgrade to file.</li>
     *   <li>Voice with non-AMR mime type → downgrade to file (WeCom
     *       voice msgtype only accepts AMR).</li>
     *   <li>Voice in AMR but &gt; 2 MB → downgrade to file.</li>
     * </ul>
     * Without this layer, oversized uploads would chunk-upload for up to
     * a minute before the platform server rejected them at the finish
     * step, with the user seeing nothing arrive in their chat.
     * <p>
     * Package-private for unit-test access.
     */
    static WeComUploadLimitDecision applyWeComUploadLimits(long fileSize, String mediaType,
                                                            String contentType) {
        String type = mediaType == null ? "file" : mediaType.toLowerCase();
        String mime = contentType == null ? "" : contentType.toLowerCase().trim();

        if (fileSize > FILE_MAX_BYTES) {
            double mb = fileSize / 1024.0 / 1024.0;
            return new WeComUploadLimitDecision(
                    type, true,
                    String.format(java.util.Locale.ROOT,
                            "文件大小 %.2fMB 超过企业微信 20MB 上限，无法发送。请压缩或拆分后再发。", mb),
                    false, null);
        }
        if ("image".equals(type) && fileSize > IMAGE_MAX_BYTES) {
            double mb = fileSize / 1024.0 / 1024.0;
            return new WeComUploadLimitDecision(
                    "file", false, null,
                    true,
                    String.format(java.util.Locale.ROOT,
                            "图片 %.2fMB 超过 10MB 限制，已转为文件形式发送", mb));
        }
        if ("video".equals(type) && fileSize > VIDEO_MAX_BYTES) {
            double mb = fileSize / 1024.0 / 1024.0;
            return new WeComUploadLimitDecision(
                    "file", false, null,
                    true,
                    String.format(java.util.Locale.ROOT,
                            "视频 %.2fMB 超过 10MB 限制，已转为文件形式发送", mb));
        }
        if ("voice".equals(type)) {
            if (!mime.isEmpty() && !VOICE_SUPPORTED_MIMES.contains(mime)) {
                return new WeComUploadLimitDecision(
                        "file", false, null, true,
                        "语音格式 " + mime + " 不支持（企微仅支持 AMR），已转为文件形式发送");
            }
            if (fileSize > VOICE_MAX_BYTES) {
                double mb = fileSize / 1024.0 / 1024.0;
                return new WeComUploadLimitDecision(
                        "file", false, null,
                        true,
                        String.format(java.util.Locale.ROOT,
                                "语音 %.2fMB 超过 2MB 限制，已转为文件形式发送", mb));
            }
        }
        return WeComUploadLimitDecision.pass(type);
    }

    /**
     * 发送欢迎消息
     */
    private void replyWelcome(String reqId, String text) {
        Map<String, Object> body = Map.of(
                "msgtype", "text",
                "text", Map.of("content", text)
        );
        Map<String, Object> frame = Map.of(
                "cmd", CMD_RESPONSE_WELCOME,
                "headers", Map.of("req_id", reqId),
                "body", body
        );
        sendFrameWithAck(reqId, frame);
    }

    /**
     * Send an interactive template card (e.g. button_interaction approval card).
     *
     * <p>Wraps the card payload in {@code msgtype=template_card} and routes via
     * the existing reply channel ({@code aibot_respond_msg}, bound to the inbound
     * frame's req_id). Source-verified against aibot SDK
     * {@code client.py:188-207 reply_template_card}.
     *
     * <p>Caller must have an active reply context for {@code reqId} — i.e. the
     * card is sent in response to a previously received message frame, not as a
     * proactive group push (which WeCom rejects for AI Bots, see RFC-32 G-12).
     *
     * @param reqId       the original inbound frame's {@code headers.req_id}
     * @param templateCard the WeCom template_card payload (card_type / task_id /
     *                    main_title / button_list / etc.)
     */
    public void replyTemplateCard(String reqId, Map<String, Object> templateCard) {
        Map<String, Object> body = Map.of(
                "msgtype", "template_card",
                "template_card", templateCard
        );
        Map<String, Object> frame = Map.of(
                "cmd", CMD_RESPONSE,
                "headers", Map.of("req_id", reqId),
                "body", body
        );
        sendFrameWithAck(reqId, frame);
    }

    /**
     * Update a previously-posted template card. Used by inbound
     * {@code template_card_event} handlers (e.g. tool-guard approval) to swap
     * the {@code button_interaction} card for a {@code text_notice} resolved
     * state once the user clicks a button.
     *
     * <p><b>5-second window</b>: per the aibot protocol, the response must be
     * sent within 5s of receiving the {@code template_card_event} frame —
     * otherwise the update is silently dropped. The handler path therefore
     * has to validate identity + render the new card synchronously (fast
     * DB lookup + map construction, well under 1ms) and only enqueue the
     * inject-command on the agent thread afterwards.
     *
     * <p>Source-verified against aibot SDK {@code client.py:260-284 update_template_card}.
     *
     * @param eventReqId the inbound {@code template_card_event} frame's req_id
     *                  (DIFFERENT from the original card-posting req_id)
     * @param templateCard the replacement card payload (same task_id as the
     *                    original card)
     */
    public void updateTemplateCard(String eventReqId, Map<String, Object> templateCard) {
        Map<String, Object> body = Map.of(
                "response_type", "update_template_card",
                "template_card", templateCard
        );
        Map<String, Object> frame = Map.of(
                "cmd", CMD_RESPONSE_UPDATE,
                "headers", Map.of("req_id", eventReqId),
                "body", body
        );
        sendFrameWithAck(eventReqId, frame);
    }

    /**
     * URL for the resolved approval card's mandatory {@code card_action}
     * link (WeCom rejects {@code text_notice} cards without a type-1/2
     * action). Reads channel config {@code card_action_url}; public so the
     * card handler (different package) can pass it to the renderer.
     */
    public String resolvedCardActionUrl() {
        return getConfigString("card_action_url", ToolGuardCardRenderer.DEFAULT_CARD_ACTION_URL);
    }

    /**
     * Keepalive refresh tick (called by {@link WeComKeepaliveScheduler}
     * every 20s). Sends {@code finish=false} on the existing stream so
     * WeCom's server-side TTL counter resets.
     *
     * <p>Public so the scheduler in this same package can invoke it; the
     * scheduler is itself a singleton bean and outside callers should
     * not be triggering refresh ticks.
     */
    public void replyStreamRefreshForKeepalive(String reqId, String streamId, String text) {
        // Bypass chunk dedup: a refresh whose text equals the previous chunk
        // (e.g. the static placeholder when no progress supplier is attached)
        // would otherwise be swallowed by replyStream's dedup guard — no
        // network frame goes out, the server-side TTL is NOT reset, and the
        // slot dies exactly the way this keepalive exists to prevent. Clearing
        // the dedup slot first guarantees every tick produces a real frame.
        streamLastContent.remove(streamId);
        replyStream(reqId, streamId, text, false);
    }

    /**
     * Force-finish the keepalive stream (180s ceiling reached). Sends
     * {@code finish=true} so WeCom closes the slot cleanly. The
     * scheduler immediately follows this with
     * {@link #invalidateReplyContext} so the eventual real reply takes
     * the fresh-stream path.
     */
    public void replyStreamFinishForKeepalive(String reqId, String streamId, String text) {
        replyStream(reqId, streamId, text, true);
    }

    /**
     * Drop the {@link WeComReplyContext} entry for a {@code targetId}
     * if (and only if) its current {@code processingStreamId} matches
     * the supplied {@code streamId}. Idempotent and safe to call from
     * any thread.
     *
     * <p>Used by {@link WeComKeepaliveScheduler} after force-finishing
     * a stuck stream — RFC-32 §2.1.2 invariant: the next
     * {@link #renderAndSend} call must NOT reuse a finished
     * {@code processingStreamId}.
     *
     * <p>The match-and-remove uses {@link
     * java.util.concurrent.ConcurrentHashMap#computeIfPresent} so a
     * concurrent {@code renderAndSend} that already swapped the
     * context for a fresh stream is left untouched.
     */
    public void invalidateReplyContext(String targetId, String streamId) {
        if (targetId == null || streamId == null) return;
        replyContexts.computeIfPresent(targetId, (k, ctx) -> {
            if (streamId.equals(ctx.processingStreamId())) {
                log.debug("[wecom] invalidateReplyContext: cleared {} (stream={})", targetId, streamId);
                return null;  // remove entry
            }
            return ctx;
        });
    }

    /**
     * Route a synthetic message into the standard
     * {@link ChannelMessageRouter} pipeline as if the user had typed it.
     *
     * <p>Bypasses {@link AbstractChannelAdapter#onMessage} so the
     * pre-flight bot-prefix filter and access-control check are SKIPPED
     * — appropriate for events that already represent an explicit user
     * intent (e.g. a button click on an approval card). The router still
     * runs its own approval validation in
     * {@link ChannelMessageRouter#processMessage}, so the identity check
     * for "only original requester can approve" still fires.
     *
     * <p>Currently used by tool-guard card handler. Package-private (no
     * modifier) so only sibling classes in the wecom package can inject;
     * external code must go through {@link ChannelAdapter#onMessage}.
     */
    public void injectSyntheticMessage(ChannelMessage message) {
        messageRouter.enqueue(message, this, channelEntity);
    }

    // ==================== 媒体上传协议 ====================

    /**
     * 通过 WebSocket 分块上传文件到企业微信
     * <p>
     * 三阶段协议：
     *   1. Init: 发送文件元数据 → 获得 upload_id
     *   2. Chunks: 发送 base64 编码的 512KB 分块
     *   3. Finish: 完成上传 → 获得 media_id
     *
     * @param fileBytes  文件内容
     * @param fileName   文件名
     * @param mediaType  媒体类型："image" / "file" / "voice" / "video"
     * @return media_id，失败返回 null
     */
    @SuppressWarnings("unchecked")
    private String uploadMedia(byte[] fileBytes, String fileName, String mediaType) {
        if (webSocket == null || fileBytes == null || fileBytes.length == 0) {
            return null;
        }
        // Pre-flight chunk count guard. WeCom's chunked upload protocol caps
        // out near 100 chunks (~50 MB at 512 KB / chunk) but we already
        // reject anything over FILE_MAX_BYTES (20 MB ≈ 40 chunks) before
        // reaching here, so this is a defence-in-depth log line rather
        // than a routine path.
        int totalChunks = (int) Math.ceil((double) fileBytes.length / UPLOAD_CHUNK_SIZE);
        if (totalChunks > 100) {
            log.warn("[wecom] Upload would require {} chunks (>100 cap), rejecting: {} ({} bytes)",
                    totalChunks, fileName, fileBytes.length);
            return null;
        }

        boolean acquired = false;
        try {
            acquired = uploadLock.tryAcquire(60, TimeUnit.SECONDS);
            if (!acquired) {
                log.warn("[wecom] Upload lock timeout, another upload may be in progress");
                return null;
            }

            String md5 = md5Hex(fileBytes);

            // Phase 1: Init
            String initReqId = generateReqId(CMD_UPLOAD_INIT);
            Map<String, Object> initBody = new LinkedHashMap<>();
            initBody.put("type", mediaType);
            initBody.put("filename", fileName);
            initBody.put("total_size", fileBytes.length);
            initBody.put("total_chunks", totalChunks);
            initBody.put("md5", md5);

            Map<String, Object> initFrame = Map.of(
                    "cmd", CMD_UPLOAD_INIT,
                    "headers", Map.of("req_id", initReqId),
                    "body", initBody
            );
            Map<String, Object> initAck = sendFrameWithAckBlocking(initReqId, initFrame, UPLOAD_ACK_TIMEOUT_MS);
            Map<String, Object> initAckBody = (Map<String, Object>) initAck.getOrDefault("body", Map.of());
            String uploadId = (String) initAckBody.getOrDefault("upload_id", "");
            if (uploadId.isBlank()) {
                log.error("[wecom] Upload init failed: empty upload_id");
                return null;
            }
            log.debug("[wecom] Upload init: upload_id={}, chunks={}", uploadId.substring(0, Math.min(20, uploadId.length())), totalChunks);

            // Phase 2: Chunks
            for (int i = 0; i < totalChunks; i++) {
                int offset = i * UPLOAD_CHUNK_SIZE;
                int length = Math.min(UPLOAD_CHUNK_SIZE, fileBytes.length - offset);
                byte[] chunk = Arrays.copyOfRange(fileBytes, offset, offset + length);
                String base64Data = Base64.getEncoder().encodeToString(chunk);

                String chunkReqId = generateReqId(CMD_UPLOAD_CHUNK);
                Map<String, Object> chunkBody = new LinkedHashMap<>();
                chunkBody.put("upload_id", uploadId);
                chunkBody.put("chunk_index", i);
                // Field name MUST be "base64_data" — the WeCom AI bot upload
                // server reads the chunk bytes from this exact key. A previous
                // version sent "data" which the server silently dropped, so
                // metadata (filename/size) committed but the bytes never made
                // it to storage. Receivers then saw the file with the right
                // name/size but couldn't open it ("文件已损坏").
                chunkBody.put("base64_data", base64Data);

                Map<String, Object> chunkFrame = Map.of(
                        "cmd", CMD_UPLOAD_CHUNK,
                        "headers", Map.of("req_id", chunkReqId),
                        "body", chunkBody
                );
                sendFrameWithAckBlocking(chunkReqId, chunkFrame, UPLOAD_ACK_TIMEOUT_MS);
            }

            // Phase 3: Finish
            String finishReqId = generateReqId(CMD_UPLOAD_FINISH);
            Map<String, Object> finishFrame = Map.of(
                    "cmd", CMD_UPLOAD_FINISH,
                    "headers", Map.of("req_id", finishReqId),
                    "body", Map.of("upload_id", uploadId)
            );
            Map<String, Object> finishAck = sendFrameWithAckBlocking(finishReqId, finishFrame, UPLOAD_ACK_TIMEOUT_MS);
            Map<String, Object> finishAckBody = (Map<String, Object>) finishAck.getOrDefault("body", Map.of());
            String mediaId = (String) finishAckBody.getOrDefault("media_id", "");
            if (mediaId.isBlank()) {
                log.error("[wecom] Upload finish failed: empty media_id");
                return null;
            }

            log.info("[wecom] Upload completed: media_id={}, type={}, size={}KB",
                    mediaId.substring(0, Math.min(20, mediaId.length())), mediaType, fileBytes.length / 1024);
            return mediaId;

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("[wecom] Upload interrupted");
            return null;
        } catch (Exception e) {
            log.error("[wecom] Upload failed for {}: {}", fileName, e.getMessage(), e);
            return null;
        } finally {
            if (acquired) {
                uploadLock.release();
            }
        }
    }

    /**
     * 发送帧并阻塞等待 ACK 响应（用于上传协议需要读取返回值的场景）
     *
     * @return ACK 帧 Map
     * @throws RuntimeException 超时或错误
     */
    private Map<String, Object> sendFrameWithAckBlocking(String reqId, Map<String, Object> frame, long timeoutMs) {
        CompletableFuture<Map<String, Object>> ackFuture = new CompletableFuture<>();
        pendingAcks.put(reqId, ackFuture);
        sendFrame(frame);
        try {
            return ackFuture.get(timeoutMs, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            pendingAcks.remove(reqId);
            throw new RuntimeException("Upload ACK timeout for reqId=" + reqId, e);
        } catch (ExecutionException e) {
            throw new RuntimeException("Upload ACK error for reqId=" + reqId, e.getCause());
        } catch (InterruptedException e) {
            pendingAcks.remove(reqId);
            Thread.currentThread().interrupt();
            throw new RuntimeException("Upload interrupted", e);
        }
    }

    /**
     * 使用 media_id 发送媒体消息
     *
     * @param targetId   目标 ID（userId 或 chatId）
     * @param mediaId    上传后获得的 media_id
     * @param mediaType  媒体类型（image / file / voice / video）
     * @param frameReqId 原始消息 frameReqId（非 null 时通过 reply 路径，null 时通过主动推送）
     */
    private void sendMediaMessage(String targetId, String mediaId, String mediaType, String frameReqId) {
        Map<String, Object> mediaBody = new LinkedHashMap<>();
        mediaBody.put("msgtype", mediaType);
        mediaBody.put(mediaType, Map.of("media_id", mediaId));

        if (frameReqId != null && !frameReqId.isBlank()) {
            // Caller has an explicit inbound frameReqId (the message we're
            // replying to is "now") — use that reply slot directly.
            Map<String, Object> frame = Map.of(
                    "cmd", CMD_RESPONSE,
                    "headers", Map.of("req_id", frameReqId),
                    "body", mediaBody
            );
            sendFrameWithAck(frameReqId, frame);
        } else {
            // Proactive push (cron summary, async-task forward, etc.) —
            // delegate to sendOutboundFrame so groups ride the cached
            // reqId via aibot_respond_msg (the AI bot platform rejects
            // aibot_send_msg in groups). Single chats fall through to
            // aibot_send_msg as before.
            sendOutboundFrame(targetId, mediaBody);
        }
    }

    // ==================== Markdown 表格格式化 ====================

    /**
     * 格式化 GFM Markdown 表格，使其在企业微信中对齐显示。
     * <p>
     * 企业微信要求表格列宽一致才能正确渲染。此方法解析表格，
     * 计算每列最大宽度，统一填充空格对齐。
     * 代码块内的表格不做处理。
     */
    static String formatMarkdownTables(String text) {
        if (text == null || !text.contains("|")) return text;

        String[] lines = text.split("\n", -1);
        List<String> result = new ArrayList<>();
        int i = 0;
        boolean inCodeFence = false;

        while (i < lines.length) {
            String line = lines[i];
            String stripped = line.strip();

            // 跟踪代码块（``` 内的内容不处理）
            if (stripped.startsWith("```")) {
                inCodeFence = !inCodeFence;
                result.add(line);
                i++;
                continue;
            }
            if (inCodeFence) {
                result.add(line);
                i++;
                continue;
            }

            // 检测表格开始（含 | 的行）
            if (line.contains("|")) {
                List<String> tableLines = new ArrayList<>();
                while (i < lines.length && lines[i].contains("|")
                        && !lines[i].strip().startsWith("```")) {
                    tableLines.add(lines[i]);
                    i++;
                }
                if (!tableLines.isEmpty()) {
                    result.addAll(formatTable(tableLines));
                }
                continue;
            }

            result.add(line);
            i++;
        }
        return String.join("\n", result);
    }

    /**
     * 格式化单个 Markdown 表格
     */
    private static List<String> formatTable(List<String> lines) {
        if (lines.isEmpty()) return lines;

        // 检测第二行是否为分隔行（只含 -, :, |, 空格）
        boolean hasSeparator = lines.size() >= 2
                && lines.get(1).strip().matches("[\\s\\-:|]+");

        // 解析单元格（跳过分隔行，后面会重建）
        List<List<String>> rows = new ArrayList<>();
        for (int idx = 0; idx < lines.size(); idx++) {
            if (hasSeparator && idx == 1) continue;
            String[] cells = lines.get(idx).split("\\|", -1);
            List<String> trimmed = new ArrayList<>();
            for (String cell : cells) {
                trimmed.add(cell.strip());
            }
            // 去掉首尾空元素（由前导/尾随 | 产生）
            if (!trimmed.isEmpty() && trimmed.getFirst().isEmpty()) trimmed.removeFirst();
            if (!trimmed.isEmpty() && trimmed.getLast().isEmpty()) trimmed.removeLast();
            if (!trimmed.isEmpty()) rows.add(trimmed);
        }

        if (rows.isEmpty()) return lines;

        // 计算每列最大宽度
        int colCount = rows.stream().mapToInt(List::size).max().orElse(0);
        int[] widths = new int[colCount];
        for (List<String> row : rows) {
            for (int j = 0; j < colCount; j++) {
                String cell = j < row.size() ? row.get(j) : "";
                widths[j] = Math.max(widths[j], cell.length());
            }
        }

        // 构建格式化结果
        List<String> formatted = new ArrayList<>();
        for (int idx = 0; idx < rows.size(); idx++) {
            List<String> row = rows.get(idx);
            StringBuilder sb = new StringBuilder("| ");
            for (int j = 0; j < colCount; j++) {
                String cell = j < row.size() ? row.get(j) : "";
                sb.append(padRight(cell, widths[j]));
                if (j < colCount - 1) sb.append(" | ");
            }
            sb.append(" |");
            formatted.add(sb.toString());

            // 头部行后插入分隔行
            if (idx == 0) {
                StringBuilder sep = new StringBuilder("| ");
                for (int j = 0; j < colCount; j++) {
                    sep.append("-".repeat(Math.max(3, widths[j])));
                    if (j < colCount - 1) sep.append(" | ");
                }
                sep.append(" |");
                formatted.add(sep.toString());
            }
        }
        return formatted;
    }

    private static String padRight(String s, int width) {
        if (s.length() >= width) return s;
        return s + " ".repeat(width - s.length());
    }

    // ==================== 帧发送基础设施 ====================

    /**
     * 发送 WebSocket 帧（fire and forget）
     */
    /**
     * Visible to package-level tests (RFC-32 §3.0 S-1/S-2 stress) so a
     * test subclass can override frame dispatch without monkey-patching
     * the private WS field. Production callers stay within this class.
     */
    void sendFrame(Map<String, Object> frame) {
        WebSocket ws = this.webSocket;
        if (ws == null) {
            log.warn("[wecom] WebSocket not connected, cannot send frame");
            return;
        }
        try {
            String json = objectMapper.writeValueAsString(frame);
            ws.sendText(json, true);
        } catch (Exception e) {
            log.error("[wecom] Failed to send frame: {}", e.getMessage(), e);
        }
    }

    /**
     * Serially send a frame on the WS and wait (in a per-reqId worker)
     * for its ACK. Same {@code reqId} messages are guaranteed to be
     * dispatched in arrival order: the worker reads from the queue,
     * registers {@link #pendingAcks} only after the previous ACK
     * settled, sends, then blocks on the future until the ACK arrives
     * or {@link #REPLY_ACK_TIMEOUT_MS} elapses.
     *
     * <p>RFC-32 §2.4.1 a-2 / R-5/R-6/R-7 invariants this implements:
     * <ul>
     *   <li><b>Lifecycle gate</b>: outer + inner check on
     *       {@link #replyQueueAccepting}. If closed, the returned
     *       future is fast-failed with {@link IllegalStateException}
     *       — never registered, never enqueued.</li>
     *   <li><b>TOCTOU between idle-close and late-offer</b>: the
     *       offer happens INSIDE the {@code compute} lambda, sharing
     *       the bin lock with the worker's own {@code compute}-based
     *       idle-close. They serialize cleanly.</li>
     *   <li><b>Executor null/shutdown defense</b>: re-checked inside
     *       compute; submit wrapped in try/catch for
     *       {@link RejectedExecutionException}.</li>
     *   <li><b>offered[] flag</b>: any path that doesn't successfully
     *       offer falls through to {@code completeExceptionally}; no
     *       caller future ever hangs forever.</li>
     * </ul>
     *
     * <p>Returns the ACK future for callers that want to chain on
     * success (e.g. extract {@code body} fields from the ACK frame).
     * Existing fire-and-forget callers can ignore the return value;
     * timeout/error handling lives inside the worker.
     */
    @SuppressWarnings("UnusedReturnValue")
    private CompletableFuture<Map<String, Object>> sendFrameWithAck(String reqId, Map<String, Object> frame) {
        CompletableFuture<Map<String, Object>> ackFuture = new CompletableFuture<>();

        // ---- Outer lifecycle check (fast-fail, no allocations beyond the future) ----
        if (!replyQueueAccepting.get()) {
            ackFuture.completeExceptionally(
                    new IllegalStateException("WeCom channel not accepting reply tasks (lifecycle gate closed)"));
            return ackFuture;
        }

        ReplyTask task = new ReplyTask(frame, ackFuture);
        boolean[] offered = {false};

        try {
            replyQueues.compute(reqId, (k, existing) -> {
                // ---- Inner lifecycle check: gate may have flipped between outer check and bin lock ----
                if (!replyQueueAccepting.get()) {
                    return existing;  // do NOT modify map; offered[0] stays false → fail below
                }

                // ---- Reuse open state if present ----
                if (existing != null && !existing.closed().get()) {
                    existing.queue().offer(task);
                    offered[0] = true;
                    return existing;
                }

                // ---- Need to start a fresh state. Defend against late-shutdown ----
                ExecutorService exec = this.replyExecutor;
                if (exec == null || exec.isShutdown()) {
                    return existing;  // executor torn down by release; fail below
                }

                ReplyQueueState fresh = ReplyQueueState.fresh();
                fresh.queue().offer(task);
                try {
                    exec.submit(() -> reqIdWorker(k, fresh));
                    offered[0] = true;
                    return fresh;
                } catch (RejectedExecutionException ree) {
                    // Race with shutdownNow between isShutdown check and submit
                    return existing;  // do not write fresh; fail below
                }
            });
        } catch (Exception e) {
            // compute lambda surfaced something we didn't expect — never let this leak as
            // a hung future
            ackFuture.completeExceptionally(e);
            return ackFuture;
        }

        // ---- Final guarantee: any path that didn't offer must fail-fast ----
        if (!offered[0] && !ackFuture.isDone()) {
            ackFuture.completeExceptionally(
                    new IllegalStateException("WeCom channel transitioning, reply task rejected"));
        }
        return ackFuture;
    }

    // ==================== 媒体文件下载与 AES 解密 ====================

    /**
     * Conversation id for inbound media: matches the format
     * {@code ChannelMessageRouter.buildConversationId} produces from the same
     * (channelType, chatId, senderId) tuple. Pre-computing it here lets the
     * media-download helper write into the right per-conversation directory
     * <em>before</em> the {@link ChannelMessage} is built.
     *
     * <p>The router's identifier is {@code chatId} when present (group context)
     * and {@code senderId} otherwise (1:1) — there is no {@code group:} infix
     * because the router doesn't add one. An earlier divergence here ({@code
     * "wecom:group:" + chatId}) persisted media at
     * {@code data/chat-uploads/wecom:group:{chatId}/} and stamped that path
     * onto {@link MessageContentPart#getFileUrl()}, but the message's actual
     * conversationId in {@code mate_conversation} was {@code wecom:{chatId}}
     * (no {@code group:} infix). The {@code /api/v1/chat/files/...} endpoint
     * then ran {@code isConversationOwner("wecom:group:...")}, found no
     * matching row, returned 403, and the IM client rendered every
     * group-quoted image as a broken icon.
     */
    private static String inboundConversationId(String senderId, String chatId, String chatType,
                                                Long channelId) {
        boolean isGroup = "group".equals(chatType);
        String identifier = isGroup ? chatId : senderId;
        // Mirror ChannelMessageRouter#buildConversationId: scope the id by channelId so the
        // same sender on two workspaces' wecom channels never shares a conversation. channelId
        // is the ChannelEntity primary key; a null (unreachable for a persisted channel) keeps
        // the legacy two-segment form so nothing NPEs.
        return channelId != null ? "wecom:" + channelId + ":" + identifier : "wecom:" + identifier;
    }

    // ==================== 引用消息（quote）解析 ====================

    /**
     * Quoted-message extraction result: a human-readable prefix string the
     * agent prompt prepends, plus any media (image / file) that was quoted
     * and needs to be available as a content part. Either field may be
     * empty; {@link #isEmpty()} returns true only when both are.
     */
    private record QuoteContext(String prefix, List<MessageContentPart> attachedParts) {
        boolean isEmpty() {
            return (prefix == null || prefix.isBlank()) && attachedParts.isEmpty();
        }
    }

    /**
     * Parse the {@code body.quote} field of an inbound WeCom AI Bot frame.
     * Quote payloads sit alongside the new message at body level —
     * independent of the outer {@code msgtype} — and may themselves carry
     * any of text / voice / image / file / mixed. We flatten everything
     * into:
     * <ul>
     *   <li>a single {@code prefix} string of the form
     *       {@code "[引用消息: <flattened summary>]\n"} that prepends to the
     *       agent's user prompt</li>
     *   <li>a list of {@link MessageContentPart}s for any quoted media so
     *       the vision / document tools can analyse the actually-quoted
     *       image or PDF, not just see "[图片]" in the prefix</li>
     * </ul>
     * Returns null when {@code body.quote} is absent / empty / malformed —
     * the caller treats that the same as "no quote context".
     */
    private QuoteContext extractQuoteContext(Map<String, Object> body, String msgId,
                                              String senderId, String chatId, String chatType) {
        Object raw = body.get("quote");
        if (!(raw instanceof Map<?, ?> map)) return null;
        @SuppressWarnings("unchecked")
        Map<String, Object> quote = (Map<String, Object>) map;
        String quoteType = (String) quote.getOrDefault("msgtype", "");
        if (quoteType == null || quoteType.isBlank()) return null;

        // Flatten: a "mixed" quote nests its own msg_item array; single-type
        // quotes act as a one-element list of themselves.
        List<Map<String, Object>> items;
        if ("mixed".equals(quoteType)) {
            @SuppressWarnings("unchecked")
            Map<String, Object> mixed = (Map<String, Object>) quote.getOrDefault("mixed", Map.of());
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> mi = (List<Map<String, Object>>) mixed.getOrDefault("msg_item", List.of());
            items = mi;
        } else {
            items = List.of(quote);
        }

        String inboundConvId = inboundConversationId(senderId, chatId, chatType, channelEntity != null ? channelEntity.getId() : null);
        StringBuilder summary = new StringBuilder();
        List<MessageContentPart> attached = new ArrayList<>();

        for (Map<String, Object> item : items) {
            String itemType = (String) item.getOrDefault("msgtype", "");
            switch (itemType == null ? "" : itemType) {
                case "text" -> {
                    @SuppressWarnings("unchecked")
                    Map<String, Object> t = (Map<String, Object>) item.getOrDefault("text", Map.of());
                    String content = ((String) t.getOrDefault("content", "")).trim();
                    if (!content.isBlank()) {
                        appendQuoteSummary(summary, content);
                    }
                }
                case "voice" -> {
                    @SuppressWarnings("unchecked")
                    Map<String, Object> v = (Map<String, Object>) item.getOrDefault("voice", Map.of());
                    String asr = ((String) v.getOrDefault("content", "")).trim();
                    if (!asr.isBlank()) {
                        appendQuoteSummary(summary, "[语音] " + asr);
                    } else {
                        appendQuoteSummary(summary, "[语音消息]");
                    }
                }
                case "image" -> {
                    @SuppressWarnings("unchecked")
                    Map<String, Object> img = (Map<String, Object>) item.getOrDefault("image", Map.of());
                    String url = (String) img.getOrDefault("url", "");
                    String aesKey = (String) img.getOrDefault("aeskey", "");
                    if (!url.isBlank()) {
                        attached.add(buildInboundImagePart(url, aesKey, msgId,
                                "quoted_image.jpg", inboundConvId));
                    }
                    appendQuoteSummary(summary, "[图片]");
                }
                case "file" -> {
                    @SuppressWarnings("unchecked")
                    Map<String, Object> f = (Map<String, Object>) item.getOrDefault("file", Map.of());
                    String url = (String) f.getOrDefault("url", "");
                    String aesKey = (String) f.getOrDefault("aeskey", "");
                    String filename = (String) f.getOrDefault("filename",
                            f.getOrDefault("file_name", f.getOrDefault("name", "file.bin")));
                    if (!url.isBlank()) {
                        MessageContentPart part = buildInboundFilePart(url, aesKey, msgId,
                                filename, inboundConvId);
                        attached.add(part);
                        if (part.getFileName() != null && !part.getFileName().isBlank()) {
                            filename = part.getFileName();
                        }
                    }
                    appendQuoteSummary(summary, "[文件: " + filename + "]");
                }
                default -> {
                    // Unknown quote sub-type — surface the type tag so the
                    // agent knows something was quoted even if we can't
                    // unpack it.
                    if (itemType != null && !itemType.isBlank()) {
                        appendQuoteSummary(summary, "[" + itemType + "]");
                    }
                }
            }
        }

        if (summary.length() == 0 && attached.isEmpty()) {
            return null;
        }
        String prefix = "[引用消息: " + summary + "]\n";
        return new QuoteContext(prefix, attached);
    }

    private static void appendQuoteSummary(StringBuilder summary, String fragment) {
        if (summary.length() > 0) summary.append(' ');
        summary.append(fragment);
    }

    // ==================== appmsg 解析（PDF/Word/Excel/链接/小程序）====================

    /**
     * Decoded {@code msgtype=appmsg} payload — text marker the agent reads
     * + any attached media parts. Returned by {@link #extractAppmsgContent}
     * so the inbound switch can splice it into {@code textContent} and
     * {@code contentParts} uniformly.
     */
    record AppmsgContent(String text, List<MessageContentPart> attachedParts) {}

    /**
     * Parse a {@code msgtype=appmsg} body into a text marker + media parts.
     * <p>
     * Supports four variants observed in the WeCom platform:
     * <ul>
     *   <li>{@code appmsg.file} — forwarded PDF / Word / Excel; reuses
     *       {@link #buildInboundFilePart} so magic-byte sniff + ZIP
     *       refinement work identically to plain {@code msgtype=file}</li>
     *   <li>{@code appmsg.image} — forwarded image card</li>
     *   <li>{@code appmsg.miniprogram} — miniprogram card; surface the
     *       title so the agent at least knows what was shared</li>
     *   <li>{@code appmsg.url} — public-account article / external link;
     *       flatten title + description + URL into text</li>
     * </ul>
     * Unknown variants fall back to a {@code [appmsg]} marker so the
     * agent isn't completely blind.
     * <p>
     * Package-private for unit-test access.
     */
    AppmsgContent extractAppmsgContent(Map<String, Object> body, String msgId,
                                        String senderId, String chatId, String chatType) {
        @SuppressWarnings("unchecked")
        Map<String, Object> appmsg = (Map<String, Object>) body.getOrDefault("appmsg", Map.of());
        String title = ((String) appmsg.getOrDefault("title", "")).trim();
        String desc  = ((String) appmsg.getOrDefault("description", "")).trim();
        String linkUrl = ((String) appmsg.getOrDefault("url", "")).trim();
        String inboundConvId = inboundConversationId(senderId, chatId, chatType, channelEntity != null ? channelEntity.getId() : null);

        Object fileObj = appmsg.get("file");
        Object imageObj = appmsg.get("image");
        Object miniObj = appmsg.get("miniprogram");

        List<MessageContentPart> attached = new ArrayList<>();
        StringBuilder text = new StringBuilder();

        if (fileObj instanceof Map<?, ?> fileMap) {
            @SuppressWarnings("unchecked")
            Map<String, Object> fileBody = (Map<String, Object>) fileMap;
            String fileUrl = (String) fileBody.getOrDefault("url", "");
            String aesKey = (String) fileBody.getOrDefault("aeskey", "");
            String filename = (String) fileBody.getOrDefault("filename",
                    fileBody.getOrDefault("file_name",
                            fileBody.getOrDefault("name",
                                    title.isBlank() ? "file.bin" : title)));
            if (!fileUrl.isBlank()) {
                MessageContentPart filePart = buildInboundFilePart(
                        fileUrl, aesKey, msgId, filename, inboundConvId);
                attached.add(filePart);
                if (filePart.getFileName() != null && !filePart.getFileName().isBlank()) {
                    filename = filePart.getFileName();
                }
            }
            text.append("[文件: ").append(filename).append("]");
        } else if (imageObj instanceof Map<?, ?> imgMap) {
            @SuppressWarnings("unchecked")
            Map<String, Object> imgBody = (Map<String, Object>) imgMap;
            String imgUrl = (String) imgBody.getOrDefault("url", "");
            String aesKey = (String) imgBody.getOrDefault("aeskey", "");
            if (!imgUrl.isBlank()) {
                attached.add(buildInboundImagePart(imgUrl, aesKey, msgId,
                        "appmsg_image.jpg", inboundConvId));
            }
            text.append("[图片").append(title.isBlank() ? "" : ": " + title).append("]");
        } else if (miniObj instanceof Map<?, ?> miniMap) {
            @SuppressWarnings("unchecked")
            Map<String, Object> mini = (Map<String, Object>) miniMap;
            String miniTitle = ((String) mini.getOrDefault("title",
                    title.isBlank() ? "未命名小程序" : title)).trim();
            text.append("[小程序: ").append(miniTitle).append("]");
        } else if (!linkUrl.isBlank()) {
            text.append("[链接]");
            if (!title.isBlank()) text.append(' ').append(title);
            if (!desc.isBlank()) text.append('\n').append(desc);
            text.append('\n').append(linkUrl);
            // WeChat public-account articles (mp.weixin.qq.com) ship the
            // body behind a captcha-gated SSR page — the URL is opaque to
            // any LLM tool. Without this hint the model invents plausible
            // content from the title alone (observed: "本文讲了三个要点…"
            // hallucinations). The hint nudges the agent to ask the user
            // to paste the article text instead of guessing.
            if (isPublicAccountArticle(linkUrl)) {
                text.append('\n').append(PUBLIC_ACCOUNT_ARTICLE_HINT);
            }
        } else if (!title.isBlank()) {
            text.append("[appmsg: ").append(title).append("]");
        } else {
            text.append("[appmsg]");
        }
        return new AppmsgContent(text.toString(), attached);
    }

    /**
     * Hint appended to forwarded WeChat public-account articles. Worded as
     * a directive for the agent (not a user-visible message) — the agent's
     * reasoning prompt picks it up alongside the link itself, so the model
     * sees the directive in-band with the share.
     */
    static final String PUBLIC_ACCOUNT_ARTICLE_HINT =
            "（提示：该链接为公众号文章，正文需要用户在微信内打开后复制粘贴，"
            + "请优先请用户粘贴正文，不要凭标题猜测内容。）";

    /**
     * Public-account article links are hosted on {@code mp.weixin.qq.com}.
     * Compared to a generic URL host check, this is intentionally narrow —
     * other Tencent properties (e.g. video.qq.com) don't share the same
     * "title-only, body needs paste" property and shouldn't get the hint.
     */
    static boolean isPublicAccountArticle(String url) {
        if (url == null) return false;
        String lower = url.toLowerCase();
        return lower.contains("://mp.weixin.qq.com/")
                || lower.startsWith("mp.weixin.qq.com/");
    }

    /**
     * Build a fully-populated image content part for inbound WeCom media.
     * <p>
     * When download is enabled and succeeds, the part carries
     * {@code path}, {@code fileUrl} (browser-servable), {@code fileName},
     * {@code storedName}, {@code fileSize}, and a precise {@code contentType}
     * — every field the chat bubble and the multimodal sidecar inspect. When
     * download is disabled or fails, the part falls back to URL-only fields
     * but still sets {@code fileName} so the bubble doesn't render
     * "未命名 / unknown".
     */
    private MessageContentPart buildInboundImagePart(String url, String aesKey, String msgId,
                                                      String fileNameHint, String conversationId) {
        if (getConfigBoolean("media_download_enabled", true)) {
            InboundMediaDownloader.DownloadedMedia r =
                    downloadInboundMedia(url, aesKey, msgId, fileNameHint, conversationId);
            if (r != null) {
                String localPath = r.localPath().toString();
                MessageContentPart part = new MessageContentPart();
                part.setType("image");
                part.setFileName(r.fileName());
                part.setStoredName(r.storedName());
                part.setPath(localPath);
                part.setFileUrl(r.fileUrl());
                part.setFileSize(r.fileSize());
                // Prefer the sniffed contentType (could be image/png) over a
                // hardcoded image/jpeg. Falls back to image/jpeg only when the
                // sniff was inconclusive.
                String ct = r.contentType();
                part.setContentType((ct != null && ct.startsWith("image/")) ? ct : "image/jpeg");
                // mediaId mirrors path so callers that prefer it still resolve
                // to the same on-disk file (matches Web upload's behaviour).
                part.setMediaId(localPath);
                return part;
            }
        }
        // Fallback: download disabled or failed. Browser preview will be broken
        // because the WeCom CDN URL carries a short-lived signature, but at
        // least the bubble shows "image.jpg" instead of "未命名 / unknown".
        // The image is also unusable by the model: the URL points at AES-encrypted
        // bytes (when aeskey is present) and expires in ~5 minutes, so without a
        // local download the agent can only report "file not found". Warn loudly so
        // operators know to enable media download rather than chase a phantom bug.
        boolean encrypted = aesKey != null && !aesKey.isBlank();
        log.warn("[wecom] Inbound image '{}' stored URL-only ({} download). The model "
                        + "cannot read it — enable 'media_download_enabled' on this channel. "
                        + "url={}", fileNameHint,
                getConfigBoolean("media_download_enabled", true) ? "failed" : "disabled",
                encrypted ? "<encrypted COS URL>" : url);
        MessageContentPart part = new MessageContentPart();
        part.setType("image");
        part.setFileName(fileNameHint);
        part.setFileUrl(url);
        part.setMediaId(url);
        part.setContentType("image/jpeg");
        return part;
    }

    /**
     * Build a fully-populated file content part for inbound WeCom media.
     * <p>
     * Mirrors {@link #buildInboundImagePart} but for non-image attachments
     * (PDF, DOCX, ZIP, etc.). The magic-byte sniffer inside
     * {@link #downloadInboundMedia} fixes generic {@code file.bin} hints to
     * the real extension so downstream tools (PDF text extractor, magika,
     * etc.) key off the correct mime.
     */
    private MessageContentPart buildInboundFilePart(String url, String aesKey, String msgId,
                                                     String fileNameHint, String conversationId) {
        if (getConfigBoolean("media_download_enabled", true)) {
            InboundMediaDownloader.DownloadedMedia r =
                    downloadInboundMedia(url, aesKey, msgId, fileNameHint, conversationId);
            if (r != null) {
                String localPath = r.localPath().toString();
                MessageContentPart part = new MessageContentPart();
                part.setType("file");
                part.setFileName(r.fileName());
                part.setStoredName(r.storedName());
                part.setPath(localPath);
                part.setFileUrl(r.fileUrl());
                part.setFileSize(r.fileSize());
                part.setContentType(r.contentType());
                part.setMediaId(localPath);
                return part;
            }
        }
        // Fallback when download is disabled or fails — at least keep the
        // original hint so the bubble doesn't say "file.bin" for a PDF.
        MessageContentPart part = new MessageContentPart();
        part.setType("file");
        part.setFileName(fileNameHint);
        part.setFileUrl(url);
        part.setMediaId(url);
        return part;
    }

    /**
     * Download + decrypt an inbound media attachment via the shared media
     * pipeline, stored under {@code data/chat-uploads/{conversationId}/} so the
     * existing {@code /api/v1/chat/files/...} endpoint can serve it back to the
     * chat bubble. Returns the persisted, type-detected file, or {@code null}
     * on download/decrypt failure (callers fall back to URL-only).
     */
    private InboundMediaDownloader.DownloadedMedia downloadInboundMedia(String url, String aesKey, String msgId,
                                                    String fileNameHint, String conversationId) {
        // Store under the workspace/agent-aware upload root ({convId}/ subdir),
        // falling back to the legacy data/chat-uploads default, so the existing
        // /api/v1/chat/files/{convId}/{storedName} endpoint serves the file
        // back to the chat bubble — the WeCom CDN URL carries a short-lived
        // signature that expires before a browser can fetch it. The shared
        // pipeline owns retry/backoff, magic-byte type detection, and the
        // dedup-named write; the WeCom-specific AES-256-CBC decrypt stays here
        // inside the byte source so a fetch + decrypt is retried as one unit.
        Path uploadDir = (chatUploadLocationResolver != null)
                ? chatUploadLocationResolver.resolveConversationDir(conversationId)
                : Path.of("data", "chat-uploads", ChatUploadLocationResolver.sanitizeSegment(conversationId));
        String hint = (fileNameHint == null || fileNameHint.isBlank()) ? null : fileNameHint;
        return InboundMediaDownloader.download(
                () -> {
                    HttpRequest request = HttpRequest.newBuilder()
                            .uri(URI.create(url))
                            .timeout(Duration.ofSeconds(30))
                            .GET()
                            .build();
                    HttpResponse<InputStream> response =
                            httpClient.send(request, HttpResponse.BodyHandlers.ofInputStream());
                    byte[] encrypted = response.body().readAllBytes();
                    return (aesKey != null && !aesKey.isBlank())
                            ? decryptAes256Cbc(encrypted, aesKey)
                            : encrypted;
                },
                hint,
                uploadDir,
                "wecom",
                url,
                storedName -> "/api/v1/chat/files/" + conversationId + "/" + storedName)
                .orElse(null);
    }

    /**
     * AES-256-CBC decryption for WeCom media payloads.
     * <p>
     * 1. Base64 decode aesKey (auto-fix missing padding)
     * 2. IV = first 16 bytes of the decoded key
     * 3. AES-256-CBC decrypt
     * 4. Strip PKCS#7 padding
     */
    private byte[] decryptAes256Cbc(byte[] encryptedData, String aesKeyBase64) throws Exception {
        // 补齐 Base64 padding
        int padCount = (4 - aesKeyBase64.length() % 4) % 4;
        String padded = aesKeyBase64 + "=".repeat(padCount);
        byte[] keyBytes = Base64.getDecoder().decode(padded);

        // IV = 前 16 字节
        byte[] iv = Arrays.copyOf(keyBytes, 16);

        // 确保数据是 16 字节的倍数
        int blockSize = 16;
        int remainder = encryptedData.length % blockSize;
        if (remainder != 0) {
            encryptedData = Arrays.copyOf(encryptedData, encryptedData.length + (blockSize - remainder));
        }

        // AES-256-CBC 解密（NoPadding — 手动去 PKCS#7）
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
        IvParameterSpec ivSpec = new IvParameterSpec(iv);
        Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
        byte[] decrypted = cipher.doFinal(encryptedData);

        // PKCS#7 去填充
        int padLen = decrypted[decrypted.length - 1] & 0xFF;
        if (padLen < 1 || padLen > 32 || padLen > decrypted.length) {
            throw new IllegalArgumentException("Invalid PKCS#7 padding value: " + padLen);
        }
        for (int i = decrypted.length - padLen; i < decrypted.length; i++) {
            if ((decrypted[i] & 0xFF) != padLen) {
                throw new IllegalArgumentException("Invalid PKCS#7 padding: bytes mismatch");
            }
        }
        return Arrays.copyOf(decrypted, decrypted.length - padLen);
    }

    // ==================== 主动推送 ====================

    @Override
    public boolean supportsProactiveSend() {
        return true;
    }

    @Override
    public void proactiveSend(String targetId, String content) {
        sendMessageToChat(targetId, content);
    }

    @Override
    public String getChannelType() {
        return CHANNEL_TYPE;
    }

    /**
     * WeCom's AI-bot transport is WebSocket-only ({@code wss://openws.work.weixin.qq.com}
     * with {@code aibot_subscribe} authenticated by {@code bot_id + secret}) — there is
     * no HTTP webhook fallback. Multiple nodes subscribing with the same
     * credentials would each receive every {@code aibot_msg_callback} and race
     * to send {@code aibot_respond_msg}, producing duplicate replies and
     * eventual gateway rejection. The leader gate ensures only one node
     * holds the subscription at a time.
     */
    @Override
    public boolean requiresSingleLeader() {
        return true;
    }

    // ==================== 工具方法 ====================

    /**
     * 生成唯一请求 ID：{prefix}_{timestamp}_{counter}
     */
    private String generateReqId(String prefix) {
        return prefix + "_" + System.currentTimeMillis() + "_" + reqIdCounter.incrementAndGet();
    }

    /**
     * MD5 哈希（字节数组输入）
     */
    private String md5Hex(byte[] input) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] hash = md.digest(input);
            return bytesToHex(hash);
        } catch (Exception e) {
            return "0";
        }
    }

    private String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    // ==================== 回复队列内部类 ====================

    private record ReplyTask(Map<String, Object> frame, CompletableFuture<Map<String, Object>> future) {}
}