@memorycode/mcp-server 1.0.0 → 1.1.0

package/dist/server.js

@@ -1,23 +1,25 @@
 /**
- * YIS-15 Task 2.2 / YIS-20 / YIS-21: MCP Server 实现
- * YIS-22: 添加 load_config、list_configs Tool，支持自然语言唤起配置切换
+ * YIS-15 Task 2.2 / YIS-20 / YIS-21 / MCP 1.1: MCP Server 实现
+ * 档案 = 个人记忆；认知芯片 = 可在 AI 中直接切换的思考/输出模式。
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, ReadResourceRequestSchema, McpError, ErrorCode, } from '@modelcontextprotocol/sdk/types.js';
+import { writeRuntime } from './runtimeStore.js';
 import { logInfo, logWarn } from './utils/logger.js';
-const RESOURCE_URI_PREFIX = 'memorycode://profile/';
+const PROFILE_URI_PREFIX = 'memorycode://profile/';
+const CHIP_URI_PREFIX = 'memorycode://chip/';
 const MIME_TYPE = 'text/markdown';
 const TOOLS = [
     {
         name: 'load_config',
-        description: '加载指定的 MemoryCode 记忆配置，使后续回复使用该身份/风格。用户说「请使用职场配置」「切换到学生模式」等时调用。',
+        description: '加载指定的 MemoryCode 记忆档案（个人记忆/人设），使后续回复使用该身份。用户说「请使用职场配置」「切换到学生模式」等时调用。切换档案不会自动切换认知芯片，除非该档案在 MCP runtime 中已有记录的芯片。',
         inputSchema: {
             type: 'object',
             properties: {
                 config_name: {
                     type: 'string',
-                    description: '要加载的配置名称，如：空白、职场、创作者、自由职业、学生（以当前可用列表为准）',
+                    description: '要加载的档案名称，如：空白、职场、创作者、自由职业、学生（以当前可用列表为准）',
                 },
             },
             required: ['config_name'],
@@ -25,12 +27,64 @@ const TOOLS = [
     },
     {
         name: 'list_configs',
-        description: '列出当前可用的所有 MemoryCode 记忆配置名称，供用户选择或确认。',
+        description: '列出当前可用的所有 MemoryCode 记忆档案名称，供用户选择或确认。',
         inputSchema: {
             type: 'object',
             properties: {},
         },
     },
+    {
+        name: 'list_chips',
+        description: '列出当前可用的认知芯片名称。认知芯片只改变 AI 的思考与输出方式，不改变用户身份记忆。',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'load_chip',
+        description: '为当前或指定档案加载认知芯片，使后续回复使用该思考/输出模式。用户说「切换到严谨分析芯片」「用结构表达」等时调用。需要 MCP 1.1 导出文件（含 chips/compositions）。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                chip_name: {
+                    type: 'string',
+                    description: '认知芯片名称，如：结构表达、严谨分析、战略决策（以 list_chips 为准）',
+                },
+                profile_name: {
+                    type: 'string',
+                    description: '可选。指定档案名称；省略则作用于当前已加载档案。',
+                },
+            },
+            required: ['chip_name'],
+        },
+    },
+    {
+        name: 'unload_chip',
+        description: '卸载当前或指定档案的认知芯片，回到该档案原始认知调优（无芯片覆盖）。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                profile_name: {
+                    type: 'string',
+                    description: '可选。指定档案名称；省略则作用于当前已加载档案。',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_cognitive_chip',
+        description: '查看认知芯片元信息（名称、描述、来源）。省略 chip_name 时返回当前档案已加载的芯片。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                chip_name: {
+                    type: 'string',
+                    description: '可选。芯片名称；省略则返回当前档案 runtime 中的芯片。',
+                },
+            },
+        },
+    },
     {
         name: 'get_user_profile',
         description: 'Get current user identity profile from MemoryCode (nickname, roles, about). Use this when personalization needs user background.',
@@ -53,15 +107,28 @@ const TOOLS = [
         },
     },
 ];
+const EMPTY_PARSED = {
+    schemaVersion: '1.0',
+    resources: [],
+    profiles: [],
+    chips: [],
+    compositions: [],
+    runtime: {
+        activeProfileId: null,
+        activeChipByProfile: {},
+        updatedAt: new Date().toISOString(),
+    },
+};
 export class MemoryCodeMCPServer {
-    resources = [];
+    parsed = { ...EMPTY_PARSED, runtime: { ...EMPTY_PARSED.runtime } };
     memorySnapshot = null;
+    watchFilePath = null;
     server;
     transport = null;
     constructor() {
         this.server = new Server({
             name: 'memorycode',
-            version: '1.0.0',
+            version: '1.1.0',
         }, {
             capabilities: {
                 resources: {
@@ -70,130 +137,509 @@ export class MemoryCodeMCPServer {
                 },
                 tools: { listChanged: true },
             },
-            /** Cursor 等客户端通过 GetInstructions/initialize 获取此说明，避免 "No server info found" 类问题 */
             instructions: [
-                'MemoryCode MCP: 提供记忆配置供 AI 使用。',
-                'Resources: 通过 @ 或资源列表加载 memorycode://profile/<id> 获取某配置的完整 prompt。',
-                'Tools: list_configs 列出可用配置；load_config 加载指定配置名称（如「职场」「创作者」）使后续回复使用该身份。',
-                'Tools: get_user_profile 返回当前身份信息；get_expertise 支持按 domain 过滤技能深度。',
+                'MemoryCode MCP: 档案 = 个人记忆（身份/背景）；认知芯片 = 可热插拔的思考与输出模式。',
+                'Resources: memorycode://profile/<id> 获取档案当前组合 prompt；memorycode://chip/<id> 查看芯片说明。',
+                'Tools: list_configs / load_config 管理档案；list_chips / load_chip / unload_chip 管理认知芯片。',
+                'Tools: get_cognitive_chip 查看芯片元信息；get_user_profile / get_expertise 查询身份与技能。',
+                '芯片切换需要 MCP 1.1 导出文件；若 load_chip 失败请让用户重新从 MemoryCode 导出 memorycode-mcp.json。',
             ].join(' '),
         });
         this.server.setRequestHandler(ListToolsRequestSchema, () => ({
             tools: TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
         }));
