@eoasmxd/freya 0.4.0 → 0.4.2

package/plugins/plugin-weixin-channel/dist/index.js

@@ -1,8 +1,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-// @ts-ignore
-import qrcodeTerminal from "qrcode-terminal";
+import QRCode from "qrcode";
 const WEIXIN_MIME_MAP = {
     ".pdf": "application/pdf",
     ".txt": "text/plain",
@@ -228,45 +227,20 @@ export default class FreyaWeixinChannelPlugin {
             if (!qrcode) {
                 throw new Error("获取微信登录二维码失败：服务端未返回 qrcode");
             }
-            const matrix = [];
-            qrcodeTerminal.generate(scanUrl, { small: false }, (code) => {
-                const lines = code.split("\n");
-                for (const line of lines) {
-                    const cleanLine = line.replace(/[\r\n]/g, "");
-                    if (!cleanLine)
-                        continue;
-                    const row = [];
-                    const re = /\x1b\[(40|47)m  \x1b\[0m/g;
-                    let match;
-                    while ((match = re.exec(cleanLine)) !== null) {
-                        row.push(match[1] === "40" ? 1 : 0);
-                    }
-                    if (row.length > 0) {
-                        matrix.push(row);
-                    }
-                }
+            const qrAscii = await QRCode.toString(scanUrl, {
+                type: "utf8",
+                errorCorrectionLevel: "M",
+                margin: 2
             });
-            const size = matrix.length;
-            let svgContent = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="180" height="180" style="shape-rendering:crispEdges;">`;
-            svgContent += `<rect width="${size}" height="${size}" fill="#ffffff"/>`;
-            for (let y = 0; y < size; y++) {
-                const row = matrix[y];
-                for (let x = 0; x < row.length; x++) {
-                    if (row[x] === 1) {
-                        svgContent += `<rect x="${x}" y="${y}" width="1" height="1" fill="#000000"/>`;
-                    }
-                }
-            }
-            svgContent += `</svg>`;
-            const base64Svg = Buffer.from(svgContent).toString("base64");
-            const qrDataUri = `data:image/svg+xml;base64,${base64Svg}`;
             this.pollWeixinQrStatus(ctx, accountId, config, qrcode).catch((err) => {
                 ctx.logger.error(`微信账号 [${accountId}] 后台监听扫码绑定失败:`, err.message);
             });
-            return `⚠️ **微信账号 [${accountId}] 登录二维码已成功生成！**\n\n` +
+            return (`⚠️ **微信账号 [${accountId}] 登录二维码已成功生成！**\n\n` +
                 `**[微信扫码] 请使用微信扫描下方二维码绑定账号 [${accountId}]**：\n\n` +
-                `![微信登录二维码](${qrDataUri})\n\n` +
-                `*(提示：若二维码未能正常显示，您可以直接点击 [打开微信二维码网页](${scanUrl}) 扫码绑定)*`;
+                "```text\n" +
+                qrAscii +
+                "\n```\n\n" +
+                `*(提示：若字符二维码未能正常显示或无法扫描，您可以直接点击 [打开微信二维码网页](${scanUrl}) 扫码绑定)*`);
         }
         catch (err) {
             ctx.logger.error(`微信账号 [${accountId}] 拉取扫码登录失败:`, err.message);

package/plugins/plugin-weixin-channel/package.json

@@ -18,11 +18,12 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@eoasmxd/freya-sdk": "^0.4.0",
-    "qrcode-terminal": "^0.12.0"
+    "@eoasmxd/freya-sdk": "^0.4.2",
+    "qrcode": "^1.5.4"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@types/qrcode": "^1.5.5",
     "typescript": "^5.5.0"
   }
 }

package/src/packages/core/src/agent/agent-executor.ts

@@ -216,6 +216,11 @@ export class FreyaAgentExecutor {
     const deactivatedIds: string[] = [];
 
     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));
 

package/src/packages/core/src/command/command-executor.ts

@@ -32,6 +32,14 @@ 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/src/packages/core/src/command/command-registry.ts

@@ -1,11 +1,45 @@
 import type { FreyaCommand, FreyaContext } from '@eoasmxd/freya-sdk';
 
+const BUILTIN_COMMAND_CATEGORY_MAP: Record<string, string> = {
+  approve: 'auth',
+  reject: 'auth',
+  session: 'session',
+  model: 'model',
+  models: 'model'
+};
+
 /** 系统指令注册表：维护主指令与别名的映射字典 */
 export class FreyaCommandRegistry {
   private commands = new Map<string, FreyaCommand>();
   private aliasMap = new Map<string, string>();
   private pluginCommandsMap = new Map<string, string[]>();
 
+  constructor(private context?: FreyaContext) {}
+
+  setContext(context: FreyaContext): void {
+    this.context = context;
+  }
+
+  /** 判断指定指令当前是否已注册且处于可用启用状态 */
+  isCommandEnabled(name: string): boolean {
+    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 as any)?.commands?.builtin;
+      if (commandsConfig && typeof commandsConfig[category]?.enabled === 'boolean') {
+        return commandsConfig[category].enabled;
+      }
+    }
+
+    return true;
+  }
+
   /** 注册新的系统指令并建立别名路由 */
   register(command: FreyaCommand, pluginId?: string): void {
     const name = command.name.toLowerCase();
@@ -63,6 +97,6 @@ export class FreyaCommandRegistry {
   }
 
   list(): FreyaCommand[] {
-    return Array.from(this.commands.values());
+    return Array.from(this.commands.values()).filter((cmd) => this.isCommandEnabled(cmd.name));
   }
 }

package/src/packages/core/src/command/commands/skill-commands.ts

@@ -22,11 +22,12 @@ export function registerSkillCommands(deps: SkillCommandDeps): void {
     };
 
     const handleList = async (): Promise<string> => {
-        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 || '无描述'}`
+        const lines = activeSkills.map((s) =>
+            `- **${s.name}** \`${s.id}\` — ${s.description || '无描述'}`
         ).join('\n');
         return `### 📋 可用技能\n\n${lines}`;
     };
