@dcrays/dcgchat 0.4.13 → 0.4.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/dcgchat",
-  "version": "0.4.13",
+  "version": "0.4.24",
   "type": "module",
   "description": "OpenClaw channel plugin for 书灵墨宝 (WebSocket)",
   "main": "index.ts",

package/src/bot.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto'
 import path from 'node:path'
 import type { ReplyPayload } from 'openclaw/plugin-sdk'
 import { createReplyPrefixContext, createTypingCallbacks } from 'openclaw/plugin-sdk'
@@ -14,10 +15,20 @@ import { resolveAccount, sendDcgchatMedia } from './channel.js'
 import { generateSignUrl } from './request/api.js'
 import { sendChunk, sendFinal, sendText as sendTextMsg, sendError, wsSendRaw, sendText } from './transport.js'
 import { dcgLogger } from './utils/log.js'
-import { channelInfo, systemCommand, interruptCommand, ENV, ignoreToolCommand } from './utils/constant.js'
-import { sendGatewayRpc } from './gateway/socket.js'
+import { channelInfo, systemCommand, stopCommand, ENV, ignoreToolCommand } from './utils/constant.js'
 import { clearParamsMessage, getEffectiveMsgParams, setParamsMessage } from './utils/params.js'
-import { getChildSessionKeysTrackedForRequester, resetSubagentStateForRequesterSession, waitUntilSubagentsIdle } from './tool.js'
+import { waitUntilSubagentsIdle } from './tool.js'
+import {
+  beginSupersedingUserTurn,
+  clearActiveRunIdForSession,
+  clearSessionStreamSuppression,
+  interruptLocalDispatchAndGateway,
+  isSessionStreamSuppressed,
+  preemptInboundQueueForStop,
+  releaseDispatchAbortIfCurrent,
+  runInboundTurnSequenced,
+  setActiveRunIdForSession
+} from './sessionTermination.js'
 
 type MediaInfo = {
   path: string
@@ -30,14 +41,18 @@ type TFileInfo = { name: string; url: string }
 
 const mediaMaxBytes = 300 * 1024 * 1024
 
-/** 当前会话最近一次 agent run 的 runId（供 chat.abort 精确打断；无则仅传 sessionKey 仍会中止该会话全部活动运行） */
-const activeRunIdBySessionKey = new Map<string, string>()
-
 /**
- * 用户在该 sessionKey 上触发打断后，旧 run 的流式/投递不再下发；与 sessionKey 一一对应，支持多会话。
- * 清除时机：① 下一条非打断用户消息开始处理时；② 旧 run 收尾到 mobook 段时若仍抑制则跳过并发后删除。
+ * 每条入站消息（含 /stop）递增。用于丢弃「已被后续入站抢占」的处理在 dispatch 结束后的尾部逻辑。
+ * 仅 /stop 时的 epoch 无法覆盖「新用户消息抢占上一轮」的并发 WS 场景，会导致旧 handler 仍执行 sendFinal(end)、
+ * 而新消息被误判为 stale；且上一轮若未对网关 chat.abort，服务端 run 会继续，表现为「新消息秒结束、旧回复复活」。
  */
-const sessionStreamSuppressed = new Set<string>()
+const inboundGenerationBySessionKey = new Map<string, number>()
+
+function bumpInboundGeneration(sessionKey: string): number {
+  const n = (inboundGenerationBySessionKey.get(sessionKey) ?? 0) + 1
+  inboundGenerationBySessionKey.set(sessionKey, n)
+  return n
+}
 
 /** 各 sessionKey 当前轮回复的流式分片序号（仅统计实际下发的文本 chunk）；每轮非打断消息开始时置 0 */
 const streamChunkIdxBySessionKey = new Map<string, number>()
@@ -140,16 +155,29 @@ const typingCallbacks = createTypingCallbacks({
 })
 
 /**
- * 处理一条用户消息，调用 Agent 并返回回复
+ * 处理一条用户消息，调用 Agent 并返回回复（同会话串行见 sessionTermination.runInboundTurnSequenced）。
  */
 export async function handleDcgchatMessage(msg: InboundMessage, accountId: string): Promise<void> {
-  let completeText = ''
   const config = getOpenClawConfig()
   if (!config) {
     dcgLogger('no config available', 'error')
     return
   }
   const account = resolveAccount(config, accountId)
+  const queueSessionKey = getSessionKey(msg.content, account.accountId)
+  const queueText = (msg.content.text ?? '').trim()
+  if (stopCommand.includes(queueText)) {
+    preemptInboundQueueForStop(queueSessionKey)
+  }
+  await runInboundTurnSequenced(queueSessionKey, () => handleDcgchatMessageInboundTurn(msg, accountId))
+}
+
+async function handleDcgchatMessageInboundTurn(msg: InboundMessage, accountId: string): Promise<void> {
+  const config = getOpenClawConfig()
+  if (!config) {
+    return
+  }
+  const account = resolveAccount(config, accountId)
   const userId = msg._userId.toString()
 
   const core = getDcgchatRuntime()
@@ -168,6 +196,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
 
   const effectiveAgentId = embeddedAgentId ?? route.agentId
   const dcgSessionKey = getSessionKey(msg.content, account.accountId)
+  const inboundGenAtStart = bumpInboundGeneration(dcgSessionKey)
 
   const mergedParams = {
     userId: msg._userId,
@@ -175,7 +204,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     sessionId: conversationId,
     messageId: msg.content.message_id,
     domainId: msg.content.domain_id,
-    appId: msg.content.app_id,
+    appId: config.channels?.["dcgchat"]?.appId || 100,
     botId: msg.content.bot_id ?? '',
     agentId: msg.content.agent_id ?? '',
     sessionKey: dcgSessionKey,
@@ -195,6 +224,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
   if (!text) {
     sendTextMsg('你需要我帮你做什么呢？', outboundCtx)
     sendFinal(outboundCtx, 'not text')
+    setMsgStatus(dcgSessionKey, 'finished')
     return
   }
 
@@ -251,7 +281,8 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
 
     const sentMediaKeys = new Set<string>()
     const getMediaKey = (url: string) => url.split(/[\\/]/).pop() ?? url
-    let streamedTextLen = 0
+    /** 与 Feishu snapshot 模式一致：payload.text 为当前轮助手全文快照，据此算增量，避免工具前后快照变短或非单调时丢字 */
+    let lastStreamSnapshot = ''
 
     if (msg.content.skills_scope.length > 0 && !msg.content?.agent_clone_code && !ignoreToolCommand.includes(text?.trim())) {
       const workspaceDir = getWorkspaceDir()
@@ -274,7 +305,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       humanDelay: core.channel.reply.resolveHumanDelayConfig(config, route.agentId),
       onReplyStart: async () => {},
       deliver: async (payload: ReplyPayload, info) => {
-        if (sessionStreamSuppressed.has(dcgSessionKey)) return
+        if (isSessionStreamSuppressed(dcgSessionKey)) return
         const mediaList = resolveReplyMediaList(payload)
         for (const mediaUrl of mediaList) {
           const key = getMediaKey(mediaUrl)
@@ -287,9 +318,9 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       onError: (err: unknown, info: { kind: string }) => {
         setMsgStatus(dcgSessionKey, 'finished')
         sendFinal(outboundCtx, 'error')
-        activeRunIdBySessionKey.delete(dcgSessionKey)
+        clearActiveRunIdForSession(dcgSessionKey)
         streamChunkIdxBySessionKey.delete(dcgSessionKey)
-        const suppressed = sessionStreamSuppressed.has(dcgSessionKey)
+        const suppressed = isSessionStreamSuppressed(dcgSessionKey)
         dcgLogger(`${info.kind} reply failed${suppressed ? ' (stream suppressed)' : ''}: ${String(err)}`, 'error')
       },
       onIdle: () => {
@@ -297,10 +328,11 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       }
     })
 
+    let dispatchAbort: AbortController | undefined
     try {
-      if (!interruptCommand.includes(text?.trim())) {
-        sessionStreamSuppressed.delete(dcgSessionKey)
+      if (!stopCommand.includes(text?.trim())) {
         streamChunkIdxBySessionKey.set(dcgSessionKey, 0)
+        dispatchAbort = await beginSupersedingUserTurn(dcgSessionKey)
       }
 
       if (systemCommand.includes(text?.trim())) {
@@ -315,49 +347,22 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
               dispatcher,
               replyOptions: {
                 ...replyOptions,
+                abortSignal: dispatchAbort!.signal,
                 onModelSelected: prefixContext.onModelSelected,
                 onAgentRunStart: (runId) => {
-                  activeRunIdBySessionKey.set(dcgSessionKey, runId)
+                  setActiveRunIdForSession(dcgSessionKey, runId)
                 }
               }
             })
         })
-      } else if (interruptCommand.includes(text?.trim())) {
-        dcgLogger(`interrupt command: ${text}`)
+      } else if (stopCommand.includes(text?.trim())) {
         const ctxForAbort = priorOutboundCtx.messageId?.trim() || priorOutboundCtx.sessionId?.trim() ? priorOutboundCtx : outboundCtx
-        sendFinal(ctxForAbort.messageId?.trim() ? ctxForAbort : { ...ctxForAbort, messageId: `${Date.now()}` }, 'abort')
-        sendText('会话已终止', outboundCtx)
-        sessionStreamSuppressed.add(dcgSessionKey)
-        const abortOneSession = async (sessionKey: string) => {
-          try {
-            await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey } })
-          } catch (e) {
-            dcgLogger(`chat.abort ${sessionKey}: ${String(e)}`, 'error')
-          }
-        }
-        const keysToAbort = new Set<string>(getChildSessionKeysTrackedForRequester(dcgSessionKey))
-        try {
-          const listed = await sendGatewayRpc<{ sessions?: Array<{ key?: string }> }>({
-            method: 'sessions.list',
-            params: { spawnedBy: dcgSessionKey, limit: 256 }
-          })
-          for (const s of listed?.sessions ?? []) {
-            const k = typeof s?.key === 'string' ? s.key.trim() : ''
-            if (k) keysToAbort.add(k)
-          }
-        } catch (e) {
-          dcgLogger(`sessions.list spawnedBy: ${String(e)}`, 'error')
-        }
-        for (const sk of keysToAbort) {
-          await abortOneSession(sk)
-        }
-        await abortOneSession(dcgSessionKey)
+        await interruptLocalDispatchAndGateway(dcgSessionKey, ctxForAbort)
         streamChunkIdxBySessionKey.delete(dcgSessionKey)