-        this.server.setRequestHandler(CallToolRequestSchema, (request) => {
-            const { name, arguments: args } = request.params;
-            if (name === 'load_config') {
-                const configName = typeof args?.config_name === 'string' ? args.config_name.trim() : '';
-                if (!configName) {
-                    return {
-                        content: [{ type: 'text', text: '请提供 config_name 参数，例如：职场、创作者、学生。' }],
-                        isError: true,
-                    };
-                }
-                const resource = this.findResourceByConfigName(configName);
-                if (!resource) {
-                    const names = this.resources.map((r) => r.name).join('、') || '（暂无）';
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `未找到配置「${configName}」。当前可用：${names}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            return this.handleToolCall(request.params.name, request.params.arguments);
+        });
+        this.server.setRequestHandler(ListResourcesRequestSchema, () => ({
+            resources: this.listAllResources(),
+        }));
+        this.server.setRequestHandler(ListResourceTemplatesRequestSchema, () => ({
+            resourceTemplates: [],
+        }));
+        this.server.setRequestHandler(ReadResourceRequestSchema, (request) => {
+            return this.handleReadResource(request.params.uri);
+        });
+        logInfo('[MemoryCode] MCP Server initialized (v1.1): resources + tools including chip switching');
+    }
+    setWatchFilePath(filePath) {
+        this.watchFilePath = filePath;
+    }
+    updateMemorySnapshot(parsed, payload) {
+        this.parsed = parsed;
+        this.memorySnapshot = payload;
+        this.server.sendResourceListChanged().catch((err) => {
+            logWarn(`Failed to send resources/list_changed: ${err}`);
+        });
+    }
+    async handleToolCall(name, args) {
+        switch (name) {
+            case 'load_config':
+                return await this.toolLoadConfig(args);
+            case 'list_configs':
+                return this.toolListConfigs();
+            case 'list_chips':
+                return this.toolListChips();
+            case 'load_chip':
+                return await this.toolLoadChip(args);
+            case 'unload_chip':
+                return await this.toolUnloadChip(args);
+            case 'get_cognitive_chip':
+                return this.toolGetCognitiveChip(args);
+            case 'get_user_profile':
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(this.getUserProfile(), null, 2) }],
+                };
+            case 'get_expertise': {
+                const domain = typeof args?.domain === 'string' ? args.domain : undefined;
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(this.getExpertise(domain), null, 2) }],
+                };
+            }
+            default:
+                throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${name}`);
+        }
+    }
+    async toolLoadConfig(args) {
+        const configName = typeof args?.config_name === 'string' ? args.config_name.trim() : '';
+        if (!configName) {
+            return {
+                content: [{ type: 'text', text: '请提供 config_name 参数，例如：职场、创作者、学生。' }],
+                isError: true,
+            };
+        }
+        const profile = this.findProfileByName(configName);
+        if (!profile) {
+            const names = this.getProfileNames().join('、') || '（暂无）';
+            return {
+                content: [{ type: 'text', text: `未找到档案「${configName}」。当前可用：${names}` }],
+                isError: true,
+            };
+        }
+        const chipState = this.resolveActiveChipForProfile(profile);
+        const prompt = this.resolvePrompt(profile.id, chipState.chipId);
+        if (!prompt) {
+            const resource = this.findResourceByConfigName(configName);
+            if (!resource || this.supportsChipSwitching()) {
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `已加载配置：${resource.name}\n\n${resource.prompt}`,
+                            text: `无法生成档案「${configName}」的 prompt。请重新从 MemoryCode 导出 MCP 文件。`,
                         },
                     ],
+                    isError: true,
+                };
+            }
+            this.parsed.runtime.activeProfileId = profile.id;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `已加载档案：${profile.name}\n\n${resource.prompt}`,
+                    },
+                ],
+            };
+        }
+        this.parsed.runtime.activeProfileId = profile.id;
+        this.parsed.runtime.activeChipByProfile[profile.id] = chipState.chipId;
+        await this.queueRuntimePersist();
+        const chipLabel = chipState.chipId ? this.findChipById(chipState.chipId)?.name ?? chipState.chipId : '无芯片';
+        const warning = chipState.warning ? `\n注意：${chipState.warning}` : '';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `已加载档案：${profile.name}\n认知芯片：${chipLabel}${warning}\n\n${prompt}`,
+                },
+            ],
+        };
+    }
+    toolListConfigs() {
+        const names = this.getProfileNames();
+        const text = names.length > 0
+            ? `当前可用档案：\n${names.map((c) => `- ${c}`).join('\n')}`
+            : '当前暂无可用档案，请先在 MemoryCode 中导出 memorycode-mcp.json 并放在 MCP 监听的路径。';
+        return { content: [{ type: 'text', text }] };
+    }
+    toolListChips() {
+        if (!this.supportsChipSwitching()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: '当前 MCP 文件不支持认知芯片切换（需要 schema 1.1）。请从 MemoryCode 重新导出 memorycode-mcp.json。',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const names = this.parsed.chips.map((c) => c.name);
+        const text = names.length > 0
+            ? `当前可用认知芯片：\n${names.map((c) => `- ${c}`).join('\n')}`
+            : '当前导出文件中没有可用认知芯片。';
+        return { content: [{ type: 'text', text }] };
+    }
+    async toolLoadChip(args) {
+        if (!this.supportsChipSwitching()) {
+            return this.chipUnsupportedError();
+        }
+        const chipName = typeof args?.chip_name === 'string' ? args.chip_name.trim() : '';
+        if (!chipName) {
+            return {
+                content: [{ type: 'text', text: '请提供 chip_name 参数，例如：结构表达、严谨分析。' }],
+                isError: true,
+            };
+        }
+        const chip = this.findChipByName(chipName);
+        if (!chip) {
+            const names = this.parsed.chips.map((c) => c.name).join('、') || '（暂无）';
+            return {
+                content: [{ type: 'text', text: `未找到认知芯片「${chipName}」。当前可用：${names}` }],
+                isError: true,
+            };
+        }
+        const profileName = typeof args?.profile_name === 'string' ? args.profile_name.trim() : '';
+        const profile = profileName
+            ? this.findProfileByName(profileName)
+            : this.getRuntimeActiveProfile();
+        if (!profile) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: profileName
+                            ? `未找到档案「${profileName}」。请先 load_config 或提供有效 profile_name。`
+                            : '请先 load_config 加载一个档案，再切换认知芯片。',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const prompt = this.resolvePrompt(profile.id, chip.id);
+        if (!prompt) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `无法找到档案「${profile.name}」与芯片「${chip.name}」的组合 prompt。请重新从 MemoryCode 导出 MCP 文件。`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        this.parsed.runtime.activeProfileId = profile.id;
+        this.parsed.runtime.activeChipByProfile[profile.id] = chip.id;
+        await this.queueRuntimePersist();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `已加载认知芯片：${chip.name}\n档案：${profile.name}\n\n${prompt}`,
+                },
+            ],
+        };
+    }
+    async toolUnloadChip(args) {
+        if (!this.supportsChipSwitching()) {
+            return this.chipUnsupportedError();
+        }
+        const profileName = typeof args?.profile_name === 'string' ? args.profile_name.trim() : '';
+        const profile = profileName
+            ? this.findProfileByName(profileName)
+            : this.getRuntimeActiveProfile();
+        if (!profile) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: '请先 load_config 加载一个档案，再卸载认知芯片。',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const prompt = this.resolvePrompt(profile.id, null);
+        if (!prompt) {
+            return {
+                content: [{ type: 'text', text: `无法生成档案「${profile.name}」的无芯片 prompt。` }],
+                isError: true,
+            };
+        }
+        this.parsed.runtime.activeProfileId = profile.id;
+        this.parsed.runtime.activeChipByProfile[profile.id] = null;
+        await this.queueRuntimePersist();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `已卸载认知芯片。\n档案：${profile.name}\n\n${prompt}`,
+                },
+            ],
+        };
+    }
+    toolGetCognitiveChip(args) {
+        if (!this.supportsChipSwitching()) {
+            return this.chipUnsupportedError();
+        }
+        const chipName = typeof args?.chip_name === 'string' ? args.chip_name.trim() : '';
+        let chip;
+        if (chipName) {
+            chip = this.findChipByName(chipName);
+            if (!chip) {
+                return {
+                    content: [{ type: 'text', text: `未找到认知芯片「${chipName}」。` }],
+                    isError: true,
                 };
             }
-            if (name === 'list_configs') {
-                const names = this.resources.map((r) => r.name);
-                const text = names.length > 0
-                    ? `当前可用配置：\n${names.map((c) => `- ${c}`).join('\n')}`
-                    : '当前暂无可用配置，请先在 MemoryCode 中导出 memorycode-mcp.json 并放在 MCP 监听的路径。';
+        }
+        else {
+            const profile = this.getRuntimeActiveProfile();
+            if (!profile) {
                 return {
-                    content: [{ type: 'text', text }],
+                    content: [{ type: 'text', text: '当前没有已加载的档案，无法确定认知芯片。' }],
+                    isError: true,
                 };
             }
-            if (name === 'get_user_profile') {
-                const result = this.getUserProfile();
+            const chipId = this.parsed.runtime.activeChipByProfile[profile.id] ?? null;
+            if (!chipId) {
                 return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ profile: profile.name, activeChip: null, message: '当前档案未加载认知芯片' }, null, 2),
+                        },
+                    ],
                 };
             }
