aws-runtime-bridge 1.9.61 → 1.9.65

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

@@ -42,7 +42,6 @@ export class McpServer {
     memoryStore;
     roleMemoryStore;
     sessionContextMemoryStore;
-    memoryStoresShareFile;
     initialRoleName = "";
     /** 是否有真实的角色名（非 env 空值 fallback "default-role"） */
     hasRoleName = false;
@@ -50,52 +49,16 @@ export class McpServer {
     contextManager;
     /** 子 Agent 模式：仅暴露 Memory 工具，拒绝非 Memory 工具调用 */
     isSubAgent;
-    /**
-     * 内存级去重缓存：记录本轮已通知过的 listable memory 文件变更状态。
-     * key = memoryId，value = 已通知时刻各绑定文件的 MD5 复合哈希。
-     * 文件再次变更（MD5 变化）时仍会触发新通知。
-     * 进程重启后自动清空（届时重新检测）。
-     */
-    notifiedFileChangeMemoryIds = new Map();
-    /**
-     * Step1「memory 仍处于 updating 状态」提醒的冷却时间戳表。
-     * key = memory URI，value = 上次发送「请继续更新」提醒的时间戳。
-     * 用于避免 buildMemoryFileChangeNotification 在 polling 周期内对 sticky 的 updating
-     * memory 每轮都裸发 _acodeAutoDelegate（进而导致运行层反复 spawn 相同子任务）。
-     * 冷却窗口内不再发出该提醒；窗口到期后若 memory 仍未处理，才会重新委托。
-     */
-    lastUpdatePendingNotifyAt = new Map();
-    /** Step1「仍 updating」提醒的冷却窗口（5 分钟）。冷却期内不重复裸发 _acodeAutoDelegate。 */
-    static UPDATE_PENDING_NOTIFY_COOLDOWN_MS = 5 * 60 * 1000;
-    /**
-     * 本地缓存 listable 记忆（recently_memory/agent_memory）的文件 MD5 map。
-     * 服务端（Java 后端）不持久化 file_md5_map 字段，listByType 返回的记录该字段为 undefined。
-     * 必须本地缓存才能让 checkMemoriesFileChanges 有正确的旧 MD5 做对比。
-     */
-    listableMd5Cache = new Map();
     /**
      * 租约续期定时器 (v1.21.0)。
      * 每 60 秒续期一次当前 agent 持有的所有 updating memory 的租约。
      */
     leaseRenewalTimer = null;
+    activeLeaseUris = new Set();
     static LEASE_DURATION_MINUTES = 10;
     static LEASE_RENEW_INTERVAL_MS = 60_000;
-    /**
-     * claim 去重缓存 (v1.21.0)。
-     * 避免 5s 后台定时器重复调 server claim 同一个 memory。
-     * key = memory URI, value = 本地缓存的租约到期时间戳。
-     * 仅缓存 claim 成功的 URI，在 lease 到期前不再调 server。
-     */
-    claimedCache = new Map();
     /** profile 是否已同步（防止 activelySyncProfile 与 profileHandler 双重同步） */
     profileSynced = false;
-    /**
-     * Memory 通知 null 结果缓存：key → expiresAt 时间戳。
-     * 仅缓存 null（无通知）结果，避免 while(true) 每 30s 重复读盘。
-     * 有通知时立即投递并清除缓存，不缓存非 null 结果。
-     */
-    memoryNotificationNullCache = new Map();
-    static MEMORY_NOTIFICATION_NULL_TTL_MS = 60_000;
     /**
      * poll_message 单例控制：防止并发调用导致消息被第一个消费后第二个空等。
      * 当已有 poll 在进行时，后续调用直接等待同一个 Promise。
@@ -215,7 +178,7 @@ export class McpServer {
             }
         }
         logger.info(`[McpServer] 永久记忆同步完成: 成功 ${synced}, 跳过 ${skipped}, 共 ${localMemories.length}`);
-        await this.reportCombinedMemoryStats();
+        await this.reportMemoryStatsToServer();
     }
     /**
      * 规范化绑定的文件路径。
@@ -320,7 +283,6 @@ export class McpServer {
         this.memoryStore = new ServerMemoryStore(this.agentClient);
         this.roleMemoryStore = new MemoryStore(memoryStorePaths.rolePath);
         this.sessionContextMemoryStore = new MemoryStore(path.join(path.dirname(memoryStorePaths.rolePath), "..", "session_context"));
-        this.memoryStoresShareFile = false;
         this.isSubAgent = process.env.AWS_SUB_AGENT === "true";
         this.contextManager = new ContextManager(this.sessionContextMemoryStore);
         this.server = new Server({
@@ -622,101 +584,64 @@ export class McpServer {
         return McpServer.MEMORY_TYPES.some((memoryType) => memoryType === value);
     }
     /**
-     * 按记忆生命周期选择存储作用域。
-     * 主流程：长期 project_memory 走角色级 store；recently_memory/agent_memory 走当前 Agent 实例级 store。
+     * 所有类型的记忆统一走服务端（Server 是唯一权威源）。
+     * 本地 roleMemoryStore 仅用于 project_memory 的备份写入与启动恢复。
      */
-    /**
-     * 按记忆生命周期选择存储作用域。
-     * 主流程：永久记忆(project_memory)始终走本地 roleMemoryStore（.agentswork），
-     *         确保本地文件始终有副本，后续部署恢复时可通过 Local → Server 同步回 server。
-     * recently_memory/agent_memory/session_context 始终走实例级 server store。
-     */
-    getMemoryStoreForType(memoryType) {
-        if (memoryType === "project_memory") {
-            return this.roleMemoryStore;
-        }
+    getMemoryStoreForType(_memoryType) {
         return this.memoryStore;
     }
     /**
-     * 在未显式指定类型时按两个作用域读取。
-     * 主流程：先查角色级长期记忆 -> 再查实例级临时/近期记忆，保持旧工具参数可选语义。
+     * 读取记忆：直接走服务端（Server 是唯一权威源）。
      */
     async readMemoryFromScopedStores(input) {
-        if (this.memoryStoresShareFile) {
-            return await this.memoryStore.readMemory(input);
-        }
         if (input.memory_type) {
-            // project_memory：服务端为权威源（claim/租约/memory_status 均在服务端维护），
-            // 本地 roleMemoryStore 仅作服务端不可用时的离线降级副本。
-            // 之前本地优先会导致 read_memory 读到过时的 memory_status='normal'，
-            // 而服务端 DB 已是 'updating'（文件变更 claim 只写服务端），状态脱节。
-            if (input.memory_type === "project_memory") {
-                try {
-                    const serverRecord = await this.memoryStore.readMemory(input);
-                    if (serverRecord) {
-                        return serverRecord;
-                    }
-                }
-                catch {
-                    // 服务端不可用，降级到本地
-                }
-                return await this.roleMemoryStore.readMemory(input);
-            }
-            // recently_memory / agent_memory：实例级，走服务端
             return await this.memoryStore.readMemory(input);
         }
-        // 未指定 memory_type：优先查服务端 project_memory（权威源），
-        // 降级本地 roleMemoryStore（离线未同步记录），最后查服务端实例级记忆。
+        const longTerm = await this.memoryStore.readMemory({
+            ...input,
+            memory_type: "project_memory",
+        }).catch(() => null);
+        if (longTerm) {
+            return longTerm;
+        }
+        return await this.memoryStore.readMemory(input);
+    }
+    /**
+     * 将 project_memory 异步备份到本地文件（纯灾备，不作为读取源）。
+     */
+    async backupProjectMemoryToLocal(input) {
         try {
-            const serverLongTerm = await this.memoryStore.readMemory({
-                ...input,
+            const record = await this.memoryStore.readMemory({
+                uri: input.uri,
                 memory_type: "project_memory",
             });
-            if (serverLongTerm) {
-                return serverLongTerm;
+            if (record) {
+                await this.roleMemoryStore.deleteMemory({ uri: input.uri, memory_type: "project_memory" }).catch(() => { });
+                await this.roleMemoryStore.createMemory(record);
             }
         }
-        catch {
-            // 服务端不可用，降级到本地
+        catch (e) {
+            logger.warn("[McpServer] backupProjectMemoryToLocal 失败: uri=%s", input.uri, e);
         }
-        const localLongTerm = await this.roleMemoryStore.readMemory({
-            ...input,
-            memory_type: "project_memory",
-        });
-        if (localLongTerm) {
-            return localLongTerm;
+    }
+    /**
+     * 删除 project_memory 的本地备份文件。
+     */
+    async removeProjectMemoryLocalBackup(uri) {
+        try {
+            await this.roleMemoryStore.deleteMemory({ uri, memory_type: "project_memory" });
+        }
+        catch (e) {
+            logger.warn("[McpServer] removeProjectMemoryLocalBackup 失败: uri=%s", uri, e);
         }
-        return await this.memoryStore.readMemory(input);
     }
     /**
-     * 在未显式指定类型时定位可更新/删除的存储。
-     * 主流程：按读取优先级查找记录 -> 返回命中的 store 与规范化类型，避免跨作用域误写。
+     * 定位可更新/删除的存储：统一走服务端。
      */
     async findMemoryStoreForMutation(input) {
-        if (this.memoryStoresShareFile) {
-            return { store: this.memoryStore, memory_type: input.memory_type };
-        }
         if (input.memory_type) {
-            // project_memory：服务端为权威源（claim/memory_status/租约均在服务端维护），
-            // mutation 必须走服务端，否则本地写入与服务端状态脱节。
-            // 本地 roleMemoryStore 仅在“本地存在离线记录但服务端没有”时降级（未同步的离线编辑）；
-            // 新建（两者均无）必须落到服务端，避免 create 写入本地导致服务端统计/可见性脱节。
-            if (input.memory_type === "project_memory") {
-                const serverRecord = await this.memoryStore.readMemory(input).catch(() => null);
-                if (serverRecord) {
-                    return { store: this.memoryStore, memory_type: "project_memory" };
-                }
-                const localRecord = await this.roleMemoryStore.readMemory(input).catch(() => null);
-                if (localRecord) {
-                    return { store: this.roleMemoryStore, memory_type: "project_memory" };
-                }
-                return { store: this.memoryStore, memory_type: "project_memory" };
-            }
-            // recently_memory / agent_memory：实例级，走服务端
             return { store: this.memoryStore, memory_type: input.memory_type };
         }
-        // 未指定 memory_type：优先查服务端 project_memory（权威源），
-        // 降级本地 roleMemoryStore（离线未同步记录），最后回退服务端实例级。
         const serverLongTerm = await this.memoryStore.readMemory({
             uri: input.uri,
             memory_type: "project_memory",
@@ -724,59 +649,15 @@ export class McpServer {
         if (serverLongTerm) {
             return { store: this.memoryStore, memory_type: "project_memory" };
         }
-        const localLongTerm = await this.roleMemoryStore.readMemory({
-            uri: input.uri,
-            memory_type: "project_memory",
-        });
-        if (localLongTerm) {
-            return { store: this.roleMemoryStore, memory_type: "project_memory" };
-        }
         return { store: this.memoryStore };
     }
-    /**
-     * 合并角色级长期记忆与实例级短期记忆容量统计。
-     * 主流程：实例 store 负责 listable 限额；角色 store 只贡献长期 memory 数量。
-     */
-    combineMemoryStats(instanceStats, roleStats) {
-        if (this.memoryStoresShareFile) {
-            return instanceStats;
-        }
-        // 服务端 now 也按角色级返回永久记忆统计（同角色实例共享），
-        // 本地 roleMemoryStore 也可能有尚未同步到服务端的记录。
-        // permanentCount 取两者的较大值作为保守估计（下界）。
-        // 注意: 当 instance 和 role 分别有对方没有的唯一 URI 时，实际并集 > Math.max，
-        // 但此处只有 count 无 URI 列表，无法精确计算并集，使用下界避免面板显示虚高。
-        const permanentCount = Math.max(instanceStats.by_type.project_memory.count, roleStats.by_type.project_memory.count);
-        // total 同样保守估算：用 server 非 project_memory count + permanentCount 下界
-        const serverNonMemoryTotal = instanceStats.total - instanceStats.by_type.project_memory.count;
-        return {
-            total: serverNonMemoryTotal + permanentCount,
-            listable: instanceStats.listable,
-            by_type: {
-                recently_memory: instanceStats.by_type.recently_memory,
-                agent_memory: instanceStats.by_type.agent_memory,
-                project_memory: {
-                    ...roleStats.by_type.project_memory,
-                    count: permanentCount,
-                },
-                session_context: instanceStats.by_type.session_context,
-            },
-        };
-    }
-    /**
-     * 上报当前合并后的记忆统计。
-     * 主流程：读取实例级与角色级统计 -> 合并长期 memory count -> 通过 server 广播给 Dashboard。
-     */
-    async reportCombinedMemoryStats() {
-        const instanceStats = await this.memoryStore.getStats();
-        const mergedStats = this.hasRoleName
-            ? this.combineMemoryStats(instanceStats, await this.roleMemoryStore.getStats())
-            : instanceStats;
+    async reportMemoryStatsToServer() {
+        const stats = await this.memoryStore.getStats();
         try {
-            await this.agentClient.reportMemoryStats(mergedStats);
+            await this.agentClient.reportMemoryStats(stats);
         }
         catch (error) {
-            logger.warn("[McpServer] 上报合并 memory 统计失败，已保留本地记忆写入结果:", error);
+            logger.warn("[McpServer] 上报 memory 统计失败:", error);
         }
     }
     /**
@@ -884,19 +765,13 @@ export class McpServer {
             file_md5_map: fileMd5Map,
             last_check_time: lastCheckTime,
         };
-        const created = await this.getMemoryStoreForType(input.memory_type).createMemory(input);
-        // Dual-write permanent memory to server BEFORE reporting stats,
-        // 确保 reportCombinedMemoryStats 上报时 server 端已包含 project_memory 记录，
-        // 避免 Dashboard 统计与本地写入脱节。
+        const created = await this.memoryStore.createMemory(input);
         if (input.memory_type === "project_memory") {
-            try {
-                await this.memoryStore.createMemory(input);
-            }
-            catch (e) {
-                logger.warn("[McpServer] Failed to sync permanent memory to server:", e);
-            }
+            this.backupProjectMemoryToLocal(input).catch((e) => {
+                logger.warn("[McpServer] 备份 project_memory 到本地失败:", e);
+            });
         }
-        await this.reportCombinedMemoryStats();
+        await this.reportMemoryStatsToServer();
         // v1.13.0: recently_memory 过期判定、agent_memory 过期/回忆状态由服务端 memory_status 字段管理，
         // 无需 TS 侧本地缓存。服务端默认按类型填充正确状态（recently_memory='normal', agent_memory='normal'）。
         return this.toMemoryWriteResult(created);
@@ -946,20 +821,15 @@ export class McpServer {
             uri: input.uri,
             memory_type: target.memory_type ?? input.memory_type,
         });
-        // 当记忆已绑定文件或处于更新中状态时，要求显式指定 bound_files 并校验文件存在性。
-        // 这确保文件被删除后，Agent 必须更新 bound_files 列表（移除已删除文件）才能完成更新，
-        // 避免已删除文件路径作为"僵尸绑定"长期保留。
-        const hasExistingBoundFiles = !!existingForMd5?.bound_files && existingForMd5.bound_files.length > 0;
-        const isUpdatingState = existingForMd5?.memory_status === "updating";
-        if ((hasExistingBoundFiles || isUpdatingState) &&
-            input.bound_files === undefined) {
-            throw new Error("此记忆已绑定文件或处于更新中状态，更新时必须指定 bound_files 列表。" +
-                "请提供 bound_files 参数（如需移除已删除的文件，请更新列表仅保留当前存在的文件）。");
-        }
-        // 校验 bound_files 中所有文件是否存在：不存在的文件会导致更新失败
+        // 校验绑定文件存在性：
+        // - 如果提供了新的 bound_files，校验新列表中的文件是否都存在
+        // - 如果未提供 bound_files，校验当前已绑定的文件是否都存在
         if (input.bound_files !== undefined) {
             await this.validateBoundFilesExist(input.bound_files);
         }
+        else if (existingForMd5?.bound_files && existingForMd5.bound_files.length > 0) {
+            await this.validateBoundFilesExist(existingForMd5.bound_files);
+        }
         const effectiveBoundFiles = input.bound_files ?? existingForMd5?.bound_files;
         // 重新计算绑定文件的 MD5 map，确保更新后 MD5 与文件实际内容一致
         let fileMd5Map;
@@ -979,31 +849,24 @@ export class McpServer {
             file_md5_map: fileMd5Map,
             last_check_time: lastCheckTime,
         });
-        // Dual-write permanent memory update to server（同步 MD5 map 避免服务端重复检测）
-        // 当 target.store 已是服务端（兄弟实例创建的记忆回退场景）时跳过，避免重复写。
-        // 必须在 reportCombinedMemoryStats 之前完成，确保上报时 server 端统计已同步。
-        if (target.memory_type === "project_memory" && target.store !== this.memoryStore) {
-            try {
-                await this.memoryStore.updateMemory({
-                    ...input,
-                    memory_type: "project_memory",
-                    file_md5_map: fileMd5Map,
-                    last_check_time: lastCheckTime,
-                });
-            }
-            catch (e) {
-                logger.warn("[McpServer] Failed to sync permanent memory update to server:", e);
-            }
+        if (target.memory_type === "project_memory") {
+            this.backupProjectMemoryToLocal({
+                ...input,
+                memory_type: "project_memory",
+                file_md5_map: fileMd5Map,
+                last_check_time: lastCheckTime,
+            }).catch((e) => {
+                logger.warn("[McpServer] 备份 project_memory 更新到本地失败:", e);
+            });
         }
-        await this.reportCombinedMemoryStats();
+        await this.reportMemoryStatsToServer();
         // v1.13.0: agent_memory 过期与回忆状态由服务端 memory_status 字段管理。
         // v1.21.0: 如果是 project_memory 且之前是 updating 状态，释放 Server claim
         if (target.memory_type === 'project_memory' && existingForMd5?.memory_status === 'updating') {
             try {
                 await this.memoryStore.releaseMemoryClaim(input.uri);
-                this.claimedCache.delete(input.uri);
-                // 所有 claim 已释放，停止续期定时器避免无意义请求
-                if (this.claimedCache.size === 0) {
+                this.activeLeaseUris.delete(input.uri);
+                if (this.activeLeaseUris.size === 0) {
                     this.stopLeaseRenewal();
                 }
             }
@@ -1068,7 +931,7 @@ export class McpServer {
             }
         }
         if (deletedCount > 0) {
-            await this.reportCombinedMemoryStats();
+            await this.reportMemoryStatsToServer();
         }
         return {
             deleted: deletedCount,
@@ -1078,7 +941,7 @@ export class McpServer {
     }
     /**
      * 删除单条记忆的内部辅助方法。
-     * - skipStats=true 时跳过 reportCombinedMemoryStats 调用，由批量调用方统一上报一次。
+     * - skipStats=true 时跳过 reportMemoryStatsToServer 调用，由批量调用方统一上报一次。
      * - 返回 true/false 表示是否实际删除（与 store.deleteMemory 一致）。
      */
     async deleteMemorySingle(uri, memory_type, skipStats = false) {
@@ -1090,20 +953,13 @@ export class McpServer {
             memory_type: effectiveType,
         });
         if (deleted) {
-            // v1.13.0: 服务端 deleteMemory 内部已处理相关清理逻辑，
-            // TS 侧无需任何本地元数据清理。
-            // Dual-write permanent memory delete to server
-            // 当 target.store 已是服务端时跳过，避免重复删除。
-            if (effectiveType === "project_memory" && target.store !== this.memoryStore) {
-                try {
-                    await this.memoryStore.deleteMemory({ uri, memory_type: "project_memory" });
-                }
-                catch (e) {
-                    logger.warn("[McpServer] Failed to sync permanent memory delete to server:", e);
-                }
+            if (effectiveType === "project_memory") {
+                this.removeProjectMemoryLocalBackup(uri).catch((e) => {
+                    logger.warn("[McpServer] 删除 project_memory 本地备份失败:", e);
+                });
             }
             if (!skipStats) {
-                await this.reportCombinedMemoryStats();
+                await this.reportMemoryStatsToServer();
             }
         }
         return deleted;
@@ -1148,34 +1004,7 @@ export class McpServer {
      * 具体逻辑：按 memory_type 分流 -> 无类型时合并 roleMemoryStore(永久)与 memoryStore(recently/agent)。
      */
     async searchOwnMemories(input) {
-        if (input.memory_type) {
-            return await this.getMemoryStoreForType(input.memory_type).searchMemory(input);
-        }
-        if (this.memoryStoresShareFile) {
-            return await this.memoryStore.searchMemory(input);
-        }
-        // 无角色名时不查询 roleMemoryStore（避免 default-role 共享目录导致跨角色污染）
-        if (!this.hasRoleName) {
-            return await this.memoryStore.searchMemory(input);
-        }
-        const [roleResult, instanceResult] = await Promise.all([
-            this.roleMemoryStore.searchMemory({ ...input, memory_type: "project_memory" }),
-            this.memoryStore.searchMemory(input),
-        ]);
-        const seen = new Set();
-        const limit = typeof input.limit === "number" && input.limit > 0 ? input.limit : 10;
-        const results = [...roleResult.results, ...instanceResult.results]
-            .filter((record) => {
-            const key = `${record.memory_type}:${record.uri}`;
-            if (seen.has(key)) {
-                return false;
-            }
-            seen.add(key);
-            return true;
-        })
-            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
-            .slice(0, limit);
-        return { query: roleResult.query || instanceResult.query, results };
+        return await this.memoryStore.searchMemory(input);
     }
     /**
      * 合并两组搜索结果，按 uri 去重、更新时间排序。
@@ -1214,10 +1043,7 @@ export class McpServer {
      * 主流程：读取 MemoryStore 统计结果，供 Agent 在创建前判断 listable/type 容量。
      */
     async handleGetMemoryStats(args) {
-        const instanceStats = await this.memoryStore.getStats();
-        const stats = this.hasRoleName
-            ? this.combineMemoryStats(instanceStats, await this.roleMemoryStore.getStats())
-            : instanceStats;
+        const stats = await this.memoryStore.getStats();
         const memoryType = this.getOptionalMemoryType(args);
         if (!memoryType) {
             return stats;
@@ -1250,16 +1076,11 @@ export class McpServer {
         const rawScope = this.getOptionalString(args, "scope");
         // 默认 scope='all'：合并搜索自身与子Agent绑定文件的记忆
         const scope = rawScope === "own" || rawScope === "children" ? rawScope : "all";
-        // 搜索子 Agent 的 memory（server + 本地文件系统双路径，并行）
         const fetchChildMemories = async () => {
-            const [serverResult, localResult] = await Promise.all([
-                this.memoryStore.listByFile(normalizedPath, {
-                    memory_type: memoryType,
-                    scope: "children",
-                }).catch(() => []), // server 不可用时降级
-                this.searchChildMemoriesByFileLocal(normalizedPath, memoryType),
-            ]);
-            return this.mergeIdDedupe(serverResult, localResult);
+            return await this.memoryStore.listByFile(normalizedPath, {
+                memory_type: memoryType,
+                scope: "children",
+            }).catch(() => []);
         };
         if (scope === "children") {
             const childResult = await fetchChildMemories();
@@ -1429,25 +1250,9 @@ export class McpServer {
      * 同时查询临时记忆(server)和永久记忆(local roleMemoryStore)。
      */
     async collectOwnMemoriesByFile(filePath, memoryType) {
-        const serverResult = await this.memoryStore.listByFile(filePath, {
+        return await this.memoryStore.listByFile(filePath, {
             memory_type: memoryType,
         });
-        let localResult = [];
-        // 补充查询本地永久记忆（server 可能未同步）；无角色名时跳过（避免 default-role 跨角色污染）
-        if (this.hasRoleName && (!memoryType || memoryType === "project_memory")) {
-            localResult = await this.roleMemoryStore.listByFile(filePath, "project_memory");
-        }
-        // 去重合并
-        const seen = new Set(serverResult.map(m => `${m.memory_type}:${m.uri}`));
-        const merged = [...serverResult];
-        for (const m of localResult) {
-            const key = `${m.memory_type}:${m.uri}`;
-            if (!seen.has(key)) {
-                merged.push(m);
-                seen.add(key);
-            }
-        }
-        return merged;
     }
     /**
      * 放弃 Memory 更新状态 (v1.21.0 改为走 release API)
@@ -1465,24 +1270,13 @@ export class McpServer {
         }
         // 调 Server release API 释放 claim
         await this.memoryStore.releaseMemoryClaim(uri);
-        // 同时清除本地 roleMemoryStore 的 updating 状态（如果是 project_memory）
-        // 兄弟实例创建的记忆本地不存在时静默跳过，服务端 release 才是权威操作
         if (record?.memory_type === 'project_memory') {
-            try {
-                await this.roleMemoryStore.updateMemory({
-                    uri,
-                    memory_type: 'project_memory',
-                });
-                // 不传 memory_status → MemoryStore 默认重置为 normal
-            }
-            catch (e) {
-                logger.info(`[McpServer] abandon_memory_update: 本地无此记忆，跳过本地状态清理: ${uri}`);
-            }
+            this.backupProjectMemoryToLocal({ uri, memory_type: 'project_memory' }).catch((e) => {
+                logger.info(`[McpServer] abandon_memory_update: 同步本地备份失败: ${uri}`, e);
+            });
         }
-        // 从去重缓存移除
-        this.claimedCache.delete(uri);
-        // 所有 claim 已释放，停止续期定时器避免无意义请求
-        if (this.claimedCache.size === 0) {
+        this.activeLeaseUris.delete(uri);
+        if (this.activeLeaseUris.size === 0) {
             this.stopLeaseRenewal();
         }
         return {
@@ -1571,7 +1365,7 @@ export class McpServer {
         catch (e) {
             logger.warn('[McpServer] 清理回忆中记忆失败: %s', e instanceof Error ? e.message : String(e));
         }
-        await this.reportCombinedMemoryStats();
+        await this.reportMemoryStatsToServer();
         const deletedCount = result.deleted ?? 0;
         return {
             deleted: deletedCount,
@@ -1669,26 +1463,6 @@ export class McpServer {
         }
         return false;
     }
-    /**
-     * 带 null 结果缓存的 Memory 通知构建。
-     * 主流程：查缓存 → 命中且未过期则返回 null → 未命中则调 buildFn →
-     *   结果为 null 则写入缓存（TTL 60s）→ 结果非 null 则清除缓存并返回。
-     * 目的：while(true) 每 30s 轮询时避免重复读盘，有通知时立即投递不受缓存影响。
-     */
-    async getCachedMemoryNotification(key, buildFn) {
-        const expiresAt = this.memoryNotificationNullCache.get(key);
-        if (expiresAt !== undefined && expiresAt > Date.now()) {
-            return null;
-        }
-        const result = await buildFn();
-        if (result === null) {
-            this.memoryNotificationNullCache.set(key, Date.now() + McpServer.MEMORY_NOTIFICATION_NULL_TTL_MS);
-        }
-        else {
-            this.memoryNotificationNullCache.delete(key);
-        }
-        return result;
-    }
     async handlePollMessage() {
         logger.info('[McpServer] handlePollMessage 被调用');
         if (this.pendingPollMessage) {
@@ -1773,8 +1547,8 @@ export class McpServer {
             if (todoNotifLoop) {
                 return this.buildPollResult({ directMessages: [todoNotifLoop], groupMessages: [] });
             }
-            // 非紧急类：无紧急类时，检查所有非紧急项
-            const nonUrgent = await this.checkAllLocalNonUrgentNotifications();
+            // 非紧急类：无紧急类时，检查非紧急项（文件变更仅在入口处检测一次，循环内跳过）
+            const nonUrgent = await this.checkAllLocalNonUrgentNotifications(false);
             if (nonUrgent.length > 0) {
                 return this.buildPollResult({ directMessages: nonUrgent, groupMessages: [] });
             }
@@ -1783,19 +1557,19 @@ export class McpServer {
     /**
      * 检查本地非紧急通知（memory过期回忆、文件变更、容量整理），返回所有命中的通知。
      * Task 不在此方法中检查，因为 Task 通过服务端 hydrate 以消息形式返回。
+     * @param includeFileChange 是否包含文件变更检测，默认 true；循环轮询时传 false 以跳过。
      */
-    async checkAllLocalNonUrgentNotifications() {
+    async checkAllLocalNonUrgentNotifications(includeFileChange = true) {
         const messages = [];
-        // Memory 过期回忆
-        const recurrenceNotif = await this.getCachedMemoryNotification('recurrence', () => this.buildMemoryRecurrenceNotification());
+        const recurrenceNotif = await this.buildMemoryRecurrenceNotification();
         if (recurrenceNotif)
             messages.push(recurrenceNotif);
-        // Memory 文件变更（需要更新）
-        const fileChangeNotif = await this.buildMemoryFileChangeNotification();
-        if (fileChangeNotif)
-            messages.push(fileChangeNotif);
-        // Memory 容量整理
-        const cleanupNotif = await this.getCachedMemoryNotification('cleanup', () => this.buildMemoryCleanupNotification());
+        if (includeFileChange) {
+            const fileChangeNotif = await this.buildMemoryFileChangeNotification();
+            if (fileChangeNotif)
+                messages.push(fileChangeNotif);
+        }
+        const cleanupNotif = await this.buildMemoryCleanupNotification();
         if (cleanupNotif)
             messages.push(cleanupNotif);
         return messages;
@@ -2028,37 +1802,46 @@ export class McpServer {
                         },
                     };
                 }
-                // Step1「仍 updating」提醒去重：sticky 的 updating memory 若不在冷却窗口内才发提醒，
-                // 否则本轮直接返回 null，避免每轮 poll 都裸发 _acodeAutoDelegate 触发运行层反复 spawn 子任务。
-                const now = Date.now();
-                const pendingToNotify = updatingMemories.filter(m => {
-                    const last = this.lastUpdatePendingNotifyAt.get(m.uri) ?? 0;
-                    return now - last >= McpServer.UPDATE_PENDING_NOTIFY_COOLDOWN_MS;
+                const pendingToNotify = updatingMemories;
+                const pendingStatuses = new Map();
+                for (const m of pendingToNotify.slice(0, 5)) {
+                    pendingStatuses.set(m.uri, await this.computeBoundFileStatuses(m));
+                }
+                const memoriesWithRealChanges = pendingToNotify.filter(m => {
+                    const statuses = pendingStatuses.get(m.uri);
+                    if (!statuses || statuses.length === 0)
+                        return false;
+                    return statuses.some(s => s.status === 'content_changed' || s.status === 'not_found');
                 });
-                // 清理已不在 updating 列表中的过期冷却记录
-                for (const uri of this.lastUpdatePendingNotifyAt.keys()) {
-                    if (!updatingMemories.some(m => m.uri === uri)) {
-                        this.lastUpdatePendingNotifyAt.delete(uri);
+                const staleUpdatingMemories = pendingToNotify.filter(m => !memoriesWithRealChanges.includes(m));
+                if (staleUpdatingMemories.length > 0) {
+                    logger.info(`[McpServer] 文件变更检测 Step1: ${staleUpdatingMemories.length} 个 updating memory 绑定文件无真实变更，自动释放: ${staleUpdatingMemories.map(m => m.uri).join(', ')}`);
+                    for (const m of staleUpdatingMemories) {
+                        try {
+                            await this.memoryStore.releaseMemoryClaim(m.uri);
+                            this.activeLeaseUris.delete(m.uri);
+                            await this.memoryStore.updateMemory({
+                                uri: m.uri,
+                                memory_type: 'project_memory',
+                            });
+                        }
+                        catch (e) {
+                            logger.info(`[McpServer] 自动释放 stale updating memory 失败: ${m.uri}`, e);
+                        }
+                    }
+                    if (this.activeLeaseUris.size === 0) {
+                        this.stopLeaseRenewal();
                     }
                 }
-                if (pendingToNotify.length === 0) {
-                    logger.info(`[McpServer] 文件变更检测 Step1: ${updatingMemories.length} 个 updating memory 均处于冷却窗口内，跳过提醒`);
+                if (memoriesWithRealChanges.length === 0) {
+                    logger.info(`[McpServer] 文件变更检测 Step1: 所有 updating memory 绑定文件均无真实变更，已自动释放，跳过委托`);
                     return null;
                 }
-                for (const m of pendingToNotify) {
-                    this.lastUpdatePendingNotifyAt.set(m.uri, now);
-                }
-                // 计算 pending（仍 updating）记忆的逐文件状态，供子 agent 在提示词中标注
-                // （无变更/内容变更/文件找不到），避免「本次变更文件: 未知」歧义。
-                const pendingStatuses = new Map();
-                for (const m of pendingToNotify.slice(0, 5)) {
-                    pendingStatuses.set(m.uri, await this.computeBoundFileStatuses(m));
-                }
-                const memoryList = pendingToNotify
+                const memoryList = memoriesWithRealChanges
                     .slice(0, 5)
                     .map(m => `- ${m.uri} (文件: ${m.bound_files?.join(', ') || '未知'})`)
                     .join('\n');
-                logger.info(`[McpServer] 文件变更检测 Step1: ${pendingToNotify.length}/${updatingMemories.length} 个 updating memory 待更新（其余冷却中），租约已续期`);
+                logger.info(`[McpServer] 文件变更检测 Step1: ${memoriesWithRealChanges.length}/${updatingMemories.length} 个 updating memory 有真实文件变更，触发委托`);
                 return {
                     msgId: `memory-update-pending-${Date.now()}`,
                     senderId: "MCP-System",
@@ -2070,10 +1853,8 @@ export class McpServer {
                     timestamp: new Date().toISOString(),
                     _acodeAutoDelegate: {
                         type: 'memory_file_change',
-                        uris: pendingToNotify.slice(0, 5).map(m => m.uri),
-                        // 此分支为「仍 updating」状态提醒，本轮未检测到新的文件变更，
-                        // 仅传递绑定文件清单与逐文件状态供子 agent 直接定位文件，changedFiles 留空。
-                        fileChanges: pendingToNotify.slice(0, 5).map(m => ({
+                        uris: memoriesWithRealChanges.slice(0, 5).map(m => m.uri),
+                        fileChanges: memoriesWithRealChanges.slice(0, 5).map(m => ({
                             uri: m.uri,
                             boundFiles: m.bound_files ?? [],
                             fileStatuses: pendingStatuses.get(m.uri) ?? [],
@@ -2090,15 +1871,6 @@ export class McpServer {
             logger.info(`[McpServer] 文件变更检测 Step2: recently=${recentlyMemoryMemories.length}, agent=${agentMemoryMemories.length}, ` +
                 `有绑定文件=${listableWithFiles.length}/${listableMemories.length}。` +
                 `详情: ${listableMemories.map(m => `${m.uri}(bound=${m.bound_files?.length ?? 0},md5=${Object.keys(m.file_md5_map ?? {}).length})`).join('; ') || '无 memory'}`);
-            // 用本地 MD5 缓存补全 listable 记录（服务端可能不持久化 file_md5_map 字段）
-            for (const m of listableMemories) {
-                if (!m.file_md5_map) {
-                    const cached = this.listableMd5Cache.get(m.id);
-                    if (cached) {
-                        m.file_md5_map = cached;
-                    }
-                }
-            }
             // 捕获检测前的 md5 map 快照，用于检测 checkMemoriesFileChanges 是否修复了键缺失
             // （路径规范化不一致导致 bound_files 与 file_md5_map 键不匹配时的静默修正）
             const listableMd5Snapshots = new Map();
@@ -2108,18 +1880,8 @@ export class McpServer {
                 }
             }
             const listableChanges = await this.checkMemoriesFileChanges(listableMemories);
-            const newListableChanges = listableChanges.filter(c => {
-                const memory = listableMemories.find(m => m.id === c.memoryId);
-                const md5Map = memory?.file_md5_map;
-                const changeKey = this.buildMemoryChangeNotificationKey(c.memoryId, md5Map);
-                const lastNotified = this.notifiedFileChangeMemoryIds.get(c.memoryId);
-                const isNew = lastNotified !== changeKey;
-                if (!isNew) {
-                    logger.info(`[McpServer] 文件变更检测 Step2: ${c.memoryUri} 变更被去重吞掉 (changeKey=${changeKey}, lastNotified=${lastNotified})`);
-                }
-                return isNew;
-            });
-            logger.info(`[McpServer] 文件变更检测 Step2: 检测到变更=${listableChanges.length}, 去重后=${newListableChanges.length}` +
+            const newListableChanges = listableChanges;
+            logger.info(`[McpServer] 文件变更检测 Step2: 检测到变更=${listableChanges.length}` +
                 (listableChanges.length > 0 ? ` 变更项: ${listableChanges.map(c => `${c.memoryUri}(${c.changedFiles.join(',')})`).join('; ')}` : ''));
             // 回写被修复的 md5 map（键缺失修正）到服务端，避免后续轮次因键不匹配反复误判。
             // 仅回写未发生真实变更的 memory（发生变更的已在下方 claim/通知流程中处理）。
@@ -2142,9 +1904,6 @@ export class McpServer {
                             file_md5_map: m.file_md5_map,
                             last_check_time: m.last_check_time,
                         });
-                        if (m.file_md5_map) {
-                            this.listableMd5Cache.set(m.id, m.file_md5_map);
-                        }
                     }
                     catch (e) {
                         logger.info(`[McpServer] 回写 listable MD5 map 失败: ${m.uri}`, e);
@@ -2152,14 +1911,6 @@ export class McpServer {
                 }
             }
             if (newListableChanges.length > 0) {
-                for (const c of newListableChanges) {
-                    const memory = listableMemories.find(m => m.id === c.memoryId);
-                    const md5Map = memory?.file_md5_map;
-                    this.notifiedFileChangeMemoryIds.set(c.memoryId, this.buildMemoryChangeNotificationKey(c.memoryId, md5Map));
-                    if (memory?.file_md5_map) {
-                        this.listableMd5Cache.set(c.memoryId, memory.file_md5_map);
-                    }
-                }
                 const changeDetails = newListableChanges
                     .map(change => `- ${change.memoryUri} (文件: ${change.changedFiles.join(', ')})`)
                     .join('\n');
@@ -2264,8 +2015,7 @@ export class McpServer {
                                 last_check_time: memory.last_check_time,
                                 bound_files: memory.bound_files,
                             });
-                            // 加入去重缓存（lease 有效期内不再重复 claim）
-                            this.claimedCache.set(memory.uri, Date.now() + McpServer.LEASE_DURATION_MINUTES * 60 * 1000);
+                            this.activeLeaseUris.add(memory.uri);
                         }
                     }
                     // 启动租约续期（仅 Server claim 成功时需要，降级模式不续期）
@@ -2308,19 +2058,8 @@ export class McpServer {
             return null;
         }
     }
-    /**
-     * 检查指定 URI 是否在 claim 去重缓存内 (v1.21.0)。
-     * 在 lease 有效期内不再重复 claim。
-     */
     isClaimCached(uri) {
-        const expiry = this.claimedCache.get(uri);
-        if (expiry === undefined)
-            return false;
-        if (expiry <= Date.now()) {
-            this.claimedCache.delete(uri);
-            return false;
-        }
-        return true;
+        return this.activeLeaseUris.has(uri);
     }
     /**
      * 计算某条记忆全部绑定文件的逐文件状态（纯计算，不修改任何状态）。
@@ -2334,11 +2073,19 @@ export class McpServer {
         if (!memory.bound_files || memory.bound_files.length === 0)
             return result;
         const oldMd5Map = memory.file_md5_map || {};
+        const workspacePath = process.env.AWS_WORKSPACE_PATH || process.cwd();
         for (const filePath of memory.bound_files) {
             try {
                 const currentMd5 = await this.calculateFileMd5(filePath);
                 if (currentMd5 === null) {
-                    result.push({ path: filePath, status: 'not_found' });
+                    const resolvedPath = path.resolve(workspacePath, filePath);
+                    const fileTrulyMissing = await this.verifyFileNotExist(resolvedPath);
+                    if (fileTrulyMissing && oldMd5Map[filePath]) {
+                        result.push({ path: filePath, status: 'not_found', serverMd5: oldMd5Map[filePath] });
+                    }
+                    else {
+                        result.push({ path: filePath, status: 'no_change' });
+                    }
                     continue;
                 }
                 const oldMd5 = oldMd5Map[filePath];
@@ -2346,14 +2093,13 @@ export class McpServer {
                     result.push({ path: filePath, status: 'no_change' });
                 }
                 else if (oldMd5 !== currentMd5) {
-                    result.push({ path: filePath, status: 'content_changed' });
+                    result.push({ path: filePath, status: 'content_changed', localMd5: currentMd5, serverMd5: oldMd5 });
                 }
                 else {
                     result.push({ path: filePath, status: 'no_change' });
                 }
             }
             catch {
-                // MD5 计算失败：保守视为未变更，不误报
                 result.push({ path: filePath, status: 'no_change' });
             }
         }
@@ -2382,43 +2128,39 @@ export class McpServer {
                     try {
                         const currentMd5 = await this.calculateFileMd5(filePath);
                         if (currentMd5 === null) {
-                            // 文件不存在或无法读取
                             const resolvedPath = path.resolve(workspacePath, filePath);
                             logger.info(`[McpServer] MD5 计算返回 null: ${filePath} -> ${resolvedPath} (workspace=${workspacePath})`);
                             const oldMd5ForMissing = oldMd5Map[filePath];
                             if (oldMd5ForMissing) {
-                                // 该文件曾有基线，现在读不到 -> 视为变更（文件被删除/移动）
-                                statuses.push({ path: filePath, status: 'not_found' });
-                                changedFiles.push(`${filePath} (文件找不到)`);
-                                // 收口：文件已消失，从 bound_files 移除该路径，消除悬空引用。
-                                // 否则 listByFile/findByBoundFile 会持续命中无效记录，且文件恢复后因基线已清而变更检测失效。
-                                // bound_files 修剪结果由调用方在变更回写分支同步持久化（见 buildMemoryFileChangeNotification）。
-                                if (memory.bound_files) {
-                                    memory.bound_files = memory.bound_files.filter(f => f !== filePath);
+                                const fileTrulyMissing = await this.verifyFileNotExist(resolvedPath);
+                                if (fileTrulyMissing) {
+                                    statuses.push({ path: filePath, status: 'not_found', serverMd5: oldMd5ForMissing });
+                                    changedFiles.push(`${filePath}（文件找不到 Server: ${oldMd5ForMissing}）`);
+                                    if (memory.bound_files) {
+                                        memory.bound_files = memory.bound_files.filter(f => f !== filePath);
+                                    }
+                                }
+                                else {
+                                    logger.info(`[McpServer] 文件存在但 MD5 计算失败（瞬态错误），跳过: ${filePath}`);
+                                    statuses.push({ path: filePath, status: 'no_change' });
                                 }
                             }
                             else {
-                                // 无该文件基线且文件不存在：标注找不到但不计入变更，避免对未知状态误报
-                                statuses.push({ path: filePath, status: 'not_found' });
+                                statuses.push({ path: filePath, status: 'no_change' });
                             }
-                            // 无该文件基线时静默跳过，避免对未知状态误报
                             continue;
                         }
                         newMd5Map[filePath] = currentMd5;
                         const oldMd5 = oldMd5Map[filePath];
                         if (!oldMd5) {
-                            // 该文件无可用基线（键缺失或空值）。常见原因：
-                            //   1) 新增到 bound_files 的文件尚未建基线；
-                            //   2) 历史 TS/Java 路径规范化不一致（如 Windows 反斜杠）导致键不匹配。
-                            // 静默建立基线，不视为变更，避免 md5 实际未变却误报需要更新。
                             statuses.push({ path: filePath, status: 'no_change' });
                             baselineRepaired = true;
                             logger.info(`[McpServer] 建立单文件基线: ${filePath} new=${currentMd5} (workspace=${workspacePath}, memory=${memory.uri})`);
                         }
                         else if (oldMd5 !== currentMd5) {
                             logger.info(`[McpServer] 文件变更: ${filePath} old=${oldMd5} new=${currentMd5} (workspace=${workspacePath})`);
-                            statuses.push({ path: filePath, status: 'content_changed' });
-                            changedFiles.push(`${filePath} (内容变更)`);
+                            statuses.push({ path: filePath, status: 'content_changed', localMd5: currentMd5, serverMd5: oldMd5 });
+                            changedFiles.push(`${filePath}（内容变更 本地: ${currentMd5} Server: ${oldMd5}）`);
                         }
                         else {
                             statuses.push({ path: filePath, status: 'no_change' });
@@ -2426,14 +2168,7 @@ export class McpServer {
                     }
                     catch (error) {
                         logger.info(`[McpServer] 计算文件 MD5 失败: ${filePath}`, error);
-                        const oldMd5ForError = oldMd5Map[filePath];
-                        if (oldMd5ForError) {
-                            statuses.push({ path: filePath, status: 'content_changed' });
-                            changedFiles.push(`${filePath} (MD5计算失败)`);
-                        }
-                        else {
-                            statuses.push({ path: filePath, status: 'no_change' });
-                        }
+                        statuses.push({ path: filePath, status: 'no_change' });
                     }
                 }
                 // 无基线时：更新 MD5 map 到 memory 对象（供调用方回写），但不计入变更
@@ -2502,17 +2237,14 @@ export class McpServer {
             return null;
         }
     }
-    /**
-     * 构建 Memory 文件变更通知的复合去重键。
-     * 基于 memoryId + 当前各绑定文件的 MD5 生成，当任意绑定文件内容变化时复合键也随之变化，
-     * 从而确保真实文件变更不会因简单 memoryId 去重而静默吞掉。
-     */
-    buildMemoryChangeNotificationKey(memoryId, md5Map) {
-        if (!md5Map || Object.keys(md5Map).length === 0) {
-            return memoryId;
+    async verifyFileNotExist(resolvedPath) {
+        try {
+            await fs.promises.access(resolvedPath, fs.constants.F_OK);
+            return false;
+        }
+        catch {
+            return true;
         }
-        const sorted = Object.entries(md5Map).sort(([a], [b]) => a.localeCompare(b));
-        return `${memoryId}:${sorted.map(([k, v]) => `${k}=${v}`).join('|')}`;
     }
     async handleGetMessage() {
         // 消息来源标记：
@@ -2795,13 +2527,6 @@ export class McpServer {
                     logger.warn("[McpServer] 租约已丢失（renewed=0），停止续期定时器");
                     this.stopLeaseRenewal();
                 }
-                // L-1: 主动清理 claimedCache 中的过期条目，避免堆积
-                const now = Date.now();
-                for (const [uri, expiry] of this.claimedCache) {
-                    if (expiry <= now) {
-                        this.claimedCache.delete(uri);
-                    }
-                }
             }
             catch (e) {
                 logger.warn('[McpServer] 续期租约失败: %s', e instanceof Error ? e.message : String(e));
@@ -2857,7 +2582,7 @@ export class McpServer {
                 if (statusReporter) {
                     statusReporter.reportWaitingInput();
                 }
-                await this.reportCombinedMemoryStats();
+                await this.reportMemoryStatsToServer();
                 // 注册成功后检查是否需要从本地恢复永久记忆到 server
                 // 触发条件：server 当前角色 memory 计数为 0（重部署后 DB 为空）
                 // 不依赖 isExisting / profileHandler，确保所有场景都能触发
@@ -2883,7 +2608,7 @@ export class McpServer {
                         if (statusReporter) {
                             statusReporter.reportWaitingInput();
                         }
-                        await this.reportCombinedMemoryStats();
+                        await this.reportMemoryStatsToServer();
                         return;
                     }
                     // 未启用降级模式，抛出异常