-        resetSubagentStateForRequesterSession(dcgSessionKey)
-        setMsgStatus(dcgSessionKey, 'finished')
         clearSentMediaKeys(msg.content.message_id)
+        setMsgStatus(dcgSessionKey, 'finished')
         clearParamsMessage(dcgSessionKey)
-        clearParamsMessage(userId)
+        sendText('会话已终止', outboundCtx)
         sendFinal(outboundCtx, 'stop')
         return
       } else {
@@ -387,29 +392,35 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
               dispatcher,
               replyOptions: {
                 ...replyOptions,
+                abortSignal: dispatchAbort!.signal,
                 onModelSelected: prefixContext.onModelSelected,
                 onAgentRunStart: (runId) => {
-                  activeRunIdBySessionKey.set(dcgSessionKey, runId)
+                  setActiveRunIdForSession(dcgSessionKey, runId)
                 },
                 onPartialReply: async (payload: ReplyPayload) => {
-                  if (sessionStreamSuppressed.has(dcgSessionKey)) return
+                  if (isSessionStreamSuppressed(dcgSessionKey)) return
 
-                  if (payload.text) {
-                    completeText = payload.text
-                  }
                   // --- Streaming text chunks ---
                   if (payload.text) {
-                    const delta = payload.text.startsWith(completeText.slice(0, streamedTextLen))
-                      ? payload.text.slice(streamedTextLen)
-                      : payload.text
+                    const t = payload.text
+                    let delta = ''
+                    if (t.startsWith(lastStreamSnapshot)) {
+                      delta = t.slice(lastStreamSnapshot.length)
+                      lastStreamSnapshot = t
+                    } else if (lastStreamSnapshot.startsWith(t)) {
+                      // 快照缩短（模型修订等）：不重复下发
+                    } else {
+                      // 与上一轮快照不衔接（常见于工具后快照从新的助手片段重新开始）：整段下发
+                      delta = t
+                      lastStreamSnapshot = t
+                    }
                     if (delta.trim()) {
                       const prev = streamChunkIdxBySessionKey.get(dcgSessionKey) ?? 0
                       streamChunkIdxBySessionKey.set(dcgSessionKey, prev + 1)
                       sendChunk(delta, outboundCtx, prev)
                     }
-                    streamedTextLen = payload.text.length
                   } else {
-                    dcgLogger(`onPartialReply no text: ${JSON.stringify(payload)}`, 'error')
+                    dcgLogger(`onPartialReply no text (media/tool metadata): ${JSON.stringify(payload)}`)
                   }
                   // --- Media from payload ---
                   const mediaList = resolveReplyMediaList(payload)
@@ -425,17 +436,37 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         })
       }
     } catch (err: unknown) {
-      dcgLogger(` dispatchReplyFromConfig error: ${String(err)}`, 'error')
+      dcgLogger(`handleDcgchatMessage error: ${String(err)}`, 'error')
+      if ((inboundGenerationBySessionKey.get(dcgSessionKey) ?? 0) === inboundGenAtStart) {
+        setMsgStatus(dcgSessionKey, 'finished')
+      }
+    } finally {
+      releaseDispatchAbortIfCurrent(dcgSessionKey, dispatchAbort)
     }
 