@@ -36,8 +37,8 @@ export function registerSkillCommands(deps: SkillCommandDeps): void {
             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/src/packages/core/src/config/config-manager.ts

@@ -4,6 +4,7 @@ import type { FreyaPluginManager } from '../plugin/plugin-manager.js';
 import type { FreyaPromptManager } from '../prompt/prompt-manager.js';
 import { FreyaConfigFileHandler } from './file-handler.js';
 import { FreyaConfigSchemaRegistry } from './schema-registry.js';
+import type { FreyaSkillRegistry, FreyaSkill } from '../skill/skill-registry.js';
 import path from 'node:path';
 import { PROJECT_ROOT } from '../utils/paths.js';
 
@@ -155,19 +156,22 @@ export class FreyaConfigManager {
   private llmRegistry: FreyaLLMRegistry;
   private pluginManager: FreyaPluginManager;
   private promptManager: FreyaPromptManager;
+  private skillRegistry?: FreyaSkillRegistry;
 
   constructor(
     context: FreyaContext,
     schemaRegistry: FreyaConfigSchemaRegistry,
     promptManager: FreyaPromptManager,
     llmRegistry: FreyaLLMRegistry,
-    pluginManager: FreyaPluginManager
+    pluginManager: FreyaPluginManager,
+    skillRegistry?: FreyaSkillRegistry
   ) {
     this.context = context;
     this.schemaRegistry = schemaRegistry;
     this.promptManager = promptManager;
     this.llmRegistry = llmRegistry;
     this.pluginManager = pluginManager;
+    this.skillRegistry = skillRegistry;
   }
 
   /** 获取全部敏感字段的 keyPath 列表 */
@@ -480,6 +484,16 @@ export class FreyaConfigManager {
     return await this.pluginManager.togglePlugin(pluginId, enabled);
   }
 
+  listSkills(): FreyaSkill[] {
+    if (!this.skillRegistry) return [];
+    return this.skillRegistry.getAllSkills();
+  }
+
+  async toggleSkill(skillId: string, enabled: boolean): Promise<string> {
+    if (!this.skillRegistry) return '❌ 技能注册表服务未初始化。';
+    return await this.skillRegistry.toggleSkill(skillId, enabled);
+  }
+
   async readPrompt(name: string): Promise<string> {
     const promptName = String(name).trim().toUpperCase();
     if (!ALLOWED_PROMPTS.has(promptName)) {
@@ -683,6 +697,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: '系统指令'
       }
     ];
 

package/src/packages/core/src/kernel.ts

@@ -49,11 +49,11 @@ export class FreyaKernel {
     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();
@@ -68,7 +68,8 @@ export class FreyaKernel {
       configSchemaRegistry,
       promptManager,
       llmRegistry,
-      this.pluginManager
+      this.pluginManager,
+      skillRegistry
     );
 
     configManager.registerCoreSchema();
@@ -96,7 +97,7 @@ export class FreyaKernel {
 
     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/src/packages/core/src/skill/skill-registry.ts

@@ -8,27 +8,66 @@ export interface FreyaSkill {
   name: string;
   description: string;
   content: string;
+  enabled: boolean;
+  source: 'builtin' | 'runtime';
 }
 
-/** 技能注册表，从 skills/ 目录加载 Markdown 格式技能 */
+/** 技能注册表，从 skills/ 目录加载 Markdown 格式技能并管理软开关状态 */
 export class FreyaSkillRegistry {
   private skills = new Map<string, FreyaSkill>();
+  private context?: FreyaContext;
 
   async loadSkills(context: FreyaContext): Promise<void> {
+    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: Array<{ id: string; enabled: boolean }> = [];
+      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<string, boolean>();
+      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: any) {
       context.logger.error('扫描物理技能 skills 目录遭遇故障:', err);
     }
   }
 
   /** 从指定目录加载技能到内存注册表中 */
-  private async loadSkillsFromDirectory(dirPath: string, context: FreyaContext): Promise<void> {
+  private async loadSkillsFromDirectory(dirPath: string, source: 'builtin' | 'runtime', context: FreyaContext): Promise<void> {
     try {
       const files = await fs.readdir(dirPath);
       for (const file of files) {
@@ -36,11 +75,17 @@ 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
             });
           }
         }
@@ -50,8 +95,55 @@ export class FreyaSkillRegistry {
     }
   }
 
-  getSkills(): Map<string, FreyaSkill> {
-    return this.skills;
+  /** 获取技能列表（默认只返回启用状态的技能） */
+  getSkills(onlyEnabled: boolean = true): Map<string, FreyaSkill> {
+    if (!onlyEnabled) {
+      return this.skills;
+    }
+    const filtered = new Map<string, FreyaSkill>();
+    for (const [id, skill] of this.skills.entries()) {
+      if (skill.enabled) {
+        filtered.set(id, skill);
+      }
+    }
+    return filtered;
+  }
+
+  /** 获取全量技能数组（供管理控制台使用） */
+  getAllSkills(): FreyaSkill[] {
+    return Array.from(this.skills.values());
+  }
+
+  /** 切换技能的启用/禁用状态并持久化 */
+  async toggleSkill(skillId: string, enabled: boolean): Promise<string> {
+    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: any) {
+      return `❌ 技能状态变更成功，但写入 skills.json 失败: ${err.message}`;
+    }
+  }
+
+  /** 持久化当前所有技能启停状态至 skills.json */
+  private async persistSkillsConfig(configSkillsPath: string): Promise<void> {
+    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: string): FreyaSkill | undefined {

package/src/packages/core/src/tools/meta/index.ts

@@ -1,11 +1,13 @@
 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 class FreyaMetaToolbox implements FreyaToolbox {
   constructor(
     private sessionManager: FreyaSessionManager,
-    private toolRegistry?: FreyaToolRegistry
+    private toolRegistry?: FreyaToolRegistry,
+    private skillRegistry?: FreyaSkillRegistry
   ) {}
 
   getId(): string {
@@ -106,6 +108,12 @@ export class FreyaMetaToolbox implements FreyaToolbox {
           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/src/packages/core/src/tools/tool-registry.ts

@@ -1,14 +1,39 @@
-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 class FreyaToolRegistry {
   private toolboxes: FreyaToolbox[] = [];
 
-  /** 注册一个工具箱（内置或外部插件）。 */
+  constructor(private context?: FreyaContext) {}
+
+  setContext(context: FreyaContext): void {
+    this.context = context;
+  }
+
+  /** 判断指定工具箱当前是否已注册且处于可用启用状态 */
+  isToolboxEnabled(toolboxId: string): boolean {
+    if (toolboxId === 'meta') {
+      return true;
+    }
+
+    const isRegistered = this.toolboxes.some((tb) => tb.getId() === toolboxId);
+    if (!isRegistered) {
+      return false;
+    }
+
+    const toolsConfig = (this.context?.config as any)?.tools?.builtin;
+    if (toolsConfig && typeof toolsConfig[toolboxId]?.enabled === 'boolean') {
+      return toolsConfig[toolboxId].enabled;
+    }
+
+    return true;
+  }
+
+  /** 注册工具箱 */
   registerToolbox(toolbox: FreyaToolbox): void {
     const newId = toolbox.getId();
     const existingIndex = this.toolboxes.findIndex((tb) => tb.getId() === newId || tb === toolbox);
@@ -25,16 +50,22 @@ export class FreyaToolRegistry {
     this.toolboxes = this.toolboxes.filter((tb) => tb.getId() !== id);
   }
 
-  /** 获取指定 ID 的工具箱中的所有原子工具。 */
+  /** 获取指定 ID 的工具箱中的所有原子工具 */
   getToolsInBox(id: string): FreyaTool[] {
+    if (!this.isToolboxEnabled(id)) {
+      return [];
+    }
     const tb = this.toolboxes.find((t) => t.getId() === id);
     return tb ? tb.getTools() : [];
   }
 
-  /** 聚合所有来源的工具，返回完整工具字典。 */
+  /** 聚合所有来源的已启用工具 */
   getAllTools(): Map<string, FreyaTool> {
     const tools = new Map<string, FreyaTool>();
     for (const toolbox of this.toolboxes) {
+      if (!this.isToolboxEnabled(toolbox.getId())) {
+        continue;
+      }
       for (const tool of toolbox.getTools()) {
         tools.set(tool.getDefinition().name, tool);
       }
@@ -42,13 +73,16 @@ export class FreyaToolRegistry {
     return tools;
   }
 
-  /** 根据当前会话已激活的工具箱列表，动态过滤获取所需的工具字典 */
+  /** 根据当前会话已激活的工具箱列表，过滤获取所需的工具字典 */
   getFilteredTools(activeToolboxIds: string[]): Map<string, FreyaTool> {
     const activeSet = new Set(activeToolboxIds || []);
     const tools = new Map<string, FreyaTool>();
 
     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);
@@ -58,16 +92,19 @@ export class FreyaToolRegistry {
     return tools;
   }
 
-  /** 聚合所有来源的工具提示词引导说明，延迟解析 key → 内容 */
+  /** 聚合所有已启用的工具箱提示词引导说明 */
   getToolInstructions(promptRegistry: FreyaPromptRegistry): string[] {
     const instructions: string[] = [];
     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}`);
       }
     }
@@ -75,6 +112,9 @@ export class FreyaToolRegistry {
   }
 
   getRegisteredToolboxIds(): string[] {
-    return this.toolboxes.map((tb) => tb.getId());
+    return this.toolboxes
+      .map((tb) => tb.getId())
+      .filter((id) => this.isToolboxEnabled(id));
   }
 }
+

package/src/packages/core/src/web/config-api.ts

@@ -199,6 +199,26 @@ export class FreyaConfigApi {
         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]);