foliko 1.0.74 → 1.0.76

package/plugins/ambient-agent-plugin.js

@@ -1,1565 +0,0 @@
-/**
- * Ambient Agent 插件
- * 持续后台运行的智能代理，监控事件并主动执行操作
- */
-
-const { Plugin } = require('../src/core/plugin-base')
-const { StepExecutor } = require('../src/capabilities/workflow-engine')
-const { Agent } = require('../src/core/agent')
-const { z } = require('zod')
-const fs = require('fs')
-const path = require('path')
-
-// 目标生命周期状态
-const GoalState = {
-  PENDING: 'pending',      // 待激活
-  ACTIVE: 'active',        // 执行中
-  COMPLETED: 'completed',  // 已完成
-  FAILED: 'failed'         // 已失败
-}
-
-// 生成唯一ID
-function generateId() {
-  if (require('crypto').randomUUID) {
-    return require('crypto').randomUUID()
-  }
-  return `goal_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-}
-
-// ============================================================================
-// StateStore - 持久化目标和记忆到 .agent/data/ambient/*.json
-// ============================================================================
-class StateStore {
-  constructor(persistencePath) {
-    this._persistencePath = persistencePath
-    this._ensureDir()
-  }
-
-  _ensureDir() {
-    if (!fs.existsSync(this._persistencePath)) {
-      fs.mkdirSync(this._persistencePath, { recursive: true })
-    }
-  }
-
-  _getGoalsPath() {
-    return path.join(this._persistencePath, 'goals.json')
-  }
-
-  _getMemoriesPath() {
-    return path.join(this._persistencePath, 'memories.json')
-  }
-
-  saveGoals(goals) {
-    try {
-      fs.writeFileSync(this._getGoalsPath(), JSON.stringify(goals, null, 2))
-    } catch (err) {
-      console.error('[Ambient] 保存目标失败:', err.message)
-    }
-  }
-
-  loadGoals() {
-    try {
-      const filePath = this._getGoalsPath()
-      if (fs.existsSync(filePath)) {
-        const data = fs.readFileSync(filePath, 'utf-8')
-        return JSON.parse(data)
-      }
-    } catch (err) {
-      console.error('[Ambient] 加载目标失败:', err.message)
-    }
-    return []
-  }
-
-  saveMemories(memories) {
-    try {
-      fs.writeFileSync(this._getMemoriesPath(), JSON.stringify(memories, null, 2))
-    } catch (err) {
-      console.error('[Ambient] 保存记忆失败:', err.message)
-    }
-  }
-
-  loadMemories() {
-    try {
-      const filePath = this._getMemoriesPath()
-      if (fs.existsSync(filePath)) {
-        const data = fs.readFileSync(filePath, 'utf-8')
-        return JSON.parse(data)
-      }
-    } catch (err) {
-      console.error('[Ambient] 加载记忆失败:', err.message)
-    }
-    return []
-  }
-}
-
-// ============================================================================
-// GoalManager - 管理目标及其生命周期状态
-// ============================================================================
-class GoalManager {
-  constructor(stateStore) {
-    this._goals = new Map()
-    this._stateStore = stateStore
-    this._loadGoals()
-  }
-
-  _loadGoals() {
-    const savedGoals = this._stateStore.loadGoals()
-    for (const goal of savedGoals) {
-      this._goals.set(goal.id, goal)
-    }
-  }
-
-  _persist() {
-    const goalsArray = Array.from(this._goals.values())
-    this._stateStore.saveGoals(goalsArray)
-  }
-
-  createGoal(goalData) {
-    const actions = goalData.actions || []
-    const goal = {
-      id: generateId(),
-      title: goalData.title || '未命名目标',
-      description: goalData.description || '',
-      priority: goalData.priority || 5,
-      state: GoalState.PENDING,
-      actions: actions,
-      _originalActions: actions.slice(),  // 保存原始 actions，用于事件驱动目标重置
-      conditions: goalData.conditions || {},
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      activatedAt: null,
-      completedAt: null,
-      failedAt: null,
-      attempts: 0,
-      maxAttempts: goalData.maxAttempts || 10,
-      consecutiveSameActions: 0,
-      lastActionId: null,
-      eventsReceived: []
-    }
-    this._goals.set(goal.id, goal)
-    this._persist()
-    return goal
-  }
-
-  getGoal(id) {
-    return this._goals.get(id)
-  }
-
-  getAllGoals() {
-    return Array.from(this._goals.values())
-  }
-
-  getActiveGoals() {
-    return Array.from(this._goals.values()).filter(g => g.state === GoalState.ACTIVE)
-  }
-
-  getPendingGoals() {
-    return Array.from(this._goals.values()).filter(g => g.state === GoalState.PENDING)
-  }
-
-  updateGoal(id, updates) {
-    const goal = this._goals.get(id)
-    if (!goal) return null
-    Object.assign(goal, updates, { updatedAt: new Date() })
-    this._persist()
-    return goal
-  }
-
-  activateGoal(id) {
-    const goal = this._goals.get(id)
-    if (!goal || goal.state !== GoalState.PENDING) return null
-    goal.state = GoalState.ACTIVE
-    goal.activatedAt = new Date()
-    goal.updatedAt = new Date()
-    this._persist()
-    return goal
-  }
-
-  completeGoal(id) {
-    const goal = this._goals.get(id)
-    if (!goal) return null
-    goal.state = GoalState.COMPLETED
-    goal.completedAt = new Date()
-    goal.updatedAt = new Date()
-    this._persist()
-    return goal
-  }
-
-  failGoal(id, reason) {
-    const goal = this._goals.get(id)
-    if (!goal) return null
-    goal.state = GoalState.FAILED
-    goal.failedAt = new Date()
-    goal.failureReason = reason
-    goal.updatedAt = new Date()
-    this._persist()
-    return goal
-  }
-
-  deleteGoal(id) {
-    const deleted = this._goals.delete(id)
-    if (deleted) this._persist()
-    return deleted
-  }
-
-  addEventToGoal(goalId, event) {
-    const goal = this._goals.get(goalId)
-    if (!goal) return
-
-    // 通用去重：如果最近 2 秒内已有相同类型的事件，跳过
-    const now = Date.now()
-    const recentSameEvent = goal.eventsReceived.find(e =>
-      e.event === event.type && (now - new Date(e.timestamp).getTime()) < 2000
-    )
-    if (recentSameEvent) {
-      console.log(`[Ambient] 跳过重复事件: ${event.type} (2秒内不重复添加)`)
-      return
-    }
-
-    // event 格式: { type: 'email:received', email: {...}, timestamp: ... }
-    // 需要提取 type 和 data（email 对象）
-    goal.eventsReceived.push({
-      event: event.type,
-      data: event.data || event.email || event,
-      timestamp: new Date()
-    })
-    this._persist()
-  }
-}
-
-// ============================================================================
-// EventWatcher - 订阅框架事件，筛选相关事件
-// ============================================================================
-class EventWatcher {
-  constructor(goalManager, framework) {
-    this._goalManager = goalManager
-    this._framework = framework
-    this._handlers = []
-    this._relevantEvents = new Set([
-      'tool:result',              // 工具执行结果
-      'scheduler:reminder',       // 定时提醒
-      'agent:message',            // 代理消息
-      'think:thought_completed',  // 思考完成
-      'email:received',           // 收到邮件
-      'webhook:received'          // Webhook接收
-    ])
-  }
-
-  start() {
-    const events = [
-      ['tool:result', (data) => this._handleEvent('tool:result', 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)],
-      ['email:received', (data) => this._handleEvent('email:received', data)],
-      ['webhook:received', (data) => this._handleEvent('webhook:received', data)]
-    ]
-
-    for (const [event, handler] of events) {
-      this._framework.on(event, handler)
-      this._handlers.push({ event, handler })
-    }
-  }
-
-  stop() {
-    for (const { event, handler } of this._handlers) {
-      this._framework.off(event, handler)
-    }
-    this._handlers = []
-  }
-
-  _handleEvent(type, data) {
-    const activeGoals = this._goalManager.getActiveGoals()
-    console.log(`[Ambient] _handleEvent: type=${type}, activeGoals=${activeGoals.length}`)
-    for (const goal of activeGoals) {
-      // 检查目标条件是否匹配此事件
-      const isRelevant = this._isRelevantToGoal(goal, type, data)
-      console.log(`[Ambient] goal=${goal.id}, isRelevant=${isRelevant}, conditions=${JSON.stringify(goal.conditions)}`)
-      if (isRelevant) {
-        // 将 data 展平到事件对象中，方便通过 {{_event.xxx}} 访问
-        this._goalManager.addEventToGoal(goal.id, { type, ...data })
-        console.log(`[Ambient] Event added to goal ${goal.id}`)
-      }
-    }
-
-    // 检查是否有 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 })
-        console.log(`[Ambient] 事件触发激活目标: ${goal.id} (事件: ${type})`)
-      }
-    }
-  }
-
-  _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 && 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
-      }
-    }
-    return true
-  }
-}
-
-// ============================================================================
-// Reflector - 评估操作结果，更新目标状态
-// ============================================================================
-class Reflector {
-  constructor(goalManager) {
-    this._goalManager = goalManager
-  }
-
-  evaluateOutcome(goal, actionResult) {
-    if (!goal) return null
-
-    // 检查是否是事件驱动目标
-    const isEventDriven = goal.conditions?.events && goal.conditions.events.length > 0
-
-    // 检查错误
-    if (actionResult && actionResult.error) {
-      // 增加尝试次数但不立即失败
-      goal.attempts++
-      // 事件驱动目标：错误不导致失败或完成
-      if (isEventDriven) {
-        return { shouldContinue: true, goalComplete: false }
-      }
-      return {
-        shouldContinue: goal.attempts < goal.maxAttempts,
-        actionTaken: false
-      }
-    }
-
-    // 检查是否成功完成
-    if (actionResult && actionResult.success === true) {
-      goal.attempts++
-
-      // 事件驱动目标：永远不会完成，持续等待下一事件
-      if (isEventDriven) {
-        return { shouldContinue: true, goalComplete: false }
-      }
-
-      // 检查目标是否完成
-      if (goal.actions.length === 0 || goal.attempts >= goal.maxAttempts) {
-        return { shouldContinue: false, goalComplete: true }
-      }
-
-      return { shouldContinue: true, actionTaken: true }
-    }
-
-    // 工具执行无错误 - 视为成功
-    goal.attempts++
-
-    // 事件驱动目标：永远不会完成
-    if (isEventDriven) {
-      return { shouldContinue: true, goalComplete: false }
-    }
-
-    // 检查目标是否完成（没有更多操作）
-    if (goal.actions.length === 0 || goal.attempts >= goal.maxAttempts) {
-      return { shouldContinue: false, goalComplete: true }
-    }
-
-    return { shouldContinue: true, actionTaken: true }
-  }
-
-  checkLoopDetection(goal, actionId) {
-    // 如果同一操作连续重复3次，则目标失败
-    if (goal.lastActionId === actionId) {
-      goal.consecutiveSameActions++
-      if (goal.consecutiveSameActions >= 3) {
-        this._goalManager.failGoal(goal.id, '检测到循环：同一操作连续重复3次')
-        return true
-      }
-    } else {
-      goal.consecutiveSameActions = 1
-      goal.lastActionId = actionId
-    }
-    return false
-  }
-}
-
-// ============================================================================
-// ExplorerLoop - 主自主循环，决定并执行操作
-// ============================================================================
-class ExplorerLoop {
-  constructor(goalManager, reflector, framework, config) {
-    this._goalManager = goalManager
-    this._reflector = reflector
-    this._framework = framework
-    this._config = config
-    this._running = false
-    this._timer = null
-    this._lastActionTime = 0
-    this._tickCount = 0
-    this._recentActivities = []
-    this._stepExecutor = new StepExecutor(framework)
-    this._ambientAgent = null
-    this._initAmbientAgent()
-  }
-
-  /**
-   * 初始化 Ambient 专用子 Agent
-   */
-  _initAmbientAgent() {
-    const aiPlugin = this._framework.pluginManager?.get('ai')
-    const llmConfig = aiPlugin ? aiPlugin.getConfig() : {}
-
-    this._ambientAgent = new Agent(this._framework, {
-      name: 'ambient-worker',
-      systemPrompt: `你是 ambient-worker，一个专门执行后台任务的子 agent。
-
-你的职责：
-1. 执行 LLM 调用的任务（如生成回复、发送消息）
-2. 不主动思考，只执行给定任务
-3. 快速响应，不等待用户交互
-
-当收到任务时，直接执行并返回结果。`,
-      model: llmConfig.model,
-      provider: llmConfig.provider,
-      apiKey: llmConfig.apiKey,
-      baseURL: llmConfig.baseURL
-    })
-
-    // 注册到主 agent（如果主 agent 已存在）
-    if (this._framework._mainAgent) {
-      this._registerAmbientWorker(this._framework._mainAgent)
-    } else {
-      // 等待主 agent 创建
-      this._framework.once('agent:created', (agent) => {
-        if (this._framework._mainAgent && agent === this._framework._mainAgent) {
-          this._registerAmbientWorker(agent)
-        }
-      })
-    }
-  }
-
-  /**
-   * 注册 ambient-worker 到主 agent
-   */
-  _registerAmbientWorker(agent) {
-    if (!this._ambientAgent) return
-    agent.registerSubAgent(
-      'ambient-worker',
-      this._ambientAgent,
-      '后台任务执行器',
-      '执行需要 AI 能力的后台任务'
-    )
-    console.log('[Ambient] ambient-worker subagent registered')
-  }
-
-  start() {
-    if (this._running) return
-    this._running = true
-    this._scheduleNext()
-  }
-
-  stop() {
-    this._running = false
-    if (this._timer) {
-      clearTimeout(this._timer)
-      this._timer = null
-    }
-  }
-
-  pause() {
-    this._running = false
-    if (this._timer) {
-      clearTimeout(this._timer)
-      this._timer = null
-    }
-  }
-
-  resume() {
-    if (!this._running) {
-      this._running = true
-      this._scheduleNext()
-    }
-  }
-
-  isRunning() {
-    return this._running
-  }
-
-  getStatus() {
-    return {
-      running: this._running,
-      tickCount: this._tickCount,
-      lastTick: this._lastActionTime ? new Date(this._lastActionTime) : null,
-      recentActivities: this._recentActivities.slice(-10),
-      activeGoals: this._goalManager.getActiveGoals().length,
-      pendingGoals: this._goalManager.getPendingGoals().length
-    }
-  }
-
-  _scheduleNext() {
-    if (!this._running) return
-    this._timer = setTimeout(() => this._tick(), this._config.tickInterval)
-  }
-
-  async _tick() {
-    if (!this._running) return
-
-    // 如果处于嵌套执行上下文中，跳过此tick
-    try {
-      if (this._framework.getExecutionContext) {
-        const ctx = this._framework.getExecutionContext()
-        if (ctx && ctx.id) {
-          // 跳过此tick，重新调度
-          this._scheduleNext()
-          return
-        }
-      }
-    } catch (e) {
-      // getExecutionContext可能不存在，继续执行
-    }
-
-    this._tickCount++
-    
-
-    try {
-      await this._processGoals()
-    } catch (err) {
-      console.error('[Ambient] Tick错误:', err.message)
-      this._addActivity('error', { message: err.message })
-    }
-    this._lastActionTime = Date.now()
-    // 调度下一次tick
-    this._scheduleNext()
-  }
-
-  async _processGoals() {
-    const activeGoals = this._goalManager.getActiveGoals()
-
-    for (const goal of activeGoals) {
-      // 检查冷却时间
-      if (Date.now() - this._lastActionTime < this._config.cooldownPeriod) {
-        continue
-      }
-
-      // 检查目标是否有未处理的事件
-      const hasNewEvents = goal.eventsReceived && goal.eventsReceived.length > 0
-
-      // 检查是否是事件驱动目标
-      const isEventDriven = goal.conditions?.events && goal.conditions.events.length > 0
-
-      // 事件驱动目标：只有在新事件时才执行 actions
-      if (isEventDriven && !hasNewEvents) {
-        continue
-      }
-
-      // 获取下一个操作
-      if (goal.actions && goal.actions.length > 0) {
-        // 如果有多个 action，按顺序执行所有 action
-        if (goal.actions.length > 1) {
-          const eventData = hasNewEvents ? goal.eventsReceived[0] : null
-          const results = await this._executeAllActions(goal.actions, eventData)
-
-          // 最后一个结果用于评估
-          const lastResult = results.length > 0 ? results[results.length - 1].result : null
-
-          // 评估结果
-          const outcome = this._reflector.evaluateOutcome(goal, lastResult)
-
-          // 检查是否是事件驱动目标
-          const isEventDriven = goal.conditions?.events && goal.conditions.events.length > 0
-
-          if (outcome.goalComplete && !isEventDriven) {
-            // 非事件驱动目标可以完成
-            this._goalManager.completeGoal(goal.id)
-            this._addActivity('goal_completed', { goalId: goal.id, attempts: goal.attempts })
-            this._notifyUser('目标完成', `目标 "${goal.title}" 已完成（尝试次数：${goal.attempts}）`, 'success')
-          } else if (!outcome.shouldContinue && !isEventDriven) {
-            // 非事件驱动目标可以失败
-            this._goalManager.failGoal(goal.id, '达到最大尝试次数')
-            this._addActivity('goal_failed', { goalId: goal.id, reason: '达到最大尝试次数' })
-            this._notifyUser('目标失败', `目标 "${goal.title}" 失败：达到最大尝试次数`, 'error')
-          } else {
-            // 事件驱动目标：不论结果如何，都重置并继续等待下一事件
-            this._addActivity('actions_completed', { goalId: goal.id, actionCount: results.length })
-          }
-
-          // 执行操作后清除已处理的事件，并重置 actions 以处理下一事件
-          if (hasNewEvents) {
-            goal.eventsReceived = []
-            // 重置 actions 为原始 actions，以便处理下一事件
-            if (goal._originalActions) {
-              goal.actions = goal._originalActions.slice()
-            }
-            this._goalManager.updateGoal(goal.id, { eventsReceived: [], actions: goal.actions })
-          }
-          continue
-        }
-
-        // 单个 action，使用原有逻辑
-        const action = goal.actions[0]
-
-        // 循环检测（仅用于非事件驱动的操作）
-        if (!hasNewEvents && this._reflector.checkLoopDetection(goal, action.id)) {
-          this._addActivity('goal_failed', { goalId: goal.id, reason: '检测到循环' })
-          // 通知用户目标失败
-          this._notifyUser('目标失败', `目标 "${goal.title}" 失败：检测到循环（同一操作连续重复）`, 'error')
-          continue
-        }
-
-        // 执行操作
-        const result = await this._executeAction(action, hasNewEvents ? goal.eventsReceived[0] : null)
-
-        // 评估结果
-        const outcome = this._reflector.evaluateOutcome(goal, result)
-
-        if (outcome.goalComplete) {
-          this._goalManager.completeGoal(goal.id)
-          this._addActivity('goal_completed', { goalId: goal.id, attempts: goal.attempts })
-          // 通知用户目标完成
-          this._notifyUser('目标完成', `目标 "${goal.title}" 已完成（尝试次数：${goal.attempts}）`, 'success')
-        } else if (!outcome.shouldContinue) {
-          this._goalManager.failGoal(goal.id, '达到最大尝试次数')
-          this._addActivity('goal_failed', { goalId: goal.id, reason: '达到最大尝试次数' })
-          // 通知用户目标失败
-          this._notifyUser('目标失败', `目标 "${goal.title}" 失败：达到最大尝试次数`, 'error')
-        } else if (outcome.actionTaken) {
-          // 从队列中移除已完成的操作
-          // 注意：对于事件驱动目标，如果 hasNewEvents 为 true，不移除 action 而是在下面重置
-          if (!hasNewEvents) {
-            goal.actions.shift()
-          }
-          this._addActivity('action_executed', { goalId: goal.id, action: action.id, hasEvents: hasNewEvents })
-        }
-
-        // 执行操作后清除已处理的事件，并重置 actions 以处理下一事件
-        if (hasNewEvents) {
-          goal.eventsReceived = []
-          // 重置 actions 为原始 actions，以便处理下一事件
-          if (goal._originalActions) {
-            goal.actions = goal._originalActions.slice()
-          }
-          this._goalManager.updateGoal(goal.id, { eventsReceived: [], actions: goal.actions })
-        }
-      }
-    }
-
-    // 激活满足条件的待处理目标
-    const pendingGoals = this._goalManager.getPendingGoals()
-    for (const goal of pendingGoals) {
-      // 自动激活没有条件的目标
-      // 有条件的目标会在事件触发时被 EventWatcher 自动激活
-      if (!goal.conditions || Object.keys(goal.conditions).length === 0) {
-        this._goalManager.activateGoal(goal.id)
-        this._addActivity('goal_activated', { goalId: goal.id })
-      } else {
-        // 有条件的目标，立即激活以便开始监听事件
-        this._goalManager.activateGoal(goal.id)
-        this._addActivity('goal_activated', { goalId: goal.id, reason: '事件监听目标已激活' })
-      }
-    }
-  }
-
-  /**
-   * 执行单个 action
-   * @param {Object} action - action 配置
-   * @param {Object} eventData - 事件数据
-   * @param {Object} context - 执行上下文（包含 stepOutputs 等）
-   * @returns {Promise<Object>} 执行结果
-   */
-  async _executeAction(action, eventData = null, context = null) {
-    if (!this._framework) {
-      return { success: false, error: '框架不可用' }
-    }
-
-    try {
-      // 如果没有提供 context，创建一个新的
-      if (!context) {
-        context = {
-          input: {},
-          variables: {
-            _event: eventData?.data || eventData || null,
-            _eventRaw: eventData || null,
-            _action: action
-          },
-          lastResult: null
-        }
-      } else {
-        // 更新 context 中的 _action
-        context.variables._action = action
-      }
-
-      // 将 action 转换为 step 配置
-      const step = this._actionToStep(action)
-
-      // 解析 step.args 中的变量引用（支持 ${actionId.output} 格式）
-      if (step.args) {
-        step.args = this._resolveActionArgs(step.args, context)
-      }
-      if (step.input) {
-        step.input = this._resolveActionArgs(step.input, context)
-      }
-
-      // message 和 think 类型使用专用子 agent 执行
-      if (step.type === 'message' || step.type === 'think') {
-        return await this._executeWithAmbientAgent(step, context)
-      }
-
-      // 其他类型使用 StepExecutor 直接执行
-      const result = await this._stepExecutor.executeStep(step, context)
-      return result
-    } catch (err) {
-      return { success: false, error: err.message }
-    }
-  }
-
-  /**
-   * 解析 action 参数中的变量引用
-   * 支持 ${actionId.output}、${actionId.output.field} 和 ${event.xxx} 格式
-   * @param {Object} args - 参数对象
-   * @param {Object} context - 执行上下文
-   * @returns {Object} 解析后的参数
-   */
-  _resolveActionArgs(args, context) {
-    if (!args || typeof args !== 'object') return args
-
-    const stepOutputs = context.variables._stepOutputs || {}
-    const eventData = context.variables._event || {}
-
-    const resolved = {}
-    for (const [key, value] of Object.entries(args)) {
-      resolved[key] = this._resolveActionValue(value, stepOutputs, eventData)
-    }
-    return resolved
-  }
-
-  /**
-   * 解析单个值中的 ${actionId.output} 引用和 ${event.xxx} 引用
-   */
-  _resolveActionValue(value, stepOutputs, eventData) {
-    if (typeof value === 'string') {
-      // 处理 ${actionId.output} 和 ${actionId.output.field} 格式
-      const result = value.replace(/\$\{([^}]+)\}/g, (match, path) => {
-        if (path === 'output' || path === 'result') {
-          // {{result}} 引用上一步结果
-          return stepOutputs._lastResult ?? match
-        }
-        if (path.startsWith('event.')) {
-          // ${event.xxx} 引用事件数据
-          let eventPath = path.replace(/^event\./, '')
-          // 优先在 eventData.data 中查找（因为事件数据通常存储在 data 字段）
-          if (eventData?.data) {
-            let 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)
-            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
-          }
-          return match
-        }
-        if (path === 'event') {
-          // ${event} 引用整个事件数据对象
-          return eventData ?? match
-        }
-        if (path.includes('.')) {
-          // ${actionId.output.field} 格式
-          const [actionId, ...fieldParts] = path.split('.')
-          if (actionId === 'result' || actionId === 'output') {
-            // {{result.field}} 格式
-            const val = this._getNestedValue(stepOutputs._lastResult, fieldParts.join('.'))
-            return val !== undefined ? val : match
-          }
-          const actionOutput = stepOutputs[actionId]
-          if (actionOutput !== undefined) {
-            const val = this._getNestedValue(actionOutput, fieldParts.join('.'))
-            return val !== undefined ? val : match
-          }
-        } else {
-          // ${actionId.output} 格式
-          const actionOutput = stepOutputs[path]
-          if (actionOutput !== undefined) return actionOutput
-        }
-        return match
-      })
-      return result
-    } else if (Array.isArray(value)) {
-      return value.map(v => this._resolveActionValue(v, stepOutputs, eventData))
-    } else if (typeof value === 'object' && value !== null) {
-      const resolved = {}
-      for (const [k, v] of Object.entries(value)) {
-        resolved[k] = this._resolveActionValue(v, stepOutputs, eventData)
-      }
-      return resolved
-    }
-    return value
-  }
-
-  _getNestedValue(obj, path) {
-    if (!obj) return undefined
-    const parts = path.split('.')
-    let current = obj
-    for (const part of parts) {
-      if (current === null || current === undefined) return undefined
-      current = current[part]
-    }
-    return current
-  }
-
-  /**
-   * 按顺序执行所有 actions
-   * @param {Array} actions - action 数组
-   * @param {Object} eventData - 事件数据
-   * @returns {Promise<Array>} 所有执行结果
-   */
-  async _executeAllActions(actions, eventData = null) {
-    const results = []
-    const stepOutputs = {}
-
-    const context = {
-      input: {},
-      variables: {
-        _event: eventData?.data || eventData || null,
-        _eventRaw: eventData || null,
-        _stepOutputs: stepOutputs
-      },
-      lastResult: null
-    }
-
-    for (const action of actions) {
-      // 执行前更新 stepOutputs
-      context.variables._stepOutputs = stepOutputs
-
-      const result = await this._executeAction(action, eventData, context)
-
-      // 保存结果：使用 action id 作为键
-      if (action.id) {
-        stepOutputs[action.id] = result
-      }
-      // 同时保存为 _lastResult 供 {{result}} 引用
-      stepOutputs._lastResult = result
-      context.lastResult = result
-
-      results.push({ actionId: action.id, result })
-
-      // 如果执行失败，停止执行
-      if (result && result.success === false) {
-        break
-      }
-    }
-
-    return results
-  }
-
-  /**
-   * 使用 ambient 子 agent 执行 AI 相关操作
-   */
-  async _executeWithAmbientAgent(step, context) {
-    if (!this._ambientAgent) {
-      return { success: false, error: 'Ambient agent 未初始化' }
-    }
-
-    if (step.type === 'message') {
-      let content = step.content || ''
-      content = this._stepExecutor._resolveValue(content, context)
-
-      if (context.variables._event) {
-        content = `${content}\n\n[事件上下文: ${JSON.stringify(context.variables._event)}]`
-      }
-
-      try {
-        const result = await this._ambientAgent.pushMessage(content)
-        return { success: true, result }
-      } catch (err) {
-        return { success: false, error: err.message }
-      }
-    }
-
-    if (step.type === 'think') {
-      const thinkPlugin = this._framework.pluginManager?.get('think')
-      if (!thinkPlugin) {
-        return { success: false, error: '思考插件不可用' }
-      }
-
-      let topic = step.topic || 'Ambient代理反思'
-      topic = this._stepExecutor._resolveValue(topic, context)
-
-      if (context.variables._event) {
-        topic = `${topic}\n\n[事件上下文: ${JSON.stringify(context.variables._event)}]`
-      }
-
-      try {
-        const result = await thinkPlugin._triggerThinking({
-          topic,
-          mode: step.mode || 'reflect',
-          depth: step.depth || 2
-        })
-        return result
-      } catch (err) {
-        return { success: false, error: err.message }
-      }
-    }
-
-    return { success: false, error: `未知 AI 操作类型: ${step.type}` }
-  }
-
-  /**
-   * 将 action 转换为 step 配置
-   */
-  _actionToStep(action) {
-    const step = {
-      id: action.id || `action_${Date.now()}`,
-      type: action.type,
-      name: action.name || action.id
-    }
-
-    switch (action.type) {
-      case 'tool':
-        step.tool = action.name
-        step.args = action.args || {}
-        break
-      case 'message':
-        step.content = action.content || ''
-        break
-      case 'think':
-        step.topic = action.topic || 'Ambient代理反思'
-        step.mode = action.mode || 'reflect'
-        step.depth = action.depth || 2
-        break
-    }
-
-    return step
-  }
-
-  _getActiveAgent() {
-    if (this._framework._mainAgent) {
-      return this._framework._mainAgent
-    }
-    const agents = this._framework._agents || []
-    return agents.length > 0 ? agents[agents.length - 1] : null
-  }
-
-  _addActivity(type, data) {
-    this._recentActivities.push({
-      type,
-      data,
-      timestamp: new Date()
-    })
-    // 只保留最近50条活动记录
-    if (this._recentActivities.length > 50) {
-      this._recentActivities = this._recentActivities.slice(-50)
-    }
-  }
-
-  /**
-   * 通知用户（通过事件发送给消息插件）
-   */
-  _notifyUser(title, message, level = 'info') {
-    if (!this._framework) return
-
-    // 获取目标相关的sessionId（如果有）
-    let sessionId = null
-    const sessionPlugin = this._framework.pluginManager.get('session')
-    if (sessionPlugin) {
-      const sessions = sessionPlugin.listSessions()
-      if (sessions.length > 0) {
-        // 取最新的会话
-        sessions.sort((a, b) => new Date(b.lastActive).getTime() - new Date(a.lastActive).getTime())
-        sessionId = sessions[0].id
-      }
-    }
-
-    // 发送统一的通知事件
-    this._framework.emit('notification', {
-      title,
-      message,
-      source: 'ambient',
-      level,  // 'info' | 'warning' | 'success' | 'error'
-      sessionId,
-      timestamp: new Date()
-    })
-
-    console.log(`[Ambient:通知] ${title}: ${message}`)
-  }
-}
-
-// ============================================================================
-// 主插件类
-// ============================================================================
-class AmbientAgentPlugin extends Plugin {
-  constructor(config = {}) {
-    super()
-    this.name = 'ambient'
-    this.version = '1.0.0'
-this.description = `Ambient Agent - 持续后台运行的智能代理，用于主动监控事件并执行操作
-
-## 支持的事件类型（创建目标时 conditions.events 必须使用这些确切的名称）：
-- email:received - 收到新邮件（参数：from, subject, text, messageId）
-- tool:result - 工具执行完成（参数：name, args, result）
-- scheduler:reminder - 定时提醒（参数：taskId, message, time）
-- scheduler:task_completed - 任务完成（参数：taskId, result）
-- scheduler:task_failed - 任务失败（参数：taskId, error）
-- agent:message - 代理消息（参数：content, sessionId）
-- think:thought_completed - 思考完成（参数：mode, topic, thought）
-- webhook:received - Webhook接收（参数：headers, body, query, path）
-
-## 在 action 参数中引用事件数据：
-使用 \${event.xxx} 语法，例如：\${event.from}、\${event.subject}、\${event.text}`
-    this.priority = 18
-    this.system = true
-
-    this.config = {
-      enabled: config.enabled !== false,
-      tickInterval: config.tickInterval || 5000,      // tick间隔（毫秒）
-      cooldownPeriod: config.cooldownPeriod || 3000,  // 冷却时间（毫秒）
-      persistencePath: config.persistencePath || '.agent/data/ambient',
-      defaultGoals: config.defaultGoals || []
-    }
-
-    this._framework = null
-    this._stateStore = null
-    this._goalManager = null
-    this._eventWatcher = null
-    this._reflector = null
-    this._explorerLoop = null
-    this._memories = []
-  }
-
-  install(framework) {
-    this._framework = framework
-    this._stateStore = new StateStore(this.config.persistencePath)
-    this._goalManager = new GoalManager(this._stateStore)
-    this._reflector = new Reflector(this._goalManager)
-
-    // 加载持久化的记忆
-    this._memories = this._stateStore.loadMemories()
-
-    return this
-  }
-
-  start(framework) {
-    if (!this.config.enabled) {
-      console.log('[Ambient] 插件已禁用，跳过启动')
-      return this
-    }
-
-    // 如果没有现有目标，创建默认目标
-    if (this._goalManager.getAllGoals().length === 0 && this.config.defaultGoals.length > 0) {
-      for (const goalDef of this.config.defaultGoals) {
-        this._goalManager.createGoal(goalDef)
-      }
-    }
-
-    // 启动事件监听器
-    this._eventWatcher = new EventWatcher(this._goalManager, this._framework)
-    this._eventWatcher.start()
-
-    // 动态更新description显示支持的事件及参数
-    const eventDescriptions = {
-      'tool:result': '工具执行结果事件 - 参数: name(工具名), args(执行参数), result(执行结果), error(错误信息)',
-      'scheduler:reminder': '定时提醒事件 - 参数: taskId(任务ID), message(提醒消息), time(触发时间)',
-      'scheduler:task_completed': '任务完成事件 - 参数: taskId(任务ID), result(任务结果)',
-      'scheduler:task_failed': '任务失败事件 - 参数: taskId(任务ID), error(错误信息)',
-      'agent:message': '代理消息事件 - 参数: content(消息内容), sessionId(会话ID), agentId(代理ID)',
-      'think:thought_completed': '思考完成事件 - 参数: mode(思考模式), topic(思考主题), thought(思考内容), depth(思考深度)',
-      'email:received': '收到邮件事件 - 参数: from(发件人), to(收件人), subject(主题), text(正文), body(HTML正文), messageId(消息ID), timestamp(时间戳)',
-      'webhook:received': 'Webhook接收事件 - 参数: headers(HTTP头), body(请求体), query(查询参数), path(请求路径)'
-    }
-
-    const events = Array.from(this._eventWatcher._relevantEvents)
-    const eventList = events.map(e => {
-      const desc = eventDescriptions[e] || e
-      return `  - ${desc}`
-    }).join('\n')
-
-    this.description = `Ambient Agent - 持续后台运行的智能代理，用于主动监控和执行操作
-支持的事件及参数：
-${eventList}
-
-使用 \${event.xxx} 在 action 参数中引用事件数据`
-
-    // 启动探索循环
-    this._explorerLoop = new ExplorerLoop(this._goalManager, this._reflector, this._framework, {
-      tickInterval: this.config.tickInterval,
-      cooldownPeriod: this.config.cooldownPeriod
-    })
-    this._explorerLoop.start()
-
-    // 注册工具
-    this._registerTools(framework)
-
-    console.log('[Ambient] 插件已启动')
-    return this
-  }
-
-  _registerTools(framework) {
-    // ambient_goals - 列出/创建/更新/删除目标
-    framework.registerTool({
-      name: 'ambient_goals',
-      description: '管理Ambient Agent目标 - 列出、创建、更新、删除、激活目标',
-      inputSchema: z.object({
-        action: z.enum(['list', 'create', 'update', 'delete', 'activate']).describe('执行的操作'),
-        goalId: z.string().optional().describe('目标ID（更新/删除/激活时必需）'),
-        title: z.string().optional().describe('目标标题（创建/更新时使用）'),
-        description: z.string().optional().describe('目标描述（创建/更新时使用）'),
-        priority: z.number().optional().describe('优先级1-10，数值越高越重要（创建/更新时使用）'),
-        actions: z.array(z.object({
-          id: z.string().optional().describe('操作标识符'),
-          type: z.enum(['tool', 'message', 'think']).describe('操作类型'),
-          name: z.string().optional().describe('工具名称（tool类型时使用）'),
-          args: z.record(z.any()).optional().describe('工具参数（tool类型时使用）'),
-          content: z.string().optional().describe('消息内容（message类型时使用）'),
-          topic: z.string().optional().describe('思考主题（think类型时使用）'),
-          mode: z.enum(['reflect', 'brainstorm', 'analyze', 'plan']).optional().describe('思考模式（think类型时使用）')
-        })).optional().describe('要执行的操作列表（创建/更新时使用）'),
-        conditions: z.object({
-          events: z.union([z.string(), z.array(z.string())]).optional().describe('要监听的事件类型'),
-          toolNames: z.union([z.string(), z.array(z.string())]).optional().describe('按工具名称过滤')
-        }).optional().describe('激活条件（创建/更新时使用）')
-      }),
-      execute: async (args) => {
-        return this._handleGoalsTool(args)
-      }
-    })
-
-    // ambient_status - 获取当前循环状态
-    framework.registerTool({
-      name: 'ambient_status',
-      description: '获取当前Ambient Agent状态 - 循环状态、进行中的目标、最近活动',
-      inputSchema: z.object({}),
-      execute: async () => {
-        return this._handleStatusTool()
-      }
-    })
-
-    // ambient_think - 触发主动LLM思考
-    framework.registerTool({
-      name: 'ambient_think',
-      description: '为某个目标触发主动LLM思考 - 模式：reflect（反思）、brainstorm（头脑风暴）、plan（计划）、analyze（分析）',
-      inputSchema: z.object({
-        goalId: z.string().optional().describe('要思考的目标ID'),
-        mode: z.enum(['reflect', 'brainstorm', 'plan', 'analyze']).describe('思考模式'),
-        topic: z.string().optional().describe('要思考的主题'),
-        depth: z.number().optional().describe('思考深度1-5')
-      }),
-      execute: async (args) => {
-        return this._handleThinkTool(args)
-      }
-    })
-
-    // ambient_remember - 存储/检索/搜索持久化记忆
-    framework.registerTool({
-      name: 'ambient_remember',
-      description: '为Ambient Agent存储或检索持久化记忆',
-      inputSchema: z.object({
-        action: z.enum(['store', 'retrieve', 'search']).describe('操作：store存储记忆、retrieve检索最近、search搜索'),
-        content: z.string().optional().describe('记忆内容（store时使用）'),
-        key: z.string().optional().describe('记忆键（store/retrieve时使用）'),
-        query: z.string().optional().describe('搜索查询（search时使用）'),
-        limit: z.number().optional().describe('最大结果数（retrieve/search时使用）')
-      }),
-      execute: async (args) => {
-        return this._handleRememberTool(args)
-      }
-    })
-
-    // ambient_control - 暂停/恢复/调整探索循环
-    framework.registerTool({
-      name: 'ambient_control',
-      description: '控制Ambient Agent探索循环 - 暂停、恢复或调整设置',
-      inputSchema: z.object({
-        action: z.enum(['pause', 'resume', 'status', 'adjust']).describe('控制操作'),
-        tickInterval: z.number().optional().describe('新的tick间隔毫秒数（adjust时使用）'),
-        cooldownPeriod: z.number().optional().describe('新的冷却时间毫秒数（adjust时使用）')
-      }),
-      execute: async (args) => {
-        return this._handleControlTool(args)
-      }
-    })
-  }
-
-  _handleGoalsTool(args) {
-    const { action, goalId, title, description, priority, actions, conditions } = args
-
-    switch (action) {
-      case 'list': {
-        const allGoals = this._goalManager.getAllGoals()
-        return {
-          success: true,
-          goals: allGoals.map(g => ({
-            id: g.id,
-            title: g.title,
-            state: g.state,
-            priority: g.priority,
-            actionsCount: g.actions ? g.actions.length : 0,
-            attempts: g.attempts,
-            createdAt: g.createdAt,
-            activatedAt: g.activatedAt,
-            completedAt: g.completedAt,
-            failedAt: g.failedAt
-          })),
-          total: allGoals.length,
-          active: this._goalManager.getActiveGoals().length,
-          pending: this._goalManager.getPendingGoals().length
-        }
-      }
-
-      case 'create': {
-        if (!title) {
-          return { success: false, error: '创建目标需要提供标题' }
-        }
-        const goal = this._goalManager.createGoal({ title, description, priority, actions, conditions })
-        return { success: true, goal }
-      }
-
-      case 'update': {
-        if (!goalId) {
-          return { success: false, error: '更新目标需要提供目标ID' }
-        }
-        const updates = {}
-        if (title !== undefined) updates.title = title
-        if (description !== undefined) updates.description = description
-        if (priority !== undefined) updates.priority = priority
-        if (actions !== undefined) updates.actions = actions
-        if (conditions !== undefined) updates.conditions = conditions
-        const goal = this._goalManager.updateGoal(goalId, updates)
-        return goal ? { success: true, goal } : { success: false, error: '目标未找到' }
-      }
-
-      case 'delete': {
-        if (!goalId) {
-          return { success: false, error: '删除目标需要提供目标ID' }
-        }
-        const deleted = this._goalManager.deleteGoal(goalId)
-        return { success: deleted }
-      }
-
-      case 'activate': {
-        if (!goalId) {
-          return { success: false, error: '激活目标需要提供目标ID' }
-        }
-        const goal = this._goalManager.activateGoal(goalId)
-        return goal ? { success: true, goal } : { success: false, error: '目标未找到或不是待激活状态' }
-      }
-
-      default:
-        return { success: false, error: `未知操作: ${action}` }
-    }
-  }
-
-  _handleStatusTool() {
-    if (!this._explorerLoop) {
-      return { success: false, error: '探索循环未初始化' }
-    }
-
-    const loopStatus = this._explorerLoop.getStatus()
-    const activeGoals = this._goalManager.getActiveGoals().map(g => ({
-      id: g.id,
-      title: g.title,
-      priority: g.priority,
-      attempts: g.attempts,
-      lastActionId: g.lastActionId
-    }))
-    const pendingGoals = this._goalManager.getPendingGoals().map(g => ({
-      id: g.id,
-      title: g.title,
-      priority: g.priority
-    }))
-
-    return {
-      success: true,
-      loop: {
-        running: loopStatus.running,
-        tickCount: loopStatus.tickCount,
-        lastTick: loopStatus.lastTick,
-        tickInterval: this.config.tickInterval,
-        cooldownPeriod: this.config.cooldownPeriod
-      },
-      activeGoals,
-      pendingGoals,
-      recentActivities: loopStatus.recentActivities
-    }
-  }
-
-  async _handleThinkTool(args) {
-    const { goalId, mode, topic, depth } = args
-
-    // 获取活跃代理
-    const agent = this._getActiveAgent()
-    if (!agent) {
-      return { success: false, error: '没有可用的活跃代理' }
-    }
-
-    // 构建思考提示
-    let prompt = ''
-    if (goalId) {
-      const goal = this._goalManager.getGoal(goalId)
-      if (goal) {
-        prompt = this._buildGoalThinkPrompt(goal, mode, topic)
-      } else {
-        return { success: false, error: '目标未找到' }
-      }
-    } else {
-      prompt = this._buildFreeThinkPrompt(mode, topic)
-    }
-
-    // 如果代理忙，等待其变为可用
-    let attempts = 0
-    const maxWaitAttempts = 10
-    const waitInterval = 500
-
-    while (agent._status === 'busy' && attempts < maxWaitAttempts) {
-      console.log('[Ambient] 代理忙，等待中...')
-      await new Promise(resolve => setTimeout(resolve, waitInterval))
-      attempts++
-    }
-
-    if (agent._status === 'busy') {
-      return {
-        success: false,
-        error: '代理繁忙，无法及时变为可用。请稍后重试。',
-        queued: true
-      }
-    }
-
-    // 通过代理执行思考
-    const thinkPlugin = this._framework.pluginManager.get('think')
-    if (thinkPlugin) {
-      const result = await thinkPlugin._triggerThinking({ topic: prompt, mode, depth: depth || 2 })
-      // 如果结果提示繁忙，返回更友好的消息
-      if (result && result.message && result.message.includes && result.message.includes('busy')) {
-        return {
-          success: true,
-          queued: true,
-          message: '思考请求已排队，将在代理空闲时处理。'
-        }
-      }
-      return result
-    }
-
-    // 备用：直接推送消息
-    return agent.pushMessage(prompt).then(result => ({
-      success: true,
-      result: typeof result === 'string' ? result : JSON.stringify(result)
-    })).catch(err => ({
-      success: false,
-      error: err.message
-    }))
-  }
-
-  _buildGoalThinkPrompt(goal, mode, topic) {
-    const modePrompts = {
-      reflect: `作为Ambient Agent，反思当前目标：
-标题: ${goal.title}
-描述: ${goal.description || '无'}
-优先级: ${goal.priority}
-状态: ${goal.state}
-尝试次数: ${goal.attempts}
-
-${topic ? `额外关注点: ${topic}` : ''}
-
-请反思：
-1. 这个目标仍然相关且可实现吗？
-2. 操作是否适合这个目标？
-3.有什么可以改进的？`,
-      brainstorm: `为Ambient Agent目标头脑风暴新方法：
-标题: ${goal.title}
-${goal.description ? `描述: ${goal.description}` : ''}
-计划的操作数: ${goal.actions ? goal.actions.length : 0}
-
-${topic ? `关注点: ${topic}` : '生成关于如何更有效地追求这个目标的新想法。'}`,
-      plan: `为Ambient Agent目标制定更精细的计划：
-标题: ${goal.title}
-${goal.description ? `描述: ${goal.description}` : ''}
-${topic ? `额外上下文: ${topic}` : ''}
-
-制定一个清晰、可操作的计划。`,
-      analyze: `分析Ambient Agent目标：
-标题: ${goal.title}
-状态: ${goal.state}
-优先级: ${goal.priority}
-操作: ${goal.actions ? JSON.stringify(goal.actions) : '无'}
-
-${topic ? `分析重点: ${topic}` : '这个目标的优势、劣势和潜在问题是什么？'}`
-    }
-    return modePrompts[mode] || modePrompts.reflect
-  }
-
-  _buildFreeThinkPrompt(mode, topic) {
-    const modePrompts = {
-      reflect: `Ambient Agent反思: ${topic || '思考系统和目标的当前状态。有什么可以改进的？'}`,
-      brainstorm: `Ambient Agent头脑风暴: ${topic || '生成关于新目标或方法的有创意想法。'}`,
-      plan: `Ambient Agent计划: ${topic || '为待实现的目标制定计划。'}`,
-      analyze: `Ambient Agent分析: ${topic || '分析当前目标及其进展。'}`
-    }
-    return modePrompts[mode] || modePrompts.reflect
-  }
-
-  _handleRememberTool(args) {
-    const { action, content, key, query, limit } = args
-    const maxResults = limit || 10
-
-    switch (action) {
-      case 'store': {
-        if (!content) {
-          return { success: false, error: '存储需要提供内容' }
-        }
-        const memoryKey = key || `memory_${Date.now()}`
-        const memory = {
-          key: memoryKey,
-          content,
-          timestamp: new Date()
-        }
-        this._memories.push(memory)
-        this._stateStore.saveMemories(this._memories)
-        return { success: true, memory }
-      }
-
-      case 'retrieve': {
-        const memories = this._memories.slice(-maxResults).reverse()
-        return {
-          success: true,
-          memories,
-          total: this._memories.length
-        }
-      }
-
-      case 'search': {
-        if (!query) {
-          return { success: false, error: '搜索需要提供查询词' }
-        }
-        const queryLower = query.toLowerCase()
-        const results = this._memories
-          .filter(m => m.content.toLowerCase().includes(queryLower))
-          .slice(-maxResults)
-          .reverse()
-        return {
-          success: true,
-          results,
-          total: results.length
-        }
-      }
-
-      default:
-        return { success: false, error: `未知操作: ${action}` }
-    }
-  }
-
-  _handleControlTool(args) {
-    const { action, tickInterval, cooldownPeriod } = args
-
-    switch (action) {
-      case 'pause': {
-        if (!this._explorerLoop) {
-          return { success: false, error: '探索循环未初始化' }
-        }
-        this._explorerLoop.pause()
-        return { success: true, message: '探索循环已暂停' }
-      }
-
-      case 'resume': {
-        if (!this._explorerLoop) {
-          return { success: false, error: '探索循环未初始化' }
-        }
-        this._explorerLoop.resume()
-        return { success: true, message: '探索循环已恢复' }
-      }
-
-      case 'status': {
-        if (!this._explorerLoop) {
-          return { success: false, error: '探索循环未初始化' }
-        }
-        const status = this._explorerLoop.getStatus()
-        return {
-          success: true,
-          running: status.running,
-          tickCount: status.tickCount,
-          lastTick: status.lastTick,
-          tickInterval: this.config.tickInterval,
-          cooldownPeriod: this.config.cooldownPeriod
-        }
-      }
-
-      case 'adjust': {
-        if (tickInterval) {
-          this.config.tickInterval = tickInterval
-        }
-        if (cooldownPeriod) {
-          this.config.cooldownPeriod = cooldownPeriod
-        }
-        return {
-          success: true,
-          message: '设置已调整',
-          tickInterval: this.config.tickInterval,
-          cooldownPeriod: this.config.cooldownPeriod
-        }
-      }
-
-      default:
-        return { success: false, error: `未知操作: ${action}` }
-    }
-  }
-
-  _getActiveAgent() {
-    if (this._framework._mainAgent) {
-      return this._framework._mainAgent
-    }
-    const agents = this._framework._agents || []
-    return agents.length > 0 ? agents[agents.length - 1] : null
-  }
-
-  reload(framework) {
-    this._framework = framework
-    if (this._explorerLoop && this._explorerLoop.isRunning()) {
-      // 用新的框架引用重新启动
-      this._eventWatcher = new EventWatcher(this._goalManager, this._framework)
-      this._eventWatcher.start()
-    }
-  }
-
-  uninstall(framework) {
-    // 停止探索循环
-    if (this._explorerLoop) {
-      this._explorerLoop.stop()
-      this._explorerLoop = null
-    }
-
-    // 停止事件监听器
-    if (this._eventWatcher) {
-      this._eventWatcher.stop()
-      this._eventWatcher = null
-    }
-
-    // 清除引用
-    this._framework = null
-    this._goalManager = null
-    this._reflector = null
-    this._stateStore = null
-    this._memories = []
-  }
-}
-
-module.exports = { AmbientAgentPlugin, GoalState }