-    if (![...systemCommand, ...interruptCommand].includes(text?.trim())) {
-      if (sessionStreamSuppressed.has(dcgSessionKey)) {
-        sessionStreamSuppressed.delete(dcgSessionKey)
+    const inboundGenNow = inboundGenerationBySessionKey.get(dcgSessionKey) ?? 0
+    if (inboundGenNow !== inboundGenAtStart) {
+      dcgLogger(`skip post-reply tail: sessionKey=${dcgSessionKey} (stale handler: inbound gen ${inboundGenAtStart}→${inboundGenNow})`)
+      return
+    }
+
+    if (![...systemCommand, ...stopCommand].includes(text?.trim())) {
+      if (isSessionStreamSuppressed(dcgSessionKey)) {
+        clearSessionStreamSuppression(dcgSessionKey)
       }
     }
     clearSentMediaKeys(msg.content.message_id)
     const storePath = core.channel.session.resolveStorePath(config.session?.store)
     await waitUntilSubagentsIdle(dcgSessionKey, { timeoutMs: 600_000 })
+    // 等待子 agent 期间可能已有新入站消息（generation 已变），不能再 end/finished，否则会误结束新轮或放行错挂的正文。
+    if ((inboundGenerationBySessionKey.get(dcgSessionKey) ?? 0) !== inboundGenAtStart) {
+      dcgLogger(
+        `skip post-wait tail: sessionKey=${dcgSessionKey} (stale handler after subagent wait: inbound gen ${inboundGenAtStart}→${inboundGenerationBySessionKey.get(dcgSessionKey)})`
+      )
+      return
+    }
+    clearActiveRunIdForSession(dcgSessionKey)
+    setMsgStatus(dcgSessionKey, 'finished')
     sendFinal(outboundCtx, 'end')
     dcgLogger(`record session route: updateLastRoute.to=${dcgSessionKey}, accountId=${route.accountId}`)
     core.channel.session
@@ -458,6 +489,9 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       })
   } catch (err) {
     dcgLogger(` handle message failed: ${String(err)}`, 'error')
+    if ((inboundGenerationBySessionKey.get(dcgSessionKey) ?? 0) === inboundGenAtStart) {
+      setMsgStatus(dcgSessionKey, 'finished')
+    }
     sendError(err instanceof Error ? err.message : String(err), outboundCtx)
   }
 }

package/src/channel.ts

