aws-runtime-bridge 1.9.124 → 1.9.126

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

@@ -2,8 +2,8 @@ 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 { describe, it } from "node:test";
-import { AgentClient } from "./agent-client.js";
+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";
@@ -21,6 +21,10 @@ function createServerWithUnread(unreadMessages, overrides = {}) {
             isRegistered: true,
         }),
         fetchUnreadMessages: async () => unreadMessages,
+        markMeetingRead: async () => { },
+        callAgentScopedTool: async () => {
+            throw new Error("unexpected callAgentScopedTool in test stub");
+        },
         ...overrides,
     };
     Reflect.set(server, "agentClient", agentClientStub);
@@ -194,6 +198,65 @@ describe("McpServer unread backlog hydration", () => {
         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",
@@ -1635,6 +1698,8 @@ describe("McpServer group discovery tool", () => {
                 capturedArgs = args;
                 return hiredResult;
             },
+            // 「招聘工具」能力开启，通过执行期守卫（默认关闭）
+            getRuntimeFeatures: async () => ({ "agentSys.hire": true }),
             getStatusReporter: () => null,
         });
         const handleToolCall = Reflect.get(server, "handleToolCall");
@@ -1660,6 +1725,11 @@ describe("McpServer group discovery tool", () => {
     });
     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", {
@@ -1704,6 +1774,8 @@ describe("McpServer group discovery tool", () => {
                 capturedArgs = args;
                 return batchResult;
             },
+            // 「招聘工具」能力开启，通过执行期守卫（默认关闭）
+            getRuntimeFeatures: async () => ({ "agentSys.hire": true }),
             getStatusReporter: () => null,
         });
         const handleToolCall = Reflect.get(server, "handleToolCall");
@@ -1745,6 +1817,11 @@ describe("McpServer group discovery tool", () => {
     });
     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", {
@@ -1755,6 +1832,11 @@ describe("McpServer group discovery tool", () => {
     });
     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", {
@@ -2027,13 +2109,31 @@ describe("AgentClient group room aggregation", () => {
     });
 });
 describe("McpServer todo guard on poll_message", () => {
-    // 使用唯一 agentId 避免污染开发者真实 todo 文件；每次测试写入并清理
+    // 使用唯一 agentId 避免污染开发者真实 todo 文件；每次测试写入并清理。
+    // ACODE_HOME 指向临时目录：与被测的 resolveAcodeDataHome() 同源，不触碰真实 ~/.acode
     const testAgentId = `test-todo-reminder-${process.pid}-${Date.now()}`;
-    const todoDir = path.join(os.homedir(), ".acode", "todos");
-    const todoPath = path.join(todoDir, `${testAgentId}.json`);
+    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({
+        await writeFile(todoPath(), JSON.stringify({
             agentId: testAgentId,
             updatedAt: new Date().toISOString(),
             background: "test background",
@@ -2042,7 +2142,7 @@ describe("McpServer todo guard on poll_message", () => {
     }
     async function cleanupTodoFile() {
         try {
-            await rm(todoPath, { force: true });
+            await rm(todoPath(), { force: true });
         }
         catch {
             // 忽略清理失败
@@ -2175,3 +2275,524 @@ describe("McpServer todo guard on poll_message", () => {
         }
     });
 });
+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）");
+    });
+});