aws-runtime-bridge 1.9.79 → 1.9.80

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

@@ -1,2709 +1,38 @@
-/**
- * MCP Server 实现
- * 提供 MCP Tools 供 AI Agent 调用
- */
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { AgentClient } from "./agent-client.js";
-import { MCP_SERVER_NAME, MCP_SERVER_VERSION, REGISTER_MAX_RETRIES, REGISTER_RETRY_INTERVAL_MS, DEGRADED_MODE_ENABLED, DEGRADED_MODE_RETRY_INTERVAL_MS, DEGRADED_MODE_MAX_RETRIES, } from "./constants.js";
-import { logger } from "./logger.js";
-import { MCP_TOOLS, MEMORY_TOOL_NAMES } from "./mcp-tools.js";
-import { MessageBuffer } from "./message-buffer.js";
-import { ContextManager } from "./context-manager.js";
-import { MemoryCapacityError, MemoryStore, } from "./memory-store.js";
-import { ServerMemoryStore } from "./server-memory-store.js";
-const DEFAULT_MCP_HTTP_REQUEST_TIMEOUT_MS = 120_000;
-/**
- * poll_message 内部轮询间隔：每 30 秒在永久阻塞的 poll_message 中醒来一次，
- * 检查 WebSocket 缓冲区、Memory 通知（文件变更/TODO/容量等）。
- * 能主动通知的消息（WebSocket）实时响应，无法主动通知的状态变化最长 30s 延迟。
- * poll_message 永不超时返回空，只在有消息可返回时才退出。
- */
-const POLL_MESSAGE_INTERNAL_POLL_INTERVAL_MS = 30_000;
-const PATH_UNSAFE_CHARACTERS = new Set([
-    "<",
-    ">",
-    ":",
-    '"',
-    "/",
-    "\\",
-    "|",
-    "?",
-    "*",
-]);
-export class McpServer {
-    server;
-    agentClient;
-    messageBuffer;
-    memoryStore;
-    roleMemoryStore;
-    sessionContextMemoryStore;
-    initialRoleName = "";
-    /** 是否有真实的角色名（非 env 空值 fallback "default-role"） */
-    hasRoleName = false;
-    /** 上下文管理器 (v1.8.0) */
-    contextManager;
-    /** 子 Agent 模式：仅暴露 Memory 工具，拒绝非 Memory 工具调用 */
-    isSubAgent;
-    /**
-     * 租约续期定时器 (v1.21.0)。
-     * 每 60 秒续期一次当前 agent 持有的所有 updating memory 的租约。
-     */
-    leaseRenewalTimer = null;
-    activeLeaseUris = new Set();
-    static LEASE_DURATION_MINUTES = 10;
-    static LEASE_RENEW_INTERVAL_MS = 60_000;
-    /** profile 是否已同步（防止 activelySyncProfile 与 profileHandler 双重同步） */
-    profileSynced = false;
-    /**
-     * poll_message 单例控制：防止并发调用导致消息被第一个消费后第二个空等。
-     * 当已有 poll 在进行时，后续调用直接等待同一个 Promise。
-     */
-    pendingPollMessage = null;
-    // 系统提示词由 runtime adapter（ACode/OpenCode/Codex/Claude）在会话创建时注入，
-    // 无需通过 MCP 工具返回。三方 runtime（OpenCode/Claude）将三层提示词合并为一条 system prompt，
-    // ACode 则直接注入为前三条 system role 消息。
-    /**
-     * 收到 Profile 后同步角色存储路径。
-     * 当服务端返回的 roleName 与进程初始化时不一致时，重建 roleMemoryStore 指向正确的目录。
-     */
-    syncRoleMemoryStore(profile) {
-        logger.info(`[McpServer] syncRoleMemoryStore 被调用: displayName=${profile.displayName}, roleName="${profile.roleName ?? '(空)'}", id=${profile.id}`);
-        if (!profile.roleName) {
-            logger.warn(`[McpServer] syncRoleMemoryStore: profile.roleName 为空，hasRoleName 保持 false。profile=${JSON.stringify({ id: profile.id, displayName: profile.displayName, roleName: profile.roleName, instanceName: profile.instanceName })}`);
-            return;
-        }
-        const expectedRoleDir = McpServer.sanitizeRoleDirectoryName(profile.roleName);
-        this.hasRoleName = true; // Profile 确认了角色名
-        if (expectedRoleDir === this.initialRoleName) {
-            return;
-        }
-        logger.info(`[McpServer] 角色目录与初始值不一致，重建 roleMemoryStore: "${this.initialRoleName}" -> "${expectedRoleDir}"`);
-        this.roleMemoryStore = new MemoryStore(McpServer.buildRoleMemoryStorePath(expectedRoleDir));
-        this.initialRoleName = expectedRoleDir;
-    }
-    /**
-     * 在 profile 到达后检查是否需要将本地永久记忆同步到 server。
-     * 触发条件：当前角色在 server 上还没有任何 memory 类型记录（通常发生在重部署后 server DB 为空时）。
-     * 主流程：异步执行，不阻塞 profile 处理链路。
-     * 1. 调用 server get_memory_stats 获取当前角色 memory 类型计数
-     * 2. 若 count === 0，读取本地永久记忆（角色子目录 + 遗留父目录 fallback）
-     * 3. 逐条调用 server create_memory 写入（已存在则静默跳过）
-     */
-    maybeSyncPermanentMemoryToServer() {
-        this.doMaybeSyncPermanentMemoryToServer().catch((e) => {
-            logger.warn('[McpServer] maybeSyncPermanentMemoryToServer 异常: %s, stack=%s', e instanceof Error ? e.message : String(e), e instanceof Error ? e.stack : '(no stack)');
-        });
-    }
-    async doMaybeSyncPermanentMemoryToServer() {
-        logger.info("[McpServer] maybeSyncPermanentMemoryToServer 开始，initialRoleName="
-            + this.initialRoleName);
-        // Step 1: 检查 server 当前角色的 memory 计数
-        let stats;
-        try {
-            stats = await this.memoryStore.getStats();
-        }
-        catch (e) {
-            logger.warn("[McpServer] 获取 server 记忆统计失败，跳过同步:", e instanceof Error ? e.message : e);
-            return;
-        }
-        const memoryCount = stats.by_type["project_memory"]?.count ?? 0;
-        logger.info(`[McpServer] server memory 计数=${memoryCount}，`
-            + `是否需要同步=${memoryCount === 0}`);
-        if (memoryCount > 0) {
-            return;
-        }
-        // Step 2: 读取本地永久记忆
-        // 2a: 先读角色子目录
-        let localMemories = [];
-        try {
-            localMemories = await this.roleMemoryStore.listByType("project_memory");
-            logger.info(`[McpServer] 角色子目录读取到 ${localMemories.length} 条永久记忆`);
-        }
-        catch (e) {
-            logger.warn("[McpServer] 读取角色子目录永久记忆失败:", e instanceof Error ? e.message : e);
-        }
-        // 2b: 角色子目录为空时，fallback 读遗留父目录（旧版无角色子目录）
-        if (localMemories.length === 0) {
-            const legacyStorePath = path.dirname(McpServer.buildRoleMemoryStorePath(this.initialRoleName));
-            logger.info(`[McpServer] 尝试从遗留目录读取: ${legacyStorePath}`);
-            try {
-                const legacyStore = new MemoryStore(legacyStorePath);
-                const legacyMemories = await legacyStore.listByType("project_memory");
-                if (legacyMemories.length > 0) {
-                    logger.info(`[McpServer] 从遗留目录读取到 ${legacyMemories.length} 条永久记忆`);
-                    localMemories = legacyMemories;
-                }
-            }
-            catch (e) {
-                logger.warn("[McpServer] 读取遗留目录永久记忆失败:", e instanceof Error ? e.message : e);
-            }
-        }
-        if (localMemories.length === 0) {
-            logger.info("[McpServer] 本地也无永久记忆，跳过同步");
-            return;
-        }
-        // Step 3: 逐条写入 server
-        let synced = 0;
-        let skipped = 0;
-        for (const record of localMemories) {
-            try {
-                await this.memoryStore.createMemory({
-                    memory_type: "project_memory",
-                    uri: record.uri,
-                    title: record.title,
-                    content: record.content,
-                    keywords: record.keywords,
-                    bound_files: record.bound_files,
-                    file_md5_map: record.file_md5_map,
-                    last_check_time: record.last_check_time,
-                });
-                synced++;
-                logger.info(`[McpServer] 同步永久记忆成功: ${record.uri}`);
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                if (msg.includes("already exists")
-                    || msg.includes("Memory already exists")) {
-                    skipped++;
-                }
-                else {
-                    logger.warn(`[McpServer] 同步永久记忆失败 (${record.uri}): ${msg}`);
-                    skipped++;
-                }
-            }
-        }
-        logger.info(`[McpServer] 永久记忆同步完成: 成功 ${synced}, 跳过 ${skipped}, 共 ${localMemories.length}`);
-        await this.reportMemoryStatsToServer();
-    }
-    /**
-     * 规范化绑定的文件路径。
-     * 项目约定以下前缀都表示工作区根路径：
-     *   ./xxx → ./xxx (已是相对路径)
-     *   /xxx  → ./xxx (/ 视为工作区根路径)
-     *   @/xxx → ./xxx (@/ 视为工作区根路径别名)
-     *   xxx   → ./xxx (裸路径视为当前工作区相对)
-     */
-    normalizeBoundFilePath(filePath) {
-        const trimmed = String(filePath || "").trim().replace(/\\/g, "/");
-        if (!trimmed)
-            return trimmed;
-        // 去掉 @/ 前缀（@ 视为工作区根路径）
-        const noAt = trimmed.startsWith("@/") ? trimmed.substring(1) : trimmed;
-        if (noAt.startsWith("./"))
-            return noAt;
-        // /xxx 和 xxx 都统一成 ./xxx（与 Java normalizeBoundFilePath 保持一致，处理多前导斜杠）
-        return `./${noAt.replace(/^\/+/, "")}`;
-    }
-    /**
-     * 规范化绑定的文件路径数组。
-     */
-    normalizeBoundFiles(files) {
-        if (!files || !Array.isArray(files))
-            return files;
-        return files.map(f => this.normalizeBoundFilePath(String(f)));
-    }
-    /**
-     * 验证绑定文件是否存在。
-     * 主流程：规范化后的路径 -> 相对于工作区根路径解析 -> 逐文件检查是否存在 -> 汇总缺失列表并抛出错误。
-     */
-    async validateBoundFilesExist(boundFiles) {
-        if (!boundFiles || boundFiles.length === 0)
-            return;
-        const workspacePath = process.env.AWS_WORKSPACE_PATH || process.cwd();
-        const { access } = await import('node:fs/promises');
-        const missingFiles = [];
-        for (const filePath of boundFiles) {
-            try {
-                const resolvedPath = path.resolve(workspacePath, filePath);
-                await access(resolvedPath);
-            }
-            catch {
-                missingFiles.push(filePath);
-            }
-        }
-        if (missingFiles.length > 0) {
-            throw new Error(`绑定的文件不存在，请确认文件路径正确后再重新提交:\n${missingFiles.map(f => `  - ${f}`).join('\n')}`);
-        }
-    }
-    /**
-     * 记忆写入成功后的 MCP 响应 DTO。
-     * 主流程：保留定位与版本元数据，刻意不包含 content，避免 create/update 回显大段提交内容。
-     */
-    toMemoryWriteResult(record) {
-        return {
-            id: record.id,
-            uri: record.uri,
-            domain: record.domain,
-            path: record.path,
-            title: record.title,
-            memory_type: record.memory_type,
-            createdAt: record.createdAt,
-            updatedAt: record.updatedAt,
-            version: record.version,
-            keywords: record.keywords,
-            bound_files: record.bound_files,
-        };
-    }
-    /**
-     * 返回完整的 Memory 记录（包含元数据）。
-     * Memory 增强功能 (v1.6.0)
-     */
-    toMemoryRecordWithMetadata(record) {
-        return {
-            id: record.id,
-            uri: record.uri,
-            domain: record.domain,
-            path: record.path,
-            title: record.title,
-            content: record.content,
-            memory_type: record.memory_type,
-            createdAt: record.createdAt,
-            updatedAt: record.updatedAt,
-            version: record.version,
-            // Memory 增强字段
-            keywords: record.keywords,
-            bound_files: record.bound_files,
-            file_md5_map: record.file_md5_map,
-            memory_status: record.memory_status,
-            updating_agent_id: record.updating_agent_id,
-            last_check_time: record.last_check_time,
-        };
-    }
-    constructor() {
-        this.agentClient = new AgentClient();
-        this.messageBuffer = new MessageBuffer();
-        this.initialRoleName = McpServer.resolveRoleMemoryDirectoryName();
-        this.hasRoleName = !!process.env.AWS_ROLE_NAME; // 只有明确设置了 env 才认为有角色名
-        const memoryStorePaths = McpServer.resolveMemoryStorePaths();
-        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.isSubAgent = process.env.AWS_SUB_AGENT === "true";
-        this.contextManager = new ContextManager(this.sessionContextMemoryStore);
-        this.server = new Server({
-            name: MCP_SERVER_NAME,
-            version: MCP_SERVER_VERSION,
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            const tools = this.isSubAgent
-                ? MCP_TOOLS.filter((t) => MEMORY_TOOL_NAMES.has(t.name))
-                : MCP_TOOLS;
-            return { tools };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                const result = await this.handleToolCall(name, args);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                const errorPayload = error instanceof MemoryCapacityError
-                    ? {
-                        error: errorMessage,
-                        ...error.details,
-                    }
-                    : { error: errorMessage };
-                // 服务端记录完整异常，方便排查 LOST 等异常状态
-                logger.error('[McpServer] 工具调用异常: tool=%s, error=%s, stack=%s', name, errorMessage, error instanceof Error ? error.stack : '(no stack)');
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(errorPayload, null, 2),
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        });
-    }
-    /**
-     * 处理工具调用
-     */
-    async handleToolCall(name, args) {
-        // 子 agent 共享父 agent MCP 连接时注入的标记：
-        // 剥离后跳过状态上报，避免子 agent 事件出现在父 agent 时间线上
-        const isSubAgentCall = args?._aws_sub_agent === true;
-        // 委托等待循环中后续 poll_message 注入的标记：
-        // 跳过 reportToolUse/reportToolResult，只保留 reportThinking，
-        // 避免"调用MCP↔思考中"状态反复跳动
-        const isSilentPoll = args?._aws_silent_poll === true;
-        const cleanArgs = { ...args };
-        delete cleanArgs._aws_sub_agent;
-        delete cleanArgs._aws_silent_poll;
-        // 报告工具调用状态
-        // - 子 agent 调用：完全跳过（不污染父 agent 时间线）
-        // - 静默 poll：跳过 reportToolUse（不报"调用MCP"），但仍保留 statusReporter 供 reportThinking
-        const statusReporter = isSubAgentCall
-            ? null
-            : this.agentClient.getStatusReporter();
-        if (statusReporter && !isSilentPoll) {
-            statusReporter.reportToolUse(name, this.sanitizeToolUseArgs(name, cleanArgs));
-        }
-        try {
-            const result = await this.executeToolCall(name, cleanArgs);
-            // 工具调用完成后，先上报返回数据供时间线日志查看，再切换为思考状态
-            // （Agent 正在处理工具结果、决定下一步动作，而非真正的空闲等待）
-            if (statusReporter && !isSilentPoll) {
-                const reportableResult = this.stripAutoDelegateForReporting(result);
-                if (reportableResult !== null) {
-                    // 正常结果：上报 toolResult + thinking（工具调用完成，回到思考状态）
-                    statusReporter.reportToolResult(reportableResult);
-                    statusReporter.reportThinking();
-                }
-                // 委托消息（reportableResult === null）：跳过 reportToolResult 和 reportThinking，
-                // 保持 tool_using 状态。主 agent 仍在 poll_message 循环中等待真正的消息，
-                // 委托给子 agent 处理不应影响主 agent 的状态显示。
-            }
-            return result;
-        }
-        catch (error) {
-            // 工具调用失败，报告错误状态
-            if (statusReporter && !isSilentPoll) {
-                statusReporter.reportToolError(error);
-            }
-            throw error;
-        }
-    }
-    /**
-     * 执行具体的工具调用
-     */
-    async executeToolCall(name, args) {
-        if (this.isSubAgent && !MEMORY_TOOL_NAMES.has(name)) {
-            throw new Error(`Sub-agent is not allowed to call tool: ${name}`);
-        }
-        switch (name) {
-            case "get_colleague":
-                return await this.agentClient.discoverColleagues();
-            case "get_group_rooms":
-                return await this.agentClient.discoverGroupRooms();
-            case "get_profile": {
-                return await this.agentClient.getProfile();
-            }
-            case "hire_colleague":
-                return await this.handleHireColleague(args);
-            case "hire_colleagues_batch":
-                return await this.handleHireColleaguesBatch(args);
-            case "send_group":
-                return await this.handleSendGroup(args);
-            case "send_private":
-                return await this.handleSendPrivate(args);
-            case "poll_message":
-                return await this.handlePollMessage();
-            case "get_message":
-                return this.handleGetMessage();
-            case "get_dm_history":
-                return await this.handleGetDmHistory(args);
-            case "get_group_history":
-                return await this.handleGetGroupHistory(args);
-            case "my_task":
-                return await this.agentClient.getMyTasks();
-            case "create_task_instance_comment":
-                return await this.handleCreateTaskInstanceComment(args);
-            case "submit_task_result":
-                return await this.handleSubmitTaskResult(args);
-            case "start_task_rollback":
-                return await this.handleStartTaskRollback(args);
-            case "finish_task_rollback":
-                return await this.handleFinishTaskRollback(args);
-            case "reject_task":
-                return await this.handleRejectTask(args);
-            case "terminate_task":
-                return await this.handleTerminateTask(args);
-            case "create_memory":
-                return await this.handleCreateMemory(args);
-            case "read_memory":
-                return await this.handleReadMemory(args);
-            case "update_memory":
-                return await this.handleUpdateMemory(args);
-            case "delete_memory":
-                return await this.handleDeleteMemory(args);
-            case "search_memory":
-                return await this.handleSearchMemory(args);
-            case "list_memories":
-                return await this.handleListMemories(args);
-            case "get_memory_stats":
-                return await this.handleGetMemoryStats(args);
-            // Memory 增强功能工具 (v1.6.0)
-            case "list_memories_by_file":
-                return await this.handleListMemoriesByFile(args);
-            case "abandon_memory_update":
-                return await this.handleAbandonMemoryUpdate(args);
-            // Memory 近期记忆过期与回忆工具 (v1.11.0)
-            case "memory_recurrence":
-                return await this.handleMemoryRecurrence(args);
-            case "memory_recurrence_complete":
-                return await this.handleMemoryRecurrenceComplete();
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    }
-    // ============ 工具处理方法 ============
-    static MEMORY_TYPES = [
-        "recently_memory",
-        "agent_memory",
-        "project_memory",
-        "session_context",
-    ];
-    static MEMORY_TOOL_NAMES = new Set([
-        "create_memory",
-        "read_memory",
-        "update_memory",
-        "delete_memory",
-        "search_memory",
-        "list_memories",
-        "get_memory_stats",
-        // Memory 增强功能工具 (v1.6.0)
-        "list_memories_by_file",
-        "abandon_memory_update",
-        // Memory 近期记忆过期与回忆工具 (v1.11.0)
-        "memory_recurrence",
-        "memory_recurrence_complete",
-    ]);
-    /**
-     * 从 startPath 向上逐级查找 .agentswork 目录。
-     * 主流程：从 startPath 开始检查是否存在 .agentswork -> 递归父目录直到根目录 -> 如果找到返回完整路径，否则在 startPath 创建。
-     */
-    static findAgentsworkDirSync(startPath) {
-        let current = path.resolve(startPath);
-        while (true) {
-            if (fs.existsSync(path.join(current, ".agentswork"))) {
-                return path.join(current, ".agentswork");
-            }
-            const parent = path.dirname(current);
-            if (parent === current)
-                break; // 到达根目录
-            current = parent;
-        }
-        return path.join(path.resolve(startPath), ".agentswork");
-    }
-    /**
-     * 清理角色名中的非法路径字符，返回安全的目录名。
-     */
-    static sanitizeRoleDirectoryName(roleName) {
-        const safeRoleName = String(roleName || "")
-            .trim()
-            .split("")
-            .map((character) => PATH_UNSAFE_CHARACTERS.has(character) || character.charCodeAt(0) < 32
-            ? "_"
-            : character)
-            .join("")
-            .replace(/^\.+|\.+$/g, "")
-            .trim();
-        return safeRoleName || "default-role";
-    }
-    /**
-     * 解析角色级记忆目录名。
-     * 主流程：优先使用 AWS_ROLE_NAME，清理路径分隔符等非法字符，避免不同角色的长期 memory 混写。
-     */
-    static resolveRoleMemoryDirectoryName() {
-        return McpServer.sanitizeRoleDirectoryName(process.env.AWS_ROLE_NAME || "");
-    }
-    /**
-     * 根据 roleName 构建永久记忆存储路径。
-     */
-    static buildRoleMemoryStorePath(roleName) {
-        const workspacePath = process.env.AWS_WORKSPACE_PATH || process.cwd();
-        const agentsworkDir = McpServer.findAgentsworkDirSync(workspacePath);
-        return path.join(agentsworkDir, "memory", "memory", McpServer.sanitizeRoleDirectoryName(roleName));
-    }
-    /**
-     * 解析记忆存储路径。
-     * 主流程：recently_memory/agent_memory 走 server 数据库；长期 project_memory 默认写入项目 .agentswork/memory/memory/<roleName>/<domain>.json。
-     */
-    static resolveMemoryStorePaths() {
-        const configuredPath = String(process.env.AWS_MEMORY_STORE_PATH || "").trim();
-        if (configuredPath) {
-            return { instancePath: configuredPath, rolePath: configuredPath };
-        }
-        const workspacePath = process.env.AWS_WORKSPACE_PATH || process.cwd();
-        const agentsworkDir = McpServer.findAgentsworkDirSync(workspacePath);
-        const instancePath = String(process.env.AWS_INSTANCE_MEMORY_STORE_PATH || "").trim() ||
-            path.join(agentsworkDir, "memory", "server-managed");
-        const rolePath = String(process.env.AWS_ROLE_MEMORY_STORE_PATH || "").trim() ||
-            path.join(agentsworkDir, "memory", "memory", McpServer.resolveRoleMemoryDirectoryName());
-        return { instancePath, rolePath };
-    }
-    getRequiredString(args, key) {
-        const value = args[key];
-        if (typeof value !== "string" || value.trim().length === 0) {
-            throw new Error(`${key} is required`);
-        }
-        return value;
-    }
-    getOptionalString(args, key) {
-        const value = args[key];
-        return typeof value === "string" ? value : undefined;
-    }
-    getOptionalNumber(args, key) {
-        const value = args[key];
-        return typeof value === "number" ? value : undefined;
-    }
-    getOptionalStringArray(args, key) {
-        const value = args[key];
-        return Array.isArray(value) ? value.map((v) => String(v)) : undefined;
-    }
-    getOptionalMemoryType(args) {
-        const value = args.memory_type;
-        if (value === undefined) {
-            return undefined;
-        }
-        return this.parseMemoryType(value);
-    }
-    parseMemoryType(value) {
-        if (typeof value !== "string") {
-            throw new Error(`Invalid memory_type: ${String(value)}`);
-        }
-        const normalized = value.trim();
-        if (!this.isMemoryType(normalized)) {
-            throw new Error(`Invalid memory_type: ${value}`);
-        }
-        return normalized;
-    }
-    isMemoryType(value) {
-        return McpServer.MEMORY_TYPES.some((memoryType) => memoryType === value);
-    }
-    /**
-     * 所有类型的记忆统一走服务端（Server 是唯一权威源）。
-     * 本地 roleMemoryStore 仅用于 project_memory 的备份写入与启动恢复。
-     */
-    getMemoryStoreForType(_memoryType) {
-        return this.memoryStore;
-    }
-    /**
-     * 读取记忆：直接走服务端（Server 是唯一权威源）。
-     */
-    async readMemoryFromScopedStores(input) {
-        if (input.memory_type) {
-            return await this.memoryStore.readMemory(input);
-        }
-        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 record = await this.memoryStore.readMemory({
-                uri: input.uri,
-                memory_type: "project_memory",
-            });
-            if (record) {
-                await this.roleMemoryStore.deleteMemory({ uri: input.uri, memory_type: "project_memory" }).catch(() => { });
-                await this.roleMemoryStore.createMemory(record);
-            }
-        }
-        catch (e) {
-            logger.warn("[McpServer] backupProjectMemoryToLocal 失败: uri=%s", input.uri, e);
-        }
-    }
-    /**
-     * 删除 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);
-        }
-    }
-    /**
-     * 定位可更新/删除的存储：统一走服务端。
-     */
-    async findMemoryStoreForMutation(input) {
-        if (input.memory_type) {
-            return { store: this.memoryStore, memory_type: input.memory_type };
-        }
-        const serverLongTerm = await this.memoryStore.readMemory({
-            uri: input.uri,
-            memory_type: "project_memory",
-        }).catch(() => null);
-        if (serverLongTerm) {
-            return { store: this.memoryStore, memory_type: "project_memory" };
-        }
-        return { store: this.memoryStore };
-    }
-    async reportMemoryStatsToServer() {
-        const stats = await this.memoryStore.getStats();
-        try {
-            await this.agentClient.reportMemoryStats(stats);
-        }
-        catch (error) {
-            logger.warn("[McpServer] 上报 memory 统计失败:", error);
-        }
-    }
-    /**
-     * 系统提示词由 runtime adapter 在会话创建时注入，MCP 层面不再负责返回。
-     * 详见 startListeningInternal -> profileHandler 中的合并注入逻辑。
-     *
-     * @deprecated 启动记忆不再通过 MCP 的 systemMessages 返回。
-     *   三方 runtime（OpenCode/Claude）在 adapter 层将三层提示词合并为一条 system prompt；
-     *   ACode 则直接注入为前三条 system role 消息。
-     */
-    /**
-     * 生成安全的工具状态上报参数。
-     * 主流程：memory 工具只上报元数据，避免 content/query/old_string/new_string/append 离开本地记忆边界。
-     */
-    sanitizeToolUseArgs(name, args) {
-        if (!McpServer.MEMORY_TOOL_NAMES.has(name)) {
-            return args;
-        }
-        const sanitized = {};
-        const uri = this.getOptionalString(args, "uri");
-        const memoryType = this.getOptionalString(args, "memory_type");
-        const limit = this.getOptionalNumber(args, "limit");
-        if (uri) {
-            sanitized.uri = uri;
-        }
-        if (memoryType) {
-            sanitized.memory_type = memoryType;
-        }
-        if (typeof limit === "number") {
-            sanitized.limit = limit;
-        }
-        if (name === "search_memory") {
-            sanitized.queryProvided =
-                typeof args.query === "string" && args.query.length > 0;
-            if (args.keyword_mode !== undefined) {
-                sanitized.keyword_mode = args.keyword_mode;
-            }
-        }
-        return sanitized;
-    }
-    /**
-     * 过滤工具返回结果中的 _acodeAutoDelegate 消息，避免自动委托通知
-     * （memory 文件变更/过期/容量整理）作为工具返回数据泄露到时间线。
-     *
-     * 背景：ACode 运行时在 processMemoryAutoDelegates 中拦截这些消息并 spawn
-     * 子 agent 处理，主 agent 不会感知。但 MCP server 的 statusReporter 在
-     * 拦截之前就已上报原始结果，Java 后端 AgentEventService 会将含 actionResult
-     * 的状态事件持久化并通过 AGENT_EVENTS_DELTA 推送到 dashboard 时间线，
-     * 导致本应被隐藏的委托通知暴露给用户。
-     *
-     * 返回 null 表示结果全部为委托消息，应跳过 reportToolResult
-     * （由 ACode 运行时在拦截后上报最终结果）。
-     */
-    stripAutoDelegateForReporting(result) {
-        if (!result || typeof result !== "object") {
-            return result;
-        }
-        const pollResult = result;
-        const directMessages = Array.isArray(pollResult.directMessages)
-            ? pollResult.directMessages
-            : [];
-        const groupMessages = Array.isArray(pollResult.groupMessages)
-            ? pollResult.groupMessages
-            : [];
-        const isDelegate = (m) => !!m &&
-            typeof m === "object" &&
-            "_acodeAutoDelegate" in m;
-        const hasDelegate = directMessages.some(isDelegate);
-        if (!hasDelegate) {
-            return result;
-        }
-        const remainingDm = directMessages.filter((m) => !isDelegate(m));
-        if (remainingDm.length === 0 && groupMessages.length === 0) {
-            return null;
-        }
-        return { ...pollResult, directMessages: remainingDm };
-    }
-    /**
-     * 创建本地记忆。
-     * 主流程：校验必填字段 -> 交给 MemoryStore 规范化 URI 和类型 -> 返回不含 content 的写入结果。
-     */
-    async handleCreateMemory(args) {
-        const boundFiles = this.normalizeBoundFiles(this.getOptionalStringArray(args, "bound_files"));
-        // 验证绑定文件是否存在，避免创建无有效文件绑定的记忆
-        await this.validateBoundFilesExist(boundFiles);
-        // 创建时即计算绑定文件的 MD5 基线，避免首次文件变更检测产生假阳性
-        let fileMd5Map;
-        let lastCheckTime;
-        if (boundFiles && boundFiles.length > 0) {
-            fileMd5Map = {};
-            for (const f of boundFiles) {
-                const md5 = await this.calculateFileMd5(f);
-                if (md5)
-                    fileMd5Map[f] = md5;
-            }
-            lastCheckTime = new Date().toISOString();
-        }
-        const input = {
-            memory_type: this.parseMemoryType(this.getRequiredString(args, "memory_type")),
-            uri: this.getRequiredString(args, "uri"),
-            title: this.getOptionalString(args, "title"),
-            content: this.getRequiredString(args, "content"),
-            keywords: this.getOptionalStringArray(args, "keywords"),
-            bound_files: boundFiles,
-            file_md5_map: fileMd5Map,
-            last_check_time: lastCheckTime,
-        };
-        const created = await this.memoryStore.createMemory(input);
-        if (input.memory_type === "project_memory") {
-            this.backupProjectMemoryToLocal(input).catch((e) => {
-                logger.warn("[McpServer] 备份 project_memory 到本地失败:", e);
-            });
-        }
-        await this.reportMemoryStatsToServer();
-        // v1.13.0: recently_memory 过期判定、agent_memory 过期/回忆状态由服务端 memory_status 字段管理，
-        // 无需 TS 侧本地缓存。服务端默认按类型填充正确状态（recently_memory='normal', agent_memory='normal'）。
-        return this.toMemoryWriteResult(created);
-    }
-    /**
-     * 读取本地记忆。
-     * 主流程：按 uri 读取；如果传入 memory_type，则由 MemoryStore 执行类型一致性校验。
-     */
-    async handleReadMemory(args) {
-        const input = {
-            uri: this.getRequiredString(args, "uri"),
-            memory_type: this.getOptionalMemoryType(args),
-        };
-        return await this.readMemoryFromScopedStores(input);
-    }
-    /**
-     * 更新本地记忆。
-     * 主流程：精确替换/追加/仅状态更新 -> MemoryStore 执行变更和版本递增 -> 返回不含 content 的写入结果。
-     * 支持三种写法：1) 精确替换（old_string + new_string）；2) 追加（append）；3) 无内容更新（仅传 uri，
-     * 用于过期续期、刷新绑定文件 MD5、释放 updating 状态等场景）。
-     */
-    async handleUpdateMemory(args) {
-        const hasReplace = typeof args.old_string === "string" ||
-            typeof args.new_string === "string";
-        const hasCompleteReplace = typeof args.old_string === "string" &&
-            typeof args.new_string === "string";
-        const append = this.getOptionalString(args, "append");
-        if (hasReplace && !hasCompleteReplace) {
-            throw new Error("old_string and new_string must be provided together");
-        }
-        // 允许无内容更新：当未提供 old_string/new_string 且未提供有效 append 时，
-        // 视为"仅状态更新"——用于过期续期、刷新绑定文件 MD5、释放 updating 状态等场景。
-        // 此时内容不变，但会重算绑定文件 MD5 并续期（expirable 类型）。
-        const input = {
-            uri: this.getRequiredString(args, "uri"),
-            memory_type: this.getOptionalMemoryType(args),
-            title: this.getOptionalString(args, "title"),
-            old_string: this.getOptionalString(args, "old_string"),
-            new_string: this.getOptionalString(args, "new_string"),
-            append,
-            keywords: this.getOptionalStringArray(args, "keywords"),
-            bound_files: this.normalizeBoundFiles(this.getOptionalStringArray(args, "bound_files")),
-        };
-        const target = await this.findMemoryStoreForMutation(input);
-        // 读取当前记忆以获取 bound_files，用于 MD5 重算
-        const existingForMd5 = await target.store.readMemory({
-            uri: input.uri,
-            memory_type: target.memory_type ?? input.memory_type,
-        });
-        // 校验绑定文件存在性：
-        // - 如果提供了新的 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;
-        let lastCheckTime;
-        if (effectiveBoundFiles && effectiveBoundFiles.length > 0) {
-            fileMd5Map = {};
-            for (const f of effectiveBoundFiles) {
-                const md5 = await this.calculateFileMd5(f);
-                if (md5)
-                    fileMd5Map[f] = md5;
-            }
-            lastCheckTime = new Date().toISOString();
-        }
-        const updated = await target.store.updateMemory({
-            ...input,
-            memory_type: target.memory_type ?? input.memory_type,
-            file_md5_map: fileMd5Map,
-            last_check_time: lastCheckTime,
-        });
-        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.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.activeLeaseUris.delete(input.uri);
-                if (this.activeLeaseUris.size === 0) {
-                    this.stopLeaseRenewal();
-                }
-            }
-            catch (e) {
-                logger.warn('[McpServer] 释放 memory claim 失败: uri=%s, error=%s', input.uri, e instanceof Error ? e.message : String(e));
-            }
-        }
-        return this.toMemoryWriteResult(updated);
-    }
-    /**
-     * 删除本地记忆。
-     * 主流程：按 uri 删除；如果传入 memory_type，则先校验分类，最后返回 deleted 布尔值。
-     */
-    async handleDeleteMemory(args) {
-        const singleUri = typeof args.uri === "string" ? args.uri : undefined;
-        const memoriesArray = Array.isArray(args.memories)
-            ? args.memories
-            : undefined;
-        // uri 与 memories 互斥校验
-        if (singleUri && memoriesArray && memoriesArray.length > 0) {
-            throw new Error("delete_memory 不支持同时传入 uri 和 memories，请二选一");
-        }
-        if (!singleUri && (!memoriesArray || memoriesArray.length === 0)) {
-            throw new Error("delete_memory 需要 uri 或 memories 参数");
-        }
-        // 单条路径：保持原返回结构 { deleted: boolean }，向后兼容
-        if (singleUri) {
-            const memory_type = this.getOptionalMemoryType(args);
-            const deleted = await this.deleteMemorySingle(singleUri, memory_type);
-            return { deleted };
-        }
-        // 批量路径：逐条删除，每条独立 memory_type
-        let deletedCount = 0;
-        const notFound = [];
-        const failed = [];
-        for (let i = 0; i < memoriesArray.length; i++) {
-            const item = memoriesArray[i];
-            if (typeof item !== "object" || item === null) {
-                failed.push({ uri: String(item), reason: `memories[${i}] 不是对象` });
-                continue;
-            }
-            const obj = item;
-            const uri = typeof obj.uri === "string" ? obj.uri : "";
-            if (!uri) {
-                failed.push({ uri: "", reason: `memories[${i}].uri 缺失` });
-                continue;
-            }
-            const memory_type = typeof obj.memory_type === "string"
-                ? this.parseMemoryType(obj.memory_type)
-                : undefined;
-            try {
-                const deleted = await this.deleteMemorySingle(uri, memory_type, /* skipStats */ true);
-                if (deleted) {
-                    deletedCount++;
-                }
-                else {
-                    notFound.push(uri);
-                }
-            }
-            catch (e) {
-                failed.push({ uri, reason: e instanceof Error ? e.message : String(e) });
-            }
-        }
-        if (deletedCount > 0) {
-            await this.reportMemoryStatsToServer();
-        }
-        return {
-            deleted: deletedCount,
-            not_found: notFound,
-            failed,
-        };
-    }
-    /**
-     * 删除单条记忆的内部辅助方法。
-     * - skipStats=true 时跳过 reportMemoryStatsToServer 调用，由批量调用方统一上报一次。
-     * - 返回 true/false 表示是否实际删除（与 store.deleteMemory 一致）。
-     */
-    async deleteMemorySingle(uri, memory_type, skipStats = false) {
-        const input = { uri, memory_type };
-        const target = await this.findMemoryStoreForMutation(input);
-        const effectiveType = target.memory_type ?? input.memory_type;
-        const deleted = await target.store.deleteMemory({
-            ...input,
-            memory_type: effectiveType,
-        });
-        if (deleted) {
-            if (effectiveType === "project_memory") {
-                this.removeProjectMemoryLocalBackup(uri).catch((e) => {
-                    logger.warn("[McpServer] 删除 project_memory 本地备份失败:", e);
-                });
-            }
-            if (!skipStats) {
-                await this.reportMemoryStatsToServer();
-            }
-        }
-        return deleted;
-    }
-    /**
-     * 搜索本地记忆与子 Agent 记忆（父子 Agent 可见性）。
-     * 主流程：解析 scope -> own(默认)仅搜自己 -> children仅搜子Agent的file-scoped记忆 -> all合并。
-     * 子 Agent 判定规则：同项目且工作区路径为当前路径子目录。
-     */
-    async handleSearchMemory(args) {
-        const rawScope = this.getOptionalString(args, "scope");
-        const scope = rawScope === "children" || rawScope === "all" ? rawScope : "own";
-        const rawKeywordMode = this.getOptionalString(args, "keyword_mode");
-        const keywordMode = rawKeywordMode === "all" ? "all" : rawKeywordMode === "any" ? "any" : undefined;
-        const input = {
-            query: this.getRequiredString(args, "query"),
-            limit: this.getOptionalNumber(args, "limit"),
-            memory_type: this.getOptionalMemoryType(args),
-            keywords: this.getOptionalStringArray(args, "keywords"),
-            keyword_mode: keywordMode,
-            scope,
-        };
-        // scope='children': 仅搜索子 Agent 的 file-scoped 记忆（通过 server 代理）
-        if (scope === "children") {
-            return await this.memoryStore.searchMemory(input);
-        }
-        // 搜索自己的记忆（scope='own' 默认行为）
-        const ownResult = await this.searchOwnMemories(input);
-        // scope='own': 仅返回自己的结果
-        if (scope === "own") {
-            return ownResult;
-        }
-        // scope='all': 合并自己的记忆与子 Agent 的 file-scoped 记忆
-        const childResult = await this.memoryStore.searchMemory({
-            ...input,
-            scope: "children",
-        });
-        return this.mergeSearchResults(ownResult, childResult, input.limit);
-    }
-    /**
-     * 搜索自己工作区的所有记忆。
-     * 具体逻辑：按 memory_type 分流 -> 无类型时合并 roleMemoryStore(永久)与 memoryStore(recently/agent)。
-     */
-    async searchOwnMemories(input) {
-        return await this.memoryStore.searchMemory(input);
-    }
-    /**
-     * 合并两组搜索结果，按 uri 去重、更新时间排序。
-     * 具体逻辑：own 结果优先 -> 补充 child 结果中 uri 不重复的 -> 排序 -> 截断到 limit。
-     */
-    mergeSearchResults(own, child, limit) {
-        const seen = new Set();
-        const maxResults = typeof limit === "number" && limit > 0 ? limit : 10;
-        const merged = [...own.results, ...child.results]
-            .filter((record) => {
-            const key = record.uri;
-            if (seen.has(key)) {
-                return false;
-            }
-            seen.add(key);
-            return true;
-        })
-            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
-            .slice(0, maxResults);
-        return { query: own.query || child.query, results: merged };
-    }
-    /**
-     * 列出短期类型记忆。
-     * 主流程：只允许 recently_memory/agent_memory，拒绝 project_memory（永久记忆仅通过 search 检索）。
-     * MemoryStore.listByType 内部仍允许 project_memory 供文件变更检测使用，但 MCP 层面不暴露给 Agent。
-     */
-    async handleListMemories(args) {
-        const memoryType = this.getRequiredString(args, "memory_type");
-        if (memoryType === "project_memory" || memoryType === "session_context") {
-            throw new Error(`Invalid memory_type: ${memoryType}`);
-        }
-        return await this.memoryStore.listByType(memoryType);
-    }
-    /**
-     * 获取本地记忆容量统计。
-     * 主流程：读取 MemoryStore 统计结果，供 Agent 在创建前判断 listable/type 容量。
-     */
-    async handleGetMemoryStats(args) {
-        const stats = await this.memoryStore.getStats();
-        const memoryType = this.getOptionalMemoryType(args);
-        if (!memoryType) {
-            return stats;
-        }
-        return {
-            memory_type: memoryType,
-            total: stats.by_type[memoryType].count,
-            by_type: {
-                [memoryType]: stats.by_type[memoryType],
-            },
-        };
-    }
-    /**
-     * 按文件查询绑定了该文件的 Memory
-     * Memory 增强功能 (v1.6.0)
-     */
-    /**
-     * 按文件路径查询 Memory（支持 scope 跨 Agent 搜索）。
-     * 主流程：解析scope -> own(默认)仅自己 -> children搜索子Agent -> all合并。
-     * 子 Agent 搜索同时走两条路径：
-     *   1. server searchChildByFilePath（查 DB）
-     *   2. 本地文件系统扫描 child .agentswork/memory/memory/（查本地永久记忆文件）
-     * 两条路径结果按 id 去重合并，确保无论子 Agent 的永久记忆是否已同步到
-     * 服务端数据库，父 Agent 都能搜索到。
-     */
-    async handleListMemoriesByFile(args) {
-        const rawPath = this.getRequiredString(args, "file_path");
-        const normalizedPath = this.normalizeBoundFilePath(rawPath);
-        const memoryType = this.getOptionalMemoryType(args);
-        const rawScope = this.getOptionalString(args, "scope");
-        // 默认 scope='all'：合并搜索自身与子Agent绑定文件的记忆
-        const scope = rawScope === "own" || rawScope === "children" ? rawScope : "all";
-        const fetchChildMemories = async () => {
-            return await this.memoryStore.listByFile(normalizedPath, {
-                memory_type: memoryType,
-                scope: "children",
-            }).catch(() => []);
-        };
-        if (scope === "children") {
-            const childResult = await fetchChildMemories();
-            return {
-                file_path: normalizedPath,
-                count: childResult.length,
-                memories: childResult.map(m => this.toMemoryRecordWithMetadata(m)),
-            };
-        }
-        // 搜索自己的记忆
-        const ownMemories = await this.collectOwnMemoriesByFile(normalizedPath, memoryType);
-        if (scope === "own") {
-            return {
-                file_path: normalizedPath,
-                count: ownMemories.length,
-                memories: ownMemories.map(m => this.toMemoryRecordWithMetadata(m)),
-            };
-        }
-        // scope='all': 合并自己的 + 子 Agent 的（server + 本地双路径已由 fetchChildMemories 聚合）
-        const childResult = await fetchChildMemories();
-        const seen = new Set(ownMemories.map(m => m.id));
-        const merged = [...ownMemories];
-        for (const m of childResult) {
-            if (!seen.has(m.id)) {
-                merged.push(m);
-                seen.add(m.id);
-            }
-        }
-        merged.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-        return {
-            file_path: normalizedPath,
-            count: merged.length,
-            memories: merged.map(m => this.toMemoryRecordWithMetadata(m)),
-        };
-    }
-    /**
-     * 按 id 去重合并两批 MemoryRecord，按 updatedAt 倒序排列。
-     * 首批（left）优先级高，其 id 会标记为 seen，重复的 right 项被丢弃。
-     */
-    mergeIdDedupe(left, right) {
-        const seen = new Set();
-        for (const m of left) {
-            if (m.id)
-                seen.add(m.id);
-        }
-        const merged = [...left];
-        for (const m of right) {
-            if (m.id && !seen.has(m.id)) {
-                merged.push(m);
-                seen.add(m.id);
-            }
-        }
-        merged.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-        return merged;
-    }
-    /**
-     * 通过文件系统扫描子 Agent 的 .agentswork 目录，
-     * 读取永久记忆 JSON 文件，按 path_prefix 匹配 bound_files。
-     *
-     * 主流程：
-     * 1. 解析 file_path（如 ./frontend/src/main.ts）的路径层级
-     * 2. 逐级（从长到短）找到子 Agent 的 .agentswork 目录
-     * 3. 读取该目录下所有 role 的 JSON 文件
-     * 4. 对每条记忆，将 bound_files 与 child-relative 路径比较
-     *
-     * 作为 server searchChildByFilePath 的本地补充，
-     * 确保子 Agent 的本地永久记忆（未同步到 server）也能被搜索到。
-     */
-    async searchChildMemoriesByFileLocal(filePath, memoryType) {
-        const workspacePath = process.env.AWS_WORKSPACE_PATH || process.cwd();
-        const normalizedFilePath = this.normalizeBoundFilePath(filePath);
-        // 解析路径 segments
-        // 例如 ./frontend/src/main.ts → relativePath = "frontend/src/main.ts"
-        //     segments = ["frontend", "src", "main.ts"]
-        const relativePath = normalizedFilePath.startsWith('./')
-            ? normalizedFilePath.substring(2)
-            : normalizedFilePath;
-        const segments = relativePath.split('/');
-        const results = [];
-        const seenById = new Set();
-        const { access, readdir, readFile } = await import('node:fs/promises');
-        // 从最长的路径前缀开始尝试（兼容嵌套子 Agent：深度=2 时 prefix=frontend/src）
-        for (let depth = segments.length - 1; depth >= 1; depth--) {
-            const prefixSegments = segments.slice(0, depth);
-            const childRelativeSegments = segments.slice(depth);
-            const childRelativePath = './' + childRelativeSegments.join('/');
-            // 子 Agent 的候选工作区路径
-            const childWorkspace = path.join(workspacePath, ...prefixSegments);
-            // 跳过父 Agent 自身（避免把 parent 当 child 扫）
-            if (childWorkspace === workspacePath)
-                continue;
-            const childAgentsworkDir = path.join(childWorkspace, '.agentswork');
-            // 检查 .agentswork 是否存在
-            try {
-                await access(childAgentsworkDir);
-            }
-            catch {
-                continue; // 这个前缀不是子 Agent 工作区
-            }
-            // 读取子 Agent 的永久记忆目录 .agentswork/memory/memory/<roleName>/
-            const memoryBaseDir = path.join(childAgentsworkDir, 'memory', 'memory');
-            let roleDirs;
-            try {
-                const entries = await readdir(memoryBaseDir, { withFileTypes: true });
-                roleDirs = entries.filter(e => e.isDirectory()).map(e => e.name);
-            }
-            catch {
-                continue;
-            }
-            for (const roleDir of roleDirs) {
-                const rolePath = path.join(memoryBaseDir, roleDir);
-                let files;
-                try {
-                    files = await readdir(rolePath);
-                }
-                catch {
-                    continue;
-                }
-                for (const file of files) {
-                    if (!file.endsWith('.json'))
-                        continue;
-                    const jsonPath = path.join(rolePath, file);
-                    let content;
-                    try {
-                        content = await readFile(jsonPath, 'utf-8');
-                    }
-                    catch {
-                        continue;
-                    }
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(content);
-                    }
-                    catch {
-                        continue;
-                    }
-                    if (!parsed.by_uri)
-                        continue;
-                    // 遍历该 domain 的所有记忆，匹配 bound_files
-                    for (const [uri, record] of Object.entries(parsed.by_uri)) {
-                        if (!record)
-                            continue;
-                        const recordId = record.id || uri;
-                        if (seenById.has(recordId))
-                            continue;
-                        if (memoryType && record.memory_type !== memoryType)
-                            continue;
-                        if (record.bound_files && record.bound_files.length > 0) {
-                            const matched = record.bound_files.some(bf => this.normalizeBoundFilePath(bf) === childRelativePath);
-                            if (matched) {
-                                seenById.add(recordId);
-                                results.push({
-                                    ...record,
-                                    uri: record.uri || uri,
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        results.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-        return results;
-    }
-    /**
-     * 按文件路径搜索本 Agent 的记忆。
-     * 同时查询临时记忆(server)和永久记忆(local roleMemoryStore)。
-     */
-    async collectOwnMemoriesByFile(filePath, memoryType) {
-        return await this.memoryStore.listByFile(filePath, {
-            memory_type: memoryType,
-        });
-    }
-    /**
-     * 放弃 Memory 更新状态 (v1.21.0 改为走 release API)
-     * Memory 增强功能 (v1.6.0)
-     */
-    async handleAbandonMemoryUpdate(args) {
-        const uri = this.getRequiredString(args, "uri");
-        const memoryType = this.getOptionalMemoryType(args);
-        // 关闭更新前先读取记忆，校验已绑定文件的存在性。
-        // 若存在已删除的文件，放弃更新将失败——Agent 需先通过 update_memory 修正 bound_files 列表
-        // （移除不存在的文件）后，由 update_memory 自动释放 claim。
-        const record = await this.memoryStore.readMemory({ uri, memory_type: memoryType });
-        if (record?.bound_files && record.bound_files.length > 0) {
-            await this.validateBoundFilesExist(record.bound_files);
-        }
-        // 调 Server release API 释放 claim
-        await this.memoryStore.releaseMemoryClaim(uri);
-        if (record?.memory_type === 'project_memory') {
-            this.backupProjectMemoryToLocal({ uri, memory_type: 'project_memory' }).catch((e) => {
-                logger.info(`[McpServer] abandon_memory_update: 同步本地备份失败: ${uri}`, e);
-            });
-        }
-        this.activeLeaseUris.delete(uri);
-        if (this.activeLeaseUris.size === 0) {
-            this.stopLeaseRenewal();
-        }
-        return {
-            success: true,
-            uri,
-            message: "Memory 更新状态已清除",
-        };
-    }
-    // ============ Memory 近期记忆过期与回忆工具处理 (v1.11.0 / v1.13.0 / v1.19.0) ============
-    // v1.13.0: 过期判定与 recalling 状态标记已统一迁移到服务端 memory_status 字段，
-    // 下方两个工具方法直接调用服务端接口，不再依赖任何本地元数据。
-    // v1.19.0: recently_memory 纳入过期回忆流程，与 agent_memory 行为完全一致。
-    /**
-     * 处理 memory_recurrence 工具调用。
-     * 主流程：调用服务端 list_expired_memories 拉取已过期的 recently_memory / agent_memory ->
-     * 按过期时间排序（最早优先）-> 取前 limit 条 ->
-     * 仅标记这 limit 条为「回忆中」状态 -> 返回这些记忆及剩余数量。
-     */
-    async handleMemoryRecurrence(args) {
-        // v1.13.0: 过期判定与 recalling 状态全部由服务端管理
-        // v1.19.0: recently_memory 同样纳入过期回忆流程
-        const limit = Math.max(1, args?.limit ?? 10);
-        const expiredMemories = await this.memoryStore.listExpiredRecentlyMemories();
-        if (expiredMemories.length === 0) {
-            return {
-                memories: [],
-                count: 0,
-                remaining: 0,
-                totalExpired: 0,
-                message: "没有待回忆的即将遗忘记忆。",
-            };
-        }
-        // 按过期时间排序（最早过期优先）并取前 limit 条
-        // 使用 Date.getTime() 确保无论日期格式（UTC/本地时间）都能正确排序
-        const sorted = [...expiredMemories].sort((a, b) => {
-            const aTime = new Date(a.expiresAt || a.createdAt || 0).getTime();
-            const bTime = new Date(b.expiresAt || b.createdAt || 0).getTime();
-            return aTime - bTime;
-        });
-        const batch = sorted.slice(0, limit);
-        // 仅标记这一批为 recalling 状态（服务端）
-        const batchUris = batch.map(m => m.uri);
-        try {
-            await this.memoryStore.markExpiredMemoriesRecalling(batchUris);
-        }
-        catch (e) {
-            logger.warn('[McpServer] 标记过期记忆为 recalling 失败: uriCount=%s, error=%s', batchUris.length, e instanceof Error ? e.message : String(e));
-        }
-        const remaining = Math.max(0, expiredMemories.length - batch.length);
-        // 返回过期记忆的摘要（不含完整 content 以减少上下文占用）
-        const memorySummaries = batch.map(m => ({
-            uri: m.uri,
-            title: m.title,
-            domain: m.domain,
-            path: m.path,
-            memory_status: 'recalling',
-            contentPreview: typeof m.content === 'string' && m.content.length > 200 ? m.content.substring(0, 200) + '...' : m.content,
-            createdAt: m.createdAt,
-            updatedAt: m.updatedAt,
-        }));
-        return {
-            memories: memorySummaries,
-            count: batch.length,
-            limit: limit,
-            remaining: remaining,
-            totalExpired: expiredMemories.length,
-            message: remaining > 0
-                ? `本次处理 ${batch.length} 条即将遗忘的记忆（最早过期优先），剩余 ${remaining} 条待处理。\n` +
-                    `请审查后决定（update_memory 续期，TTL ×2 / 不处理），\n` +
-                    `完成后调用 memory_recurrence_complete 清理，再调 memory_recurrence 处理下一批。`
-                : `已处理全部 ${batch.length} 条即将遗忘的记忆。\n` +
-                    `请审查后决定（update_memory 续期，TTL ×2 / 不处理），\n` +
-                    `完成后调用 memory_recurrence_complete 清理。`,
-        };
-    }
-    /**
-     * 处理 memory_recurrence_complete 工具调用。
-     * 主流程：调用服务端 clear_recalling_expired_memories 删除所有「recalling + 已过期」记录。
-     */
-    async handleMemoryRecurrenceComplete() {
-        // v1.13.0: 删除操作由服务端完成
-        let result = { deleted: 0, uris: [] };
-        try {
-            result = await this.memoryStore.clearRecallingExpiredMemories();
-        }
-        catch (e) {
-            logger.warn('[McpServer] 清理回忆中记忆失败: %s', e instanceof Error ? e.message : String(e));
-        }
-        await this.reportMemoryStatsToServer();
-        const deletedCount = result.deleted ?? 0;
-        return {
-            deleted: deletedCount,
-            uris: result.uris ?? [],
-            message: deletedCount === 0
-                ? "没有待疏理的回忆中记忆。"
-                : `已清理 ${deletedCount} 条已过期近期记忆。`,
-        };
-    }
-    /**
-     * 获取最近的消息历史用于压缩。
-     * 主流程：获取未读消息 + 历史消息 -> 合并排序 -> 返回。
-     */
-    async fetchRecentMessages() {
-        const [dmHistory, groupHistory] = await Promise.all([
-            this.agentClient.getDmHistory(undefined, 200).catch(() => ({ messages: [], count: 0 })),
-            this.agentClient.getGroupHistory(200).catch(() => ({ messages: [], count: 0 })),
-        ]);
-        const messages = [
-            ...dmHistory.messages,
-            ...groupHistory.messages,
-        ];
-        messages.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-        return messages;
-    }
-    async handleSendGroup(args) {
-        if (!args.content || typeof args.content !== "string") {
-            throw new Error("content is required");
-        }
-        // 记录 token 消耗 (v1.8.0)
-        this.recordMessageTokenUsage(args.content).catch((err) => logger.warn("[McpServer] Failed to record token usage", err));
-        return await this.agentClient.sendGroupMessage(args.content, args.projectName, args.roomId);
-    }
-    /**
-     * 记录消息发送产生的 token 消耗。
-     * 主流程：估算内容 token -> 获取会话 ID -> 记录到 ContextManager。
-     */
-    async recordMessageTokenUsage(content) {
-        try {
-            const profile = await this.agentClient.getProfile().catch(() => null);
-            if (!profile?.runtimeSessionId)
-                return;
-            const estimatedTokens = this.contextManager.estimateTokens(content);
-            await this.contextManager.recordUsage(profile.runtimeSessionId, { input: 0, output: estimatedTokens });
-        }
-        catch {
-            // 非关键功能，静默失败
-        }
-    }
-    async handleHireColleague(args) {
-        if (!args.workspacePath || typeof args.workspacePath !== "string") {
-            throw new Error("workspacePath is required");
-        }
-        return await this.agentClient.hireColleague(args);
-    }
-    async handleHireColleaguesBatch(args) {
-        if (!Array.isArray(args.items) || args.items.length === 0) {
-            throw new Error("items is required and must contain at least one hire item");
-        }
-        args.items.forEach((item, index) => {
-            if (!item.workspacePath || typeof item.workspacePath !== "string") {
-                throw new Error(`items[${index}].workspacePath is required`);
-            }
-        });
-        return await this.agentClient.hireColleaguesBatch(args);
-    }
-    async handleSendPrivate(args) {
-        if (!args.targetId || typeof args.targetId !== "string") {
-            throw new Error("targetId is required");
-        }
-        if (!args.content || typeof args.content !== "string") {
-            throw new Error("content is required");
-        }
-        // 记录 token 消耗 (v1.8.0)
-        this.recordMessageTokenUsage(args.content).catch((err) => logger.warn("[McpServer] Failed to record token usage", err));
-        return await this.agentClient.sendDirectMessage(args.targetId, args.content, args.waitReply, args.replyToCallId, args.timeoutMs);
-    }
-    async handleCreateTaskInstanceComment(args) {
-        const taskInstanceId = this.getRequiredString(args, "taskInstanceId");
-        const content = this.getRequiredString(args, "content");
-        return await this.agentClient.createTaskInstanceComment({
-            taskInstanceId,
-            content,
-        });
-    }
-    /**
-     * 构建内存通知并前置到消息列表。
-     * @returns 若生成了通知并已前置，返回 true；否则返回 false。
-     */
-    async prependMemoryNotification(messages, buildFn) {
-        const notification = await buildFn();
-        if (notification) {
-            messages.directMessages.unshift(notification);
-            return true;
-        }
-        return false;
-    }
-    async handlePollMessage() {
-        logger.info('[McpServer] handlePollMessage 被调用');
-        if (this.pendingPollMessage) {
-            logger.info('[McpServer] poll_message 已有进行中的调用，等待其完成');
-            return await this.pendingPollMessage;
-        }
-        this.pendingPollMessage = (async () => {
-            return await this.doPollMessage();
-        })();
-        try {
-            return await this.pendingPollMessage;
-        }
-        finally {
-            this.pendingPollMessage = null;
-        }
-    }
-    /**
-     * poll_message 主循环逻辑。
-     *
-     * 紧急/非紧急分类策略：
-     * - 紧急类：未读消息（私信/群聊）、task、todo
-     * - 非紧急类：memory过期回忆、memory文件变更、memory容量整理
-     * - 规则：有紧急类时返回所有命中的紧急项（不搭配非紧急类）；
-     *   无紧急类时返回所有命中的非紧急项。
-     *
-     * 返回组合（只可能是以下两种之一）：
-     * 1、所有命中的紧急项（未读消息 + todo + task 中命中的全部）
-     * 2、所有命中的非紧急项（memory过期 + 文件变更 + 容量整理 中命中的全部）
-     *
-     * 注：subAgent 终态事件由 ACode 运行时层（runtime.ts callPollMessageWithSubAgentRace）
-     * 在 MCP 调用前后注入，MCP server 内部不直接检测子 agent 状态。
-     * 注：Todo 在入口和 while 循环中均检查，确保阻塞期间创建的 Todo 也能被感知。
-     */
-    async doPollMessage() {
-        logger.info('[McpServer] doPollMessage 被调用');
-        // 紧急类检查：hydrate 未读消息 + task
-        await this.hydrateUnreadMessagesFromServer({
-            blockIfEmpty: false,
-            includePipelineTasks: true,
-        });
-        // 紧急类检查：Todo（只检查一次）
-        const todoNotif = await this.buildTodoReminderNotification();
-        // 紧急类：有未读消息/task 时，加上 todo（如果有），返回所有紧急项
-        const urgentBuffered = this.messageBuffer.get();
-        if (urgentBuffered.directMessages.length > 0 || urgentBuffered.groupMessages.length > 0) {
-            if (todoNotif) {
-                urgentBuffered.directMessages.unshift(todoNotif);
-            }
-            return this.buildPollResult(urgentBuffered);
-        }
-        // 紧急类：无未读消息/task 但有 todo，直接返回 todo
-        if (todoNotif) {
-            return this.buildPollResult({ directMessages: [todoNotif], groupMessages: [] });
-        }
-        // 非紧急类：无紧急类时，检查所有非紧急项（memory过期 + 文件变更 + 容量整理）
-        const nonUrgentMessages = await this.checkAllLocalNonUrgentNotifications();
-        if (nonUrgentMessages.length > 0) {
-            return this.buildPollResult({ directMessages: nonUrgentMessages, groupMessages: [] });
-        }
-        // 无紧急类且无非紧急类：进入 while 循环等待新消息
-        let pollTagAlreadyMcp = false; // 标记当前状态 tag 已确认为 poll_message，后续不再检查
-        while (true) {
-            // ★ 修复：poll_message 阻塞期间，如果有 thinking 事件覆盖了状态 tag，
-            //   在 while 循环首次迭代中检查并恢复 poll_message 状态，确保前端状态 tag
-            //   与真实运行状态一致。已确认后 flag 置位，后续循环不再重复检查和恢复。
-            if (!pollTagAlreadyMcp) {
-                const statusReporter = this.agentClient.getStatusReporter();
-                if (statusReporter) {
-                    const currentStatus = statusReporter.getCurrentStatus();
-                    const isPollMessageTag = currentStatus.status === 'tool_using' &&
-                        currentStatus.actionDetail != null &&
-                        currentStatus.actionDetail.includes('poll_message');
-                    if (isPollMessageTag) {
-                        pollTagAlreadyMcp = true;
-                    }
-                    else {
-                        // 状态 tag 被覆盖了，恢复为 poll_message（只恢复一次）
-                        statusReporter.reportToolUse('poll_message', {});
-                        pollTagAlreadyMcp = true;
-                    }
-                }
-            }
-            const polled = await this.messageBuffer.poll(POLL_MESSAGE_INTERNAL_POLL_INTERVAL_MS);
-            // 紧急类：poll 到消息（私信/群聊），立即返回
-            if (polled.directMessages.length > 0 || polled.groupMessages.length > 0) {
-                return this.buildPollResult(polled);
-            }
-            // poll 超时无消息时，重新检查紧急类（task + todo 可能在此期间到达/创建）
-            // 与入口处逻辑一致：先查 todo，再合并消息/task，紧急项一起返回
-            await this.hydrateUnreadMessagesFromServer({
-                blockIfEmpty: false,
-                includePipelineTasks: true,
-            });
-            const todoNotifLoop = await this.buildTodoReminderNotification();
-            const taskBuffered = this.messageBuffer.get();
-            if (taskBuffered.directMessages.length > 0 || taskBuffered.groupMessages.length > 0) {
-                if (todoNotifLoop) {
-                    taskBuffered.directMessages.unshift(todoNotifLoop);
-                }
-                return this.buildPollResult(taskBuffered);
-            }
-            // 紧急类：无消息/task 但有 todo，返回 todo
-            if (todoNotifLoop) {
-                return this.buildPollResult({ directMessages: [todoNotifLoop], groupMessages: [] });
-            }
-            // 非紧急类：无紧急类时，检查非紧急项（文件变更仅在入口处检测一次，循环内跳过）
-            const nonUrgent = await this.checkAllLocalNonUrgentNotifications(false);
-            if (nonUrgent.length > 0) {
-                return this.buildPollResult({ directMessages: nonUrgent, groupMessages: [] });
-            }
-        }
-    }
-    /**
-     * 检查本地非紧急通知（memory过期回忆、文件变更、容量整理），返回所有命中的通知。
-     * Task 不在此方法中检查，因为 Task 通过服务端 hydrate 以消息形式返回。
-     * @param includeFileChange 是否包含文件变更检测，默认 true；循环轮询时传 false 以跳过。
-     */
-    async checkAllLocalNonUrgentNotifications(includeFileChange = true) {
-        const messages = [];
-        const recurrenceNotif = await this.buildMemoryRecurrenceNotification();
-        if (recurrenceNotif)
-            messages.push(recurrenceNotif);
-        if (includeFileChange) {
-            const fileChangeNotif = await this.buildMemoryFileChangeNotification();
-            if (fileChangeNotif)
-                messages.push(fileChangeNotif);
-        }
-        const cleanupNotif = await this.buildMemoryCleanupNotification();
-        if (cleanupNotif)
-            messages.push(cleanupNotif);
-        return messages;
-    }
-    buildPollResult(messages, fromBuffer = true) {
-        return {
-            directMessages: messages.directMessages,
-            groupMessages: messages.groupMessages,
-            fromBuffer,
-            systemMessages: [],
-        };
-    }
-    /**
-     * 解析正整数环境变量。
-     * 主流程：读取环境变量 -> 转成整数 -> 非法值使用默认值。
-     */
-    parsePositiveIntegerEnv(name, defaultValue) {
-        const raw = process.env[name];
-        if (!raw || !raw.trim()) {
-            return defaultValue;
-        }
-        const parsed = Number.parseInt(raw, 10);
-        if (!Number.isFinite(parsed) || parsed <= 0) {
-            logger.warn(`[McpServer] ${name} 无效，使用默认值 ${defaultValue}ms`);
-            return defaultValue;
-        }
-        return parsed;
-    }
-    sleep(delayMs) {
-        if (delayMs <= 0) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-    /**
-     * 构建本地记忆整理提醒。
-     * 主流程：读取容量统计 -> 找出超过软限制的 listable 类型 -> 注入一条非持久化系统私信提醒 Agent 整理。
-     */
-    async buildMemoryCleanupNotification() {
-        try {
-            const stats = await this.memoryStore.getStats();
-            const exceededTypes = Object.entries(stats.by_type).filter(([, typeStats]) => typeStats.listable && typeStats.exceeded);
-            const exceededDomains = Object.entries(stats.by_type).flatMap(([memoryType, typeStats]) => typeStats.listable
-                ? Object.entries(typeStats.by_domain)
-                    .filter(([, domainStats]) => domainStats.exceeded)
-                    .map(([domain, domainStats]) => ({
-                    memoryType,
-                    domain,
-                    domainStats,
-                }))
-                : []);
-            if (exceededTypes.length === 0 && exceededDomains.length === 0) {
-                return null;
-            }
-            const typeDetails = exceededTypes.map(([memoryType, typeStats]) => `${memoryType} 当前 ${typeStats.domainCount} 个 URI domain 类型，建议上限 ${typeStats.limit} 个，硬上限 ${typeStats.hardLimit} 个`);
-            const domainDetails = exceededDomains.map(({ memoryType, domain, domainStats }) => `${memoryType}/${domain} 类型下当前 ${domainStats.count} 条 memory，建议上限 ${domainStats.limit} 条，硬上限 ${domainStats.hardLimit} 条`);
-            const cleanupActions = [
-                "请调用 get_memory_stats 查看容量详情",
-                "调用 list_memories 按类型查看超限记忆",
-                "删除不再需要的 recently_memory",
-                "更新 agent_memory 续期（TTL ×2）或删除过期项",
-            ].join("；");
-            return {
-                msgId: `memory-cleanup-${Date.now()}`,
-                senderId: "MCP-System",
-                senderName: "系统",
-                receiverId: this.getCurrentAgentId() || undefined,
-                content: `本地 memory 已超过建议容量，需要整理。${[...typeDetails, ...domainDetails].join("；")}。${cleanupActions}。`,
-                requireReply: false,
-                prompt: "这是一条本地 memory 容量整理提醒，自动生成，无需持久化。请优先整理已超过建议上限的短期/近期 memory 类型，或具体类型下的 memory 条目。",
-                timestamp: new Date().toISOString(),
-                _acodeAutoDelegate: {
-                    type: 'memory_cleanup',
-                    uris: exceededDomains.map(d => `${d.memoryType}/${d.domain}`),
-                },
-            };
-        }
-        catch (error) {
-            logger.warn('[McpServer] 构建本地 memory 整理提醒失败: %s', error instanceof Error ? error.message : String(error));
-            return null;
-        }
-    }
-    /**
-     * 构建近期记忆过期回忆通知（有即将遗忘的记忆需要整理）。
-     * Memory 近期记忆过期 (v1.11.0) / v1.13.0 改用服务端 memory_status 字段 / v1.19.0 扩展
-     *
-     * 通知策略（基于服务端 memory_status）：
-     * 1. 有过期 recently_memory / agent_memory 且 memory_status='recalling'（回忆中但未完成疏理）：
-     *    通知 "存在待疏理的即将遗忘记忆，请通过 memory_recurrence 获取进行整理"
-     * 2. 有过期 recently_memory / agent_memory 且 memory_status='normal'（尚未开始回忆）：
-     *    通知 "有即将遗忘记忆得整理，请通过 memory_recurrence 进行回忆"
-     * v1.19.0: recently_memory 纳入过期回忆流程，与 agent_memory 一并处理。
-     */
-    async buildMemoryRecurrenceNotification() {
-        try {
-            // v1.13.0: 改为调用服务端 list_expired_memories，返回的记录带 memory_status
-            const expiredMemories = await this.memoryStore.listExpiredRecentlyMemories();
-            if (expiredMemories.length === 0)
-                return null;
-            const agentId = this.getCurrentAgentId();
-            if (!agentId)
-                return null;
-            const recallingExpired = expiredMemories.filter(m => m.memory_status === 'recalling');
-            const normalExpired = expiredMemories.filter(m => !recallingExpired.includes(m));
-            // 场景1: 有 recalling 状态的过期记忆（Agent 未完成疏理）
-            if (recallingExpired.length > 0) {
-                const memoryList = recallingExpired.slice(0, 5).map(m => m.uri).join('\n');
-                return {
-                    msgId: `memory-recurrence-pending-${Date.now()}`,
-                    senderId: "MCP-System",
-                    senderName: "系统",
-                    receiverId: agentId,
-                    content: `存在待疏理的即将遗忘记忆（共 ${recallingExpired.length} 条），请通过 memory_recurrence 获取进行整理。\n\n待疏理记忆：\n${memoryList}${recallingExpired.length > 5 ? `\n  ...及其他 ${recallingExpired.length - 5} 条` : ''}`,
-                    requireReply: false,
-                    prompt: "memory_recurrence 取回的记忆仍在回忆中，请通过 memory_recurrence_complete 完成疏理，或继续归档/续期。",
-                    timestamp: new Date().toISOString(),
-                    _acodeAutoDelegate: {
-                        type: 'memory_expiration',
-                        uris: recallingExpired.map(m => m.uri),
-                    },
-                };
-            }
-            // 场景2: 有待回忆的过期记忆
-            if (normalExpired.length > 0) {
-                const memoryList = normalExpired.slice(0, 5).map(m => m.uri).join('\n');
-                return {
-                    msgId: `memory-recurrence-${Date.now()}`,
-                    senderId: "MCP-System",
-                    senderName: "系统",
-                    receiverId: agentId,
-                    content: `有 ${normalExpired.length} 条即将遗忘的记忆得整理，请使用 memory_recurrence(limit=10) 分批处理（最早过期优先，每次 10 条）。\n\n即将遗忘的记忆：\n${memoryList}${normalExpired.length > 5 ? `\n  ...及其他 ${normalExpired.length - 5} 条` : ''}`,
-                    requireReply: false,
-                    prompt: `这是一条近期记忆过期提醒，共有 ${normalExpired.length} 条记忆即将遗忘，请调用 memory_recurrence 分批次获取并决定处理方式。`,
-                    timestamp: new Date().toISOString(),
-                    _acodeAutoDelegate: {
-                        type: 'memory_expiration',
-                        uris: normalExpired.map(m => m.uri),
-                    },
-                };
-            }
-            return null;
-        }
-        catch (error) {
-            logger.warn('[McpServer] 构建近期记忆过期回忆通知失败: %s', error instanceof Error ? error.message : String(error));
-            return null;
-        }
-    }
-    /**
-     * 构建 Memory 文件变更检测通知。
-     * Memory 增强功能 (v1.6.0)
-     *
-     * 检测流程（所有数据均从服务端读取，不降级到本地）：
-     * 1. 检查本 Agent 标记为 updating 但未处理的 Memory
-     * 2. 检查短期记忆、近期记忆绑定的文件是否变更
-     * 3. 检查永久记忆的文件变更，先走 Server 原子 claim，再标记本地
-     */
-    async buildMemoryFileChangeNotification() {
-        logger.info(`[McpServer] buildMemoryFileChangeNotification 被调用: hasRoleName=${this.hasRoleName}, agentId=${this.getCurrentAgentId() ?? '(空)'}`);
-        // 无角色名时不检测本地永久记忆文件变更（避免 default-role 跨角色污染）
-        if (!this.hasRoleName) {
-            logger.info('[McpServer] 文件变更检测跳过: hasRoleName=false');
-            return null;
-        }
-        try {
-            const agentId = this.getCurrentAgentId();
-            if (!agentId) {
-                logger.info('[McpServer] 文件变更检测跳过: agentId 为空');
-                return null;
-            }
-            // ★ 所有检查均从服务端读取（memory_status/claim/租约/file_md5_map 均以服务端 DB 为权威源）。
-            //   原Step 0 syncClaimStatusFromServer 读本地 roleMemoryStore 清理本地过时 claim，
-            //   服务端权威后本地 updating 状态不再被任何决策路径读取，该同步已无意义，移除。
-            //   服务端不可用时直接 catch 返回 null（下方 catch），不降级到本地。
-            // 步骤1: 检查是否有 pending 的 updating memories（服务端角色级永久记忆），
-            // 同时检测绑定文件是否再次变更（用户可能在 Agent 处理前又改了文件）
-            // 数据源切换：从服务端角色级 scope 读取（同角色所有实例共享），
-            // 不再用本地 roleMemoryStore（仅本实例可见，兄弟实例无法检测到彼此创建的 memory）。
-            const permanentList = await this.memoryStore.listByType('project_memory');
-            const updatingMemories = permanentList.filter(m => m.memory_status === 'updating' && m.updating_agent_id === agentId);
-            if (updatingMemories.length > 0) {
-                // 当前 agent 持有未完成的 updating memory，确保租约续期定时器在运行，
-                // 避免 agent 在更新过程中租约过期被其他实例接管。
-                this.startLeaseRenewal();
-                // 对 updating 记忆也检测文件是否再次变更
-                const updatingChanges = await this.checkMemoriesFileChanges(updatingMemories);
-                if (updatingChanges.length > 0) {
-                    // 有新的文件变更，更新 MD5 map 持久化，发出新变更通知
-                    for (const change of updatingChanges) {
-                        const memory = updatingMemories.find(m => m.id === change.memoryId);
-                        if (memory) {
-                            // MD5 回写到服务端角色级 scope（显式传 memory_status:updating 防止 auto-release）
-                            // bound_files 同步回写：checkMemoriesFileChanges 可能已修剪掉消失的文件路径（消除悬空引用）
-                            await this.memoryStore.updateMemory({
-                                uri: memory.uri,
-                                memory_type: 'project_memory',
-                                memory_status: 'updating',
-                                updating_agent_id: agentId,
-                                file_md5_map: memory.file_md5_map,
-                                last_check_time: memory.last_check_time,
-                                bound_files: memory.bound_files,
-                            });
-                        }
-                    }
-                    const selectedCount = Math.min(updatingChanges.length, 5);
-                    const changeDetails = updatingChanges
-                        .slice(0, 5)
-                        .map(change => `- ${change.memoryUri} (文件: ${change.changedFiles.join(', ')})`)
-                        .join('\n');
-                    return {
-                        msgId: `memory-file-change-${Date.now()}`,
-                        senderId: "MCP-System",
-                        senderName: "系统",
-                        receiverId: agentId,
-                        content: `检测到以下 ${selectedCount} 个处于更新中的 Memory 绑定的文件再次变更，已更新 MD5 记录：\n\n${changeDetails}\n\n请调用 read_memory 查看最新内容并调用 update_memory 更新。`,
-                        requireReply: false,
-                        prompt: "这是一条文件变更提醒，您之前标记为更新中的记忆绑定的文件又有新变更，请处理。",
-                        timestamp: new Date().toISOString(),
-                        _acodeAutoDelegate: {
-                            type: 'memory_file_change',
-                            uris: updatingChanges.slice(0, 5).map(c => c.memoryUri),
-                            fileChanges: updatingChanges.slice(0, 5).map(c => {
-                                const memory = updatingMemories.find(m => m.id === c.memoryId);
-                                return {
-                                    uri: c.memoryUri,
-                                    boundFiles: memory?.bound_files ?? [],
-                                    fileStatuses: c.fileStatuses,
-                                    changedFiles: c.changedFiles,
-                                };
-                            }),
-                        },
-                    };
-                }
-                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');
-                });
-                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 (memoriesWithRealChanges.length === 0) {
-                    logger.info(`[McpServer] 文件变更检测 Step1: 所有 updating memory 绑定文件均无真实变更，已自动释放，跳过委托`);
-                    return null;
-                }
-                const memoryList = memoriesWithRealChanges
-                    .slice(0, 5)
-                    .map(m => `- ${m.uri} (文件: ${m.bound_files?.join(', ') || '未知'})`)
-                    .join('\n');
-                logger.info(`[McpServer] 文件变更检测 Step1: ${memoriesWithRealChanges.length}/${updatingMemories.length} 个 updating memory 有真实文件变更，触发委托`);
-                return {
-                    msgId: `memory-update-pending-${Date.now()}`,
-                    senderId: "MCP-System",
-                    senderName: "系统",
-                    receiverId: agentId,
-                    content: `您有以下 Memory 正处于更新中状态但尚未完成更新：\n\n${memoryList}\n\n请继续完成更新工作。`,
-                    requireReply: false,
-                    prompt: "这是一条更新提醒，您之前已标记这些记忆为更新中，请继续处理。",
-                    timestamp: new Date().toISOString(),
-                    _acodeAutoDelegate: {
-                        type: 'memory_file_change',
-                        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) ?? [],
-                        })),
-                    },
-                };
-            }
-            // 步骤2: 检查短期记忆和近期记忆（服务端存储）
-            const recentlyMemoryMemories = await this.memoryStore.listByType('recently_memory');
-            const agentMemoryMemories = await this.memoryStore.listByType('agent_memory');
-            const listableMemories = [...recentlyMemoryMemories, ...agentMemoryMemories];
-            // 诊断日志：列出 listable memory 的绑定文件和 MD5 基线情况
-            const listableWithFiles = listableMemories.filter(m => m.bound_files && m.bound_files.length > 0);
-            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 map 快照，用于检测 checkMemoriesFileChanges 是否修复了键缺失
-            // （路径规范化不一致导致 bound_files 与 file_md5_map 键不匹配时的静默修正）
-            const listableMd5Snapshots = new Map();
-            for (const m of listableMemories) {
-                if (m.bound_files && m.bound_files.length > 0) {
-                    listableMd5Snapshots.set(m.id, JSON.stringify(m.file_md5_map ?? {}));
-                }
-            }
-            const listableChanges = await this.checkMemoriesFileChanges(listableMemories);
-            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/通知流程中处理）。
-            const repairedListableMemories = listableMemories.filter(m => {
-                if (!m.bound_files || m.bound_files.length === 0)
-                    return false;
-                if (listableChanges.some(c => c.memoryId === m.id))
-                    return false;
-                const before = listableMd5Snapshots.get(m.id);
-                const after = JSON.stringify(m.file_md5_map ?? {});
-                return before !== after;
-            });
-            if (repairedListableMemories.length > 0) {
-                logger.info(`[McpServer] 文件变更检测 Step2: 回写 ${repairedListableMemories.length} 个 listable memory 的修正 MD5 map`);
-                for (const m of repairedListableMemories) {
-                    try {
-                        await this.memoryStore.updateMemory({
-                            uri: m.uri,
-                            memory_type: m.memory_type,
-                            file_md5_map: m.file_md5_map,
-                            last_check_time: m.last_check_time,
-                        });
-                    }
-                    catch (e) {
-                        logger.info(`[McpServer] 回写 listable MD5 map 失败: ${m.uri}`, e);
-                    }
-                }
-            }
-            if (newListableChanges.length > 0) {
-                const changeDetails = newListableChanges
-                    .map(change => `- ${change.memoryUri} (文件: ${change.changedFiles.join(', ')})`)
-                    .join('\n');
-                return {
-                    msgId: `memory-file-change-${Date.now()}`,
-                    senderId: "MCP-System",
-                    senderName: "系统",
-                    receiverId: agentId,
-                    content: `检测到以下 Memory 绑定的文件已变更，请及时更新：\n\n${changeDetails}\n\n请调用 read_memory 查看内容并调用 update_memory 更新。`,
-                    requireReply: false,
-                    prompt: "这是一条文件变更提醒，自动生成，无需持久化。",
-                    timestamp: new Date().toISOString(),
-                    _acodeAutoDelegate: {
-                        type: 'memory_file_change',
-                        uris: newListableChanges.map(c => c.memoryUri),
-                        fileChanges: newListableChanges.map(c => {
-                            const memory = listableMemories.find(m => m.id === c.memoryId);
-                            return {
-                                uri: c.memoryUri,
-                                boundFiles: memory?.bound_files ?? [],
-                                fileStatuses: c.fileStatuses,
-                                changedFiles: c.changedFiles,
-                            };
-                        }),
-                    },
-                };
-            }
-            // 步骤3: 检查永久记忆（角色本地存储）— 优先走 Server 原子 claim，失败时降级到本地直接标记
-            const permanentMemoriesWithFiles = permanentList.filter(m => m.bound_files && m.bound_files.length > 0
-                && (m.memory_status === 'normal' || !m.memory_status)
-                && !this.isClaimCached(m.uri));
-            const permanentTotalWithFiles = permanentList.filter(m => m.bound_files && m.bound_files.length > 0);
-            logger.info(`[McpServer] 文件变更检测 Step3: project_memory 总数=${permanentList.length}, ` +
-                `有绑定文件=${permanentTotalWithFiles.length}, 待检测(过滤updating/claimed后)=${permanentMemoriesWithFiles.length}。` +
-                `被过滤原因: ${permanentTotalWithFiles.length - permanentMemoriesWithFiles.length} 项(memory_status=updating 或 isClaimCached)`);
-            // 捕获检测前的 md5 map 快照，用于检测 checkMemoriesFileChanges 是否修复了无基线/键缺失
-            const permanentMd5Snapshots = new Map();
-            for (const m of permanentMemoriesWithFiles) {
-                permanentMd5Snapshots.set(m.id, JSON.stringify(m.file_md5_map ?? {}));
-            }
-            const permanentChanges = await this.checkMemoriesFileChanges(permanentMemoriesWithFiles);
-            // 回写被修复的 md5 map（无基线建基线或键缺失修正）到服务端。
-            // 通过快照对比精确识别被修正的 memory，避免每轮回写所有未变更记录。
-            const baselineUpdatedMemories = permanentMemoriesWithFiles.filter(m => {
-                if (permanentChanges.some(c => c.memoryId === m.id))
-                    return false;
-                const before = permanentMd5Snapshots.get(m.id);
-                const after = JSON.stringify(m.file_md5_map ?? {});
-                return before !== after
-                    && m.file_md5_map && Object.keys(m.file_md5_map).length > 0;
-            });
-            if (baselineUpdatedMemories.length > 0) {
-                logger.info(`[McpServer] 文件变更检测 Step3: 回写 ${baselineUpdatedMemories.length} 个 memory 的修正 MD5 map 到服务端（无基线/键缺失修复）`);
-                for (const m of baselineUpdatedMemories) {
-                    try {
-                        await this.memoryStore.updateMemory({
-                            uri: m.uri,
-                            memory_type: 'project_memory',
-                            file_md5_map: m.file_md5_map,
-                            last_check_time: m.last_check_time,
-                        });
-                    }
-                    catch (e) {
-                        logger.info(`[McpServer] 回写基线 MD5 失败: ${m.uri}`, e);
-                    }
-                }
-            }
-            logger.info(`[McpServer] 文件变更检测 Step3: 检测到变更=${permanentChanges.length}` +
-                (permanentChanges.length > 0 ? ` 变更项: ${permanentChanges.map(c => `${c.memoryUri}(${c.changedFiles.join(',')})`).join('; ')}` : ''));
-            if (permanentChanges.length > 0) {
-                // 最多选取 5 个
-                const selectedChanges = permanentChanges.slice(0, 5);
-                const urisToClaim = selectedChanges.map(c => c.memoryUri);
-                let claimedViaServer = false;
-                let claimedUris = new Set();
-                try {
-                    // Path A: 尝试走 Server 原子 claim
-                    const claimResult = await this.memoryStore.claimMemoryUpdate(urisToClaim, McpServer.LEASE_DURATION_MINUTES, 'project_memory');
-                    claimedUris = new Set(claimResult.claimed_uris ?? []);
-                    claimedViaServer = true;
-                }
-                catch (e) {
-                    // Path B: Server API 不可用 → 降级到本地直接标记
-                    logger.info("[McpServer] Server claim API 不可用，降级到本地直接标记:", e);
-                    claimedUris = new Set(urisToClaim);
-                }
-                if (claimedUris.size > 0) {
-                    const claimedChanges = selectedChanges.filter(c => claimedUris.has(c.memoryUri));
-                    // 标记本地 roleMemoryStore
-                    for (const change of claimedChanges) {
-                        const memory = permanentList.find(m => m.id === change.memoryId);
-                        if (memory) {
-                            // claim 状态由 batchClaimUpdate 在服务端原子写入；此处仅回写新 MD5 基线到服务端角色级 scope，
-                            // 显式传 memory_status:updating/updating_agent_id 防止 Java updateMemory auto-release 误释放 claim。
-                            // bound_files 同步回写：checkMemoriesFileChanges 可能已修剪掉消失的文件路径（消除悬空引用）
-                            await this.memoryStore.updateMemory({
-                                uri: memory.uri,
-                                memory_type: 'project_memory',
-                                memory_status: 'updating',
-                                updating_agent_id: agentId,
-                                file_md5_map: memory.file_md5_map,
-                                last_check_time: memory.last_check_time,
-                                bound_files: memory.bound_files,
-                            });
-                            this.activeLeaseUris.add(memory.uri);
-                        }
-                    }
-                    // 启动租约续期（仅 Server claim 成功时需要，降级模式不续期）
-                    if (claimedViaServer && claimedUris.size > 0) {
-                        this.startLeaseRenewal();
-                    }
-                    const changeDetails = claimedChanges
-                        .map(change => `- ${change.memoryUri} (文件: ${change.changedFiles.join(', ')})`)
-                        .join('\n');
-                    return {
-                        msgId: `memory-file-change-${Date.now()}`,
-                        senderId: "MCP-System",
-                        senderName: "系统",
-                        receiverId: agentId,
-                        content: `检测到以下 ${claimedChanges.length} 个永久记忆绑定的文件已变更，已为您标记为更新中：\n\n${changeDetails}\n\n请调用 read_memory 查看内容并调用 update_memory 更新。更新完成后状态将自动恢复为正常。`,
-                        requireReply: false,
-                        prompt: "这是一条文件变更提醒，已自动标记更新状态，请处理。",
-                        timestamp: new Date().toISOString(),
-                        _acodeAutoDelegate: {
-                            type: 'memory_file_change',
-                            uris: claimedChanges.map(c => c.memoryUri),
-                            fileChanges: claimedChanges.map(c => {
-                                const memory = permanentList.find(m => m.id === c.memoryId);
-                                return {
-                                    uri: c.memoryUri,
-                                    boundFiles: memory?.bound_files ?? [],
-                                    fileStatuses: c.fileStatuses,
-                                    changedFiles: c.changedFiles,
-                                };
-                            }),
-                        },
-                    };
-                }
-            }
-            logger.info('[McpServer] 文件变更检测完成: 无变更通知产生');
-            return null;
-        }
-        catch (error) {
-            logger.warn('[McpServer] 构建 Memory 文件变更检测通知失败: %s', error instanceof Error ? error.message : String(error));
-            return null;
-        }
-    }
-    isClaimCached(uri) {
-        return this.activeLeaseUris.has(uri);
-    }
-    /**
-     * 计算某条记忆全部绑定文件的逐文件状态（纯计算，不修改任何状态）。
-     * - no_change: 文件存在且 MD5 与基线一致（或无基线时保守视为未变）
-     * - content_changed: 文件存在但 MD5 与基线不一致
-     * - not_found: 文件读取不到（被删除/移动）
-     * 注意：无基线（新增绑定文件尚未建基线）的文件保守返回 no_change，避免误报为变更。
-     */
-    async computeBoundFileStatuses(memory) {
-        const result = [];
-        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) {
-                    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];
-                if (!oldMd5) {
-                    result.push({ path: filePath, status: 'no_change' });
-                }
-                else if (oldMd5 !== currentMd5) {
-                    result.push({ path: filePath, status: 'content_changed', localMd5: currentMd5, serverMd5: oldMd5 });
-                }
-                else {
-                    result.push({ path: filePath, status: 'no_change' });
-                }
-            }
-            catch {
-                result.push({ path: filePath, status: 'no_change' });
-            }
-        }
-        return result;
-    }
-    /**
-     * 检查一组 Memory 的文件变更
-     * Memory 增强功能 (v1.6.0)
-     */
-    async checkMemoriesFileChanges(memories) {
-        const changes = [];
-        for (const memory of memories) {
-            if (!memory.bound_files || memory.bound_files.length === 0) {
-                continue;
-            }
-            try {
-                const changedFiles = [];
-                const statuses = [];
-                const newMd5Map = {};
-                const oldMd5Map = memory.file_md5_map || {};
-                const workspacePath = process.env.AWS_WORKSPACE_PATH || process.cwd();
-                const hasNoBaseline = Object.keys(oldMd5Map).length === 0;
-                // 标记本轮是否修复了单文件基线（键缺失/空值），用于回写修正后的 map 但不计入变更
-                let baselineRepaired = false;
-                for (const filePath of memory.bound_files) {
-                    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) {
-                                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: 'no_change' });
-                            }
-                            continue;
-                        }
-                        newMd5Map[filePath] = currentMd5;
-                        const oldMd5 = oldMd5Map[filePath];
-                        if (!oldMd5) {
-                            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', localMd5: currentMd5, serverMd5: oldMd5 });
-                            changedFiles.push(`${filePath}（内容变更 本地: ${currentMd5} Server: ${oldMd5}）`);
-                        }
-                        else {
-                            statuses.push({ path: filePath, status: 'no_change' });
-                        }
-                    }
-                    catch (error) {
-                        logger.info(`[McpServer] 计算文件 MD5 失败: ${filePath}`, error);
-                        statuses.push({ path: filePath, status: 'no_change' });
-                    }
-                }
-                // 无基线时：更新 MD5 map 到 memory 对象（供调用方回写），但不计入变更
-                if (hasNoBaseline && Object.keys(newMd5Map).length > 0) {
-                    memory.file_md5_map = newMd5Map;
-                    memory.last_check_time = new Date().toISOString();
-                    continue; // 不 push 到 changes
-                }
-                // 键缺失修复：map 非空但部分文件缺少基线（路径规范化不一致或新增文件）。
-                // 回写修正后的 map 供调用方持久化，但不计入变更，避免误报。
-                if (baselineRepaired && Object.keys(newMd5Map).length > 0) {
-                    memory.file_md5_map = newMd5Map;
-                    memory.last_check_time = new Date().toISOString();
-                }
-                if (changedFiles.length > 0) {
-                    changes.push({
-                        memoryId: memory.id,
-                        memoryUri: memory.uri,
-                        fileStatuses: statuses,
-                        changedFiles,
-                    });
-                    // ⚠️ 不要用 newMd5Map 覆盖 memory.file_md5_map！
-                    // 检测阶段只负责"发现变更并通知 agent"，MD5 基线必须保留为旧值，
-                    // 让调用方把旧基线回写到 DB。否则 agent 收到变更通知后，
-                    // 重算文件 MD5 与 DB 中已被覆盖的新基线一致，会误判"文件实际未变"。
-                    // 新基线只能由 agent 主动调用 update_memory 处理完变更后重建。
-                    // 仅更新检测时间戳，记录本次检查发生过。
-                    memory.last_check_time = new Date().toISOString();
-                }
-            }
-            catch (error) {
-                logger.warn(`[McpServer] 检查 Memory ${memory.id} 文件变更失败:`, error);
-            }
-        }
-        return changes;
-    }
-    /**
-     * 计算文件 MD5
-     * Memory 增强功能 (v1.6.0)
-     */
-    async calculateFileMd5(filePath) {
-        try {
-            const { createReadStream } = await import('node:fs');
-            const { createHash } = await import('node:crypto');
-            // 绑定文件以工作区相对路径存储（./xxx），需相对 AWS_WORKSPACE_PATH 解析，
-            // 与 validateBoundFilesExist 保持一致，避免 cwd ≠ 工作区时读不到文件。
-            const workspacePath = process.env.AWS_WORKSPACE_PATH || process.cwd();
-            const resolvedPath = path.resolve(workspacePath, filePath);
-            // L-5: 防止路径逃逸（如 ../../../etc/passwd）
-            const normalizedWorkspace = path.resolve(workspacePath);
-            const normalizedResolved = path.resolve(resolvedPath);
-            if (!normalizedResolved.startsWith(normalizedWorkspace + path.sep) && normalizedResolved !== normalizedWorkspace) {
-                logger.warn(`[McpServer] calculateFileMd5: 路径逃逸被拒绝: ${filePath}`);
-                return null;
-            }
-            return new Promise((resolve) => {
-                const hash = createHash('md5');
-                const stream = createReadStream(resolvedPath);
-                stream.on('data', (chunk) => hash.update(chunk));
-                stream.on('end', () => resolve(hash.digest('hex')));
-                stream.on('error', () => resolve(null));
-            });
-        }
-        catch (error) {
-            logger.info(`[McpServer] 计算文件 MD5 失败: ${filePath}`, error);
-            return null;
-        }
-    }
-    async verifyFileNotExist(resolvedPath) {
-        try {
-            await fs.promises.access(resolvedPath, fs.constants.F_OK);
-            return false;
-        }
-        catch {
-            return true;
-        }
-    }
-    async handleGetMessage() {
-        // 消息来源标记：
-        // - buffer 在 hydrate 前已有消息 → fromBuffer=true（来自本地 buffer）
-        // - buffer 空、hydrate 从服务端拉到消息 → fromBuffer=false（来自服务端）
-        // - buffer 空、hydrate 也无消息（仅有 Memory 通知注入）→ fromBuffer=true（本地注入）
-        const hadBufferedMessages = this.messageBuffer.size() > 0;
-        await this.hydrateUnreadMessagesFromServer();
-        const messages = this.messageBuffer.get();
-        const hasRealMessages = messages.directMessages.length > 0 || messages.groupMessages.length > 0;
-        const fromBuffer = hadBufferedMessages || !hasRealMessages;
-        if (await this.prependMemoryNotification(messages, () => this.buildMemoryRecurrenceNotification())) {
-            return this.buildPollResult(messages, fromBuffer);
-        }
-        if (await this.prependMemoryNotification(messages, () => this.buildMemoryCleanupNotification())) {
-            return this.buildPollResult(messages, fromBuffer);
-        }
-        return this.buildPollResult(messages, fromBuffer);
-    }
-    /**
-     * 从服务端补拉未读消息并写入本地缓冲。
-     * 主流程：按调用方指定的阻塞/流程线任务参数请求服务端 -> 过滤本地不可投递消息 -> 追加到当前消息缓存。
-     */
-    async hydrateUnreadMessagesFromServer(options = {}) {
-        try {
-            const unreadMessages = await this.agentClient.fetchUnreadMessages({
-                blockIfEmpty: options.blockIfEmpty ?? false,
-                blockTimeoutMs: options.blockTimeoutMs,
-                includePipelineTasks: options.includePipelineTasks,
-            });
-            if (unreadMessages.directMessages.length === 0 &&
-                unreadMessages.groupMessages.length === 0) {
-                return true;
-            }
-            const filteredDirectMessages = unreadMessages.directMessages.filter((message) => this.shouldBufferIncomingMessage(message));
-            const filteredGroupMessages = unreadMessages.groupMessages.filter((message) => this.shouldBufferIncomingMessage(message));
-            filteredDirectMessages.forEach((message) => {
-                this.messageBuffer.push(message);
-            });
-            filteredGroupMessages.forEach((message) => {
-                this.messageBuffer.push(message);
-            });
-            logger.info(`[McpServer] 已补拉未读消息，私聊: ${filteredDirectMessages.length}，群聊: ${filteredGroupMessages.length}`);
-            return true;
-        }
-        catch (error) {
-            logger.error('[McpServer] 补拉未读消息失败: %s, stack=%s', error instanceof Error ? error.message : String(error), error instanceof Error ? error.stack : '(no stack)');
-            return false;
-        }
-    }
-    async handleGetDmHistory(args) {
-        return await this.agentClient.getDmHistory(args.targetUserId, args.limit, args.since);
-    }
-    async handleGetGroupHistory(args) {
-        return await this.agentClient.getGroupHistory(args.limit, args.roomId, args.since);
-    }
-    async handleSubmitTaskResult(args) {
-        if (!args.nodeId || typeof args.nodeId !== "string") {
-            throw new Error("nodeId is required");
-        }
-        if (!args.outputPayload || typeof args.outputPayload !== "string") {
-            throw new Error("outputPayload is required");
-        }
-        const changeLog = Array.isArray(args.changeLog)
-            ? args.changeLog
-            : undefined;
-        return await this.agentClient.submitTaskResult(args.nodeId, args.outputPayload, changeLog);
-    }
-    async handleStartTaskRollback(args) {
-        const input = {
-            rollbackTaskId: this.getRequiredString(args, "rollbackTaskId"),
-        };
-        return await this.agentClient.startTaskRollback(input);
-    }
-    async handleFinishTaskRollback(args) {
-        const input = {
-            rollbackTaskId: this.getRequiredString(args, "rollbackTaskId"),
-            resultMessage: this.getOptionalString(args, "resultMessage"),
-        };
-        return await this.agentClient.finishTaskRollback(input);
-    }
-    async handleRejectTask(args) {
-        if (!args.nodeId || typeof args.nodeId !== "string") {
-            throw new Error("nodeId is required");
-        }
-        if (!args.reason || typeof args.reason !== "string") {
-            throw new Error("reason is required");
-        }
-        return await this.agentClient.rejectTask(args.nodeId, args.reason);
-    }
-    async handleTerminateTask(args) {
-        if (!args.taskInstanceId || typeof args.taskInstanceId !== "string") {
-            throw new Error("taskInstanceId is required");
-        }
-        if (!args.reason || typeof args.reason !== "string") {
-            throw new Error("reason is required");
-        }
-        return await this.agentClient.terminateTask(args.taskInstanceId, args.reason);
-    }
-    /**
-     * 处理接收到的消息（WebSocket 推送）
-     */
-    async handleIncomingMessage(message) {
-        if (!this.shouldBufferIncomingMessage(message)) {
-            // pipeline_task_assigned 不进 buffer，但需唤醒 poll 走 hydrate 重查任务，
-            // 否则 poll_message 会被 messageBuffer.poll(30s) 阻塞，task 流转最长延迟 30s。
-            if (!this.isGroupMessage(message) && this.isPipelineTaskAssignedNotification(message)) {
-                logger.info("[McpServer] 收到 pipeline_task_assigned 唤醒信号，立即唤醒 poll 走 hydrate 重查");
-                this.messageBuffer.wakeUpWaiters();
-            }
-            return undefined;
-        }
-        logger.info(`[McpServer] 收到消息: ${message.content?.substring(0, 50) || "(无内容)"}`);
-        this.messageBuffer.push(message);
-        return undefined;
-    }
-    /**
-     * 判断消息是否应该进入本地缓冲区。
-     * 主流程：过滤结构异常消息 -> 过滤当前 Agent 自发消息 -> 过滤持久化流程线唤醒私信。
-     */
-    shouldBufferIncomingMessage(message) {
-        if (!message || typeof message !== "object") {
-            logger.warn("[McpServer] 忽略结构异常的消息，避免缓冲区污染");
-            return false;
-        }
-        if (this.isSelfSentMessage(message)) {
-            logger.info("[McpServer] 忽略当前 Agent 自己发送的消息，避免 poll_message/get_message 回环");
-            return false;
-        }
-        if (!this.isGroupMessage(message)) {
-            if (this.isPipelineTaskAssignedNotification(message)) {
-                logger.info("[McpServer] 忽略持久化 pipeline_task_assigned 私信，仅作为 poll_message 唤醒信号处理");
-                return false;
-            }
-            return true;
-        }
-        return true;
-    }
-    /**
-     * 判断是否为群消息。
-     * 通过 msgId 类型进行收窄，便于后续安全执行群消息专属过滤逻辑。
-     */
-    isGroupMessage(message) {
-        return !!message && typeof message === "object" && typeof message.msgId === "number";
-    }
-    /**
-     * 判断是否为持久化流程线任务待领取私信。
-     * 主流程：同时检查 content 与 prompt，只要包含 pipeline_task_assigned 就不进入本地缓冲，避免未抢占成功 Agent 收到系统任务提醒。
-     */
-    isPipelineTaskAssignedNotification(message) {
-        const content = typeof message.content === "string" ? message.content : "";
-        const prompt = typeof message.prompt === "string" ? message.prompt : "";
-        return (content.includes("pipeline_task_assigned") ||
-            prompt.includes("pipeline_task_assigned"));
-    }
-    /**
-     * 判断消息是否由当前 Agent 自己发送。
-     * 主流程：读取当前 Agent 状态 -> 比较 senderId -> 返回过滤结果。
-     */
-    isSelfSentMessage(message) {
-        if (!message || typeof message !== "object") {
-            return false;
-        }
-        const currentAgentId = this.getCurrentAgentId();
-        return (!!currentAgentId &&
-            typeof message.senderId === "string" &&
-            message.senderId === currentAgentId);
-    }
-    /**
-     * 安全读取当前 Agent ID。
-     * 测试替身或异常场景下如果 agentClient 未提供 getState，则返回 null，避免影响消息主流程。
-     */
-    getCurrentAgentId() {
-        const maybeAgentClient = this.agentClient;
-        if (typeof maybeAgentClient.getState !== "function") {
-            return null;
-        }
-        return maybeAgentClient.getState().agentId ?? null;
-    }
-    /**
-     * 将 agentId 安全化为文件名片段：仅保留字母数字下划线短横，其余替换为下划线。
-     * 与 acode 包 TodoStore.filePath 的路径安全化逻辑保持一致。
-     */
-    sanitizeAgentIdForTodoFile(agentId) {
-        return String(agentId).replace(/[^a-zA-Z0-9_-]/g, "_");
-    }
-    /**
-     * 构建 Todo 未完成项提醒通知。
-     *
-     * 触发条件（全部满足）：
-     *   1. 当前 agentId 可读取
-     *   2. ~/.acode/todos/{agentId}.json 存在且可解析
-     *   3. 存在 status !== "completed" 的未完成项
-     *
-     * 行为：
-     *   - 有未完成项：构造轻量系统通知并返回（不持久化）。
-     *   - 全部完成 / 无文件 / 异常：静默返回 null，不阻断 poll_message。
-     *
-     * 通知以 DirectMessage 形式注入，senderId="MCP-System"，不落库、不持久化。
-     * 提示内容简洁，仅提醒有未完成待办，Agent 如需查看详情应调用 todo_read。
-     */
-    async buildTodoReminderNotification() {
-        try {
-            const agentId = this.getCurrentAgentId();
-            if (!agentId)
-                return null;
-            const todoPath = path.join(os.homedir(), ".acode", "todos", `${this.sanitizeAgentIdForTodoFile(agentId)}.json`);
-            let raw;
-            try {
-                raw = await fs.promises.readFile(todoPath, "utf-8");
-            }
-            catch (error) {
-                // 文件不存在视为无 todo，不通知
-                if (error?.code === "ENOENT")
-                    return null;
-                throw error;
-            }
-            const doc = JSON.parse(raw);
-            const todos = Array.isArray(doc.todos)
-                ? doc.todos
-                : [];
-            const incomplete = todos.filter((t) => t &&
-                typeof t === "object" &&
-                typeof t.content === "string" &&
-                (t.status === "pending" ||
-                    t.status === "in_progress" ||
-                    t.status === "cancelled"));
-            if (incomplete.length === 0) {
-                return null;
-            }
-            return {
-                msgId: `todo-reminder-${Date.now()}`,
-                senderId: "MCP-System",
-                senderName: "系统",
-                receiverId: agentId,
-                content: `Todo 列表存在 ${incomplete.length} 项未完成，请调用 todo_read 查看并处理。`,
-                requireReply: false,
-                prompt: "这是一条 Todo 未完成项提醒，自动生成，无需持久化。请评估是否需要继续处理未完成的 Todo，可调用 todo_read 获取完整列表。",
-                timestamp: new Date().toISOString(),
-            };
-        }
-        catch (error) {
-            logger.warn('[McpServer] 构建 Todo 提醒失败: %s', error instanceof Error ? error.message : String(error));
-            return null;
-        }
-    }
-    // ============ 生命周期 ============
-    async start() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        await this.agentClient.initialize();
-        logger.info("[McpServer] MCP Server 已启动，等待连接...");
-        logger.info(`[McpServer] 可用工具: ${MCP_TOOLS.map((t) => t.name).join(", ")}`);
-        logger.info(`[McpServer] 工作目录: ${process.env.AWS_WORKSPACE_PATH || process.cwd()}`);
-        // 检查降级模式配置
-        if (DEGRADED_MODE_ENABLED) {
-            logger.info(`[McpServer] 降级模式已启用，注册失败时将以离线模式继续运行`);
-        }
-        // v1.13.0: 不再加载本地元数据缓存，过期/TODO/回忆状态统一由服务端 memory_status 字段管理
-        // 后台注册：不阻塞 MCP 工具暴露，Agent 可立即接收工具调用
-        this.autoRegisterInBackground();
-        logger.info("[McpServer] MCP Server 已就绪，工具已可用");
-    }
-    /**
-     * 启动租约续期定时器 (v1.21.0)。
-     * 每 60 秒续期一次当前 agent 持有的所有 updating memory 的租约，
-     * 防止租约过期导致其他实例接管。
-     */
-    startLeaseRenewal() {
-        if (this.leaseRenewalTimer)
-            return;
-        this.leaseRenewalTimer = setInterval(async () => {
-            try {
-                const agentId = this.getCurrentAgentId();
-                if (!agentId)
-                    return;
-                const result = await this.memoryStore.renewMemoryLease(McpServer.LEASE_DURATION_MINUTES);
-                // 续期返回 0 说明租约已丢失（被过期清理或被其他 agent 接管），停止续期
-                if (result.renewed === 0) {
-                    logger.warn("[McpServer] 租约已丢失（renewed=0），停止续期定时器");
-                    this.stopLeaseRenewal();
-                }
-            }
-            catch (e) {
-                logger.warn('[McpServer] 续期租约失败: %s', e instanceof Error ? e.message : String(e));
-            }
-        }, McpServer.LEASE_RENEW_INTERVAL_MS);
-        logger.info("[McpServer] 租约续期定时器已启动，间隔: 60s");
-    }
-    /**
-     * 停止租约续期定时器 (v1.21.0)。
-     */
-    stopLeaseRenewal() {
-        if (this.leaseRenewalTimer) {
-            clearInterval(this.leaseRenewalTimer);
-            this.leaseRenewalTimer = null;
-            logger.info("[McpServer] 租约续期定时器已停止");
-        }
-    }
-    /**
-     * 停止 McpServer，清理后台定时器。
-     * 主流程：停止租约续期 -> 释放所有 claim -> 停止 Agent 客户端消息循环。
-     */
-    stop() {
-        this.stopLeaseRenewal();
-        // 释放所有持有的 claim
-        const agentId = this.getCurrentAgentId();
-        if (agentId) {
-            this.memoryStore.releaseAllMemoryClaims().catch(e => logger.warn('[McpServer] 释放 claim 失败: %s', e instanceof Error ? e.message : String(e)));
-        }
-        this.agentClient.stop();
-        logger.info("[McpServer] MCP Server 已停止");
-    }
-    // ============ 记忆统一状态字段 (v1.13.0) ============
-    // v1.13.0 改用服务端 memory_status 字段管理 agent_memory 过期/回忆状态，
-    // 下方工具直接调用服务端接口，本地不再维护元数据缓存。
-    // buildMemoryRecurrenceNotification / handleMemoryRecurrence / handleMemoryRecurrenceComplete
-    // 已在文件其他位置实现（直接使用 this.memoryStore.listExpiredRecentlyMemories / markExpiredMemoriesRecalling / clearRecallingExpiredMemories）。
-    async autoRegister() {
-        const agentConfig = this.agentClient.getAgentConfig();
-        logger.info(`[McpServer] 角色: "${agentConfig.roleName}"`);
-        logger.info(`[McpServer] AgentID: "${agentConfig.agentId || "(自动分配)"}"`);
-        logger.info("[McpServer] 正在请求调度中心注册...");
-        let retryCount = 0;
-        while (true) {
-            try {
-                const result = await this.agentClient.register();
-                logger.info(`[McpServer] 注册成功: ${result.displayName} (${result.agentId})`);
-                logger.info(`[McpServer] 状态: ${result.status}`);
-                // 注册成功后自动启动消息监听
-                this.startListeningInternal();
-                logger.info("[McpServer] 消息监听已自动启动");
-                // 报告 Agent 已启动并等待输入
-                const statusReporter = this.agentClient.getStatusReporter();
-                if (statusReporter) {
-                    statusReporter.reportWaitingInput();
-                }
-                await this.reportMemoryStatsToServer();
-                // 注册成功后检查是否需要从本地恢复永久记忆到 server
-                // 触发条件：server 当前角色 memory 计数为 0（重部署后 DB 为空）
-                // 不依赖 isExisting / profileHandler，确保所有场景都能触发
-                this.maybeSyncPermanentMemoryToServer();
-                return;
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                retryCount++;
-                // 检查是否达到最大重试次数
-                if (REGISTER_MAX_RETRIES > 0 && retryCount >= REGISTER_MAX_RETRIES) {
-                    // 如果启用了降级模式，进入降级模式而不是抛出异常
-                    if (DEGRADED_MODE_ENABLED) {
-                        logger.warn(`[McpServer] 注册超过最大重试次数 (${REGISTER_MAX_RETRIES}次)，进入降级模式`);
-                        this.agentClient.enterDegradedMode();
-                        // 启动消息监听（降级模式下仍可接收本地消息）
-                        this.startListeningInternal();
-                        logger.info("[McpServer] 降级模式：消息监听已启动");
-                        // 启动后台重试注册
-                        this.agentClient.retryRegistrationInBackground(DEGRADED_MODE_RETRY_INTERVAL_MS, DEGRADED_MODE_MAX_RETRIES);
-                        // 报告 Agent 已启动（降级模式）
-                        const statusReporter = this.agentClient.getStatusReporter();
-                        if (statusReporter) {
-                            statusReporter.reportWaitingInput();
-                        }
-                        await this.reportMemoryStatsToServer();
-                        return;
-                    }
-                    // 未启用降级模式，抛出异常
-                    throw new Error(`注册超过最大重试次数 (${REGISTER_MAX_RETRIES}次)，放弃启动: ${errorMessage}`);
-                }
-                logger.warn(`[McpServer] 注册失败，等待重试... (${retryCount}/${REGISTER_MAX_RETRIES}): ${errorMessage}`);
-                await this.delay(REGISTER_RETRY_INTERVAL_MS);
-            }
-        }
-    }
-    /**
-     * 在后台启动注册流程，不阻塞 MCP 工具暴露。
-     * 主流程：autoRegister 包含重试循环和降级模式逻辑，后台执行避免拖慢 MCP Server 就绪时间。
-     */
-    autoRegisterInBackground() {
-        this.autoRegister().catch((error) => {
-            logger.error('[McpServer] 后台注册异常: %s, stack=%s', error instanceof Error ? error.message : String(error), error instanceof Error ? error.stack : '(no stack)');
-        });
-    }
-    /**
-     * 内部方法：启动消息监听（不返回 MCP 响应）
-     */
-    startListeningInternal() {
-        logger.info("[McpServer] startListeningInternal 被调用");
-        const profileHandler = (profile) => {
-            // 收到 Profile 信息后，存储到消息缓冲区
-            logger.info(`[McpServer] profileHandler 被调用，displayName: ${profile.displayName}`);
-            this.messageBuffer.setProfileMessage(profile);
-            this.profileSynced = true;
-            this.syncRoleMemoryStore(profile);
-            this.maybeSyncPermanentMemoryToServer();
-        };
-        // 降级模式下跳过 WebSocket 连接
-        if (this.agentClient.isInDegradedMode()) {
-            logger.info("[McpServer] 降级模式：跳过 WebSocket 连接，仅启动本地消息监听");
-            this.agentClient.start(this.handleIncomingMessage.bind(this), {
-                pollMode: false,
-                profileHandler,
-            });
-            this.activelySyncProfile();
-            return;
-        }
-        this.agentClient.start(this.handleIncomingMessage.bind(this), {
-            pollMode: false,
-            profileHandler,
-        });
-        // 注册时 getProfileByAgentId 会触发 Java markProfileFetched，导致 WebSocket 连接后
-        // Java 不再推送 PROFILE_INFO 消息（AgentWebSocketHandler 检查 hasProfileFetched 跳过）。
-        // 因此 profileHandler 可能永远不会被触发，需要主动获取 profile 同步 hasRoleName。
-        this.activelySyncProfile();
-    }
-    /**
-     * 主动获取 profile 并同步角色存储路径。
-     * 当 Java 侧因 hasProfileFetched=true 跳过 PROFILE_INFO 推送时，
-     * profileHandler 不会被调用，hasRoleName 永远为 false，导致文件变更检测被跳过。
-     * 此方法在 startListeningInternal 后主动拉取 profile，确保 hasRoleName 被正确设置。
-     */
-    activelySyncProfile() {
-        if (this.profileSynced)
-            return;
-        this.agentClient.getProfile().then((profile) => {
-            if (this.profileSynced)
-                return;
-            this.profileSynced = true;
-            logger.info(`[McpServer] 主动获取 profile 成功: displayName=${profile.displayName}, roleName="${profile.roleName ?? '(空)'}"`);
-            this.messageBuffer.setProfileMessage(profile);
-            this.syncRoleMemoryStore(profile);
-            this.maybeSyncPermanentMemoryToServer();
-        }).catch((e) => {
-            logger.warn('[McpServer] 主动获取 profile 失败: %s', e instanceof Error ? e.message : String(e));
-        });
-    }
-    delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}
-//# sourceMappingURL=mcp-server.js.map
+import $ from"node:fs";import U from"node:os";import g from"node:path";import{Server as B}from"@modelcontextprotocol/sdk/server/index.js";import{StdioServerTransport as x}from"@modelcontextprotocol/sdk/server/stdio.js";import{CallToolRequestSchema as q,ListToolsRequestSchema as W}from"@modelcontextprotocol/sdk/types.js";import{AgentClient as H}from"./agent-client.js";import{MCP_SERVER_NAME as z,MCP_SERVER_VERSION as G,REGISTER_MAX_RETRIES as C,REGISTER_RETRY_INTERVAL_MS as Y,DEGRADED_MODE_ENABLED as j,DEGRADED_MODE_RETRY_INTERVAL_MS as K,DEGRADED_MODE_MAX_RETRIES as J}from"./constants.js";import{logger as a}from"./logger.js";import{MCP_TOOLS as O,MEMORY_TOOL_NAMES as F}from"./mcp-tools.js";import{MessageBuffer as V}from"./message-buffer.js";import{ContextManager as X}from"./context-manager.js";import{MemoryCapacityError as Q,MemoryStore as N}from"./memory-store.js";import{ServerMemoryStore as Z}from"./server-memory-store.js";const fe=12e4,ee=3e4,te=new Set(["<",">",":",'"',"/","\\","|","?","*"]);class v{server;agentClient;messageBuffer;memoryStore;roleMemoryStore;sessionContextMemoryStore;initialRoleName="";hasRoleName=!1;contextManager;isSubAgent;leaseRenewalTimer=null;activeLeaseUris=new Set;static LEASE_DURATION_MINUTES=10;static LEASE_RENEW_INTERVAL_MS=6e4;profileSynced=!1;pendingPollMessage=null;syncRoleMemoryStore(e){if(a.info(`[McpServer] syncRoleMemoryStore \u88AB\u8C03\u7528: displayName=${e.displayName}, roleName="${e.roleName??"(\u7A7A)"}", id=${e.id}`),!e.roleName){a.warn(`[McpServer] syncRoleMemoryStore: profile.roleName \u4E3A\u7A7A\uFF0ChasRoleName \u4FDD\u6301 false\u3002profile=${JSON.stringify({id:e.id,displayName:e.displayName,roleName:e.roleName,instanceName:e.instanceName})}`);return}const t=v.sanitizeRoleDirectoryName(e.roleName);this.hasRoleName=!0,t!==this.initialRoleName&&(a.info(`[McpServer] \u89D2\u8272\u76EE\u5F55\u4E0E\u521D\u59CB\u503C\u4E0D\u4E00\u81F4\uFF0C\u91CD\u5EFA roleMemoryStore: "${this.initialRoleName}" -> "${t}"`),this.roleMemoryStore=new N(v.buildRoleMemoryStorePath(t)),this.initialRoleName=t)}maybeSyncPermanentMemoryToServer(){this.doMaybeSyncPermanentMemoryToServer().catch(e=>{a.warn("[McpServer] maybeSyncPermanentMemoryToServer \u5F02\u5E38: %s, stack=%s",e instanceof Error?e.message:String(e),e instanceof Error?e.stack:"(no stack)")})}async doMaybeSyncPermanentMemoryToServer(){a.info("[McpServer] maybeSyncPermanentMemoryToServer \u5F00\u59CB\uFF0CinitialRoleName="+this.initialRoleName);let e;try{e=await this.memoryStore.getStats()}catch(s){a.warn("[McpServer] \u83B7\u53D6 server \u8BB0\u5FC6\u7EDF\u8BA1\u5931\u8D25\uFF0C\u8DF3\u8FC7\u540C\u6B65:",s instanceof Error?s.message:s);return}const t=e.by_type.project_memory?.count??0;if(a.info(`[McpServer] server memory \u8BA1\u6570=${t}\uFF0C\u662F\u5426\u9700\u8981\u540C\u6B65=${t===0}`),t>0)return;let r=[];try{r=await this.roleMemoryStore.listByType("project_memory"),a.info(`[McpServer] \u89D2\u8272\u5B50\u76EE\u5F55\u8BFB\u53D6\u5230 ${r.length} \u6761\u6C38\u4E45\u8BB0\u5FC6`)}catch(s){a.warn("[McpServer] \u8BFB\u53D6\u89D2\u8272\u5B50\u76EE\u5F55\u6C38\u4E45\u8BB0\u5FC6\u5931\u8D25:",s instanceof Error?s.message:s)}if(r.length===0){const s=g.dirname(v.buildRoleMemoryStorePath(this.initialRoleName));a.info(`[McpServer] \u5C1D\u8BD5\u4ECE\u9057\u7559\u76EE\u5F55\u8BFB\u53D6: ${s}`);try{const l=await new N(s).listByType("project_memory");l.length>0&&(a.info(`[McpServer] \u4ECE\u9057\u7559\u76EE\u5F55\u8BFB\u53D6\u5230 ${l.length} \u6761\u6C38\u4E45\u8BB0\u5FC6`),r=l)}catch(o){a.warn("[McpServer] \u8BFB\u53D6\u9057\u7559\u76EE\u5F55\u6C38\u4E45\u8BB0\u5FC6\u5931\u8D25:",o instanceof Error?o.message:o)}}if(r.length===0){a.info("[McpServer] \u672C\u5730\u4E5F\u65E0\u6C38\u4E45\u8BB0\u5FC6\uFF0C\u8DF3\u8FC7\u540C\u6B65");return}let n=0,i=0;for(const s of r)try{await this.memoryStore.createMemory({memory_type:"project_memory",uri:s.uri,title:s.title,content:s.content,keywords:s.keywords,bound_files:s.bound_files,file_md5_map:s.file_md5_map,last_check_time:s.last_check_time}),n++,a.info(`[McpServer] \u540C\u6B65\u6C38\u4E45\u8BB0\u5FC6\u6210\u529F: ${s.uri}`)}catch(o){const l=o instanceof Error?o.message:String(o);l.includes("already exists")||l.includes("Memory already exists")||a.warn(`[McpServer] \u540C\u6B65\u6C38\u4E45\u8BB0\u5FC6\u5931\u8D25 (${s.uri}): ${l}`),i++}a.info(`[McpServer] \u6C38\u4E45\u8BB0\u5FC6\u540C\u6B65\u5B8C\u6210: \u6210\u529F ${n}, \u8DF3\u8FC7 ${i}, \u5171 ${r.length}`),await this.reportMemoryStatsToServer()}normalizeBoundFilePath(e){const t=String(e||"").trim().replace(/\\/g,"/");if(!t)return t;const r=t.startsWith("@/")?t.substring(1):t;return r.startsWith("./")?r:`./${r.replace(/^\/+/,"")}`}normalizeBoundFiles(e){return!e||!Array.isArray(e)?e:e.map(t=>this.normalizeBoundFilePath(String(t)))}async validateBoundFilesExist(e){if(!e||e.length===0)return;const t=process.env.AWS_WORKSPACE_PATH||process.cwd(),{access:r}=await import("node:fs/promises"),n=[];for(const i of e)try{const s=g.resolve(t,i);await r(s)}catch{n.push(i)}if(n.length>0)throw new Error(`\u7ED1\u5B9A\u7684\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u8BF7\u786E\u8BA4\u6587\u4EF6\u8DEF\u5F84\u6B63\u786E\u540E\u518D\u91CD\u65B0\u63D0\u4EA4:
+${n.map(i=>`  - ${i}`).join(`
+`)}`)}toMemoryWriteResult(e){return{id:e.id,uri:e.uri,domain:e.domain,path:e.path,title:e.title,memory_type:e.memory_type,createdAt:e.createdAt,updatedAt:e.updatedAt,version:e.version,keywords:e.keywords,bound_files:e.bound_files}}toMemoryRecordWithMetadata(e){return{id:e.id,uri:e.uri,domain:e.domain,path:e.path,title:e.title,content:e.content,memory_type:e.memory_type,createdAt:e.createdAt,updatedAt:e.updatedAt,version:e.version,keywords:e.keywords,bound_files:e.bound_files,file_md5_map:e.file_md5_map,memory_status:e.memory_status,updating_agent_id:e.updating_agent_id,last_check_time:e.last_check_time}}constructor(){this.agentClient=new H,this.messageBuffer=new V,this.initialRoleName=v.resolveRoleMemoryDirectoryName(),this.hasRoleName=!!process.env.AWS_ROLE_NAME;const e=v.resolveMemoryStorePaths();this.memoryStore=new Z(this.agentClient),this.roleMemoryStore=new N(e.rolePath),this.sessionContextMemoryStore=new N(g.join(g.dirname(e.rolePath),"..","session_context")),this.isSubAgent=process.env.AWS_SUB_AGENT==="true",this.contextManager=new X(this.sessionContextMemoryStore),this.server=new B({name:z,version:G},{capabilities:{tools:{}}}),this.setupHandlers()}setupHandlers(){this.server.setRequestHandler(W,async()=>({tools:this.isSubAgent?O.filter(t=>F.has(t.name)):O})),this.server.setRequestHandler(q,async e=>{const{name:t,arguments:r}=e.params;try{const n=await this.handleToolCall(t,r);return{content:[{type:"text",text:JSON.stringify(n,null,2)}]}}catch(n){const i=n instanceof Error?n.message:String(n),s=n instanceof Q?{error:i,...n.details}:{error:i};return a.error("[McpServer] \u5DE5\u5177\u8C03\u7528\u5F02\u5E38: tool=%s, error=%s, stack=%s",t,i,n instanceof Error?n.stack:"(no stack)"),{content:[{type:"text",text:JSON.stringify(s,null,2)}],isError:!0}}})}async handleToolCall(e,t){const r=t?._aws_sub_agent===!0,n=t?._aws_silent_poll===!0,i={...t};delete i._aws_sub_agent,delete i._aws_silent_poll;const s=r?null:this.agentClient.getStatusReporter();s&&!n&&s.reportToolUse(e,this.sanitizeToolUseArgs(e,i));try{const o=await this.executeToolCall(e,i);if(s&&!n){const l=this.stripAutoDelegateForReporting(o);l!==null&&(s.reportToolResult(l),s.reportThinking())}return o}catch(o){throw s&&!n&&s.reportToolError(o),o}}async executeToolCall(e,t){if(this.isSubAgent&&!F.has(e))throw new Error(`Sub-agent is not allowed to call tool: ${e}`);switch(e){case"get_colleague":return await this.agentClient.discoverColleagues();case"get_group_rooms":return await this.agentClient.discoverGroupRooms();case"get_profile":return await this.agentClient.getProfile();case"hire_colleague":return await this.handleHireColleague(t);case"hire_colleagues_batch":return await this.handleHireColleaguesBatch(t);case"send_group":return await this.handleSendGroup(t);case"send_private":return await this.handleSendPrivate(t);case"poll_message":return await this.handlePollMessage();case"get_message":return this.handleGetMessage();case"get_dm_history":return await this.handleGetDmHistory(t);case"get_group_history":return await this.handleGetGroupHistory(t);case"my_task":return await this.agentClient.getMyTasks();case"create_task_instance_comment":return await this.handleCreateTaskInstanceComment(t);case"submit_task_result":return await this.handleSubmitTaskResult(t);case"start_task_rollback":return await this.handleStartTaskRollback(t);case"finish_task_rollback":return await this.handleFinishTaskRollback(t);case"reject_task":return await this.handleRejectTask(t);case"terminate_task":return await this.handleTerminateTask(t);case"create_memory":return await this.handleCreateMemory(t);case"read_memory":return await this.handleReadMemory(t);case"update_memory":return await this.handleUpdateMemory(t);case"delete_memory":return await this.handleDeleteMemory(t);case"search_memory":return await this.handleSearchMemory(t);case"list_memories":return await this.handleListMemories(t);case"get_memory_stats":return await this.handleGetMemoryStats(t);case"list_memories_by_file":return await this.handleListMemoriesByFile(t);case"abandon_memory_update":return await this.handleAbandonMemoryUpdate(t);case"memory_recurrence":return await this.handleMemoryRecurrence(t);case"memory_recurrence_complete":return await this.handleMemoryRecurrenceComplete();default:throw new Error(`Unknown tool: ${e}`)}}static MEMORY_TYPES=["recently_memory","agent_memory","project_memory","session_context"];static MEMORY_TOOL_NAMES=new Set(["create_memory","read_memory","update_memory","delete_memory","search_memory","list_memories","get_memory_stats","list_memories_by_file","abandon_memory_update","memory_recurrence","memory_recurrence_complete"]);static findAgentsworkDirSync(e){let t=g.resolve(e);for(;;){if($.existsSync(g.join(t,".agentswork")))return g.join(t,".agentswork");const r=g.dirname(t);if(r===t)break;t=r}return g.join(g.resolve(e),".agentswork")}static sanitizeRoleDirectoryName(e){return String(e||"").trim().split("").map(r=>te.has(r)||r.charCodeAt(0)<32?"_":r).join("").replace(/^\.+|\.+$/g,"").trim()||"default-role"}static resolveRoleMemoryDirectoryName(){return v.sanitizeRoleDirectoryName(process.env.AWS_ROLE_NAME||"")}static buildRoleMemoryStorePath(e){const t=process.env.AWS_WORKSPACE_PATH||process.cwd(),r=v.findAgentsworkDirSync(t);return g.join(r,"memory","memory",v.sanitizeRoleDirectoryName(e))}static resolveMemoryStorePaths(){const e=String(process.env.AWS_MEMORY_STORE_PATH||"").trim();if(e)return{instancePath:e,rolePath:e};const t=process.env.AWS_WORKSPACE_PATH||process.cwd(),r=v.findAgentsworkDirSync(t),n=String(process.env.AWS_INSTANCE_MEMORY_STORE_PATH||"").trim()||g.join(r,"memory","server-managed"),i=String(process.env.AWS_ROLE_MEMORY_STORE_PATH||"").trim()||g.join(r,"memory","memory",v.resolveRoleMemoryDirectoryName());return{instancePath:n,rolePath:i}}getRequiredString(e,t){const r=e[t];if(typeof r!="string"||r.trim().length===0)throw new Error(`${t} is required`);return r}getOptionalString(e,t){const r=e[t];return typeof r=="string"?r:void 0}getOptionalNumber(e,t){const r=e[t];return typeof r=="number"?r:void 0}getOptionalStringArray(e,t){const r=e[t];return Array.isArray(r)?r.map(n=>String(n)):void 0}getOptionalMemoryType(e){const t=e.memory_type;if(t!==void 0)return this.parseMemoryType(t)}parseMemoryType(e){if(typeof e!="string")throw new Error(`Invalid memory_type: ${String(e)}`);const t=e.trim();if(!this.isMemoryType(t))throw new Error(`Invalid memory_type: ${e}`);return t}isMemoryType(e){return v.MEMORY_TYPES.some(t=>t===e)}getMemoryStoreForType(e){return this.memoryStore}async readMemoryFromScopedStores(e){if(e.memory_type)return await this.memoryStore.readMemory(e);const t=await this.memoryStore.readMemory({...e,memory_type:"project_memory"}).catch(()=>null);return t||await this.memoryStore.readMemory(e)}async backupProjectMemoryToLocal(e){try{const t=await this.memoryStore.readMemory({uri:e.uri,memory_type:"project_memory"});t&&(await this.roleMemoryStore.deleteMemory({uri:e.uri,memory_type:"project_memory"}).catch(()=>{}),await this.roleMemoryStore.createMemory(t))}catch(t){a.warn("[McpServer] backupProjectMemoryToLocal \u5931\u8D25: uri=%s",e.uri,t)}}async removeProjectMemoryLocalBackup(e){try{await this.roleMemoryStore.deleteMemory({uri:e,memory_type:"project_memory"})}catch(t){a.warn("[McpServer] removeProjectMemoryLocalBackup \u5931\u8D25: uri=%s",e,t)}}async findMemoryStoreForMutation(e){return e.memory_type?{store:this.memoryStore,memory_type:e.memory_type}:await this.memoryStore.readMemory({uri:e.uri,memory_type:"project_memory"}).catch(()=>null)?{store:this.memoryStore,memory_type:"project_memory"}:{store:this.memoryStore}}async reportMemoryStatsToServer(){const e=await this.memoryStore.getStats();try{await this.agentClient.reportMemoryStats(e)}catch(t){a.warn("[McpServer] \u4E0A\u62A5 memory \u7EDF\u8BA1\u5931\u8D25:",t)}}sanitizeToolUseArgs(e,t){if(!v.MEMORY_TOOL_NAMES.has(e))return t;const r={},n=this.getOptionalString(t,"uri"),i=this.getOptionalString(t,"memory_type"),s=this.getOptionalNumber(t,"limit");return n&&(r.uri=n),i&&(r.memory_type=i),typeof s=="number"&&(r.limit=s),e==="search_memory"&&(r.queryProvided=typeof t.query=="string"&&t.query.length>0,t.keyword_mode!==void 0&&(r.keyword_mode=t.keyword_mode)),r}stripAutoDelegateForReporting(e){if(!e||typeof e!="object")return e;const t=e,r=Array.isArray(t.directMessages)?t.directMessages:[],n=Array.isArray(t.groupMessages)?t.groupMessages:[],i=l=>!!l&&typeof l=="object"&&"_acodeAutoDelegate"in l;if(!r.some(i))return e;const o=r.filter(l=>!i(l));return o.length===0&&n.length===0?null:{...t,directMessages:o}}async handleCreateMemory(e){const t=this.normalizeBoundFiles(this.getOptionalStringArray(e,"bound_files"));await this.validateBoundFilesExist(t);let r,n;if(t&&t.length>0){r={};for(const o of t){const l=await this.calculateFileMd5(o);l&&(r[o]=l)}n=new Date().toISOString()}const i={memory_type:this.parseMemoryType(this.getRequiredString(e,"memory_type")),uri:this.getRequiredString(e,"uri"),title:this.getOptionalString(e,"title"),content:this.getRequiredString(e,"content"),keywords:this.getOptionalStringArray(e,"keywords"),bound_files:t,file_md5_map:r,last_check_time:n},s=await this.memoryStore.createMemory(i);return i.memory_type==="project_memory"&&this.backupProjectMemoryToLocal(i).catch(o=>{a.warn("[McpServer] \u5907\u4EFD project_memory \u5230\u672C\u5730\u5931\u8D25:",o)}),await this.reportMemoryStatsToServer(),this.toMemoryWriteResult(s)}async handleReadMemory(e){const t={uri:this.getRequiredString(e,"uri"),memory_type:this.getOptionalMemoryType(e)};return await this.readMemoryFromScopedStores(t)}async handleUpdateMemory(e){const t=typeof e.old_string=="string"||typeof e.new_string=="string",r=typeof e.old_string=="string"&&typeof e.new_string=="string",n=this.getOptionalString(e,"append");if(t&&!r)throw new Error("old_string and new_string must be provided together");const i={uri:this.getRequiredString(e,"uri"),memory_type:this.getOptionalMemoryType(e),title:this.getOptionalString(e,"title"),old_string:this.getOptionalString(e,"old_string"),new_string:this.getOptionalString(e,"new_string"),append:n,keywords:this.getOptionalStringArray(e,"keywords"),bound_files:this.normalizeBoundFiles(this.getOptionalStringArray(e,"bound_files"))},s=await this.findMemoryStoreForMutation(i),o=await s.store.readMemory({uri:i.uri,memory_type:s.memory_type??i.memory_type});i.bound_files!==void 0?await this.validateBoundFilesExist(i.bound_files):o?.bound_files&&o.bound_files.length>0&&await this.validateBoundFilesExist(o.bound_files);const l=i.bound_files??o?.bound_files;let m,y;if(l&&l.length>0){m={};for(const u of l){const S=await this.calculateFileMd5(u);S&&(m[u]=S)}y=new Date().toISOString()}const h=await s.store.updateMemory({...i,memory_type:s.memory_type??i.memory_type,file_md5_map:m,last_check_time:y});if(s.memory_type==="project_memory"&&this.backupProjectMemoryToLocal({...i,memory_type:"project_memory",file_md5_map:m,last_check_time:y}).catch(u=>{a.warn("[McpServer] \u5907\u4EFD project_memory \u66F4\u65B0\u5230\u672C\u5730\u5931\u8D25:",u)}),await this.reportMemoryStatsToServer(),s.memory_type==="project_memory"&&o?.memory_status==="updating")try{await this.memoryStore.releaseMemoryClaim(i.uri),this.activeLeaseUris.delete(i.uri),this.activeLeaseUris.size===0&&this.stopLeaseRenewal()}catch(u){a.warn("[McpServer] \u91CA\u653E memory claim \u5931\u8D25: uri=%s, error=%s",i.uri,u instanceof Error?u.message:String(u))}return this.toMemoryWriteResult(h)}async handleDeleteMemory(e){const t=typeof e.uri=="string"?e.uri:void 0,r=Array.isArray(e.memories)?e.memories:void 0;if(t&&r&&r.length>0)throw new Error("delete_memory \u4E0D\u652F\u6301\u540C\u65F6\u4F20\u5165 uri \u548C memories\uFF0C\u8BF7\u4E8C\u9009\u4E00");if(!t&&(!r||r.length===0))throw new Error("delete_memory \u9700\u8981 uri \u6216 memories \u53C2\u6570");if(t){const o=this.getOptionalMemoryType(e);return{deleted:await this.deleteMemorySingle(t,o)}}let n=0;const i=[],s=[];for(let o=0;o<r.length;o++){const l=r[o];if(typeof l!="object"||l===null){s.push({uri:String(l),reason:`memories[${o}] \u4E0D\u662F\u5BF9\u8C61`});continue}const m=l,y=typeof m.uri=="string"?m.uri:"";if(!y){s.push({uri:"",reason:`memories[${o}].uri \u7F3A\u5931`});continue}const h=typeof m.memory_type=="string"?this.parseMemoryType(m.memory_type):void 0;try{await this.deleteMemorySingle(y,h,!0)?n++:i.push(y)}catch(u){s.push({uri:y,reason:u instanceof Error?u.message:String(u)})}}return n>0&&await this.reportMemoryStatsToServer(),{deleted:n,not_found:i,failed:s}}async deleteMemorySingle(e,t,r=!1){const n={uri:e,memory_type:t},i=await this.findMemoryStoreForMutation(n),s=i.memory_type??n.memory_type,o=await i.store.deleteMemory({...n,memory_type:s});return o&&(s==="project_memory"&&this.removeProjectMemoryLocalBackup(e).catch(l=>{a.warn("[McpServer] \u5220\u9664 project_memory \u672C\u5730\u5907\u4EFD\u5931\u8D25:",l)}),r||await this.reportMemoryStatsToServer()),o}async handleSearchMemory(e){const t=this.getOptionalString(e,"scope"),r=t==="children"||t==="all"?t:"own",n=this.getOptionalString(e,"keyword_mode"),i=n==="all"?"all":n==="any"?"any":void 0,s={query:this.getRequiredString(e,"query"),limit:this.getOptionalNumber(e,"limit"),memory_type:this.getOptionalMemoryType(e),keywords:this.getOptionalStringArray(e,"keywords"),keyword_mode:i,scope:r};if(r==="children")return await this.memoryStore.searchMemory(s);const o=await this.searchOwnMemories(s);if(r==="own")return o;const l=await this.memoryStore.searchMemory({...s,scope:"children"});return this.mergeSearchResults(o,l,s.limit)}async searchOwnMemories(e){return await this.memoryStore.searchMemory(e)}mergeSearchResults(e,t,r){const n=new Set,i=typeof r=="number"&&r>0?r:10,s=[...e.results,...t.results].filter(o=>{const l=o.uri;return n.has(l)?!1:(n.add(l),!0)}).sort((o,l)=>l.updatedAt.localeCompare(o.updatedAt)).slice(0,i);return{query:e.query||t.query,results:s}}async handleListMemories(e){const t=this.getRequiredString(e,"memory_type");if(t==="project_memory"||t==="session_context")throw new Error(`Invalid memory_type: ${t}`);return await this.memoryStore.listByType(t)}async handleGetMemoryStats(e){const t=await this.memoryStore.getStats(),r=this.getOptionalMemoryType(e);return r?{memory_type:r,total:t.by_type[r].count,by_type:{[r]:t.by_type[r]}}:t}async handleListMemoriesByFile(e){const t=this.getRequiredString(e,"file_path"),r=this.normalizeBoundFilePath(t),n=this.getOptionalMemoryType(e),i=this.getOptionalString(e,"scope"),s=i==="own"||i==="children"?i:"all",o=async()=>await this.memoryStore.listByFile(r,{memory_type:n,scope:"children"}).catch(()=>[]);if(s==="children"){const u=await o();return{file_path:r,count:u.length,memories:u.map(S=>this.toMemoryRecordWithMetadata(S))}}const l=await this.collectOwnMemoriesByFile(r,n);if(s==="own")return{file_path:r,count:l.length,memories:l.map(u=>this.toMemoryRecordWithMetadata(u))};const m=await o(),y=new Set(l.map(u=>u.id)),h=[...l];for(const u of m)y.has(u.id)||(h.push(u),y.add(u.id));return h.sort((u,S)=>S.updatedAt.localeCompare(u.updatedAt)),{file_path:r,count:h.length,memories:h.map(u=>this.toMemoryRecordWithMetadata(u))}}mergeIdDedupe(e,t){const r=new Set;for(const i of e)i.id&&r.add(i.id);const n=[...e];for(const i of t)i.id&&!r.has(i.id)&&(n.push(i),r.add(i.id));return n.sort((i,s)=>s.updatedAt.localeCompare(i.updatedAt)),n}async searchChildMemoriesByFileLocal(e,t){const r=process.env.AWS_WORKSPACE_PATH||process.cwd(),n=this.normalizeBoundFilePath(e),s=(n.startsWith("./")?n.substring(2):n).split("/"),o=[],l=new Set,{access:m,readdir:y,readFile:h}=await import("node:fs/promises");for(let u=s.length-1;u>=1;u--){const S=s.slice(0,u),T="./"+s.slice(u).join("/"),A=g.join(r,...S);if(A===r)continue;const c=g.join(A,".agentswork");try{await m(c)}catch{continue}const p=g.join(c,"memory","memory");let R;try{R=(await y(p,{withFileTypes:!0})).filter(f=>f.isDirectory()).map(f=>f.name)}catch{continue}for(const _ of R){const f=g.join(p,_);let I;try{I=await y(f)}catch{continue}for(const d of I){if(!d.endsWith(".json"))continue;const w=g.join(f,d);let M;try{M=await h(w,"utf-8")}catch{continue}let b;try{b=JSON.parse(M)}catch{continue}if(b.by_uri)for(const[P,k]of Object.entries(b.by_uri)){if(!k)continue;const D=k.id||P;l.has(D)||t&&k.memory_type!==t||k.bound_files&&k.bound_files.length>0&&k.bound_files.some(L=>this.normalizeBoundFilePath(L)===T)&&(l.add(D),o.push({...k,uri:k.uri||P}))}}}}return o.sort((u,S)=>S.updatedAt.localeCompare(u.updatedAt)),o}async collectOwnMemoriesByFile(e,t){return await this.memoryStore.listByFile(e,{memory_type:t})}async handleAbandonMemoryUpdate(e){const t=this.getRequiredString(e,"uri"),r=this.getOptionalMemoryType(e),n=await this.memoryStore.readMemory({uri:t,memory_type:r});return n?.bound_files&&n.bound_files.length>0&&await this.validateBoundFilesExist(n.bound_files),await this.memoryStore.releaseMemoryClaim(t),n?.memory_type==="project_memory"&&this.backupProjectMemoryToLocal({uri:t,memory_type:"project_memory"}).catch(i=>{a.info(`[McpServer] abandon_memory_update: \u540C\u6B65\u672C\u5730\u5907\u4EFD\u5931\u8D25: ${t}`,i)}),this.activeLeaseUris.delete(t),this.activeLeaseUris.size===0&&this.stopLeaseRenewal(),{success:!0,uri:t,message:"Memory \u66F4\u65B0\u72B6\u6001\u5DF2\u6E05\u9664"}}async handleMemoryRecurrence(e){const t=Math.max(1,e?.limit??10),r=await this.memoryStore.listExpiredRecentlyMemories();if(r.length===0)return{memories:[],count:0,remaining:0,totalExpired:0,message:"\u6CA1\u6709\u5F85\u56DE\u5FC6\u7684\u5373\u5C06\u9057\u5FD8\u8BB0\u5FC6\u3002"};const i=[...r].sort((m,y)=>{const h=new Date(m.expiresAt||m.createdAt||0).getTime(),u=new Date(y.expiresAt||y.createdAt||0).getTime();return h-u}).slice(0,t),s=i.map(m=>m.uri);try{await this.memoryStore.markExpiredMemoriesRecalling(s)}catch(m){a.warn("[McpServer] \u6807\u8BB0\u8FC7\u671F\u8BB0\u5FC6\u4E3A recalling \u5931\u8D25: uriCount=%s, error=%s",s.length,m instanceof Error?m.message:String(m))}const o=Math.max(0,r.length-i.length);return{memories:i.map(m=>({uri:m.uri,title:m.title,domain:m.domain,path:m.path,memory_status:"recalling",contentPreview:typeof m.content=="string"&&m.content.length>200?m.content.substring(0,200)+"...":m.content,createdAt:m.createdAt,updatedAt:m.updatedAt})),count:i.length,limit:t,remaining:o,totalExpired:r.length,message:o>0?`\u672C\u6B21\u5904\u7406 ${i.length} \u6761\u5373\u5C06\u9057\u5FD8\u7684\u8BB0\u5FC6\uFF08\u6700\u65E9\u8FC7\u671F\u4F18\u5148\uFF09\uFF0C\u5269\u4F59 ${o} \u6761\u5F85\u5904\u7406\u3002
+\u8BF7\u5BA1\u67E5\u540E\u51B3\u5B9A\uFF08update_memory \u7EED\u671F\uFF0CTTL \xD72 / \u4E0D\u5904\u7406\uFF09\uFF0C
+\u5B8C\u6210\u540E\u8C03\u7528 memory_recurrence_complete \u6E05\u7406\uFF0C\u518D\u8C03 memory_recurrence \u5904\u7406\u4E0B\u4E00\u6279\u3002`:`\u5DF2\u5904\u7406\u5168\u90E8 ${i.length} \u6761\u5373\u5C06\u9057\u5FD8\u7684\u8BB0\u5FC6\u3002
+\u8BF7\u5BA1\u67E5\u540E\u51B3\u5B9A\uFF08update_memory \u7EED\u671F\uFF0CTTL \xD72 / \u4E0D\u5904\u7406\uFF09\uFF0C
+\u5B8C\u6210\u540E\u8C03\u7528 memory_recurrence_complete \u6E05\u7406\u3002`}}async handleMemoryRecurrenceComplete(){let e={deleted:0,uris:[]};try{e=await this.memoryStore.clearRecallingExpiredMemories()}catch(r){a.warn("[McpServer] \u6E05\u7406\u56DE\u5FC6\u4E2D\u8BB0\u5FC6\u5931\u8D25: %s",r instanceof Error?r.message:String(r))}await this.reportMemoryStatsToServer();const t=e.deleted??0;return{deleted:t,uris:e.uris??[],message:t===0?"\u6CA1\u6709\u5F85\u758F\u7406\u7684\u56DE\u5FC6\u4E2D\u8BB0\u5FC6\u3002":`\u5DF2\u6E05\u7406 ${t} \u6761\u5DF2\u8FC7\u671F\u8FD1\u671F\u8BB0\u5FC6\u3002`}}async fetchRecentMessages(){const[e,t]=await Promise.all([this.agentClient.getDmHistory(void 0,200).catch(()=>({messages:[],count:0})),this.agentClient.getGroupHistory(200).catch(()=>({messages:[],count:0}))]),r=[...e.messages,...t.messages];return r.sort((n,i)=>new Date(n.timestamp).getTime()-new Date(i.timestamp).getTime()),r}async handleSendGroup(e){if(!e.content||typeof e.content!="string")throw new Error("content is required");return this.recordMessageTokenUsage(e.content).catch(t=>a.warn("[McpServer] Failed to record token usage",t)),await this.agentClient.sendGroupMessage(e.content,e.projectName,e.roomId)}async recordMessageTokenUsage(e){try{const t=await this.agentClient.getProfile().catch(()=>null);if(!t?.runtimeSessionId)return;const r=this.contextManager.estimateTokens(e);await this.contextManager.recordUsage(t.runtimeSessionId,{input:0,output:r})}catch{}}async handleHireColleague(e){if(!e.workspacePath||typeof e.workspacePath!="string")throw new Error("workspacePath is required");return await this.agentClient.hireColleague(e)}async handleHireColleaguesBatch(e){if(!Array.isArray(e.items)||e.items.length===0)throw new Error("items is required and must contain at least one hire item");return e.items.forEach((t,r)=>{if(!t.workspacePath||typeof t.workspacePath!="string")throw new Error(`items[${r}].workspacePath is required`)}),await this.agentClient.hireColleaguesBatch(e)}async handleSendPrivate(e){if(!e.targetId||typeof e.targetId!="string")throw new Error("targetId is required");if(!e.content||typeof e.content!="string")throw new Error("content is required");return this.recordMessageTokenUsage(e.content).catch(t=>a.warn("[McpServer] Failed to record token usage",t)),await this.agentClient.sendDirectMessage(e.targetId,e.content,e.waitReply,e.replyToCallId,e.timeoutMs)}async handleCreateTaskInstanceComment(e){const t=this.getRequiredString(e,"taskInstanceId"),r=this.getRequiredString(e,"content");return await this.agentClient.createTaskInstanceComment({taskInstanceId:t,content:r})}async prependMemoryNotification(e,t){const r=await t();return r?(e.directMessages.unshift(r),!0):!1}async handlePollMessage(){if(a.info("[McpServer] handlePollMessage \u88AB\u8C03\u7528"),this.pendingPollMessage)return a.info("[McpServer] poll_message \u5DF2\u6709\u8FDB\u884C\u4E2D\u7684\u8C03\u7528\uFF0C\u7B49\u5F85\u5176\u5B8C\u6210"),await this.pendingPollMessage;this.pendingPollMessage=(async()=>await this.doPollMessage())();try{return await this.pendingPollMessage}finally{this.pendingPollMessage=null}}async doPollMessage(){a.info("[McpServer] doPollMessage \u88AB\u8C03\u7528"),await this.hydrateUnreadMessagesFromServer({blockIfEmpty:!1,includePipelineTasks:!0});const e=await this.buildTodoReminderNotification(),t=this.messageBuffer.get();if(t.directMessages.length>0||t.groupMessages.length>0)return e&&t.directMessages.unshift(e),this.buildPollResult(t);if(e)return this.buildPollResult({directMessages:[e],groupMessages:[]});const r=await this.checkAllLocalNonUrgentNotifications();if(r.length>0)return this.buildPollResult({directMessages:r,groupMessages:[]});let n=!1;for(;;){if(!n){const m=this.agentClient.getStatusReporter();if(m){const y=m.getCurrentStatus();y.status==="tool_using"&&y.actionDetail!=null&&y.actionDetail.includes("poll_message")||m.reportToolUse("poll_message",{}),n=!0}}const i=await this.messageBuffer.poll(ee);if(i.directMessages.length>0||i.groupMessages.length>0)return this.buildPollResult(i);await this.hydrateUnreadMessagesFromServer({blockIfEmpty:!1,includePipelineTasks:!0});const s=await this.buildTodoReminderNotification(),o=this.messageBuffer.get();if(o.directMessages.length>0||o.groupMessages.length>0)return s&&o.directMessages.unshift(s),this.buildPollResult(o);if(s)return this.buildPollResult({directMessages:[s],groupMessages:[]});const l=await this.checkAllLocalNonUrgentNotifications(!1);if(l.length>0)return this.buildPollResult({directMessages:l,groupMessages:[]})}}async checkAllLocalNonUrgentNotifications(e=!0){const t=[],r=await this.buildMemoryRecurrenceNotification();if(r&&t.push(r),e){const i=await this.buildMemoryFileChangeNotification();i&&t.push(i)}const n=await this.buildMemoryCleanupNotification();return n&&t.push(n),t}buildPollResult(e,t=!0){return{directMessages:e.directMessages,groupMessages:e.groupMessages,fromBuffer:t,systemMessages:[]}}parsePositiveIntegerEnv(e,t){const r=process.env[e];if(!r||!r.trim())return t;const n=Number.parseInt(r,10);return!Number.isFinite(n)||n<=0?(a.warn(`[McpServer] ${e} \u65E0\u6548\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C ${t}ms`),t):n}sleep(e){return e<=0?Promise.resolve():new Promise(t=>setTimeout(t,e))}async buildMemoryCleanupNotification(){try{const e=await this.memoryStore.getStats(),t=Object.entries(e.by_type).filter(([,o])=>o.listable&&o.exceeded),r=Object.entries(e.by_type).flatMap(([o,l])=>l.listable?Object.entries(l.by_domain).filter(([,m])=>m.exceeded).map(([m,y])=>({memoryType:o,domain:m,domainStats:y})):[]);if(t.length===0&&r.length===0)return null;const n=t.map(([o,l])=>`${o} \u5F53\u524D ${l.domainCount} \u4E2A URI domain \u7C7B\u578B\uFF0C\u5EFA\u8BAE\u4E0A\u9650 ${l.limit} \u4E2A\uFF0C\u786C\u4E0A\u9650 ${l.hardLimit} \u4E2A`),i=r.map(({memoryType:o,domain:l,domainStats:m})=>`${o}/${l} \u7C7B\u578B\u4E0B\u5F53\u524D ${m.count} \u6761 memory\uFF0C\u5EFA\u8BAE\u4E0A\u9650 ${m.limit} \u6761\uFF0C\u786C\u4E0A\u9650 ${m.hardLimit} \u6761`),s=["\u8BF7\u8C03\u7528 get_memory_stats \u67E5\u770B\u5BB9\u91CF\u8BE6\u60C5","\u8C03\u7528 list_memories \u6309\u7C7B\u578B\u67E5\u770B\u8D85\u9650\u8BB0\u5FC6","\u5220\u9664\u4E0D\u518D\u9700\u8981\u7684 recently_memory","\u66F4\u65B0 agent_memory \u7EED\u671F\uFF08TTL \xD72\uFF09\u6216\u5220\u9664\u8FC7\u671F\u9879"].join("\uFF1B");return{msgId:`memory-cleanup-${Date.now()}`,senderId:"MCP-System",senderName:"\u7CFB\u7EDF",receiverId:this.getCurrentAgentId()||void 0,content:`\u672C\u5730 memory \u5DF2\u8D85\u8FC7\u5EFA\u8BAE\u5BB9\u91CF\uFF0C\u9700\u8981\u6574\u7406\u3002${[...n,...i].join("\uFF1B")}\u3002${s}\u3002`,requireReply:!1,prompt:"\u8FD9\u662F\u4E00\u6761\u672C\u5730 memory \u5BB9\u91CF\u6574\u7406\u63D0\u9192\uFF0C\u81EA\u52A8\u751F\u6210\uFF0C\u65E0\u9700\u6301\u4E45\u5316\u3002\u8BF7\u4F18\u5148\u6574\u7406\u5DF2\u8D85\u8FC7\u5EFA\u8BAE\u4E0A\u9650\u7684\u77ED\u671F/\u8FD1\u671F memory \u7C7B\u578B\uFF0C\u6216\u5177\u4F53\u7C7B\u578B\u4E0B\u7684 memory \u6761\u76EE\u3002",timestamp:new Date().toISOString(),_acodeAutoDelegate:{type:"memory_cleanup",uris:r.map(o=>`${o.memoryType}/${o.domain}`)}}}catch(e){return a.warn("[McpServer] \u6784\u5EFA\u672C\u5730 memory \u6574\u7406\u63D0\u9192\u5931\u8D25: %s",e instanceof Error?e.message:String(e)),null}}async buildMemoryRecurrenceNotification(){try{const e=await this.memoryStore.listExpiredRecentlyMemories();if(e.length===0)return null;const t=this.getCurrentAgentId();if(!t)return null;const r=e.filter(i=>i.memory_status==="recalling"),n=e.filter(i=>!r.includes(i));if(r.length>0){const i=r.slice(0,5).map(s=>s.uri).join(`
+`);return{msgId:`memory-recurrence-pending-${Date.now()}`,senderId:"MCP-System",senderName:"\u7CFB\u7EDF",receiverId:t,content:`\u5B58\u5728\u5F85\u758F\u7406\u7684\u5373\u5C06\u9057\u5FD8\u8BB0\u5FC6\uFF08\u5171 ${r.length} \u6761\uFF09\uFF0C\u8BF7\u901A\u8FC7 memory_recurrence \u83B7\u53D6\u8FDB\u884C\u6574\u7406\u3002
+
+\u5F85\u758F\u7406\u8BB0\u5FC6\uFF1A
+${i}${r.length>5?`
+  ...\u53CA\u5176\u4ED6 ${r.length-5} \u6761`:""}`,requireReply:!1,prompt:"memory_recurrence \u53D6\u56DE\u7684\u8BB0\u5FC6\u4ECD\u5728\u56DE\u5FC6\u4E2D\uFF0C\u8BF7\u901A\u8FC7 memory_recurrence_complete \u5B8C\u6210\u758F\u7406\uFF0C\u6216\u7EE7\u7EED\u5F52\u6863/\u7EED\u671F\u3002",timestamp:new Date().toISOString(),_acodeAutoDelegate:{type:"memory_expiration",uris:r.map(s=>s.uri)}}}if(n.length>0){const i=n.slice(0,5).map(s=>s.uri).join(`
+`);return{msgId:`memory-recurrence-${Date.now()}`,senderId:"MCP-System",senderName:"\u7CFB\u7EDF",receiverId:t,content:`\u6709 ${n.length} \u6761\u5373\u5C06\u9057\u5FD8\u7684\u8BB0\u5FC6\u5F97\u6574\u7406\uFF0C\u8BF7\u4F7F\u7528 memory_recurrence(limit=10) \u5206\u6279\u5904\u7406\uFF08\u6700\u65E9\u8FC7\u671F\u4F18\u5148\uFF0C\u6BCF\u6B21 10 \u6761\uFF09\u3002
+
+\u5373\u5C06\u9057\u5FD8\u7684\u8BB0\u5FC6\uFF1A
+${i}${n.length>5?`
+  ...\u53CA\u5176\u4ED6 ${n.length-5} \u6761`:""}`,requireReply:!1,prompt:`\u8FD9\u662F\u4E00\u6761\u8FD1\u671F\u8BB0\u5FC6\u8FC7\u671F\u63D0\u9192\uFF0C\u5171\u6709 ${n.length} \u6761\u8BB0\u5FC6\u5373\u5C06\u9057\u5FD8\uFF0C\u8BF7\u8C03\u7528 memory_recurrence \u5206\u6279\u6B21\u83B7\u53D6\u5E76\u51B3\u5B9A\u5904\u7406\u65B9\u5F0F\u3002`,timestamp:new Date().toISOString(),_acodeAutoDelegate:{type:"memory_expiration",uris:n.map(s=>s.uri)}}}return null}catch(e){return a.warn("[McpServer] \u6784\u5EFA\u8FD1\u671F\u8BB0\u5FC6\u8FC7\u671F\u56DE\u5FC6\u901A\u77E5\u5931\u8D25: %s",e instanceof Error?e.message:String(e)),null}}async buildMemoryFileChangeNotification(){if(a.info(`[McpServer] buildMemoryFileChangeNotification \u88AB\u8C03\u7528: hasRoleName=${this.hasRoleName}, agentId=${this.getCurrentAgentId()??"(\u7A7A)"}`),!this.hasRoleName)return a.info("[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B\u8DF3\u8FC7: hasRoleName=false"),null;try{const e=this.getCurrentAgentId();if(!e)return a.info("[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B\u8DF3\u8FC7: agentId \u4E3A\u7A7A"),null;const t=await this.memoryStore.listByType("project_memory"),r=t.filter(c=>c.memory_status==="updating"&&c.updating_agent_id===e);if(r.length>0){this.startLeaseRenewal();const c=await this.checkMemoriesFileChanges(r);if(c.length>0){for(const M of c){const b=r.find(P=>P.id===M.memoryId);b&&await this.memoryStore.updateMemory({uri:b.uri,memory_type:"project_memory",memory_status:"updating",updating_agent_id:e,file_md5_map:b.file_md5_map,last_check_time:b.last_check_time,bound_files:b.bound_files})}const d=Math.min(c.length,5),w=c.slice(0,5).map(M=>`- ${M.memoryUri} (\u6587\u4EF6: ${M.changedFiles.join(", ")})`).join(`
+`);return{msgId:`memory-file-change-${Date.now()}`,senderId:"MCP-System",senderName:"\u7CFB\u7EDF",receiverId:e,content:`\u68C0\u6D4B\u5230\u4EE5\u4E0B ${d} \u4E2A\u5904\u4E8E\u66F4\u65B0\u4E2D\u7684 Memory \u7ED1\u5B9A\u7684\u6587\u4EF6\u518D\u6B21\u53D8\u66F4\uFF0C\u5DF2\u66F4\u65B0 MD5 \u8BB0\u5F55\uFF1A
+
+${w}
+
+\u8BF7\u8C03\u7528 read_memory \u67E5\u770B\u6700\u65B0\u5185\u5BB9\u5E76\u8C03\u7528 update_memory \u66F4\u65B0\u3002`,requireReply:!1,prompt:"\u8FD9\u662F\u4E00\u6761\u6587\u4EF6\u53D8\u66F4\u63D0\u9192\uFF0C\u60A8\u4E4B\u524D\u6807\u8BB0\u4E3A\u66F4\u65B0\u4E2D\u7684\u8BB0\u5FC6\u7ED1\u5B9A\u7684\u6587\u4EF6\u53C8\u6709\u65B0\u53D8\u66F4\uFF0C\u8BF7\u5904\u7406\u3002",timestamp:new Date().toISOString(),_acodeAutoDelegate:{type:"memory_file_change",uris:c.slice(0,5).map(M=>M.memoryUri),fileChanges:c.slice(0,5).map(M=>{const b=r.find(P=>P.id===M.memoryId);return{uri:M.memoryUri,boundFiles:b?.bound_files??[],fileStatuses:M.fileStatuses,changedFiles:M.changedFiles}})}}}const p=r,R=new Map;for(const d of p.slice(0,5))R.set(d.uri,await this.computeBoundFileStatuses(d));const _=p.filter(d=>{const w=R.get(d.uri);return!w||w.length===0?!1:w.some(M=>M.status==="content_changed"||M.status==="not_found")}),f=p.filter(d=>!_.includes(d));if(f.length>0){a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step1: ${f.length} \u4E2A updating memory \u7ED1\u5B9A\u6587\u4EF6\u65E0\u771F\u5B9E\u53D8\u66F4\uFF0C\u81EA\u52A8\u91CA\u653E: ${f.map(d=>d.uri).join(", ")}`);for(const d of f)try{await this.memoryStore.releaseMemoryClaim(d.uri),this.activeLeaseUris.delete(d.uri),await this.memoryStore.updateMemory({uri:d.uri,memory_type:"project_memory"})}catch(w){a.info(`[McpServer] \u81EA\u52A8\u91CA\u653E stale updating memory \u5931\u8D25: ${d.uri}`,w)}this.activeLeaseUris.size===0&&this.stopLeaseRenewal()}if(_.length===0)return a.info("[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step1: \u6240\u6709 updating memory \u7ED1\u5B9A\u6587\u4EF6\u5747\u65E0\u771F\u5B9E\u53D8\u66F4\uFF0C\u5DF2\u81EA\u52A8\u91CA\u653E\uFF0C\u8DF3\u8FC7\u59D4\u6258"),null;const I=_.slice(0,5).map(d=>`- ${d.uri} (\u6587\u4EF6: ${d.bound_files?.join(", ")||"\u672A\u77E5"})`).join(`
+`);return a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step1: ${_.length}/${r.length} \u4E2A updating memory \u6709\u771F\u5B9E\u6587\u4EF6\u53D8\u66F4\uFF0C\u89E6\u53D1\u59D4\u6258`),{msgId:`memory-update-pending-${Date.now()}`,senderId:"MCP-System",senderName:"\u7CFB\u7EDF",receiverId:e,content:`\u60A8\u6709\u4EE5\u4E0B Memory \u6B63\u5904\u4E8E\u66F4\u65B0\u4E2D\u72B6\u6001\u4F46\u5C1A\u672A\u5B8C\u6210\u66F4\u65B0\uFF1A
+
+${I}
+
+\u8BF7\u7EE7\u7EED\u5B8C\u6210\u66F4\u65B0\u5DE5\u4F5C\u3002`,requireReply:!1,prompt:"\u8FD9\u662F\u4E00\u6761\u66F4\u65B0\u63D0\u9192\uFF0C\u60A8\u4E4B\u524D\u5DF2\u6807\u8BB0\u8FD9\u4E9B\u8BB0\u5FC6\u4E3A\u66F4\u65B0\u4E2D\uFF0C\u8BF7\u7EE7\u7EED\u5904\u7406\u3002",timestamp:new Date().toISOString(),_acodeAutoDelegate:{type:"memory_file_change",uris:_.slice(0,5).map(d=>d.uri),fileChanges:_.slice(0,5).map(d=>({uri:d.uri,boundFiles:d.bound_files??[],fileStatuses:R.get(d.uri)??[]}))}}}const n=await this.memoryStore.listByType("recently_memory"),i=await this.memoryStore.listByType("agent_memory"),s=[...n,...i],o=s.filter(c=>c.bound_files&&c.bound_files.length>0);a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step2: recently=${n.length}, agent=${i.length}, \u6709\u7ED1\u5B9A\u6587\u4EF6=${o.length}/${s.length}\u3002\u8BE6\u60C5: ${s.map(c=>`${c.uri}(bound=${c.bound_files?.length??0},md5=${Object.keys(c.file_md5_map??{}).length})`).join("; ")||"\u65E0 memory"}`);const l=new Map;for(const c of s)c.bound_files&&c.bound_files.length>0&&l.set(c.id,JSON.stringify(c.file_md5_map??{}));const m=await this.checkMemoriesFileChanges(s),y=m;a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step2: \u68C0\u6D4B\u5230\u53D8\u66F4=${m.length}`+(m.length>0?` \u53D8\u66F4\u9879: ${m.map(c=>`${c.memoryUri}(${c.changedFiles.join(",")})`).join("; ")}`:""));const h=s.filter(c=>{if(!c.bound_files||c.bound_files.length===0||m.some(_=>_.memoryId===c.id))return!1;const p=l.get(c.id),R=JSON.stringify(c.file_md5_map??{});return p!==R});if(h.length>0){a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step2: \u56DE\u5199 ${h.length} \u4E2A listable memory \u7684\u4FEE\u6B63 MD5 map`);for(const c of h)try{await this.memoryStore.updateMemory({uri:c.uri,memory_type:c.memory_type,file_md5_map:c.file_md5_map,last_check_time:c.last_check_time})}catch(p){a.info(`[McpServer] \u56DE\u5199 listable MD5 map \u5931\u8D25: ${c.uri}`,p)}}if(y.length>0){const c=y.map(p=>`- ${p.memoryUri} (\u6587\u4EF6: ${p.changedFiles.join(", ")})`).join(`
+`);return{msgId:`memory-file-change-${Date.now()}`,senderId:"MCP-System",senderName:"\u7CFB\u7EDF",receiverId:e,content:`\u68C0\u6D4B\u5230\u4EE5\u4E0B Memory \u7ED1\u5B9A\u7684\u6587\u4EF6\u5DF2\u53D8\u66F4\uFF0C\u8BF7\u53CA\u65F6\u66F4\u65B0\uFF1A
+
+${c}
+
+\u8BF7\u8C03\u7528 read_memory \u67E5\u770B\u5185\u5BB9\u5E76\u8C03\u7528 update_memory \u66F4\u65B0\u3002`,requireReply:!1,prompt:"\u8FD9\u662F\u4E00\u6761\u6587\u4EF6\u53D8\u66F4\u63D0\u9192\uFF0C\u81EA\u52A8\u751F\u6210\uFF0C\u65E0\u9700\u6301\u4E45\u5316\u3002",timestamp:new Date().toISOString(),_acodeAutoDelegate:{type:"memory_file_change",uris:y.map(p=>p.memoryUri),fileChanges:y.map(p=>{const R=s.find(_=>_.id===p.memoryId);return{uri:p.memoryUri,boundFiles:R?.bound_files??[],fileStatuses:p.fileStatuses,changedFiles:p.changedFiles}})}}}const u=t.filter(c=>c.bound_files&&c.bound_files.length>0&&(c.memory_status==="normal"||!c.memory_status)&&!this.isClaimCached(c.uri)),S=t.filter(c=>c.bound_files&&c.bound_files.length>0);a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step3: project_memory \u603B\u6570=${t.length}, \u6709\u7ED1\u5B9A\u6587\u4EF6=${S.length}, \u5F85\u68C0\u6D4B(\u8FC7\u6EE4updating/claimed\u540E)=${u.length}\u3002\u88AB\u8FC7\u6EE4\u539F\u56E0: ${S.length-u.length} \u9879(memory_status=updating \u6216 isClaimCached)`);const E=new Map;for(const c of u)E.set(c.id,JSON.stringify(c.file_md5_map??{}));const T=await this.checkMemoriesFileChanges(u),A=u.filter(c=>{if(T.some(_=>_.memoryId===c.id))return!1;const p=E.get(c.id),R=JSON.stringify(c.file_md5_map??{});return p!==R&&c.file_md5_map&&Object.keys(c.file_md5_map).length>0});if(A.length>0){a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step3: \u56DE\u5199 ${A.length} \u4E2A memory \u7684\u4FEE\u6B63 MD5 map \u5230\u670D\u52A1\u7AEF\uFF08\u65E0\u57FA\u7EBF/\u952E\u7F3A\u5931\u4FEE\u590D\uFF09`);for(const c of A)try{await this.memoryStore.updateMemory({uri:c.uri,memory_type:"project_memory",file_md5_map:c.file_md5_map,last_check_time:c.last_check_time})}catch(p){a.info(`[McpServer] \u56DE\u5199\u57FA\u7EBF MD5 \u5931\u8D25: ${c.uri}`,p)}}if(a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B Step3: \u68C0\u6D4B\u5230\u53D8\u66F4=${T.length}`+(T.length>0?` \u53D8\u66F4\u9879: ${T.map(c=>`${c.memoryUri}(${c.changedFiles.join(",")})`).join("; ")}`:"")),T.length>0){const c=T.slice(0,5),p=c.map(f=>f.memoryUri);let R=!1,_=new Set;try{const f=await this.memoryStore.claimMemoryUpdate(p,v.LEASE_DURATION_MINUTES,"project_memory");_=new Set(f.claimed_uris??[]),R=!0}catch(f){a.info("[McpServer] Server claim API \u4E0D\u53EF\u7528\uFF0C\u964D\u7EA7\u5230\u672C\u5730\u76F4\u63A5\u6807\u8BB0:",f),_=new Set(p)}if(_.size>0){const f=c.filter(d=>_.has(d.memoryUri));for(const d of f){const w=t.find(M=>M.id===d.memoryId);w&&(await this.memoryStore.updateMemory({uri:w.uri,memory_type:"project_memory",memory_status:"updating",updating_agent_id:e,file_md5_map:w.file_md5_map,last_check_time:w.last_check_time,bound_files:w.bound_files}),this.activeLeaseUris.add(w.uri))}R&&_.size>0&&this.startLeaseRenewal();const I=f.map(d=>`- ${d.memoryUri} (\u6587\u4EF6: ${d.changedFiles.join(", ")})`).join(`
+`);return{msgId:`memory-file-change-${Date.now()}`,senderId:"MCP-System",senderName:"\u7CFB\u7EDF",receiverId:e,content:`\u68C0\u6D4B\u5230\u4EE5\u4E0B ${f.length} \u4E2A\u6C38\u4E45\u8BB0\u5FC6\u7ED1\u5B9A\u7684\u6587\u4EF6\u5DF2\u53D8\u66F4\uFF0C\u5DF2\u4E3A\u60A8\u6807\u8BB0\u4E3A\u66F4\u65B0\u4E2D\uFF1A
+
+${I}
+
+\u8BF7\u8C03\u7528 read_memory \u67E5\u770B\u5185\u5BB9\u5E76\u8C03\u7528 update_memory \u66F4\u65B0\u3002\u66F4\u65B0\u5B8C\u6210\u540E\u72B6\u6001\u5C06\u81EA\u52A8\u6062\u590D\u4E3A\u6B63\u5E38\u3002`,requireReply:!1,prompt:"\u8FD9\u662F\u4E00\u6761\u6587\u4EF6\u53D8\u66F4\u63D0\u9192\uFF0C\u5DF2\u81EA\u52A8\u6807\u8BB0\u66F4\u65B0\u72B6\u6001\uFF0C\u8BF7\u5904\u7406\u3002",timestamp:new Date().toISOString(),_acodeAutoDelegate:{type:"memory_file_change",uris:f.map(d=>d.memoryUri),fileChanges:f.map(d=>{const w=t.find(M=>M.id===d.memoryId);return{uri:d.memoryUri,boundFiles:w?.bound_files??[],fileStatuses:d.fileStatuses,changedFiles:d.changedFiles}})}}}}return a.info("[McpServer] \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B\u5B8C\u6210: \u65E0\u53D8\u66F4\u901A\u77E5\u4EA7\u751F"),null}catch(e){return a.warn("[McpServer] \u6784\u5EFA Memory \u6587\u4EF6\u53D8\u66F4\u68C0\u6D4B\u901A\u77E5\u5931\u8D25: %s",e instanceof Error?e.message:String(e)),null}}isClaimCached(e){return this.activeLeaseUris.has(e)}async computeBoundFileStatuses(e){const t=[];if(!e.bound_files||e.bound_files.length===0)return t;const r=e.file_md5_map||{},n=process.env.AWS_WORKSPACE_PATH||process.cwd();for(const i of e.bound_files)try{const s=await this.calculateFileMd5(i);if(s===null){const l=g.resolve(n,i);await this.verifyFileNotExist(l)&&r[i]?t.push({path:i,status:"not_found",serverMd5:r[i]}):t.push({path:i,status:"no_change"});continue}const o=r[i];o?o!==s?t.push({path:i,status:"content_changed",localMd5:s,serverMd5:o}):t.push({path:i,status:"no_change"}):t.push({path:i,status:"no_change"})}catch{t.push({path:i,status:"no_change"})}return t}async checkMemoriesFileChanges(e){const t=[];for(const r of e)if(!(!r.bound_files||r.bound_files.length===0))try{const n=[],i=[],s={},o=r.file_md5_map||{},l=process.env.AWS_WORKSPACE_PATH||process.cwd(),m=Object.keys(o).length===0;let y=!1;for(const h of r.bound_files)try{const u=await this.calculateFileMd5(h);if(u===null){const E=g.resolve(l,h);a.info(`[McpServer] MD5 \u8BA1\u7B97\u8FD4\u56DE null: ${h} -> ${E} (workspace=${l})`);const T=o[h];T?await this.verifyFileNotExist(E)?(i.push({path:h,status:"not_found",serverMd5:T}),n.push(`${h}\uFF08\u6587\u4EF6\u627E\u4E0D\u5230 Server: ${T}\uFF09`),r.bound_files&&(r.bound_files=r.bound_files.filter(c=>c!==h))):(a.info(`[McpServer] \u6587\u4EF6\u5B58\u5728\u4F46 MD5 \u8BA1\u7B97\u5931\u8D25\uFF08\u77AC\u6001\u9519\u8BEF\uFF09\uFF0C\u8DF3\u8FC7: ${h}`),i.push({path:h,status:"no_change"})):i.push({path:h,status:"no_change"});continue}s[h]=u;const S=o[h];S?S!==u?(a.info(`[McpServer] \u6587\u4EF6\u53D8\u66F4: ${h} old=${S} new=${u} (workspace=${l})`),i.push({path:h,status:"content_changed",localMd5:u,serverMd5:S}),n.push(`${h}\uFF08\u5185\u5BB9\u53D8\u66F4 \u672C\u5730: ${u} Server: ${S}\uFF09`)):i.push({path:h,status:"no_change"}):(i.push({path:h,status:"no_change"}),y=!0,a.info(`[McpServer] \u5EFA\u7ACB\u5355\u6587\u4EF6\u57FA\u7EBF: ${h} new=${u} (workspace=${l}, memory=${r.uri})`))}catch(u){a.info(`[McpServer] \u8BA1\u7B97\u6587\u4EF6 MD5 \u5931\u8D25: ${h}`,u),i.push({path:h,status:"no_change"})}if(m&&Object.keys(s).length>0){r.file_md5_map=s,r.last_check_time=new Date().toISOString();continue}y&&Object.keys(s).length>0&&(r.file_md5_map=s,r.last_check_time=new Date().toISOString()),n.length>0&&(t.push({memoryId:r.id,memoryUri:r.uri,fileStatuses:i,changedFiles:n}),r.last_check_time=new Date().toISOString())}catch(n){a.warn(`[McpServer] \u68C0\u67E5 Memory ${r.id} \u6587\u4EF6\u53D8\u66F4\u5931\u8D25:`,n)}return t}async calculateFileMd5(e){try{const{createReadStream:t}=await import("node:fs"),{createHash:r}=await import("node:crypto"),n=process.env.AWS_WORKSPACE_PATH||process.cwd(),i=g.resolve(n,e),s=g.resolve(n),o=g.resolve(i);return!o.startsWith(s+g.sep)&&o!==s?(a.warn(`[McpServer] calculateFileMd5: \u8DEF\u5F84\u9003\u9038\u88AB\u62D2\u7EDD: ${e}`),null):new Promise(l=>{const m=r("md5"),y=t(i);y.on("data",h=>m.update(h)),y.on("end",()=>l(m.digest("hex"))),y.on("error",()=>l(null))})}catch(t){return a.info(`[McpServer] \u8BA1\u7B97\u6587\u4EF6 MD5 \u5931\u8D25: ${e}`,t),null}}async verifyFileNotExist(e){try{return await $.promises.access(e,$.constants.F_OK),!1}catch{return!0}}async handleGetMessage(){const e=this.messageBuffer.size()>0;await this.hydrateUnreadMessagesFromServer();const t=this.messageBuffer.get(),r=t.directMessages.length>0||t.groupMessages.length>0,n=e||!r;return await this.prependMemoryNotification(t,()=>this.buildMemoryRecurrenceNotification())?this.buildPollResult(t,n):await this.prependMemoryNotification(t,()=>this.buildMemoryCleanupNotification())?this.buildPollResult(t,n):this.buildPollResult(t,n)}async hydrateUnreadMessagesFromServer(e={}){try{const t=await this.agentClient.fetchUnreadMessages({blockIfEmpty:e.blockIfEmpty??!1,blockTimeoutMs:e.blockTimeoutMs,includePipelineTasks:e.includePipelineTasks});if(t.directMessages.length===0&&t.groupMessages.length===0)return!0;const r=t.directMessages.filter(i=>this.shouldBufferIncomingMessage(i)),n=t.groupMessages.filter(i=>this.shouldBufferIncomingMessage(i));return r.forEach(i=>{this.messageBuffer.push(i)}),n.forEach(i=>{this.messageBuffer.push(i)}),a.info(`[McpServer] \u5DF2\u8865\u62C9\u672A\u8BFB\u6D88\u606F\uFF0C\u79C1\u804A: ${r.length}\uFF0C\u7FA4\u804A: ${n.length}`),!0}catch(t){return a.error("[McpServer] \u8865\u62C9\u672A\u8BFB\u6D88\u606F\u5931\u8D25: %s, stack=%s",t instanceof Error?t.message:String(t),t instanceof Error?t.stack:"(no stack)"),!1}}async handleGetDmHistory(e){return await this.agentClient.getDmHistory(e.targetUserId,e.limit,e.since)}async handleGetGroupHistory(e){return await this.agentClient.getGroupHistory(e.limit,e.roomId,e.since)}async handleSubmitTaskResult(e){if(!e.nodeId||typeof e.nodeId!="string")throw new Error("nodeId is required");if(!e.outputPayload||typeof e.outputPayload!="string")throw new Error("outputPayload is required");const t=Array.isArray(e.changeLog)?e.changeLog:void 0;return await this.agentClient.submitTaskResult(e.nodeId,e.outputPayload,t)}async handleStartTaskRollback(e){const t={rollbackTaskId:this.getRequiredString(e,"rollbackTaskId")};return await this.agentClient.startTaskRollback(t)}async handleFinishTaskRollback(e){const t={rollbackTaskId:this.getRequiredString(e,"rollbackTaskId"),resultMessage:this.getOptionalString(e,"resultMessage")};return await this.agentClient.finishTaskRollback(t)}async handleRejectTask(e){if(!e.nodeId||typeof e.nodeId!="string")throw new Error("nodeId is required");if(!e.reason||typeof e.reason!="string")throw new Error("reason is required");return await this.agentClient.rejectTask(e.nodeId,e.reason)}async handleTerminateTask(e){if(!e.taskInstanceId||typeof e.taskInstanceId!="string")throw new Error("taskInstanceId is required");if(!e.reason||typeof e.reason!="string")throw new Error("reason is required");return await this.agentClient.terminateTask(e.taskInstanceId,e.reason)}async handleIncomingMessage(e){if(!this.shouldBufferIncomingMessage(e)){!this.isGroupMessage(e)&&this.isPipelineTaskAssignedNotification(e)&&(a.info("[McpServer] \u6536\u5230 pipeline_task_assigned \u5524\u9192\u4FE1\u53F7\uFF0C\u7ACB\u5373\u5524\u9192 poll \u8D70 hydrate \u91CD\u67E5"),this.messageBuffer.wakeUpWaiters());return}a.info(`[McpServer] \u6536\u5230\u6D88\u606F: ${e.content?.substring(0,50)||"(\u65E0\u5185\u5BB9)"}`),this.messageBuffer.push(e)}shouldBufferIncomingMessage(e){return!e||typeof e!="object"?(a.warn("[McpServer] \u5FFD\u7565\u7ED3\u6784\u5F02\u5E38\u7684\u6D88\u606F\uFF0C\u907F\u514D\u7F13\u51B2\u533A\u6C61\u67D3"),!1):this.isSelfSentMessage(e)?(a.info("[McpServer] \u5FFD\u7565\u5F53\u524D Agent \u81EA\u5DF1\u53D1\u9001\u7684\u6D88\u606F\uFF0C\u907F\u514D poll_message/get_message \u56DE\u73AF"),!1):this.isGroupMessage(e)?!0:this.isPipelineTaskAssignedNotification(e)?(a.info("[McpServer] \u5FFD\u7565\u6301\u4E45\u5316 pipeline_task_assigned \u79C1\u4FE1\uFF0C\u4EC5\u4F5C\u4E3A poll_message \u5524\u9192\u4FE1\u53F7\u5904\u7406"),!1):!0}isGroupMessage(e){return!!e&&typeof e=="object"&&typeof e.msgId=="number"}isPipelineTaskAssignedNotification(e){const t=typeof e.content=="string"?e.content:"",r=typeof e.prompt=="string"?e.prompt:"";return t.includes("pipeline_task_assigned")||r.includes("pipeline_task_assigned")}isSelfSentMessage(e){if(!e||typeof e!="object")return!1;const t=this.getCurrentAgentId();return!!t&&typeof e.senderId=="string"&&e.senderId===t}getCurrentAgentId(){const e=this.agentClient;return typeof e.getState!="function"?null:e.getState().agentId??null}sanitizeAgentIdForTodoFile(e){return String(e).replace(/[^a-zA-Z0-9_-]/g,"_")}async buildTodoReminderNotification(){try{const e=this.getCurrentAgentId();if(!e)return null;const t=g.join(U.homedir(),".acode","todos",`${this.sanitizeAgentIdForTodoFile(e)}.json`);let r;try{r=await $.promises.readFile(t,"utf-8")}catch(o){if(o?.code==="ENOENT")return null;throw o}const n=JSON.parse(r),s=(Array.isArray(n.todos)?n.todos:[]).filter(o=>o&&typeof o=="object"&&typeof o.content=="string"&&(o.status==="pending"||o.status==="in_progress"||o.status==="cancelled"));return s.length===0?null:{msgId:`todo-reminder-${Date.now()}`,senderId:"MCP-System",senderName:"\u7CFB\u7EDF",receiverId:e,content:`Todo \u5217\u8868\u5B58\u5728 ${s.length} \u9879\u672A\u5B8C\u6210\uFF0C\u8BF7\u8C03\u7528 todo_read \u67E5\u770B\u5E76\u5904\u7406\u3002`,requireReply:!1,prompt:"\u8FD9\u662F\u4E00\u6761 Todo \u672A\u5B8C\u6210\u9879\u63D0\u9192\uFF0C\u81EA\u52A8\u751F\u6210\uFF0C\u65E0\u9700\u6301\u4E45\u5316\u3002\u8BF7\u8BC4\u4F30\u662F\u5426\u9700\u8981\u7EE7\u7EED\u5904\u7406\u672A\u5B8C\u6210\u7684 Todo\uFF0C\u53EF\u8C03\u7528 todo_read \u83B7\u53D6\u5B8C\u6574\u5217\u8868\u3002",timestamp:new Date().toISOString()}}catch(e){return a.warn("[McpServer] \u6784\u5EFA Todo \u63D0\u9192\u5931\u8D25: %s",e instanceof Error?e.message:String(e)),null}}async start(){const e=new x;await this.server.connect(e),await this.agentClient.initialize(),a.info("[McpServer] MCP Server \u5DF2\u542F\u52A8\uFF0C\u7B49\u5F85\u8FDE\u63A5..."),a.info(`[McpServer] \u53EF\u7528\u5DE5\u5177: ${O.map(t=>t.name).join(", ")}`),a.info(`[McpServer] \u5DE5\u4F5C\u76EE\u5F55: ${process.env.AWS_WORKSPACE_PATH||process.cwd()}`),j&&a.info("[McpServer] \u964D\u7EA7\u6A21\u5F0F\u5DF2\u542F\u7528\uFF0C\u6CE8\u518C\u5931\u8D25\u65F6\u5C06\u4EE5\u79BB\u7EBF\u6A21\u5F0F\u7EE7\u7EED\u8FD0\u884C"),this.autoRegisterInBackground(),a.info("[McpServer] MCP Server \u5DF2\u5C31\u7EEA\uFF0C\u5DE5\u5177\u5DF2\u53EF\u7528")}startLeaseRenewal(){this.leaseRenewalTimer||(this.leaseRenewalTimer=setInterval(async()=>{try{if(!this.getCurrentAgentId())return;(await this.memoryStore.renewMemoryLease(v.LEASE_DURATION_MINUTES)).renewed===0&&(a.warn("[McpServer] \u79DF\u7EA6\u5DF2\u4E22\u5931\uFF08renewed=0\uFF09\uFF0C\u505C\u6B62\u7EED\u671F\u5B9A\u65F6\u5668"),this.stopLeaseRenewal())}catch(e){a.warn("[McpServer] \u7EED\u671F\u79DF\u7EA6\u5931\u8D25: %s",e instanceof Error?e.message:String(e))}},v.LEASE_RENEW_INTERVAL_MS),a.info("[McpServer] \u79DF\u7EA6\u7EED\u671F\u5B9A\u65F6\u5668\u5DF2\u542F\u52A8\uFF0C\u95F4\u9694: 60s"))}stopLeaseRenewal(){this.leaseRenewalTimer&&(clearInterval(this.leaseRenewalTimer),this.leaseRenewalTimer=null,a.info("[McpServer] \u79DF\u7EA6\u7EED\u671F\u5B9A\u65F6\u5668\u5DF2\u505C\u6B62"))}stop(){this.stopLeaseRenewal(),this.getCurrentAgentId()&&this.memoryStore.releaseAllMemoryClaims().catch(t=>a.warn("[McpServer] \u91CA\u653E claim \u5931\u8D25: %s",t instanceof Error?t.message:String(t))),this.agentClient.stop(),a.info("[McpServer] MCP Server \u5DF2\u505C\u6B62")}async autoRegister(){const e=this.agentClient.getAgentConfig();a.info(`[McpServer] \u89D2\u8272: "${e.roleName}"`),a.info(`[McpServer] AgentID: "${e.agentId||"(\u81EA\u52A8\u5206\u914D)"}"`),a.info("[McpServer] \u6B63\u5728\u8BF7\u6C42\u8C03\u5EA6\u4E2D\u5FC3\u6CE8\u518C...");let t=0;for(;;)try{const r=await this.agentClient.register();a.info(`[McpServer] \u6CE8\u518C\u6210\u529F: ${r.displayName} (${r.agentId})`),a.info(`[McpServer] \u72B6\u6001: ${r.status}`),this.startListeningInternal(),a.info("[McpServer] \u6D88\u606F\u76D1\u542C\u5DF2\u81EA\u52A8\u542F\u52A8");const n=this.agentClient.getStatusReporter();n&&n.reportWaitingInput(),await this.reportMemoryStatsToServer(),this.maybeSyncPermanentMemoryToServer();return}catch(r){const n=r instanceof Error?r.message:String(r);if(t++,C>0&&t>=C){if(j){a.warn(`[McpServer] \u6CE8\u518C\u8D85\u8FC7\u6700\u5927\u91CD\u8BD5\u6B21\u6570 (${C}\u6B21)\uFF0C\u8FDB\u5165\u964D\u7EA7\u6A21\u5F0F`),this.agentClient.enterDegradedMode(),this.startListeningInternal(),a.info("[McpServer] \u964D\u7EA7\u6A21\u5F0F\uFF1A\u6D88\u606F\u76D1\u542C\u5DF2\u542F\u52A8"),this.agentClient.retryRegistrationInBackground(K,J);const i=this.agentClient.getStatusReporter();i&&i.reportWaitingInput(),await this.reportMemoryStatsToServer();return}throw new Error(`\u6CE8\u518C\u8D85\u8FC7\u6700\u5927\u91CD\u8BD5\u6B21\u6570 (${C}\u6B21)\uFF0C\u653E\u5F03\u542F\u52A8: ${n}`)}a.warn(`[McpServer] \u6CE8\u518C\u5931\u8D25\uFF0C\u7B49\u5F85\u91CD\u8BD5... (${t}/${C}): ${n}`),await this.delay(Y)}}autoRegisterInBackground(){this.autoRegister().catch(e=>{a.error("[McpServer] \u540E\u53F0\u6CE8\u518C\u5F02\u5E38: %s, stack=%s",e instanceof Error?e.message:String(e),e instanceof Error?e.stack:"(no stack)")})}startListeningInternal(){a.info("[McpServer] startListeningInternal \u88AB\u8C03\u7528");const e=t=>{a.info(`[McpServer] profileHandler \u88AB\u8C03\u7528\uFF0CdisplayName: ${t.displayName}`),this.messageBuffer.setProfileMessage(t),this.profileSynced=!0,this.syncRoleMemoryStore(t),this.maybeSyncPermanentMemoryToServer()};if(this.agentClient.isInDegradedMode()){a.info("[McpServer] \u964D\u7EA7\u6A21\u5F0F\uFF1A\u8DF3\u8FC7 WebSocket \u8FDE\u63A5\uFF0C\u4EC5\u542F\u52A8\u672C\u5730\u6D88\u606F\u76D1\u542C"),this.agentClient.start(this.handleIncomingMessage.bind(this),{pollMode:!1,profileHandler:e}),this.activelySyncProfile();return}this.agentClient.start(this.handleIncomingMessage.bind(this),{pollMode:!1,profileHandler:e}),this.activelySyncProfile()}activelySyncProfile(){this.profileSynced||this.agentClient.getProfile().then(e=>{this.profileSynced||(this.profileSynced=!0,a.info(`[McpServer] \u4E3B\u52A8\u83B7\u53D6 profile \u6210\u529F: displayName=${e.displayName}, roleName="${e.roleName??"(\u7A7A)"}"`),this.messageBuffer.setProfileMessage(e),this.syncRoleMemoryStore(e),this.maybeSyncPermanentMemoryToServer())}).catch(e=>{a.warn("[McpServer] \u4E3B\u52A8\u83B7\u53D6 profile \u5931\u8D25: %s",e instanceof Error?e.message:String(e))})}delay(e){return new Promise(t=>setTimeout(t,e))}}export{v as McpServer};
+