@xgjktech/xg_cwork_im 1.19.35 → 1.19.36

package/dist/src/turn/subagent-monitor.js

@@ -1,26 +1,28 @@
 import { getOrCreateShared, getSharedMap } from "../plugin/process-shared-store.js";
 import { turnOnAllChildrenDone } from "./turn-end-controller.js";
-/** 模块实例 ID：用于确认插件是否被重复加载（若日志出现两个不同 id，则存在双实例，spawn/end 可能被不同实例处理）。 */
+/** 模块实例 ID：用于确认插件是否被重复加载（若日志出现两个不同 id，则存在双实例）。 */
 const MODULE_INSTANCE_ID = `m${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
 console.log(`[subagent-monitor] module loaded instance=${MODULE_INSTANCE_ID} pid=${process.pid} title=${(process.title || "(none)").trim()}`);
-// 进程级共享：跨模块重载后监控不中断——各代模块读写同一份 maps/轮询/api 候选。
-const childToRound = getSharedMap("subagent-child-to-round");
-const roundMonitors = getSharedMap("subagent-round-monitors");
-const deferredFinished = getSharedMap("subagent-deferred-finished");
+// 进程级共享：跨模块重载后状态不中断。
+const targets = getSharedMap("subagent-targets");
+const groupAnchors = getSharedMap("subagent-group-anchors");
 const roundAdmissionTombstones = getSharedMap("subagent-round-admission-tombstones");
 /** 记录被 `/stop` 中断的 subagent run（按 childSessionKey 索引，存被中断 runId 与过期时间）。 */
 const childTombstones = getSharedMap("subagent-child-tombstones");
 const POLL_INTERVAL_MS = 15_000;
 /**
  * apiCandidates 保留上限：OpenClaw 会对同一模块反复重注册（多代 registry 并存且从不触发
- * cleanup，见日志 `registerSeq` 递增而 `cleanup` 为 0）。每代 register 都会 push 一个新 api 进
- * 进程级 candidates，若不停老代则数组无限增长、引用无法回收。该数组仅作为「当前 runtime 探测
- * 不可用时的回退池」（resolveUsablePluginApi），而单进程内 register 是按时间顺序的短爆发（通常
- * 2~4 次），功能上只需最近几代即可，故截断更早的候选。
+ * cleanup）。数组仅作为「当前 runtime 探测不可用时的回退池」（resolveUsablePluginApi），
+ * 单进程内 register 是按时间顺序的短爆发，功能上只需最近几代即可，故截断更早候选。
  */
 const MAX_API_CANDIDATES = 4;
 const ROUND_TOMBSTONE_TTL_MS = 30_000;
 const CHILD_TOMBSTONE_TTL_MS = 5 * 60_000;
+const GROUP_ANCHOR_TTL_MS = 24 * 60 * 60_000;
+/** 仍在跑的目标最长存活：仅作泄漏兜底；正常由 ended 事件 / 轮询对账回收。 */
+const TARGET_TTL_MS = 60 * 60_000;
+/** 已完成目标的保留窗口：用于 /stop 快照与迟到事件幂等去重，随后回收。 */
+const COMPLETED_TARGET_TTL_MS = 5 * 60_000;
 const MAX_INCR_MSGS = 5;
 const MSG_TRUNCATE_LEN = 40;
 /** 单次 tick 用 openclaw `agent.wait` 对账 subagent run 状态的探测超时。 */
@@ -111,7 +113,15 @@ async function resolveUsablePluginApi() {
 export function getSubagentMonitorInstanceId() {
     return MODULE_INSTANCE_ID;
 }
-function pruneTombstones(now = Date.now()) {
+/** 记录该会话最近一次消息锚点，供拿不到 `requester.messageId` 时兜底。 */
+export function noteSubagentGroupAnchor(groupId, anchor) {
+    const gid = groupId?.trim();
+    const a = anchor?.trim();
+    if (!gid || !a)
+        return;
+    groupAnchors.set(gid, { anchor: a, expiresAt: Date.now() + GROUP_ANCHOR_TTL_MS });
+}
+function prune(now = Date.now()) {
     for (const [key, expiresAt] of roundAdmissionTombstones) {
         if (expiresAt <= now)
             roundAdmissionTombstones.delete(key);
@@ -120,270 +130,304 @@ function pruneTombstones(now = Date.now()) {
         if (tombstone.expiresAt <= now)
             childTombstones.delete(key);
     }
+    for (const [key, entry] of groupAnchors) {
+        if (entry.expiresAt <= now)
+            groupAnchors.delete(key);
+    }
+    for (const [key, target] of Array.from(targets)) {
+        if (target.expiresAt <= now) {
+            console.warn(`[subagent-monitor] target TTL expired instance=${MODULE_INSTANCE_ID} ` +
+                `childSessionKey=${target.childSessionKey} runId=${target.runId} completed=${target.completed} completedSent=${target.completedStatSent === true}`);
+            targets.delete(key);
+            continue;
+        }
+        // 已完成且终态快照已推送的目标，保留一小段窗口（/stop 快照 + 迟到事件去重）后回收；
+        // 已完成但快照尚未推送成功的目标不得回收，留给 tick 重试。
+        if (target.completed &&
+            target.completedStatSent &&
+            (target.completedAt ?? 0) + COMPLETED_TARGET_TTL_MS <= now) {
+            targets.delete(key);
+        }
+    }
+}
+/** 是否仍有待处理目标：仍在跑，或已完成但终态快照尚未成功推送。 */
+function hasPendingTarget() {
+    for (const target of targets.values()) {
+        if (!target.completed || !target.completedStatSent)
+            return true;
+    }
+    return false;
 }
 function stopTickerIfIdle() {
-    if (roundMonitors.size === 0 && m.ticker) {
+    if (!hasPendingTarget() && m.ticker) {
         clearInterval(m.ticker);
         m.ticker = null;
     }
 }
-function removeMonitor(monitor, reason) {
-    console.warn(`[subagent-monitor] removeMonitor instance=${MODULE_INSTANCE_ID} reason=${reason} roundKey=${monitor.roundKey} gen=${monitor.generation} ` +
-        `subagents=${Array.from(monitor.subagents.values()).map((r) => r.runId).join(",") || "(none)"}`);
-    if (roundMonitors.get(monitor.roundKey)?.generation === monitor.generation) {
-        roundMonitors.delete(monitor.roundKey);
-    }
-    if (deferredFinished.get(monitor.roundKey)?.generation === monitor.generation) {
-        deferredFinished.delete(monitor.roundKey);
-    }
-    for (const record of monitor.subagents.values()) {
-        const indexed = childToRound.get(record.childSessionKey);
-        if (indexed?.roundKey === monitor.roundKey && indexed.generation === monitor.generation) {
-            childToRound.delete(record.childSessionKey);
-        }
-    }
-    stopTickerIfIdle();
+function ensureTickerRunning() {
+    if (m.ticker)
+        return;
+    void tick();
+    m.ticker = setInterval(() => void tick(), POLL_INTERVAL_MS);
+    m.ticker.unref?.();
 }
-export function startMonitor(params) {
-    pruneTombstones();
-    if (roundAdmissionTombstones.has(params.roundKey)) {
-        console.warn(`[subagent-monitor] startMonitor rejected instance=${MODULE_INSTANCE_ID} reason=roundAdmissionTombstone roundKey=${params.roundKey} runId=${params.spawn.runId}`);
+/**
+ * 登记一个子任务的发送目标并立即推送 running。
+ *
+ * 不要求存在活跃轮次：`roundKey`/`generation` 缺省时仅做发送与对账，不参与整轮计数。
+ */
+export function registerSubagent(params) {
+    prune();
+    if (!params.childSessionKey || !params.runId) {
+        console.warn(`[subagent-monitor] register rejected instance=${MODULE_INSTANCE_ID} reason=missingKey`);
         return false;
     }
-    let monitor = roundMonitors.get(params.roundKey);
-    if (monitor && monitor.generation !== params.generation) {
-        removeMonitor(monitor, "generation-change");
-        monitor = undefined;
-    }
-    if (!monitor) {
-        monitor = {
-            roundKey: params.roundKey,
-            generation: params.generation,
-            groupId: params.groupId,
-            agentId: params.agentId,
-            streamClient: params.streamClient,
-            replyToMsgId: params.replyToMsgId,
-            subagents: new Map(),
-        };
-        roundMonitors.set(params.roundKey, monitor);
-    }
-    if (monitor.subagents.has(params.spawn.runId)) {
-        console.warn(`[subagent-monitor] startMonitor rejected instance=${MODULE_INSTANCE_ID} reason=duplicateRunId roundKey=${params.roundKey} runId=${params.spawn.runId}`);
+    if (params.roundKey && roundAdmissionTombstones.has(params.roundKey)) {
+        console.warn(`[subagent-monitor] register rejected instance=${MODULE_INSTANCE_ID} reason=roundAdmissionTombstone ` +
+            `roundKey=${params.roundKey} runId=${params.runId}`);
         return false;
     }
-    const record = {
-        ...params.spawn,
-        lastMsgIndex: 0,
-        completed: false,
+    const existing = targets.get(params.childSessionKey);
+    if (existing) {
+        if (existing.runId === params.runId) {
+            console.warn(`[subagent-monitor] register rejected instance=${MODULE_INSTANCE_ID} reason=duplicateRunId ` +
+                `childSessionKey=${params.childSessionKey} runId=${params.runId}`);
+            return false;
+        }
+        // 同 childSessionKey 的新 run（steer-restart / run 重建）：覆盖旧目标。
+        // 旧 run 的卡片若不收尾会永久停在「进行中」，这里补发一次 completed 再移除。
+        console.warn(`[subagent-monitor] register replace instance=${MODULE_INSTANCE_ID} childSessionKey=${params.childSessionKey} ` +
+            `oldRunId=${existing.runId} newRunId=${params.runId}`);
+        void closeSupersededTarget(existing).catch((err) => {
+            console.error(`[subagent-monitor] close superseded target failed: ${String(err)}`);
+        });
+        targets.delete(params.childSessionKey);
+    }
+    const anchor = (params.replyToMsgId ?? "").trim() || groupAnchors.get(params.groupId)?.anchor || "";
+    if (anchor) {
+        noteSubagentGroupAnchor(params.groupId, anchor);
+    }
+    const target = {
+        childSessionKey: params.childSessionKey,
+        runId: params.runId,
+        label: params.label ?? params.runId.slice(0, 8),
+        agentId: params.agentId,
+        groupId: params.groupId,
+        anchorMsgId: anchor,
+        streamClient: params.streamClient,
         messages: [],
+        lastMsgIndex: 0,
         sendFrom: 0,
         reading: false,
+        completed: false,
+        roundKey: params.roundKey,
+        generation: params.generation,
+        expiresAt: Date.now() + TARGET_TTL_MS,
     };
-    monitor.subagents.set(record.runId, record);
-    childToRound.set(record.childSessionKey, {
-        roundKey: monitor.roundKey,
-        generation: monitor.generation,
-        runId: record.runId,
-    });
-    console.warn(`[subagent-monitor] startMonitor ok instance=${MODULE_INSTANCE_ID} roundKey=${monitor.roundKey} gen=${monitor.generation} ` +
-        `childSessionKey=${record.childSessionKey} runId=${record.runId}`);
-    sendWsStat(monitor, monitor.streamClient);
+    targets.set(target.childSessionKey, target);
+    console.log(`[subagent-monitor] register ok instance=${MODULE_INSTANCE_ID} childSessionKey=${target.childSessionKey} ` +
+        `runId=${target.runId} round=${target.roundKey ? `${target.roundKey}#${target.generation}` : "(none)"} ` +
+        `anchor=${anchor ? "yes" : "(none)"}`);
+    void pushSubagentStat(target);
     ensureTickerRunning();
     return true;
 }
 export function hasActiveSubagents(roundKey, generation) {
-    const monitor = roundMonitors.get(roundKey);
-    return Boolean(monitor &&
-        monitor.generation === generation &&
-        Array.from(monitor.subagents.values()).some((record) => !record.completed));
+    return Array.from(targets.values()).some((target) => target.roundKey === roundKey && target.generation === generation && !target.completed);
 }
 /** 子任务结束事件定位其所属轮次（供 turn-end-controller 递减活跃子任务数）。 */
 export function findChildRoundIndex(childSessionKey) {
-    return childToRound.get(childSessionKey);
+    const target = targets.get(childSessionKey);
+    if (!target || target.roundKey === undefined || target.generation === undefined)
+        return undefined;
+    return { roundKey: target.roundKey, generation: target.generation, runId: target.runId };
 }
-export function deferFinished(roundKey, generation, reason) {
-    deferredFinished.set(roundKey, { reason, generation });
+/**
+ * 整轮收尾（dispatch wrapper finally）调用。
+ *
+ * 与旧实现不同：**不销毁仍在跑的目标**——仅解除其轮次归属（保留 groupId/锚点/client），
+ * 迟到完成仍能补发 completed；已完成的同类目标顺带回收。
+ */
+export function finalizeRoundMonitoring(roundKey, generation) {
+    for (const [key, target] of Array.from(targets)) {
+        if (target.roundKey !== roundKey || target.generation !== generation)
+            continue;
+        // 仅当 completed 快照已成功推送才回收；否则保留并解除轮次归属，交给 tick 重试补发。
+        if (target.completed && target.completedStatSent) {
+            targets.delete(key);
+            continue;
+        }
+        target.roundKey = undefined;
+        target.generation = undefined;
+    }
 }
 export function prepareSubagentInterrupt(roundKey, generation, now = Date.now()) {
-    pruneTombstones(now);
+    prune(now);
     roundAdmissionTombstones.set(roundKey, now + ROUND_TOMBSTONE_TTL_MS);
-    const monitor = roundMonitors.get(roundKey);
-    if (!monitor || monitor.generation !== generation)
-        return [];
-    const result = Array.from(monitor.subagents.values()).map((record) => {
-        childTombstones.set(record.childSessionKey, {
-            runId: record.runId,
+    const result = [];
+    for (const [key, target] of Array.from(targets)) {
+        if (target.roundKey !== roundKey || target.generation !== generation)
+            continue;
+        childTombstones.set(target.childSessionKey, {
+            runId: target.runId,
             expiresAt: now + CHILD_TOMBSTONE_TTL_MS,
         });
-        return {
-            runId: record.runId,
-            label: record.label ?? record.runId.slice(0, 8),
-            status: record.completed ? "completed" : "suspended",
-            messages: record.messages,
-        };
-    });
-    removeMonitor(monitor, "interrupt");
+        result.push({
+            runId: target.runId,
+            label: target.label,
+            status: target.completed ? "completed" : "suspended",
+            messages: target.messages,
+        });
+        targets.delete(key);
+    }
+    stopTickerIfIdle();
     return result;
 }
 export function markSubagentCompleted(childSessionKey, runId) {
-    pruneTombstones();
+    prune();
     // 仅拦截被 `/stop` 中断的同一 runId 的迟到结束事件；新 run（不同 runId 复用同 key）不受影响。
     const tombstone = childTombstones.get(childSessionKey);
     if (tombstone && runId && runId === tombstone.runId)
         return;
-    const entry = childToRound.get(childSessionKey);
-    if (!entry) {
-        console.debug(`[subagent-monitor] markSubagentCompleted: no round entry instance=${MODULE_INSTANCE_ID} childSessionKey=${childSessionKey}`);
+    const target = targets.get(childSessionKey);
+    if (!target) {
+        console.debug(`[subagent-monitor] markSubagentCompleted: no target instance=${MODULE_INSTANCE_ID} ` +
+            `childSessionKey=${childSessionKey} runId=${runId ?? "(none)"}`);
         return;
     }
-    console.debug(`[subagent-monitor] markSubagentCompleted: entry found instance=${MODULE_INSTANCE_ID} childSessionKey=${childSessionKey} runId=${runId ?? "(none)"} ` +
-        `roundKey=${entry.roundKey} gen=${entry.generation}`);
-    const monitor = roundMonitors.get(entry.roundKey);
-    if (!monitor || monitor.generation !== entry.generation) {
-        console.debug(`[subagent-monitor] markSubagentCompleted: monitor mismatch childSessionKey=${childSessionKey} runId=${runId ?? "(none)"} gen=${entry.generation}`);
-        return;
-    }
-    // runId 可能与 spawn 时不同（steer-restart / run 重建）：优先精确匹配，回退到 childSessionKey。
-    let record = runId ? monitor.subagents.get(runId) : undefined;
-    if (!record) {
-        record = Array.from(monitor.subagents.values()).find((r) => r.childSessionKey === childSessionKey);
-        if (record && runId && record.runId !== runId) {
-            console.debug(`[subagent-monitor] markSubagentCompleted: runId fallback childSessionKey=${childSessionKey} ` +
-                `eventRunId=${runId} recordRunId=${record.runId}`);
-        }
-    }
-    if (!record) {
-        console.debug(`[subagent-monitor] markSubagentCompleted: no record childSessionKey=${childSessionKey} runId=${runId ?? "(none)"}`);
-        return;
+    if (runId && target.runId !== runId) {
+        // runId 可能与 spawn 时不同（steer-restart / run 重建）：回退到 childSessionKey。
+        console.debug(`[subagent-monitor] markSubagentCompleted: runId fallback instance=${MODULE_INSTANCE_ID} ` +
+            `childSessionKey=${childSessionKey} eventRunId=${runId} targetRunId=${target.runId}`);
     }
     void (async () => {
         try {
-            await readSubagentMessages(record);
+            await readSubagentMessages(target);
         }
         catch (err) {
             console.error(`[subagent-monitor] completion read failed: ${String(err)}`);
         }
-        if (record.completed)
-            return;
-        record.completed = true;
-        await settleMonitorIfComplete(monitor);
+        await completeTarget(target);
     })();
 }
-async function settleMonitorIfComplete(monitor) {
-    if (roundMonitors.get(monitor.roundKey) !== monitor)
-        return;
-    if (!Array.from(monitor.subagents.values()).every((record) => record.completed))
+async function completeTarget(target) {
+    if (target.completed)
         return;
-    const signature = statSignature(monitor);
-    if (signature === monitor.lastPushedSignature)
-        return;
-    // 整轮收尾（WS FINISHED + RUN_USAGE + completeActiveRound）改由 turn-end-controller 在
-    // 主会话出现非 yield 段终态（或静默兜底）后，由 dispatch wrapper 统一执行；
-    // 这里只负责推送 SUBAGENT_STAT 快照，绝不自行 end/remove/complete ——
-    // OpenClaw 7.1+/8.x 中「所有已知子任务完成」不代表整轮结束（主会话可能 resume
-    // 继续派发新一批子任务），因此本快照允许多波次多次推送，仅对完全相同的状态去重。
+    target.completed = true;
+    target.completedAt = Date.now();
     try {
-        await sendFinalStat(monitor, monitor.streamClient);
-        for (const record of monitor.subagents.values()) {
-            record.sendFrom = record.messages.length;
-        }
-        monitor.lastPushedSignature = signature;
-        console.log(`[subagent-monitor] final SUBAGENT_STAT sent (settle) roundKey=${monitor.roundKey} gen=${monitor.generation} ` +
-            `subagents=${Array.from(monitor.subagents.values()).length} — waiting turn-end for FINISHED`);
+        await pushCompleted(target);
     }
     catch (err) {
-        console.error(`[subagent-monitor] final state send failed: ${String(err)}`);
+        console.error(`[subagent-monitor] completed SUBAGENT_STAT failed: ${String(err)}`);
     }
-    turnOnAllChildrenDone(monitor.roundKey, monitor.generation);
+    maybeAllChildrenDone(target.roundKey, target.generation);
+    stopTickerIfIdle();
 }
 /**
- * 整轮收尾时（dispatch wrapper 在 turn-end-controller 放行后）清理本轮监控。
- * 与 removeMonitor 的 settle 路径不同：此处轮次真正结束，直接拆监控与子任务索引。
+ * 覆盖同 childSessionKey 的旧 run 时，先把旧 run 的卡片收尾（补发 completed），
+ * 否则旧 runId 的卡片会永久停在「进行中」。不做整轮 activeChildren 对账：
+ * 该 child 的逻辑计数由紧接着登记的新目标继续代表。
  */
-export function finalizeRoundMonitoring(roundKey, generation) {
-    const monitor = roundMonitors.get(roundKey);
-    if (!monitor || monitor.generation !== generation)
+async function closeSupersededTarget(target) {
+    if (target.completed)
         return;
-    removeMonitor(monitor, "round-finished");
+    target.completed = true;
+    target.completedAt = Date.now();
+    await pushCompleted(target);
 }
-async function readSubagentMessages(record) {
-    if (!m.api || record.reading)
+/** 整轮计数对账：该轮已无未完成目标时，通知 turn-end-controller。 */
+function maybeAllChildrenDone(roundKey, generation) {
+    if (!roundKey || generation === undefined)
         return;
-    record.reading = true;
+    const anyActive = Array.from(targets.values()).some((target) => target.roundKey === roundKey && target.generation === generation && !target.completed);
+    if (!anyActive)
+        turnOnAllChildrenDone(roundKey, generation);
+}
+async function readSubagentMessages(target) {
+    if (!m.api || target.reading)
+        return;
+    target.reading = true;
     try {
         let messages = [];
         try {
             const result = await m.api.runtime.subagent.getSessionMessages({
-                sessionKey: record.childSessionKey,
+                sessionKey: target.childSessionKey,
             });
             messages = Array.isArray(result.messages) ? result.messages : [];
         }
         catch (err) {
             // runtime.subagent 可能只在 gateway 请求上下文内可用（openclaw 7.x request-scoped）；
             // 读取失败不能拖垮整个 tick，这里吞掉并继续，消息下次再拉。
-            console.warn(`[subagent-monitor] getSessionMessages failed childSessionKey=${record.childSessionKey} runId=${record.runId}: ${String(err)}`);
+            console.warn(`[subagent-monitor] getSessionMessages failed childSessionKey=${target.childSessionKey} runId=${target.runId}: ${String(err)}`);
         }
-        for (const msg of messages.slice(record.lastMsgIndex))
-            record.messages.push(cleanMsg(msg));
-        record.lastMsgIndex = messages.length;
+        for (const msg of messages.slice(target.lastMsgIndex))
+            target.messages.push(cleanMsg(msg));
+        target.lastMsgIndex = messages.length;
     }
     finally {
-        record.reading = false;
+        target.reading = false;
     }
 }
 /**
  * 用 openclaw 权威 run 状态对账：run 已结束（ok/error）返回 true，仍在运行（timeout）返回 false。
  * 探测失败（如 runId 已不存在、状态码异常）保守按「仍在运行」处理，交给事件路径兜底。
  */
-async function probeRunStatus(record) {
+async function probeRunStatus(target) {
     if (!m.api)
         return false;
     try {
         const result = await m.api.runtime.subagent.waitForRun({
-            runId: record.runId,
+            runId: target.runId,
             timeoutMs: RUN_STATUS_PROBE_TIMEOUT_MS,
         });
         return result.status !== "timeout";
     }
     catch (err) {
-        console.warn(`[subagent-monitor] waitForRun probe failed runId=${record.runId}: ${String(err)}`);
+        console.warn(`[subagent-monitor] waitForRun probe failed runId=${target.runId}: ${String(err)}`);
         return false;
     }
 }
-function ensureTickerRunning() {
-    if (m.ticker)
-        return;
-    void tick();
-    m.ticker = setInterval(() => void tick(), POLL_INTERVAL_MS);
-    m.ticker.unref?.();
-}
 async function tick() {
-    if (roundMonitors.size === 0) {
+    prune();
+    if (targets.size === 0) {
         stopTickerIfIdle();
         return;
     }
     // 确保使用可用的 runtime：探测并必要时切回候选中的可用 api，避免坏 runtime 继续抛 RequestScoped。
     await resolveUsablePluginApi();
-    for (const monitor of Array.from(roundMonitors.values())) {
+    const running = Array.from(targets.values()).filter((target) => !target.completed);
+    // pending 含：仍在跑的目标，以及已完成但终态快照尚未成功推送的目标（需重试补发）。
+    const pending = Array.from(targets.values()).filter((target) => !target.completed || !target.completedStatSent);
+    try {
+        await Promise.all(running.map((target) => readSubagentMessages(target)));
+        // 并行对账：已结束的 run 在 gateway 侧有 terminal snapshot 缓存，立即返回；仍在跑的会阻塞至探测超时。
+        await Promise.all(running.map(async (target) => {
+            if (target.completed)
+                return;
+            if (await probeRunStatus(target)) {
+                target.completed = true;
+                target.completedAt = Date.now();
+            }
+        }));
+    }
+    catch (err) {
+        console.error(`[subagent-monitor] poll failed: ${String(err)}`);
+    }
+    for (const target of pending) {
+        if (targets.get(target.childSessionKey) !== target)
+            continue;
         try {
-            const runningRecords = Array.from(monitor.subagents.values()).filter((record) => !record.completed);
-            await Promise.all(runningRecords.map((record) => readSubagentMessages(record)));
-            if (roundMonitors.get(monitor.roundKey) !== monitor)
-                continue;
-            // 并行对账：已结束的 run 在 gateway 侧有 terminal snapshot 缓存，立即返回；仍在跑的会阻塞至探测超时。
-            await Promise.all(runningRecords.map(async (record) => {
-                if (record.completed)
-                    return;
-                if (await probeRunStatus(record))
-                    record.completed = true;
-            }));
-            if (roundMonitors.get(monitor.roundKey) !== monitor)
-                continue;
-            sendWsStat(monitor, monitor.streamClient);
-            await settleMonitorIfComplete(monitor);
+            if (target.completed) {
+                await pushCompleted(target);
+                maybeAllChildrenDone(target.roundKey, target.generation);
+            }
+            else {
+                await pushSubagentStat(target);
+            }
         }
         catch (err) {
-            console.error(`[subagent-monitor] poll failed roundKey=${monitor.roundKey}: ${String(err)}`);
+            console.error(`[subagent-monitor] SUBAGENT_STAT failed childSessionKey=${target.childSessionKey}: ${String(err)}`);
         }
     }
     stopTickerIfIdle();
@@ -421,59 +465,62 @@ function cleanMsg(msg) {
         text = `${text.slice(0, MSG_TRUNCATE_LEN)}…`;
     return `[助手] ${text}${toolCount > 0 ? ` [调用${toolCount}个工具]` : ""}`;
 }
-function toSubagentList(monitor, incremental) {
-    return Array.from(monitor.subagents.values()).map((record) => ({
-        runId: record.runId,
-        label: record.label ?? record.runId.slice(0, 8),
-        status: record.completed ? "completed" : "running",
-        messages: incremental
-            ? record.messages.slice(record.sendFrom, record.sendFrom + MAX_INCR_MSGS)
-            : record.messages,
-    }));
-}
 /**
- * 客户端可见状态的稳定签名：新增子任务、状态翻转（running→completed）或消息数变化都会改变。
- * 仅凭它做「无变化不重复推送」的去重；同一轮多波次派发不会被锁死。
+ * 推送一条 SUBAGENT_STAT（单目标、增量消息；状态取目标当前 completed）。
+ * 发送失败只记录、不抛出：fire-and-forget 调用点（spawn/tick）不应产生 unhandledRejection。
+ * 返回是否发送成功（未推进 sendFrom 时下次可重试）。
  */
-function statSignature(monitor) {
-    return Array.from(monitor.subagents.values())
-        .map((r) => `${r.runId}:${r.completed ? "completed" : "running"}:${r.messages.length}`)
-        .join("|");
-}
-function sendWsStat(monitor, client) {
-    const signature = statSignature(monitor);
-    // 有 running 子任务时保持逐 tick 推送（running/新增消息语义不变）；
-    // 全部已完成且状态无变化（等 turn-end 的空窗）则去重，避免 tick 刷同一份完成快照。
-    const hasRunning = Array.from(monitor.subagents.values()).some((r) => !r.completed);
-    if (!hasRunning && signature === monitor.lastPushedSignature)
-        return;
-    const subagentList = toSubagentList(monitor, true);
-    client
-        .sendEvent({
-        groupId: monitor.groupId,
-        replyToMsgId: monitor.replyToMsgId,
-        event: "SUBAGENT_STAT",
-        data: { subagentList },
-    })
-        .then(() => {
-        subagentList.forEach((item) => {
-            const record = monitor.subagents.get(item.runId);
-            if (record)
-                record.sendFrom += item.messages.length;
+async function pushSubagentStat(target) {
+    if (!target.anchorMsgId) {
+        console.debug(`[subagent-monitor] SUBAGENT_STAT skipped (no anchor) childSessionKey=${target.childSessionKey} runId=${target.runId}`);
+        return false;
+    }
+    const messages = target.messages.slice(target.sendFrom, target.sendFrom + MAX_INCR_MSGS);
+    try {
+        await target.streamClient.sendEvent({
+            groupId: target.groupId,
+            replyToMsgId: target.anchorMsgId,
+            event: "SUBAGENT_STAT",
+            data: {
+                subagentList: [
+                    {
+                        runId: target.runId,
+                        label: target.label,
+                        status: target.completed ? "completed" : "running",
+                        messages,
+                    },
+                ],
+            },
         });
-        monitor.lastPushedSignature = signature;
-    })
-        .catch((err) => {
-        console.error(`[subagent-monitor] SUBAGENT_STAT failed: ${String(err)}`);
-    });
+    }
+    catch (err) {
+        console.error(`[subagent-monitor] SUBAGENT_STAT failed childSessionKey=${target.childSessionKey} runId=${target.runId}: ${String(err)}`);
+        return false;
+    }
+    target.sendFrom += messages.length;
+    return true;
 }
-async function sendFinalStat(monitor, client) {
-    await client.sendEvent({
-        groupId: monitor.groupId,
-        replyToMsgId: monitor.replyToMsgId,
-        event: "SUBAGENT_STAT",
-        data: { subagentList: toSubagentList(monitor, false) },
-    });
+/** 完成收尾：补发全部待推消息，并至少推送一次 completed 状态（幂等；发送失败下次重试）。 */
+async function pushCompleted(target) {
+    if (target.completedStatSent || target.completedStatSending)
+        return;
+    if (!target.anchorMsgId) {
+        // 无锚点无法发送（buildSendEventPayload 要求非空）；标记已处理，避免无意义重试与 ticker 空转。
+        target.completedStatSent = true;
+        return;
+    }
+    target.completedStatSending = true;
+    try {
+        while (target.sendFrom < target.messages.length) {
+            if (!(await pushSubagentStat(target)))
+                return;
+        }
+        if (await pushSubagentStat(target))
+            target.completedStatSent = true;
+    }
+    finally {
+        target.completedStatSending = false;
+    }
 }
 export function __tickForTests() {
     return tick();
@@ -489,9 +536,8 @@ export function disposeSubagentMonitor() {
     m.api = null;
     m.apiProbe = "unverified";
     m.apiCandidates.length = 0;
-    childToRound.clear();
-    roundMonitors.clear();
-    deferredFinished.clear();
+    targets.clear();
+    groupAnchors.clear();
     roundAdmissionTombstones.clear();
     childTombstones.clear();
 }