foliko 1.1.6 → 1.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "type": "commonjs",
@@ -54,7 +54,7 @@
     "@ai-sdk/openai-compatible": "^2.0.35",
     "@anthropic-ai/sdk": "^0.39.0",
     "@chnak/weixin-bot": "^1.2.7",
-    "@chnak/zod-to-markdown": "1.0.3",
+    "@chnak/zod-to-markdown": "1.0.6",
     "@hono/node-server": "^1.19.11",
     "@larksuiteoapi/node-sdk": "^1.59.0",
     "@modelcontextprotocol/sdk": "^1.27.1",

package/plugins/ambient-agent/EventWatcher.js

@@ -20,14 +20,26 @@ class EventWatcher {
    */
   start() {
     const events = [
+      // 工具事件
+      ['tool:call', (data) => this._handleEvent('tool:call', data)],
       ['tool:result', (data) => this._handleEvent('tool:result', data)],
+      ['tool:error', (data) => this._handleEvent('tool:error', data)],
+      // Scheduler 事件
+      ['scheduler:task_created', (data) => this._handleEvent('scheduler:task_created', data)],
       ['scheduler:reminder', (data) => this._handleEvent('scheduler:reminder', data)],
-      ['agent:message', (data) => this._handleEvent('agent:message', data)],
-      ['think:thought_completed', (data) => this._handleEvent('think:thought_completed', data)],
       ['scheduler:task_completed', (data) => this._handleEvent('scheduler:task_completed', data)],
       ['scheduler:task_failed', (data) => this._handleEvent('scheduler:task_failed', data)],
+      // Agent/Think 事件
+      ['agent:message', (data) => this._handleEvent('agent:message', data)],
+      ['think:thought_completed', (data) => this._handleEvent('think:thought_completed', data)],
+      // Email/Webhook 事件
       ['email:received', (data) => this._handleEvent('email:received', data)],
-      ['webhook:received', (data) => this._handleEvent('webhook:received', data)]
+      ['webhook:received', (data) => this._handleEvent('webhook:received', data)],
+      ['webhook:processed', (data) => this._handleEvent('webhook:processed', data)],
+      // Worker/Subagent 事件
+      ['worker:completed', (data) => this._handleEvent('worker:completed', data)],
+      ['worker:error', (data) => this._handleEvent('worker:error', data)],
+      ['subagent:chat:end', (data) => this._handleEvent('subagent:chat:end', data)]
     ]
 
     for (const [event, handler] of events) {
@@ -53,58 +65,42 @@ class EventWatcher {
    */
   _handleEvent(type, data) {
     const activeGoals = this._goalManager.getActiveGoals()
-    // log.info(`_handleEvent: type=${type}, activeGoals=${activeGoals.length}`)
 
     for (const goal of activeGoals) {
-      // 检查目标条件是否匹配此事件
-      const isRelevant = this._isRelevantToGoal(goal, type, data)
-      // log.info(`goal=${goal.id}, isRelevant=${isRelevant}, conditions=${JSON.stringify(goal.conditions)}`)
-
-      if (isRelevant) {
-        // 将 data 展平到事件对象中，方便通过 {{_event.xxx}} 访问
-        this._goalManager.addEventToGoal(goal.id, { type, ...data })
-        // log.info(`Event added to goal ${goal.id}`)
+      if (this._isRelevantToGoal(goal, type, data)) {
+        // 直接传入原样数据
+        this._goalManager.addEventToGoal(goal.id, { eventType: type, data })
       }
     }
 
-    // 检查是否有 pending 目标需要激活
     const pendingGoals = this._goalManager.getPendingGoals()
     for (const goal of pendingGoals) {
       if (this._isRelevantToGoal(goal, type, data)) {
-        // 激活目标
         this._goalManager.activateGoal(goal.id)
-        // 添加事件
-        this._goalManager.addEventToGoal(goal.id, { type, ...data })
-        // log.info(`事件触发激活目标: ${goal.id} (事件: ${type})`)
+        this._goalManager.addEventToGoal(goal.id, { eventType: type, data })
       }
     }
   }
 
   /**
    * 检查事件是否与目标相关
-   * @param {Object} goal - 目标对象
-   * @param {string} eventType - 事件类型
-   * @param {Object} data - 事件数据
-   * @returns {boolean} 是否相关
    */
   _isRelevantToGoal(goal, eventType, data) {
-    // 检查条件中是否有明确的事件类型
-    if (goal.conditions && goal.conditions.events) {
-      const allowedEvents = Array.isArray(goal.conditions.events)
-        ? goal.conditions.events
-        : [goal.conditions.events]
-      if (!allowedEvents.includes(eventType)) {
-        return false
-      }
+    // 检查事件类型
+    if (goal.conditions?.events) {
+      const allowed = Array.isArray(goal.conditions.events) ? goal.conditions.events : [goal.conditions.events]
+      if (!allowed.includes(eventType)) return false
     }
-    // 检查工具名称过滤器
-    if (goal.conditions && goal.conditions.toolNames) {
-      const toolNames = Array.isArray(goal.conditions.toolNames)
-        ? goal.conditions.toolNames
-        : [goal.conditions.toolNames]
-      if (data && data.toolName && !toolNames.includes(data.toolName)) {
-        return false
-      }
+    // 检查工具名称
+    if (goal.conditions?.toolNames) {
+      const toolNames = Array.isArray(goal.conditions.toolNames) ? goal.conditions.toolNames : [goal.conditions.toolNames]
+      const eventName = data?.toolName || data?.name
+      if (!eventName) return true
+      // 统一下划线和冒号格式进行匹配
+      const normalize = (n) => n?.replace(/_/g, ':')
+      const normName = normalize(eventName)
+      const isMatch = toolNames.some(tn => normalize(tn) === normName || tn === eventName)
+      if (!isMatch) return false
     }
     return true
   }

package/plugins/ambient-agent/ExplorerLoop.js

@@ -176,10 +176,14 @@ class ExplorerLoop {
 
   async _processGoals() {
     const activeGoals = this._goalManager.getActiveGoals()
+    //log.info(`[ExplorerLoop] _processGoals: ${activeGoals.length} 个活跃目标, _lastActionTime=${this._lastActionTime}, cooldown=${this._config.cooldownPeriod}`)
 
     for (const goal of activeGoals) {
       // 检查冷却时间
-      if (Date.now() - this._lastActionTime < this._config.cooldownPeriod) {
+      const timeSinceLastAction = Date.now() - this._lastActionTime
+      //log.info(`[ExplorerLoop] 检查 goal=${goal.id}, timeSinceLastAction=${timeSinceLastAction}`)
+      if (timeSinceLastAction < this._config.cooldownPeriod) {
+        //log.info(`[ExplorerLoop] 跳过 goal=${goal.id}, 还在冷却中`)
         continue
       }
 
@@ -191,15 +195,28 @@ class ExplorerLoop {
 
       // 事件驱动目标：只有在新事件时才执行 actions
       if (isEventDriven && !hasNewEvents) {
+        //log.info(`[ExplorerLoop] 跳过 goal=${goal.id}, 事件驱动但无新事件`)
         continue
       }
 
-      // 获取下一个操作
+      log.info(`[ExplorerLoop] 开始执行 goal=${goal.id}, hasNewEvents=${hasNewEvents}, actions=${goal.actions?.length}`)
+
+      // 获取下一个操作（跳过已完成的 actions）
       if (goal.actions && goal.actions.length > 0) {
+        // 过滤掉已完成的 actions
+        const pendingActions = goal.actions.filter(a => !a.completed)
+        if (pendingActions.length === 0) {
+          log.info(`[ExplorerLoop] goal=${goal.id} 所有 actions 已完成，等待下一事件`)
+          this._resetGoalForNextEvent(goal)
+          continue
+        }
+
         // 如果有多个 action，按顺序执行所有 action
         if (goal.actions.length > 1) {
           const eventData = hasNewEvents ? goal.eventsReceived[0] : null
+          log.info(`[ExplorerLoop] 执行 ${goal.actions.length} 个 actions, eventData=${JSON.stringify(eventData?.data?.subject || 'none')}`)
           const results = await this._executeAllActions(goal.actions, eventData)
+          log.info(`[ExplorerLoop] actions 执行完成, results.length=${results.length}`)
 
           // 最后一个结果用于评估
           const lastResult = results.length > 0 ? results[results.length - 1].result : null
@@ -220,17 +237,39 @@ class ExplorerLoop {
           } else {
             // 事件驱动目标：不论结果如何，都重置并继续等待下一事件
             this._addActivity('actions_completed', { goalId: goal.id, actionCount: results.length })
-          }
 
-          // 执行操作后清除已处理的事件，并重置 actions 以处理下一事件
-          if (hasNewEvents) {
-            this._resetGoalForNextEvent(goal)
+            // 检查所有 actions 是否都已完成
+            const allDone = goal.actions.every(a => a.completed)
+            if (allDone && !goal.persistent) {
+              // 一次性目标：所有 actions 完成后直接完成
+              this._goalManager.completeGoal(goal.id)
+              this._addActivity('goal_completed', { goalId: goal.id, reason: '一次性任务执行完成' })
+              this._notifyUser('目标完成', `目标 "${goal.title}" 已完成`, 'success')
+            } else if (hasNewEvents) {
+              // 持久化目标且有新事件，重置 actions
+              this._resetGoalForNextEvent(goal)
+            }
           }
           continue
         }
 
         // 单个 action，使用原有逻辑
-        const action = goal.actions[0]
+        const action = goal.actions.find(a => !a.completed)
+        if (!action) {
+          // 所有 actions 已完成
+          log.info(`[ExplorerLoop] goal=${goal.id} 所有 actions 已完成`)
+          const allDone = goal.actions.every(a => a.completed)
+          if (allDone && !goal.persistent) {
+            // 一次性目标：所有 actions 完成后直接完成
+            this._goalManager.completeGoal(goal.id)
+            this._addActivity('goal_completed', { goalId: goal.id, reason: '一次性任务执行完成' })
+            this._notifyUser('目标完成', `目标 "${goal.title}" 已完成`, 'success')
+          } else {
+            // 持久化目标：等待下一事件
+            this._resetGoalForNextEvent(goal)
+          }
+          continue
+        }
 
         // 循环检测（仅用于非事件驱动的操作）
         if (!hasNewEvents && this._reflector.checkLoopDetection(goal, action.id)) {
@@ -243,6 +282,9 @@ class ExplorerLoop {
         // 执行操作
         const result = await this._executeAction(action, hasNewEvents ? goal.eventsReceived[0] : null)
 
+        // 标记 action 为已完成
+        action.completed = true
+
         // 评估结果
         const outcome = this._reflector.evaluateOutcome(goal, result)
 
@@ -256,17 +298,20 @@ class ExplorerLoop {
           this._addActivity('goal_failed', { goalId: goal.id, reason: '达到最大尝试次数' })
           // 通知用户目标失败
           this._notifyUser('目标失败', `目标 "${goal.title}" 失败：达到最大尝试次数`, 'error')
-        } else if (outcome.actionTaken) {
-          // 从队列中移除已完成的操作
-          if (!hasNewEvents) {
-            goal.actions.shift()
-          }
+        } else {
           this._addActivity('action_executed', { goalId: goal.id, action: action.id, hasEvents: hasNewEvents })
-        }
 
-        // 执行操作后清除已处理的事件，并重置 actions 以处理下一事件
-        if (hasNewEvents) {
-          this._resetGoalForNextEvent(goal)
+          // 检查所有 actions 是否都已完成
+          const allDone = goal.actions.every(a => a.completed)
+          if (allDone && !goal.persistent) {
+            // 一次性目标：所有 actions 完成后直接完成
+            this._goalManager.completeGoal(goal.id)
+            this._addActivity('goal_completed', { goalId: goal.id, reason: '一次性任务执行完成' })
+            this._notifyUser('目标完成', `目标 "${goal.title}" 已完成`, 'success')
+          } else if (hasNewEvents) {
+            // 持久化目标且有新事件，重置 actions
+            this._resetGoalForNextEvent(goal)
+          }
         }
       }
     }
@@ -288,15 +333,15 @@ class ExplorerLoop {
   }
 
   /**
-   * 重置目标以处理下一事件
+   * 重置目标以处理下一事件（仅用于持久化目标）
    */
   _resetGoalForNextEvent(goal) {
     goal.eventsReceived = []
-    // 重置 actions 为原始 actions，以便处理下一事件
-    if (goal._originalActions) {
-      goal.actions = goal._originalActions.slice()
+    // 重置所有 actions 的完成标记
+    for (const action of goal.actions) {
+      action.completed = false
     }
-    this._goalManager.updateGoal(goal.id, { eventsReceived: [], actions: goal.actions })
+    this._goalManager.updateGoal(goal.id, { eventsReceived: [] })
   }
 
   // ============================================================================
@@ -335,6 +380,18 @@ class ExplorerLoop {
       // 将 action 转换为 step 配置
       const step = this._actionToStep(action)
 
+      // 将 _event 注入到 step.args 中，供工具使用
+      // 统一使用 eventData.data 作为事件数据源
+      const effectiveEventData = eventData || context?.variables?._eventRaw
+      if (effectiveEventData) {
+        step.args = step.args || {}
+        // 从 eventData.data 中提取邮件对象（email 事件的数据在 data.email 中）
+        const eventObj = effectiveEventData?.data?.email || effectiveEventData?.data || effectiveEventData
+        // 统一注入到 _event，让 ${event.xxx} 可以直接访问
+        step.args._event = eventObj
+        step.args._eventRaw = effectiveEventData
+      }
+
       // 解析 step.args 中的变量引用（支持 ${actionId.output} 格式）
       if (step.args) {
         step.args = this._resolveActionArgs(step.args, context)
@@ -348,7 +405,21 @@ class ExplorerLoop {
         return await this._executeWithAmbientAgent(step, context)
       }
 
-      // 其他类型使用 StepExecutor 直接执行
+      // 工具类型
+      if (step.type === 'tool') {
+        if (step.tool) {
+          // 工具已指定，通过 ext_call 执行（plugin 可选）
+          const extResult = await this._executeViaExtCall(step.tool, step.args || {}, step.plugin)
+          if (extResult && (extResult.success !== false || !extResult.error?.includes('not found'))) {
+            return extResult
+          }
+          log.info(`[ExplorerLoop] ext_call 回退到 StepExecutor: ${step.tool}`)
+        } else {
+          // 工具未指定，让 LLM 选择工具
+          return await this._executeWithAmbientAgent(step, context)
+        }
+      }
+
       const result = await this._stepExecutor.executeStep(step, context)
       return result
     } catch (err) {
@@ -387,24 +458,23 @@ class ExplorerLoop {
         if (path.startsWith('event.')) {
           // ${event.xxx} 引用事件数据
           let eventPath = path.replace(/^event\./, '')
-          // 优先在 eventData.data 中查找（因为事件数据通常存储在 data 字段）
+          // 直接在 eventData 中查找（最常见的情况）
+          let val = this._getNestedValue(eventData, eventPath)
+          if (val !== undefined) return val
+          // 兼容：如果 eventData.data 存在，尝试从中查找
           if (eventData?.data) {
-            let val = this._getNestedValue(eventData.data, eventPath)
+            val = this._getNestedValue(eventData.data, eventPath)
             if (val !== undefined) return val
           }
-          // 再尝试直接在 eventData 中查找
-          let val = this._getNestedValue(eventData, eventPath)
-          if (val !== undefined) return val
-          // 兼容：如果 path 是 event.data.xxx 但 eventData 没有 data，尝试跳过一层
-          if (eventPath.startsWith('data.')) {
-            eventPath = eventPath.replace(/^data\./, '')
-            val = this._getNestedValue(eventData, eventPath)
+          // 兼容：如果 eventData.email 存在（邮件事件，字段直接在 email 对象下），查找 eventData.email
+          if (eventData?.email) {
+            val = this._getNestedValue(eventData.email, eventPath)
             if (val !== undefined) return val
           }
-          // 特殊回退：如果查找 body 但找不到，尝试 text（邮件数据中用 text）
-          if (eventPath === 'body' || eventPath === 'text') {
-            const textVal = this._getNestedValue(eventData?.data, 'text')
-            if (textVal !== undefined) return textVal
+          // 兼容：如果 eventData.data.email 存在（嵌套的邮件事件），直接在 email 对象中查找
+          if (eventData?.data?.email) {
+            val = this._getNestedValue(eventData.data.email, eventPath)
+            if (val !== undefined) return val
           }
           return match
         }
@@ -477,11 +547,19 @@ class ExplorerLoop {
     }
 
     for (const action of actions) {
+      // 跳过已完成的 action
+      if (action.completed) {
+        continue
+      }
+
       // 执行前更新 stepOutputs
       context.variables._stepOutputs = stepOutputs
 
       const result = await this._executeAction(action, eventData, context)
 
+      // 标记 action 为已完成
+      action.completed = true
+
       // 保存结果：使用 action id 作为键
       if (action.id) {
         stepOutputs[action.id] = result
@@ -501,6 +579,18 @@ class ExplorerLoop {
     return results
   }
 
+  /**
+   * 获取所有扩展工具的描述（供 LLM 选择）
+   */
+  _getExtensionsDescription() {
+    const extExec = this._framework.pluginManager?.get('extension-executor')
+    if (!extExec || !extExec._buildExtensionsDescription) {
+      return '无可用的扩展工具'
+    }
+    const desc = extExec._buildExtensionsDescription()
+    return desc || '无可用的扩展工具'
+  }
+
   /**
    * 使用 ambient 子 agent 执行 AI 相关操作
    */
@@ -550,6 +640,94 @@ class ExplorerLoop {
       }
     }
 
+    if (step.type === 'tool') {
+      // 如果工具已指定，直接执行
+      if (step.tool) {
+        return await this._executeViaExtCall(step.tool, step.args || {})
+      }
+
+      // 工具未指定，让 LLM 根据上下文选择
+      const eventData = context.variables._event
+      let eventContextStr = '无事件上下文'
+      if (eventData) {
+        eventContextStr = `**事件数据结构（从 event.xxx 引用任何字段）**:\n\`\`\`json\n${JSON.stringify(eventData, null, 2)}\n\`\`\``
+      }
+
+      // 上一步的输出结果（可用于引用）
+      const lastResult = context.variables._stepOutputs?._lastResult
+      let lastResultStr = ''
+      if (lastResult) {
+        lastResultStr = `**上一步结果（从 result.xxx 引用任何字段）**:\n\`\`\`json\n${JSON.stringify(lastResult, null, 2)}\n\`\`\``
+      }
+
+      const extensionsInfo = this._getExtensionsDescription()
+
+      const prompt = `你是 Ambient Agent，需要为以下目标选择一个合适的工具来执行。
+
+**目标**: ${step.name || '根据事件自动决定执行什么操作'}
+
+${eventContextStr}
+
+${lastResultStr}
+
+## 可用的扩展工具及其参数要求：
+${extensionsInfo}
+
+## 如何决定参数传递：
+1. 查看上方的**事件数据结构**，找到需要的字段
+2. 查看工具的**参数要求**（parameters 或 properties 下列出的字段）
+3. 根据字段名称和含义，判断应该传递什么值
+4. 使用 \${event.xxx} 或 \${result.xxx} 引用对应字段
+
+**示例**：
+如果事件中有 \`from: "user@example.com"\`，而工具需要 \`to\` 参数，
+则传递 \`"to": "\${event.from}"\`
+
+**返回格式**：
+\`\`\`json
+{
+  "plugin": "插件名",
+  "tool": "工具名",
+  "args": {
+    "参数名": "\${event.字段名}"
+  }
+}
+\`\`\`
+
+如果不需要执行任何工具，返回：\`\`\`json
+{"plugin": null, "tool": null, "args": {}}
+\`\`\`
+
+请直接返回 JSON 代码块。`
+
+      try {
+        const response = await this._ambientAgent.pushMessage(prompt)
+        const responseText = typeof response === 'string' ? response : JSON.stringify(response)
+
+        // 尝试解析 LLM 返回的 JSON
+        let toolChoice = null
+        try {
+          // 提取 JSON（可能在 markdown 代码块中）
+          const jsonMatch = responseText.match(/```json\n?([\s\S]*?)\n?```/) || responseText.match(/(\{[\s\S]*\})/)
+          if (jsonMatch) {
+            toolChoice = JSON.parse(jsonMatch[1])
+          }
+        } catch (e) {
+          log.warn(`[ExplorerLoop] 解析 LLM 工具选择失败: ${e.message}`)
+          return { success: false, error: `LLM 返回格式错误: ${responseText.slice(0, 200)}` }
+        }
+
+        if (toolChoice && toolChoice.tool) {
+          log.info(`[ExplorerLoop] LLM 选择工具: plugin=${toolChoice.plugin}, tool=${toolChoice.tool}, args=${JSON.stringify(toolChoice.args)}`)
+          return await this._executeViaExtCall(toolChoice.tool, toolChoice.args || {}, toolChoice.plugin)
+        } else {
+          return { success: true, message: 'LLM 选择不执行任何工具', response: responseText }
+        }
+      } catch (err) {
+        return { success: false, error: err.message }
+      }
+    }
+
     return { success: false, error: `未知 AI 操作类型: ${step.type}` }
   }
 
@@ -560,7 +738,8 @@ class ExplorerLoop {
     const step = {
       id: action.id || `action_${Date.now()}`,
       type: action.type,
-      name: action.name || action.id
+      name: action.name || action.id,
+      plugin: action.plugin  // 插件名称（如 email, gate-trading）
     }
 
     switch (action.type) {
@@ -585,6 +764,129 @@ class ExplorerLoop {
   // 辅助方法
   // ============================================================================
 
+  /**
+   * 通过 ext_call 执行插件工具
+   * 支持所有通过 extension-executor 注册的工具：email, mcp, python, extension 等
+   * @param {string} toolName - 工具名称（如 email_auto_reply, mcp_github_search）
+   * @param {Object} args - 工具参数
+   * @param {string} [plugin] - 插件名称（如指定则直接使用，否则从 toolName 推断）
+   * @returns {Promise<Object>} 执行结果
+   */
+  async _executeViaExtCall(toolName, args, plugin) {
+    // 尝试多种可能的插件前缀
+    const pluginPrefixes = [
+      ['email_', 'email'],
+      ['scheduler_', 'scheduler'],
+      ['memory_', 'memory'],
+      ['web_', 'web'],
+      ['shell_', 'shell'],
+      ['python_', 'python'],
+      ['think_', 'think'],
+      ['mcp_', 'mcp'],
+      ['ext_', 'extension'],
+    ]
+
+    // 如果指定了 plugin，直接使用
+    if (plugin) {
+      log.info(`[ExplorerLoop] 通过 ext_call 执行: plugin=${plugin}, tool=${toolName}`)
+      try {
+        const result = await this._framework.executeTool('ext_call', {
+          plugin,
+          tool: toolName,
+          args
+        })
+        return result
+      } catch (err) {
+        log.warn(`[ExplorerLoop] ext_call 错误: ${err.message}`)
+        return { success: false, error: err.message }
+      }
+    }
+
+    // 先尝试从工具名推断的插件
+    const inferredPlugin = this._inferPluginName(toolName)
+    log.info(`[ExplorerLoop] 通过 ext_call 执行: plugin=${inferredPlugin}, tool=${toolName}`)
+
+    try {
+      const result = await this._framework.executeTool('ext_call', {
+        plugin: inferredPlugin,
+        tool: toolName,
+        args
+      })
+      return result
+    } catch (err) {
+      // 如果错误不是 "not found"，返回错误
+      if (!err.message.includes("not found") && !err.message.includes("不存在")) {
+        log.warn(`[ExplorerLoop] ext_call 错误: ${err.message}`)
+        return { success: false, error: err.message }
+      }
+      // 否则尝试其他可能的插件
+    }
+
+    // 尝试其他可能的插件前缀
+    for (const [prefix, extPlugin] of pluginPrefixes) {
+      if (toolName.startsWith(prefix) && extPlugin !== inferredPlugin) {
+        try {
+          const result = await this._framework.executeTool('ext_call', {
+            plugin: extPlugin,
+            tool: toolName,
+            args
+          })
+          log.info(`[ExplorerLoop] ext_call 成功: plugin=${extPlugin}, tool=${toolName}`)
+          return result
+        } catch (err) {
+          continue
+        }
+      }
+    }
+
+    // 尝试不带前缀的工具名（某些扩展可能用其他命名）
+    const shortName = toolName.replace(/^[a-z]+_/, '')
+    for (const [prefix, plugin] of pluginPrefixes) {
+      try {
+        const result = await this._framework.executeTool('ext_call', {
+          plugin,
+          tool: shortName,
+          args
+        })
+        log.info(`[ExplorerLoop] ext_call 成功（短名）: plugin=${plugin}, tool=${shortName}`)
+        return result
+      } catch (err) {
+        continue
+      }
+    }
+
+    return { success: false, error: `工具 ${toolName} 未找到` }
+  }
+
+  /**
+   * 从工具名称推断插件名称
+   * @param {string} toolName - 工具名称
+   * @returns {string} 插件名称
+   */
+  _inferPluginName(toolName) {
+    // 常见插件工具前缀映射
+    const pluginPrefixes = {
+      email_: 'email',
+      scheduler_: 'scheduler',
+      memory_: 'memory',
+      web_: 'web',
+      shell_: 'shell',
+      python_: 'python',
+      think_: 'think',
+      mcp_: 'mcp',
+      ext_: 'extension',
+    }
+
+    for (const [prefix, plugin] of Object.entries(pluginPrefixes)) {
+      if (toolName.startsWith(prefix)) {
+        return plugin
+      }
+    }
+
+    // 默认返回 'extension'（extension-executor 默认命名空间）
+    return 'extension'
+  }
+
   _getActiveAgent() {
     if (this._framework._mainAgent) {
       return this._framework._mainAgent

package/plugins/ambient-agent/GoalManager.js

@@ -33,7 +33,11 @@ class GoalManager {
    * @returns {Object} 创建的目标
    */
   createGoal(goalData) {
-    const actions = goalData.actions || []
+    const actions = (goalData.actions || []).map((action, index) => ({
+      ...action,
+      completed: false,
+      order: index
+    }))
     const goal = {
       id: generateId(),
       title: goalData.title || '未命名目标',
@@ -41,8 +45,8 @@ class GoalManager {
       priority: goalData.priority || 5,
       state: GoalState.PENDING,
       actions: actions,
-      _originalActions: actions.slice(),  // 保存原始 actions，用于事件驱动目标重置
       conditions: goalData.conditions || {},
+      persistent: goalData.persistent !== false,  // 默认 true，false 为一次性
       createdAt: new Date(),
       updatedAt: new Date(),
       activatedAt: null,
@@ -187,7 +191,7 @@ class GoalManager {
     // 需要提取 type 和 data（email 对象）
     goal.eventsReceived.push({
       event: event.type,
-      data: event.data || event.email || event,
+      data: event.data || event,
       timestamp: new Date()
     })
     this._persist()