foliko 2.0.5 → 2.0.6

package/src/plugin/base.js

@@ -21,6 +21,12 @@ class Plugin {
   _framework = null;
   _subAgents = [];
   tools = {};
+  _registeredTools = [];       // 记录通过 tool.register 注册的工具 { name, def }
+  _registeredExtensions = [];   // 记录通过 extension.register 注册的扩展工具 { extName, toolName, toolDef }
+  _registeredWorkflows = [];   // 记录通过 workflow.register 注册的工作流 { name, def }
+  _registeredAgents = [];       // 记录通过 agent.register 注册的子代理 { name, agent }
+  _registeredPrompts = [];   // 记录通过 prompt.register 注册的 prompt parts { name, provider, options }
+  _registeredSkills = [];       // 记录通过 skill.register 注册的技能 { name, content, metadata, options }
 
   /**
    * 声明式 prompt parts（推荐使用，替代 start() 中的 registerPromptPart 调用）
@@ -74,16 +80,730 @@ class Plugin {
     }
   }
 
+  /**
+   * 注册工具到 ToolRegistry（AI SDK 直接调用方式）
+   * 会在 uninstall/reload 时自动移除
+   *
+   * 用法：
+   *   this.tool.register({
+   *     name: 'my-tool',
+   *     description: '描述',
+   *     inputSchema: z.object({ ... }),
+   *     execute: async (args) => { ... }
+   *   });
+   */
+  get tool() {
+    if (!this._toolAccessor) {
+      this._toolAccessor = {
+        register: (toolDef) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] tool.register() called before plugin installed`);
+            return;
+          }
+          const registry = this._framework.toolRegistry;
+          if (!registry) {
+            log.warn(`[${this.name}] toolRegistry not found`);
+            return;
+          }
+          if (!toolDef || !toolDef.name) {
+            log.warn(`[${this.name}] tool.register() missing tool name`);
+            return;
+          }
+          // 记录，用于卸载时清理
+          this._registeredTools.push({ name: toolDef.name, def: toolDef });
+          // 阻止重复注册同名工具
+          if (registry.has(toolDef.name)) {
+            log.debug(`[${this.name}] Tool '${toolDef.name}' already registered, skipping`);
+            return;
+          }
+          registry.register(toolDef);
+          log.debug(`[${this.name}] Registered tool: ${toolDef.name}`);
+        },
+        remove: (toolName) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] tool.remove() called before plugin installed`);
+            return;
+          }
+          const registry = this._framework.toolRegistry;
+          if (!registry) return;
+          registry.unregister(toolName);
+          this._registeredTools = this._registeredTools.filter(t => t.name !== toolName);
+          log.debug(`[${this.name}] Removed tool: ${toolName}`);
+        },
+
+        /**
+         * 执行已注册的工具
+         * @param {string} toolName 工具名称
+         * @param {object} args 工具参数
+         * @param {object} context 执行上下文（可选）
+         */
+        execute: async (toolName, args, context = {}) => {
+          if (!this._framework) {
+            throw new Error(`[${this.name}] tool.execute() called before plugin installed`);
+          }
+          const registry = this._framework.toolRegistry;
+          if (!registry) {
+            throw new Error(`[${this.name}] toolRegistry not found`);
+          }
+          if (!registry.has(toolName)) {
+            throw new Error(`[${this.name}] Tool '${toolName}' not found`);
+          }
+          return await registry.execute(toolName, args, context);
+        },
+      };
+    }
+    return this._toolAccessor;
+  }
+
+  /**
+   * 注册扩展工具到 ExtensionExecutor（通过 ext_call 间接调用）
+   * 会在 uninstall/reload 时自动移除
+   * 扩展名自动使用 this.name
+   *
+   * 用法：
+   *   this.extension.register({
+   *     name: 'do-something',
+   *     description: '描述',
+   *     inputSchema: z.object({ ... }),
+   *     execute: async (args) => { ... }
+   *   });
+   */
+  get extension() {
+    if (!this._extensionAccessor) {
+      this._extensionAccessor = {
+        register: (toolDef) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] extension.register() called before plugin installed`);
+            return;
+          }
+          if (!toolDef || !toolDef.name) {
+            log.warn(`[${this.name}] extension.register() missing tool name`);
+            return;
+          }
+          // 记录，用于卸载时清理（扩展名自动用 this.name）
+          // 即使 extExec 还未加载，也先记录
+          this._registeredExtensions.push({ extName: this.name, toolName: toolDef.name, toolDef });
+
+          const extExec = this._framework.pluginManager.get('extension-executor');
+          if (!extExec) {
+            log.debug(`[${this.name}] extension-executor not found yet, deferring tool registration: ${toolDef.name}`);
+            return;
+          }
+          // extExec 可用，立即注册
+          extExec.registerTool(
+            this.name,
+            {
+              name: this.name,
+              description: this.description,
+              version: this.version,
+            },
+            toolDef
+          );
+          // 强制失效缓存，确保 prompt 能更新
+          extExec._invalidatePromptCaches(this._framework);
+          log.debug(`[${this.name}] Registered extension tool: ${this.name}/${toolDef.name}`);
+        },
+        remove: (toolName) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] extension.remove() called before plugin installed`);
+            return;
+          }
+          const extExec = this._framework.pluginManager.get('extension-executor');
+          if (extExec) {
+            extExec._unregisterTool(this.name, toolName);
+          }
+          this._registeredExtensions = this._registeredExtensions.filter(
+            e => !(e.extName === this.name && e.toolName === toolName)
+          );
+          log.debug(`[${this.name}] Removed extension tool: ${this.name}/${toolName}`);
+        },
+
+        /**
+         * 执行扩展工具（通过 ext_call 调用）
+         * 支持两种调用方式：
+         *   this.extension.execute('tool-name', args)           // 执行当前插件的
+         *   this.extension.execute('plugin-name', 'tool-name', args)  // 执行指定插件的
+         */
+        execute: async (pluginNameOrToolName, toolNameOrArgs, args = {}) => {
+          if (!this._framework) {
+            throw new Error(`[${this.name}] extension.execute() called before plugin installed`);
+          }
+          const extExec = this._framework.pluginManager.get('extension-executor');
+          if (!extExec) {
+            return { success: false, error: 'extension-executor not found' };
+          }
+
+          let pluginName, toolName;
+          if (typeof toolNameOrArgs === 'object') {
+            // 第一种：只传工具名和参数
+            pluginName = this.name;
+            toolName = pluginNameOrToolName;
+            args = toolNameOrArgs;
+          } else {
+            // 第二种：传插件名、工具名和参数
+            pluginName = pluginNameOrToolName;
+            toolName = toolNameOrArgs;
+          }
+
+          const result = await extExec._executeTool(pluginName, toolName, args, this._framework);
+          return result;
+        },
+      };
+    }
+    return this._extensionAccessor;
+  }
+
+  /**
+   * 注册工作流到 WorkflowEngine
+   * 支持 register/remove/execute 方法
+   *
+   * 用法：
+   *   this.workflow.register('my-workflow', {
+   *     name: 'my-workflow',
+   *     steps: [...]
+   *   });
+   */
+  get workflow() {
+    if (!this._workflowAccessor) {
+      this._workflowAccessor = {
+        register: (name, workflowDef) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] workflow.register() called before plugin installed`);
+            return;
+          }
+          const workflowPlugin = this._framework.pluginManager?.get('workflow');
+          if (!workflowPlugin) {
+            log.warn(`[${this.name}] workflow plugin not found`);
+            return;
+          }
+          if (!name || !workflowDef) {
+            log.warn(`[${this.name}] workflow.register() missing name or definition`);
+            return;
+          }
+          // 记录，用于卸载时清理
+          this._registeredWorkflows.push({ name, def: workflowDef });
+          // 注册到 workflow plugin
+          workflowPlugin._workflows.set(name, workflowDef);
+          // 注册为工具
+          workflowPlugin._registerWorkflowTools();
+          log.debug(`[${this.name}] Registered workflow: ${name}`);
+        },
+
+        remove: (name) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] workflow.remove() called before plugin installed`);
+            return;
+          }
+          const workflowPlugin = this._framework.pluginManager?.get('workflow');
+          if (!workflowPlugin) return;
+          workflowPlugin.remove(name);
+          this._registeredWorkflows = this._registeredWorkflows.filter(w => w.name !== name);
+          log.debug(`[${this.name}] Removed workflow: ${name}`);
+        },
+
+        execute: async (name, input = {}) => {
+          if (!this._framework) {
+            throw new Error(`[${this.name}] workflow.execute() called before plugin installed`);
+          }
+          const workflowPlugin = this._framework.pluginManager?.get('workflow');
+          if (!workflowPlugin) {
+            throw new Error(`[${this.name}] workflow plugin not found`);
+          }
+          return await workflowPlugin.executeWorkflow(name, input);
+        },
+      };
+    }
+    return this._workflowAccessor;
+  }
+
+  /**
+   * 注册子代理到框架
+   * 支持 register/remove/execute 方法
+   *
+   * 用法：
+   *   this.agent.register({
+   *     name: 'my-agent',
+   *     role: '助手',
+   *     goal: '描述',
+   *     tools: {},
+   *     parentTools: []
+   *   });
+   */
+  get agent() {
+    if (!this._agentAccessor) {
+      this._agentAccessor = {
+        register: (config) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] agent.register() called before plugin installed`);
+            return;
+          }
+          if (!config || !config.name) {
+            log.warn(`[${this.name}] agent.register() missing config or name`);
+            return;
+          }
+          const subAgentManager = this._framework.pluginManager.get('subagent-manager');
+          if (!subAgentManager) {
+            log.warn(`[${this.name}] subagent-manager plugin not found`);
+            return;
+          }
+
+          const agent = this._framework.createSubAgent({
+            name: config.name,
+            role: config.role,
+            goal: config.description || config.role,
+            tools: config.tools || {},
+            parentTools: config.parentTools || [],
+          });
+
+          subAgentManager.registerPlugin({
+            name: config.name,
+            role: config.role,
+            goal: config.description || config.role,
+            agent,
+            tools: config.tools || {},
+          });
+
+          // 记录，用于卸载时清理
+          this._registeredAgents.push({ name: config.name, agent });
+
+          // 也添加到 _subAgents 供基类管理
+          this._subAgents.push({
+            name: config.name,
+            agent,
+            plugin: null,
+          });
+
+          log.debug(`[${this.name}] Registered agent: ${config.name}`);
+        },
+
+        remove: (name) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] agent.remove() called before plugin installed`);
+            return;
+          }
+          const subAgentManager = this._framework.pluginManager.get('subagent-manager');
+          if (!subAgentManager) return;
+
+          subAgentManager.unregisterPlugin(name);
+
+          // 从 _subAgents 移除
+          this._subAgents = this._subAgents.filter(s => s.name !== name);
+          // 从 _registeredAgents 移除
+          this._registeredAgents = this._registeredAgents.filter(a => a.name !== name);
+
+          log.debug(`[${this.name}] Removed agent: ${name}`);
+        },
+
+        get: (name) => {
+          return this._registeredAgents.find(a => a.name === name)?.agent;
+        },
+      };
+    }
+    return this._agentAccessor;
+  }
+
+  /**
+   * 注册 Prompt Part 到 framework.prompts
+   * 支持 register/remove 方法
+   *
+   * 用法：
+   *   this.prompt.register('my-prompt', () => 'prompt content', { scope: 'global', priority: 50 });
+   */
+  get prompt() {
+    if (!this._promptAccessor) {
+      this._promptAccessor = {
+        register: (name, provider, options = {}) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] prompt.register() called before plugin installed`);
+            return;
+          }
+          const reg = this._framework.prompts;
+          if (!reg) {
+            log.warn(`[${this.name}] prompts registry not found`);
+            return;
+          }
+          if (!name || !provider) {
+            log.warn(`[${this.name}] prompt.register() missing name or provider`);
+            return;
+          }
+          // 记录，用于卸载时清理
+          this._registeredPrompts.push({ name, provider, options });
+          // 注册到 framework.prompts
+          reg.register(this.name, name, provider, options);
+          log.debug(`[${this.name}] Registered prompt: ${name}`);
+        },
+
+        remove: (name) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] prompt.remove() called before plugin installed`);
+            return;
+          }
+          const reg = this._framework.prompts;
+          if (!reg) return;
+          reg.clearOwner(this.name, name);
+          this._registeredPrompts = this._registeredPrompts.filter(p => p.name !== name);
+          log.debug(`[${this.name}] Removed prompt: ${name}`);
+        },
+      };
+    }
+    return this._promptAccessor;
+  }
+
+  /**
+   * 注册/查询/删除 Skill（程序化管理技能）
+   * 会在 uninstall/reload 时自动清理
+   *
+   * 用法：
+   *   // 注册
+   *   this.skill.register('my-skill', '技能内容（markdown）', {
+   *     description: '技能描述',
+   *     'allowed-tools': 'tool1,tool2'
+   *   }, {
+   *     commands: [{ name: 'cmd1', description: '...', execute: async (args) => {...} }],
+   *     references: { 'extra': 'extra.md' },
+   *     path: '/path/to/skill'  // 可选
+   *   });
+   *
+   *   // 查询
+   *   const skill = this.skill.get('my-skill');
+   *   const details = this.skill.details('my-skill');
+   *
+   *   // 删除
+   *   this.skill.remove('my-skill');
+   */
+  get skill() {
+    if (!this._skillAccessor) {
+      this._skillAccessor = {
+        /**
+         * 注册一个技能
+         * @param {string} name 技能名称
+         * @param {string} content 技能内容（markdown）
+         * @param {Object} [metadata] 元数据 { description, license, compatibility, allowedTools, 'allowed-tools' }
+         * @param {Object} [options] 选项 { commands, references, scripts, path }
+         * @returns {Object|null} 注册结果
+         */
+        register: (name, content, metadata = {}, options = {}) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] skill.register() called before plugin installed`);
+            return null;
+          }
+          if (!name) {
+            log.warn(`[${this.name}] skill.register() missing name`);
+            return null;
+          }
+          const sm = this._framework.pluginManager?.get('skill-manager');
+          if (!sm) {
+            log.warn(`[${this.name}] skill-manager plugin not found`);
+            return null;
+          }
+          // 记录，用于卸载时清理
+          this._registeredSkills.push({ name, content, metadata, options });
+          // 调用 skill-manager 的 register
+          const result = sm.register(name, content || '', metadata, options);
+          log.debug(`[${this.name}] Registered skill: ${name}`);
+          return result;
+        },
+
+        /**
+         * 获取技能信息
+         * @param {string} name 技能名
+         * @returns {Object|null}
+         */
+        get: (name) => {
+          const sm = this._framework?.pluginManager?.get('skill-manager');
+          return sm?.getSkill?.(name) || null;
+        },
+
+        /**
+         * 检查技能是否存在
+         */
+        has: (name) => {
+          const sm = this._framework?.pluginManager?.get('skill-manager');
+          return sm?.hasSkill?.(name) || false;
+        },
+
+        /**
+         * 获取技能详情（description、metadata、content、path、commands、references、scripts）
+         */
+        details: (name) => {
+          const sm = this._framework?.pluginManager?.get('skill-manager');
+          return sm?.getSkillDetails?.(name) || null;
+        },
+
+        /**
+         * 列出所有已注册的技能名
+         */
+        list: () => {
+          const sm = this._framework?.pluginManager?.get('skill-manager');
+          return sm?.getAllSkills?.() || [];
+        },
+
+        /**
+         * 列出本插件注册的技能
+         */
+        listOwned: () => {
+          return this._registeredSkills.map((s) => s.name);
+        },
+
+        /**
+         * 删除技能
+         * @param {string} name 技能名
+         * @returns {boolean} 是否成功删除
+         */
+        remove: (name) => {
+          if (!this._framework) {
+            log.warn(`[${this.name}] skill.remove() called before plugin installed`);
+            return false;
+          }
+          const sm = this._framework.pluginManager?.get('skill-manager');
+          if (!sm) return false;
+          const removed = sm.remove(name);
+          if (removed) {
+            this._registeredSkills = this._registeredSkills.filter((s) => s.name !== name);
+            log.debug(`[${this.name}] Removed skill: ${name}`);
+          }
+          return removed;
+        },
+
+        /**
+         * 直接执行技能命令（通过 ext_call）
+         * @param {string} command 格式 `<skill>:<command>`，如 'my-skill:cmd1'
+         * @param {Object} [args] 参数对象
+         */
+        execute: async (command, args = {}) => {
+          if (!this._framework) {
+            throw new Error(`[${this.name}] skill.execute() called before plugin installed`);
+          }
+          if (!command || !command.includes(':')) {
+            throw new Error(`[${this.name}] skill.execute() requires '<skill>:<command>' format`);
+          }
+          const [skillName, ...rest] = command.split(':');
+          const cmdName = rest.join(':');
+          return await this._framework.executeTool('ext_call', {
+            plugin: `skill:${skillName}`,
+            tool: cmdName,
+            args: args || {},
+          });
+        },
+      };
+    }
+    return this._skillAccessor;
+  }
+
+  /**
+   * 插件启动钩子 - 子类可重写
+   * 注意：不需要调用 super.start(framework)，基类自动处理
+   */
+  onStart(framework) {
+    // 子类可重写此方法注册工具/扩展
+  }
+
   start(framework) {
+    this._framework = framework;
     this._autoRegisterSubAgents();
     this._autoRegisterPrompts();
+    this._reRegisterTools();
+    this._reRegisterExtensions();
+    this._reRegisterWorkflows();
+    this._reRegisterAgents();
+    this._reRegisterPrompts();
+    this._reRegisterSkills();
+    this.onStart(framework);
     return this;
   }
 
+  /**
+   * 重新注册所有通过 tool.register 注册的工具
+   */
+  _reRegisterTools() {
+    const registry = this._framework?.toolRegistry;
+    if (!registry) return;
+    for (const { name, def } of this._registeredTools) {
+      if (!registry.has(name)) {
+        registry.register(def);
+        log.debug(`[${this.name}] Re-registered tool: ${name}`);
+      }
+    }
+  }
+
+  /**
+   * 重新注册所有通过 extension.register 注册的扩展工具
+   */
+  _reRegisterExtensions() {
+    const extExec = this._framework?.pluginManager?.get('extension-executor');
+    if (!extExec) return;
+    for (const { extName, toolDef } of this._registeredExtensions) {
+      extExec.registerTool(
+        extName,
+        {
+          name: extName,
+          description: this.description,
+          version: this.version,
+        },
+        toolDef
+      );
+      log.debug(`[${this.name}] Re-registered extension tool: ${extName}/${toolDef.name}`);
+    }
+  }
+
+  /**
+   * 重新注册所有通过 workflow.register 注册的工作流
+   */
+  _reRegisterWorkflows() {
+    const workflowPlugin = this._framework?.pluginManager?.get('workflow');
+    if (!workflowPlugin) return;
+    for (const { name, def } of this._registeredWorkflows) {
+      workflowPlugin._workflows.set(name, def);
+      workflowPlugin._registerWorkflowTools();
+      log.debug(`[${this.name}] Re-registered workflow: ${name}`);
+    }
+  }
+
+  /**
+   * 重新注册所有通过 agent.register 注册的子代理
+   */
+  _reRegisterAgents() {
+    const subAgentManager = this._framework?.pluginManager?.get('subagent-manager');
+    if (!subAgentManager) return;
+    for (const { name, agent } of this._registeredAgents) {
+      subAgentManager.registerPlugin({
+        name,
+        agent,
+        role: agent.role || '',
+        goal: agent.goal || '',
+        tools: {},
+      });
+      log.debug(`[${this.name}] Re-registered agent: ${name}`);
+    }
+  }
+
+  /**
+   * 重新注册所有通过 prompt.register 注册的 prompt parts
+   */
+  _reRegisterPrompts() {
+    const reg = this._framework?.prompts;
+    if (!reg) return;
+    for (const { name, provider, options } of this._registeredPrompts) {
+      reg.register(this.name, name, provider, options);
+      log.debug(`[${this.name}] Re-registered prompt: ${name}`);
+    }
+  }
+
+  /**
+   * 重新注册所有通过 skill.register 注册的技能
+   */
+  _reRegisterSkills() {
+    const sm = this._framework?.pluginManager?.get('skill-manager');
+    if (!sm) return;
+    for (const { name, content, metadata, options } of this._registeredSkills) {
+      // 如果技能已经存在（可能未在 reload 中清理），先移除
+      if (sm.hasSkill(name)) {
+        sm.remove(name);
+      }
+      sm.register(name, content || '', metadata, options);
+      log.debug(`[${this.name}] Re-registered skill: ${name}`);
+    }
+  }
+
+  /**
+   * 插件停止钩子 - 子类可重写
+   * 注意：不需要调用 super.stop()，基类自动处理
+   */
+  onStop() {
+    // 子类可重写此方法进行清理
+  }
+
+  /**
+   * 停止插件（disable 时调用）
+   * 移除工具和扩展，但保留注册记录以便 re-enable 时重新注册
+   */
+  stop() {
+    // 移除 tool.register 注册的工具
+    for (const { name } of this._registeredTools) {
+      try {
+        this._framework?.toolRegistry?.unregister(name);
+        log.debug(`[${this.name}] Stopped tool: ${name}`);
+      } catch (err) {
+        // ignore
+      }
+    }
+    // 移除 extension.register 注册的扩展工具
+    for (const { extName, toolName } of this._registeredExtensions) {
+      try {
+        const extExec = this._framework?.pluginManager?.get('extension-executor');
+        if (extExec) {
+          extExec._unregisterTool(extName, toolName);
+          log.debug(`[${this.name}] Stopped extension tool: ${extName}/${toolName}`);
+        }
+      } catch (err) {
+        // ignore
+      }
+    }
+    // 移除 workflow.register 注册的工作流
+    for (const { name } of this._registeredWorkflows) {
+      try {
+        const workflowPlugin = this._framework?.pluginManager?.get('workflow');
+        if (workflowPlugin) {
+          workflowPlugin.remove(name);
+          log.debug(`[${this.name}] Stopped workflow: ${name}`);
+        }
+      } catch (err) {
+        // ignore
+      }
+    }
+    // 移除 agent.register 注册的子代理
+    for (const { name } of this._registeredAgents) {
+      try {
+        const subAgentManager = this._framework?.pluginManager?.get('subagent-manager');
+        if (subAgentManager) {
+          subAgentManager.unregisterPlugin(name);
+          log.debug(`[${this.name}] Stopped agent: ${name}`);
+        }
+      } catch (err) {
+        // ignore
+      }
+    }
+    // 移除 prompt.register 注册的 prompt parts
+    for (const { name } of this._registeredPrompts) {
+      try {
+        const reg = this._framework?.prompts;
+        if (reg) {
+          reg.clearOwner(this.name, name);
+          log.debug(`[${this.name}] Stopped prompt: ${name}`);
+        }
+      } catch (err) {
+        // ignore
+      }
+    }
+    // 移除 skill.register 注册的技能
+    for (const { name } of this._registeredSkills) {
+      try {
+        const sm = this._framework?.pluginManager?.get('skill-manager');
+        if (sm) {
+          sm.remove(name);
+          log.debug(`[${this.name}] Stopped skill: ${name}`);
+        }
+      } catch (err) {
+        // ignore
+      }
+    }
+    this.onStop();
+  }
+
   /**
    * 自动注册 this.prompts 声明的所有 part 到 framework.prompts
    * - 失败一个不影响其他
    * - 'this' 在 provider 中绑定到 plugin 实例（必须用普通 function，箭头函数的 this 是词法的）
+   *
+   * 支持两种声明方式：
+   *   1. provider 函数（原有方式）：
+   *      { name: 'xxx', provider() { return this._buildSomething(); } }
+   *
+   *   2. 文件方式（新增）：
+   *      { name: 'xxx', file: './PROMPT.md', vars: { key: 'value' } }
+   *      - file 相对于插件文件路径解析
+   *      - vars 支持静态对象或 () => object 动态函数
+   *      - {{varName}} 在渲染时被替换
    */
   _autoRegisterPrompts() {
     const reg = this._framework?.prompts;
@@ -91,14 +811,23 @@ class Plugin {
     if (!Array.isArray(this.prompts) || this.prompts.length === 0) return;
 
     for (const entry of this.prompts) {
-      if (!entry || !entry.name || typeof entry.provider !== 'function') {
-        log.warn(`[${this.name}] Invalid prompt entry: missing name or provider`);
+      if (!entry || !entry.name) {
+        log.warn(`[${this.name}] Invalid prompt entry: missing name`);
         continue;
       }
       try {
-        // bind 让 provider 中的 this 指向 plugin 实例
-        const boundProvider = entry.provider.bind(this);
-        reg.register(this.name, entry.name, boundProvider, {
+        let provider;
+        if (entry.file) {
+          // 文件方式：读取 PROMPT.md 并支持变量插值
+          provider = this._createFilePromptProvider(entry.file, entry.vars, entry.interpolate);
+        } else if (typeof entry.provider === 'function') {
+          // 函数方式
+          provider = entry.provider.bind(this);
+        } else {
+          log.warn(`[${this.name}] Prompt entry "${entry.name}" missing provider or file`);
+          continue;
+        }
+        reg.register(this.name, entry.name, provider, {
           scope: entry.scope,
           priority: entry.priority,
           description: entry.description,
@@ -109,6 +838,70 @@ class Plugin {
     }
   }
 
+  /**
+   * 创建文件 prompt provider
+   * @param {string} filePath 文件路径（绝对或相对）
+   * @param {Object|Function} vars 变量（静态或动态函数）
+   * @param {Function} interpolate 后处理函数，用于注入动态内容
+   */
+  _createFilePromptProvider(filePath, vars, interpolate) {
+    const fs = require('fs');
+    const path = require('path');
+
+    // 解析文件路径：相对路径基于插件文件目录，绝对路径直接用
+    let fullPath = filePath;
+    if (!path.isAbsolute(filePath)) {
+      // 使用栈追踪获取插件文件路径
+      // 栈结构: Error, _createFilePromptProvider, _autoRegisterPrompts, 子类start, plugin-manager调用start, ...
+      const stack = new Error().stack.split('\n');
+      let pluginFile;
+      for (let i = 3; i < stack.length; i++) { // 从索引3开始跳过 base.js 的方法
+        const line = stack[i];
+        // 排除 base.js 自身和 node: 内置模块
+        if (line.includes('plugin/base.js') || line.includes('node:')) continue;
+        // 提取文件路径 (filename:line:col) 或 (filename)
+        const match = line.match(/\((.*?):\d+:\d+\)/) || line.match(/at\s+(.*?):\d+:\d+/);
+        if (match && match[1] !== '[eval]') {
+          pluginFile = match[1];
+          break;
+        }
+      }
+      const pluginDir = pluginFile ? path.dirname(path.resolve(pluginFile)) : process.cwd();
+      fullPath = path.resolve(pluginDir, filePath);
+    }
+
+    // 缓存原始文件内容（只读一次）
+    if (!fs.existsSync(fullPath)) {
+      return () => { throw new Error(`Prompt file not found: ${fullPath}`); };
+    }
+    const rawContent = fs.readFileSync(fullPath, 'utf-8');
+
+    return () => {
+      let content = rawContent;
+
+      // 变量插值
+      if (vars) {
+        const varsObj = typeof vars === 'function' ? vars() : vars;
+        if (varsObj && typeof varsObj === 'object') {
+          content = content.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+            if (Object.prototype.hasOwnProperty.call(varsObj, varName)) {
+              const val = varsObj[varName];
+              return val == null ? match : String(val);
+            }
+            return match;
+          });
+        }
+      }
+
+      // 后处理：用于注入动态生成的列表（如 {{subagents}}, {{skills}} 等）
+      if (typeof interpolate === 'function') {
+        content = interpolate(content, this);
+      }
+
+      return content;
+    };
+  }
+
   /**
    * 清理当前 plugin 在 framework.prompts 中注册的所有 part
    */
@@ -206,7 +999,36 @@ class Plugin {
     this._cleanupPrompts();
     this._autoRegisterPrompts();
 
+    // 清理 tool.register 注册的工具（reload 后需重新注册）
+    for (const { name: toolName } of this._registeredTools) {
+      try {
+        framework.toolRegistry?.unregister(toolName);
+      } catch (err) {
+        // ignore
+      }
+    }
+    // 注：_registeredTools 保留，reload 后 framework 重新设置后仍可重新注册
+
+    // 清理 extension.register 注册的扩展工具
+    for (const { extName, toolName } of this._registeredExtensions) {
+      try {
+        const extExec = framework.pluginManager?.get('extension-executor');
+        if (extExec) {
+          extExec._unregisterTool(extName, toolName);
+        }
+      } catch (err) {
+        // ignore
+      }
+    }
+
     this._autoRegisterSubAgents();
+    this._reRegisterTools();
+    this._reRegisterExtensions();
+    this._reRegisterWorkflows();
+    this._reRegisterAgents();
+    this._reRegisterPrompts();
+    this._reRegisterSkills();
+    this.onStart(framework);
   }
 
   onCwdChanged(oldCwd, newCwd, framework) {
@@ -217,6 +1039,87 @@ class Plugin {
     // 清理 framework.prompts 中该插件注册的所有 part
     this._cleanupPrompts();
 
+    // 清理通过 tool.register 注册的工具
+    for (const { name: toolName } of this._registeredTools) {
+      try {
+        framework.toolRegistry?.unregister(toolName);
+        log.debug(`[${this.name}] Unregistered tool: ${toolName}`);
+      } catch (err) {
+        log.warn(`[${this.name}] Failed to unregister tool '${toolName}':`, err.message);
+      }
+    }
+    this._registeredTools = [];
+
+    // 清理通过 extension.register 注册的扩展工具
+    for (const { extName, toolName } of this._registeredExtensions) {
+      try {
+        const extExec = framework.pluginManager?.get('extension-executor');
+        if (extExec) {
+          extExec._unregisterTool(extName, toolName);
+          log.debug(`[${this.name}] Unregistered extension tool: ${extName}/${toolName}`);
+        }
+      } catch (err) {
+        log.warn(`[${this.name}] Failed to unregister extension tool '${extName}/${toolName}':`, err.message);
+      }
+    }
+    this._registeredExtensions = [];
+
+    // 清理通过 workflow.register 注册的工作流
+    for (const { name } of this._registeredWorkflows) {
+      try {
+        const workflowPlugin = framework.pluginManager?.get('workflow');
+        if (workflowPlugin) {
+          workflowPlugin.remove(name);
+          log.debug(`[${this.name}] Unregistered workflow: ${name}`);
+        }
+      } catch (err) {
+        log.warn(`[${this.name}] Failed to unregister workflow '${name}':`, err.message);
+      }
+    }
+    this._registeredWorkflows = [];
+
+    // 清理通过 agent.register 注册的子代理
+    for (const { name } of this._registeredAgents) {
+      try {
+        const subAgentManager = framework.pluginManager?.get('subagent-manager');
+        if (subAgentManager) {
+          subAgentManager.unregisterPlugin(name);
+          log.debug(`[${this.name}] Unregistered agent: ${name}`);
+        }
+      } catch (err) {
+        log.warn(`[${this.name}] Failed to unregister agent '${name}':`, err.message);
+      }
+    }
+    this._registeredAgents = [];
+
+    // 清理通过 prompt.register 注册的 prompt parts
+    for (const { name } of this._registeredPrompts) {
+      try {
+        const reg = framework.prompts;
+        if (reg) {
+          reg.clearOwner(this.name, name);
+          log.debug(`[${this.name}] Unregistered prompt: ${name}`);
+        }
+      } catch (err) {
+        log.warn(`[${this.name}] Failed to unregister prompt '${name}':`, err.message);
+      }
+    }
+    this._registeredPrompts = [];
+
+    // 清理通过 skill.register 注册的技能
+    for (const { name } of this._registeredSkills) {
+      try {
+        const sm = framework.pluginManager?.get('skill-manager');
+        if (sm) {
+          sm.remove(name);
+          log.debug(`[${this.name}] Unregistered skill: ${name}`);
+        }
+      } catch (err) {
+        log.warn(`[${this.name}] Failed to unregister skill '${name}':`, err.message);
+      }
+    }
+    this._registeredSkills = [];
+
     for (const plugin of this._subAgents) {
       try {
         plugin.uninstall(framework);