@eoasmxd/freya 0.4.0 → 0.4.2

package/core/dist/agent/agent-executor.js

@@ -187,6 +187,11 @@ export class FreyaAgentExecutor {
         const nextToolboxIdleRounds = {};
         const deactivatedIds = [];
         for (const id of activeToolboxIds) {
+            if (!this.toolRegistry.isToolboxEnabled(id)) {
+                deactivatedIds.push(id);
+                this.context.logger.info(`[FreyaAgentExecutor] 工具箱 [${id}] 已被全局禁用，自动从当前会话卸载。`);
+                continue;
+            }
             const boxTools = this.toolRegistry.getToolsInBox(id);
             const isUsed = boxTools.some((tool) => executedToolNames.has(tool.getDefinition().name));
             if (isUsed) {

package/core/dist/command/command-executor.js

@@ -23,6 +23,13 @@ export class FreyaCommandExecutor {
             });
             return true;
         }
+        if (!this.registry.isCommandEnabled(commandName)) {
+            this.context.eventBus.emit('session:reply:error', {
+                sessionId,
+                message: `❌ 权限拒绝：系统指令 "/${commandName}" 已被系统管理员全局禁用。`
+            });
+            return true;
+        }
         try {
             const replyContent = await cmd.execute(args, sessionId, this.context, connectionId);
             if (replyContent) {

package/core/dist/command/command-registry.d.ts

@@ -1,9 +1,14 @@
-import type { FreyaCommand } from '@eoasmxd/freya-sdk';
+import type { FreyaCommand, FreyaContext } from '@eoasmxd/freya-sdk';
 /** 系统指令注册表：维护主指令与别名的映射字典 */
 export declare class FreyaCommandRegistry {
+    private context?;
     private commands;
     private aliasMap;
     private pluginCommandsMap;
+    constructor(context?: FreyaContext | undefined);
+    setContext(context: FreyaContext): void;
+    /** 判断指定指令当前是否已注册且处于可用启用状态 */
+    isCommandEnabled(name: string): boolean;
     /** 注册新的系统指令并建立别名路由 */
     register(command: FreyaCommand, pluginId?: string): void;
     /** 注销指定插件注册的所有指令与别名 */

package/core/dist/command/command-registry.js

@@ -1,8 +1,38 @@
+const BUILTIN_COMMAND_CATEGORY_MAP = {
+    approve: 'auth',
+    reject: 'auth',
+    session: 'session',
+    model: 'model',
+    models: 'model'
+};
 /** 系统指令注册表：维护主指令与别名的映射字典 */
 export class FreyaCommandRegistry {
+    context;
     commands = new Map();
     aliasMap = new Map();
     pluginCommandsMap = new Map();
+    constructor(context) {
+        this.context = context;
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    /** 判断指定指令当前是否已注册且处于可用启用状态 */
+    isCommandEnabled(name) {
+        const lowerName = name.toLowerCase();
+        const primaryName = this.aliasMap.get(lowerName) || lowerName;
+        if (!this.commands.has(primaryName)) {
+            return false;
+        }
+        const category = BUILTIN_COMMAND_CATEGORY_MAP[primaryName];
+        if (category) {
+            const commandsConfig = this.context?.config?.commands?.builtin;
+            if (commandsConfig && typeof commandsConfig[category]?.enabled === 'boolean') {
+                return commandsConfig[category].enabled;
+            }
+        }
+        return true;
+    }
     /** 注册新的系统指令并建立别名路由 */
     register(command, pluginId) {
         const name = command.name.toLowerCase();
@@ -54,6 +84,6 @@ export class FreyaCommandRegistry {
         return undefined;
     }
     list() {
-        return Array.from(this.commands.values());
+        return Array.from(this.commands.values()).filter((cmd) => this.isCommandEnabled(cmd.name));
     }
 }

package/core/dist/command/commands/skill-commands.js

@@ -10,10 +10,11 @@ export function registerSkillCommands(deps) {
         return '🔧 当前未激活任何技能。';
     };
     const handleList = async () => {
-        if (skills.size === 0) {
+        const activeSkills = Array.from(skills.values()).filter((s) => s.enabled !== false);
+        if (activeSkills.length === 0) {
             return '📋 暂无可用技能。';
         }
-        const lines = Array.from(skills.values()).map((s) => `- **${s.name}** — ${s.description || '无描述'}`).join('\n');
+        const lines = activeSkills.map((s) => `- **${s.name}** \`${s.id}\` — ${s.description || '无描述'}`).join('\n');
         return `### 📋 可用技能\n\n${lines}`;
     };
     const handleSet = async (skillId, sessionId) => {
@@ -21,8 +22,8 @@ export function registerSkillCommands(deps) {
             return '❌ 用法：`\`/skill set <skillId>\``。';
         }
         const skill = skills.get(skillId);
-        if (!skill) {
-            return `❌ 技能 \`${skillId}\` 不存在。请使用 \`/skill list\` 查看可用技能。`;
+        if (!skill || skill.enabled === false) {
+            return `❌ 技能 \`${skillId}\` 不存在或未启用。请使用 \`/skill list\` 查看可用技能。`;
         }
         await sessionManager.updateSession(sessionId, { activeSkillId: skillId });
         return `✅ 已激活技能: **${skill.name}** \`${skillId}\`。`;

package/core/dist/config/config-manager.d.ts

@@ -3,6 +3,7 @@ import type { FreyaLLMRegistry } from '../llm/llm-registry.js';
 import type { FreyaPluginManager } from '../plugin/plugin-manager.js';
 import type { FreyaPromptManager } from '../prompt/prompt-manager.js';
 import { FreyaConfigSchemaRegistry } from './schema-registry.js';
+import type { FreyaSkillRegistry, FreyaSkill } from '../skill/skill-registry.js';
 /** 核心统一配置管理器 */
 export declare class FreyaConfigManager {
     private context;
@@ -11,7 +12,8 @@ export declare class FreyaConfigManager {
     private llmRegistry;
     private pluginManager;
     private promptManager;
-    constructor(context: FreyaContext, schemaRegistry: FreyaConfigSchemaRegistry, promptManager: FreyaPromptManager, llmRegistry: FreyaLLMRegistry, pluginManager: FreyaPluginManager);
+    private skillRegistry?;
+    constructor(context: FreyaContext, schemaRegistry: FreyaConfigSchemaRegistry, promptManager: FreyaPromptManager, llmRegistry: FreyaLLMRegistry, pluginManager: FreyaPluginManager, skillRegistry?: FreyaSkillRegistry);
     /** 获取全部敏感字段的 keyPath 列表 */
     getSensitiveKeys(): string[];
     loadAndInit(): Promise<void>;
@@ -38,6 +40,8 @@ export declare class FreyaConfigManager {
     removeModel(providerId: string, modelId: string): Promise<string>;
     listPlugins(): Promise<any[]>;
     togglePlugin(pluginId: string, enabled: boolean): Promise<string>;
+    listSkills(): FreyaSkill[];
+    toggleSkill(skillId: string, enabled: boolean): Promise<string>;
     readPrompt(name: string): Promise<string>;
     writePrompt(name: string, content: string): Promise<string>;
     editPrompt(name: string, targetContent: string, replacementContent: string): Promise<string>;

package/core/dist/config/config-manager.js

@@ -138,12 +138,14 @@ export class FreyaConfigManager {
     llmRegistry;
     pluginManager;
     promptManager;
-    constructor(context, schemaRegistry, promptManager, llmRegistry, pluginManager) {
+    skillRegistry;
+    constructor(context, schemaRegistry, promptManager, llmRegistry, pluginManager, skillRegistry) {
         this.context = context;
         this.schemaRegistry = schemaRegistry;
         this.promptManager = promptManager;
         this.llmRegistry = llmRegistry;
         this.pluginManager = pluginManager;
+        this.skillRegistry = skillRegistry;
     }
     /** 获取全部敏感字段的 keyPath 列表 */
     getSensitiveKeys() {
@@ -475,6 +477,16 @@ export class FreyaConfigManager {
             return '❌ 插件服务未初始化。';
         return await this.pluginManager.togglePlugin(pluginId, enabled);
     }
+    listSkills() {
+        if (!this.skillRegistry)
+            return [];
+        return this.skillRegistry.getAllSkills();
+    }
+    async toggleSkill(skillId, enabled) {
+        if (!this.skillRegistry)
+            return '❌ 技能注册表服务未初始化。';
+        return await this.skillRegistry.toggleSkill(skillId, enabled);
+    }
     async readPrompt(name) {
         const promptName = String(name).trim().toUpperCase();
         if (!ALLOWED_PROMPTS.has(promptName)) {
@@ -676,6 +688,41 @@ export class FreyaConfigManager {
                 min: 10,
                 max: 300,
                 category: '安全'
+            },
+            {
+                key: 'tools.builtin.config.enabled',
+                defaultValue: true,
+                description: '是否启用系统核心配置工具箱（允许大模型查看与修改系统配置）',
+                type: 'boolean',
+                category: '系统工具'
+            },
+            {
+                key: 'tools.builtin.session.enabled',
+                defaultValue: true,
+                description: '是否启用会话与子任务管理工具箱（允许大模型查阅会话历史与派生子任务）',
+                type: 'boolean',
+                category: '系统工具'
+            },
+            {
+                key: 'commands.builtin.auth.enabled',
+                defaultValue: true,
+                description: '是否启用敏感操作授权审批指令（/approve 与 /reject）',
+                type: 'boolean',
+                category: '系统指令'
+            },
+            {
+                key: 'commands.builtin.session.enabled',
+                defaultValue: true,
+                description: '是否启用会话管理与路由指令（/session 及其子命令）',
+                type: 'boolean',
+                category: '系统指令'
+            },
+            {
+                key: 'commands.builtin.model.enabled',
+                defaultValue: true,
+                description: '是否启用模型查看与切换指令（/model 及其子命令）',
+                type: 'boolean',
+                category: '系统指令'
             }
         ];
         this.schemaRegistry.register('core', coreFields);

package/core/dist/kernel.js

@@ -44,17 +44,17 @@ export class FreyaKernel {
         ctx.logger.info('Freya 核心服务正在启动...');
         ctx.eventBus = new FreyaEventBus();
         const configSchemaRegistry = new FreyaConfigSchemaRegistry();
-        const toolRegistry = new FreyaToolRegistry();
+        const toolRegistry = new FreyaToolRegistry(ctx);
         const llmRegistry = new FreyaLLMRegistry();
         const promptRegistry = new FreyaPromptRegistry();
-        const commandRegistry = new FreyaCommandRegistry();
+        const commandRegistry = new FreyaCommandRegistry(ctx);
         this.channelRegistry = new FreyaChannelRegistry();
         const pluginRegistry = new FreyaPluginRegistry(toolRegistry, llmRegistry, this.channelRegistry);
         const skillRegistry = new FreyaSkillRegistry();
         const promptManager = new FreyaPromptManager(promptRegistry, ctx.logger);
         this.pluginManager = new FreyaPluginManager(configSchemaRegistry, commandRegistry, promptRegistry);
         await this.pluginManager.loadConfiguredPlugins(pluginRegistry, ctx);
-        const configManager = new FreyaConfigManager(ctx, configSchemaRegistry, promptManager, llmRegistry, this.pluginManager);
+        const configManager = new FreyaConfigManager(ctx, configSchemaRegistry, promptManager, llmRegistry, this.pluginManager, skillRegistry);
         configManager.registerCoreSchema();
         await configManager.loadAndInit();
         await configManager.resolveAndFreeze();
@@ -72,7 +72,7 @@ export class FreyaKernel {
         this.connectionManager = new FreyaConnectionManager(ctx.eventBus, ctx.logger);
         const configToolbox = new ConfigToolbox(configManager, ctx);
         const sessionToolbox = new SessionToolbox(this.sessionManager);
-        const metaToolbox = new FreyaMetaToolbox(this.sessionManager, toolRegistry);
+        const metaToolbox = new FreyaMetaToolbox(this.sessionManager, toolRegistry, skillRegistry);
         toolRegistry.registerToolbox(configToolbox);
         toolRegistry.registerToolbox(sessionToolbox);
         toolRegistry.registerToolbox(metaToolbox);

package/core/dist/skill/skill-registry.d.ts

@@ -4,14 +4,24 @@ export interface FreyaSkill {
     name: string;
     description: string;
     content: string;
+    enabled: boolean;
+    source: 'builtin' | 'runtime';
 }
-/** 技能注册表，从 skills/ 目录加载 Markdown 格式技能 */
+/** 技能注册表，从 skills/ 目录加载 Markdown 格式技能并管理软开关状态 */
 export declare class FreyaSkillRegistry {
     private skills;
+    private context?;
     loadSkills(context: FreyaContext): Promise<void>;
     /** 从指定目录加载技能到内存注册表中 */
     private loadSkillsFromDirectory;
-    getSkills(): Map<string, FreyaSkill>;
+    /** 获取技能列表（默认只返回启用状态的技能） */
+    getSkills(onlyEnabled?: boolean): Map<string, FreyaSkill>;
+    /** 获取全量技能数组（供管理控制台使用） */
+    getAllSkills(): FreyaSkill[];
+    /** 切换技能的启用/禁用状态并持久化 */
+    toggleSkill(skillId: string, enabled: boolean): Promise<string>;
+    /** 持久化当前所有技能启停状态至 skills.json */
+    private persistSkillsConfig;
     get(id: string): FreyaSkill | undefined;
     has(id: string): boolean;
     /** 解析技能文件的 YAML Frontmatter */

package/core/dist/skill/skill-registry.js

@@ -1,24 +1,57 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { APP_ROOT, PROJECT_ROOT } from '../utils/paths.js';
-/** 技能注册表，从 skills/ 目录加载 Markdown 格式技能 */
+/** 技能注册表，从 skills/ 目录加载 Markdown 格式技能并管理软开关状态 */
 export class FreyaSkillRegistry {
     skills = new Map();
+    context;
     async loadSkills(context) {
+        this.context = context;
         const runtimeSkillsDir = path.join(PROJECT_ROOT, 'skills');
         const defaultSkillsDir = path.join(APP_ROOT, 'skills');
+        const configSkillsPath = path.join(PROJECT_ROOT, 'config', 'skills.json');
         try {
             await fs.mkdir(runtimeSkillsDir, { recursive: true });
-            await this.loadSkillsFromDirectory(defaultSkillsDir, context);
-            await this.loadSkillsFromDirectory(runtimeSkillsDir, context);
-            context.logger.info(`动态技能扫描完成。共加载了 ${this.skills.size} 个物理技能。`);
+            await this.loadSkillsFromDirectory(defaultSkillsDir, 'builtin', context);
+            await this.loadSkillsFromDirectory(runtimeSkillsDir, 'runtime', context);
+            let configList = [];
+            try {
+                const raw = await fs.readFile(configSkillsPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed)) {
+                    configList = parsed;
+                }
+            }
+            catch {
+                configList = [];
+            }
+            const configMap = new Map();
+            for (const item of configList) {
+                if (item && typeof item.id === 'string' && typeof item.enabled === 'boolean') {
+                    configMap.set(item.id, item.enabled);
+                }
+            }
+            let configChanged = false;
+            for (const skill of this.skills.values()) {
+                if (configMap.has(skill.id)) {
+                    skill.enabled = configMap.get(skill.id);
+                }
+                else {
+                    configChanged = true;
+                }
+            }
+            if (configChanged || configList.length !== this.skills.size) {
+                await this.persistSkillsConfig(configSkillsPath);
+            }
+            const enabledCount = Array.from(this.skills.values()).filter((s) => s.enabled).length;
+            context.logger.info(`动态技能扫描完成。共加载 ${this.skills.size} 个物理技能 (已启用: ${enabledCount})。`);
         }
         catch (err) {
             context.logger.error('扫描物理技能 skills 目录遭遇故障:', err);
         }
     }
     /** 从指定目录加载技能到内存注册表中 */
-    async loadSkillsFromDirectory(dirPath, context) {
+    async loadSkillsFromDirectory(dirPath, source, context) {
         try {
             const files = await fs.readdir(dirPath);
             for (const file of files) {
@@ -26,11 +59,16 @@ export class FreyaSkillRegistry {
                     const rawContent = await fs.readFile(path.join(dirPath, file), 'utf-8');
                     const { metadata, content } = this.parseFrontmatter(rawContent);
                     if (metadata.id) {
+                        const defaultEnabled = metadata.defaultEnabled !== undefined
+                            ? metadata.defaultEnabled !== 'false'
+                            : source === 'builtin';
                         this.skills.set(metadata.id, {
                             id: metadata.id,
                             name: metadata.name || file.replace('.md', ''),
                             description: metadata.description || '',
-                            content: content.trim()
+                            content: content.trim(),
+                            enabled: defaultEnabled,
+                            source
                         });
                     }
                 }
@@ -40,8 +78,51 @@ export class FreyaSkillRegistry {
             context.logger.warn(`扫描技能目录失败: ${dirPath}`, err);
         }
     }
-    getSkills() {
-        return this.skills;
+    /** 获取技能列表（默认只返回启用状态的技能） */
+    getSkills(onlyEnabled = true) {
+        if (!onlyEnabled) {
+            return this.skills;
+        }
+        const filtered = new Map();
+        for (const [id, skill] of this.skills.entries()) {
+            if (skill.enabled) {
+                filtered.set(id, skill);
+            }
+        }
+        return filtered;
+    }
+    /** 获取全量技能数组（供管理控制台使用） */
+    getAllSkills() {
+        return Array.from(this.skills.values());
+    }
+    /** 切换技能的启用/禁用状态并持久化 */
+    async toggleSkill(skillId, enabled) {
+        const skill = this.skills.get(skillId);
+        if (!skill) {
+            return `❌ 未找到 ID 为 "${skillId}" 的技能，请检查名称是否正确。`;
+        }
+        if (skill.enabled === enabled) {
+            return `ℹ️ 技能 "${skill.name || skillId}" 状态已是 ${enabled ? '启用' : '禁用'}。`;
+        }
+        skill.enabled = enabled;
+        const configSkillsPath = path.join(PROJECT_ROOT, 'config', 'skills.json');
+        try {
+            await this.persistSkillsConfig(configSkillsPath);
+            this.context?.logger.info(`技能 "${skill.name || skillId}" 已切换为: ${enabled ? '启用' : '禁用'}`);
+            return `✅ 技能 "${skill.name || skillId}" 已成功${enabled ? '启用' : '禁用'}。`;
+        }
+        catch (err) {
+            return `❌ 技能状态变更成功，但写入 skills.json 失败: ${err.message}`;
+        }
+    }
+    /** 持久化当前所有技能启停状态至 skills.json */
+    async persistSkillsConfig(configSkillsPath) {
+        await fs.mkdir(path.dirname(configSkillsPath), { recursive: true });
+        const payload = Array.from(this.skills.values()).map((s) => ({
+            id: s.id,
+            enabled: s.enabled
+        }));
+        await fs.writeFile(configSkillsPath, JSON.stringify(payload, null, 2) + '\n', 'utf-8');
     }
     get(id) {
         return this.skills.get(id);

package/core/dist/tools/meta/index.d.ts

@@ -1,10 +1,12 @@
 import type { FreyaTool, FreyaToolbox } from '@eoasmxd/freya-sdk';
 import type { FreyaSessionManager } from '../../session/session-manager.js';
 import type { FreyaToolRegistry } from '../tool-registry.js';
+import type { FreyaSkillRegistry } from '../../skill/skill-registry.js';
 export declare class FreyaMetaToolbox implements FreyaToolbox {
     private sessionManager;
     private toolRegistry?;
-    constructor(sessionManager: FreyaSessionManager, toolRegistry?: FreyaToolRegistry | undefined);
+    private skillRegistry?;
+    constructor(sessionManager: FreyaSessionManager, toolRegistry?: FreyaToolRegistry | undefined, skillRegistry?: FreyaSkillRegistry | undefined);
     getId(): string;
     getInstructionPrompt(): string;
     getTools(): FreyaTool[];

package/core/dist/tools/meta/index.js

@@ -1,9 +1,11 @@
 export class FreyaMetaToolbox {
     sessionManager;
     toolRegistry;
-    constructor(sessionManager, toolRegistry) {
+    skillRegistry;
+    constructor(sessionManager, toolRegistry, skillRegistry) {
         this.sessionManager = sessionManager;
         this.toolRegistry = toolRegistry;
+        this.skillRegistry = skillRegistry;
     }
     getId() {
         return 'meta';
@@ -99,6 +101,12 @@ export class FreyaMetaToolbox {
                     if (!sessionId) {
                         return '❌ 错误：无法从执行上下文中提取当前会话ID。';
                     }
+                    if (this.skillRegistry) {
+                        const skill = this.skillRegistry.get(skillId);
+                        if (!skill || !skill.enabled) {
+                            return `❌ 错误：技能 [${skillId}] 不存在或已被系统管理员禁用，无法切入该模式。`;
+                        }
+                    }
                     await this.sessionManager.updateSession(sessionId, { activeSkillId: skillId });
                     return `已成功切入 [${skillId}] 技能特长工作模式。`;
                 }

package/core/dist/tools/tool-registry.d.ts

@@ -1,22 +1,27 @@
-import type { FreyaTool, FreyaToolbox } from '@eoasmxd/freya-sdk';
+import type { FreyaContext, FreyaTool, FreyaToolbox } from '@eoasmxd/freya-sdk';
 import type { FreyaPromptRegistry } from '../prompt/prompt-registry.js';
 /**
  * 内核工具注册表。
- * 统一聚合内置工具箱与来自插件体系的外部工具/工具箱。
+ * 统一聚合内置工具箱与来自插件体系的外部工具箱。
  */
 export declare class FreyaToolRegistry {
+    private context?;
     private toolboxes;
-    /** 注册一个工具箱（内置或外部插件）。 */
+    constructor(context?: FreyaContext | undefined);
+    setContext(context: FreyaContext): void;
+    /** 判断指定工具箱当前是否已注册且处于可用启用状态 */
+    isToolboxEnabled(toolboxId: string): boolean;
+    /** 注册工具箱 */
     registerToolbox(toolbox: FreyaToolbox): void;
     /** 注销工具箱 */
     unregisterToolbox(id: string): void;
-    /** 获取指定 ID 的工具箱中的所有原子工具。 */
+    /** 获取指定 ID 的工具箱中的所有原子工具 */
     getToolsInBox(id: string): FreyaTool[];
-    /** 聚合所有来源的工具，返回完整工具字典。 */
+    /** 聚合所有来源的已启用工具 */
     getAllTools(): Map<string, FreyaTool>;
-    /** 根据当前会话已激活的工具箱列表，动态过滤获取所需的工具字典 */
+    /** 根据当前会话已激活的工具箱列表，过滤获取所需的工具字典 */
     getFilteredTools(activeToolboxIds: string[]): Map<string, FreyaTool>;
-    /** 聚合所有来源的工具提示词引导说明，延迟解析 key → 内容 */
+    /** 聚合所有已启用的工具箱提示词引导说明 */
     getToolInstructions(promptRegistry: FreyaPromptRegistry): string[];
     getRegisteredToolboxIds(): string[];
 }

package/core/dist/tools/tool-registry.js

@@ -1,10 +1,32 @@
 /**
  * 内核工具注册表。
- * 统一聚合内置工具箱与来自插件体系的外部工具/工具箱。
+ * 统一聚合内置工具箱与来自插件体系的外部工具箱。
  */
 export class FreyaToolRegistry {
+    context;
     toolboxes = [];
-    /** 注册一个工具箱（内置或外部插件）。 */
+    constructor(context) {
+        this.context = context;
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    /** 判断指定工具箱当前是否已注册且处于可用启用状态 */
+    isToolboxEnabled(toolboxId) {
+        if (toolboxId === 'meta') {
+            return true;
+        }
+        const isRegistered = this.toolboxes.some((tb) => tb.getId() === toolboxId);
+        if (!isRegistered) {
+            return false;
+        }
+        const toolsConfig = this.context?.config?.tools?.builtin;
+        if (toolsConfig && typeof toolsConfig[toolboxId]?.enabled === 'boolean') {
+            return toolsConfig[toolboxId].enabled;
+        }
+        return true;
+    }
+    /** 注册工具箱 */
     registerToolbox(toolbox) {
         const newId = toolbox.getId();
         const existingIndex = this.toolboxes.findIndex((tb) => tb.getId() === newId || tb === toolbox);
@@ -19,27 +41,36 @@ export class FreyaToolRegistry {
     unregisterToolbox(id) {
         this.toolboxes = this.toolboxes.filter((tb) => tb.getId() !== id);
     }
-    /** 获取指定 ID 的工具箱中的所有原子工具。 */
+    /** 获取指定 ID 的工具箱中的所有原子工具 */
     getToolsInBox(id) {
+        if (!this.isToolboxEnabled(id)) {
+            return [];
+        }
         const tb = this.toolboxes.find((t) => t.getId() === id);
         return tb ? tb.getTools() : [];
     }
-    /** 聚合所有来源的工具，返回完整工具字典。 */
+    /** 聚合所有来源的已启用工具 */
     getAllTools() {
         const tools = new Map();
         for (const toolbox of this.toolboxes) {
+            if (!this.isToolboxEnabled(toolbox.getId())) {
+                continue;
+            }
             for (const tool of toolbox.getTools()) {
                 tools.set(tool.getDefinition().name, tool);
             }
         }
         return tools;
     }
-    /** 根据当前会话已激活的工具箱列表，动态过滤获取所需的工具字典 */
+    /** 根据当前会话已激活的工具箱列表，过滤获取所需的工具字典 */
     getFilteredTools(activeToolboxIds) {
         const activeSet = new Set(activeToolboxIds || []);
         const tools = new Map();
         for (const toolbox of this.toolboxes) {
             const toolboxId = toolbox.getId();
+            if (!this.isToolboxEnabled(toolboxId)) {
+                continue;
+            }
             if (toolboxId === 'meta' || activeSet.has(toolboxId)) {
                 for (const tool of toolbox.getTools()) {
                     tools.set(tool.getDefinition().name, tool);
@@ -48,22 +79,27 @@ export class FreyaToolRegistry {
         }
         return tools;
     }
-    /** 聚合所有来源的工具提示词引导说明，延迟解析 key → 内容 */
+    /** 聚合所有已启用的工具箱提示词引导说明 */
     getToolInstructions(promptRegistry) {
         const instructions = [];
         for (const toolbox of this.toolboxes) {
+            const toolboxId = toolbox.getId();
+            if (!this.isToolboxEnabled(toolboxId)) {
+                continue;
+            }
             const key = toolbox.getInstructionPrompt?.();
             if (!key)
                 continue;
             const resolved = promptRegistry.get(key);
             if (resolved) {
-                const toolboxId = toolbox.getId();
                 instructions.push(`### 工具箱能力说明 [激活ID: "${toolboxId}"]\n${resolved}`);
             }
         }
         return instructions;
     }
     getRegisteredToolboxIds() {
-        return this.toolboxes.map((tb) => tb.getId());
+        return this.toolboxes
+            .map((tb) => tb.getId())
+            .filter((id) => this.isToolboxEnabled(id));
     }
 }

package/core/dist/web/config-api.js

@@ -177,6 +177,24 @@ export class FreyaConfigApi {
                 res.end(JSON.stringify({ success: !msg.startsWith('❌'), message: msg }));
                 return true;
             }
+            if (pathname === '/api/config/skills' && req.method === 'GET') {
+                const skills = this.configManager.listSkills();
+                res.writeHead(200, this.headers);
+                res.end(JSON.stringify({ success: true, data: skills }));
+                return true;
+            }
+            if (pathname === '/api/config/skills/toggle' && req.method === 'POST') {
+                const { skillId, enabled } = await this.getBody(req);
+                if (!skillId) {
+                    res.writeHead(200, this.headers);
+                    res.end(JSON.stringify({ success: false, error: '缺少必要参数: skillId' }));
+                    return true;
+                }
+                const msg = await this.configManager.toggleSkill(skillId, enabled);
+                res.writeHead(200, this.headers);
+                res.end(JSON.stringify({ success: !msg.startsWith('❌'), message: msg }));
+                return true;
+            }
             const promptMatch = pathname.match(/^\/api\/config\/prompts\/([^/]+)$/);
             if (promptMatch && req.method === 'GET') {
                 const promptName = decodeURIComponent(promptMatch[1]);

package/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eoasmxd/freya-core",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "private": false,
   "license": "MIT",
   "publishConfig": {
@@ -16,7 +16,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@eoasmxd/freya-sdk": "^0.4.0",
+    "@eoasmxd/freya-sdk": "^0.4.2",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eoasmxd/freya",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "license": "MIT",
   "type": "module",
   "description": "Freya - 微内核智能体系统",
@@ -35,9 +35,10 @@
     "src"
   ],
   "dependencies": {
-    "@eoasmxd/freya-sdk": "^0.4.0",
+    "@eoasmxd/freya-sdk": "^0.4.2",
     "ws": "^8.18.0",
-    "qrcode-terminal": "^0.12.0"
+    "mysql2": "^3.11.0",
+    "qrcode": "^1.5.4"
   },
   "scripts": {
     "start": "node freya.js",