@xgjktech/xg_cwork_im 1.19.42 → 1.19.43

package/dist/src/plan-tool-middleware.test.js

@@ -1,103 +1,623 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { createPlanToolResultMiddleware, } from "./plan-tool-middleware.js";
-function makeAction(eventId, overrides = {}) {
+import { createPlanToolResultMiddleware } from "./plan-tool-middleware.js";
+const FAKE_CTX = { runtime: "openclaw" };
+function makePlan(overrides = {}) {
     return {
-        eventId,
-        event: "action_dispatch",
-        action: "form_fill",
-        target: "page://order-detail",
-        version: 1,
-        status: "completed",
-        scopeControl: { activeSessionOnly: true },
-        payload: { data: { id: eventId } },
-        timestamp: "2026-09-07T17:00:00.000+08:00",
-        origin: { channel: "xg_cwork_im", to: "g-1" },
+        planId: "plan-1",
+        goal: "迁移配置到新版本",
+        createdAt: "2026-07-27T00:00:00.000Z",
+        updatedAt: "2026-07-27T00:00:00.000Z",
+        tasks: [],
         ...overrides,
     };
 }
-function makeToolEvent(toolName, overrides = {}) {
+function makeEvent(overrides) {
+    const content = overrides.text !== undefined
+        ? [{ type: "text", text: overrides.text }]
+        : [];
     return {
-        toolCallId: "call-1",
-        toolName,
+        toolCallId: overrides.toolCallId ?? "call-1",
+        toolName: overrides.toolName ?? "xg_plan_write",
         args: {},
-        result: { details: undefined, content: [] },
-        ...overrides,
+        result: {
+            details: overrides.details,
+            content,
+        },
+    };
+}
+function makeSuccessPayload(plan, withEvent = false) {
+    return {
+        ok: true,
+        planId: plan.planId,
+        plan,
+        ...(withEvent ? { event: { emitted: false, reason: "no runId" } } : {}),
     };
 }
-class Probe {
-    sent = [];
+function makeDraftSuccessPayload(planId) {
+    return {
+        ok: true,
+        planId,
+        view: `goal: 草稿计划\nT0 [ ] 任务`,
+    };
+}
+class RecordingDeps {
+    planById = new Map();
+    planStatCalls = [];
+    sendPlanStatImpl = (params) => {
+        this.planStatCalls.push(params);
+    };
+    getPlanById = (planId) => {
+        return this.planById.get(planId);
+    };
+    sendPlanStat = (params) => {
+        this.sendPlanStatImpl(params);
+    };
     actionById = new Map();
-    deps;
-    handler;
-    constructor() {
-        this.deps = {
-            getActionById: (eventId) => this.actionById.get(eventId),
-            sendActionRunEvent: (action) => {
-                this.sent.push(action);
-            },
-        };
-        this.handler = createPlanToolResultMiddleware(this.deps);
+    actionRunEventCalls = [];
+    getActionById = (eventId) => this.actionById.get(eventId);
+    sendActionRunEvent = (action) => {
+        this.actionRunEventCalls.push(action);
+    };
+}
+/** 临时替换 console.warn 统计 [plan-telemetry] 行数，测试结束务必还原。 */
+function captureTelemetryLines(fn) {
+    const original = console.warn;
+    const lines = [];
+    console.warn = (...args) => {
+        const line = args.map(String).join(" ");
+        if (line.includes("[plan-telemetry]")) {
+            lines.push(line);
+        }
+    };
+    try {
+        fn();
     }
+    finally {
+        console.warn = original;
+    }
+    return lines;
+}
+function captureWarnLines(fn) {
+    const original = console.warn;
+    const lines = [];
+    console.warn = (...args) => {
+        lines.push(args.map(String).join(" "));
+    };
+    try {
+        fn();
+    }
+    finally {
+        console.warn = original;
+    }
+    return lines;
 }
-describe("createPlanToolResultMiddleware: 仅 xg_action_dispatch 分支（plan 已移除）", () => {
-    it("非 action 工具直接放行：不反查、不发", () => {
-        const probe = new Probe();
-        const event = makeToolEvent("xg_plan_write", {
-            result: { details: { ok: true, planId: "p-1" }, content: [] },
-        });
-        assert.equal(probe.handler(event, undefined), undefined);
-        assert.equal(probe.actionById.size, 0);
-        assert.deepEqual(probe.sent, []);
-    });
-    it("details 命中 eventId → 反查并发送", () => {
-        const probe = new Probe();
-        const action = makeAction("e-1");
-        probe.actionById.set("e-1", action);
-        probe.handler(makeToolEvent("xg_action_dispatch", {
-            result: { details: { ok: true, eventId: "e-1" }, content: [] },
-        }), undefined);
-        assert.deepEqual(probe.sent, [action]);
-    });
-    it("回退解析 content[0].text JSON 里的 eventId", () => {
-        const probe = new Probe();
-        const action = makeAction("e-2");
-        probe.actionById.set("e-2", action);
-        probe.handler(makeToolEvent("xg_action_dispatch", {
-            result: { details: undefined, content: [{ type: "text", text: '{"ok":true,"eventId":"e-2"}' }] },
-        }), undefined);
-        assert.deepEqual(probe.sent, [action]);
-    });
-    it("解析不到 eventId → 跳过，不抛", () => {
-        const probe = new Probe();
-        assert.equal(probe.handler(makeToolEvent("xg_action_dispatch", { result: { details: { ok: false }, content: [] } }), undefined), undefined);
-        assert.deepEqual(probe.sent, []);
-    });
-    it("反查不到 action → 跳过，不抛", () => {
-        const probe = new Probe();
-        assert.equal(probe.handler(makeToolEvent("xg_action_dispatch", {
-            result: { details: { ok: true, eventId: "missing" }, content: [] },
-        }), undefined), undefined);
-        assert.deepEqual(probe.sent, []);
-    });
-    it("getActionById 抛异常 → handler 不外抛", () => {
-        const probe = new Probe();
-        probe.deps.getActionById = () => {
+describe("createPlanToolResultMiddleware: 非 plan 工具直接放行", () => {
+    it("does not touch getPlanById or emit telemetry for unrelated tools", () => {
+        const deps = new RecordingDeps();
+        let getPlanByIdCalled = false;
+        deps.getPlanById = (planId) => {
+            getPlanByIdCalled = true;
+            return deps.planById.get(planId);
+        };
+        const handler = createPlanToolResultMiddleware(deps);
+        const event = makeEvent({
+            toolName: "some_other_tool",
+            details: { ok: true, data: 123 },
+        });
+        const lines = captureTelemetryLines(() => {
+            const result = handler(event, FAKE_CTX);
+            assert.equal(result, undefined);
+        });
+        assert.equal(getPlanByIdCalled, false);
+        assert.equal(lines.length, 0);
+    });
+    it("does not emit telemetry even when a non-plan tool's details is a structurally valid plan payload (pins the name filter)", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({ tasks: [{ title: "备份旧配置", status: "blocked", note: "缺少权限" }] });
+        const event = makeEvent({
+            toolCallId: "call-evil",
+            toolName: "some_evil_tool",
+            details: makeSuccessPayload(plan),
+        });
+        const lines = captureTelemetryLines(() => {
+            const result = handler(event, FAKE_CTX);
+            assert.equal(result, undefined);
+        });
+        assert.equal(lines.length, 0);
+    });
+});
+describe("createPlanToolResultMiddleware: 权威反查与兼容回退", () => {
+    it("0.3.0 新形状反查命中 → 用权威 plan 推送，并产出 blocked 遥测", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const authoritativePlan = makePlan({
+            planId: "plan-draft-hit",
+            tasks: [{ title: "备份旧配置", status: "blocked", note: "缺少权限" }],
+        });
+        deps.planById.set(authoritativePlan.planId, authoritativePlan);
+        const event = makeEvent({
+            toolCallId: "call-1",
+            toolName: "xg_plan_write",
+            details: makeDraftSuccessPayload(authoritativePlan.planId),
+        });
+        const lines = captureTelemetryLines(() => {
+            const result = handler(event, FAKE_CTX);
+            assert.equal(result, undefined);
+        });
+        assert.equal(lines.length, 1);
+        assert.ok(lines[0].includes("备份旧配置"));
+        assert.ok(lines[0].includes("缺少权限"));
+        assert.deepEqual(deps.planStatCalls, [{ plan: authoritativePlan, source: "tool" }]);
+    });
+    it("反查得到 cancelled 计划 → PLAN_STAT 照推，blocked 遥测跳过", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const cancelledPlan = makePlan({
+            planId: "plan-cancelled",
+            status: "cancelled",
+            cancelledAt: "2026-07-31T01:02:03.000Z",
+            tasks: [{ title: "旧阻塞", status: "blocked", note: "取消后不应告警" }],
+        });
+        deps.planById.set(cancelledPlan.planId, cancelledPlan);
+        const event = makeEvent({
+            toolCallId: "call-cancelled",
+            details: {
+                ok: true,
+                planId: cancelledPlan.planId,
+                view: "goal: 【已取消】迁移配置到新版本\nT0 [!] 旧阻塞",
+                cancelled: true,
+            },
+        });
+        const lines = captureTelemetryLines(() => {
+            assert.equal(handler(event, FAKE_CTX), undefined);
+        });
+        assert.deepEqual(lines, []);
+        assert.deepEqual(deps.planStatCalls, [{ plan: cancelledPlan, source: "tool" }]);
+    });
+    it("0.3.0 新形状反查未命中 → 记 warn 后放弃，不推送且不抛", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const event = makeEvent({
+            toolCallId: "call-draft-miss",
+            details: makeDraftSuccessPayload("plan-draft-miss"),
+        });
+        const lines = captureWarnLines(() => {
+            assert.doesNotThrow(() => handler(event, FAKE_CTX));
+        });
+        assert.equal(deps.planStatCalls.length, 0);
+        assert.equal(lines.length, 1);
+        assert.ok(lines[0].includes("反查不到 plan"));
+        assert.ok(lines[0].includes("plan-draft-miss"));
+    });
+    it("0.2.0 旧形状反查未命中 → 回退使用返回中的完整 plan 推送", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const legacyPlan = makePlan({
+            planId: "plan-legacy-fallback",
+            tasks: [{ title: "旧版任务", status: "pending" }],
+        });
+        const event = makeEvent({
+            toolCallId: "call-legacy-fallback",
+            details: makeSuccessPayload(legacyPlan, true),
+        });
+        handler(event, FAKE_CTX);
+        assert.deepEqual(deps.planStatCalls, [{ plan: legacyPlan, source: "tool" }]);
+    });
+});
+describe("createPlanToolResultMiddleware: text 回退路径", () => {
+    it("falls back to content[0].text when details is undefined", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({
+            planId: "plan-2",
+            tasks: [{ title: "校验数据", status: "blocked", note: "依赖未就绪" }],
+        });
+        const rawBody = JSON.stringify(makeSuccessPayload(plan, true), null, 2);
+        const event = makeEvent({
+            toolCallId: "call-2",
+            toolName: "xg_plan_write",
+            details: undefined,
+            text: rawBody,
+        });
+        const lines = captureTelemetryLines(() => {
+            const result = handler(event, FAKE_CTX);
+            assert.equal(result, undefined);
+        });
+        assert.equal(lines.length, 1);
+        assert.ok(lines[0].includes("校验数据"));
+    });
+    it("uses getPlanById authoritative state when details is missing (D5/RULING-1 §3)", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        // text 路径拿到的 plan 里没有 blocked task，但权威反查里有
+        const textPlan = makePlan({ planId: "plan-3", tasks: [{ title: "t1", status: "pending" }] });
+        const authoritativePlan = makePlan({
+            planId: "plan-3",
+            tasks: [{ title: "t1", status: "blocked", note: "authoritative 才有的阻塞" }],
+        });
+        deps.planById.set("plan-3", authoritativePlan);
+        const rawBody = JSON.stringify(makeSuccessPayload(textPlan), null, 2);
+        const event = makeEvent({
+            toolCallId: "call-3",
+            toolName: "xg_plan_write",
+            details: undefined,
+            text: rawBody,
+        });
+        const lines = captureTelemetryLines(() => {
+            handler(event, FAKE_CTX);
+        });
+        assert.equal(lines.length, 1);
+        assert.ok(lines[0].includes("authoritative 才有的阻塞"));
+    });
+});
+describe("createPlanToolResultMiddleware: 守卫拒绝畸形 payload", () => {
+    it("does not emit telemetry for ok:false", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const event = makeEvent({
+            toolCallId: "call-4",
+            toolName: "xg_plan_write",
+            details: { ok: false, error: { code: "PLAN_NOT_FOUND" } },
+        });
+        const lines = captureTelemetryLines(() => {
+            assert.equal(handler(event, FAKE_CTX), undefined);
+        });
+        assert.equal(lines.length, 0);
+    });
+    it("does not emit telemetry when planId is missing", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const event = makeEvent({
+            toolCallId: "call-5",
+            toolName: "xg_plan_write",
+            details: { ok: true, plan: makePlan() },
+        });
+        const lines = captureTelemetryLines(() => {
+            assert.equal(handler(event, FAKE_CTX), undefined);
+        });
+        assert.equal(lines.length, 0);
+    });
+    it("does not emit telemetry when tasks is not an array", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const event = makeEvent({
+            toolCallId: "call-6",
+            toolName: "xg_plan_write",
+            details: {
+                ok: true,
+                planId: "plan-6",
+                plan: { planId: "plan-6", goal: "g", createdAt: "t", updatedAt: "t", tasks: "not-an-array" },
+            },
+        });
+        const lines = captureTelemetryLines(() => {
+            assert.equal(handler(event, FAKE_CTX), undefined);
+        });
+        assert.equal(lines.length, 0);
+    });
+});
+describe("createPlanToolResultMiddleware: handler 内部出错不外抛", () => {
+    it("resolves normally even when getPlanById throws", () => {
+        const deps = new RecordingDeps();
+        deps.getPlanById = () => {
             throw new Error("boom");
         };
-        assert.equal(probe.handler(makeToolEvent("xg_action_dispatch", {
-            result: { details: { ok: true, eventId: "e-1" }, content: [] },
-        }), undefined), undefined);
-    });
-    it("sendActionRunEvent 抛异常 → handler 不外抛", () => {
-        const probe = new Probe();
-        probe.actionById.set("e-1", makeAction("e-1"));
-        probe.deps.sendActionRunEvent = () => {
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({ planId: "plan-8", tasks: [{ title: "t1", status: "blocked", note: "n" }] });
+        const rawBody = JSON.stringify(makeSuccessPayload(plan), null, 2);
+        const event = makeEvent({
+            toolCallId: "call-8",
+            toolName: "xg_plan_write",
+            details: undefined,
+            text: rawBody,
+        });
+        assert.doesNotThrow(() => handler(event, FAKE_CTX));
+    });
+});
+describe("createPlanToolResultMiddleware: 恒返回 void（同步性断言）", () => {
+    // 本任务 handler 已无异步出口（推群没了）。TASK-2x-4 引入 sendPlanStat 的
+    // fire-and-forget 之后，这条要恢复成"even when 内部 promise 永不 resolve 仍立即返回"的真实用例。
+    it("handler's return value is undefined and the call itself is synchronous", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({ tasks: [{ title: "t1", status: "blocked", note: "n" }] });
+        const event = makeEvent({
+            toolCallId: "call-9",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        const result = handler(event, FAKE_CTX);
+        assert.equal(result, undefined);
+    });
+    it("0.3.0 新形状反查后不修改 event.result", () => {
+        const deps = new RecordingDeps();
+        const plan = makePlan({ planId: "plan-no-mutate" });
+        deps.planById.set(plan.planId, plan);
+        const handler = createPlanToolResultMiddleware(deps);
+        const event = makeEvent({
+            toolCallId: "call-no-mutate",
+            details: makeDraftSuccessPayload(plan.planId),
+            text: JSON.stringify(makeDraftSuccessPayload(plan.planId)),
+        });
+        const originalResult = structuredClone(event.result);
+        handler(event, FAKE_CTX);
+        assert.deepEqual(event.result, originalResult);
+    });
+});
+describe("createPlanToolResultMiddleware: [plan-telemetry] 遥测行为（D2）", () => {
+    it("plan 含 1 个 blocked task → 恰好打 1 行，内容含 planId/taskIndex/taskTitle/note/goal", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({
+            planId: "plan-telemetry-1",
+            goal: "迁移配置到新版本",
+            tasks: [{ title: "备份旧配置", status: "blocked", note: "缺少权限" }],
+        });
+        const event = makeEvent({
+            toolCallId: "call-t1",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        const lines = captureTelemetryLines(() => {
+            handler(event, FAKE_CTX);
+        });
+        assert.equal(lines.length, 1);
+        const jsonPart = lines[0].slice(lines[0].indexOf("{"));
+        const parsed = JSON.parse(jsonPart);
+        assert.equal(parsed.planId, "plan-telemetry-1");
+        assert.equal(parsed.taskIndex, 0);
+        assert.equal(parsed.taskTitle, "备份旧配置");
+        assert.equal(parsed.note, "缺少权限");
+        assert.equal(parsed.goal, "迁移配置到新版本");
+        assert.equal(parsed.toolName, "xg_plan_write");
+    });
+    it("plan 含 2 个 blocked task → 打 2 行，顺序与 tasks 下标一致", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({
+            tasks: [
+                { title: "备份旧配置", status: "blocked", note: "缺少权限" },
+                { title: "校验数据", status: "pending" },
+                { title: "切换流量", status: "blocked", note: "依赖未就绪" },
+            ],
+        });
+        const event = makeEvent({
+            toolCallId: "call-t2",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        const lines = captureTelemetryLines(() => {
+            handler(event, FAKE_CTX);
+        });
+        assert.equal(lines.length, 2);
+        const first = JSON.parse(lines[0].slice(lines[0].indexOf("{")));
+        const second = JSON.parse(lines[1].slice(lines[1].indexOf("{")));
+        assert.equal(first.taskIndex, 0);
+        assert.equal(second.taskIndex, 2);
+    });
+    it("无 blocked task → 不打任何遥测行", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({
+            tasks: [{ title: "t1", status: "pending" }, { title: "t2", status: "completed" }],
+        });
+        const event = makeEvent({
+            toolCallId: "call-t3",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        const lines = captureTelemetryLines(() => {
+            handler(event, FAKE_CTX);
+        });
+        assert.equal(lines.length, 0);
+    });
+    it("🔴 同一 plan、同一 blocked、连续两次 middleware 事件 → 打 2 行（钉住不去重）", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({
+            planId: "plan-no-dedup",
+            tasks: [{ title: "备份旧配置", status: "blocked", note: "缺少权限" }],
+        });
+        const event = makeEvent({
+            toolCallId: "call-t4",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        const lines = captureTelemetryLines(() => {
+            handler(event, FAKE_CTX);
+            handler(event, FAKE_CTX);
+        });
+        assert.equal(lines.length, 2, "不去重：同一 blocked 连续两次事件应各打一行");
+    });
+    it("plan 带 origin → 日志行含 channel/to/sessionKey", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({
+            tasks: [{ title: "t1", status: "blocked", note: "n" }],
+            origin: { channel: "xg_cwork_im", to: "g-123", sessionKey: "sess-1" },
+        });
+        const event = makeEvent({
+            toolCallId: "call-t5",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        const lines = captureTelemetryLines(() => {
+            handler(event, FAKE_CTX);
+        });
+        assert.equal(lines.length, 1);
+        const parsed = JSON.parse(lines[0].slice(lines[0].indexOf("{")));
+        assert.equal(parsed.channel, "xg_cwork_im");
+        assert.equal(parsed.to, "g-123");
+        assert.equal(parsed.sessionKey, "sess-1");
+    });
+    it("🔴 plan 无 origin（旧数据）→ 日志行不含这几个键，且照常打日志、不抛、不跳过", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({
+            tasks: [{ title: "t1", status: "blocked", note: "n" }],
+        });
+        const event = makeEvent({
+            toolCallId: "call-t6",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        const lines = captureTelemetryLines(() => {
+            assert.doesNotThrow(() => handler(event, FAKE_CTX));
+        });
+        assert.equal(lines.length, 1);
+        const parsed = JSON.parse(lines[0].slice(lines[0].indexOf("{")));
+        assert.equal("channel" in parsed, false);
+        assert.equal("to" in parsed, false);
+        assert.equal("sessionKey" in parsed, false);
+    });
+    it("blocked task 的 note 为空/空白 → 该条不产出遥测", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({
+            tasks: [
+                { title: "无 note", status: "blocked" },
+                { title: "空白 note", status: "blocked", note: "   " },
+            ],
+        });
+        const event = makeEvent({
+            toolCallId: "call-t7",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        const lines = captureTelemetryLines(() => {
+            handler(event, FAKE_CTX);
+        });
+        assert.equal(lines.length, 0);
+    });
+});
+describe("createPlanToolResultMiddleware: PLAN_STAT 增量推送（D3）", () => {
+    it("plan_write 成功 → 发 1 条 PLAN_STAT，source === \"tool\"", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({ tasks: [{ title: "t1", status: "pending" }] });
+        const event = makeEvent({
+            toolCallId: "call-ps1",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        handler(event, FAKE_CTX);
+        assert.equal(deps.planStatCalls.length, 1);
+        assert.equal(deps.planStatCalls[0].source, "tool");
+        assert.equal(deps.planStatCalls[0].plan.planId, plan.planId);
+    });
+    it("xg_plan_execute 的单计划/列表返回均直接忽略，不解析、不反查、不推送", () => {
+        const deps = new RecordingDeps();
+        let getPlanByIdCalls = 0;
+        deps.getPlanById = () => {
+            getPlanByIdCalls += 1;
+            return undefined;
+        };
+        const handler = createPlanToolResultMiddleware(deps);
+        const events = [
+            makeEvent({
+                toolCallId: "call-ps2",
+                toolName: "xg_plan_execute",
+                details: makeDraftSuccessPayload("plan-read"),
+            }),
+            makeEvent({
+                toolCallId: "call-ps3",
+                toolName: "xg_plan_execute",
+                details: {
+                    ok: true,
+                    plans: [{
+                            planId: "plan-list",
+                            goal: "最近计划",
+                            updatedAt: "2026-07-29T00:00:00.000Z",
+                            taskCounts: { total: 1, completed: 0, blocked: 0, inProgress: 0 },
+                        }],
+                },
+            }),
+        ];
+        const lines = captureWarnLines(() => {
+            for (const event of events) {
+                handler(event, FAKE_CTX);
+            }
+        });
+        assert.equal(getPlanByIdCalls, 0);
+        assert.equal(deps.planStatCalls.length, 0);
+        assert.equal(lines.length, 0);
+    });
+    it("🔴 工具返回 ok:false → 不发 PLAN_STAT（失败不发）", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const event = makeEvent({
+            toolCallId: "call-ps5",
+            toolName: "xg_plan_write",
+            details: { ok: false, error: { code: "PLAN_NOT_FOUND" } },
+        });
+        handler(event, FAKE_CTX);
+        assert.equal(deps.planStatCalls.length, 0);
+    });
+    it("🔴 非 plan 工具 → 不发 PLAN_STAT", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({ tasks: [{ title: "t1", status: "pending" }] });
+        const event = makeEvent({
+            toolCallId: "call-ps6",
+            toolName: "some_other_tool",
+            details: makeSuccessPayload(plan),
+        });
+        handler(event, FAKE_CTX);
+        assert.equal(deps.planStatCalls.length, 0);
+    });
+    it("🔴 sendPlanStat 内部抛异常 → handler 不外抛、仍返回 void（红线回归）", () => {
+        const deps = new RecordingDeps();
+        deps.sendPlanStatImpl = () => {
             throw new Error("boom");
         };
-        assert.equal(probe.handler(makeToolEvent("xg_action_dispatch", {
-            result: { details: { ok: true, eventId: "e-1" }, content: [] },
-        }), undefined), undefined);
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({ tasks: [{ title: "t1", status: "pending" }] });
+        const event = makeEvent({
+            toolCallId: "call-ps7",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        assert.doesNotThrow(() => {
+            const result = handler(event, FAKE_CTX);
+            assert.equal(result, undefined);
+        });
+    });
+    it("🔴 跨调用序列：同一 plan 连续 3 次成功调用 → 发 3 条（全量幂等，不去重）", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        const plan = makePlan({ planId: "plan-stat-no-dedup", tasks: [{ title: "t1", status: "pending" }] });
+        const event = makeEvent({
+            toolCallId: "call-ps8",
+            toolName: "xg_plan_write",
+            details: makeSuccessPayload(plan),
+        });
+        handler(event, FAKE_CTX);
+        handler(event, FAKE_CTX);
+        handler(event, FAKE_CTX);
+        assert.equal(deps.planStatCalls.length, 3, "不去重：同一 plan 连续 3 次成功调用应各发一条");
+    });
+});
+describe("createPlanToolResultMiddleware: xg_action_dispatch → RUN_EVENT", () => {
+    it("成功结果按 eventId 反查权威 action 并推送", () => {
+        const deps = new RecordingDeps();
+        const action = {
+            eventId: "evt-1", event: "action_dispatch", action: "ui_refresh", target: "order_detail",
+            version: 1, status: "completed", payload: { data: { id: "ORD-1" } }, timestamp: "2026-08-13T00:00:00.000Z",
+            origin: { channel: "xg_cwork_im", to: "g-1" },
+        };
+        deps.actionById.set(action.eventId, action);
+        const handler = createPlanToolResultMiddleware(deps);
+        handler(makeEvent({ toolName: "xg_action_dispatch", details: { ok: true, eventId: action.eventId } }), FAKE_CTX);
+        assert.deepEqual(deps.actionRunEventCalls, [action]);
+        assert.equal(deps.planStatCalls.length, 0);
+    });
+    it("失败结果或缺失权威 action 均不推送", () => {
+        const deps = new RecordingDeps();
+        const handler = createPlanToolResultMiddleware(deps);
+        handler(makeEvent({ toolName: "xg_action_dispatch", details: { ok: false } }), FAKE_CTX);
+        handler(makeEvent({ toolName: "xg_action_dispatch", details: { ok: true, eventId: "missing" } }), FAKE_CTX);
+        assert.equal(deps.actionRunEventCalls.length, 0);
     });
 });
 //# sourceMappingURL=plan-tool-middleware.test.js.map