-            if (name === 'get_expertise') {
-                const domain = typeof args?.domain === 'string' ? args.domain : undefined;
-                const result = this.getExpertise(domain);
+            chip = this.findChipById(chipId);
+            if (!chip) {
                 return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    content: [
+                        {
+                            type: 'text',
+                            text: `当前档案记录的认知芯片「${chipId}」已不存在。请重新从 MemoryCode 导出 MCP 文件，或调用 unload_chip 清除该状态。`,
+                        },
+                    ],
+                    isError: true,
                 };
             }
-            throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${name}`);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        id: chip?.id,
+                        name: chip?.name,
+                        description: chip?.description,
+                        source: chip?.source,
+                        version: chip?.version,
+                        lastEditedAt: chip?.lastEditedAt,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    chipUnsupportedError() {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: '当前 MCP 文件不支持认知芯片切换。请从 MemoryCode 重新导出 memorycode-mcp.json（schema 1.1）。',
+                },
+            ],
+            isError: true,
+        };
+    }
+    listAllResources() {
+        const profileResources = this.parsed.resources.map((r) => {
+            const desc = r.description || r.name;
+            const description = desc.startsWith('Memory - ') ? desc : `Memory - ${desc}`;
+            return {
+                uri: PROFILE_URI_PREFIX + encodeURIComponent(r.id),
+                name: r.name,
+                description,
+                mimeType: MIME_TYPE,
+            };
         });
-        this.server.setRequestHandler(ListResourcesRequestSchema, (_request) => {
-            const resources = this.resources.map((r) => {
-                const desc = r.description || r.name;
-                const description = desc.startsWith('Memory - ') ? desc : `Memory - ${desc}`;
+        const chipResources = this.parsed.chips.map((c) => ({
+            uri: CHIP_URI_PREFIX + encodeURIComponent(c.id),
+            name: c.name,
+            description: `Chip - ${c.description}`,
+            mimeType: MIME_TYPE,
+        }));
+        return [...profileResources, ...chipResources];
+    }
+    handleReadResource(uri) {
+        if (uri.startsWith(PROFILE_URI_PREFIX)) {
+            const id = decodeURIComponent(uri.slice(PROFILE_URI_PREFIX.length));
+            const profile = this.parsed.profiles.find((p) => p.id === id);
+            const resource = this.parsed.resources.find((r) => r.id === id);
+            if (profile && this.supportsChipSwitching()) {
+                const chipState = this.resolveActiveChipForProfile(profile);
+                const prompt = this.resolvePrompt(profile.id, chipState.chipId);
+                if (prompt) {
+                    return {
+                        contents: [{ uri, mimeType: MIME_TYPE, text: prompt }],
+                    };
+                }
+            }
+            if (resource) {
                 return {
-                    uri: RESOURCE_URI_PREFIX + encodeURIComponent(r.id),
-                    name: r.name,
-                    description,
-                    mimeType: MIME_TYPE,
+                    contents: [{ uri, mimeType: MIME_TYPE, text: resource.prompt }],
                 };
-            });
-            return { resources };
-        });
-        this.server.setRequestHandler(ListResourceTemplatesRequestSchema, () => {
-            return { resourceTemplates: [] };
-        });
-        this.server.setRequestHandler(ReadResourceRequestSchema, (request) => {
-            const uri = request.params.uri;
-            if (!uri.startsWith(RESOURCE_URI_PREFIX)) {
-                throw new McpError(ErrorCode.InvalidParams, `Invalid resource URI: ${uri}`);
             }
-            const id = decodeURIComponent(uri.slice(RESOURCE_URI_PREFIX.length));
-            const resource = this.resources.find((r) => r.id === id);
-            if (!resource) {
-                throw new McpError(ErrorCode.InvalidParams, `Resource not found: ${uri}`);
+            throw new McpError(ErrorCode.InvalidParams, `Resource not found: ${uri}`);
+        }
+        if (uri.startsWith(CHIP_URI_PREFIX)) {
+            const id = decodeURIComponent(uri.slice(CHIP_URI_PREFIX.length));
+            const chip = this.findChipById(id);
+            if (!chip) {
+                throw new McpError(ErrorCode.InvalidParams, `Chip resource not found: ${uri}`);
             }
+            const text = [
+                `# 认知芯片：${chip.name}`,
+                '',
+                chip.description,
+                '',
+                `来源：${chip.source === 'official' ? '官方' : '自定义'}${chip.version ? ` · ${chip.version}` : ''}`,
+                '',
+                '使用方式：调用 load_chip 工具加载此芯片（需先 load_config 选择档案）。',
+                '此资源为芯片说明，不会自动改变当前会话状态。',
+            ].join('\n');
             return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: MIME_TYPE,
