aws-runtime-bridge 1.9.130 → 1.9.134

package/package/aws-client-agent-mcp/dist/mcp-server.test.js

@@ -1,2798 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { after, before, describe, it } from "node:test";
-import { AgentClient, PollLongPollTimeoutError } from "./agent-client.js";
-import { McpServer } from "./mcp-server.js";
-import { MCP_TOOLS } from "./mcp-tools.js";
-import { MemoryStore, } from "./memory-store.js";
-import { MessageBuffer } from "./message-buffer.js";
-function createServerWithUnread(unreadMessages, overrides = {}) {
-    const server = new McpServer();
-    Reflect.set(server, "messageBuffer", new MessageBuffer());
-    const agentClientStub = {
-        getStatusReporter: () => null,
-        getMyTasks: async () => [],
-        getState: () => ({
-            agentId: "agent-self",
-            displayName: "Self Agent",
-            isConnected: true,
-            isRegistered: true,
-        }),
-        fetchUnreadMessages: async () => unreadMessages,
-        markMeetingRead: async () => { },
-        callAgentScopedTool: async () => {
-            throw new Error("unexpected callAgentScopedTool in test stub");
-        },
-        ...overrides,
-    };
-    Reflect.set(server, "agentClient", agentClientStub);
-    return server;
-}
-async function withMemoryServer(callback) {
-    const dir = await mkdtemp(path.join(os.tmpdir(), "aws-mcp-memory-"));
-    const server = new McpServer();
-    Reflect.set(server, "memoryStore", new MemoryStore(path.join(dir, "instance-memory")));
-    Reflect.set(server, "roleMemoryStore", new MemoryStore(path.join(dir, "role-memory")));
-    try {
-        return await callback(server);
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-    }
-}
-async function withScopedMemoryServers(callback) {
-    const dir = await mkdtemp(path.join(os.tmpdir(), "aws-mcp-scoped-memory-"));
-    const firstServer = new McpServer();
-    const secondServer = new McpServer();
-    Reflect.set(firstServer, "memoryStore", new MemoryStore(path.join(dir, "agent-one-memory")));
-    Reflect.set(secondServer, "memoryStore", new MemoryStore(path.join(dir, "agent-two-memory")));
-    Reflect.set(firstServer, "roleMemoryStore", new MemoryStore(path.join(dir, "shared-role-memory")));
-    Reflect.set(secondServer, "roleMemoryStore", new MemoryStore(path.join(dir, "shared-role-memory")));
-    try {
-        return await callback(firstServer, secondServer);
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-    }
-}
-function getHandleToolCall(server) {
-    return Reflect.get(server, "handleToolCall");
-}
-/**
- * 测试辅助：访问 McpServer 的私有 messageBuffer（WebSocket 本地消息队列），
- * 用于模拟外部消息到达后唤醒阻塞中的 poll_message。
- * 注意：直接依赖私有字段名，若 mcp-server.ts 重命名该字段需同步修改本函数，
- * 避免测试在字段改名后静默失效（Reflect 访问不会报编译错误）。
- */
-function getMessageBuffer(server) {
-    return Reflect.get(server, "messageBuffer");
-}
-function attachMemoryStatsReporter(server, reportedStats) {
-    const existingClient = Reflect.get(server, "agentClient");
-    Reflect.set(server, "agentClient", {
-        ...existingClient,
-        getStatusReporter: () => null,
-        reportMemoryStats: async (memoryStats) => {
-            reportedStats.push(memoryStats);
-        },
-    });
-}
-function withTemporaryEnv(values, callback) {
-    const previousValues = new Map();
-    for (const [key, value] of Object.entries(values)) {
-        previousValues.set(key, process.env[key]);
-        if (value === undefined) {
-            delete process.env[key];
-        }
-        else {
-            process.env[key] = value;
-        }
-    }
-    try {
-        return callback();
-    }
-    finally {
-        for (const [key, value] of previousValues.entries()) {
-            if (value === undefined) {
-                delete process.env[key];
-            }
-            else {
-                process.env[key] = value;
-            }
-        }
-    }
-}
-describe("MCP task tool exposure", () => {
-    it("should not expose start_task because task claiming is silent", () => {
-        assert.equal(MCP_TOOLS.some((tool) => tool.name === "start_task"), false);
-    });
-});
-describe("McpServer unread backlog hydration", () => {
-    it("poll_message should return unread direct and group messages fetched after restart", async () => {
-        const directMessage = {
-            msgId: "dm-offline-1",
-            senderId: "agent-b",
-            senderName: "Agent B",
-            content: "offline dm",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const groupMessage = {
-            msgId: 101,
-            senderId: "agent-c",
-            senderName: "Agent C",
-            content: "offline group",
-            timestamp: new Date().toISOString(),
-            projectId: "demo",
-        };
-        const server = createServerWithUnread({
-            directMessages: [directMessage],
-            groupMessages: [groupMessage],
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = await handleToolCall.call(server, "poll_message", {});
-        assert.deepEqual(result, {
-            directMessages: [directMessage],
-            groupMessages: [groupMessage],
-            fromBuffer: true,
-            systemMessages: [],
-        });
-    });
-    it("get_message should return unread messages fetched when local buffer is empty", async () => {
-        const directMessage = {
-            msgId: "dm-offline-2",
-            senderId: "agent-d",
-            senderName: "Agent D",
-            content: "wake up dm",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const server = createServerWithUnread({
-            directMessages: [directMessage],
-            groupMessages: [],
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = await handleToolCall.call(server, "get_message", {});
-        assert.deepEqual(result, {
-            directMessages: [directMessage],
-            groupMessages: [],
-            fromBuffer: false,
-            systemMessages: [],
-        });
-    });
-    it("poll_message should keep blocking through empty polls until messages arrive", async () => {
-        const directMessage = {
-            msgId: "dm-delayed-1",
-            senderId: "agent-delayed",
-            senderName: "Agent Delayed",
-            content: "delayed dm",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const fetchOptions = [];
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async (options) => {
-                fetchOptions.push(options ?? {});
-                return { directMessages: [], groupMessages: [] };
-            },
-        });
-        // Simulate a WebSocket message arriving after hydration returns empty.
-        // poll_message must keep blocking on the local buffer until the message arrives.
-        const buffer = getMessageBuffer(server);
-        setTimeout(() => {
-            buffer.push(directMessage);
-        }, 50);
-        const handleToolCall = getHandleToolCall(server);
-        const result = await handleToolCall.call(server, "poll_message", {});
-        assert.deepEqual(result, {
-            directMessages: [directMessage],
-            groupMessages: [],
-            fromBuffer: true,
-            systemMessages: [],
-        });
-        // fetchUnreadMessages should only be called once (the initial non-blocking hydrate).
-        // The message must arrive via the local buffer (WebSocket push), not a second blocking fetch.
-        assert.equal(fetchOptions.length, 1);
-        assert.equal(fetchOptions[0].blockIfEmpty, false);
-        assert.equal(fetchOptions[0].includePipelineTasks, true);
-    });
-    it("poll_message should exit promptly when the client aborts the request", async () => {
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => ({ directMessages: [], groupMessages: [] }),
-        });
-        const controller = new AbortController();
-        const handleToolCall = getHandleToolCall(server);
-        const pending = handleToolCall.call(server, "poll_message", {}, controller.signal);
-        // 等循环进入 messageBuffer.poll 阻塞，再模拟客户端取消（MCP 超时/断开触发 extra.signal）
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        controller.abort();
-        getMessageBuffer(server).wakeUpWaiters();
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        assert.notEqual(result, "timeout", "poll_message must exit after client abort instead of blocking forever");
-        assert.deepEqual(result.directMessages, []);
-        assert.deepEqual(result.groupMessages, []);
-    });
-    it("poll_message must requeue consumed messages when aborted after consumption", async () => {
-        // 消息打服务端标记：让阻塞循环在消费后进入 mark_dm_read 撤回确认，
-        // 通过慢确认把 abort 卡在"已消费、未交付"窗口内（真实 race 场景的时间线）
-        const directMessage = {
-            msgId: "dm-abort-after-consume",
-            senderId: "agent-sender",
-            senderName: "Agent Sender",
-            content: "message consumed right before abort",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-            _awsServerMessage: true,
-        };
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => ({ directMessages: [], groupMessages: [] }),
-            markDmRead: async (msgIds) => {
-                await new Promise((resolve) => setTimeout(resolve, 150));
-                return new Set(msgIds);
-            },
-        });
-        const controller = new AbortController();
-        const handleToolCall = getHandleToolCall(server);
-        const buffer = getMessageBuffer(server);
-        const pending = handleToolCall.call(server, "poll_message", {}, controller.signal);
-        // 消息在 poll 阻塞期间到达并被消费（卡在 mark_dm_read 确认中），随后调用方取消
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        buffer.push(directMessage);
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        assert.ok(controller.signal.aborted === false);
-        controller.abort();
-        getMessageBuffer(server).wakeUpWaiters();
-        await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]);
-        // 关键断言：被取消的 poll 消费过的消息必须回滚到缓冲区，
-        // 否则下次 poll_message 永远拿不到（本地去重 + 服务端已读双重拦截）
-        assert.equal(buffer.size(), 1, "consumed message must be requeued back to the buffer after abort");
-        const redelivered = await buffer.poll(0);
-        assert.deepEqual(redelivered.directMessages.map((m) => m.msgId), [directMessage.msgId]);
-    });
-    it("poll_message should handle hydration error gracefully and receive WebSocket messages", async () => {
-        const directMessage = {
-            msgId: "dm-hydration-error-ws",
-            senderId: "agent-ws",
-            senderName: "Agent WS",
-            content: "delivered via WebSocket after hydration error",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        let fetchCount = 0;
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => {
-                fetchCount += 1;
-                throw new Error("MCP tool poll_message timed out after 120000ms");
-            },
-        });
-        // Simulate WebSocket message arriving after hydration fails
-        const buffer = getMessageBuffer(server);
-        setTimeout(() => {
-            buffer.push(directMessage);
-        }, 50);
-        const handleToolCall = getHandleToolCall(server);
-        const result = await handleToolCall.call(server, "poll_message", {});
-        assert.deepEqual(result, {
-            directMessages: [directMessage],
-            groupMessages: [],
-            fromBuffer: true,
-            systemMessages: [],
-        });
-        // fetchUnreadMessages should only be called once (the initial hydrate, which throws).
-        // hydrateUnreadMessagesFromServer catches the error, and poll_message falls back to
-        // blocking on the local buffer until the WebSocket message arrives.
-        assert.equal(fetchCount, 1);
-    });
-    it("get_message should still hydrate unread group messages after profile push is received", async () => {
-        const groupMessage = {
-            msgId: 301,
-            senderId: "agent-e",
-            senderName: "Agent E",
-            content: "offline group after profile",
-            timestamp: new Date().toISOString(),
-            projectId: "demo",
-            roomId: "inner_group:g-1",
-        };
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [groupMessage],
-        });
-        const messageBuffer = getMessageBuffer(server);
-        messageBuffer.setProfileMessage({
-            id: "agent-1",
-            displayName: "Agent One",
-            roleName: "Backend Agent",
-            prompt: "prompt",
-            isOnline: true,
-            onlineSince: new Date().toISOString(),
-            createdAt: new Date().toISOString(),
-            projectId: "demo",
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = (await handleToolCall.call(server, "get_message", {}));
-        assert.equal(result.fromBuffer, false);
-        assert.deepEqual(result.directMessages, []);
-        assert.deepEqual(result.groupMessages, [groupMessage]);
-    });
-    it("get_message should filter out self-sent unread group messages fetched from server", async () => {
-        const selfGroupMessage = {
-            msgId: 401,
-            senderId: "agent-self",
-            senderName: "Self Agent",
-            content: "my own group message",
-            timestamp: new Date().toISOString(),
-            projectId: "demo",
-            roomId: "project:demo",
-        };
-        const otherGroupMessage = {
-            msgId: 402,
-            senderId: "agent-other",
-            senderName: "Other Agent",
-            content: "other group message",
-            timestamp: new Date().toISOString(),
-            projectId: "demo",
-            roomId: "project:demo",
-        };
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [selfGroupMessage, otherGroupMessage],
-        });
-        Reflect.set(server, "agentClient", {
-            fetchUnreadMessages: async () => ({
-                directMessages: [],
-                groupMessages: [selfGroupMessage, otherGroupMessage],
-            }),
-            getState: () => ({
-                agentId: "agent-self",
-                displayName: "Self Agent",
-                isConnected: true,
-                isRegistered: true,
-            }),
-            getMyTasks: async () => [],
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = await handleToolCall.call(server, "get_message", {});
-        assert.deepEqual(result, {
-            directMessages: [],
-            groupMessages: [otherGroupMessage],
-            fromBuffer: false,
-            systemMessages: [],
-        });
-    });
-    it("poll_message should filter out self-sent unread messages fetched from server", async () => {
-        const selfDirectMessage = {
-            msgId: "dm-self-1",
-            senderId: "agent-self",
-            senderName: "Self Agent",
-            receiverId: "agent-self",
-            content: "my own direct message",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const otherDirectMessage = {
-            msgId: "dm-other-1",
-            senderId: "agent-other",
-            senderName: "Other Agent",
-            receiverId: "agent-self",
-            content: "other direct message",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const selfGroupMessage = {
-            msgId: 403,
-            senderId: "agent-self",
-            senderName: "Self Agent",
-            content: "my own group message",
-            timestamp: new Date().toISOString(),
-            projectId: "demo",
-            roomId: "project:demo",
-        };
-        const otherGroupMessage = {
-            msgId: 404,
-            senderId: "agent-other",
-            senderName: "Other Agent",
-            content: "other group message",
-            timestamp: new Date().toISOString(),
-            projectId: "demo",
-            roomId: "project:demo",
-        };
-        const server = createServerWithUnread({
-            directMessages: [selfDirectMessage, otherDirectMessage],
-            groupMessages: [selfGroupMessage, otherGroupMessage],
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.deepEqual(result.directMessages, [otherDirectMessage]);
-        assert.deepEqual(result.groupMessages, [otherGroupMessage]);
-        assert.equal(result.fromBuffer, true);
-    });
-    it("get_message should ignore malformed unread group entries instead of crashing", async () => {
-        const validGroupMessage = {
-            msgId: 501,
-            senderId: "agent-other",
-            senderName: "Other Agent",
-            content: "valid group message",
-            timestamp: new Date().toISOString(),
-            projectId: "demo",
-            roomId: "project:demo",
-        };
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [validGroupMessage],
-        });
-        Reflect.set(server, "agentClient", {
-            fetchUnreadMessages: async () => ({
-                directMessages: [],
-                groupMessages: [undefined, validGroupMessage],
-            }),
-            getState: () => ({
-                agentId: "agent-self",
-                displayName: "Self Agent",
-                isConnected: true,
-                isRegistered: true,
-            }),
-            getMyTasks: async () => [],
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = await handleToolCall.call(server, "get_message", {});
-        assert.deepEqual(result, {
-            directMessages: [],
-            groupMessages: [validGroupMessage],
-            fromBuffer: false,
-            systemMessages: [],
-        });
-    });
-    it("get_message should pass through backend task notification without local my_task injection", async () => {
-        const taskNotification = {
-            msgId: "task-notify-backend-1",
-            senderId: "MCP-System",
-            senderName: "系统",
-            receiverId: "agent-self",
-            content: "你有任务需要关注！1 个待处理任务：实现接口。",
-            requireReply: false,
-            prompt: "后端动态任务提醒",
-            timestamp: new Date().toISOString(),
-        };
-        let myTaskCalls = 0;
-        const server = createServerWithUnread({
-            directMessages: [taskNotification],
-            groupMessages: [],
-        }, {
-            getMyTasks: async () => {
-                myTaskCalls += 1;
-                return [];
-            },
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "get_message", {}));
-        assert.deepEqual(result.directMessages, [taskNotification]);
-        assert.deepEqual(result.groupMessages, []);
-        assert.equal(result.fromBuffer, false);
-        assert.equal(myTaskCalls, 0);
-    });
-    it("poll_message should attempt non-blocking backend task claim before local return", async () => {
-        const taskNotification = {
-            msgId: "task-notify-backend-2",
-            senderId: "MCP-System",
-            senderName: "系统",
-            receiverId: "agent-self",
-            content: "你有任务需要关注！1 个处理中任务：需要提交。",
-            requireReply: false,
-            prompt: "后端动态任务提醒",
-            timestamp: new Date().toISOString(),
-        };
-        const fetchOptions = [];
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [],
-        }, {
-            fetchUnreadMessages: async (options) => {
-                fetchOptions.push(options);
-                return { directMessages: [taskNotification], groupMessages: [] };
-            },
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.deepEqual(result.directMessages, [taskNotification]);
-        assert.deepEqual(result.groupMessages, []);
-        assert.equal(result.fromBuffer, true);
-        assert.equal(fetchOptions.length, 1);
-        assert.equal(fetchOptions[0]?.blockIfEmpty, false);
-        assert.equal(fetchOptions[0]?.includePipelineTasks, true);
-        assert.equal(fetchOptions[0]?.blockTimeoutMs, undefined);
-    });
-    it("poll_message should merge existing local cache with newly claimed task notification", async () => {
-        const cachedMessage = {
-            msgId: "cached-dm-before-task",
-            senderId: "agent-cached",
-            senderName: "Cached Agent",
-            receiverId: "agent-self",
-            content: "cached message already in local buffer",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const taskNotification = {
-            msgId: "task-notify-claimed-with-cache",
-            senderId: "MCP-System",
-            senderName: "系统",
-            receiverId: "agent-self",
-            content: "你有任务需要关注！已通过 poll_message 静默抢占。",
-            requireReply: false,
-            prompt: "后端动态任务提醒",
-            timestamp: new Date().toISOString(),
-        };
-        const fetchOptions = [];
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [],
-        }, {
-            fetchUnreadMessages: async (options) => {
-                fetchOptions.push(options);
-                return { directMessages: [taskNotification], groupMessages: [] };
-            },
-        });
-        const messageBuffer = getMessageBuffer(server);
-        messageBuffer.push(cachedMessage);
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.deepEqual(result.directMessages, [cachedMessage, taskNotification]);
-        assert.deepEqual(result.groupMessages, []);
-        assert.equal(result.fromBuffer, true);
-        assert.equal(fetchOptions.length, 1);
-        assert.equal(fetchOptions[0]?.blockIfEmpty, false);
-        assert.equal(fetchOptions[0]?.includePipelineTasks, true);
-    });
-    it("poll_message should wait for WebSocket messages when backend long polling returns empty", async () => {
-        const delayedMessage = {
-            msgId: "dm-after-empty-poll",
-            senderId: "agent-later",
-            senderName: "Later Agent",
-            receiverId: "agent-self",
-            content: "arrived after empty backend poll",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        let fetchCalls = 0;
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [],
-        }, {
-            fetchUnreadMessages: async () => {
-                fetchCalls += 1;
-                return { directMessages: [], groupMessages: [] };
-            },
-        });
-        // Simulate WebSocket message arriving after backend returns empty
-        const buffer = getMessageBuffer(server);
-        setTimeout(() => {
-            buffer.push(delayedMessage);
-        }, 50);
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        // Only the initial non-blocking hydrate should call fetchUnreadMessages.
-        // The message must arrive via the local buffer (WebSocket push).
-        assert.equal(fetchCalls, 1);
-        assert.deepEqual(result.directMessages, [delayedMessage]);
-        assert.deepEqual(result.groupMessages, []);
-        assert.equal(result.fromBuffer, true);
-    });
-    it("poll_message should restore waiting status when task notification is returned", async () => {
-        const statusEvents = [];
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [],
-        }, {
-            fetchUnreadMessages: async () => ({
-                directMessages: [
-                    {
-                        msgId: "task-notify-thinking",
-                        senderId: "MCP-System",
-                        senderName: "系统",
-                        receiverId: "agent-self",
-                        content: "你有任务需要关注！处理待办流程。",
-                        requireReply: false,
-                        timestamp: new Date().toISOString(),
-                    },
-                ],
-                groupMessages: [],
-            }),
-            getStatusReporter: () => ({
-                reportToolUse: () => statusEvents.push("tool_using"),
-                reportToolResult: () => statusEvents.push("tool_result"),
-                reportThinking: () => statusEvents.push("thinking"),
-                reportWaitingInput: () => statusEvents.push("waiting_input"),
-                reportError: () => statusEvents.push("error"),
-                reportToolError: () => statusEvents.push("tool_error"),
-            }),
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.equal(result.directMessages.length, 1);
-        assert.deepEqual(statusEvents, ["tool_using", "tool_result", "thinking"]);
-    });
-    it("get_message should restore thinking status when task notification is returned", async () => {
-        const statusEvents = [];
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [],
-        }, {
-            fetchUnreadMessages: async () => ({
-                directMessages: [
-                    {
-                        msgId: "task-notify-get-message",
-                        senderId: "MCP-System",
-                        senderName: "系统",
-                        receiverId: "agent-self",
-                        content: "你有任务需要关注！继续流程任务。",
-                        requireReply: false,
-                        timestamp: new Date().toISOString(),
-                    },
-                ],
-                groupMessages: [],
-            }),
-            getStatusReporter: () => ({
-                reportToolUse: () => statusEvents.push("tool_using"),
-                reportToolResult: () => statusEvents.push("tool_result"),
-                reportThinking: () => statusEvents.push("thinking"),
-                reportWaitingInput: () => statusEvents.push("waiting_input"),
-                reportError: () => statusEvents.push("error"),
-                reportToolError: () => statusEvents.push("tool_error"),
-            }),
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "get_message", {}));
-        assert.equal(result.directMessages.length, 1);
-        assert.deepEqual(statusEvents, ["tool_using", "tool_result", "thinking"]);
-    });
-    it("poll_message should restore thinking status when unread messages are returned", async () => {
-        const statusEvents = [];
-        const directMessage = {
-            msgId: "dm-status-thinking",
-            senderId: "agent-status-source",
-            senderName: "Status Source",
-            content: "work message",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const server = createServerWithUnread({
-            directMessages: [directMessage],
-            groupMessages: [],
-        }, {
-            getStatusReporter: () => ({
-                reportToolUse: () => statusEvents.push("tool_using"),
-                reportToolResult: () => statusEvents.push("tool_result"),
-                reportThinking: () => statusEvents.push("thinking"),
-                reportWaitingInput: () => statusEvents.push("waiting_input"),
-                reportError: () => statusEvents.push("error"),
-                reportToolError: () => statusEvents.push("tool_error"),
-            }),
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.deepEqual(result.directMessages, [directMessage]);
-        assert.deepEqual(statusEvents, ["tool_using", "tool_result", "thinking"]);
-    });
-    it("get_message should restore thinking status when unread messages are returned", async () => {
-        const statusEvents = [];
-        const directMessage = {
-            msgId: "dm-get-status-waiting",
-            senderId: "agent-get-status-source",
-            senderName: "Get Status Source",
-            content: "private work message",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const server = createServerWithUnread({
-            directMessages: [directMessage],
-            groupMessages: [],
-        }, {
-            getStatusReporter: () => ({
-                reportToolUse: () => statusEvents.push("tool_using"),
-                reportToolResult: () => statusEvents.push("tool_result"),
-                reportThinking: () => statusEvents.push("thinking"),
-                reportWaitingInput: () => statusEvents.push("waiting_input"),
-                reportError: () => statusEvents.push("error"),
-                reportToolError: () => statusEvents.push("tool_error"),
-            }),
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "get_message", {}));
-        assert.deepEqual(result.directMessages, [directMessage]);
-        assert.deepEqual(statusEvents, [
-            "tool_using",
-            "tool_result",
-            "thinking",
-        ]);
-    });
-    it("get_message should restore thinking status when no messages or tasks are returned", async () => {
-        const statusEvents = [];
-        const server = createServerWithUnread({
-            directMessages: [],
-            groupMessages: [],
-        }, {
-            getStatusReporter: () => ({
-                reportToolUse: () => statusEvents.push("tool_using"),
-                reportToolResult: () => statusEvents.push("tool_result"),
-                reportThinking: () => statusEvents.push("thinking"),
-                reportWaitingInput: () => statusEvents.push("waiting_input"),
-                reportError: () => statusEvents.push("error"),
-                reportToolError: () => statusEvents.push("tool_error"),
-            }),
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "get_message", {}));
-        assert.deepEqual(result.directMessages, []);
-        assert.deepEqual(result.groupMessages, []);
-        assert.deepEqual(statusEvents, [
-            "tool_using",
-            "tool_result",
-            "thinking",
-        ]);
-    });
-    it("poll_message should skip reportToolResult and reportThinking when only _acodeAutoDelegate messages are returned", async () => {
-        const statusEvents = [];
-        const reportedResults = [];
-        const delegateMessage = {
-            msgId: "memory-update-pending-1",
-            senderId: "MCP-System",
-            senderName: "系统",
-            receiverId: "agent-self",
-            content: "您有以下 Memory 正处于更新中状态",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-            _acodeAutoDelegate: {
-                type: "memory_file_change",
-                uris: ["architecture://relay/core-routing"],
-            },
-        };
-        const server = createServerWithUnread({
-            directMessages: [delegateMessage],
-            groupMessages: [],
-        }, {
-            getStatusReporter: () => ({
-                reportToolUse: () => statusEvents.push("tool_using"),
-                reportToolResult: (r) => {
-                    statusEvents.push("tool_result");
-                    reportedResults.push(r);
-                },
-                reportThinking: () => statusEvents.push("thinking"),
-                reportWaitingInput: () => statusEvents.push("waiting_input"),
-                reportError: () => statusEvents.push("error"),
-                reportToolError: () => statusEvents.push("tool_error"),
-            }),
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.equal(result.directMessages.length, 1);
-        // 委托消息：保持 tool_using 状态，不上报 tool_result 也不上报 thinking
-        // 主 agent 仍在 poll_message 循环中等待真正的消息，委托给子 agent 处理不应影响主 agent 状态
-        assert.deepEqual(statusEvents, ["tool_using"]);
-        assert.equal(reportedResults.length, 0);
-    });
-    it("poll_message should filter _acodeAutoDelegate from reportToolResult but keep normal messages", async () => {
-        const statusEvents = [];
-        const reportedResults = [];
-        const delegateMessage = {
-            msgId: "memory-update-pending-2",
-            senderId: "MCP-System",
-            senderName: "系统",
-            receiverId: "agent-self",
-            content: "请继续完成更新工作",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-            _acodeAutoDelegate: {
-                type: "memory_file_change",
-                uris: ["architecture://overview/system-architecture"],
-            },
-        };
-        const normalMessage = {
-            msgId: "dm-normal-work",
-            senderId: "agent-colleague",
-            senderName: "Colleague",
-            content: "请帮忙看一下这个接口",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const server = createServerWithUnread({
-            directMessages: [delegateMessage, normalMessage],
-            groupMessages: [],
-        }, {
-            getStatusReporter: () => ({
-                reportToolUse: () => statusEvents.push("tool_using"),
-                reportToolResult: (r) => {
-                    statusEvents.push("tool_result");
-                    reportedResults.push(r);
-                },
-                reportThinking: () => statusEvents.push("thinking"),
-                reportWaitingInput: () => statusEvents.push("waiting_input"),
-                reportError: () => statusEvents.push("error"),
-                reportToolError: () => statusEvents.push("tool_error"),
-            }),
-        });
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.equal(result.directMessages.length, 2);
-        assert.deepEqual(statusEvents, ["tool_using", "tool_result", "thinking"]);
-        assert.equal(reportedResults.length, 1);
-        const reported = reportedResults[0];
-        assert.equal(reported.directMessages.length, 1);
-        assert.equal(reported.directMessages[0].msgId, "dm-normal-work");
-    });
-});
-describe("McpServer memory store paths", () => {
-    it("uses project permanent memory directory by default", async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), "aws-mcp-memory-paths-"));
-        try {
-            const paths = withTemporaryEnv({
-                AWS_WORKSPACE_PATH: dir,
-                AWS_ROLE_NAME: "Backend/Engineer:Lead",
-                AWS_MEMORY_STORE_PATH: undefined,
-                AWS_ROLE_MEMORY_STORE_PATH: undefined,
-                AWS_INSTANCE_MEMORY_STORE_PATH: undefined,
-                AWS_AGENT_ID: undefined,
-            }, () => Reflect.get(McpServer, "resolveMemoryStorePaths").call(McpServer));
-            assert.equal(paths.rolePath, path.join(dir, ".agentswork", "memory", "memory", "Backend_Engineer_Lead"));
-            assert.equal(paths.instancePath, path.join(dir, ".agentswork", "memory", "server-managed"));
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        }
-    });
-    it("falls back to a default role memory directory when role name is blank", async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), "aws-mcp-memory-paths-"));
-        try {
-            const paths = withTemporaryEnv({
-                AWS_WORKSPACE_PATH: dir,
-                AWS_ROLE_NAME: "  ",
-                AWS_MEMORY_STORE_PATH: undefined,
-                AWS_ROLE_MEMORY_STORE_PATH: undefined,
-                AWS_INSTANCE_MEMORY_STORE_PATH: undefined,
-                AWS_AGENT_ID: undefined,
-            }, () => Reflect.get(McpServer, "resolveMemoryStorePaths").call(McpServer));
-            assert.equal(paths.rolePath, path.join(dir, ".agentswork", "memory", "memory", "default-role"));
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        }
-    });
-});
-describe("McpServer memory tools", () => {
-    it("exposes memory tools in MCP tool catalog", () => {
-        const toolNames = MCP_TOOLS.map((tool) => tool.name);
-        assert.ok(toolNames.includes("create_memory"));
-        assert.ok(toolNames.includes("read_memory"));
-        assert.ok(toolNames.includes("update_memory"));
-        assert.ok(toolNames.includes("delete_memory"));
-        assert.ok(toolNames.includes("search_memory"));
-        assert.ok(toolNames.includes("list_memories"));
-        assert.ok(toolNames.includes("get_memory_stats"));
-        // Memory 近期记忆过期与回忆工具 (v1.11.0)
-        assert.ok(toolNames.includes("memory_recurrence"));
-        assert.ok(toolNames.includes("memory_recurrence_complete"));
-    });
-    it("creates, reads, updates, searches, and deletes memory through MCP dispatch", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            const created = await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "Core://Agent/Profile/",
-                content: "prefers concise backend summaries",
-            });
-            assert.equal(created.uri, "core://Agent/Profile");
-            assert.equal(created.content, undefined);
-            const read = await handleToolCall.call(server, "read_memory", {
-                uri: "core://Agent/Profile",
-                memory_type: "project_memory",
-            });
-            assert.equal(read.content, "prefers concise backend summaries");
-            const updated = await handleToolCall.call(server, "update_memory", {
-                uri: "core://Agent/Profile",
-                memory_type: "project_memory",
-                old_string: "concise",
-                new_string: "structured",
-                append: "\nuses MCP memory tools",
-            });
-            assert.equal(updated.content, undefined);
-            assert.equal(updated.version, 2);
-            const readUpdated = await handleToolCall.call(server, "read_memory", {
-                uri: "core://Agent/Profile",
-                memory_type: "project_memory",
-            });
-            assert.match(readUpdated.content, /structured backend/);
-            assert.match(readUpdated.content, /MCP memory tools/);
-            const searchResult = await handleToolCall.call(server, "search_memory", {
-                query: "backend",
-                limit: 5,
-            });
-            assert.equal(searchResult.results.length, 1);
-            const deleted = await handleToolCall.call(server, "delete_memory", {
-                uri: "core://Agent/Profile",
-                memory_type: "project_memory",
-            });
-            assert.deepEqual(deleted, { deleted: true });
-        });
-    });
-    it("delete_memory supports batch deletion via memories array", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            // 准备 4 条不同类型的记忆（模拟过期回忆流程中跨类型 recalling 场景）
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
-                uri: "task://batch/a",
-                content: "a",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "agent_memory",
-                uri: "agent://batch/b",
-                content: "b",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://batch/c",
-                content: "c",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "agent_memory",
-                uri: "agent://batch/d",
-                content: "d",
-            });
-            // 批量删除：跨 3 种类型 + 1 条不存在 + 1 条类型不匹配（用独立 uri 避免与已删项冲突）
-            const result = await handleToolCall.call(server, "delete_memory", {
-                memories: [
-                    { uri: "task://batch/a", memory_type: "recently_memory" },
-                    { uri: "agent://batch/b", memory_type: "agent_memory" },
-                    { uri: "core://batch/c", memory_type: "project_memory" },
-                    { uri: "task://batch/missing" }, // 不存在
-                    { uri: "agent://batch/d", memory_type: "project_memory" }, // 类型不匹配（d 实为 agent_memory）
-                ],
-            });
-            const batch = result;
-            assert.equal(batch.deleted, 3);
-            assert.deepEqual(batch.not_found, ["task://batch/missing"]);
-            assert.equal(batch.failed.length, 1);
-            assert.equal(batch.failed[0].uri, "agent://batch/d");
-            // 类型不匹配的那条仍然存在
-            const stillThere = await handleToolCall.call(server, "read_memory", {
-                uri: "agent://batch/d",
-            });
-            assert.ok(stillThere.uri);
-        });
-    });
-    it("delete_memory batch supports omitted memory_type (auto-detect)", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
-                uri: "task://auto/a",
-                content: "a",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "agent_memory",
-                uri: "agent://auto/b",
-                content: "b",
-            });
-            // 全部省略 memory_type，由系统自动判定
-            const result = await handleToolCall.call(server, "delete_memory", {
-                memories: [{ uri: "task://auto/a" }, { uri: "agent://auto/b" }],
-            });
-            const batch = result;
-            assert.equal(batch.deleted, 2);
-            assert.deepEqual(batch.not_found, []);
-            assert.equal(batch.failed.length, 0);
-        });
-    });
-    it("delete_memory rejects when both uri and memories are provided", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await assert.rejects(() => handleToolCall.call(server, "delete_memory", {
-                uri: "task://x",
-                memories: [{ uri: "task://y" }],
-            }), /uri 和 memories/);
-        });
-    });
-    it("delete_memory rejects when neither uri nor memories is provided", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await assert.rejects(() => handleToolCall.call(server, "delete_memory", {}), /uri 或 memories/);
-        });
-    });
-    it("lists task and recent memories while protecting long-term memory from list_memories", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
-                uri: "task://todo/current",
-                content: "finish memory endpoint tests",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "agent_memory",
-                uri: "recent://discussion/memory-tools",
-                content: "memory tools should stay local for now",
-            });
-            const taskList = await handleToolCall.call(server, "list_memories", {
-                memory_type: "recently_memory",
-            });
-            assert.equal(taskList.length, 1);
-            const recentList = await handleToolCall.call(server, "list_memories", {
-                memory_type: "agent_memory",
-            });
-            assert.equal(recentList.length, 1);
-            await assert.rejects(() => handleToolCall.call(server, "list_memories", {
-                memory_type: "project_memory",
-            }), /Invalid memory_type/);
-        });
-    });
-    it("stores memories in the instance store and isolates them between agent instances", async () => {
-        await withScopedMemoryServers(async (firstServer, secondServer) => {
-            const firstHandleToolCall = getHandleToolCall(firstServer);
-            const secondHandleToolCall = getHandleToolCall(secondServer);
-            await firstHandleToolCall.call(firstServer, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://role/shared-profile",
-                content: "long-term memory of instance one",
-            });
-            await firstHandleToolCall.call(firstServer, "create_memory", {
-                memory_type: "agent_memory",
-                uri: "recent://instance/private-context",
-                content: "agent one private context",
-            });
-            // 当前架构：记忆统一落在实例 store（跨实例共享由服务端 ServerMemoryStore 承担），
-            // 另一个实例本地读不到第一条实例的任何记忆
-            const roleMemoryFromSecond = await secondHandleToolCall.call(secondServer, "read_memory", {
-                uri: "core://role/shared-profile",
-                memory_type: "project_memory",
-            });
-            const recentMemoryFromSecond = await secondHandleToolCall.call(secondServer, "read_memory", {
-                uri: "recent://instance/private-context",
-                memory_type: "agent_memory",
-            });
-            assert.equal(roleMemoryFromSecond, null);
-            assert.equal(recentMemoryFromSecond, null);
-            // 写入实例自己可以正常读回
-            const ownRoleMemory = await firstHandleToolCall.call(firstServer, "read_memory", {
-                uri: "core://role/shared-profile",
-                memory_type: "project_memory",
-            });
-            assert.equal(ownRoleMemory.content, "long-term memory of instance one");
-        });
-    });
-    it("returns memory stats through MCP dispatch", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
-                uri: "task://todo/stats",
-                content: "temporary task",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "agent_memory",
-                uri: "recent://note/stats",
-                content: "hot context",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/profile",
-                content: "long-term profile",
-            });
-            const stats = await handleToolCall.call(server, "get_memory_stats", {});
-            const typedStats = stats;
-            assert.equal(typedStats.total, 3);
-            assert.deepEqual(typedStats.listable, {
-                count: 2,
-                limit: 64,
-                hardLimit: 128,
-                exceeded: false,
-                hardExceeded: false,
-            });
-            assert.equal(typedStats.by_type.recently_memory.count, 1);
-            assert.equal(typedStats.by_type.recently_memory.domainCount, 1);
-            assert.equal(typedStats.by_type.recently_memory.by_domain.task?.count, 1);
-            assert.equal(typedStats.by_type.agent_memory.count, 1);
-            assert.equal(typedStats.by_type.agent_memory.domainCount, 1);
-            assert.equal(typedStats.by_type.agent_memory.by_domain.recent?.count, 1);
-            assert.equal(typedStats.by_type.project_memory.count, 1);
-            assert.equal(typedStats.by_type.project_memory.domainCount, 1);
-            assert.equal(typedStats.by_type.project_memory.by_domain.core?.count, 1);
-        });
-    });
-    it("reports combined memory stats after long-term memory changes", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            const reportedStats = [];
-            attachMemoryStatsReporter(server, reportedStats);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "project://test-aws/permanent-memory-check",
-                content: "dashboard should see this permanent memory count",
-            });
-            assert.equal(reportedStats.length, 1);
-            assert.equal(reportedStats[0]?.by_type.project_memory.count, 1);
-            assert.equal(reportedStats[0]?.by_type.project_memory.by_domain.project?.count, 1);
-        });
-    });
-    it("reports existing combined memory stats after auto registration", async () => {
-        await withMemoryServer(async (server) => {
-            const reportedStats = [];
-            // 当前架构：统计只来自实例 store（roleMemoryStore 合并统计已随双库架构移除）
-            const instanceStore = Reflect.get(server, "memoryStore");
-            await instanceStore.createMemory({
-                memory_type: "project_memory",
-                uri: "project://test-aws/existing-permanent-memory",
-                content: "existing role memory should be visible on dashboard startup",
-            });
-            // profileSynced=true 阻止 activelySyncProfile 异步调用 getProfile（mock 缺失该方法）；
-            // maybeSyncPermanentMemoryToServer 覆盖为空函数避免异步操作干扰 tmpdir cleanup。
-            Reflect.set(server, "hasRoleName", true);
-            Reflect.set(server, "profileSynced", true);
-            Reflect.set(server, "maybeSyncPermanentMemoryToServer", () => { });
-            Reflect.set(server, "agentClient", {
-                getAgentConfig: () => ({ roleName: "backend", agentId: "agent-1" }),
-                register: async () => ({
-                    agentId: "agent-1",
-                    displayName: "Backend Agent",
-                    status: "online",
-                }),
-                start: () => undefined,
-                isInDegradedMode: () => false,
-                getStatusReporter: () => null,
-                reportMemoryStats: async (memoryStats) => {
-                    reportedStats.push(memoryStats);
-                },
-            });
-            const autoRegister = Reflect.get(server, "autoRegister");
-            await autoRegister.call(server);
-            assert.equal(reportedStats.length, 1);
-            assert.equal(reportedStats[0]?.by_type.project_memory.count, 1);
-            assert.equal(reportedStats[0]?.by_type.project_memory.by_domain.project?.count, 1);
-        });
-    });
-    it("returns memory stats for one requested memory type", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
-                uri: "task://todo/stats",
-                content: "temporary task",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "agent_memory",
-                uri: "recent://note/stats",
-                content: "hot context",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/profile",
-                content: "long-term profile",
-            });
-            const stats = (await handleToolCall.call(server, "get_memory_stats", {
-                memory_type: "agent_memory",
-            }));
-            assert.equal(stats.memory_type, "agent_memory");
-            assert.equal(stats.total, 1);
-            assert.deepEqual(Object.keys(stats.by_type), ["agent_memory"]);
-            assert.equal(stats.by_type.agent_memory?.domainCount, 1);
-            assert.equal(stats.by_type.agent_memory?.by_domain.recent?.count, 1);
-            const memoryStats = (await handleToolCall.call(server, "get_memory_stats", { memory_type: "project_memory" }));
-            assert.equal(memoryStats.memory_type, "project_memory");
-            assert.equal(memoryStats.total, 1);
-            assert.deepEqual(Object.keys(memoryStats.by_type), ["project_memory"]);
-            assert.equal(memoryStats.by_type.project_memory?.domainCount, 1);
-            assert.equal(memoryStats.by_type.project_memory?.by_domain.core?.count, 1);
-        });
-    });
-    it("poll_message returns cleanup notice as a while-type when no unread messages", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            Reflect.set(server, "agentClient", {
-                fetchUnreadMessages: async () => ({
-                    directMessages: [],
-                    groupMessages: [],
-                }),
-                getState: () => ({ agentId: "agent-self" }),
-                getStatusReporter: () => null,
-            });
-            for (let index = 0; index < 33; index += 1) {
-                await handleToolCall.call(server, "create_memory", {
-                    memory_type: "agent_memory",
-                    uri: `recent://cleanup/${index}`,
-                    content: `recent ${index}`,
-                });
-            }
-            // Override poll to resolve immediately with empty (simulating timeout without waiting 30s)
-            const buffer = getMessageBuffer(server);
-            let pollCallCount = 0;
-            buffer.poll = ((_timeoutMs) => {
-                pollCallCount++;
-                return Promise.resolve({ directMessages: [], groupMessages: [] });
-            });
-            const result = (await handleToolCall.call(server, "poll_message", {}));
-            assert.equal(result.groupMessages.length, 0);
-            // cleanup notice returned as a while-type (no unread messages)
-            assert.equal(result.directMessages.length, 1);
-            assert.match(result.directMessages[0]?.msgId, /^memory-cleanup-/);
-            assert.equal(result.directMessages[0]?.senderId, "MCP-System");
-            assert.equal(result.directMessages[0]?.receiverId, "agent-self");
-            assert.match(result.directMessages[0]?.content ?? "", /本地 memory 已超过建议容量/);
-            assert.match(result.directMessages[0]?.content ?? "", /get_memory_stats/);
-            assert.equal(result.directMessages[0]?.prompt, undefined);
-            // 非紧急类在初始路径直接返回，不进入 while 循环
-            assert.equal(pollCallCount, 0);
-        });
-    });
-    it("poll_message returns task notification without cleanup notice (while-type not stacked)", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            const taskNotification = {
-                msgId: "task-notify-before-cleanup",
-                senderId: "MCP-System",
-                senderName: "系统",
-                receiverId: "agent-self",
-                content: "你有任务需要关注！cleanup 前已完成静默抢占。",
-                requireReply: false,
-                timestamp: new Date().toISOString(),
-            };
-            const fetchOptions = [];
-            Reflect.set(server, "agentClient", {
-                fetchUnreadMessages: async (options) => {
-                    fetchOptions.push(options ?? {});
-                    return {
-                        directMessages: [taskNotification],
-                        groupMessages: [],
-                    };
-                },
-                getState: () => ({ agentId: "agent-self" }),
-                getStatusReporter: () => null,
-            });
-            for (let index = 0; index < 33; index += 1) {
-                await handleToolCall.call(server, "create_memory", {
-                    memory_type: "agent_memory",
-                    uri: `recent://cleanup-claim/${index}`,
-                    content: `recent ${index}`,
-                });
-            }
-            const result = (await handleToolCall.call(server, "poll_message", {}));
-            // Task notification is returned as an unread message; cleanup is a while-type
-            // that is only checked when there are no unread messages - not stacked with messages.
-            assert.equal(result.groupMessages.length, 0);
-            assert.equal(result.directMessages.length, 1);
-            assert.equal(result.directMessages[0]?.msgId, taskNotification.msgId);
-        });
-    });
-    it("get_message injects a cleanup notice when listable memory exceeds soft limits", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            Reflect.set(server, "agentClient", {
-                fetchUnreadMessages: async () => ({
-                    directMessages: [],
-                    groupMessages: [],
-                }),
-                getState: () => ({ agentId: "agent-self" }),
-                getStatusReporter: () => null,
-            });
-            for (let index = 0; index < 33; index += 1) {
-                await handleToolCall.call(server, "create_memory", {
-                    memory_type: "agent_memory",
-                    uri: `recent://cleanup-get/${index}`,
-                    content: `recent ${index}`,
-                });
-            }
-            const result = (await handleToolCall.call(server, "get_message", {}));
-            assert.equal(result.fromBuffer, true);
-            assert.equal(result.groupMessages.length, 0);
-            assert.equal(result.directMessages.length, 1);
-            assert.match(result.directMessages[0]?.msgId, /^memory-cleanup-/);
-            assert.equal(result.directMessages[0]?.senderId, "MCP-System");
-            assert.equal(result.directMessages[0]?.receiverId, "agent-self");
-            assert.match(result.directMessages[0]?.content ?? "", /本地 memory 已超过建议容量/);
-            assert.match(result.directMessages[0]?.content ?? "", /agent_memory\/recent 类型下当前 33 条 memory/);
-            assert.equal(result.directMessages[0]?.prompt, undefined);
-        });
-    });
-    it("rejects incomplete memory update arguments", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/incomplete-update",
-                content: "original",
-            });
-            await assert.rejects(() => handleToolCall.call(server, "update_memory", {
-                uri: "core://agent/incomplete-update",
-                old_string: "original",
-            }), /old_string and new_string must be provided together/);
-        });
-    });
-    it("get_message with _aws_force_inject returns only force messages and keeps normal ones", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            Reflect.set(server, "agentClient", {
-                fetchUnreadMessages: async () => ({
-                    directMessages: [],
-                    groupMessages: [],
-                }),
-                getState: () => ({ agentId: "agent-self" }),
-                getStatusReporter: () => null,
-            });
-            const messageBuffer = getMessageBuffer(server);
-            messageBuffer.push({
-                msgId: "dm-force-1",
-                senderId: "human-1",
-                senderName: "Human One",
-                content: "紧急消息",
-                requireReply: false,
-                force: true,
-                timestamp: new Date().toISOString(),
-            });
-            messageBuffer.push({
-                msgId: "dm-normal-1",
-                senderId: "agent-2",
-                senderName: "Agent Two",
-                content: "普通消息",
-                requireReply: false,
-                timestamp: new Date().toISOString(),
-            });
-            // runtime 迭代边界强制注入调用：只取 force=true 的私信
-            const result = (await handleToolCall.call(server, "get_message", {
-                _aws_force_inject: true,
-            }));
-            assert.equal(result.directMessages.length, 1);
-            assert.equal(result.directMessages[0]?.msgId, "dm-force-1");
-            assert.equal(result.groupMessages.length, 0);
-            // 普通消息留在缓冲区，下一次 get_message 正常返回
-            const rest = (await handleToolCall.call(server, "get_message", {}));
-            assert.equal(rest.directMessages.length, 1);
-            assert.equal(rest.directMessages[0]?.msgId, "dm-normal-1");
-        });
-    });
-    it("redacts memory content from status reporting", async () => {
-        await withMemoryServer(async (server) => {
-            const reported = [];
-            const statusReporter = {
-                reportToolUse: (name, args) => reported.push({ name, args }),
-                reportToolResult: () => undefined,
-                reportToolError: () => undefined,
-                reportThinking: () => undefined,
-                reportWaitingInput: () => undefined,
-                reportError: () => undefined,
-            };
-            Reflect.set(server, "agentClient", {
-                getStatusReporter: () => statusReporter,
-            });
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/private",
-                content: "secret local memory content",
-            });
-            await handleToolCall.call(server, "update_memory", {
-                uri: "core://agent/private",
-                old_string: "secret",
-                new_string: "private",
-                append: "\nnever report this append",
-            });
-            await handleToolCall.call(server, "search_memory", {
-                query: "private search phrase",
-                limit: 3,
-            });
-            assert.deepEqual(reported[0], {
-                name: "create_memory",
-                args: { uri: "core://agent/private", memory_type: "project_memory" },
-            });
-            assert.deepEqual(reported[1], {
-                name: "update_memory",
-                args: { uri: "core://agent/private" },
-            });
-            assert.deepEqual(reported[2], {
-                name: "search_memory",
-                args: { limit: 3, queryProvided: true },
-            });
-        });
-    });
-    it("keeps normal non-memory status reporting unchanged", async () => {
-        const server = new McpServer();
-        const reported = [];
-        const statusReporter = {
-            reportToolUse: (name, args) => reported.push({ name, args }),
-            reportToolResult: () => undefined,
-            reportToolError: () => undefined,
-            reportThinking: () => undefined,
-            reportWaitingInput: () => undefined,
-            reportError: () => undefined,
-        };
-        Reflect.set(server, "agentClient", {
-            sendGroupMessage: async () => ({
-                msgId: 1,
-                timestamp: new Date().toISOString(),
-            }),
-            getStatusReporter: () => statusReporter,
-        });
-        const handleToolCall = getHandleToolCall(server);
-        await handleToolCall.call(server, "send_group", {
-            content: "normal message",
-            roomId: "project:demo",
-        });
-        assert.deepEqual(reported, [
-            {
-                name: "send_group",
-                args: { content: "normal message", roomId: "project:demo" },
-            },
-        ]);
-    });
-    it("rejects invalid memory type before writing", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await assert.rejects(() => handleToolCall.call(server, "create_memory", {
-                memory_type: "unknown",
-                uri: "core://agent/invalid-type",
-                content: "should not write",
-            }), /Invalid memory_type/);
-        });
-    });
-    it("rejects duplicate create and returns deleted false for missing memory", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/duplicate",
-                content: "first",
-            });
-            await assert.rejects(() => handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/duplicate",
-                content: "second",
-            }), /Memory already exists/);
-            const missingDelete = await handleToolCall.call(server, "delete_memory", {
-                uri: "core://agent/not-found",
-            });
-            assert.deepEqual(missingDelete, { deleted: false });
-        });
-    });
-    it("allows no-content update for status-only refresh (empty append)", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/noop",
-                content: "original",
-            });
-            // 空 append 不再报错，而是执行无内容更新（仅刷新状态/MD5）
-            const result = await handleToolCall.call(server, "update_memory", {
-                uri: "core://agent/noop",
-                append: "",
-            });
-            assert.ok(result, "no-content update should succeed");
-        });
-    });
-    it("rejects create_memory when bound_files contain non-existent paths", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await assert.rejects(() => handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/missing-bound-file",
-                content: "memory with non-existent bound file",
-                bound_files: ["./non-existent-file.ts"],
-            }), /绑定的文件不存在/);
-        });
-    });
-    it("rejects update_memory when new bound_files contain non-existent paths", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/update-with-missing-bound-file",
-                content: "original content",
-            });
-            await assert.rejects(() => handleToolCall.call(server, "update_memory", {
-                uri: "core://agent/update-with-missing-bound-file",
-                memory_type: "project_memory",
-                old_string: "original",
-                new_string: "updated",
-                bound_files: ["./non-existent-file.ts"],
-            }), /绑定的文件不存在/);
-        });
-    });
-    it("allows create_memory with valid existing bound files", async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), "aws-mcp-bound-file-test-"));
-        const testFilePath = path.join(dir, "existing-file.ts");
-        await writeFile(testFilePath, "test content", "utf-8");
-        const previousWorkspacePath = process.env.AWS_WORKSPACE_PATH;
-        process.env.AWS_WORKSPACE_PATH = dir;
-        try {
-            await withMemoryServer(async (server) => {
-                const handleToolCall = getHandleToolCall(server);
-                const created = await handleToolCall.call(server, "create_memory", {
-                    memory_type: "project_memory",
-                    uri: "core://agent/valid-bound-file",
-                    content: "memory with valid bound file",
-                    bound_files: ["./existing-file.ts"],
-                });
-                assert.equal(created.uri, "core://agent/valid-bound-file");
-                assert.deepEqual(created.bound_files, ["./existing-file.ts"]);
-            });
-        }
-        finally {
-            if (previousWorkspacePath === undefined) {
-                delete process.env.AWS_WORKSPACE_PATH;
-            }
-            else {
-                process.env.AWS_WORKSPACE_PATH = previousWorkspacePath;
-            }
-            await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        }
-    });
-    it("rejects create_memory with mixed existing and non-existent bound files", async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), "aws-mcp-bound-file-mixed-"));
-        const testFilePath = path.join(dir, "existing-file.ts");
-        await writeFile(testFilePath, "test content", "utf-8");
-        const previousWorkspacePath = process.env.AWS_WORKSPACE_PATH;
-        process.env.AWS_WORKSPACE_PATH = dir;
-        try {
-            await withMemoryServer(async (server) => {
-                const handleToolCall = getHandleToolCall(server);
-                await assert.rejects(() => handleToolCall.call(server, "create_memory", {
-                    memory_type: "project_memory",
-                    uri: "core://agent/mixed-bound-file",
-                    content: "memory with mixed bound files",
-                    bound_files: ["./existing-file.ts", "./non-existent-file.ts"],
-                }), /non-existent-file/);
-            });
-        }
-        finally {
-            if (previousWorkspacePath === undefined) {
-                delete process.env.AWS_WORKSPACE_PATH;
-            }
-            else {
-                process.env.AWS_WORKSPACE_PATH = previousWorkspacePath;
-            }
-            await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        }
-    });
-    it("allows update_memory without bound_files when existing bound files are absent", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "project_memory",
-                uri: "core://agent/update-without-bound-files",
-                content: "original content",
-            });
-            // Update without bound_files should succeed even if existing bound files are invalid
-            const updated = await handleToolCall.call(server, "update_memory", {
-                uri: "core://agent/update-without-bound-files",
-                memory_type: "project_memory",
-                old_string: "original",
-                new_string: "updated",
-            });
-            assert.equal(updated.version, 2);
-        });
-    });
-    it("normalizes Windows backslash bound_files to forward slashes on create", async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), "aws-mcp-bound-file-backslash-"));
-        const subDir = path.join(dir, "src", "utils");
-        await (await import("node:fs/promises")).mkdir(subDir, { recursive: true });
-        const testFilePath = path.join(subDir, "file.ts");
-        await writeFile(testFilePath, "test content", "utf-8");
-        const previousWorkspacePath = process.env.AWS_WORKSPACE_PATH;
-        process.env.AWS_WORKSPACE_PATH = dir;
-        try {
-            await withMemoryServer(async (server) => {
-                const handleToolCall = getHandleToolCall(server);
-                const created = await handleToolCall.call(server, "create_memory", {
-                    memory_type: "project_memory",
-                    uri: "core://agent/backslash-bound-file",
-                    content: "memory with Windows backslash bound file",
-                    bound_files: ["src\\utils\\file.ts"],
-                });
-                const boundFiles = created.bound_files;
-                assert.deepEqual(boundFiles, ["./src/utils/file.ts"]);
-            });
-        }
-        finally {
-            if (previousWorkspacePath === undefined) {
-                delete process.env.AWS_WORKSPACE_PATH;
-            }
-            else {
-                process.env.AWS_WORKSPACE_PATH = previousWorkspacePath;
-            }
-            await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        }
-    });
-});
-describe("McpServer group discovery tool", () => {
-    it("get_group_rooms should proxy discoverable groups from agent client", async () => {
-        const server = new McpServer();
-        Reflect.set(server, "agentClient", {
-            discoverGroupRooms: async () => ({
-                groups: [
-                    {
-                        id: "project:demo",
-                        projectId: "demo",
-                        roomType: "project",
-                        scopeRefId: "demo",
-                        name: "demo 公共群聊",
-                        memberUserIds: ["agent-1"],
-                    },
-                    {
-                        id: "inner_group:g-1",
-                        projectId: "demo",
-                        roomType: "inner_group",
-                        scopeRefId: "g-1",
-                        name: "后端小组",
-                        memberUserIds: ["agent-1", "agent-2"],
-                    },
-                ],
-            }),
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = await handleToolCall.call(server, "get_group_rooms", {});
-        assert.deepEqual(result, {
-            groups: [
-                {
-                    id: "project:demo",
-                    projectId: "demo",
-                    roomType: "project",
-                    scopeRefId: "demo",
-                    name: "demo 公共群聊",
-                    memberUserIds: ["agent-1"],
-                },
-                {
-                    id: "inner_group:g-1",
-                    projectId: "demo",
-                    roomType: "inner_group",
-                    scopeRefId: "g-1",
-                    name: "后端小组",
-                    memberUserIds: ["agent-1", "agent-2"],
-                },
-            ],
-        });
-    });
-    it("send_group should forward roomId to agent client", async () => {
-        const server = new McpServer();
-        let capturedArgs = null;
-        Reflect.set(server, "agentClient", {
-            sendGroupMessage: async (content, projectId, roomId) => {
-                capturedArgs = { content, projectId, roomId };
-                return {
-                    msgId: 1,
-                    timestamp: new Date().toISOString(),
-                };
-            },
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        await handleToolCall.call(server, "send_group", {
-            content: "hello room",
-            projectId: "demo",
-            roomId: "inner_group:g-1",
-        });
-        assert.deepEqual(capturedArgs, {
-            content: "hello room",
-            projectId: "demo",
-            roomId: "inner_group:g-1",
-        });
-    });
-    it("hire_colleague should forward role creation payload to agent client", async () => {
-        const server = new McpServer();
-        let capturedArgs = null;
-        const hiredResult = {
-            id: "agent-new",
-            displayName: "后端开发同事-AB12",
-            roleName: "后端开发同事",
-            projectId: "demo",
-            workspacePath: "D:/workspace/demo",
-            runtimeBridgeBaseUrl: "http://127.0.0.1:18081",
-            runtimeStatus: "stopped",
-        };
-        Reflect.set(server, "agentClient", {
-            hireColleague: async (args) => {
-                capturedArgs = args;
-                return hiredResult;
-            },
-            // 「招聘工具」能力开启，通过执行期守卫（默认关闭）
-            getRuntimeFeatures: async () => ({ "agentSys.hire": true }),
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = await handleToolCall.call(server, "hire_colleague", {
-            projectId: "demo",
-            roleName: "后端开发同事",
-            displayName: "后端开发同事-AB12",
-            prompt: "负责后端接口开发",
-            workspacePath: "D:/workspace/demo",
-            runtimeSkillEnabled: true,
-            runtimeMcpEnabled: true,
-        });
-        assert.deepEqual(capturedArgs, {
-            projectId: "demo",
-            roleName: "后端开发同事",
-            displayName: "后端开发同事-AB12",
-            prompt: "负责后端接口开发",
-            workspacePath: "D:/workspace/demo",
-            runtimeSkillEnabled: true,
-            runtimeMcpEnabled: true,
-        });
-        assert.deepEqual(result, hiredResult);
-    });
-    it("hire_colleague should validate required workspacePath", async () => {
-        const server = new McpServer();
-        // 「招聘工具」能力开启，通过执行期守卫（默认关闭）
-        Reflect.set(server, "agentClient", {
-            getRuntimeFeatures: async () => ({ "agentSys.hire": true }),
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        await assert.rejects(async () => {
-            await handleToolCall.call(server, "hire_colleague", {
-                roleName: "后端开发同事",
-            });
-        }, /workspacePath is required/);
-    });
-    it("hire_colleagues_batch should forward batch payload to agent client", async () => {
-        const server = new McpServer();
-        let capturedArgs = null;
-        const batchResult = {
-            batchId: "hire-batch-001",
-            projectId: "demo",
-            summary: {
-                total: 2,
-                approved: 1,
-                rejected: 1,
-                created: 1,
-                failed: 0,
-            },
-            results: [
-                {
-                    itemId: "item-1",
-                    decision: "APPROVED",
-                    status: "CREATED",
-                    createdAgent: {
-                        id: "agent-new",
-                        displayName: "后端开发同事-AB12",
-                        roleName: "后端开发同事",
-                    },
-                },
-                {
-                    itemId: "item-2",
-                    decision: "REJECTED",
-                    status: "REJECTED",
-                    reason: "当前阶段暂不需要",
-                },
-            ],
-        };
-        Reflect.set(server, "agentClient", {
-            hireColleaguesBatch: async (args) => {
-                capturedArgs = args;
-                return batchResult;
-            },
-            // 「招聘工具」能力开启，通过执行期守卫（默认关闭）
-            getRuntimeFeatures: async () => ({ "agentSys.hire": true }),
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = await handleToolCall.call(server, "hire_colleagues_batch", {
-            projectId: "demo",
-            items: [
-                {
-                    roleName: "后端开发同事",
-                    displayName: "后端开发同事-AB12",
-                    prompt: "负责后端接口开发",
-                    workspacePath: "D:/workspace/demo/backend",
-                },
-                {
-                    newRoleName: "测试开发同事",
-                    displayName: "测试开发同事-CD34",
-                    prompt: "负责接口测试",
-                    workspacePath: "D:/workspace/demo/test",
-                },
-            ],
-        });
-        assert.deepEqual(capturedArgs, {
-            projectId: "demo",
-            items: [
-                {
-                    roleName: "后端开发同事",
-                    displayName: "后端开发同事-AB12",
-                    prompt: "负责后端接口开发",
-                    workspacePath: "D:/workspace/demo/backend",
-                },
-                {
-                    newRoleName: "测试开发同事",
-                    displayName: "测试开发同事-CD34",
-                    prompt: "负责接口测试",
-                    workspacePath: "D:/workspace/demo/test",
-                },
-            ],
-        });
-        assert.deepEqual(result, batchResult);
-    });
-    it("hire_colleagues_batch should validate required items", async () => {
-        const server = new McpServer();
-        // 「招聘工具」能力开启，通过执行期守卫（默认关闭）
-        Reflect.set(server, "agentClient", {
-            getRuntimeFeatures: async () => ({ "agentSys.hire": true }),
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        await assert.rejects(async () => {
-            await handleToolCall.call(server, "hire_colleagues_batch", {
-                projectId: "demo",
-                items: [],
-            });
-        }, /items is required/);
-    });
-    it("hire_colleagues_batch should validate every item workspacePath", async () => {
-        const server = new McpServer();
-        // 「招聘工具」能力开启，通过执行期守卫（默认关闭）
-        Reflect.set(server, "agentClient", {
-            getRuntimeFeatures: async () => ({ "agentSys.hire": true }),
-            getStatusReporter: () => null,
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        await assert.rejects(async () => {
-            await handleToolCall.call(server, "hire_colleagues_batch", {
-                projectId: "demo",
-                items: [
-                    {
-                        roleName: "后端开发同事",
-                        workspacePath: "D:/workspace/demo/backend",
-                    },
-                    {
-                        roleName: "测试开发同事",
-                    },
-                ],
-            });
-        }, /items\[1\].workspacePath is required/);
-    });
-});
-describe("McpServer incoming group message filtering", () => {
-    it("should ignore self-sent group messages pushed from websocket events", async () => {
-        const server = new McpServer();
-        Reflect.set(server, "messageBuffer", new MessageBuffer());
-        Reflect.set(server, "agentClient", {
-            getState: () => ({
-                agentId: "agent-self",
-                displayName: "Self Agent",
-                isConnected: true,
-                isRegistered: true,
-            }),
-            getStatusReporter: () => null,
-        });
-        const selfGroupMessage = {
-            msgId: 501,
-            senderId: "agent-self",
-            senderName: "Self Agent",
-            content: "loopback group message",
-            timestamp: new Date().toISOString(),
-            projectId: "demo",
-            roomId: "project:demo",
-        };
-        const handleIncomingMessage = Reflect.get(server, "handleIncomingMessage");
-        await handleIncomingMessage.call(server, selfGroupMessage);
-        const messageBuffer = getMessageBuffer(server);
-        const drained = messageBuffer.get();
-        assert.deepEqual(drained, {
-            directMessages: [],
-            groupMessages: [],
-        });
-    });
-    it("should ignore persisted pipeline task assignment direct messages from websocket events", async () => {
-        const server = new McpServer();
-        Reflect.set(server, "messageBuffer", new MessageBuffer());
-        Reflect.set(server, "agentClient", {
-            getState: () => ({
-                agentId: "agent-loser",
-                displayName: "Loser Agent",
-                isConnected: true,
-                isRegistered: true,
-            }),
-            getStatusReporter: () => null,
-        });
-        const taskAssignedMessage = {
-            msgId: "task-assigned-1",
-            senderId: "MCP-System",
-            senderName: "MCP System",
-            receiverId: "agent-loser",
-            content: "🔔 [系统通知] 您有 1 个新的流程线任务正在等待处理。\n{\"type\":\"pipeline_task_assigned\",\"nodeId\":\"node-1\"}",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const handleIncomingMessage = Reflect.get(server, "handleIncomingMessage");
-        await handleIncomingMessage.call(server, taskAssignedMessage);
-        const messageBuffer = getMessageBuffer(server);
-        const drained = messageBuffer.get();
-        assert.deepEqual(drained, {
-            directMessages: [],
-            groupMessages: [],
-        });
-    });
-});
-describe("McpServer unread direct message filtering", () => {
-    it("should not return persisted pipeline task assignment messages from local buffer", async () => {
-        const taskAssignedMessage = {
-            msgId: "task-assigned-2",
-            senderId: "MCP-System",
-            senderName: "MCP System",
-            receiverId: "agent-loser",
-            content: "🔔 [系统通知] 您有 1 个新的流程线任务正在等待处理。\n{\"type\":\"pipeline_task_assigned\",\"nodeId\":\"node-1\"}",
-            requireReply: false,
-            prompt: "pipeline_task_assigned wake signal",
-            timestamp: new Date().toISOString(),
-        };
-        const normalMessage = {
-            msgId: "normal-1",
-            senderId: "human-1",
-            senderName: "Human",
-            receiverId: "agent-loser",
-            content: "normal direct message",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const server = createServerWithUnread({
-            directMessages: [taskAssignedMessage, normalMessage],
-            groupMessages: [],
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = (await handleToolCall.call(server, "get_message", {}));
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0]?.msgId, "normal-1");
-        assert.equal(result.groupMessages.length, 0);
-    });
-});
-describe("AgentClient group room aggregation", () => {
-    it("fetchUnreadMessages should aggregate unread messages from all discoverable rooms", async () => {
-        const client = new AgentClient();
-        Reflect.set(client, "agentId", "agent-1");
-        Reflect.set(client, "projectId", "demo");
-        const calls = [];
-        Reflect.set(client, "httpClient", {
-            callTool: async (toolName, args) => {
-                calls.push({ toolName, args });
-                if (toolName === "get_dm_messages") {
-                    return { messages: [] };
-                }
-                if (toolName === "discover_group_rooms") {
-                    return {
-                        groups: [
-                            {
-                                id: "project:demo",
-                                projectId: "demo",
-                                roomType: "project",
-                                scopeRefId: "demo",
-                                name: "demo 公共群聊",
-                                memberUserIds: ["agent-1"],
-                            },
-                            {
-                                id: "inner_group:g-1",
-                                projectId: "demo",
-                                roomType: "inner_group",
-                                scopeRefId: "g-1",
-                                name: "后端小组",
-                                memberUserIds: ["agent-1", "agent-2"],
-                            },
-                        ],
-                    };
-                }
-                if (toolName === "get_group_messages") {
-                    if (args.roomId === "project:demo") {
-                        return {
-                            messages: [
-                                {
-                                    msgId: 1,
-                                    senderId: "agent-a",
-                                    senderName: "Agent A",
-                                    projectId: "demo",
-                                    roomId: "project:demo",
-                                    content: "project message",
-                                    timestamp: new Date().toISOString(),
-                                },
-                            ],
-                            currentReadPos: 1,
-                            hasMore: false,
-                        };
-                    }
-                    if (args.roomId === "inner_group:g-1") {
-                        return {
-                            messages: [
-                                {
-                                    msgId: 2,
-                                    senderId: "agent-b",
-                                    senderName: "Agent B",
-                                    projectId: "demo",
-                                    roomId: "inner_group:g-1",
-                                    content: "inner group message",
-                                    timestamp: new Date().toISOString(),
-                                },
-                            ],
-                            currentReadPos: 2,
-                            hasMore: false,
-                        };
-                    }
-                }
-                throw new Error(`unexpected tool call: ${toolName}`);
-            },
-        });
-        const result = await client.fetchUnreadMessages();
-        assert.equal(result.directMessages.length, 0);
-        assert.deepEqual(result.groupMessages.map((message) => ({
-            roomId: message.roomId,
-            content: message.content,
-        })), [
-            { roomId: "project:demo", content: "project message" },
-            { roomId: "inner_group:g-1", content: "inner group message" },
-        ]);
-        assert.equal(calls.filter((call) => call.toolName === "get_group_messages").length, 2);
-    });
-    it("getGroupHistory should aggregate history from all discoverable rooms when roomId is omitted", async () => {
-        const client = new AgentClient();
-        Reflect.set(client, "agentId", "agent-1");
-        Reflect.set(client, "projectId", "demo");
-        Reflect.set(client, "httpClient", {
-            callTool: async (toolName, args) => {
-                if (toolName === "discover_group_rooms") {
-                    return {
-                        groups: [
-                            {
-                                id: "project:demo",
-                                projectId: "demo",
-                                roomType: "project",
-                                scopeRefId: "demo",
-                                name: "demo 公共群聊",
-                                memberUserIds: ["agent-1"],
-                            },
-                            {
-                                id: "inner_group:g-1",
-                                projectId: "demo",
-                                roomType: "inner_group",
-                                scopeRefId: "g-1",
-                                name: "后端小组",
-                                memberUserIds: ["agent-1", "agent-2"],
-                            },
-                        ],
-                    };
-                }
-                if (toolName === "get_group_history") {
-                    if (args.roomId === "project:demo") {
-                        return {
-                            messages: [
-                                {
-                                    msgId: 1,
-                                    senderId: "agent-a",
-                                    senderName: "Agent A",
-                                    projectId: "demo",
-                                    roomId: "project:demo",
-                                    content: "project history",
-                                    timestamp: "2026-03-25T10:00:00.000Z",
-                                },
-                            ],
-                            count: 1,
-                        };
-                    }
-                    if (args.roomId === "inner_group:g-1") {
-                        return {
-                            messages: [
-                                {
-                                    msgId: 2,
-                                    senderId: "agent-b",
-                                    senderName: "Agent B",
-                                    projectId: "demo",
-                                    roomId: "inner_group:g-1",
-                                    content: "group history",
-                                    timestamp: "2026-03-25T11:00:00.000Z",
-                                },
-                            ],
-                            count: 1,
-                        };
-                    }
-                }
-                throw new Error(`unexpected tool call: ${toolName}`);
-            },
-        });
-        const result = await client.getGroupHistory(50);
-        assert.deepEqual(result.messages.map((message) => ({
-            roomId: message.roomId,
-            content: message.content,
-        })), [
-            { roomId: "project:demo", content: "project history" },
-            { roomId: "inner_group:g-1", content: "group history" },
-        ]);
-        assert.equal(result.count, 2);
-    });
-});
-describe("McpServer todo guard on poll_message", () => {
-    // 使用唯一 agentId 避免污染开发者真实 todo 文件；每次测试写入并清理。
-    // ACODE_HOME 指向临时目录：与被测的 resolveAcodeDataHome() 同源，不触碰真实 ~/.acode
-    const testAgentId = `test-todo-reminder-${process.pid}-${Date.now()}`;
-    let savedAcodeHome;
-    let acodeHome = "";
-    let todoDir = "";
-    before(async () => {
-        savedAcodeHome = process.env.ACODE_HOME;
-        acodeHome = await mkdtemp(path.join(os.tmpdir(), "acode-home-"));
-        process.env.ACODE_HOME = acodeHome;
-        todoDir = path.join(acodeHome, "todos");
-    });
-    after(async () => {
-        if (savedAcodeHome === undefined) {
-            delete process.env.ACODE_HOME;
-        }
-        else {
-            process.env.ACODE_HOME = savedAcodeHome;
-        }
-        await rm(acodeHome, { recursive: true, force: true });
-    });
-    const todoPath = () => path.join(todoDir, `${testAgentId}.json`);
-    async function writeTodoFile(todos) {
-        await mkdir(todoDir, { recursive: true });
-        await writeFile(todoPath(), JSON.stringify({
-            agentId: testAgentId,
-            updatedAt: new Date().toISOString(),
-            background: "test background",
-            todos,
-        }), "utf-8");
-    }
-    async function cleanupTodoFile() {
-        try {
-            await rm(todoPath(), { force: true });
-        }
-        catch {
-            // 忽略清理失败
-        }
-    }
-    function createServerForTodo() {
-        return createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            getState: () => ({ agentId: testAgentId }),
-        });
-    }
-    function makeDirectMessage(msgId) {
-        return {
-            msgId,
-            senderId: "agent-wake",
-            senderName: "Wake Agent",
-            content: `wake message ${msgId}`,
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    it("returns todo block message when incomplete todos exist", async () => {
-        await writeTodoFile([
-            { content: "任务A", status: "pending", priority: "high" },
-            { content: "任务B", status: "completed", priority: "low" },
-        ]);
-        try {
-            const server = createServerForTodo();
-            const handleToolCall = getHandleToolCall(server);
-            // 有未完成 todo 时 poll_message 正常 JSON 返回提示消息（非异常）
-            const result = (await handleToolCall.call(server, "poll_message", {}));
-            assert.equal(result.directMessages.length, 1);
-            assert.equal(result.directMessages[0].senderId, "MCP-System");
-            assert.equal(result.directMessages[0].content, "当前有未处理的todo list不能使用poll_message阻塞获取消息");
-        }
-        finally {
-            await cleanupTodoFile();
-        }
-    });
-    it("returns todo block message even with unread messages", async () => {
-        await writeTodoFile([
-            { content: "任务A", status: "pending", priority: "high" },
-        ]);
-        try {
-            const server = createServerForTodo();
-            // 先把消息放入 buffer，模拟已有未读消息
-            const buffer = getMessageBuffer(server);
-            const msg = makeDirectMessage("msg-before-poll");
-            buffer.push(msg);
-            const handleToolCall = getHandleToolCall(server);
-            // todo 前置检查在 hydrate 之前，即使有未读消息也先返回提示
-            const result = (await handleToolCall.call(server, "poll_message", {}));
-            assert.equal(result.directMessages.length, 1);
-            assert.equal(result.directMessages[0].content, "当前有未处理的todo list不能使用poll_message阻塞获取消息");
-        }
-        finally {
-            await cleanupTodoFile();
-        }
-    });
-    it("allows poll_message when all todos are completed", async () => {
-        await writeTodoFile([
-            { content: "任务A", status: "completed", priority: "high" },
-        ]);
-        try {
-            const server = createServerForTodo();
-            const buffer = getMessageBuffer(server);
-            const wake = makeDirectMessage("wake-completed");
-            setTimeout(() => buffer.push(wake), 50);
-            const handleToolCall = getHandleToolCall(server);
-            const result = (await handleToolCall.call(server, "poll_message", {}));
-            // 全完成时无未完成 todo，进入 while 循环等待消息后返回
-            assert.equal(result.directMessages.length, 1);
-            assert.equal(result.directMessages[0].msgId, "wake-completed");
-        }
-        finally {
-            await cleanupTodoFile();
-        }
-    });
-    it("allows poll_message when todo file is absent", async () => {
-        // 确保文件不存在
-        await cleanupTodoFile();
-        const server = createServerForTodo();
-        const buffer = getMessageBuffer(server);
-        const wake = makeDirectMessage("wake-no-file");
-        setTimeout(() => buffer.push(wake), 50);
-        const handleToolCall = getHandleToolCall(server);
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        // 无 todo 文件 -> 进入 while 循环等待消息后返回
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0].msgId, "wake-no-file");
-    });
-    it("returns todo block message when todo has in_progress status", async () => {
-        await writeTodoFile([
-            { content: "任务A", status: "in_progress", priority: "high" },
-        ]);
-        try {
-            const server = createServerForTodo();
-            const handleToolCall = getHandleToolCall(server);
-            const result = (await handleToolCall.call(server, "poll_message", {}));
-            assert.equal(result.directMessages.length, 1);
-            assert.equal(result.directMessages[0].content, "当前有未处理的todo list不能使用poll_message阻塞获取消息");
-        }
-        finally {
-            await cleanupTodoFile();
-        }
-    });
-    it("allows poll_message again after todos are all completed", async () => {
-        await writeTodoFile([
-            { content: "任务A", status: "pending", priority: "high" },
-        ]);
-        try {
-            const server = createServerForTodo();
-            const handleToolCall = getHandleToolCall(server);
-            // 第一次 poll：有未完成项 -> 返回提示消息（正常 JSON）
-            const result1 = (await handleToolCall.call(server, "poll_message", {}));
-            assert.equal(result1.directMessages.length, 1);
-            assert.equal(result1.directMessages[0].content, "当前有未处理的todo list不能使用poll_message阻塞获取消息");
-            // 全部完成后：poll_message 恢复正常阻塞，等消息返回
-            await writeTodoFile([
-                { content: "任务A", status: "completed", priority: "high" },
-            ]);
-            const buffer = getMessageBuffer(server);
-            const wake = makeDirectMessage("wake-after-complete");
-            setTimeout(() => buffer.push(wake), 50);
-            const result = (await handleToolCall.call(server, "poll_message", {}));
-            assert.equal(result.directMessages.length, 1);
-            assert.equal(result.directMessages[0].msgId, "wake-after-complete");
-        }
-        finally {
-            await cleanupTodoFile();
-        }
-    });
-});
-describe("McpServer meeting tools", () => {
-    const MEETING_TOOLS = [
-        "create_meeting",
-        "leave_meeting",
-        "end_meeting",
-        "meeting_speak",
-        "get_meeting_info",
-        "my_meetings",
-    ];
-    it("meeting_* 工具全部经 callAgentScopedTool 转发到服务端执行", async () => {
-        const calls = [];
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            callAgentScopedTool: async (name, args) => {
-                calls.push({ name, args });
-                return { status: "STARTED", meeting: { meetingId: "m-1" } };
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        for (const toolName of MEETING_TOOLS) {
-            const args = toolName === "meeting_speak"
-                ? { meetingId: "m-1", content: "大家好" }
-                : { meetingId: "m-1" };
-            await handleToolCall.call(server, toolName, args);
-        }
-        assert.equal(calls.length, MEETING_TOOLS.length);
-        assert.deepEqual(calls.map((c) => c.name), MEETING_TOOLS);
-        // 参数透传（agentId 由 agent-client 的 callAgentScopedTool 注入）
-        const speakCall = calls.find((c) => c.name === "meeting_speak");
-        assert.deepEqual(speakCall?.args, { meetingId: "m-1", content: "大家好" });
-    });
-    it("poll 结果中的会议通道消息原样交付（不打 _awsServerMessage，不参与 mark_dm_read 确认）", async () => {
-        const meetingMessage = {
-            msgId: "2001",
-            channel: "meeting",
-            meetingId: "m-1",
-            topic: "晨会",
-            senderId: "MEETING-SYSTEM",
-            senderName: "会议系统",
-            content: "会议已到位，共 3 人参会，可开始发言。",
-            isSystem: true,
-            timestamp: new Date().toISOString(),
-        };
-        const server = createServerWithUnread({
-            directMessages: [meetingMessage],
-            groupMessages: [],
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0].channel, "meeting");
-        assert.equal(result.directMessages[0]
-            ._awsServerMessage, undefined, "会议消息不应带服务端确认标记（服务端 read_pos 已推进）");
-    });
-    it("会议邀请 SYSTEM_NOTIFY 唤醒阻塞 poll 后，强制 hydrate 同时取回邀请与自动加入提示", async () => {
-        const autoJoinNotice = {
-            msgId: 42,
-            channel: "meeting",
-            meetingId: "m-9",
-            topic: "评审会",
-            senderId: "MEETING-SYSTEM",
-            senderName: "会议系统",
-            content: "系统已自动为你加入会议「评审会」（会议ID：m-9）。",
-            isSystem: true,
-            timestamp: new Date().toISOString(),
-        };
-        const inviteNotice = {
-            msgId: "invite-9",
-            channel: "meeting_invite",
-            meetingId: "m-9",
-            topic: "评审会",
-            senderId: "MCP-System",
-            senderName: "MCP System",
-            content: "📢 [会议邀请] 你被邀请参加会议「评审会」（会议ID：m-9）。",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        const markedNotifications = [];
-        let fetchCount = 0;
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => {
-                fetchCount += 1;
-                return fetchCount >= 3
-                    ? { directMessages: [inviteNotice, autoJoinNotice], groupMessages: [] }
-                    : { directMessages: [], groupMessages: [] };
-            },
-            markNotificationRead: async (msgIds) => {
-                markedNotifications.push(msgIds);
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        // 模拟服务端在 poll 阻塞期间推送会议邀请系统通知（WS SYSTEM_NOTIFY）
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, { type: "meeting_invite", meetingId: "m-9" });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        if (result === "timeout") {
-            assert.fail("会议邀请唤醒后 poll_message 必须立即返回，不得继续阻塞");
-        }
-        assert.equal(result.directMessages.length, 2);
-        assert.deepEqual(result.directMessages.map((message) => message.channel), ["meeting_invite", "meeting"]);
-        assert.equal(result.directMessages[0].msgId, "invite-9");
-        assert.equal(result.directMessages[1].msgId, 42);
-        assert.deepEqual(markedNotifications, [["invite-9"]]);
-    });
-    it("SYSTEM_NOTIFY 携带完整会议邀请（直接指名）时仅作唤醒信号：不入本地缓冲，由强制 hydrate 取回服务端抢占结果", async () => {
-        let fetchCount = 0;
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => {
-                fetchCount += 1;
-                // 第 1 次 = 入口 hydrate；第 2 次 = 邀请唤醒的强制 hydrate。
-                // 模拟服务端 poll：抢占式入会返回自动加入提示，未读邀请通知随白名单一并交付
-                return fetchCount >= 2
-                    ? {
-                        directMessages: [
-                            {
-                                msgId: "invite-direct-1",
-                                channel: "meeting_invite",
-                                senderId: "MCP-System",
-                                content: "📢 [会议邀请] 你被邀请参加会议「晨会」。",
-                                requireReply: false,
-                                timestamp: new Date().toISOString(),
-                            },
-                            {
-                                msgId: "auto-join-1",
-                                channel: "meeting",
-                                meetingId: "meeting-direct-1",
-                                senderId: "MCP-System",
-                                content: "系统已自动为你加入会议「晨会」。",
-                                isSystem: true,
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                        groupMessages: [],
-                    }
-                    : { directMessages: [], groupMessages: [] };
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, {
-            id: "invite-direct-1",
-            type: "meeting_invite",
-            senderId: "MCP-System",
-            senderName: "MCP System",
-            content: "📢 [会议邀请] 你被邀请参加会议「晨会」（会议ID：meeting-direct-1）。",
-            timestamp: new Date().toISOString(),
-            payload: JSON.stringify({ meetingId: "meeting-direct-1" }),
-        });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        assert.notEqual(result, "timeout");
-        if (result === "timeout")
-            return;
-        // 携带 id 的直接指名邀请同样不入 WS 缓冲：内容全部来自强制 hydrate 的服务端结果
-        assert.equal(result.directMessages.length, 2);
-        assert.equal(result.directMessages[0].msgId, "invite-direct-1");
-        assert.equal(result.directMessages[1].msgId, "auto-join-1");
-        assert.ok(fetchCount >= 2);
-    });
-    it("竞争性会议邀请(角色席位 competitive=true)仅作唤醒信号：不入本地缓冲，交付服务端抢占后的自动加入提示", async () => {
-        let fetchCount = 0;
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => {
-                fetchCount += 1;
-                // 第 1 次 = 入口 hydrate（无内容）；第 2 次 = 会议邀请强制 hydrate，
-                // 模拟服务端抢占式入会成功后返回"已自动加入会议"系统提示
-                return fetchCount >= 2
-                    ? {
-                        directMessages: [
-                            {
-                                msgId: "auto-join-1",
-                                channel: "meeting",
-                                meetingId: "meeting-comp-1",
-                                senderId: "MCP-System",
-                                content: "系统已自动为你加入会议「晨会」（会议ID：meeting-comp-1）。",
-                                requireReply: false,
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                        groupMessages: [],
-                    }
-                    : { directMessages: [], groupMessages: [] };
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, {
-            id: "invite-comp-1",
-            type: "meeting_invite",
-            senderId: "MCP-System",
-            senderName: "MCP System",
-            content: "📢 [会议邀请] 角色「共享角色」被邀请参加会议「晨会」。",
-            timestamp: new Date().toISOString(),
-            payload: JSON.stringify({ meetingId: "meeting-comp-1", roleId: "role-shared", competitive: true }),
-        });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        assert.notEqual(result, "timeout", "竞争性邀请应立即唤醒 poll 并经强制 hydrate 返回抢占结果");
-        if (result === "timeout")
-            return;
-        // 邀请文本本身不进本地缓冲；交付的是服务端抢占入会后的自动加入提示
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0].msgId, "auto-join-1");
-        assert.ok(fetchCount >= 2, "应触发会议邀请强制 hydrate 完成服务端抢占");
-    });
-    it("会议消息(channel=meeting)交付前经 mark_meeting_read 确认推进服务端游标", async () => {
-        let fetchCount = 0;
-        const confirmedIds = [];
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => {
-                fetchCount += 1;
-                return fetchCount >= 2
-                    ? {
-                        directMessages: [
-                            {
-                                msgId: "auto-join-confirm-1",
-                                channel: "meeting",
-                                meetingId: "meeting-confirm-1",
-                                senderId: "MCP-System",
-                                content: "系统已自动为你加入会议「晨会」。",
-                                isSystem: true,
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                        groupMessages: [],
-                    }
-                    : { directMessages: [], groupMessages: [] };
-            },
-            markMeetingRead: async (msgIds) => {
-                confirmedIds.push(...msgIds);
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, { type: "meeting_invite", meetingId: "meeting-confirm-1" });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        assert.notEqual(result, "timeout");
-        if (result === "timeout")
-            return;
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0].msgId, "auto-join-confirm-1");
-        // 服务端 peek 不推进 read_pos：交付成功必须经 mark_meeting_read 确认，
-        // 否则客户端超时丢响应后「已自动加入/会议开始」永久丢失、poll_message 永不返回
-        assert.deepEqual(confirmedIds, ["auto-join-confirm-1"]);
-    });
-    it("mark_meeting_read 确认失败时降级交付：会议消息不因确认异常丢失", async () => {
-        let fetchCount = 0;
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => {
-                fetchCount += 1;
-                return fetchCount >= 2
-                    ? {
-                        directMessages: [
-                            {
-                                msgId: "auto-join-degrade-1",
-                                channel: "meeting",
-                                meetingId: "meeting-degrade-1",
-                                senderId: "MCP-System",
-                                content: "系统已自动为你加入会议「晨会」。",
-                                isSystem: true,
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                        groupMessages: [],
-                    }
-                    : { directMessages: [], groupMessages: [] };
-            },
-            markMeetingRead: async () => {
-                throw new Error("mark_meeting_read 服务端暂不可用");
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, { type: "meeting_invite", meetingId: "meeting-degrade-1" });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        assert.notEqual(result, "timeout", "确认失败必须降级为直接交付，poll 不能死等");
-        if (result === "timeout")
-            return;
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0].msgId, "auto-join-degrade-1");
-    });
-    it("服务端 peek 重投同一会议消息时本地去重拦截，不二次交付给 LLM", async () => {
-        const meetingMessage = {
-            msgId: "auto-join-redeliver-1",
-            channel: "meeting",
-            meetingId: "meeting-redeliver-1",
-            senderId: "MCP-System",
-            content: "系统已自动为你加入会议「晨会」。",
-            isSystem: true,
-            timestamp: new Date().toISOString(),
-        };
-        let fetchCount = 0;
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            // 服务端为 peek 语义：客户端确认前（或确认丢失时）每次 hydrate 都重投同一条
-            fetchUnreadMessages: async () => {
-                fetchCount += 1;
-                return fetchCount >= 2
-                    ? { directMessages: [meetingMessage], groupMessages: [] }
-                    : { directMessages: [], groupMessages: [] };
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, { type: "meeting_invite", meetingId: "meeting-redeliver-1" });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        assert.notEqual(result, "timeout");
-        if (result === "timeout")
-            return;
-        // 强制 hydrate 循环内同一消息可能被 peek 多次重投，交付结果必须只含一条
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0].msgId, "auto-join-redeliver-1");
-    });
-    it("会议邀请唤醒的强制 hydrate 携带 preemptiveJoinWaitMs 预算与覆盖服务端等待的请求超时", async () => {
-        const fetchOptions = [];
-        let fetchCount = 0;
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async (options) => {
-                fetchOptions.push(options);
-                fetchCount += 1;
-                return fetchCount >= 2
-                    ? {
-                        directMessages: [
-                            {
-                                msgId: "auto-join-wait-1",
-                                channel: "meeting",
-                                meetingId: "meeting-wait-9",
-                                senderId: "MCP-System",
-                                content: "系统已自动为你加入会议「晨会」（会议ID：meeting-wait-9）。",
-                                isSystem: true,
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                        groupMessages: [],
-                    }
-                    : { directMessages: [], groupMessages: [] };
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, { type: "meeting_invite", meetingId: "meeting-wait-9" });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        assert.notEqual(result, "timeout");
-        if (result === "timeout")
-            return;
-        assert.ok(fetchOptions.length >= 2, "入口 hydrate + 强制 hydrate 均应发生");
-        // 入口 hydrate 显式传 0（"立即加入但不阻塞等待"）：省略会让服务端回退默认阻塞预算，
-        // 与入口的短客户端超时错配；等待全员到位由强制 hydrate 的预算完成
-        assert.equal(fetchOptions[0]?.preemptiveJoinWaitMs, 0);
-        assert.notEqual(fetchOptions[0]?.propagatePollTimeout, true);
-        // 强制 hydrate 携带完整等待预算，单请求超时必须覆盖服务端等待预算，
-        // 否则合法长请求被误判超时
-        assert.equal(fetchOptions[1]?.preemptiveJoinWaitMs, 45_000);
-        assert.equal(fetchOptions[1]?.pollMessageTimeoutMs, 65_000);
-        assert.equal(fetchOptions[1]?.skipGroupMessages, true);
-        assert.equal(fetchOptions[1]?.propagatePollTimeout, true);
-        assert.equal(result.directMessages[0].msgId, "auto-join-wait-1");
-    });
-    it("会议邀请强制 hydrate 客户端超时：不立即连发重试，稍后经自愈重挂继续抢占", async () => {
-        const fetchTimestamps = [];
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async (options) => {
-                fetchTimestamps.push(Date.now());
-                const call = fetchTimestamps.length;
-                // 第 1 次 = 入口 hydrate；第 2 次 = 强制 hydrate，模拟客户端硬超时
-                if (call === 2 && options?.propagatePollTimeout === true) {
-                    throw new PollLongPollTimeoutError("MCP tool poll_message timed out after 65000ms");
-                }
-                // 自愈重挂后的强制 hydrate 仍返回空，第 2 次重试交付自动加入提示，
-                // 使 pending poll 自然结束（不遗留活跃定时器阻塞测试进程退出）
-                if (call >= 4) {
-                    return {
-                        directMessages: [
-                            {
-                                msgId: "auto-join-rearm-1",
-                                channel: "meeting",
-                                meetingId: "meeting-timeout-1",
-                                senderId: "MCP-System",
-                                content: "系统已自动为你加入会议「晨会」（会议ID：meeting-timeout-1）。",
-                                isSystem: true,
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                        groupMessages: [],
-                    };
-                }
-                return { directMessages: [], groupMessages: [] };
-            },
-        });
-        // 注入短自愈重挂延迟（默认 10s，测试无法等待）
-        Reflect.set(server, "meetingHydrateTimeoutRearmDelayMs", 50);
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, { type: "meeting_invite", meetingId: "meeting-timeout-1" });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 3000)),
-        ]));
-        assert.notEqual(result, "timeout", "自愈重挂后应继续强制 hydrate 并交付抢占结果");
-        if (result === "timeout")
-            return;
-        assert.ok(fetchTimestamps.length >= 3, "超时后应经自愈重挂再次发起强制 hydrate");
-        // 关键断言：超时后没有 150ms 间隔的立即重试——第 3 次请求必须等自愈重挂延迟
-        assert.ok(fetchTimestamps[2] - fetchTimestamps[1] >= 45, "客户端超时后不应立即重试（服务端可能仍在执行上一请求），应等待自愈重挂延迟");
-        assert.equal(result.directMessages[0].msgId, "auto-join-rearm-1");
-    });
-    it("meeting_creator_prompt 系统通知同样唤醒受阻 poll：全员聆听时创建者请发言提醒即时送达", async () => {
-        let fetchCount = 0;
-        const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-            fetchUnreadMessages: async () => {
-                fetchCount += 1;
-                // 第 1 次 = 入口 hydrate（无内容）；第 2 次 = 创建者提醒唤醒的强制 hydrate，
-                // 会议模式白名单取回 meeting_creator_prompt 定向提醒
-                return fetchCount >= 2
-                    ? {
-                        directMessages: [
-                            {
-                                msgId: "creator-prompt-1",
-                                channel: "notification",
-                                senderId: "MCP-System",
-                                content: "🔔 [会议提醒] 「晨会」当前没有人发言，你作为会议创建者，请你进行会议发言。",
-                                requireReply: false,
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                        groupMessages: [],
-                    }
-                    : { directMessages: [], groupMessages: [] };
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const pending = handleToolCall.call(server, "poll_message", {});
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        const handleSystemNotify = Reflect.get(server, "handleSystemNotify");
-        handleSystemNotify.call(server, {
-            id: "creator-prompt-1",
-            type: "meeting_creator_prompt",
-            senderId: "MCP-System",
-            senderName: "MCP System",
-            content: "🔔 [会议提醒] 「晨会」当前没有人发言，你作为会议创建者，请你进行会议发言。",
-            timestamp: new Date().toISOString(),
-            payload: JSON.stringify({ meetingId: "meeting-silent-1", role: "creator" }),
-        });
-        const result = (await Promise.race([
-            pending,
-            new Promise((resolve) => setTimeout(() => resolve("timeout"), 2000)),
-        ]));
-        assert.notEqual(result, "timeout", "创建者提醒应立即唤醒 poll 而非等 30s hydrate 周期");
-        if (result === "timeout")
-            return;
-        assert.ok(fetchCount >= 2);
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0].msgId, "creator-prompt-1");
-        assert.ok(String(result.directMessages[0].content).includes("请你进行会议发言"));
-    });
-    it("meeting_invite 通知 DM 不打 _awsServerMessage，确认查不到 t_direct_message 行也不被丢弃", async () => {
-        const inviteNotice = {
-            msgId: "notif-uuid-001",
-            channel: "meeting_invite",
-            meetingId: "m-9",
-            topic: "评审会",
-            senderId: "MCP-System",
-            senderName: "系统",
-            content: "📢 [会议邀请] 你被邀请参加会议「评审会」（会议ID：m-9）。",
-            requireReply: false,
-            timestamp: new Date().toISOString(),
-        };
-        // markDmRead 模拟服务端真实行为：通知 UUID 不在 t_direct_message，返回空集合。
-        // 若消息被误打 _awsServerMessage 标记，confirmServerMessages 会将其当作"已撤回"丢弃，
-        // 同时服务端通知已"取即已读" → 邀请永久丢失，poll_message 永远等不到。
-        let markDmReadCalled = false;
-        const server = createServerWithUnread({ directMessages: [inviteNotice], groupMessages: [] }, {
-            markDmRead: async () => {
-                markDmReadCalled = true;
-                return new Set();
-            },
-        });
-        const handleToolCall = Reflect.get(server, "handleToolCall");
-        const result = (await handleToolCall.call(server, "poll_message", {}));
-        // 入口 hydrate 拉到的 meeting_invite 通知必须交付（即使 mark_dm_read 确认不到）
-        assert.equal(result.directMessages.length, 1);
-        assert.equal(result.directMessages[0].channel, "meeting_invite");
-        assert.equal(result.directMessages[0].msgId, "notif-uuid-001");
-        assert.equal(result.directMessages[0]
-            ._awsServerMessage, undefined, "meeting_invite 通知 DM 不应带服务端确认标记（UUID 不在 t_direct_message，确认必失败）");
-        assert.equal(markDmReadCalled, false, "meeting_invite 通知 DM 不应触发 mark_dm_read 确认（不在 t_direct_message）");
-    });
-});