@xgjktech/xg_cwork_im 1.18.9 → 1.19.0

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

@@ -1,623 +1,103 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { createPlanToolResultMiddleware } from "./plan-tool-middleware.js";
-const FAKE_CTX = { runtime: "openclaw" };
-function makePlan(overrides = {}) {
+import { createPlanToolResultMiddleware, } from "./plan-tool-middleware.js";
+function makeAction(eventId, overrides = {}) {
     return {
-        planId: "plan-1",
-        goal: "迁移配置到新版本",
-        createdAt: "2026-07-27T00:00:00.000Z",
-        updatedAt: "2026-07-27T00:00:00.000Z",
-        tasks: [],
+        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" },
         ...overrides,
     };
 }
-function makeEvent(overrides) {
-    const content = overrides.text !== undefined
-        ? [{ type: "text", text: overrides.text }]
-        : [];
+function makeToolEvent(toolName, overrides = {}) {
     return {
-        toolCallId: overrides.toolCallId ?? "call-1",
-        toolName: overrides.toolName ?? "xg_plan_write",
+        toolCallId: "call-1",
+        toolName,
         args: {},
-        result: {
-            details: overrides.details,
-            content,
-        },
-    };
-}
-function makeSuccessPayload(plan, withEvent = false) {
-    return {
-        ok: true,
-        planId: plan.planId,
-        plan,
-        ...(withEvent ? { event: { emitted: false, reason: "no runId" } } : {}),
-    };
-}
-function makeDraftSuccessPayload(planId) {
-    return {
-        ok: true,
-        planId,
-        view: `goal: 草稿计划\nT0 [ ] 任务`,
+        result: { details: undefined, content: [] },
+        ...overrides,
     };
 }
-class RecordingDeps {
-    planById = new Map();
-    planStatCalls = [];
-    sendPlanStatImpl = (params) => {
-        this.planStatCalls.push(params);
-    };
-    getPlanById = (planId) => {
-        return this.planById.get(planId);
-    };
-    sendPlanStat = (params) => {
-        this.sendPlanStatImpl(params);
-    };
+class Probe {
+    sent = [];
     actionById = new Map();
-    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;
+    deps;
+    handler;
+    constructor() {
+        this.deps = {
+            getActionById: (eventId) => this.actionById.get(eventId),
+            sendActionRunEvent: (action) => {
+                this.sent.push(action);
+            },
+        };
+        this.handler = createPlanToolResultMiddleware(this.deps);
     }
-    return lines;
 }
-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 = () => {
+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 = () => {
             throw new Error("boom");
         };
-        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 = () => {
+        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 = () => {
             throw new Error("boom");
         };
-        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);
+        assert.equal(probe.handler(makeToolEvent("xg_action_dispatch", {
+            result: { details: { ok: true, eventId: "e-1" }, content: [] },
+        }), undefined), undefined);
     });
 });
 //# sourceMappingURL=plan-tool-middleware.test.js.map