aws-runtime-bridge 1.9.32 → 1.9.40

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

@@ -1,12 +1,12 @@
 import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+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 { McpServer } from "./mcp-server.js";
 import { MCP_TOOLS } from "./mcp-tools.js";
-import { MemoryCapacityError, MemoryStore, } from "./memory-store.js";
+import { MemoryStore, } from "./memory-store.js";
 import { MessageBuffer } from "./message-buffer.js";
 function createServerWithUnread(unreadMessages, overrides = {}) {
     const server = new McpServer();
@@ -150,52 +150,40 @@ describe("McpServer unread backlog hydration", () => {
         });
     });
     it("poll_message should keep blocking through empty polls until messages arrive", async () => {
-        const previousBlockWait = process.env.AWS_POLL_MESSAGE_BLOCK_WAIT_MS;
-        process.env.AWS_POLL_MESSAGE_BLOCK_WAIT_MS = "20";
-        try {
-            const directMessage = {
-                msgId: "dm-delayed-1",
-                senderId: "agent-delayed",
-                senderName: "Agent Delayed",
-                content: "delayed dm",
-                requireReply: false,
-                timestamp: new Date().toISOString(),
-            };
-            const fetchOptions = [];
-            let fetchCount = 0;
-            const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
-                fetchUnreadMessages: async (options) => {
-                    fetchOptions.push(options ?? {});
-                    fetchCount += 1;
-                    if (fetchCount <= 1) {
-                        return { directMessages: [], groupMessages: [] };
-                    }
-                    return { directMessages: [directMessage], groupMessages: [] };
-                },
-            });
-            const handleToolCall = getHandleToolCall(server);
-            const result = await handleToolCall.call(server, "poll_message", {});
-            assert.deepEqual(result, {
-                directMessages: [directMessage],
-                groupMessages: [],
-                fromBuffer: true,
-                systemMessages: [],
-            });
-            assert.equal(fetchOptions.length, 2);
-            assert.equal(fetchOptions[0].blockIfEmpty, false);
-            assert.equal(fetchOptions[0].includePipelineTasks, false);
-            assert.equal(fetchOptions[1].blockIfEmpty, true);
-            assert.ok(typeof fetchOptions[1].blockTimeoutMs === "number");
-            assert.equal(fetchOptions[1].blockTimeoutMs, 20);
-        }
-        finally {
-            if (previousBlockWait === undefined) {
-                delete process.env.AWS_POLL_MESSAGE_BLOCK_WAIT_MS;
-            }
-            else {
-                process.env.AWS_POLL_MESSAGE_BLOCK_WAIT_MS = previousBlockWait;
-            }
-        }
+        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 = Reflect.get(server, "messageBuffer");
+        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, false);
     });
     it("poll_message should handle hydration error gracefully and receive WebSocket messages", async () => {
         const directMessage = {
@@ -210,10 +198,7 @@ describe("McpServer unread backlog hydration", () => {
         const server = createServerWithUnread({ directMessages: [], groupMessages: [] }, {
             fetchUnreadMessages: async () => {
                 fetchCount += 1;
-                if (fetchCount === 2) {
-                    throw new Error("MCP tool poll_message timed out after 120000ms");
-                }
-                return { directMessages: [], groupMessages: [] };
+                throw new Error("MCP tool poll_message timed out after 120000ms");
             },
         });
         // Simulate WebSocket message arriving after hydration fails
@@ -229,7 +214,10 @@ describe("McpServer unread backlog hydration", () => {
             fromBuffer: true,
             systemMessages: [],
         });
-        assert.equal(fetchCount, 2);
+        // 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 = {
@@ -519,54 +507,13 @@ describe("McpServer unread backlog hydration", () => {
         }, 50);
         const handleToolCall = getHandleToolCall(server);
         const result = (await handleToolCall.call(server, "poll_message", {}));
-        assert.equal(fetchCalls, 2);
+        // 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 clamp block wait below HTTP request timeout", async () => {
-        const previousBlockWait = process.env.AWS_POLL_MESSAGE_BLOCK_WAIT_MS;
-        process.env.AWS_POLL_MESSAGE_BLOCK_WAIT_MS = "120000";
-        try {
-            const delayedMessage = {
-                msgId: "dm-after-clamped-poll",
-                senderId: "agent-later",
-                senderName: "Later Agent",
-                receiverId: "agent-self",
-                content: "arrived after clamped backend poll",
-                requireReply: false,
-                timestamp: new Date().toISOString(),
-            };
-            const fetchOptions = [];
-            const server = createServerWithUnread({
-                directMessages: [],
-                groupMessages: [],
-            }, {
-                fetchUnreadMessages: async (options) => {
-                    fetchOptions.push(options ?? {});
-                    return fetchOptions.length === 1
-                        ? { directMessages: [], groupMessages: [] }
-                        : fetchOptions.length === 2
-                            ? { directMessages: [delayedMessage], groupMessages: [] }
-                            : { directMessages: [], groupMessages: [] };
-                },
-            });
-            const handleToolCall = getHandleToolCall(server);
-            const result = (await handleToolCall.call(server, "poll_message", {}));
-            assert.deepEqual(result.directMessages, [delayedMessage]);
-            assert.equal(fetchOptions[0].blockIfEmpty, false);
-            assert.equal(fetchOptions[1].blockIfEmpty, true);
-            assert.equal(fetchOptions[1].blockTimeoutMs, 120000);
-        }
-        finally {
-            if (previousBlockWait === undefined) {
-                delete process.env.AWS_POLL_MESSAGE_BLOCK_WAIT_MS;
-            }
-            else {
-                process.env.AWS_POLL_MESSAGE_BLOCK_WAIT_MS = previousBlockWait;
-            }
-        }
-    });
     it("poll_message should restore waiting status when task notification is returned", async () => {
         const statusEvents = [];
         const server = createServerWithUnread({
@@ -768,7 +715,6 @@ describe("McpServer memory tools", () => {
         assert.ok(toolNames.includes("search_memory"));
         assert.ok(toolNames.includes("list_memories"));
         assert.ok(toolNames.includes("get_memory_stats"));
-        assert.ok(toolNames.includes("archive_recently_memory"));
         // Memory 近期记忆过期与回忆工具 (v1.11.0)
         assert.ok(toolNames.includes("memory_recurrence"));
         assert.ok(toolNames.includes("memory_recurrence_complete"));
@@ -777,7 +723,7 @@ describe("McpServer memory tools", () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             const created = await handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "Core://Agent/Profile/",
                 content: "prefers concise backend summaries",
             });
@@ -785,12 +731,12 @@ describe("McpServer memory tools", () => {
             assert.equal(created.content, undefined);
             const read = await handleToolCall.call(server, "read_memory", {
                 uri: "core://Agent/Profile",
-                memory_type: "memory",
+                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: "memory",
+                memory_type: "project_memory",
                 old_string: "concise",
                 new_string: "structured",
                 append: "\nuses MCP memory tools",
@@ -799,7 +745,7 @@ describe("McpServer memory tools", () => {
             assert.equal(updated.version, 2);
             const readUpdated = await handleToolCall.call(server, "read_memory", {
                 uri: "core://Agent/Profile",
-                memory_type: "memory",
+                memory_type: "project_memory",
             });
             assert.match(readUpdated.content, /structured backend/);
             assert.match(readUpdated.content, /MCP memory tools/);
@@ -810,7 +756,7 @@ describe("McpServer memory tools", () => {
             assert.equal(searchResult.results.length, 1);
             const deleted = await handleToolCall.call(server, "delete_memory", {
                 uri: "core://Agent/Profile",
-                memory_type: "memory",
+                memory_type: "project_memory",
             });
             assert.deepEqual(deleted, { deleted: true });
         });
@@ -819,25 +765,25 @@ describe("McpServer memory tools", () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "task_list",
+                memory_type: "recently_memory",
                 uri: "task://todo/current",
                 content: "finish memory endpoint tests",
             });
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_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: "task_list",
+                memory_type: "recently_memory",
             });
             assert.equal(taskList.length, 1);
             const recentList = await handleToolCall.call(server, "list_memories", {
-                memory_type: "recently_memory",
+                memory_type: "agent_memory",
             });
             assert.equal(recentList.length, 1);
             await assert.rejects(() => handleToolCall.call(server, "list_memories", {
-                memory_type: "memory",
+                memory_type: "project_memory",
             }), /Invalid memory_type/);
         });
     });
@@ -846,76 +792,42 @@ describe("McpServer memory tools", () => {
             const firstHandleToolCall = getHandleToolCall(firstServer);
             const secondHandleToolCall = getHandleToolCall(secondServer);
             await firstHandleToolCall.call(firstServer, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://role/shared-profile",
                 content: "shared role knowledge",
             });
             await firstHandleToolCall.call(firstServer, "create_memory", {
-                memory_type: "recently_memory",
+                memory_type: "agent_memory",
                 uri: "recent://instance/private-context",
                 content: "agent one private context",
             });
             const roleMemory = await secondHandleToolCall.call(secondServer, "read_memory", {
                 uri: "core://role/shared-profile",
-                memory_type: "memory",
+                memory_type: "project_memory",
             });
             const recentMemory = await secondHandleToolCall.call(secondServer, "read_memory", {
                 uri: "recent://instance/private-context",
-                memory_type: "recently_memory",
+                memory_type: "agent_memory",
             });
             assert.equal(roleMemory.content, "shared role knowledge");
             assert.equal(recentMemory, null);
         });
     });
-    it("supports task-list removal and recent-memory archive semantics", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "task_list",
-                uri: "task://todo/remove-me",
-                content: "temporary task",
-            });
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
-                uri: "recent://note/archive-me",
-                content: "hot context",
-            });
-            const deleted = await handleToolCall.call(server, "delete_memory", {
-                uri: "task://todo/remove-me",
-                memory_type: "task_list",
-            });
-            assert.deepEqual(deleted, { deleted: true });
-            const archived = await handleToolCall.call(server, "archive_recently_memory", {
-                uri: "recent://note/archive-me",
-            });
-            assert.equal(archived.memory_type, "memory");
-            const archivedInRoleScope = await handleToolCall.call(server, "read_memory", {
-                uri: "recent://note/archive-me",
-                memory_type: "memory",
-            });
-            const removedFromInstanceScope = await handleToolCall.call(server, "read_memory", {
-                uri: "recent://note/archive-me",
-                memory_type: "recently_memory",
-            });
-            assert.equal(archivedInRoleScope.content, "hot context");
-            assert.equal(removedFromInstanceScope, null);
-        });
-    });
     it("returns memory stats through MCP dispatch", async () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "task_list",
+                memory_type: "recently_memory",
                 uri: "task://todo/stats",
                 content: "temporary task",
             });
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
+                memory_type: "agent_memory",
                 uri: "recent://note/stats",
                 content: "hot context",
             });
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/profile",
                 content: "long-term profile",
             });