@@ -1,3 +1,4 @@
+import fs from 'node:fs'
 import type { ChannelPlugin, OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk'
 import { createPluginRuntimeStore, DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk'
 import type { ResolvedDcgchatAccount, DcgchatConfig } from './types.js'
@@ -8,12 +9,15 @@ import {
   getDcgchatRuntime,
   getInfoBySessionKey,
   getOpenClawConfig,
-  hasSentMediaKey
+  hasSentMediaKey,
+  setCronMessageId
 } from './utils/global.js'
 import { isWsOpen, mergeDefaultParams, mergeSessionParams, sendFinal, wsSendRaw } from './transport.js'
 import { dcgLogger, setLogger } from './utils/log.js'
 import { getOutboundMsgParams, getParamsMessage } from './utils/params.js'
+import { isSessionActiveForTool } from './tool.js'
 import { startDcgchatGatewaySocket } from './gateway/socket.js'
+import { getCronJobsPath, readCronJob } from './cron.js'
 
 function dcgchatChannelCfg(): DcgchatConfig {
   return (getOpenClawConfig()?.channels?.["dcgchat"] as DcgchatConfig | undefined) ?? {}
@@ -61,6 +65,8 @@ export type DcgchatMediaSendOptions = {
   sessionKey: string
   mediaUrl?: string
   text?: string
+  /** 定时任务等场景须与 `getCronMessageId` 一致，避免沿用 map 里上一条用户消息的 messageId */
+  messageId?: string
 }
 
 function normalizeSessionTarget(rawTo: string): string {
@@ -69,6 +75,29 @@ function normalizeSessionTarget(rawTo: string): string {
   return getParamsMessage(cleaned)?.sessionKey?.trim() || cleaned
 }
 
+/**
+ * OpenClaw 定时任务 `sessionTarget: isolated` 时，出站 `to` 常为 `agent:<code>:cron:<jobId>[:run:…]`，
+ * 与 `paramsMessageMap` / `getCronMessageId` 使用的 jobs.json `sessionKey`（mobook 用户会话）不一致，导致发文件时 sessionId、messageId 错位或缺省。
+ */
+function extractCronJobIdFromIsolatedSessionKey(sessionKey: string): string | null {
+  const parts = sessionKey.split(':').filter((p) => p.length > 0)
+  const i = parts.findIndex((p) => p.toLowerCase() === 'cron')
+  if (i < 0 || i + 1 >= parts.length) return null
+  return parts[i + 1] ?? null
+}
+
+function resolveIsolatedCronSessionToJobSessionKey(sessionKey: string): string {
+  const jobId = extractCronJobIdFromIsolatedSessionKey(sessionKey)
+  if (!jobId) return sessionKey
+  const job = readCronJob(getCronJobsPath(), jobId)
+  const sk = job && typeof job.sessionKey === 'string' ? job.sessionKey.trim() : ''
+  if (!sk) {
+    dcgLogger(`dcgchat: cron job ${jobId} has no sessionKey in jobs.json, keep outbound key=${sessionKey}`, 'error')
+    return sessionKey
+  }
+  return sk
+}
+
 /** 出站返回的 chatId：含 `dcg-cron:` 时保留原始 `to`，便于下游识别定时投递 */
 function outboundChatId(rawTo: string | undefined, normalizedTo: string): string {
   const raw = rawTo?.trim() ?? ''
@@ -76,38 +105,78 @@ function outboundChatId(rawTo: string | undefined, normalizedTo: string): string
 }
 
 export async function sendDcgchatMedia(opts: DcgchatMediaSendOptions): Promise<void> {
-  const sessionKey = normalizeSessionTarget(opts.sessionKey ?? '')
-  const msgCtx = getOutboundMsgParams(sessionKey)
+  const rawOpt = (opts.sessionKey ?? '').trim()
+  const strippedForCron = rawOpt.replace(/^dcg-cron:/i, '').trim()
+  const fromIsolatedCron = extractCronJobIdFromIsolatedSessionKey(strippedForCron) !== null
+  const fromDcgCronWrapper = rawOpt.toLowerCase().startsWith('dcg-cron:')
+
+  let sessionKey = normalizeSessionTarget(opts.sessionKey ?? '')
+  sessionKey = resolveIsolatedCronSessionToJobSessionKey(sessionKey)
+
+  /** 定时自动执行未走 onRunCronJob，须与 finishedDcgchatCron 共用同一 messageId，否则附件与气泡错位 */
+  if (!opts.messageId?.trim() && (fromIsolatedCron || fromDcgCronWrapper) && !getCronMessageId(sessionKey)) {
+    setCronMessageId(sessionKey, `${Date.now()}`)
+  }
+
+  const cronMid = getCronMessageId(sessionKey)
+  const baseCtx = getOutboundMsgParams(sessionKey)
+  const msgCtx = opts.messageId?.trim()
+    ? { ...baseCtx, messageId: opts.messageId.trim() }
+    : cronMid
+      ? { ...baseCtx, messageId: cronMid }
+      : baseCtx
   if (!isWsOpen()) {
-    dcgLogger(`outbound media skipped -> ws not open: ${opts.mediaUrl ?? ''}`)
+    dcgLogger(`outbound media skipped -> ws not isWsOpen failed open: ${opts.mediaUrl ?? ''}`)
     return
   }
 
-  const mediaUrl = opts.mediaUrl
-  const dedupeId = msgCtx.messageId
-  if (mediaUrl && dedupeId && hasSentMediaKey(dedupeId, mediaUrl)) {
-    dcgLogger(`dcgchat: sendMedia skipped (duplicate in session): ${mediaUrl}`)
+  const mediaUrl = opts.mediaUrl?.trim()
+  if (!mediaUrl || !msgCtx.sessionId) {
+    dcgLogger(`dcgchat: sendMedia skipped (duplicate in session): ${mediaUrl} sessionId=${msgCtx.sessionId} sessionKey=${sessionKey}`)
     return
   }
-  if (mediaUrl && dedupeId) {
-    addSentMediaKey(dedupeId, mediaUrl)
+  // 判断文件存在
+  try {
+    if (!fs.existsSync(mediaUrl)) {
+      dcgLogger(`dcgchat: sendMedia skipped (file not found): ${mediaUrl} sessionKey=${sessionKey}`, 'error')
+      return
+    }
+  } catch (err) {
+    dcgLogger(`dcgchat: sendMedia skipped (cannot stat path): ${mediaUrl} ${String(err)} sessionKey=${sessionKey}`, 'error')
   }
 
-  const fileName = mediaUrl?.split(/[\\/]/).pop() || ''
+  if (mediaUrl && msgCtx.sessionId) {
+    if (hasSentMediaKey(msgCtx.sessionId, mediaUrl)) {
+      dcgLogger(`dcgchat: sendMedia skipped (hasSentMediaKey): ${mediaUrl} sessionId=${msgCtx.sessionId} sessionKey=${sessionKey}`)
+      return
+    }
+    addSentMediaKey(msgCtx.sessionId, mediaUrl)
+  }
 
+  const { sessionId, agentId } = getInfoBySessionKey(sessionKey)
+  if (!msgCtx.sessionId) {
+    msgCtx.sessionId = sessionId
+  }
+  const fileName = mediaUrl?.split(/[\\/]/).pop() || ''
+  const notMessageId = `${msgCtx?.messageId}`?.length === 13 || !msgCtx?.messageId
   try {
     const botToken = msgCtx.botToken ?? getOpenClawConfig()?.channels?.["dcgchat"]?.botToken ?? ''
     const url = opts.mediaUrl ? await ossUpload(opts.mediaUrl, botToken, 1) : ''
+    if (!msgCtx.agentId) {
+      msgCtx.agentId = agentId
+    }
     wsSendRaw(msgCtx, {
       response: opts.text ?? '',
-      message_tags: { source: 'file' },
+      is_finish: notMessageId ? -1 : 0,
+      message_tags: notMessageId ? { mark: 'empty_text_file' } : {},
       files: [{ url, name: fileName }]
     })
     dcgLogger(`dcgchat: sendMedia session=${sessionKey}, file=${fileName}`)
   } catch (error) {
     wsSendRaw(msgCtx, {
       response: opts.text ?? '',
-      message_tags: { source: 'file' },
+      message_tags: notMessageId ? { mark: 'empty_text_file' } : {},
+      is_finish: notMessageId ? -1 : 0,
       files: [{ url: opts.mediaUrl ?? '', name: fileName }]
     })
     dcgLogger(`dcgchat: error sendMedia session=${sessionKey}: ${String(error)}`, 'error')
@@ -254,25 +323,21 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
         const isCron = ctx.to.indexOf('dcg-cron:') >= 0
         const outboundCtx = getOutboundMsgParams(to)
         const content: Record<string, unknown> = { response: ctx.text }
-        if (isCron) {
-          messageId = getCronMessageId(to) || `${Date.now()}`
-          const { sessionId, agentId } = getInfoBySessionKey(to)
-          content.is_finish = -1
-          content.message_tags = { source: 'cron' }
-          const merged = mergeDefaultParams({
-            agentId: agentId,
-            sessionId: `${sessionId}`,
-            messageId: messageId,
-            real_mobook: !sessionId ? 1 : ''
-          })
-          wsSendRaw(merged, content)
-        } else {
+        if (!isCron) {
           if (outboundCtx?.sessionId) {
+            // 入站 handler 已将本轮标为 running；若已 sendFinal(end) 则应为 finished。
+            // 否则网关/Core 晚到的正文会仍用「当前 params map」里的 messageId，错挂到后一条用户消息上。
+            if (!isSessionActiveForTool(to)) {
+              dcgLogger(`channel sendText dropped (session not active): to=${to}`)
+              return {
+                channel: "dcgchat",
+                messageId: '',
+                chatId: outboundChatId(ctx.to, to)
+              }
+            }
             messageId = outboundCtx?.messageId || `${Date.now()}`
             const newCtx = { ...outboundCtx, messageId }
             wsSendRaw(newCtx, content)
-          } else {
-            dcgLogger(`channel sendText to ${ctx.to} -> sessionId not found`, 'error')
           }
         }
       }
@@ -283,15 +348,19 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
       }
     },
     sendMedia: async (ctx) => {
-      const isCron = ctx.to.indexOf('dcg-cron:') >= 0
-      const to = normalizeSessionTarget(ctx.to)
+      const normalizedFromTo = normalizeSessionTarget(ctx.to)
+      const isCron = ctx.to.indexOf('dcg-cron:') >= 0 || extractCronJobIdFromIsolatedSessionKey(normalizedFromTo) !== null
+      const to = resolveIsolatedCronSessionToJobSessionKey(normalizedFromTo)
       const outboundCtx = getOutboundMsgParams(to)
       const msgCtx = getParamsMessage(to) ?? outboundCtx
+      if (isCron && !getCronMessageId(to)) {
+        setCronMessageId(to, `${Date.now()}`)
+      }
       const cronMsgId = getCronMessageId(to)
       const fallbackMessageId = `${Date.now()}`
       const messageId = cronMsgId || (isCron ? fallbackMessageId : msgCtx?.messageId || fallbackMessageId)
-
-      if (!outboundCtx?.sessionId) {
+      const { sessionId } = getInfoBySessionKey(to)
+      if (!sessionId) {
         dcgLogger(`channel sendMedia to ${ctx.to} -> sessionId not found`, 'error')
         return {
           channel: "dcgchat",
@@ -301,7 +370,11 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
       }
 
       dcgLogger(`channel sendMedia to ${ctx.to}`)
-      await sendDcgchatMedia({ sessionKey: to || '', mediaUrl: ctx.mediaUrl || '' })
+      await sendDcgchatMedia({
+        sessionKey: to || '',
+        mediaUrl: ctx.mediaUrl || '',
+        ...(isCron ? { messageId } : {})
+      })
       return {
         channel: "dcgchat",
         messageId,

package/src/cron.ts

@@ -1,7 +1,7 @@
 import path from 'node:path'
 import fs from 'node:fs'
 import type { IMsgParams } from './types.js'
-import { isWsOpen, mergeDefaultParams, sendEventMessage, sendFinal } from './transport.js'
+import { isWsOpen, mergeDefaultParams, sendEventMessage, sendFinal, wsSendRaw } from './transport.js'
 import { getCronMessageId, getWorkspaceDir, getWsConnection, removeCronMessageId, setCronMessageId } from './utils/global.js'
 import { ossUpload } from './request/oss.js'
 import { dcgLogger } from './utils/log.js'
@@ -135,7 +135,7 @@ export const onRunCronJob = async (jobId: string, messageId: string) => {
   )
   sendMessageToGateway(JSON.stringify({ method: 'cron.run', params: { id: jobId, mode: 'force' } }))
 }
-export const finishedDcgchatCron = async (jobId: string) => {
+export const finishedDcgchatCron = async (jobId: string, summary: string, hasFileOutput?: boolean) => {
   const id = jobId?.trim()
   if (!id) {
     dcgLogger('finishedDcgchatCron: empty jobId', 'error')
@@ -147,24 +147,27 @@ export const finishedDcgchatCron = async (jobId: string) => {
     dcgLogger(`finishedDcgchatCron: no sessionKey for job id=${id}`, 'error')
     return
   }
-  const outboundCtx = getEffectiveMsgParams(sessionKey)
-  const messageId = getCronMessageId(sessionKey)
+  const messageId = getCronMessageId(sessionKey) || `${Date.now()}`
   const sessionInfo = sessionKey.split(':')
   const sessionId = sessionInfo.at(-1) ?? ''
   const agentId = sessionInfo.at(-2) ?? ''
-  if (outboundCtx?.sessionId) {
-    const newCtx = messageId ? { ...outboundCtx, messageId } : outboundCtx
-    sendFinal(newCtx, 'cron send')
-  } else {
-    const merged = mergeDefaultParams({
-      agentId: agentId,
-      sessionId: `${sessionId}`,
-      messageId: messageId,
-      is_finish: -1,
-      real_mobook: !sessionId ? 1 : ''
-    })
-    sendFinal(merged, 'cron send')
+  // if (outboundCtx?.sessionId) {
+
+  const merged = mergeDefaultParams({
+    agentId: agentId,
+    sessionId: `${sessionId}`,
+    messageId: messageId || `${Date.now()}`,
+    real_mobook: !sessionId ? 1 : ''
+  })
+  const message_tags = { source: 'cron' } as Record<string, string | boolean>
+  if (hasFileOutput) {
+    message_tags.hasFile = true
   }
+  wsSendRaw(merged, { response: summary, message_tags, is_finish: -1 })
+  setTimeout(() => {
+    sendFinal(merged, 'cron send')
+  }, 200)
+  // }
   const ws = getWsConnection()
   const baseContent = getParamsDefaults()
   if (isWsOpen()) {

package/src/cronToolCall.ts

@@ -117,34 +117,44 @@ function needsBestEffort(delivery: CronDelivery): boolean {
 }
 
 /**
- * 深拷贝 params 并注入 bestEffort: true
+ * 深拷贝 params，在 delivery 上写入 dcg 路由（to / accountId / sessionKey）。
+ * bestEffort + 默认 channel 仅在 needsBestEffort 为真时写入（announce 且无 channel）。
+ *
+ * 说明：原先仅在 needsBestEffort 为真时才改 delivery，若 jobs 里已有 channel 会整段跳过，
+ * 导致 `delivery.to` 永远不会被本钩子写入；运行时若缺 to 就会一直 not-delivered。
  */
-function injectBestEffort(params: Record<string, unknown>, sk: string): Record<string, unknown> {
+function patchCronDeliveryInParams(
+  params: Record<string, unknown>,
+  sk: string,
+  deliverySnapshot: CronDelivery
+): Record<string, unknown> | null {
   const newParams = JSON.parse(JSON.stringify(params)) as Record<string, unknown>
-  const { agentId, sessionId } = formatterSessionKey(sk)
-  // 顶层 delivery
+  const { agentId } = formatterSessionKey(sk)
+  const announceNoChannel = needsBestEffort(deliverySnapshot)
+
+  const apply = (d: CronDelivery) => {
+    d.to = `dcg-cron:${sk}`
+    if (agentId) d.accountId = agentId
+    if (announceNoChannel) {
+      d.bestEffort = true
+      d.channel = 'dcgchat-test'
+    }
+  }
+
   if (newParams.delivery && typeof newParams.delivery === 'object') {
-    ;(newParams.delivery as CronDelivery).bestEffort = true
-    ;(newParams.delivery as CronDelivery).to = `dcg-cron:${sk}`
-    ;(newParams.delivery as CronDelivery).accountId = agentId
-    ;(newParams.delivery as CronDelivery).channel = "dcgchat"
+    apply(newParams.delivery as CronDelivery)
     newParams.sessionKey = sk
     return newParams
   }
 
-  // job.delivery（须改 job 内对象，勿写 newParams.delivery——顶层可能不存在）
   const job = newParams.job as Record<string, unknown> | undefined
   if (job?.delivery && typeof job.delivery === 'object') {
-    const del = job.delivery as CronDelivery
-    del.bestEffort = true
-    del.to = `dcg-cron:${sk}`
-    del.accountId = agentId
-    del.channel = "dcgchat"
+    apply(job.delivery as CronDelivery)
     newParams.sessionKey = sk
     return newParams
   }
 
-  return newParams
+  return null
 }
 
 export function cronToolCall(event: { toolName: any; params: any; toolCallId: any }, sk: string) {
@@ -155,34 +165,38 @@ export function cronToolCall(event: { toolName: any; params: any; toolCallId: an
     const delivery = extractDelivery(params)
     if (!delivery) {
       dcgLogger(`[${LOG_TAG}] cron call (${toolCallId}) has no delivery config, skip.`)
-      return params
+      return undefined
+    }
+    const newParams = patchCronDeliveryInParams(params, sk, delivery)
+    if (!newParams) {
+      dcgLogger(`[${LOG_TAG}] cron call (${toolCallId}) could not locate delivery on params clone, skip.`)
+      return undefined
     }
-    if (!needsBestEffort(delivery)) {
+
+    const patched = newParams.delivery ?? (newParams.job as Record<string, unknown>)?.delivery
+    if (needsBestEffort(delivery)) {
       dcgLogger(
-        `[${LOG_TAG}] cron call (${toolCallId}) delivery does not need bestEffort ` +
-          `(mode=${String(delivery.mode)}, channel=${String(delivery.channel)}, bestEffort=${String(delivery.bestEffort)}), skip.`
+        `[${LOG_TAG}] cron call (${toolCallId}) patched delivery (announce, no channel): bestEffort=true, ` +
+          `delivery=${JSON.stringify(patched)}`
+      )
+    } else {
+      dcgLogger(
+        `[${LOG_TAG}] cron call (${toolCallId}) patched delivery.to / accountId (sessionKey=${sk}), ` +
+          `delivery=${JSON.stringify(patched)}`
       )
-      return params
     }
 
-    // ★ 核心：注入 bestEffort: true
-    const newParams = injectBestEffort(params, sk)
-    dcgLogger(
-      `[${LOG_TAG}] cron call (${toolCallId}) injected bestEffort=true ` +
-        `(mode=announce, no channel). delivery=${JSON.stringify(newParams.delivery || (newParams.job as Record<string, unknown>)?.delivery)}`
-    )
-
     return { params: newParams }
   } else if (toolName === 'exec') {
     if (params.command.indexOf('cron create') > -1 || params.command.indexOf('cron add') > -1) {
       const newParams = JSON.parse(JSON.stringify(params)) as Record<string, unknown>
       newParams.command =
-        params.command.replace('--json', '') + `  --session-key ${sk}  --channel ${"dcgchat"}  --to dcg-cron:${sk} --json`
+        params.command.replace('--json', '') + `  --session-key ${sk}  --channel ${'dcgchat-test'}  --to dcg-cron:${sk} --json`
       return { params: newParams }
     } else {
-      return params
+      return undefined
     }
   }
 
-  return params
+  return undefined
 }

package/src/sessionTermination.ts

@@ -0,0 +1,154 @@
+/**
+ * 会话终止 / 抢占 / 网关 abort 的集中实现，便于单独调整策略与观测。
+ * 与 bot 的 generation、流式分片序号、入站业务上下文分离，仅负责：本地 AbortController、流抑制标记、
+ * 入站串行队尾、activeRunId、chat.abort 子会话→主会话。
+ */
+import { sendGatewayRpc } from './gateway/socket.js'
+import { sendFinal } from './transport.js'
+import type { IMsgParams } from './types.js'
+import { dcgLogger } from './utils/log.js'
+import { getDescendantSessionKeysForRequester, resetSubagentStateForRequesterSession } from './tool.js'
+
+// --- 状态（仅本模块内修改，供 bot 通过下方 API 使用）---
+
+/** 当前会话最近一次 agent run 的 runId（网关 chat.abort 主会话时携带） */
+const activeRunIdBySessionKey = new Map<string, string>()
+
+/** dispatchReplyFromConfig 使用的 AbortSignal，用于真正掐断工具与模型 */
+const dispatchAbortBySessionKey = new Map<string, AbortController>()
+
+/** 打断后抑制 deliver / onPartialReply 继续下发 */
+const sessionStreamSuppressed = new Set<string>()
+
+/**
+ * 同 sessionKey 入站串行队尾；与 Core session lane 对齐，避免并发 dispatch 过早返回。
+ */
+const inboundTurnTailBySessionKey = new Map<string, Promise<void>>()
+
+// --- activeRunId（供 bot 在 onAgentRunStart / 错误收尾时同步）---
+
+export function setActiveRunIdForSession(sessionKey: string, runId: string): void {
+  activeRunIdBySessionKey.set(sessionKey, runId)
+}
+
+export function clearActiveRunIdForSession(sessionKey: string): void {
+  activeRunIdBySessionKey.delete(sessionKey)
+}
+
+// --- 流抑制 ---
+
+export function isSessionStreamSuppressed(sessionKey: string): boolean {
+  return sessionStreamSuppressed.has(sessionKey)
+}
+
+export function clearSessionStreamSuppression(sessionKey: string): void {
+  sessionStreamSuppressed.delete(sessionKey)
+}
+
+export function markSessionStreamSuppressed(sessionKey: string): void {
+  sessionStreamSuppressed.add(sessionKey)
+}
+
+// --- 入站串行队列 ---
+
+/** /stop 入队前：掐断当前 in-process，并重置队尾，使本条 stop 不必等待已被 abort 的长 turn */
+export function preemptInboundQueueForStop(sessionKey: string): void {
+  const c = dispatchAbortBySessionKey.get(sessionKey)
+  if (c) {
+    c.abort()
+    dispatchAbortBySessionKey.delete(sessionKey)
+  }
+  inboundTurnTailBySessionKey.set(sessionKey, Promise.resolve())
+  dcgLogger(`inbound queue: reset tail for /stop sessionKey=${sessionKey}`)
+}
+
+/** 将本轮入站处理挂到 sessionKey 队尾，保证同会话顺序执行 */
+export async function runInboundTurnSequenced(sessionKey: string, run: () => Promise<void>): Promise<void> {
+  const prev = inboundTurnTailBySessionKey.get(sessionKey) ?? Promise.resolve()
+  const next = prev.catch(() => {}).then(run)
+  inboundTurnTailBySessionKey.set(sessionKey, next.catch(() => {}))
+  await next
+}
+
+// --- 网关 abort ---
+
+/**
+ * 终止网关上仍可能活跃的 run（子会话自深到浅，再主会话）。
+ * supersede：仅当有子会话或 mainRunId 时发 RPC；interrupt：主会话始终 chat.abort。
+ */
+export async function abortGatewayRunsForSession(sessionKey: string, reason: 'interrupt' | 'supersede'): Promise<void> {
+  const prefix = reason === 'interrupt' ? 'interrupt' : 'supersede'
+  const descendantKeys = getDescendantSessionKeysForRequester(sessionKey)
+  const abortSubKeys = [...descendantKeys].reverse()
+  const mainRunId = activeRunIdBySessionKey.get(sessionKey)
+
+  if (reason === 'supersede' && abortSubKeys.length === 0 && !mainRunId) {
+    return
+  }
+
+  if (abortSubKeys.length > 0) {
+    dcgLogger(`${prefix}: chat.abort ${abortSubKeys.length} subagent session(s) (nested incl.)`)
+  }
+  for (const subKey of abortSubKeys) {
+    try {
+      await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey: subKey } })
+    } catch (e) {
+      dcgLogger(`${prefix}: chat.abort subagent ${subKey}: ${String(e)}`, 'error')
+    }
+  }
+
+  const shouldMainAbort = reason === 'interrupt' || Boolean(mainRunId)
+  if (shouldMainAbort) {
+    try {
+      await sendGatewayRpc({
+        method: 'chat.abort',
+        params: mainRunId ? { sessionKey, runId: mainRunId } : { sessionKey }
+      })
+    } catch (e) {
+      dcgLogger(`${prefix}: chat.abort main ${sessionKey}: ${String(e)}`, 'error')
+    }
+  }
+
+  activeRunIdBySessionKey.delete(sessionKey)
+  resetSubagentStateForRequesterSession(sessionKey)
+}
+
+// --- 本地 dispatch AbortController ---
+
+/**
+ * 新一轮非 /stop 用户消息：清除流抑制、abort 上一轮 controller、网关 supersede，并安装新的 AbortController。
+ * 调用方须在之前或之后自行 `streamChunkIdxBySessionKey.set(sessionKey, 0)`。
+ */
+export async function beginSupersedingUserTurn(sessionKey: string): Promise<AbortController> {
+  sessionStreamSuppressed.delete(sessionKey)
+  dispatchAbortBySessionKey.get(sessionKey)?.abort()
+  await abortGatewayRunsForSession(sessionKey, 'supersede')
+  const ac = new AbortController()
+  dispatchAbortBySessionKey.set(sessionKey, ac)
+  return ac
+}
+
+/** try/finally 中：仅当仍是当前 controller 时从 map 移除 */
+export function releaseDispatchAbortIfCurrent(sessionKey: string, controller: AbortController | undefined): void {
+  if (controller && dispatchAbortBySessionKey.get(sessionKey) === controller) {
+    dispatchAbortBySessionKey.delete(sessionKey)
+  }
+}
+
+/**
+ * 用户发送 /stop：本地 abort、对「上一轮对话」发 abort final、标记流抑制、网关 interrupt。
+ * 之后的 clearSentMedia、params、UI「已终止」等由 bot 继续处理。
+ */
+export async function interruptLocalDispatchAndGateway(sessionKey: string, ctxForAbort: IMsgParams): Promise<void> {
+  dcgLogger(`interrupt command: sessionKey=${sessionKey}`)
+  const inFlight = dispatchAbortBySessionKey.get(sessionKey)
+  if (inFlight) {
+    dcgLogger(`interrupt: AbortController.abort() in-process run sessionKey=${sessionKey}`)
+    inFlight.abort()
+    dispatchAbortBySessionKey.delete(sessionKey)
+  }
+  const finalCtx = ctxForAbort.messageId?.trim() ? ctxForAbort : { ...ctxForAbort, messageId: `${Date.now()}` }
+  sendFinal(finalCtx, 'abort')
+  markSessionStreamSuppressed(sessionKey)
+  await abortGatewayRunsForSession(sessionKey, 'interrupt')
+}

package/src/tool.ts

@@ -51,8 +51,30 @@ const eventList = [
   { event: 'after_tool_call', message: '' }
 ]
 
+/** 子 agent 的 sessionKey 往往未写入 params map，回落到主会话 outbound 参数避免 messageId 缺失 */
+function resolveOutboundParamsForSession(sk: string) {
+  const k = sk.trim()
+  let params = getEffectiveMsgParams(k)
+  if (params.messageId?.trim() || params.sessionId?.trim()) return params
+  const parent = requesterByChildSessionKey.get(k)
+  if (parent) {
+    const parentParams = getEffectiveMsgParams(parent)
+    if (parentParams.messageId?.trim() || parentParams.sessionId?.trim()) return parentParams
+  }
+  return params
+}
+
+/** 主会话已 running 时，子会话上的工具/事件也应下发（否则子 key 无 running 状态会整段丢消息） */
+export function isSessionActiveForTool(sk: string): boolean {
+  const k = sk.trim()
+  if (!k) return false
+  if (getMsgStatus(k) === 'running') return true
+  const parent = requesterByChildSessionKey.get(k)
+  return parent ? getMsgStatus(parent) === 'running' : false
+}
+
 function sendToolCallMessage(sk: string, text: string, toolCallId: string, isCover: number) {
-  const params = getEffectiveMsgParams(sk)
+  const params = resolveOutboundParamsForSession(sk)
   const content = { is_finish: -1, tool_call_id: toolCallId, is_cover: isCover, thinking_content: text, response: '' }
   wsSendRaw(params, content, false)
 }
@@ -158,6 +180,29 @@ export function getChildSessionKeysTrackedForRequester(requesterSessionKey: stri
   return out
 }
 
+/**
+ * 自根 requester 起 BFS 收集所有已跟踪后代子会话（含嵌套）。网关 abort 时宜自深到浅，调用方对结果 `.reverse()` 后再逐个 chat.abort。
+ */
+export function getDescendantSessionKeysForRequester(rootRequesterSessionKey: string): string[] {
+  const root = rootRequesterSessionKey.trim()
+  if (!root) return []
+  const ordered: string[] = []
+  const seen = new Set<string>()
+  let frontier = getChildSessionKeysTrackedForRequester(root)
+  while (frontier.length > 0) {
+    const next: string[] = []
+    for (const sk of frontier) {
+      const k = sk.trim()
+      if (!k || seen.has(k)) continue
+      seen.add(k)
+      ordered.push(k)
+      next.push(...getChildSessionKeysTrackedForRequester(k))
+    }
+    frontier = next
+  }
+  return ordered
+}
+
 /**
  * 打断后清空本地子 agent 跟踪（runId、父子映射、子 runId→sessionKey），并唤醒 waitUntilSubagentsIdle，避免永久挂起。
  */
@@ -280,6 +325,16 @@ function resolveHookSessionKey(
   return (args?.sessionKey || '').trim()
 }
 
+/** 定时触发时会话往往非 running，但仍需跑 before_tool_call 以注入 sessionKey / delivery（见 cronToolCall） */
+function shouldRunBeforeToolCallWithoutRunningSession(event: { toolName?: string; params?: { command?: string } }): boolean {
+  if (event?.toolName === 'cron') return true
+  const cmd = event?.params?.command
+  if (event?.toolName === 'exec' && typeof cmd === 'string') {
+    return cmd.includes('cron create') || cmd.includes('cron add')
+  }
+  return false
+}
+
 function trackSubagentLifecycle(eventName: string, event: any, args: any): void {
   if (eventName === 'subagent_spawned') {
     const runId = typeof event?.runId === 'string' ? event.runId : ''
@@ -306,14 +361,24 @@ export function monitoringToolMessage(api: OpenClawPluginApi) {
       trackSubagentLifecycle(item.event, event, args)
       const sk = resolveHookSessionKey(item.event, args ?? {})
       if (sk) {
-        const status = getMsgStatus(sk)
-        if (status === 'running') {
+        const toolHooksOk =
+          isSessionActiveForTool(sk) || (item.event === 'before_tool_call' && shouldRunBeforeToolCallWithoutRunningSession(event))
+        if (toolHooksOk) {
           if (['after_tool_call', 'before_tool_call'].includes(item.event)) {
             const { result: _result, ...rest } = event
             dcgLogger(`工具调用结果： ~ event:${item.event} ~ params:${JSON.stringify(rest)}`)
 
             if (item.event === 'before_tool_call') {
-              return cronToolCall(rest, sk)
+              const hookResult = cronToolCall(rest, sk)
+              const text = JSON.stringify({
+                type: item.event,
+                specialIdentification: 'dcgchat_tool_call_special_identification',
+                callId: event.toolCallId || event.runId || Date.now().toString(),
+                ...rest,
+                status: 'running'
+              })
+              sendToolCallMessage(sk, text, event.toolCallId || event.runId || Date.now().toString(), 0)
+              return hookResult
             }
             const text = JSON.stringify({
               type: item.event,
@@ -329,7 +394,7 @@ export function monitoringToolMessage(api: OpenClawPluginApi) {
               item.event === 'after_tool_call' ? 1 : 0
             )
           } else if (item.event) {
-            const msgCtx = getEffectiveMsgParams(sk)
+            const msgCtx = resolveOutboundParamsForSession(sk)
             if (item.event === 'llm_output') {
               if (event.lastAssistant?.errorMessage === '1003-额度不足请充值') {
                 const message = '您的积分已消耗完，您可以通过充值积分来继续使用'
@@ -346,7 +411,7 @@ export function monitoringToolMessage(api: OpenClawPluginApi) {
               params: item.message
             })
             sendToolCallMessage(sk, text, event.runId || Date.now().toString(), 0)
-            dcgLogger(`工具调用结果： ~ event:${item.event} ${status}`)
+            dcgLogger(`工具调用结果： ~ event:${item.event}`)
           }
         }
       } else if (item.event !== 'before_tool_call') {

package/src/transport.ts

@@ -1,4 +1,4 @@
-import { getWsConnection } from './utils/global.js'
+import { clearSentMediaKeys, getWsConnection } from './utils/global.js'
 import { dcgLogger } from './utils/log.js'
 import type { IMsgParams } from './types.js'
 import { getEffectiveMsgParams, getParamsDefaults } from './utils/params.js'
@@ -170,6 +170,7 @@ export function sendChunk(text: string, ctx: IMsgParams, chunkIdx: number): bool
 
 export function sendFinal(ctx: IMsgParams, tag: string): boolean {
   dcgLogger(` message handling complete state: to=${ctx.sessionId} final tag:${tag}`)
+  clearSentMediaKeys(ctx.sessionId)
   return wsSend(ctx, { response: '', state: 'final' })
 }
 

package/src/utils/constant.ts

@@ -2,6 +2,6 @@ export const ENV: 'production' | 'test' | 'develop' = 'production'
 
 
 export const systemCommand = ['/new', '/status']
-export const interruptCommand = ['/stop']
+export const stopCommand = ['/stop']
 
-export const ignoreToolCommand = ['/search', '/abort', '/queue interrupt', ...systemCommand, ...interruptCommand]
+export const ignoreToolCommand = ['/search', '/abort', '/queue interrupt', ...systemCommand, ...stopCommand]

package/src/utils/gatewayMsgHanlder.ts

@@ -1,14 +1,17 @@
 import type { GatewayEvent } from '../gateway/index.js'
 import { finishedDcgchatCron, sendDcgchatCron } from '../cron.js'
 import { dcgLogger } from './log.js'
-import { getEffectiveMsgParams, getSessionKeyBySubAgentRunId } from './params.js'
-import { sendChunk } from '../transport.js'
+import { clearParamsMessage, getEffectiveMsgParams, getSessionKeyBySubAgentRunId } from './params.js'
+import { sendChunk, sendFinal, sendText } from '../transport.js'
+import { resetSubagentStateForRequesterSession } from '../tool.js'
+import { setMsgStatus } from './global.js'
 
 /**
  * 处理网关 event 帧的副作用（agent 流式输出、cron 同步），并构造供上层分发的 GatewayEvent。
  */
 export function handleGatewayEventMessage(msg: { event?: string; payload?: Record<string, unknown>; seq?: number }): GatewayEvent {
   try {
+    // 子agent消息输出
     if (msg.event === 'agent') {
       const pl = msg.payload as { runId: string; data?: { delta?: unknown } }
       const sessionKey = getSessionKeyBySubAgentRunId(pl.runId)
@@ -19,6 +22,7 @@ export function handleGatewayEventMessage(msg: { event?: string; payload?: Recor
         }
       }
     }
+    // 定时任务
     if (msg.event === 'cron') {
       const p = msg.payload
       dcgLogger(`[Gateway] 收到定时任务事件: ${JSON.stringify(p)}`)
@@ -31,8 +35,13 @@ export function handleGatewayEventMessage(msg: { event?: string; payload?: Recor
       if (p?.action === 'removed') {
         sendDcgchatCron(p?.jobId as string)
       }
-      if (p?.action === 'finished') {
-        finishedDcgchatCron(p?.jobId as string)
+      if (p?.action === 'finished' && p?.status === 'ok') {
+        const hasFileOutput = p.delivered === true && p.deliveryStatus === 'delivered'
+        let summary = p?.summary as string
+        if (summary.indexOf('HEARTBEAT_OK') >= 0 && summary !== 'HEARTBEAT_OK') {
+          summary = summary.replace('HEARTBEAT_OK', '')
+        }
+        finishedDcgchatCron(p?.jobId as string, summary, hasFileOutput)
       }
     }
   } catch (error) {

package/src/utils/global.ts

@@ -82,11 +82,11 @@ const getMediaKey = (url: string) => url.split(/[\\/]/).pop() ?? url
 /** 已发送媒体去重：外层 messageId → 内层该会话下已发送的媒体 key（文件名） */
 const sentMediaKeysBySession = new Map<string, Set<string>>()
 
-function getSessionMediaSet(messageId: string): Set<string> {
-  let set = sentMediaKeysBySession.get(messageId)
+function getSessionMediaSet(sessionId: string): Set<string> {
+  let set = sentMediaKeysBySession.get(sessionId)
   if (!set) {
     set = new Set<string>()
-    sentMediaKeysBySession.set(messageId, set)
+    sentMediaKeysBySession.set(sessionId, set)
   }
   return set
 }
@@ -95,31 +95,48 @@ export function addSentMediaKey(messageId: string, url: string) {
   getSessionMediaSet(messageId).add(getMediaKey(url))
 }
 
-export function hasSentMediaKey(messageId: string, url: string): boolean {
-  return sentMediaKeysBySession.get(messageId)?.has(getMediaKey(url)) ?? false
+export function hasSentMediaKey(sessionId: string, url: string): boolean {
+  return sentMediaKeysBySession.get(sessionId)?.has(getMediaKey(url)) ?? false
 }
 
 /** 不传 messageId 时清空全部会话；传入则只清空该会话 */
-export function clearSentMediaKeys(messageId?: string) {
-  if (messageId) {
-    sentMediaKeysBySession.delete(messageId)
+export function clearSentMediaKeys(sessionId?: string) {
+  if (sessionId) {
+    sentMediaKeysBySession.delete(sessionId)
   } else {
     sentMediaKeysBySession.clear()
   }
 }
 
-const cronMessageIdMap = new Map<string, string>()
+/** 每个 sessionKey 下多个定时任务 messageId，入队在尾、出队在头（FIFO） */
+const cronMessageIdMap = new Map<string, string[]>()
 
-export function setCronMessageId(sk: string, messageId: string) {
-  cronMessageIdMap.set(sk, messageId)
+export function setCronMessageId(sk: string, messageId: string | number | null | undefined) {
+  const mid = messageId != null && messageId !== '' ? String(messageId).trim() : ''
+  if (!sk?.trim() || !mid) return
+  let q = cronMessageIdMap.get(sk)
+  if (!q) {
+    q = []
+    cronMessageIdMap.set(sk, q)
+  }
+  q.push(mid)
 }
 
+/** 窥视队首 messageId（不移除），供发送中与 finished 配对使用 */
 export function getCronMessageId(sk: string): string {
-  return cronMessageIdMap.get(sk) ?? ''
+  if (!sk?.trim()) return ''
+  return cronMessageIdMap.get(sk)?.[0] ?? ''
 }
 
+/** 弹出队首一条，与一次 finished 对应；队列为空时移除 key */
 export function removeCronMessageId(sk: string) {
-  cronMessageIdMap.delete(sk)
+  if (!sk?.trim()) return
+  const q = cronMessageIdMap.get(sk)
+  if (!q?.length) return
+  q.shift()
+  if (q.length === 0) {
+    cronMessageIdMap.delete(sk)
+  }
 }
 
 export const getSessionKey = (content: any, accountId: string) => {