-                        text: resource.prompt,
-                    },
-                ],
+                contents: [{ uri, mimeType: MIME_TYPE, text }],
             };
+        }
+        throw new McpError(ErrorCode.InvalidParams, `Invalid resource URI: ${uri}`);
+    }
+    supportsChipSwitching() {
+        return (this.parsed.chips.length > 0 &&
+            this.parsed.compositions.length > 0 &&
+            (this.parsed.schemaVersion === '1.1' || this.parsed.chips.length > 0));
+    }
+    resolvePrompt(profileId, chipId) {
+        const match = this.parsed.compositions.find((c) => c.profileId === profileId && (c.chipId ?? null) === (chipId ?? null));
+        return match?.prompt ?? null;
+    }
+    resolveActiveChipForProfile(profile) {
+        const rawChipId = this.parsed.runtime.activeChipByProfile[profile.id] ?? profile.defaultChipId ?? null;
+        if (!rawChipId)
+            return { chipId: null };
+        const chip = this.findChipById(rawChipId);
+        if (!chip) {
+            return {
+                chipId: null,
+                warning: `记录的认知芯片「${rawChipId}」已不可用，已回到无芯片模式。`,
+            };
+        }
+        if (!this.resolvePrompt(profile.id, rawChipId)) {
+            return {
+                chipId: null,
+                warning: `记录的认知芯片「${chip.name}」缺少组合 prompt，已回到无芯片模式。`,
+            };
+        }
+        return { chipId: rawChipId };
+    }
+    runtimeWriteQueue = Promise.resolve();
+    queueRuntimePersist() {
+        this.parsed.runtime.updatedAt = new Date().toISOString();
+        if (!this.watchFilePath)
+            return Promise.resolve();
+        const runtimeSnapshot = {
+            activeProfileId: this.parsed.runtime.activeProfileId,
+            activeChipByProfile: { ...this.parsed.runtime.activeChipByProfile },
+            updatedAt: this.parsed.runtime.updatedAt,
+        };
+        this.runtimeWriteQueue = this.runtimeWriteQueue
+            .then(() => writeRuntime(this.watchFilePath, runtimeSnapshot))
+            .catch((err) => {
+            logWarn(`Failed to persist runtime: ${err}`);
         });
-        logInfo('[MemoryCode] MCP Server initialized, capabilities: resources (listChanged, subscribe), tools (load_config, list_configs, get_user_profile, get_expertise)');
+        return this.runtimeWriteQueue;
     }