@@ -929,15 +841,15 @@ describe("McpServer memory tools", () => {
                 exceeded: false,
                 hardExceeded: false,
             });
-            assert.equal(typedStats.by_type.task_list.count, 1);
-            assert.equal(typedStats.by_type.task_list.domainCount, 1);
-            assert.equal(typedStats.by_type.task_list.by_domain.task?.count, 1);
             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.recent?.count, 1);
-            assert.equal(typedStats.by_type.memory.count, 1);
-            assert.equal(typedStats.by_type.memory.domainCount, 1);
-            assert.equal(typedStats.by_type.memory.by_domain.core?.count, 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 () => {
@@ -946,32 +858,13 @@ describe("McpServer memory tools", () => {
             const reportedStats = [];
             attachMemoryStatsReporter(server, reportedStats);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "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.memory.count, 1);
-            assert.equal(reportedStats[0]?.by_type.memory.by_domain.project?.count, 1);
-        });
-    });
-    it("reports combined memory stats after archiving recent memory", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            const reportedStats = [];
-            attachMemoryStatsReporter(server, reportedStats);
-            await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
-                uri: "project://test-aws/hot-note",
-                content: "hot note that will become permanent",
-            });
-            await handleToolCall.call(server, "archive_recently_memory", {
-                uri: "project://test-aws/hot-note",
-            });
-            const latestStats = reportedStats.at(-1);
-            assert.equal(latestStats?.by_type.recently_memory.count, 0);
-            assert.equal(latestStats?.by_type.memory.count, 1);
-            assert.equal(latestStats?.by_type.memory.by_domain.project?.count, 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 () => {
@@ -979,7 +872,7 @@ describe("McpServer memory tools", () => {
             const reportedStats = [];
             const roleMemoryStore = Reflect.get(server, "roleMemoryStore");
             await roleMemoryStore.createMemory({
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "project://test-aws/existing-permanent-memory",
                 content: "existing role memory should be visible on dashboard startup",
             });
@@ -999,75 +892,55 @@ describe("McpServer memory tools", () => {
             const autoRegister = Reflect.get(server, "autoRegister");
             await autoRegister.call(server);
             assert.equal(reportedStats.length, 1);
-            assert.equal(reportedStats[0]?.by_type.memory.count, 1);
-            assert.equal(reportedStats[0]?.by_type.memory.by_domain.project?.count, 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: "task_list",
+                memory_type: "recently_memory",
                 uri: "task://todo/stats",
                 content: "temporary task",
             });
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "recently_memory",
+                memory_type: "agent_memory",
                 uri: "recent://note/stats",
                 content: "hot context",
             });
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/profile",
                 content: "long-term profile",
             });
             const stats = (await handleToolCall.call(server, "get_memory_stats", {
-                memory_type: "recently_memory",
+                memory_type: "agent_memory",
             }));
-            assert.equal(stats.memory_type, "recently_memory");
+            assert.equal(stats.memory_type, "agent_memory");
             assert.equal(stats.total, 1);
-            assert.deepEqual(Object.keys(stats.by_type), ["recently_memory"]);
-            assert.equal(stats.by_type.recently_memory?.domainCount, 1);
-            assert.equal(stats.by_type.recently_memory?.by_domain.recent?.count, 1);
-            const memoryStats = (await handleToolCall.call(server, "get_memory_stats", { memory_type: "memory" }));
-            assert.equal(memoryStats.memory_type, "memory");
+            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), ["memory"]);
-            assert.equal(memoryStats.by_type.memory?.domainCount, 1);
-            assert.equal(memoryStats.by_type.memory?.by_domain.core?.count, 1);
-        });
-    });
-    it("keeps structured details on memory capacity errors", async () => {
-        await withMemoryServer(async (server) => {
-            const handleToolCall = getHandleToolCall(server);
-            for (let index = 0; index < 64; index += 1) {
-                await handleToolCall.call(server, "create_memory", {
-                    memory_type: "recently_memory",
-                    uri: `recent://capacity/${index}`,
-                    content: `recent ${index}`,
-                });
-            }
-            await assert.rejects(async () => {
-                await handleToolCall.call(server, "create_memory", {
-                    memory_type: "recently_memory",
-                    uri: "recent://capacity/overflow",
-                    content: "overflow",
-                });
-            }, (error) => {
-                assert.ok(error instanceof MemoryCapacityError);
-                assert.equal(error.details.code, "MEMORY_TYPE_LIMIT_REACHED");
-                assert.equal(error.details.memory_type, "recently_memory");
-                assert.equal(error.details.domain, "recent");
-                assert.equal(error.details.current, 64);
-                assert.equal(error.details.limit, 64);
-                assert.ok(error.details.recommended_actions.includes("archive_recently_memory({ uri })"));
-                return true;
-            });
+            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 injects a cleanup notice when listable memory exceeds soft limits", async () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
+            const directMessage = {
+                msgId: "dm-trigger-cleanup",
+                senderId: "agent-trigger",
+                senderName: "Trigger Agent",
+                content: "trigger cleanup notice",
+                requireReply: false,
+                timestamp: new Date().toISOString(),
+            };
             Reflect.set(server, "agentClient", {
                 fetchUnreadMessages: async () => ({
                     directMessages: [],
@@ -1078,21 +951,29 @@ describe("McpServer memory tools", () => {
             });
             for (let index = 0; index < 33; index += 1) {
                 await handleToolCall.call(server, "create_memory", {
-                    memory_type: "recently_memory",
+                    memory_type: "agent_memory",
                     uri: `recent://cleanup/${index}`,
                     content: `recent ${index}`,
                 });
             }
+            // poll_message blocks until a real message arrives; cleanup notice is prepended.
+            const buffer = Reflect.get(server, "messageBuffer");
+            setTimeout(() => {
+                buffer.push(directMessage);
+            }, 50);
             const result = (await handleToolCall.call(server, "poll_message", {}));
             assert.equal(result.groupMessages.length, 0);
-            assert.equal(result.directMessages.length, 1);
+            // cleanup notice prepended before the real message
+            assert.equal(result.directMessages.length, 2);
             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 ?? "", /recently_memory\/recent 类型下当前 33 条 memory/);
+            assert.match(result.directMessages[0]?.content ?? "", /agent_memory\/recent 类型下当前 33 条 memory/);
             assert.match(result.directMessages[0]?.content ?? "", /get_memory_stats/);
             assert.match(result.directMessages[0]?.prompt ?? "", /无需持久化/);
+            // real message follows the cleanup notice
+            assert.equal(result.directMessages[1]?.msgId, directMessage.msgId);
         });
     });
     it("poll_message should claim backend tasks before returning a cleanup notice", async () => {
@@ -1121,7 +1002,7 @@ describe("McpServer memory tools", () => {
             });
             for (let index = 0; index < 33; index += 1) {
                 await handleToolCall.call(server, "create_memory", {
-                    memory_type: "recently_memory",
+                    memory_type: "agent_memory",
                     uri: `recent://cleanup-claim/${index}`,
                     content: `recent ${index}`,
                 });
@@ -1149,7 +1030,7 @@ describe("McpServer memory tools", () => {
             });
             for (let index = 0; index < 33; index += 1) {
                 await handleToolCall.call(server, "create_memory", {
-                    memory_type: "recently_memory",
+                    memory_type: "agent_memory",
                     uri: `recent://cleanup-get/${index}`,
                     content: `recent ${index}`,
                 });
@@ -1162,7 +1043,7 @@ describe("McpServer memory tools", () => {
             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 ?? "", /recently_memory\/recent 类型下当前 33 条 memory/);
+            assert.match(result.directMessages[0]?.content ?? "", /agent_memory\/recent 类型下当前 33 条 memory/);
             assert.match(result.directMessages[0]?.prompt ?? "", /无需持久化/);
         });
     });
@@ -1170,7 +1051,7 @@ describe("McpServer memory tools", () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/incomplete-update",
                 content: "original",
             });
@@ -1196,7 +1077,7 @@ describe("McpServer memory tools", () => {
             });
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/private",
                 content: "secret local memory content",
             });
@@ -1212,7 +1093,7 @@ describe("McpServer memory tools", () => {
             });
             assert.deepEqual(reported[0], {
                 name: "create_memory",
-                args: { uri: "core://agent/private", memory_type: "memory" },
+                args: { uri: "core://agent/private", memory_type: "project_memory" },
             });
             assert.deepEqual(reported[1], {
                 name: "update_memory",
@@ -1268,12 +1149,12 @@ describe("McpServer memory tools", () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/duplicate",
                 content: "first",
             });
             await assert.rejects(() => handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/duplicate",
                 content: "second",
             }), /Memory already exists/);
