@xgjktech/xg_cwork_im 1.19.21 → 1.19.22

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

@@ -1,997 +0,0 @@
-/**
- * @ 触发的单轮回复：WebSocket BEGIN、OpenClaw dispatchReplyWithBufferedBlockDispatcher、HTTP deliver、RUN_USAGE、FINISHED。
- */
-import { isImSingleChat, resolveSendMessageReply } from "./inbound-chat-type.js";
-import { buildTerminalSendFn, InboundTerminalController, } from "./inbound-terminal-delivery.js";
-import { formatConfirmedUpstreamErrorForIm } from "./user-facing-errors.js";
-import { shouldOmitDuplicateFileCaption, shouldSuppressDuplicateTextDeliver, stripMediaDirectiveLines, stripModelUsageFooter, } from "./deliver-text.js";
-import { shouldSuppressFallbackNoticeForIm } from "./per-message-fallback-notice.js";
-import { resolveThinkingWsDisplayUpdate, THINKING_WS_SUMMARY_HINT, ThinkingWsBuffer, WS_THINKING_DISPLAY_MAX, } from "./thinking-ws-progress.js";
-import { resolveItemEventGuard } from "./item-event-guard.js";
-import { clearPendingPerMessageModel, setPendingPerMessageModel, splitModelRef, } from "./per-message-model-pending.js";
-import { resolveSessionModelFallbackContext } from "./session-model-fallback.js";
-import { IM_BLOCK_STREAMING_COALESCE_DEFAULT, isDeliverAssistantItemsEnabled, isDeliverPartialSnapshotEnabled, isDeliverSegmentBufferEnabled, isInboundBlockStreamingEnabled, resolveBlockStreamingReplyOptions, resolveDispatchOpenClawCfg, } from "./channel-config.js";
-import { clearAssistantItemSink, setAssistantItemSink } from "./assistant-item-sink.js";
-import { flushAssistantItem, resetAssistantItem } from "./assistant-item-delivery.js";
-import { sendReplyDeliverBlock, sendTextMessage } from "./send-service.js";
-import { isDeliverPayloadSendable, snapshotSupersedesBufferText, TurnDeliverBuffer } from "./turn-deliver-buffer.js";
-import { buildRunUsageFromSessionEntry, hasReportableUsage, toImStreamRunUsageData } from "./run-usage.js";
-import { readSessionUsageFields } from "./run-usage-session.js";
-import { finalizeRoundMonitoring } from "./subagent-monitor.js";
-import { registerCorePlanSnapshotClient } from "./plan-core-snapshot.js";
-import { setSessionImContext } from "./session-im-context.js";
-import { completeActiveRound, registerActiveRound, roundExists, } from "./active-round-registry.js";
-import { turnEnsureRound, turnForget, turnIsEligible, turnIsSawSubagent, turnOnDispatchReturned, } from "./turn-end-controller.js";
-import { noteWrappedRunId } from "./turn-agent-event-subscription.js";
-import { resolveNasVolumeDispatchConfig } from "./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 = resolveNasVolumeDispatchConfig({
-                cfg: baseDispatchCfg,
-                config,
-                agentId: route.agentId,
-                sessionKey: route.sessionKey,
-                volumes: nasVolumes,
-            });
-        }
-        catch (error) {
-            // NAS 是可选增强信息。任何非法声明或运行时挂载校验失败都不得阻断原消息。
-            log.warn(`${logPrefix} [nas-volumes] invalid mount ignored: ${String(error)}`);
-            try {
-                // 若本会话此前已有有效声明，继续复用它；否则完全退回原 dispatch 配置。
-                nasDispatch = resolveNasVolumeDispatchConfig({
-                    cfg: baseDispatchCfg,
-                    config,
-                    agentId: route.agentId,
-                    sessionKey: route.sessionKey,
-                });
-            }
-            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) {
-            log.info(`${logPrefix} [nas-volumes] session=${route.sessionKey} volumes=${nasVolumes?.length ?? "cached"} ` +
-                `spec=${nasDispatch.specHash.slice(0, 12)} reused=${nasDispatch.reused}` +
-                ` configOverride=${Boolean(nasConfigOverride)}`);
-        }
-        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