-    updateMemorySnapshot(resources, payload) {
-        this.resources = resources;
-        this.memorySnapshot = payload;
-        this.server.sendResourceListChanged().catch((err) => {
-            logWarn(`Failed to send resources/list_changed: ${err}`);
+    getProfileNames() {
+        if (this.parsed.profiles.length > 0) {
+            return this.parsed.profiles.map((p) => p.name);
+        }
+        return this.parsed.resources.map((r) => r.name);
+    }
+    getRuntimeActiveProfile() {
+        const id = this.parsed.runtime.activeProfileId;
+        if (id) {
+            const byRuntime = this.parsed.profiles.find((p) => p.id === id);
+            if (byRuntime)
+                return byRuntime;
+        }
+        return this.parsed.profiles[0];
+    }
+    findProfileByName(name) {
+        const profiles = this.parsed.profiles.length > 0
+            ? this.parsed.profiles
+            : this.parsed.resources.map((r) => ({
+                id: r.id,
+                name: r.name,
+                description: r.description,
+                defaultChipId: null,
+            }));
+        const direct = profiles.find((p) => p.name === name || p.name.trim() === name);
+        if (direct)
+            return direct;
+        const normalized = this.normalizeName(name);
+        if (!normalized)
+            return undefined;
+        return profiles.find((p) => this.normalizeName(p.name) === normalized);
+    }
+    findChipByName(name) {
+        const direct = this.parsed.chips.find((c) => c.name === name || c.name.trim() === name);
+        if (direct)
+            return direct;
+        const normalized = this.normalizeName(name);
+        if (!normalized)
+            return undefined;
+        return this.parsed.chips.find((c) => {
+            if (this.normalizeName(c.name) === normalized)
+                return true;
+            return c.aliases.some((a) => this.normalizeName(a) === normalized);
         });
     }
+    findChipById(id) {
+        return this.parsed.chips.find((c) => c.id === id);
+    }
+    findResourceByConfigName(configName) {
+        const directMatch = this.parsed.resources.find((r) => r.name === configName || r.name.trim() === configName);
+        if (directMatch)
+            return directMatch;
+        const normalizedInput = this.normalizeName(configName);
+        if (!normalizedInput)
+            return undefined;
+        return this.parsed.resources.find((r) => this.normalizeName(r.name) === normalizedInput);
+    }
+    normalizeName(name) {
+        return name
+            .trim()
+            .toLowerCase()
+            .replace(/[^\p{L}\p{N}\p{Script=Han}]+/gu, '');
+    }
     getUserProfile() {
-        const profile = this.getActiveProfile();
+        const profile = this.getActiveProfileRecord();
+        const runtimeProfile = this.getRuntimeActiveProfile();
+        const chipId = runtimeProfile
+            ? (this.parsed.runtime.activeChipByProfile[runtimeProfile.id] ?? null)
+            : null;
         return {
             nickname: this.toSafeString(profile?.nickname),
             roles: this.toSafeStringArray(profile?.roles),
             about: this.toSafeString(profile?.role),
+            activeProfileId: this.parsed.runtime.activeProfileId,
+            activeChipId: chipId,
             source: 'memorycode-local',
             schema_version: '1.0',
         };
     }
     getExpertise(domainRaw) {
-        const profile = this.getActiveProfile();
+        const profile = this.getActiveProfileRecord();
         const domain = typeof domainRaw === 'string' ? domainRaw.trim().toLowerCase() : '';
         const skills = Array.isArray(profile?.skills) ? profile.skills : [];
         const expertise = skills
@@ -218,17 +664,20 @@ export class MemoryCodeMCPServer {
             source: 'memorycode-local',
         };
     }
-    getActiveProfile() {
+    /** 优先 runtime 档案，其次 data.state.activeProfileId */
+    getActiveProfileRecord() {
         if (!this.memorySnapshot || typeof this.memorySnapshot !== 'object')
             return null;
         const root = this.memorySnapshot;
         const data = this.asRecord(root.data);
         const state = this.asRecord(data?.state);
-        const profiles = Array.isArray(state?.profiles) ? state?.profiles : [];
-        const activeProfileId = this.toSafeString(state?.activeProfileId);
-        if (!activeProfileId)
+        const profiles = Array.isArray(state?.profiles) ? state.profiles : [];
+        const runtimeId = this.parsed.runtime.activeProfileId;
+        const fileActiveId = this.toSafeString(state?.activeProfileId);
+        const targetId = runtimeId ?? fileActiveId;
+        if (!targetId)
             return null;
-        const profile = profiles.find((item) => this.toSafeString(this.asRecord(item)?.id) === activeProfileId);
+        const profile = profiles.find((item) => this.toSafeString(this.asRecord(item)?.id) === targetId);
         return this.asRecord(profile);
     }
     asRecord(v) {
@@ -252,22 +701,6 @@ export class MemoryCodeMCPServer {
             return 'proficient';
         return 'familiar';
     }
-    findResourceByConfigName(configName) {
-        const directMatch = this.resources.find((r) => r.name === configName || r.name.trim() === configName);
-        if (directMatch)
-            return directMatch;
-        // 容错匹配：允许用户输入去掉 emoji/符号后的名称（如「职场」匹配「💼 职场」）
-        const normalizedInput = this.normalizeConfigName(configName);
-        if (!normalizedInput)
-            return undefined;
-        return this.resources.find((r) => this.normalizeConfigName(r.name) === normalizedInput);
-    }
-    normalizeConfigName(name) {
-        return name
-            .trim()
-            .toLowerCase()
-            .replace(/[^\p{L}\p{N}\p{Script=Han}]+/gu, '');
-    }
     async run() {
         this.transport = new StdioServerTransport();
         await this.server.connect(this.transport);