@xgjktech/xg_cwork_im 1.19.21 → 1.19.23

package/dist/src/inbound/dispatch-mentioned-reply.js

@@ -0,0 +1,1014 @@
+/**
+ * @ 触发的单轮回复：WebSocket BEGIN、OpenClaw dispatchReplyWithBufferedBlockDispatcher、HTTP deliver、RUN_USAGE、FINISHED。
+ */
+import { isImSingleChat, resolveSendMessageReply } from "./inbound-chat-type.js";
+import { buildTerminalSendFn, InboundTerminalController, } from "../delivery/inbound-terminal-delivery.js";
+import { formatConfirmedUpstreamErrorForIm } from "../delivery/user-facing-errors.js";
+import { shouldOmitDuplicateFileCaption, shouldSuppressDuplicateTextDeliver, stripMediaDirectiveLines, stripModelUsageFooter, } from "../delivery/deliver-text.js";
+import { shouldSuppressFallbackNoticeForIm } from "../session/per-message-fallback-notice.js";
+import { resolveThinkingWsDisplayUpdate, THINKING_WS_SUMMARY_HINT, ThinkingWsBuffer, WS_THINKING_DISPLAY_MAX, } from "../delivery/thinking-ws-progress.js";
+import { resolveItemEventGuard } from "../turn/item-event-guard.js";
+import { clearPendingPerMessageModel, setPendingPerMessageModel, splitModelRef, } from "../session/per-message-model-pending.js";
+import { resolveSessionModelFallbackContext } from "../session/session-model-fallback.js";
+import { IM_BLOCK_STREAMING_COALESCE_DEFAULT, isDeliverAssistantItemsEnabled, isDeliverPartialSnapshotEnabled, isDeliverSegmentBufferEnabled, isInboundBlockStreamingEnabled, resolveBlockStreamingReplyOptions, resolveDispatchOpenClawCfg, } from "../plugin/channel-config.js";
+import { clearAssistantItemSink, setAssistantItemSink } from "../delivery/assistant-item-sink.js";
+import { flushAssistantItem, resetAssistantItem } from "../delivery/assistant-item-delivery.js";
+import { sendReplyDeliverBlock, sendTextMessage } from "../delivery/send-service.js";
+import { isDeliverPayloadSendable, snapshotSupersedesBufferText, TurnDeliverBuffer } from "../delivery/turn-deliver-buffer.js";
+import { buildRunUsageFromSessionEntry, hasReportableUsage, toImStreamRunUsageData } from "../turn/run-usage.js";
+import { readSessionUsageFields } from "../turn/run-usage-session.js";
+import { finalizeRoundMonitoring } from "../turn/subagent-monitor.js";
+import { registerCorePlanSnapshotClient } from "../plan/plan-core-snapshot.js";
+import { setSessionImContext } from "../session/session-im-context.js";
+import { completeActiveRound, registerActiveRound, roundExists, } from "../turn/active-round-registry.js";
+import { turnEnsureRound, turnForget, turnIsEligible, turnIsSawSubagent, turnOnDispatchReturned, } from "../turn/turn-end-controller.js";
+import { noteWrappedRunId } from "../turn/turn-agent-event-subscription.js";
+import { resolveNasVolumeDispatchConfig } from "../workspace/nas-volumes.js";
+import { resolveDispatchDriver, dispatchXgImInboundReply } from "./reply-dispatch-driver.js";
+/** WS `displayText` 过长封顶（避免网关/客户端溢出） */
+const WS_DISPLAY_TEXT_MAX = 200;
+/** 子任务轮次等整轮结束（等父会话非 yield 终态 / 静默兜底）的最长等待时间；超时强制收尾，避免悬挂。 */
+const TURN_END_WAIT_MAX_MS = 30 * 60_000;
+/** 进度 `summary` 封顶（与网关约定一致） */
+const WS_PROGRESS_SUMMARY_MAX = 200;
+/** 流式正文预览（onPartialReply 快照）经 WS 展示的封顶长度 */
+const WS_REPLY_PREVIEW_MAX = 2000;
+/** 流式正文预览 WS 推送最小间隔（节流，避免 ~13 次/秒刷屏） */
+const WS_REPLY_PREVIEW_MIN_INTERVAL_MS = 500;
+/** 流式正文预览的 WS summary 标记（客户端据此更新同一输出位；定稿 HTTP 后清草稿） */
+const WS_REPLY_PREVIEW_SUMMARY = "reply_preview";
+function clipWsDisplayText(text, max = WS_DISPLAY_TEXT_MAX) {
+    const t = text.trim();
+    if (!t)
+        return "";
+    if (t.length <= max)
+        return t;
+    return `${t.slice(0, Math.max(0, max - 1))}…`;
+}
+function clipWsProgressSummary(text, max = WS_PROGRESS_SUMMARY_MAX) {
+    const t = text.trim().replace(/\r\n/g, "\n").replace(/\n+/g, " ");
+    if (!t)
+        return "";
+    if (t.length <= max)
+        return t;
+    return `${t.slice(0, Math.max(0, max - 1))}…`;
+}
+/** 流式 BEGIN → dispatch → 可选 RUN_USAGE → 必发 FINISHED；首包超时仅日志（不对 IM 发超时话术） */
+export async function dispatchMentionedReply(args) {
+    const { accountId, rt, cfg, config, log, logPrefix, route, inboundCtx, params, currentIdentity, streamClient, agentWorkspaceDir, nasVolumes, modelOverride, thinkingLevelOverride, autoRouteMeta, inboundTrigger, isStopControl = false, driver: explicitDriver, inboundRecord } = args;
+    const terminal = new InboundTerminalController({
+        messageId: params.msgId,
+        groupId: params.groupId,
+        sessionKey: route.sessionKey,
+        trigger: inboundTrigger ?? "user",
+        log,
+        logPrefix,
+    });
+    const replyMetaForSend = resolveSendMessageReply(params);
+    const terminalSend = buildTerminalSendFn({
+        isSingleChat: isImSingleChat(params),
+        replyMeta: replyMetaForSend,
+        sendText: async (text, reply) => {
+            await sendTextMessage(config, currentIdentity.token, params.groupId, text, reply ? [reply.targetUserId] : [], log, undefined, reply);
+        },
+    });
+    log.info(`${logPrefix} [dispatch] Dispatching to OpenClaw AI, sessionKey=${route.sessionKey}`);
+    if (modelOverride) {
+        log.info(`${logPrefix} [model] per-message override requested: ${modelOverride}`);
+    }
+    if (autoRouteMeta) {
+        log.info(`${logPrefix} [route] dispatch version=${autoRouteMeta.version} tier=${autoRouteMeta.tier} ` +
+            `reason=${autoRouteMeta.reason} requestedModel=${modelOverride ?? "(none)"} ` +
+            `requestedThinking=${thinkingLevelOverride ?? "(default)"}`);
+    }
+    let isFirstReply = true;
+    let subagentNotificationSent = false;
+    const dispatchStart = Date.now();
+    const replyAnchorId = params.msgId.trim();
+    const progressGroupId = params.groupId;
+    const toolNameStack = [];
+    const notifyStreamProgress = async (event, displayText, summary, displayMax = WS_DISPLAY_TEXT_MAX) => {
+        if (isStopControl)
+            return;
+        const msg = clipWsDisplayText(displayText, displayMax);
+        const sum = summary?.trim() ? clipWsProgressSummary(summary) : undefined;
+        if (!progressGroupId.trim() || !replyAnchorId || !msg)
+            return;
+        try {
+            await streamClient.streamProgress({
+                groupId: progressGroupId,
+                replyToMsgId: replyAnchorId,
+                event,
+                displayText: msg,
+                ...(sum ? { summary: sum } : {}),
+            });
+        }
+        catch (e) {
+            log.warn(`${logPrefix} [stream] ${event} notify failed: ${String(e)}`);
+        }
+    };
+    const thinkingWsBuffer = new ThinkingWsBuffer();
+    let lastThinkingWsDisplay = "";
+    const flushThinkingWsOnce = async (reason) => {
+        const text = thinkingWsBuffer.take();
+        if (!text)
+            return;
+        const { displayText, changed } = resolveThinkingWsDisplayUpdate(lastThinkingWsDisplay, text);
+        if (!changed)
+            return;
+        lastThinkingWsDisplay = displayText;
+        await notifyStreamProgress("RUN_EVENT", displayText, THINKING_WS_SUMMARY_HINT, WS_THINKING_DISPLAY_MAX);
+        log.info(`${logPrefix} [stream] Thinking WS once (${reason}) len=${displayText.length}`);
+    };
+    let hasFirstReply = false;
+    let agentRunStarted = false;
+    let dispatchInFlight = false;
+    const firstReplyTimeoutMs = config.firstReplyTimeoutMs ?? 30 * 60_000;
+    const resolveFirstReplyTimeoutCause = () => {
+        if (!agentRunStarted)
+            return "never_started";
+        if (dispatchInFlight)
+            return "in_progress";
+        return "ended_without_http_reply";
+    };
+    const timeoutLabel = `${logPrefix} [stream] First reply timeout after ${firstReplyTimeoutMs}ms`;
+    const firstReplyTimeout = setTimeout(() => {
+        if (hasFirstReply)
+            return;
+        const timeoutCause = resolveFirstReplyTimeoutCause();
+        terminal.markTimeoutFired();
+        log.warn(`${timeoutLabel} cause=${timeoutCause} agentRunStarted=${agentRunStarted} ` +
+            `dispatchInFlight=${dispatchInFlight} (no IM timeout notice; channel timer ≠ OpenClaw terminal)`);
+    }, firstReplyTimeoutMs);
+    let deliverInvokeCount = 0;
+    let deliverCallCount = 0;
+    let deliverSkippedCount = 0;
+    let compactionNoticeDelivered = 0;
+    let lastDeliveredText = "";
+    let lastDeliveredHadMedia = false;
+    let agentRunId;
+    let dispatchError = undefined;
+    let lastDeliverError = undefined;
+    let dispatchResult;
+    let assistantItemSink;
+    // assistant-item 模式下的兜底：核心命令（如 /status）不跑 agent、无 assistant 流，
+    // assistant-item 订阅不会触发。这里记录被跳过的正文，收尾若确认本轮无任何投递则补发。
+    let assistantItemDelivered = false;
+    let assistantItemFallback;
+    const blockStreamingEnabled = isInboundBlockStreamingEnabled(config);
+    // assistant item 投递：订阅 assistant 流按每条 assistant 消息逐条发；开启时 block reply 正文不再发。
+    const assistantItemDeliveryEnabled = isDeliverAssistantItemsEnabled(config);
+    const segmentBufferEnabled = blockStreamingEnabled && isDeliverSegmentBufferEnabled(config) && !assistantItemDeliveryEnabled;
+    const segmentBuffer = segmentBufferEnabled ? new TurnDeliverBuffer() : undefined;
+    let hasBufferedSendable = false;
+    let flushSegmentBuffer = async () => { };
+    // —— onPartialReply 全量快照：当前 tool 区间内正文的权威来源 ——
+    // text 是「当前 assistant 消息」的完整快照（非增量）；tool 边界 / 轮末 flush 时用它覆盖
+    // deliver 拼接文本，消除段缓冲对「覆盖 vs 追加」的启发式猜测（CO2）。
+    const partialSnapshotEnabled = segmentBufferEnabled && isDeliverPartialSnapshotEnabled(config);
+    let segmentSnapshotText = "";
+    let segmentSnapshotHadPartial = false;
+    // WS 正文预览节流状态
+    let lastReplyPreviewAt = 0;
+    let lastReplyPreviewText = "";
+    // 观测统计（保留少量，便于线上核对）
+    let partialReplyCount = 0;
+    let partialReplyMaxTextLen = 0;
+    let partialReplyFirstAt = 0;
+    const resetSegmentSnapshot = () => {
+        segmentSnapshotText = "";
+        segmentSnapshotHadPartial = false;
+        lastReplyPreviewText = "";
+    };
+    const emitReplyPreviewWs = async (snapshot, force) => {
+        const text = snapshot.trim();
+        if (!text)
+            return;
+        const now = Date.now();
+        if (!force && now - lastReplyPreviewAt < WS_REPLY_PREVIEW_MIN_INTERVAL_MS)
+            return;
+        const clipped = clipWsDisplayText(text, WS_REPLY_PREVIEW_MAX);
+        if (clipped === lastReplyPreviewText)
+            return;
+        lastReplyPreviewAt = now;
+        lastReplyPreviewText = clipped;
+        await notifyStreamProgress("RUN_EVENT", clipped, WS_REPLY_PREVIEW_SUMMARY, WS_REPLY_PREVIEW_MAX);
+    };
+    const postHttpDeliver = async (args) => {
+        const { payloadForSend, textPart, sendLabel, invokeNum, hasMedia, omitDuplicateFileCaption } = args;
+        deliverCallCount++;
+        if (isFirstReply) {
+            const ttfr = Date.now() - dispatchStart;
+            log.info(`${logPrefix} [deliver] First response block received from AI (TTFB: ${ttfr}ms)`);
+            isFirstReply = false;
+        }
+        const reply = resolveSendMessageReply(params);
+        const atIds = reply ? [reply.targetUserId] : [];
+        if (!hasFirstReply) {
+            clearTimeout(firstReplyTimeout);
+        }
+        await sendReplyDeliverBlock(config, currentIdentity.token, params.groupId, payloadForSend, atIds, log, undefined, reply, agentWorkspaceDir);
+        if (!hasFirstReply) {
+            hasFirstReply = true;
+        }
+        terminal.markBusinessReplySent();
+        if (hasMedia) {
+            lastDeliveredHadMedia = true;
+            if (!omitDuplicateFileCaption) {
+                lastDeliveredText = textPart || "[media]";
+            }
+        }
+        else {
+            lastDeliveredText = textPart;
+            lastDeliveredHadMedia = false;
+        }
+        const preview = textPart.length > 80 ? `${textPart.slice(0, 80)}...` : textPart || "[media]";
+        log.info(`${logPrefix} [send] ${sendLabel} sent via HTTP: groupId=${params.groupId} ` +
+            `invoke=#${invokeNum} preview="${preview}"`);
+    };
+    let activeRound;
+    try {
+        if (!isStopControl) {
+            setSessionImContext(route.sessionKey, {
+                groupId: params.groupId,
+                replyToMsgId: params.msgId,
+                agentId: config.agentId || "main",
+            });
+            if (assistantItemDeliveryEnabled) {
+                // assistant 流订阅按 item 逐条把完整正文交到这里；复用本 dispatch 的发送链路
+                // （config/token/reply/终态/去重），因此 block reply 正文不再重复发送。
+                assistantItemSink = (itemId, text) => {
+                    const label = deliverCallCount === 0 ? "First reply (assistant item)" : "Assistant item";
+                    return postHttpDeliver({
+                        payloadForSend: { text },
+                        textPart: text,
+                        sendLabel: label,
+                        invokeNum: deliverInvokeCount,
+                        hasMedia: false,
+                        omitDuplicateFileCaption: false,
+                    }).then(() => {
+                        assistantItemDelivered = true;
+                    }).catch((err) => {
+                        lastDeliverError = err;
+                        log.error(`${logPrefix} [assistant-item] send failed itemId=${itemId}: ${String(err)}`);
+                    });
+                };
+                setAssistantItemSink(route.sessionKey, assistantItemSink);
+            }
+            await streamClient.start({
+                groupId: params.groupId,
+                replyToMsgId: params.msgId,
+            });
+            activeRound = registerActiveRound({
+                accountId,
+                groupId: params.groupId,
+                agentId: config.agentId || "main",
+                sessionKey: route.sessionKey,
+                replyToMsgId: params.msgId,
+                streamClient,
+            });
+            turnEnsureRound(activeRound.roundKey, activeRound.generation);
+            registerCorePlanSnapshotClient({
+                groupId: params.groupId,
+                client: streamClient,
+                replyToMsgId: params.msgId,
+                agentId: config.agentId || "main",
+                sessionKey: route.sessionKey,
+            });
+        }
+        if (modelOverride) {
+            const parsed = splitModelRef(modelOverride);
+            if (parsed) {
+                const fallbackContext = resolveSessionModelFallbackContext({
+                    storePath: inboundRecord?.storePath?.trim() ||
+                        rt.channel.session.resolveStorePath(cfg.session?.store, {
+                            agentId: route.agentId,
+                        }),
+                    sessionKey: route.sessionKey,
+                });
+                if (fallbackContext.sessionInAutoFallback) {
+                    log.info(`${logPrefix} [model] session in auto-fallback ` +
+                        `origin=${fallbackContext.fallbackOrigin?.provider ?? ""}/` +
+                        `${fallbackContext.fallbackOrigin?.model ?? ""}`);
+                }
+                setPendingPerMessageModel(route.sessionKey, modelOverride, fallbackContext);
+            }
+            else {
+                log.warn(`${logPrefix} [model] invalid per-message model ref, ignoring: ${modelOverride}`);
+            }
+        }
+        const baseDispatchCfg = resolveDispatchOpenClawCfg(cfg, config);
+        let nasDispatch;
+        try {
+            nasDispatch = await resolveNasVolumeDispatchConfig({
+                cfg: baseDispatchCfg,
+                config,
+                agentId: route.agentId,
+                sessionKey: route.sessionKey,
+                volumes: nasVolumes,
+                agentWorkspaceDir,
+                log: {
+                    info: (message) => log.info(`${logPrefix} ${message}`),
+                    warn: (message) => log.warn(`${logPrefix} ${message}`),
+                },
+            });
+        }
+        catch (error) {
+            // NAS 是可选增强信息。任何非法声明或运行时挂载校验失败都不得阻断原消息。
+            log.warn(`${logPrefix} [nas-volumes] invalid mount ignored: ${String(error)}`);
+            try {
+                // 若本会话此前已有有效声明，继续复用它；否则完全退回原 dispatch 配置。
+                nasDispatch = await resolveNasVolumeDispatchConfig({
+                    cfg: baseDispatchCfg,
+                    config,
+                    agentId: route.agentId,
+                    sessionKey: route.sessionKey,
+                    agentWorkspaceDir,
+                    log: {
+                        info: (message) => log.info(`${logPrefix} ${message}`),
+                        warn: (message) => log.warn(`${logPrefix} ${message}`),
+                    },
+                });
+            }
+            catch (cachedError) {
+                log.warn(`${logPrefix} [nas-volumes] cached mount unavailable, continuing without NAS: ${String(cachedError)}`);
+                nasDispatch = { cfg: baseDispatchCfg, reused: false };
+            }
+        }
+        const dispatchCfg = nasDispatch.cfg;
+        const nasConfigOverride = nasDispatch.configOverride;
+        if (nasDispatch.specHash || nasDispatch.syncDeclarationHash) {
+            log.info(`${logPrefix} [nas-volumes] session=${route.sessionKey} volumes=${nasVolumes?.length ?? "cached"} ` +
+                `spec=${nasDispatch.specHash?.slice(0, 12) ?? "-"} sync=${nasDispatch.syncDeclarationHash?.slice(0, 12) ?? "-"} ` +
+                `reused=${nasDispatch.reused}` +
+                ` configOverride=${Boolean(nasConfigOverride)}` +
+                ` workspace=${agentWorkspaceDir ? "yes" : "no"}`);
+        }
+        else if (nasVolumes?.length) {
+            // 声明存在但未产出 mount/sync 指纹：通常是校验失败已吞掉，或 pull/push 尚未成功落指纹。
+            log.warn(`${logPrefix} [nas-volumes] session=${route.sessionKey} volumes=${nasVolumes.length} ` +
+                `no active mount/sync fingerprint (check prior [nas-volumes] warn); workspace=${agentWorkspaceDir ? "yes" : "no"}`);
+        }
+        if (blockStreamingEnabled && baseDispatchCfg !== cfg) {
+            log.info(`${logPrefix} [dispatch] IM blockStreamingCoalesce override ` +
+                `(minChars=${IM_BLOCK_STREAMING_COALESCE_DEFAULT.minChars} idleMs=${IM_BLOCK_STREAMING_COALESCE_DEFAULT.idleMs}) ` +
+                `— agents.defaults coalesce will not delay tool-before HTTP`);
+        }
+        if (blockStreamingEnabled) {
+            log.info(`${logPrefix} [dispatch] blockStreaming=on (assistant text before tools → HTTP; tool progress → WS)`);
+        }
+        if (segmentBufferEnabled) {
+            log.info(`${logPrefix} [dispatch] deliverSegmentBuffer=on (segment buffer → flush on tool start / dispatch end)`);
+        }
+        flushSegmentBuffer = async (kind) => {
+            if (!segmentBuffer)
+                return;
+            const result = segmentBuffer.takeForFlush(kind);
+            // 本段快照（onPartialReply 全量）；仅在启用且确有回调时作为正文权威来源。
+            const snapshot = partialSnapshotEnabled && segmentSnapshotHadPartial ? segmentSnapshotText.trim() : "";
+            const sendLabel = kind === "interim"
+                ? "Interim block"
+                : deliverCallCount === 0
+                    ? "First reply"
+                    : "Final block";
+            if (result.status === "empty") {
+                // buffer 无内容但有快照（纯文本、无 deliver 文本块）→ 直接发快照。
+                if (snapshot) {
+                    if (shouldSuppressDuplicateTextDeliver({
+                        textPart: snapshot,
+                        hasMedia: false,
+                        lastDeliveredText,
+                        lastDeliveredHadMedia,
+                    })) {
+                        log.info(`${logPrefix} [deliver-buffer] flush_${kind} snapshot_only skipped ` +
+                            `(normalized same as last HTTP, len=${snapshot.length})`);
+                        resetSegmentSnapshot();
+                    }
+                    else {
+                        log.info(`${logPrefix} [deliver-buffer] flush_${kind} snapshot_only textLen=${snapshot.length}`);
+                        resetSegmentSnapshot();
+                        await postHttpDeliver({
+                            payloadForSend: { text: snapshot },
+                            textPart: snapshot,
+                            sendLabel,
+                            invokeNum: deliverInvokeCount,
+                            hasMedia: false,
+                            omitDuplicateFileCaption: false,
+                        });
+                    }
+                }
+                return;
+            }
+            if (result.status === "skipped_duplicate") {
+                log.info(`${logPrefix} [deliver-buffer] flush_${kind} skipped (same as previous HTTP, comparable match)`);
+                resetSegmentSnapshot();
+                return;
+            }
+            let { payload: payloadForSend, textPart } = result.entry;
+            const { hasMedia } = result.entry;
+            // 快照覆盖正文：仅当快照包含缓冲文本（归一化后为超集）时才覆盖，避免竞态截断；
+            // 媒体/附件等元数据仍沿用 deliver 的 payload。
+            if (snapshot && snapshot !== textPart) {
+                if (snapshotSupersedesBufferText(snapshot, textPart)) {
+                    log.info(`${logPrefix} [deliver-buffer] flush_${kind} snapshot_override ` +
+                        `bufferLen=${textPart.length} → snapshotLen=${snapshot.length}`);
+                    payloadForSend = {
+                        ...payloadForSend,
+                        text: snapshot,
+                        ...(payloadForSend.markdown != null ? { markdown: snapshot } : {}),
+                    };
+                    textPart = snapshot;
+                }
+                else {
+                    log.warn(`${logPrefix} [deliver-buffer] flush_${kind} snapshot_skip (not superset; keep buffer) ` +
+                        `bufferLen=${textPart.length} snapshotLen=${snapshot.length}`);
+                }
+            }
+            log.info(`${logPrefix} [deliver-buffer] flush_${kind} textLen=${textPart.length} hasMedia=${hasMedia}`);
+            resetSegmentSnapshot();
+            await postHttpDeliver({
+                payloadForSend,
+                textPart,
+                sendLabel,
+                invokeNum: deliverInvokeCount,
+                hasMedia,
+                omitDuplicateFileCaption: false,
+            });
+        };
+        dispatchInFlight = true;
+        const dispatchRequest = {
+            ctx: inboundCtx,
+            cfg: dispatchCfg,
+            replyOptions: {
+                ...resolveBlockStreamingReplyOptions(config),
+                sourceReplyDeliveryMode: "automatic",
+                suppressDefaultToolProgressMessages: true,
+                allowProgressCallbacksWhenSourceDeliverySuppressed: true,
+                // 单轮模型覆盖不走 replyOptions（OpenClaw 不消费 modelOverride 字段），
+                // 改由 dispatch 前登记的 pending + before_model_resolve hook 生效。
+                ...(thinkingLevelOverride ? { thinkingLevelOverride } : {}),
+                onAgentRunStart: (runId) => {
+                    agentRunStarted = true;
+                    agentRunId = runId.trim() || undefined;
+                    terminal.setRunId(runId);
+                    noteWrappedRunId(route.sessionKey, runId.trim());
+                    log.info(`${logPrefix} [dispatch] agent run started runId=${runId}`);
+                },
+                onModelSelected: (m) => {
+                    // failover 候选启动时会多次触发；终态模型以 session store 为准（RUN_USAGE）
+                    log.info(`${logPrefix} [model] run candidate provider=${m.provider} model=${m.model}`);
+                },
+                onPartialReply: async (payload) => {
+                    if (!partialSnapshotEnabled)
+                        return;
+                    const text = typeof payload.text === "string" ? payload.text : "";
+                    if (!text)
+                        return;
+                    partialReplyCount++;
+                    if (text.length > partialReplyMaxTextLen)
+                        partialReplyMaxTextLen = text.length;
+                    const now = Date.now();
+                    if (partialReplyFirstAt === 0) {
+                        partialReplyFirstAt = now;
+                        log.info(`${logPrefix} [partial] FIRST +${now - dispatchStart}ms textLen=${text.length}`);
+                    }
+                    // text 是当前 assistant 消息的全量快照（非增量）：直接作为本段正文权威来源。
+                    segmentSnapshotText = text;
+                    segmentSnapshotHadPartial = true;
+                    // 节流推送 WS 正文预览，供前端尽早覆盖显示同一输出位（HTTP 定稿前）。
+                    await emitReplyPreviewWs(text, false);
+                },
+                onReasoningStream: async (payload) => {
+                    const text = typeof payload.text === "string" ? payload.text : "";
+                    if (!text.trim())
+                        return;
+                    thinkingWsBuffer.noteStream(text);
+                },
+                onReasoningEnd: async () => {
+                    await flushThinkingWsOnce("reasoning_end");
+                },
+                onToolStart: async (p) => {
+                    const name = typeof p.name === "string" && p.name.trim().length > 0 ? p.name.trim() : "tool";
+                    const rawPhase = typeof p.phase === "string" ? p.phase.toLowerCase() : "";
+                    console.log(`[xg_cwork_im] ${logPrefix} [onToolStart] name="${name}" phase="${rawPhase}" argsKeys=${p.args ? Object.keys(p.args).join(",") : "none"}`);
+                    if (rawPhase === "update" || rawPhase === "delta" || rawPhase === "progress") {
+                        return;
+                    }
+                    if (rawPhase === "end" || rawPhase === "fail" || rawPhase === "error") {
+                        return;
+                    }
+                    if (!rawPhase || rawPhase === "start") {
+                        try {
+                            await flushSegmentBuffer("interim");
+                        }
+                        catch (interimErr) {
+                            lastDeliverError = interimErr;
+                            log.error(`${logPrefix} [deliver-buffer] flush_interim failed: ${String(interimErr)}`);
+                        }
+                        await flushThinkingWsOnce("before_tool");
+                        toolNameStack.push(name);
+                        if (name.includes("sessions_spawn") && !subagentNotificationSent) {
+                            subagentNotificationSent = true;
+                            try {
+                                await sendTextMessage(config, currentIdentity.token, params.groupId, "已将任务分配给子助手处理，稍后会把结果发给您。");
+                                console.log(`[xg_cwork_im] ${logPrefix} [subagent] sent notification from onToolStart`);
+                            }
+                            catch (sendErr) {
+                                console.warn(`[xg_cwork_im] ${logPrefix} [subagent] onToolStart send failed: ${String(sendErr)}`);
+                            }
+                        }
+                    }
+                    // WS TOOL_PHASE 已移至全局 before_tool_call hook
+                },
+                onToolResult: async (payload) => {
+                    const toolName = toolNameStack.length > 0 ? toolNameStack.pop() : "tool";
+                    // WS TOOL_PHASE 已移至全局 after_tool_call hook
+                },
+                onItemEvent: async (p) => {
+                    // 工具生命周期已由 onToolStart/onToolResult 覆盖；Reasoning 已由
+                    // onReasoningStream/onReasoningEnd 覆盖（start/end 各触发一次）。二者
+                    // 均不再进入 RUN_EVENT 兜底，避免内部诊断标识 `unmapped:*` 展示给用户。
+                    const guard = resolveItemEventGuard(p);
+                    if (guard.suppress)
+                        return;
+                    const text = (typeof p.progressText === "string" && p.progressText.trim()) ||
+                        (typeof p.summary === "string" && p.summary.trim()) ||
+                        (typeof p.title === "string" && p.title.trim()) ||
+                        (typeof p.meta === "string" && p.meta.trim()) ||
+                        "";
+                    if (!text)
+                        return;
+                    // 未识别事件只记录日志，不发送给最终用户
+                    log.debug?.(`${logPrefix} [stream] ignored unmapped onItemEvent ` +
+                        `kind=${guard.kind || "unknown"} title=${guard.title || "unknown"}`);
+                },
+                onCompactionStart: async () => {
+                    terminal.noteCompactionWsEvent("start");
+                    await notifyStreamProgress("RUN_EVENT", "正在整理上下文…");
+                },
+                onCompactionEnd: async () => {
+                    terminal.noteCompactionWsEvent("end");
+                    await notifyStreamProgress("RUN_EVENT", "上下文整理完成");
+                },
+                onApprovalEvent: async (p) => {
+                    const raw = typeof p.title === "string" && p.title.trim().length > 0
+                        ? p.title.trim()
+                        : typeof p.message === "string" && p.message.trim().length > 0
+                            ? p.message.trim()
+                            : "审批状态更新";
+                    await notifyStreamProgress("RUN_EVENT", clipWsDisplayText(raw, 160));
+                },
+                onCommandOutput: async (p) => {
+                    const ph = typeof p.phase === "string" ? p.phase.toLowerCase() : "";
+                    if (ph === "delta" || ph === "stream" || ph === "progress")
+                        return;
+                    const st = typeof p.status === "string" ? p.status.toLowerCase() : "";
+                    const terminalPhase = ["completed", "complete", "done", "end", "failed", "fail", "error"].includes(ph);
+                    const terminalStatus = ["completed", "failed", "error", "done"].includes(st);
+                    const hasExit = p.exitCode != null;
+                    if (!terminalPhase && !terminalStatus && !hasExit)
+                        return;
+                    const outRaw = typeof p.output === "string" ? p.output.trim() : "";
+                    const outSum = outRaw ? clipWsProgressSummary(outRaw) : undefined;
+                    if (ph === "failed" || ph === "fail" || ph === "error" || st === "failed" || st === "error") {
+                        await notifyStreamProgress("RUN_EVENT", "计划有变，正在调整策略", outSum); //命令执行失败
+                        return;
+                    }
+                    if (hasExit && p.exitCode !== 0) {
+                        await notifyStreamProgress("RUN_EVENT", `命令已结束（退出码 ${p.exitCode}）`, outSum);
+                        return;
+                    }
+                    await notifyStreamProgress("RUN_EVENT", "命令已执行完毕", outSum);
+                },
+                onPatchSummary: async (_p) => {
+                    await notifyStreamProgress("RUN_EVENT", "已记录文件变更摘要");
+                },
+            },
+            dispatcherOptions: {
+                responsePrefix: "",
+                onSkip: (payload, meta) => {
+                    deliverSkippedCount++;
+                    terminal.noteNormalizerSkip(meta.reason);
+                    log.info(`${logPrefix} [deliver] Payload skipped by normalizer kind=${meta.kind} reason=${meta.reason}`);
+                },
+                onError: (err, meta) => {
+                    lastDeliverError = err;
+                    log.error(`${logPrefix} [deliver] Dispatcher caught unhandled error kind=${meta.kind}: ${String(err)}`);
+                },
+                deliver: async (payload, info) => {
+                    try {
+                        deliverInvokeCount++;
+                        const textPayload = payload.markdown || payload.text || "";
+                        const trimmedForSend = textPayload.trim();
+                        const textPart = stripMediaDirectiveLines(trimmedForSend);
+                        const hasMedia = Boolean(payload.mediaUrl?.trim()) ||
+                            Boolean(payload.mediaUrls?.some((u) => typeof u === "string" && u.trim()));
+                        const textPreview = textPart.length > 160
+                            ? `${textPart.slice(0, 80)}…${textPart.slice(-80)}`
+                            : textPart;
+                        log.info(`${logPrefix} [deliver] invoke #${deliverInvokeCount} isThinking=${payload.isThinking ?? false} ` +
+                            `textLen=${textPart.length} hasMedia=${hasMedia} mediaUrl=${Boolean(payload.mediaUrl?.trim())} ` +
+                            `kind=${info?.kind ?? "none"} ` +
+                            `preview=${JSON.stringify(textPreview || "(empty)")}`);
+                        if (!hasMedia && !stripModelUsageFooter(textPart).trim()) {
+                            deliverSkippedCount++;
+                            log.info(`${logPrefix} [deliver] skip: model usage footer only (rawLen=${trimmedForSend.length})`);
+                            return;
+                        }
+                        if (payload.isError === true) {
+                            const errRaw = textPart || "(empty)";
+                            terminal.noteRuntimeErrorFromPayload(errRaw);
+                            const userText = formatConfirmedUpstreamErrorForIm(errRaw);
+                            if (!userText) {
+                                deliverSkippedCount++;
+                                log.info(`${logPrefix} [deliver] isError payload empty after format; skipped HTTP`);
+                                return;
+                            }
+                            // 上游已 deliver 的错误：HTTP 发出（白名单人话或原文），不再等到终态换插件空话
+                            const errorPayload = {
+                                ...payload,
+                                text: userText,
+                                markdown: userText,
+                                isError: true,
+                            };
+                            log.info(`${logPrefix} [deliver] isError → HTTP (confirmed map or passthrough) ` +
+                                `len=${userText.length}`);
+                            await postHttpDeliver({
+                                payloadForSend: errorPayload,
+                                textPart: userText,
+                                sendLabel: deliverInvokeCount === 1 ? "First reply (error)" : "Error payload",
+                                invokeNum: deliverInvokeCount,
+                                hasMedia: false,
+                                omitDuplicateFileCaption: false,
+                            });
+                            return;
+                        }
+                        if (payload.isCompactionNotice === true) {
+                            terminal.noteCompactionNotice(textPart || "Compacting context...");
+                            if (textPart) {
+                                // 放开 HTTP 屏蔽：compaction notice 不再丢弃，作为群消息真实发出，
+                                // 让用户能看到“会话正在整理/已整理”而不是莫名等待。
+                                // 故意不走 postHttpDeliver：不标记业务回复、不进入 lastDelivered 去重链，
+                                // 避免把“整理上下文”误当首条正式答复而破坏 first-reply 计时与终态兜底判定。
+                                try {
+                                    await terminalSend(textPart);
+                                    compactionNoticeDelivered += 1;
+                                    log.info(`${logPrefix} [deliver] Compaction notice sent via HTTP: ` +
+                                        `${JSON.stringify(textPart.slice(0, 80))}`);
+                                }
+                                catch (err) {
+                                    log.warn(`${logPrefix} [deliver] Compaction notice HTTP send failed: ${String(err)}`);
+                                }
+                            }
+                            else {
+                                deliverSkippedCount++;
+                                log.info(`${logPrefix} [deliver] Compaction notice empty; skipped`);
+                            }
+                            return;
+                        }
+                        if (payload.isReasoning === true) {
+                            deliverSkippedCount++;
+                            if (textPart)
+                                thinkingWsBuffer.noteStream(textPart);
+                            await flushThinkingWsOnce("deliver_reasoning");
+                            log.info(`${logPrefix} [deliver] Thinking block → single WS RUN_EVENT (len=${textPart.length})`);
+                            return;
+                        }
+                        if (shouldSuppressFallbackNoticeForIm({
+                            isFallbackNotice: payload.isFallbackNotice === true,
+                            deliverModelFallbackNotice: config.deliverModelFallbackNotice,
+                            requestedModelRaw: modelOverride,
+                            noticeText: textPart,
+                        })) {
+                            deliverSkippedCount++;
+                            const reason = config.deliverModelFallbackNotice === true
+                                ? "spurious per-message fallback notice"
+                                : "model fallback notice disabled for IM (deliverModelFallbackNotice)";
+                            log.info(`${logPrefix} [model] Suppressing fallback notice (${reason}): ` +
+                                `${JSON.stringify(textPart.slice(0, 120))}`);
+                            return;
+                        }
+                        if (!segmentBufferEnabled &&
+                            shouldSuppressDuplicateTextDeliver({
+                                textPart,
+                                hasMedia,
+                                lastDeliveredText,
+                                lastDeliveredHadMedia,
+                            })) {
+                            deliverSkippedCount++;
+                            log.info(`${logPrefix} [deliver] Suppressed duplicate text-only deliver ` +
+                                `(normalized same as previous, rawLen=${textPart.length})`);
+                            return;
+                        }
+                        let omitDuplicateFileCaption = false;
+                        if (!segmentBufferEnabled) {
+                            omitDuplicateFileCaption = shouldOmitDuplicateFileCaption({
+                                textPart,
+                                hasMedia,
+                                lastDeliveredText,
+                                lastDeliveredHadMedia,
+                            });
+                            if (omitDuplicateFileCaption) {
+                                log.info(`${logPrefix} [deliver] Omitting duplicate file caption ` +
+                                    `(normalized same as previous text, rawLen=${textPart.length})`);
+                            }
+                        }
+                        if (!isDeliverPayloadSendable({
+                            textPart,
+                            hasMedia,
+                            isThinking: payload.isThinking,
+                        })) {
+                            deliverSkippedCount++;
+                            log.info(`${logPrefix} [deliver] Payload has no sendable content, skipping` +
+                                ` (isThinking=${payload.isThinking ?? false} hasMedia=${hasMedia})`);
+                            return;
+                        }
+                        // assistant item 投递开启时：正文由 assistant 流订阅按 item 发送，
+                        // block reply 不再发纯文本；媒体照发但清空 caption，避免正文重复。
+                        if (assistantItemDeliveryEnabled && !hasMedia) {
+                            deliverSkippedCount++;
+                            // 记录兜底正文：核心命令/无 agent run 的轮次不会有 assistant 流，
+                            // assistant-item 订阅不会投递，收尾时用它补发避免用户看不到回复。
+                            assistantItemFallback = {
+                                payloadForSend: { ...payload, text: textPart, markdown: textPart },
+                                textPart,
+                            };
+                            log.info(`${logPrefix} [deliver] assistant-item mode: text handled by assistant subscription; ` +
+                                `skipping deliver text (textLen=${textPart.length})`);
+                            return;
+                        }
+                        let payloadForSend = textPart !== trimmedForSend
+                            ? {
+                                ...payload,
+                                ...(payload.markdown != null
+                                    ? { markdown: textPart }
+                                    : { text: textPart }),
+                            }
+                            : payload;
+                        if (omitDuplicateFileCaption || (assistantItemDeliveryEnabled && hasMedia)) {
+                            payloadForSend = { ...payloadForSend, text: "", markdown: "" };
+                        }
+                        if (segmentBufferEnabled && segmentBuffer) {
+                            if (info?.kind === "final" && segmentBuffer.hasContent()) {
+                                segmentBuffer.clear();
+                                log.info(`${logPrefix} [deliver] final block replaces buffer (intermediates discarded, textLen=${textPart.length})`);
+                            }
+                            if (shouldSuppressDuplicateTextDeliver({ textPart, hasMedia, lastDeliveredText, lastDeliveredHadMedia })) {
+                                deliverSkippedCount++;
+                                log.info(`${logPrefix} [deliver-buffer] skip: same as last HTTP delivered ` +
+                                    `(normalized match, textLen=${textPart.length})`);
+                                return;
+                            }
+                            segmentBuffer.write({ payload: payloadForSend, textPart, rawTextPart: textPayload, hasMedia });
+                            if (!hasBufferedSendable) {
+                                hasBufferedSendable = true;
+                                clearTimeout(firstReplyTimeout);
+                            }
+                            log.info(`${logPrefix} [deliver-buffer] write invoke=#${deliverInvokeCount} ` +
+                                `textLen=${textPart.length} hasMedia=${hasMedia}`);
+                            return;
+                        }
+                        const sendLabel = deliverInvokeCount === 1
+                            ? "First reply"
+                            : blockStreamingEnabled
+                                ? "Interim block"
+                                : "Additional reply";
+                        await postHttpDeliver({
+                            payloadForSend,
+                            textPart,
+                            sendLabel,
+                            invokeNum: deliverInvokeCount,
+                            hasMedia,
+                            omitDuplicateFileCaption,
+                        });
+                    }
+                    catch (err) {
+                        log.error(`${logPrefix} [deliver] Reply deliver failed: ${String(err)}`);
+                        throw err;
+                    }
+                },
+            },
+        };
+        const effectiveDriver = explicitDriver ?? resolveDispatchDriver(rt, config.dispatchDriver ?? "auto").driver;
+        log.info(`${logPrefix} [dispatch] driver=${effectiveDriver} recordInCore=${Boolean(inboundRecord)}`);
+        const storePath = inboundRecord?.storePath?.trim() ||
+            rt.channel.session.resolveStorePath(cfg.session?.store, {
+                agentId: config.agentId || "main",
+            });
+        dispatchResult = await dispatchXgImInboundReply({
+            rt,
+            ctx: dispatchRequest.ctx,
+            cfg: dispatchRequest.cfg,
+            channel: "xg_cwork_im",
+            accountId,
+            agentId: config.agentId || "main",
+            routeSessionKey: route.sessionKey,
+            storePath,
+            replyOptions: dispatchRequest.replyOptions,
+            dispatcherOptions: dispatchRequest.dispatcherOptions,
+            driver: effectiveDriver,
+            inboundRecord,
+            logPrefix,
+            warn: (message) => log.warn(message),
+            ...(nasConfigOverride ? { configOverride: nasConfigOverride } : {}),
+        });
+        dispatchInFlight = false;
+        const bufStats = segmentBuffer?.getStats();
+        log.info(`${logPrefix} [dispatch] Dispatch completed for sessionKey=${route.sessionKey}` +
+            ` (invoke=${deliverInvokeCount} delivered=${deliverCallCount} skipped=${deliverSkippedCount}` +
+            ` compaction_http=${compactionNoticeDelivered}` +
+            (bufStats
+                ? ` buffer_writes=${bufStats.writeCount}` +
+                    ` revision_overwrite=${bufStats.revisionOverwriteCount}` +
+                    ` segment_append=${bufStats.segmentAppendCount}` +
+                    ` flush_interim=${bufStats.flushInterimCount}` +
+                    ` flush_final=${bufStats.flushFinalCount}` +
+                    ` flush_dup_skip=${bufStats.skippedDuplicateFlushCount}`
+                : "") +
+            `)`);
+        if (partialSnapshotEnabled) {
+            log.info(`${logPrefix} [partial] SUMMARY count=${partialReplyCount} ` +
+                `maxTextLen=${partialReplyMaxTextLen} ` +
+                `firstAt=${partialReplyFirstAt ? partialReplyFirstAt - dispatchStart : -1}ms ` +
+                `(count=0 → 该配置下未回调 partial，flush 回退到 deliver 段缓冲)`);
+        }
+        if (deliverInvokeCount === 0) {
+            log.warn(`${logPrefix} [dispatch] OpenClaw never invoked channel deliver() for this turn — ` +
+                `this plugin will not POST /im/message/send; IM「收到消息」若存在，多半来自占位/END 或其它通道，而非本插件 HTTP 合并`);
+        }
+        else if (deliverCallCount === 0 && compactionNoticeDelivered === 0 && !segmentBuffer?.hasContent()) {
+            log.warn(`${logPrefix} [dispatch] deliver() invoked ${deliverInvokeCount} time(s) but none had sendable text/media — ` +
+                `check model output (thinking-only / empty blocks) or OpenClaw normalizer`);
+        }
+    }
+    catch (dispatchErr) {
+        dispatchError = dispatchErr;
+        log.error(`${logPrefix} [dispatch] Dispatch failed (invoke=${deliverInvokeCount} delivered=${deliverCallCount} skipped=${deliverSkippedCount}): ${String(dispatchErr)}`);
+    }
+    finally {
+        dispatchInFlight = false;
+        clearPendingPerMessageModel(route.sessionKey);
+        if (assistantItemDeliveryEnabled) {
+            // 收尾前把当前 item 的完整正文交给 sink 发完，再摘除 sink（避免终态判定漏掉最后一条）。
+            try {
+                await flushAssistantItem(route.sessionKey);
+            }
+            catch (itemErr) {
+                lastDeliverError = itemErr;
+                log.error(`${logPrefix} [assistant-item] flush_final failed: ${String(itemErr)}`);
+            }
+            clearAssistantItemSink(route.sessionKey, assistantItemSink);
+            resetAssistantItem(route.sessionKey);
+            // 兜底：assistant-item 订阅整轮没投出任何东西（核心命令/无 agent run 的轮次，
+            // 或 assistant 流缺失），但 deliver() 收到了正文——补发一次，避免 no_reply 静默。
+            if (!assistantItemDelivered && assistantItemFallback && deliverCallCount === 0) {
+                try {
+                    await postHttpDeliver({
+                        payloadForSend: assistantItemFallback.payloadForSend,
+                        textPart: assistantItemFallback.textPart,
+                        sendLabel: "Fallback reply (assistant item not delivered)",
+                        invokeNum: deliverInvokeCount,
+                        hasMedia: false,
+                        omitDuplicateFileCaption: false,
+                    });
+                    log.info(`${logPrefix} [assistant-item] fallback HTTP send: assistant subscription produced ` +
+                        `no item this turn; sent textLen=${assistantItemFallback.textPart.length}`);
+                }
+                catch (fbErr) {
+                    lastDeliverError = fbErr;
+                    log.error(`${logPrefix} [assistant-item] fallback send failed: ${String(fbErr)}`);
+                }
+            }
+        }
+        try {
+            await flushSegmentBuffer("final");
+        }
+        catch (flushErr) {
+            lastDeliverError = flushErr;
+            log.error(`${logPrefix} [deliver-buffer] flush_final failed: ${String(flushErr)}`);
+        }
+        clearTimeout(firstReplyTimeout);
+        const terminalState = await terminal.finalizeAndDeliver({
+            sendFn: terminalSend,
+            dispatchThrew: dispatchError !== undefined,
+            dispatchError,
+            lastDeliverError,
+            beforeAgentRunBlocked: dispatchResult?.beforeAgentRunBlocked === true,
+            deliverInvokeCount,
+            deliverCallCount,
+        });
+        const endReason = terminalState === "success" ||
+            hasFirstReply ||
+            terminal.wasTerminalDelivered() ||
+            terminal.didTimeoutFire() ||
+            subagentNotificationSent
+            ? "stop"
+            : "no_reply";
+        // `/stop` 仅借用 OpenClaw dispatch 触发 fast-abort；原轮次的 suspended/aborted
+        // 由 account-connection 在 dispatch 返回后串行收口，控制消息自身不产生 WS 事件。
+        if (isStopControl)
+            return;
+        // 当前业务轮次已被并发 `/stop` 接管时，收口事件由 interrupt-round 负责。
+        if (activeRound?.interrupted) {
+            log.info(`${logPrefix} [stream] round interrupted; skip late RUN_USAGE/FINISHED`);
+            return;
+        }
+        // —— 整轮收尾（OpenClaw 7.1+/8.x）：子任务流程中 dispatch 返回只是「一段 run 结束」，
+        // FINISHED/RUN_USAGE 必须等主会话出现非 yield 段终态（或静默兜底）后才发出，
+        // 否则会在主会话 resume 继续派发更多子任务时提前结束本轮。——
+        const finishWsRound = async (reason) => {
+            const roundKey = activeRound?.roundKey;
+            const generation = activeRound?.generation;
+            const hasRound = roundKey !== undefined && generation !== undefined;
+            if (hasRound && !roundExists(roundKey, generation)) {
+                log.info(`${logPrefix} [stream] round already completed/interrupted; skip late RUN_USAGE/FINISHED`);
+                turnForget(roundKey, generation);
+                return;
+            }
+            try {
+                const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
+                    agentId: config.agentId || "main",
+                });
+                const sessionFields = readSessionUsageFields({
+                    storePath,
+                    sessionKey: route.sessionKey,
+                });
+                const usage = buildRunUsageFromSessionEntry(sessionFields, {
+                    runId: agentRunId ?? terminal.getRunId(),
+                });
+                if (hasReportableUsage(usage) && usage) {
+                    await streamClient.streamUsage(toImStreamRunUsageData(usage, {
+                        groupId: params.groupId,
+                        replyToMsgId: params.msgId,
+                    }));
+                }
+                else {
+                    log.info(`${logPrefix} [stream] RUN_USAGE skipped (session store has no model/token; ` +
+                        `sessionKey=${route.sessionKey} deliver_call=${deliverCallCount})`);
+                }
+            }
+            catch (usageErr) {
+                log.warn(`${logPrefix} [stream] RUN_USAGE failed: ${String(usageErr)}`);
+            }
+            try {
+                await streamClient.end(reason, {
+                    groupId: params.groupId,
+                    replyToMsgId: params.msgId,
+                });
+                log.info(`${logPrefix} [stream] FINISHED sent: reason=${reason} terminal_state=${terminalState} ` +
+                    `has_first_reply=${hasFirstReply} deliver_invoke=${deliverInvokeCount} ` +
+                    `deliver_call=${deliverCallCount} skipped=${deliverSkippedCount}`);
+            }
+            catch (endErr) {
+                log.error(`${logPrefix} [stream] FINISHED failed: ${String(endErr)}`);
+            }
+            finally {
+                if (hasRound) {
+                    finalizeRoundMonitoring(roundKey, generation);
+                    completeActiveRound(roundKey, generation);
+                    turnForget(roundKey, generation);
+                }
+            }
+        };
+        const roundKey = activeRound?.roundKey;
+        const generation = activeRound?.generation;
+        const sawSubagent = subagentNotificationSent ||
+            (roundKey !== undefined && generation !== undefined &&
+                turnIsSawSubagent(roundKey, generation));
+        if (sawSubagent) {
+            turnEnsureRound(roundKey, generation);
+            turnOnDispatchReturned(roundKey, generation);
+            const deadline = Date.now() + TURN_END_WAIT_MAX_MS;
+            log.info(`${logPrefix} [stream] FINISHED deferred: subagent turn, waiting for lifecycle ` +
+                `final segment (no premature finish on resume). reason=${endReason} ` +
+                `terminal_state=${terminalState} deliver_invoke=${deliverInvokeCount}`);
+            const waitStartedAt = Date.now();
+            // 等待整轮结束信号（lifecycle 非 yield 终态 / 子任务完成后的静默兜底）；/
+            // 若轮次被 `/stop` 或其它收口移除，则由该路径发送过 aborted，这里直接退出。
+            while (!turnIsEligible(roundKey, generation)) {
+                if (!roundExists(roundKey, generation) || activeRound?.interrupted) {
+                    log.info(`${logPrefix} [stream] round interrupted while waiting; skip late RUN_USAGE/FINISHED`);
+                    turnForget(roundKey, generation);
+                    return;
+                }
+                if (Date.now() > deadline) {
+                    log.warn(`${logPrefix} [stream] turn-end wait exceeded ${TURN_END_WAIT_MAX_MS}ms; force finishing`);
+                    break;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+            log.info(`${logPrefix} [stream] turn-end released round=${roundKey}#${generation} ` +
+                `eligible=${turnIsEligible(roundKey, generation)} waitMs=${Date.now() - waitStartedAt}`);
+            await finishWsRound(endReason);
+        }
+        else {
+            // 无子任务的普通轮次：dispatch 返回即整轮结束，立即收尾（保持既有行为）。
+            if (roundKey !== undefined && generation !== undefined) {
+                turnEnsureRound(roundKey, generation);
+                turnOnDispatchReturned(roundKey, generation);
+            }
+            await finishWsRound(endReason);
+        }
+    }
+}
+//# sourceMappingURL=dispatch-mentioned-reply.js.map