@@ -1287,7 +1168,7 @@ describe("McpServer memory tools", () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/noop",
                 content: "original",
             });
@@ -1301,7 +1182,7 @@ describe("McpServer memory tools", () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await assert.rejects(() => handleToolCall.call(server, "create_memory", {
-                memory_type: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/missing-bound-file",
                 content: "memory with non-existent bound file",
                 bound_files: ["./non-existent-file.ts"],
@@ -1312,13 +1193,13 @@ describe("McpServer memory tools", () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "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: "memory",
+                memory_type: "project_memory",
                 old_string: "original",
                 new_string: "updated",
                 bound_files: ["./non-existent-file.ts"],
@@ -1335,7 +1216,7 @@ describe("McpServer memory tools", () => {
             await withMemoryServer(async (server) => {
                 const handleToolCall = getHandleToolCall(server);
                 const created = await handleToolCall.call(server, "create_memory", {
-                    memory_type: "memory",
+                    memory_type: "project_memory",
                     uri: "core://agent/valid-bound-file",
                     content: "memory with valid bound file",
                     bound_files: ["./existing-file.ts"],
@@ -1364,7 +1245,7 @@ describe("McpServer memory tools", () => {
             await withMemoryServer(async (server) => {
                 const handleToolCall = getHandleToolCall(server);
                 await assert.rejects(() => handleToolCall.call(server, "create_memory", {
-                    memory_type: "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"],
@@ -1385,14 +1266,14 @@ describe("McpServer memory tools", () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             await handleToolCall.call(server, "create_memory", {
-                memory_type: "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: "memory",
+                memory_type: "project_memory",
                 old_string: "original",
                 new_string: "updated",
             });
@@ -1882,4 +1763,141 @@ describe("AgentClient group room aggregation", () => {
         assert.equal(result.count, 2);
     });
 });
+describe("McpServer todo reminder on poll_message", () => {
+    // 使用唯一 agentId 避免污染开发者真实 todo 文件；每次测试写入并清理
+    const testAgentId = `test-todo-reminder-${process.pid}-${Date.now()}`;
+    const todoDir = path.join(os.homedir(), ".acode", "todos");
+    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("injects todo reminder 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);
+            const result = (await handleToolCall.call(server, "poll_message", {}));
+            assert.equal(result.directMessages.length, 1);
+            const notice = result.directMessages[0];
+            assert.equal(notice.senderId, "MCP-System");
+            assert.equal(notice.senderName, "系统");
+            assert.match(notice.content, /Todo 列表存在 1 项未完成/);
+        }
+        finally {
+            await cleanupTodoFile();
+        }
+    });
+    it("does not inject todo reminder when all todos are completed", async () => {
+        await writeTodoFile([
+            { content: "任务A", status: "completed", priority: "high" },
+        ]);
+        try {
+            const server = createServerForTodo();
+            const buffer = Reflect.get(server, "messageBuffer");
+            const wake = makeDirectMessage("wake-completed");
+            setTimeout(() => buffer.push(wake), 50);
+            const handleToolCall = getHandleToolCall(server);
+            const result = (await handleToolCall.call(server, "poll_message", {}));
+            // 全完成时不应注入 todo 通知，仅返回 push 的唤醒消息
+            assert.equal(result.directMessages.length, 1);
+            assert.equal(result.directMessages[0].msgId, "wake-completed");
+        }
+        finally {
+            await cleanupTodoFile();
+        }
+    });
+    it("does not repeat todo reminder when fingerprint unchanged", async () => {
+        await writeTodoFile([
+            { content: "任务A", status: "pending", priority: "high" },
+        ]);
+        try {
+            const server = createServerForTodo();
+            const handleToolCall = getHandleToolCall(server);
+            // 第一次：应返回 todo 通知
+            const result1 = (await handleToolCall.call(server, "poll_message", {}));
+            assert.equal(result1.directMessages.length, 1);
+            assert.match(result1.directMessages[0].content, /Todo 列表存在/);
+            // 第二次：指纹未变，应进入阻塞等待。push 一条消息让 poll 返回
+            const buffer = Reflect.get(server, "messageBuffer");
+            const wake = makeDirectMessage("wake-unchanged");
+            setTimeout(() => buffer.push(wake), 50);
+            const result2 = (await handleToolCall.call(server, "poll_message", {}));
+            // 第二次不应再注入 todo 通知，仅返回 push 的唤醒消息
+            assert.equal(result2.directMessages.length, 1);
+            assert.equal(result2.directMessages[0].msgId, "wake-unchanged");
+        }
+        finally {
+            await cleanupTodoFile();
+        }
+    });
+    it("re-injects todo reminder when todos change after being notified", async () => {
+        await writeTodoFile([
+            { content: "任务A", status: "pending", priority: "high" },
+        ]);
+        try {
+            const server = createServerForTodo();
+            const handleToolCall = getHandleToolCall(server);
+            // 第一次：返回 todo 通知（1 项未完成）
+            const result1 = (await handleToolCall.call(server, "poll_message", {}));
+            assert.match(result1.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+            // 修改 todo：新增一项未完成（指纹变化）
+            await writeTodoFile([
+                { content: "任务A", status: "pending", priority: "high" },
+                { content: "任务B", status: "in_progress", priority: "medium" },
+            ]);
+            // 第二次：指纹变化，应再次返回 todo 通知（2 项未完成）
+            const result2 = (await handleToolCall.call(server, "poll_message", {}));
+            assert.equal(result2.directMessages.length, 1);
+            assert.match(result2.directMessages[0].content, /Todo 列表存在 2 项未完成/);
+        }
+        finally {
+            await cleanupTodoFile();
+        }
+    });
+    it("does not inject todo reminder when todo file is absent", async () => {
+        // 确保文件不存在
+        await cleanupTodoFile();
+        const server = createServerForTodo();
+        const buffer = Reflect.get(server, "messageBuffer");
+        const wake = makeDirectMessage("wake-no-file");
+        setTimeout(() => buffer.push(wake), 50);
+        const handleToolCall = getHandleToolCall(server);
+        const result = (await handleToolCall.call(server, "poll_message", {}));
+        // 无 todo 文件不应注入通知，仅返回 push 的唤醒消息
+        assert.equal(result.directMessages.length, 1);
+        assert.equal(result.directMessages[0].msgId, "wake-no-file");
+    });
+});
 //# sourceMappingURL=mcp-server.test.js.map