aws-runtime-bridge 1.9.33 → 1.9.41

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, true);
     });
     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 = {
@@ -448,7 +436,7 @@ describe("McpServer unread backlog hydration", () => {
         assert.equal(result.fromBuffer, true);
         assert.equal(fetchOptions.length, 1);
         assert.equal(fetchOptions[0]?.blockIfEmpty, false);
-        assert.equal(fetchOptions[0]?.includePipelineTasks, 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 () => {
@@ -490,7 +478,7 @@ describe("McpServer unread backlog hydration", () => {
         assert.equal(result.fromBuffer, true);
         assert.equal(fetchOptions.length, 1);
         assert.equal(fetchOptions[0]?.blockIfEmpty, false);
-        assert.equal(fetchOptions[0]?.includePipelineTasks, false);
+        assert.equal(fetchOptions[0]?.includePipelineTasks, true);
     });
     it("poll_message should wait for WebSocket messages when backend long polling returns empty", async () => {
         const delayedMessage = {
@@ -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({
@@ -720,6 +667,93 @@ describe("McpServer unread backlog hydration", () => {
             "thinking",
         ]);
     });
+    it("poll_message should skip reportToolResult 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);
+        assert.deepEqual(statusEvents, ["tool_using", "thinking"]);
+        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 () => {
@@ -768,7 +802,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 +810,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 +818,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 +832,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 +843,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 +852,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 +879,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 +928,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 +945,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 +959,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,73 +979,45 @@ 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);
+            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("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;
-            });
-        });
-    });
-    it("poll_message injects a cleanup notice when listable memory exceeds soft limits", async () => {
+    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", {
@@ -1078,24 +1030,34 @@ 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}`,
                 });
             }
+            // Override poll to resolve immediately with empty (simulating timeout without waiting 30s)
+            const buffer = Reflect.get(server, "messageBuffer");
+            const originalPoll = buffer.poll.bind(buffer);
+            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 ?? "", /recently_memory\/recent 类型下当前 33 条 memory/);
             assert.match(result.directMessages[0]?.content ?? "", /get_memory_stats/);
             assert.match(result.directMessages[0]?.prompt ?? "", /无需持久化/);
+            // 非紧急类在初始路径直接返回，不进入 while 循环
+            assert.equal(pollCallCount, 0);
         });
     });
-    it("poll_message should claim backend tasks before returning a cleanup notice", async () => {
+    it("poll_message returns task notification without cleanup notice (while-type not stacked)", async () => {
         await withMemoryServer(async (server) => {
             const handleToolCall = getHandleToolCall(server);
             const taskNotification = {
@@ -1121,19 +1083,17 @@ 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}`,
                 });
             }
             const result = (await handleToolCall.call(server, "poll_message", {}));
-            assert.equal(fetchOptions.length, 1);
-            assert.equal(fetchOptions[0]?.blockIfEmpty, false);
-            assert.equal(fetchOptions[0]?.includePipelineTasks, false);
+            // 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, 2);
-            assert.match(result.directMessages[0]?.msgId, /^memory-cleanup-/);
-            assert.equal(result.directMessages[1]?.msgId, taskNotification.msgId);
+            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 () => {
@@ -1149,7 +1109,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 +1122,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 +1130,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 +1156,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 +1172,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 +1228,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/);
@@ -1283,25 +1243,27 @@ describe("McpServer memory tools", () => {
             assert.deepEqual(missingDelete, { deleted: false });
         });
     });
-    it("rejects empty append-only updates as no-op", async () => {
+    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: "memory",
+                memory_type: "project_memory",
                 uri: "core://agent/noop",
                 content: "original",
             });
-            await assert.rejects(() => handleToolCall.call(server, "update_memory", {
+            // 空 append 不再报错，而是执行无内容更新（仅刷新状态/MD5）
+            const result = await handleToolCall.call(server, "update_memory", {
                 uri: "core://agent/noop",
                 append: "",
-            }), /Provide either old_string\/new_string or 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: "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 +1274,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 +1297,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 +1326,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 +1347,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 +1844,160 @@ 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("returns todo alone when incomplete todos exist and no unread messages", 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", {}));
+            // 无未读消息时，todo 单独返回（组合2）
+            assert.equal(result.directMessages.length, 1);
+            assert.equal(result.directMessages[0].senderId, "MCP-System");
+            assert.equal(result.directMessages[0].senderName, "系统");
+            assert.match(result.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+        }
+        finally {
+            await cleanupTodoFile();
+        }
+    });
+    it("returns messages + todo when both unread messages and incomplete todos exist", async () => {
+        await writeTodoFile([
+            { content: "任务A", status: "pending", priority: "high" },
+        ]);
+        try {
+            const server = createServerForTodo();
+            // 先把消息放入 buffer，模拟已有未读消息
+            const buffer = Reflect.get(server, "messageBuffer");
+            const msg = makeDirectMessage("msg-before-poll");
+            buffer.push(msg);
+            const handleToolCall = getHandleToolCall(server);
+            const result = (await handleToolCall.call(server, "poll_message", {}));
+            // 有未读消息 + todo -> 组合4: 未读消息 + todo
+            assert.equal(result.directMessages.length, 2);
+            assert.equal(result.directMessages[0].senderId, "MCP-System");
+            assert.match(result.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+            assert.equal(result.directMessages[1].msgId, "msg-before-poll");
+        }
+        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，进入 while 循环等待消息后返回
+            assert.equal(result.directMessages.length, 1);
+            assert.equal(result.directMessages[0].msgId, "wake-completed");
+        }
+        finally {
+            await cleanupTodoFile();
+        }
+    });
+    it("returns todo alone on every poll_message when incomplete todos exist", async () => {
+        await writeTodoFile([
+            { content: "任务A", status: "pending", priority: "high" },
+        ]);
+        try {
+            const server = createServerForTodo();
+            const handleToolCall = getHandleToolCall(server);
+            // 第一次 poll：无未读消息 -> todo 单独返回（组合2）
+            const result1 = (await handleToolCall.call(server, "poll_message", {}));
+            assert.equal(result1.directMessages.length, 1);
+            assert.match(result1.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+            // 第二次 poll（待办未变）：仍返回 todo
+            const result2 = (await handleToolCall.call(server, "poll_message", {}));
+            assert.equal(result2.directMessages.length, 1);
+            assert.match(result2.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+        }
+        finally {
+            await cleanupTodoFile();
+        }
+    });
+    it("returns todo with updated count when todo file changes", async () => {
+        await writeTodoFile([
+            { content: "任务A", status: "pending", priority: "high" },
+        ]);
+        try {
+            const server = createServerForTodo();
+            const handleToolCall = getHandleToolCall(server);
+            // 第一次 poll：1 项未完成
+            const result1 = (await handleToolCall.call(server, "poll_message", {}));
+            assert.equal(result1.directMessages.length, 1);
+            assert.match(result1.directMessages[0].content, /Todo 列表存在 1 项未完成/);
+            // 修改 todo：新增一项
+            await writeTodoFile([
+                { content: "任务A", status: "pending", priority: "high" },
+                { content: "任务B", status: "in_progress", priority: "medium" },
+            ]);
+            // 第二次 poll：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 文件 -> 进入 while 循环等待消息后返回
+        assert.equal(result.directMessages.length, 1);
+        assert.equal(result.directMessages[0].msgId, "wake-no-file");
+    });
+});
 //# sourceMappingURL=mcp-server.test.js.map