foliko 1.0.63 → 1.0.65

package/plugins/ambient-agent-plugin.js

@@ -1,320 +1,195 @@
 /**
- * Ambient Agent Plugin v2 — 自主执行引擎
- *
- * 核心改造：
- * 1. DecisionEngine    — 用 LLM 推理替代 FIFO 队列，动态决策下一步
- * 2. PriorityScheduler — 多维优先级排序（优先级 + 紧迫性 + 事件权重）
- * 3. ContextBuilder    — 为每次 LLM 决策聚合完整上下文
- * 4. SemanticMemory    — 关键词索引 + 时间衰减的记忆系统
- * 5. Reflector v2      — 失败分类 + 差异化恢复策略
+ * Ambient Agent 插件
+ * 持续后台运行的智能代理，监控事件并主动执行操作
  */
 
 const { Plugin } = require('../src/core/plugin-base')
 const { z } = require('zod')
 const fs = require('fs')
 const path = require('path')
-const crypto = require('crypto')
-
-// ─────────────────────────────────────────────────────────────────────────────
-// 常量
-// ─────────────────────────────────────────────────────────────────────────────
 
+// 目标生命周期状态
 const GoalState = {
-  PENDING:   'pending',
-  ACTIVE:    'active',
-  COMPLETED: 'completed',
-  FAILED:    'failed',
-  PAUSED:    'paused'      // 新增：可暂停单个目标
-}
-
-const FailureType = {
-  TOOL_NOT_FOUND:  'tool_not_found',
-  EXECUTION_ERROR: 'execution_error',
-  TIMEOUT:         'timeout',
-  LOOP_DETECTED:   'loop_detected',
-  MAX_ATTEMPTS:    'max_attempts',
-  LLM_REFUSED:     'llm_refused'
+  PENDING: 'pending',      // 待激活
+  ACTIVE: 'active',        // 执行中
+  COMPLETED: 'completed',  // 已完成
+  FAILED: 'failed'         // 已失败
 }
 
+// 生成唯一ID
 function generateId() {
-  return crypto.randomUUID ? crypto.randomUUID() : `id_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`
+  if (require('crypto').randomUUID) {
+    return require('crypto').randomUUID()
+  }
+  return `goal_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// StateStore — 持久化（同原版，增加 executionLog）
-// ─────────────────────────────────────────────────────────────────────────────
-
+// ============================================================================
+// StateStore - 持久化目标和记忆到 .agent/data/ambient/*.json
+// ============================================================================
 class StateStore {
   constructor(persistencePath) {
-    this._path = persistencePath
+    this._persistencePath = persistencePath
     this._ensureDir()
   }
 
   _ensureDir() {
-    if (!fs.existsSync(this._path)) fs.mkdirSync(this._path, { recursive: true })
-  }
-
-  _file(name) { return path.join(this._path, `${name}.json`) }
-
-  _save(name, data) {
-    try { fs.writeFileSync(this._file(name), JSON.stringify(data, null, 2)) }
-    catch (e) { console.error(`[Ambient] save ${name} failed:`, e.message) }
+    if (!fs.existsSync(this._persistencePath)) {
+      fs.mkdirSync(this._persistencePath, { recursive: true })
+    }
   }
 
-  _load(name, fallback) {
-    try {
-      const f = this._file(name)
-      if (fs.existsSync(f)) return JSON.parse(fs.readFileSync(f, 'utf-8'))
-    } catch (e) { console.error(`[Ambient] load ${name} failed:`, e.message) }
-    return fallback
+  _getGoalsPath() {
+    return path.join(this._persistencePath, 'goals.json')
   }
 
-  saveGoals(goals)     { this._save('goals', goals) }
-  loadGoals()          { return this._load('goals', []) }
-  saveMemories(mems)   { this._save('memories', mems) }
-  loadMemories()       { return this._load('memories', []) }
-  appendLog(entry)     {
-    const logs = this._load('execution_log', [])
-    logs.push(entry)
-    // 只保留最近 500 条
-    this._save('execution_log', logs.slice(-500))
+  _getMemoriesPath() {
+    return path.join(this._persistencePath, 'memories.json')
   }
-  loadLog()            { return this._load('execution_log', []) }
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// SemanticMemory — 替代原始 memories[] 数组
-// 支持：关键词索引检索 · 时间衰减评分 · 工作记忆（临时，不持久）
-// ─────────────────────────────────────────────────────────────────────────────
 
-class SemanticMemory {
-  constructor(stateStore) {
-    this._store  = stateStore
-    this._long   = stateStore.loadMemories()  // 长期记忆（持久化）
-    this._working = []                         // 工作记忆（会话内临时）
+  saveGoals(goals) {
+    try {
+      fs.writeFileSync(this._getGoalsPath(), JSON.stringify(goals, null, 2))
+    } catch (err) {
+      console.error('[Ambient] 保存目标失败:', err.message)
+    }
   }
 
-  /**
-   * 存储记忆
-   * @param {string} content
-   * @param {object} opts  { key, tags, scope:'long'|'working', goalId }
-   */
-  store(content, opts = {}) {
-    const { key, tags = [], scope = 'long', goalId } = opts
-    const mem = {
-      id:        generateId(),
-      key:       key || `mem_${Date.now()}`,
-      content,
-      tags,
-      goalId,
-      createdAt: Date.now(),
-      accessCount: 0
-    }
-    if (scope === 'working') {
-      this._working.push(mem)
-      if (this._working.length > 50) this._working.shift()
-    } else {
-      this._long.push(mem)
-      if (this._long.length > 2000) {
-        // 淘汰：访问次数最少 + 最旧的
-        this._long.sort((a, b) => (a.accessCount - b.accessCount) || (a.createdAt - b.createdAt))
-        this._long = this._long.slice(-1800)
+  loadGoals() {
+    try {
+      const filePath = this._getGoalsPath()
+      if (fs.existsSync(filePath)) {
+        const data = fs.readFileSync(filePath, 'utf-8')
+        return JSON.parse(data)
       }
-      this._store.saveMemories(this._long)
+    } catch (err) {
+      console.error('[Ambient] 加载目标失败:', err.message)
     }
-    return mem
+    return []
   }
 
-  /**
-   * 检索记忆（关键词 + 时间衰减评分）
-   * @param {string} query
-   * @param {object} opts  { limit, scope, goalId, tags }
-   */
-  search(query, opts = {}) {
-    const { limit = 10, scope = 'all', goalId, tags } = opts
-    const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean)
-    const now = Date.now()
-    const DAY  = 86400000
-
-    const pool = scope === 'working'
-      ? this._working
-      : scope === 'long'
-        ? this._long
-        : [...this._working, ...this._long]
-
-    const scored = pool
-      .filter(m => {
-        if (goalId && m.goalId !== goalId) return false
-        if (tags && tags.length > 0 && !tags.some(t => m.tags.includes(t))) return false
-        return true
-      })
-      .map(m => {
-        const text  = m.content.toLowerCase()
-        const hits  = queryTerms.filter(t => text.includes(t)).length
-        const ratio = hits / Math.max(queryTerms.length, 1)
-        // 时间衰减：7 天半衰期
-        const ageDays  = (now - m.createdAt) / DAY
-        const timeFactor = Math.exp(-ageDays / 7)
-        // 访问热度加成
-        const hotFactor = 1 + Math.log1p(m.accessCount) * 0.1
-        return { mem: m, score: ratio * timeFactor * hotFactor }
-      })
-      .filter(s => s.score > 0)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, limit)
-
-    // 更新访问计数
-    scored.forEach(({ mem }) => {
-      mem.accessCount++
-      if (this._long.includes(mem)) this._store.saveMemories(this._long)
-    })
-
-    return scored.map(s => s.mem)
+  saveMemories(memories) {
+    try {
+      fs.writeFileSync(this._getMemoriesPath(), JSON.stringify(memories, null, 2))
+    } catch (err) {
+      console.error('[Ambient] 保存记忆失败:', err.message)
+    }
   }
 
-  /** 获取最近 N 条 */
-  recent(limit = 10, scope = 'all') {
-    const pool = scope === 'working'
-      ? this._working
-      : scope === 'long'
-        ? this._long
-        : [...this._working, ...this._long]
-    return [...pool].sort((a, b) => b.createdAt - a.createdAt).slice(0, limit)
+  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 []
   }
-
-  getAll()     { return { long: this._long, working: this._working } }
-  clearWorking() { this._working = [] }
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// GoalManager — 增强版（支持子目标）
-// ─────────────────────────────────────────────────────────────────────────────
-
+// ============================================================================
+// GoalManager - 管理目标及其生命周期状态
+// ============================================================================
 class GoalManager {
   constructor(stateStore) {
     this._goals = new Map()
-    this._store = stateStore
-    this._load()
+    this._stateStore = stateStore
+    this._loadGoals()
   }
 
-  _load() {
-    for (const g of this._store.loadGoals()) this._goals.set(g.id, g)
+  _loadGoals() {
+    const savedGoals = this._stateStore.loadGoals()
+    for (const goal of savedGoals) {
+      this._goals.set(goal.id, goal)
+    }
   }
 
   _persist() {
-    this._store.saveGoals(Array.from(this._goals.values()))
+    const goalsArray = Array.from(this._goals.values())
+    this._stateStore.saveGoals(goalsArray)
   }
 
-  createGoal(data, parentId = null) {
+  createGoal(goalData) {
     const goal = {
-      id:            generateId(),
-      title:         data.title || 'Untitled',
-      description:   data.description || '',
-      priority:      data.priority ?? 5,
-      state:         GoalState.PENDING,
-      parentId,                              // 支持子目标树
-      subGoalIds:    [],
-      // 行动模板（LLM 可参考，但不再强制按序执行）
-      actionHints:   data.actions || [],
-      conditions:    data.conditions || {},
-      successCriteria: data.successCriteria || '',
-      createdAt:     Date.now(),
-      updatedAt:     Date.now(),
-      activatedAt:   null,
-      completedAt:   null,
-      failedAt:      null,
-      attempts:      0,
-      maxAttempts:   data.maxAttempts || 15,
-      eventsReceived: [],
-      executionHistory: [],                  // 每次决策记录
-      lastDecisionAt: null
+      id: generateId(),
+      title: goalData.title || '未命名目标',
+      description: goalData.description || '',
+      priority: goalData.priority || 5,
+      state: GoalState.PENDING,
+      actions: goalData.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)
-    if (parentId) {
-      const parent = this._goals.get(parentId)
-      if (parent) {
-        parent.subGoalIds.push(goal.id)
-        parent.updatedAt = Date.now()
-      }
-    }
     this._persist()
     return goal
   }
 
-  getGoal(id)          { return this._goals.get(id) }
-  getAllGoals()         { return Array.from(this._goals.values()) }
-  getActiveGoals()     { return this.getAllGoals().filter(g => g.state === GoalState.ACTIVE) }
-  getPendingGoals()    { return this.getAllGoals().filter(g => g.state === GoalState.PENDING) }
+  getGoal(id) {
+    return this._goals.get(id)
+  }
 
-  updateGoal(id, updates) {
-    const g = this._goals.get(id)
-    if (!g) return null
-    Object.assign(g, updates, { updatedAt: Date.now() })
-    this._persist()
-    return g
+  getAllGoals() {
+    return Array.from(this._goals.values())
   }
 
-  activateGoal(id) {
-    const g = this._goals.get(id)
-    if (!g || g.state !== GoalState.PENDING) return null
-    g.state = GoalState.ACTIVE
-    g.activatedAt = Date.now()
-    g.updatedAt   = Date.now()
-    this._persist()
-    return g
+  getActiveGoals() {
+    return Array.from(this._goals.values()).filter(g => g.state === GoalState.ACTIVE)
   }
 
-  completeGoal(id) {
-    const g = this._goals.get(id)
-    if (!g) return null
-    g.state = GoalState.COMPLETED
-    g.completedAt = Date.now()
-    g.updatedAt   = Date.now()
+  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()
-    // 自动检查父目标：若所有子目标完成则触发回调
-    if (g.parentId) {
-      const parent = this._goals.get(g.parentId)
-      if (parent) {
-        const allDone = parent.subGoalIds.every(sid => {
-          const sub = this._goals.get(sid)
-          return sub && sub.state === GoalState.COMPLETED
-        })
-        if (allDone && parent.state === GoalState.ACTIVE) {
-          this.completeGoal(parent.id)
-        }
-      }
-    }
-    return g
+    return goal
   }
 
-  failGoal(id, reason, type = FailureType.EXECUTION_ERROR) {
-    const g = this._goals.get(id)
-    if (!g) return null
-    g.state = GoalState.FAILED
-    g.failedAt = Date.now()
-    g.failureReason = reason
-    g.failureType   = type
-    g.updatedAt     = Date.now()
+  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 g
+    return goal
   }
 
-  pauseGoal(id) {
-    const g = this._goals.get(id)
-    if (!g || g.state !== GoalState.ACTIVE) return null
-    g.state = GoalState.PAUSED
-    g.updatedAt = Date.now()
+  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 g
+    return goal
   }
 
-  resumeGoal(id) {
-    const g = this._goals.get(id)
-    if (!g || g.state !== GoalState.PAUSED) return null
-    g.state = GoalState.ACTIVE
-    g.updatedAt = Date.now()
+  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 g
+    return goal
   }
 
   deleteGoal(id) {
@@ -324,595 +199,209 @@ class GoalManager {
   }
 
   addEventToGoal(goalId, event) {
-    const g = this._goals.get(goalId)
-    if (!g) return
-    g.eventsReceived.push({ type: event.type, data: event.data, ts: Date.now() })
-    // 只保留最近 20 个事件
-    if (g.eventsReceived.length > 20) g.eventsReceived = g.eventsReceived.slice(-20)
-    this._persist()
-  }
-
-  recordDecision(goalId, decision) {
-    const g = this._goals.get(goalId)
-    if (!g) return
-    g.executionHistory.push({ ...decision, ts: Date.now() })
-    if (g.executionHistory.length > 50) g.executionHistory = g.executionHistory.slice(-50)
-    g.lastDecisionAt = Date.now()
-    g.updatedAt = Date.now()
+    const goal = this._goals.get(goalId)
+    if (!goal) return
+    goal.eventsReceived.push({
+      event: event.event || event.type,
+      timestamp: new Date()
+    })
     this._persist()
   }
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// PriorityScheduler — 多维优先级排序
-// ─────────────────────────────────────────────────────────────────────────────
-
-class PriorityScheduler {
-  /**
-   * 从活跃目标中选出本次 tick 应处理的目标列表
-   * 评分维度：用户优先级 + 待处理事件数 + 等待时间 + 子目标阻塞
-   */
-  schedule(goals) {
-    const now = Date.now()
-
-    return goals
-      .filter(g => g.state === GoalState.ACTIVE)
-      .map(g => {
-        // 1. 用户设定优先级（1-10）
-        const userPriority = (g.priority || 5) * 10
-
-        // 2. 待处理事件加权（有事件的目标应优先处理）
-        const eventBoost = Math.min((g.eventsReceived || []).length * 15, 60)
-
-        // 3. 等待时间加成（防止饥饿）
-        const waitMs     = g.lastDecisionAt ? now - g.lastDecisionAt : now - (g.activatedAt || now)
-        const waitBoost  = Math.min(waitMs / 60000, 20)  // 最多加 20 分，单位：分钟
-
-        // 4. 父目标降权（应先完成子目标）
-        const parentPenalty = (g.subGoalIds && g.subGoalIds.length > 0) ? -10 : 0
-
-        const score = userPriority + eventBoost + waitBoost + parentPenalty
-        return { goal: g, score }
-      })
-      .sort((a, b) => b.score - a.score)
-      .map(s => s.goal)
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// ContextBuilder — 为 LLM 决策聚合上下文
-// ─────────────────────────────────────────────────────────────────────────────
-
-class ContextBuilder {
-  constructor(memory, goalManager) {
-    this._memory      = memory
+// ============================================================================
+// 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接收
+    ])
   }
 
-  /**
-   * 构建用于 DecisionEngine 的完整上下文
-   */
-  build(goal, availableTools) {
-    // 1. 相关记忆
-    const relevantMems = this._memory.search(
-      `${goal.title} ${goal.description}`,
-      { limit: 5, goalId: goal.id }
-    )
-
-    // 2. 最近决策历史
-    const recentHistory = (goal.executionHistory || []).slice(-5)
-
-    // 3. 待处理事件摘要
-    const pendingEvents = (goal.eventsReceived || []).map(e => ({
-      type: e.type,
-      summary: this._summarizeEvent(e),
-      ts: e.ts
-    }))
-
-    // 4. 可用工具列表（简化）
-    const toolSummaries = availableTools.map(t => ({
-      name: t.name,
-      description: (t.description || '').slice(0, 100)
-    }))
-
-    // 5. 子目标状态
-    const subGoals = (goal.subGoalIds || []).map(id => {
-      const sub = this._goalManager.getGoal(id)
-      return sub ? { id: sub.id, title: sub.title, state: sub.state } : null
-    }).filter(Boolean)
-
-    return {
-      goal: {
-        id:              goal.id,
-        title:           goal.title,
-        description:     goal.description,
-        priority:        goal.priority,
-        attempts:        goal.attempts,
-        maxAttempts:     goal.maxAttempts,
-        successCriteria: goal.successCriteria,
-        actionHints:     goal.actionHints || [],
-        state:           goal.state
-      },
-      pendingEvents,
-      recentHistory,
-      relevantMemories: relevantMems.map(m => m.content),
-      subGoals,
-      availableTools:   toolSummaries
-    }
-  }
-
-  _summarizeEvent(event) {
-    if (!event.data) return event.type
-    try {
-      const d = event.data
-      if (typeof d === 'string') return d.slice(0, 200)
-      if (d.subject)  return `邮件: ${d.subject}`
-      if (d.message)  return d.message.slice(0, 200)
-      if (d.body)     return d.body.slice(0, 200)
-      return JSON.stringify(d).slice(0, 200)
-    } catch { return String(event.data).slice(0, 200) }
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// DecisionEngine — 核心：LLM 推理决定下一步行动
-// 取代原版 ExplorerLoop 中的静态 FIFO 队列
-// ─────────────────────────────────────────────────────────────────────────────
-
-class DecisionEngine {
-  constructor(framework, contextBuilder, goalManager, stateStore, config, agent) {
-    this._framework      = framework
-    this._ctx            = contextBuilder
-    this._goalManager    = goalManager
-    this._store          = stateStore
-    this._config         = config
-    this._llmCallTimeout = config.llmCallTimeout || 60000
-    this._agent          = agent  // 专用的 ambient agent
-  }
-
-  /**
-   * 主入口：为指定目标做出决策并返回要执行的 action
-   * @returns {{ action, reasoning, shouldComplete, shouldFail, failReason } | null}
-   */
-  async decide(goal) {
-    const availableTools = this._framework.getTools ? this._framework.getTools() : []
-    const context        = this._ctx.build(goal, availableTools)
-
-    // 构造 LLM prompt
-    const prompt = this._buildDecisionPrompt(context)
-
-    let llmResponse
-    try {
-      // 直接调用 LLM
-      llmResponse = await this._callLLM(prompt)
-    } catch (err) {
-      console.warn('[Ambient] DecisionEngine LLM call failed:', err.message)
-      // 降级：如果 LLM 不可用，回退到 actionHints 队列
-      return this._fallbackDecision(goal)
-    }
+  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)]
+    ]
 
-    // Agent 忙，跳过这次决策
-    if (llmResponse === null) {
-      return null
+    for (const [event, handler] of events) {
+      this._framework.on(event, handler)
+      this._handlers.push({ event, handler })
     }
-
-    // 解析 LLM 返回的 JSON 决策
-    const decision = this._parseDecision(llmResponse, goal)
-
-    // 记录决策到目标历史
-    this._goalManager.recordDecision(goal.id, {
-      reasoning: decision.reasoning,
-      action:    decision.action,
-      llmUsed:   true
-    })
-
-    // 写入执行日志
-    this._store.appendLog({
-      type:    'decision',
-      goalId:  goal.id,
-      goal:    goal.title,
-      decision,
-      ts:      Date.now()
-    })
-
-    return decision
   }
 
-  /**
-   * 构造决策 prompt
-   */
-  _buildDecisionPrompt(context) {
-    const { goal, pendingEvents, recentHistory, relevantMemories, subGoals, availableTools } = context
-
-    const eventsSection = pendingEvents.length > 0
-      ? `\n待处理事件：\n${pendingEvents.map(e => `  - [${e.type}] ${e.summary}`).join('\n')}`
-      : ''
-
-    const historySection = recentHistory.length > 0
-      ? `\n最近执行历史（避免重复）：\n${recentHistory.map(h =>
-          `  - ${h.reasoning || ''} → ${h.action ? h.action.type + ':' + (h.action.name || '') : '无行动'}`
-        ).join('\n')}`
-      : ''
-
-    const memSection = relevantMemories.length > 0
-      ? `\n相关记忆：\n${relevantMemories.map(m => `  - ${m}`).join('\n')}`
-      : ''
-
-    const subSection = subGoals.length > 0
-      ? `\n子目标状态：\n${subGoals.map(s => `  - [${s.state}] ${s.title}`).join('\n')}`
-      : ''
-
-    const toolList = availableTools.map(t => `  - ${t.name}: ${t.description}`).join('\n')
-
-    const hintSection = goal.actionHints.length > 0
-      ? `\n行动参考（可选）：\n${JSON.stringify(goal.actionHints, null, 2)}`
-      : ''
-
-    return `你是一个自主运行的 Agent，负责完成以下目标。
-
-## 当前目标
-标题：${goal.title}
-描述：${goal.description}
-优先级：${goal.priority}/10
-已尝试：${goal.attempts}/${goal.maxAttempts} 次
-成功标准：${goal.successCriteria || '完成目标描述中的任务'}
-${eventsSection}${historySection}${memSection}${subSection}${hintSection}
-
-## 可用工具
-${toolList}
-
-## 决策要求
-请分析当前状态，决定**下一步最优行动**。你必须返回一个 JSON 对象（不含 markdown 代码块）：
-
-{
-  "reasoning": "简短说明为什么选择这个行动（1-2句）",
-  "shouldComplete": false,
-  "shouldFail": false,
-  "failReason": "",
-  "action": {
-    "type": "tool | message | think | wait | create_subgoal",
-    "name": "工具名（type=tool时必填）",
-    "args": {},
-    "content": "消息内容（type=message时）",
-    "topic": "思考主题（type=think时）",
-    "mode": "reflect | plan | analyze（type=think时）",
-    "waitMs": 5000,
-    "subGoal": {
-      "title": "",
-      "description": "",
-      "priority": 5,
-      "actions": []
+  stop() {
+    for (const { event, handler } of this._handlers) {
+      this._framework.off(event, handler)
     }
-  }
-}
-
-注意：
-- 如果目标已完成，设 shouldComplete=true，action 可为 null
-- 如果目标无法完成（缺少工具/权限/信息），设 shouldFail=true 并填写 failReason
-- 如果需要等待更多事件，action.type 设为 "wait"
-- 如果任务可以分解，优先用 create_subgoal 分解
-- 不要重复刚刚执行过的相同行动`
+    this._handlers = []
   }
 
-  /**
-   * 调用 LLM（使用专用的 ambient agent）
-   */
-  async _callLLM(prompt) {
-    const agent = this._agent
-    if (!agent) throw new Error('No ambient agent available')
-
-    // 检查是否忙
-    if (agent._status === 'busy') {
-      throw new Error('busy')
-    }
-
-    try {
-      // 直接调用 chat，不使用队列
-      const result = await agent.chat(prompt)
-      return typeof result === 'string' ? result : JSON.stringify(result)
-    } catch (e) {
-      if (e.message.includes('busy')) {
-        // Agent 忙，跳过这次决策
-        return null
+  _handleEvent(type, data) {
+    const activeGoals = this._goalManager.getActiveGoals()
+    for (const goal of activeGoals) {
+      // 检查目标条件是否匹配此事件
+      if (this._isRelevantToGoal(goal, type, data)) {
+        this._goalManager.addEventToGoal(goal.id, { type, data })
       }
-      throw new Error('LLM call failed: ' + e.message)
     }
   }
 
-  /**
-   * 解析 LLM 返回的 JSON 决策
-   */
-  _parseDecision(raw, goal) {
-    try {
-      // 移除思考标签
-      let text = (raw || '').replace(/<think>[\s\S]*?<\/think>/g, '')
-
-      // 尝试提取 JSON 对象
-      const jsonMatch = text.match(/\{[\s\S]*\}/)
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0])
-
-        // 检查是否是外层包装格式 { success: true, message: "{...}" }
-        if (parsed.message && typeof parsed.message === 'string') {
-          const innerText = parsed.message.replace(/<think>[\s\S]*?<\/think>/g, '')
-          const innerMatch = innerText.match(/\{[\s\S]*\}/)
-          if (innerMatch) {
-            const inner = JSON.parse(innerMatch[0])
-            return inner
-          }
-        }
-
-        return parsed
+  _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
       }
-
-      // 尝试移除 markdown 代码块
-      const cleaned = text.replace(/```(?:json)?\n?/g, '').trim()
-      if (cleaned.startsWith('{')) {
-        const parsed = JSON.parse(cleaned)
-        return parsed
-      }
-
-      throw new Error('No JSON found in response')
-    } catch (e) {
-      console.warn('[Ambient] Failed to parse LLM decision, using fallback:', e.message)
-      return this._fallbackDecision(goal)
     }
-  }
-
-  /**
-   * 降级决策：LLM 不可用时，回退到 actionHints 队列
-   */
-  _fallbackDecision(goal) {
-    // actionHints 是文本提示，不是可执行的动作对象
-    // 降级时应该等待，让 LLM 稍后重新决策
-    return {
-      reasoning: 'LLM 不可用或解析失败，等待一下再试',
-      shouldComplete: false,
-      shouldFail: false,
-      action: { type: 'wait', waitMs: 5000 }
+    // 检查工具名称过滤器
+    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 v2 — 失败分类 + 差异化恢复策略
-// ─────────────────────────────────────────────────────────────────────────────
-
+// ============================================================================
+// Reflector - 评估操作结果，更新目标状态
+// ============================================================================
 class Reflector {
-  constructor(goalManager, memory, stateStore) {
+  constructor(goalManager) {
     this._goalManager = goalManager
-    this._memory      = memory
-    this._store       = stateStore
   }
 
-  /**
-   * 评估行动结果，返回恢复策略
-   */
-  evaluate(goal, actionResult, decision) {
-    const now = Date.now()
+  evaluateOutcome(goal, actionResult) {
+    if (!goal) return null
 
-    // —— 成功路径 ——
-    if (actionResult && actionResult.success !== false && !actionResult.error) {
+    // 检查错误
+    if (actionResult && actionResult.error) {
+      // 增加尝试次数但不立即失败
       goal.attempts++
-      // 将结果摘要写入工作记忆
-      this._memory.store(
-        `[${goal.title}] 行动成功: ${decision.reasoning} → ${JSON.stringify(actionResult).slice(0, 200)}`,
-        { scope: 'working', goalId: goal.id, tags: ['success'] }
-      )
-      this._store.appendLog({ type: 'action_success', goalId: goal.id, ts: now, result: String(actionResult).slice(0, 300) })
-      return { status: 'continue', actionSucceeded: true }
-    }
-
-    // —— 失败路径：分类处理 ——
-    goal.attempts++
-    const errMsg = (actionResult && actionResult.error) ? actionResult.error : 'unknown error'
-    const ftype  = this._classifyError(errMsg, actionResult)
-
-    this._memory.store(
-      `[${goal.title}] 行动失败(${ftype}): ${errMsg.slice(0, 200)}`,
-      { scope: 'working', goalId: goal.id, tags: ['failure', ftype] }
-    )
-    this._store.appendLog({ type: 'action_failure', goalId: goal.id, ftype, err: errMsg, ts: now })
-
-    // 超出最大尝试次数
-    if (goal.attempts >= goal.maxAttempts) {
-      return { status: 'fail', reason: `超出最大尝试次数(${goal.maxAttempts})`, type: FailureType.MAX_ATTEMPTS }
+      return {
+        shouldContinue: goal.attempts < goal.maxAttempts,
+        actionTaken: false
+      }
     }
 
-    // 不同错误类型的恢复策略
-    switch (ftype) {
-      case FailureType.TOOL_NOT_FOUND:
-        // 工具不存在 → 立即失败，不重试
-        return { status: 'fail', reason: `工具不存在: ${errMsg}`, type: ftype }
-
-      case FailureType.TIMEOUT:
-        // 超时 → 指数退避后重试
-        return { status: 'retry', backoffMs: Math.min(5000 * Math.pow(2, goal.attempts), 60000) }
+    // 检查是否成功完成
+    if (actionResult && actionResult.success === true) {
+      goal.attempts++
 
-      case FailureType.LLM_REFUSED:
-        // LLM 拒绝 → 标记失败
-        return { status: 'fail', reason: errMsg, type: ftype }
+      // 检查目标是否完成
+      if (goal.actions.length === 0 || goal.attempts >= goal.maxAttempts) {
+        return { shouldContinue: false, goalComplete: true }
+      }
 
-      default:
-        // 一般执行错误 → 继续，让 DecisionEngine 重新决策
-        return { status: 'continue', actionSucceeded: false, error: errMsg }
+      return { shouldContinue: true, actionTaken: true }
     }
-  }
-
-  _classifyError(errMsg, result) {
-    if (!errMsg) return FailureType.EXECUTION_ERROR
-    const msg = errMsg.toLowerCase()
-    if (msg.includes('not found') || msg.includes('no tool'))   return FailureType.TOOL_NOT_FOUND
-    if (msg.includes('timeout'))                                 return FailureType.TIMEOUT
-    if (msg.includes('refused') || msg.includes('not allowed')) return FailureType.LLM_REFUSED
-    return FailureType.EXECUTION_ERROR
-  }
-}
 
-// ─────────────────────────────────────────────────────────────────────────────
-// ActionExecutor — 执行层（增加超时控制）
-// ─────────────────────────────────────────────────────────────────────────────
-
-class ActionExecutor {
-  constructor(framework, config) {
-    this._framework = framework
-    this._timeout   = config.actionTimeout || 20000
-  }
-
-  async execute(action, eventData) {
-    if (!action || !action.type) return { success: false, error: 'Invalid action' }
+    // 工具执行无错误 - 视为成功
+    goal.attempts++
 
-    try {
-      return await Promise.race([
-        this._run(action, eventData),
-        new Promise((_, rej) => setTimeout(() => rej(new Error('Action execution timeout')), this._timeout))
-      ])
-    } catch (err) {
-      return { success: false, error: err.message }
+    // 检查目标是否完成（没有更多操作）
+    if (goal.actions.length === 0 || goal.attempts >= goal.maxAttempts) {
+      return { shouldContinue: false, goalComplete: true }
     }
-  }
-
-  async _run(action, eventData) {
-    switch (action.type) {
-      case 'tool': {
-        if (!action.name) return { success: false, error: 'Tool name required' }
-        const tools = this._framework.getTools ? this._framework.getTools() : []
-        const tool  = tools.find(t => t.name === action.name)
-        if (!tool) return { success: false, error: `Tool not found: ${action.name}` }
-        const args = { ...(action.args || {}) }
-        if (eventData) args._event = eventData
-        return tool.execute(args, this._framework)
-      }
 
-      case 'message': {
-        const agent = this._getAgent()
-        if (!agent) return { success: false, error: 'No active agent' }
-        let content = action.content || ''
-        if (eventData) content += `\n\n[Event: ${JSON.stringify(eventData).slice(0, 300)}]`
-        const result = await agent.pushMessage(content)
-        return { success: true, result }
-      }
+    return { shouldContinue: true, actionTaken: true }
+  }
 
-      case 'think': {
-        const thinkPlugin = this._framework.pluginManager && this._framework.pluginManager.get('think')
-        if (!thinkPlugin) return { success: false, error: 'Think plugin not available' }
-        return thinkPlugin._triggerThinking({
-          topic: action.topic || 'Ambient agent reflection',
-          mode:  action.mode  || 'reflect',
-          depth: action.depth || 2
-        })
+  checkLoopDetection(goal, actionId) {
+    // 如果同一操作连续重复3次，则目标失败
+    if (goal.lastActionId === actionId) {
+      goal.consecutiveSameActions++
+      if (goal.consecutiveSameActions >= 3) {
+        this._goalManager.failGoal(goal.id, '检测到循环：同一操作连续重复3次')
+        return true
       }
-
-      case 'wait':
-        // 显式等待
-        await new Promise(resolve => setTimeout(resolve, action.waitMs || 5000))
-        return { success: true, waited: action.waitMs || 5000 }
-
-      case 'create_subgoal':
-        // 由 ExplorerLoop 处理，此处仅返回标记
-        return { success: true, isSubGoalRequest: true, subGoal: action.subGoal }
-
-      default:
-        return { success: false, error: `Unknown action type: ${action.type}` }
+    } else {
+      goal.consecutiveSameActions = 1
+      goal.lastActionId = actionId
     }
-  }
-
-  _getAgent() {
-    if (this._framework._mainAgent) return this._framework._mainAgent
-    const agents = this._framework._agents || []
-    return agents.length > 0 ? agents[agents.length - 1] : null
+    return false
   }
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// EventWatcher — 同原版，增加优先级权重传递
-// ─────────────────────────────────────────────────────────────────────────────
-
-class EventWatcher {
-  constructor(goalManager, framework) {
+// ============================================================================
+// ExplorerLoop - 主自主循环，决定并执行操作
+// ============================================================================
+class ExplorerLoop {
+  constructor(goalManager, reflector, framework, config) {
     this._goalManager = goalManager
-    this._framework   = framework
-    this._handlers    = []
-    this._watchedEvents = [
-      'tool:result', 'scheduler:reminder', 'agent:message',
-      'think:thought_completed', 'scheduler:task_completed',
-      'scheduler:task_failed', 'email:received', 'webhook:received'
-    ]
+    this._reflector = reflector
+    this._framework = framework
+    this._config = config
+    this._running = false
+    this._timer = null
+    this._lastActionTime = 0
+    this._tickCount = 0
+    this._recentActivities = []
   }
 
   start() {
-    for (const type of this._watchedEvents) {
-      this._handlers.push(
-        this._framework.on(type, (data) => this._handle(type, data))
-      )
-    }
+    if (this._running) return
+    this._running = true
+    this._scheduleNext()
   }
 
   stop() {
-    for (const h of this._handlers) h()
-    this._handlers = []
+    this._running = false
+    if (this._timer) {
+      clearTimeout(this._timer)
+      this._timer = null
+    }
   }
 
-  _handle(type, data) {
-    const all = [
-      ...this._goalManager.getActiveGoals(),
-      ...this._goalManager.getPendingGoals()
-    ]
-    for (const goal of all) {
-      if (this._isRelevant(goal, type, data)) {
-        if (goal.state === GoalState.PENDING) this._goalManager.activateGoal(goal.id)
-        this._goalManager.addEventToGoal(goal.id, { type, data })
-      }
+  pause() {
+    this._running = false
+    if (this._timer) {
+      clearTimeout(this._timer)
+      this._timer = null
     }
   }
 
-  _isRelevant(goal, eventType, data) {
-    const conds = goal.conditions || {}
-    if (conds.events) {
-      const allowed = Array.isArray(conds.events) ? conds.events : [conds.events]
-      if (!allowed.includes(eventType)) return false
+  resume() {
+    if (!this._running) {
+      this._running = true
+      this._scheduleNext()
     }
-    if (conds.toolNames && data && data.toolName) {
-      const names = Array.isArray(conds.toolNames) ? conds.toolNames : [conds.toolNames]
-      if (!names.includes(data.toolName)) return false
-    }
-    return true
   }
-}
 
-// ─────────────────────────────────────────────────────────────────────────────
-// ExplorerLoop v2 — 集成 DecisionEngine 的主循环
-// ─────────────────────────────────────────────────────────────────────────────
-
-class ExplorerLoop {
-  constructor(goalManager, decisionEngine, reflector, executor, scheduler, memory, config) {
-    this._goalManager     = goalManager
-    this._decisionEngine  = decisionEngine
-    this._reflector       = reflector
-    this._executor        = executor
-    this._scheduler       = scheduler
-    this._memory          = memory
-    this._config          = config
-    this._running         = false
-    this._timer           = null
-    this._tickCount       = 0
-    this._recentActivities = []
-    this._backoffMap      = new Map()  // goalId → 退避到期时间
+  isRunning() {
+    return this._running
   }
 
-  start()  { if (!this._running) { this._running = true; this._scheduleNext() } }
-  stop()   { this._running = false; if (this._timer) { clearTimeout(this._timer); this._timer = null } }
-  pause()  { this.stop() }
-  resume() { this.start() }
-  isRunning() { return this._running }
-
   getStatus() {
     return {
-      running:          this._running,
-      tickCount:        this._tickCount,
-      activeGoals:      this._goalManager.getActiveGoals().length,
-      pendingGoals:     this._goalManager.getPendingGoals().length,
-      recentActivities: this._recentActivities.slice(-10)
+      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
     }
   }
 
@@ -923,435 +412,731 @@ class ExplorerLoop {
 
   async _tick() {
     if (!this._running) return
-    this._tickCount++
 
+    // 如果处于嵌套执行上下文中，跳过此tick
     try {
-      // 自动激活无条件的 pending 目标
-      for (const g of this._goalManager.getPendingGoals()) {
-        if (!g.conditions || Object.keys(g.conditions).length === 0) {
-          this._goalManager.activateGoal(g.id)
-          this._log('goal_activated', { goalId: g.id, title: g.title })
+      if (this._framework.getExecutionContext) {
+        const ctx = this._framework.getExecutionContext()
+        if (ctx && ctx.id) {
+          // 跳过此tick，重新调度
+          this._scheduleNext()
+          return
         }
       }
+    } catch (e) {
+      // getExecutionContext可能不存在，继续执行
+    }
 
-      // 调度：按优先级排序活跃目标
-      const activeGoals = this._scheduler.schedule(this._goalManager.getActiveGoals())
-
-      for (const goal of activeGoals) {
-        // 退避检查
-        const backoffUntil = this._backoffMap.get(goal.id)
-        if (backoffUntil && Date.now() < backoffUntil) continue
+    this._tickCount++
+    
 
-        await this._processGoal(goal)
-      }
+    try {
+      await this._processGoals()
     } catch (err) {
-      console.error('[Ambient] Tick error:', err.message)
-      this._log('tick_error', { message: err.message })
+      console.error('[Ambient] Tick错误:', err.message)
+      this._addActivity('error', { message: err.message })
     }
-
+    this._lastActionTime = Date.now()
+    // 调度下一次tick
     this._scheduleNext()
   }
 
-  async _processGoal(goal) {
-    const isEventDriven = goal.conditions && goal.conditions.events && goal.conditions.events.length > 0
-    const hasEvents     = (goal.eventsReceived || []).length > 0
+  async _processGoals() {
+    const activeGoals = this._goalManager.getActiveGoals()
 
-    // 事件驱动目标：无待处理事件则跳过
-    if (isEventDriven && !hasEvents) return
+    for (const goal of activeGoals) {
+      // 检查冷却时间
+      if (Date.now() - this._lastActionTime < this._config.cooldownPeriod) {
+        continue
+      }
 
-    // ── 1. DecisionEngine 决策 ──
-    let decision
-    try {
-      decision = await this._decisionEngine.decide(goal)
-    } catch (err) {
-      this._log('decision_error', { goalId: goal.id, error: err.message })
-      return
-    }
+      // 检查目标是否有未处理的事件
+      const hasNewEvents = goal.eventsReceived && goal.eventsReceived.length > 0
 
-    if (!decision) return
+      // 获取下一个操作
+      if (goal.actions && goal.actions.length > 0) {
+        const action = goal.actions[0] // 简单策略：取第一个操作
 
-    // ── 2. 处理决策结果 ──
-    if (decision.shouldComplete) {
-      this._goalManager.completeGoal(goal.id)
-      this._memory.store(`目标完成: ${goal.title}`, { goalId: goal.id, tags: ['completed'] })
-      this._log('goal_completed', { goalId: goal.id, title: goal.title })
-      return
-    }
+        // 循环检测（仅用于非事件驱动的操作）
+        if (!hasNewEvents && this._reflector.checkLoopDetection(goal, action.id)) {
+          this._addActivity('goal_failed', { goalId: goal.id, reason: '检测到循环' })
+          // 通知用户目标失败
+          this._notifyUser('目标失败', `目标 "${goal.title}" 失败：检测到循环（同一操作连续重复）`, 'error')
+          continue
+        }
 
-    if (decision.shouldFail) {
-      this._goalManager.failGoal(goal.id, decision.failReason || 'LLM decided to fail')
-      this._log('goal_failed', { goalId: goal.id, reason: decision.failReason })
-      return
-    }
+        // 执行操作
+        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) {
+          // 从队列中移除已完成的操作
+          goal.actions.shift()
+          this._addActivity('action_executed', { goalId: goal.id, action: action.id, hasEvents: hasNewEvents })
+        }
 
-    const action = decision.action
-    if (!action || action.type === 'wait') {
-      this._log('action_wait', { goalId: goal.id, reasoning: decision.reasoning })
-      this._clearEvents(goal)
-      return
+        // 执行操作后清除已处理的事件
+        if (hasNewEvents && outcome.actionTaken) {
+          goal.eventsReceived = []
+          this._goalManager.updateGoal(goal.id, { eventsReceived: [] })
+        }
+      }
     }
 
-    // ── 3. 子目标分解 ──
-    if (action.type === 'create_subgoal' && action.subGoal) {
-      const subGoal = this._goalManager.createGoal(action.subGoal, goal.id)
-      this._goalManager.activateGoal(subGoal.id)
-      this._log('subgoal_created', { parentId: goal.id, subGoalId: subGoal.id, title: subGoal.title })
-      this._clearEvents(goal)
-      return
+    // 激活满足条件的待处理目标
+    const pendingGoals = this._goalManager.getPendingGoals()
+    for (const goal of pendingGoals) {
+      // 自动激活没有条件或条件已满足的目标
+      if (!goal.conditions || Object.keys(goal.conditions).length === 0) {
+        this._goalManager.activateGoal(goal.id)
+        this._addActivity('goal_activated', { goalId: goal.id })
+      }
     }
+  }
 
-    // ── 4. 执行行动 ──
-    const eventData = hasEvents ? goal.eventsReceived[0] : null
-    this._log('action_start', { goalId: goal.id, type: action.type, name: action.name })
-
-    const result  = await this._executor.execute(action, eventData)
-    const outcome = this._reflector.evaluate(goal, result, decision)
-
-    // ── 5. 处理评估结果 ──
-    switch (outcome.status) {
-      case 'fail':
-        this._goalManager.failGoal(goal.id, outcome.reason, outcome.type)
-        this._log('goal_failed', { goalId: goal.id, reason: outcome.reason })
-        break
-
-      case 'retry':
-        this._backoffMap.set(goal.id, Date.now() + (outcome.backoffMs || 5000))
-        this._log('action_backoff', { goalId: goal.id, backoffMs: outcome.backoffMs })
-        break
+  async _executeAction(action, eventData = null) {
+    if (!this._framework) {
+      return { success: false, error: '框架不可用' }
+    }
 
-      case 'continue':
-      default:
-        this._log('action_done', {
-          goalId:    goal.id,
-          succeeded: outcome.actionSucceeded,
-          type:      action.type
-        })
-        // 事件驱动目标：执行后重置（继续等待下次事件）
-        if (isEventDriven) {
-          this._goalManager.updateGoal(goal.id, { attempts: 0 })
+    try {
+      if (action.type === 'tool') {
+        // 使用 getTools() 返回数组，按名称查找
+        const tools = this._framework.getTools()
+        const tool = tools.find(t => t.name === action.name)
+        if (!tool) {
+          return { success: false, error: `未找到工具: ${action.name}` }
         }
-        break
+        // 如果有事件数据，合并到参数中
+        const args = { ...action.args }
+        if (eventData) {
+          args._event = eventData
+        }
+        const result = await tool.execute(args, this._framework)
+        return result
+      } else if (action.type === 'message') {
+        const agent = this._getActiveAgent()
+        if (!agent) {
+          return { success: false, error: '没有可用的代理' }
+        }
+        // 如果有事件上下文，将其包含在消息中
+        let content = action.content
+        if (eventData) {
+          content = `${action.content}\n\n[事件上下文: ${JSON.stringify(eventData)}]`
+        }
+        const result = await agent.pushMessage(content)
+        return { success: true, result }
+      } else if (action.type === 'think') {
+        // 触发思考
+        const thinkPlugin = this._framework.pluginManager.get('think')
+        if (thinkPlugin) {
+          // 如果有事件上下文，将其包含在主题中
+          let topic = action.topic || 'Ambient代理反思'
+          if (eventData) {
+            topic = `${topic}\n\n[事件上下文: ${JSON.stringify(eventData)}]`
+          }
+          const result = await thinkPlugin._triggerThinking({
+            topic,
+            mode: action.mode || 'reflect',
+            depth: action.depth || 2
+          })
+          return result
+        }
+        return { success: false, error: '思考插件不可用' }
+      }
+
+      return { success: false, error: `未知的操作类型: ${action.type}` }
+    } catch (err) {
+      return { success: false, error: err.message }
     }
+  }
 
-    this._clearEvents(goal)
+  _getActiveAgent() {
+    if (this._framework._mainAgent) {
+      return this._framework._mainAgent
+    }
+    const agents = this._framework._agents || []
+    return agents.length > 0 ? agents[agents.length - 1] : null
   }
 
-  _clearEvents(goal) {
-    if ((goal.eventsReceived || []).length > 0) {
-      this._goalManager.updateGoal(goal.id, { eventsReceived: [] })
+  _addActivity(type, data) {
+    this._recentActivities.push({
+      type,
+      data,
+      timestamp: new Date()
+    })
+    // 只保留最近50条活动记录
+    if (this._recentActivities.length > 50) {
+      this._recentActivities = this._recentActivities.slice(-50)
     }
   }
 
-  _log(type, data) {
-    const entry = { type, data, ts: Date.now() }
-    this._recentActivities.push(entry)
-    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}`)
   }
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// AmbientAgentPlugin v2 — 主插件类
-// ─────────────────────────────────────────────────────────────────────────────
-
+// ============================================================================
+// 主插件类
+// ============================================================================
 class AmbientAgentPlugin extends Plugin {
   constructor(config = {}) {
     super()
-    this.name        = 'ambient'
-    this.version     = '2.0.0'
-    this.description = 'Ambient Agent v2 — 自主执行引擎（LLM 推理 + 优先级调度）'
-    this.priority    = 18
-    this.system      = true
+    this.name = 'ambient'
+    this.version = '1.0.0'
+    this.description = 'Ambient Agent - 持续后台运行的智能代理，用于主动监控和执行操作'
+    this.priority = 18
+    this.system = true
 
     this.config = {
-      enabled:        config.enabled !== false,
-      tickInterval:   config.tickInterval  || 5000,
-      cooldownPeriod: config.cooldownPeriod || 3000,
+      enabled: config.enabled !== false,
+      tickInterval: config.tickInterval || 5000,      // tick间隔（毫秒）
+      cooldownPeriod: config.cooldownPeriod || 3000,  // 冷却时间（毫秒）
       persistencePath: config.persistencePath || '.agent/data/ambient',
-      defaultGoals:   config.defaultGoals || [],
-      llmCallTimeout: config.llmCallTimeout || 30000,
-      actionTimeout:  config.actionTimeout  || 20000
+      defaultGoals: config.defaultGoals || []
     }
 
-    this._framework      = null
-    this._stateStore     = null
-    this._goalManager    = null
-    this._memory         = null
-    this._contextBuilder = null
-    this._decisionEngine = null
-    this._reflector      = null
-    this._executor       = null
-    this._scheduler      = null
-    this._eventWatcher   = null
-    this._explorerLoop   = null
+    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._memory         = new SemanticMemory(this._stateStore)
-    this._contextBuilder = new ContextBuilder(this._memory, this._goalManager)
-    this._reflector      = new Reflector(this._goalManager, this._memory, this._stateStore)
-    this._executor       = new ActionExecutor(framework, this.config)
-    this._scheduler      = new PriorityScheduler()
+    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) return this
-
-    // 创建专用的子 Agent 用于 ambient 决策（不干扰主 Agent）
-    this._ambientAgent = framework.createAgent({
-      name: 'ambient-decision',
-      systemPrompt: '你是一个任务决策助手。根据目标和当前状态，返回最优行动决策（JSON格式）。',
-      model: framework._mainAgent?.model || 'deepseek-chat',
-      apiKey: framework._mainAgent?.apiKey,
-      provider: framework._mainAgent?.provider,
-      baseURL: framework._mainAgent?.baseURL
-    })
-
-    this._decisionEngine = new DecisionEngine(framework, this._contextBuilder, this._goalManager, this._stateStore, this.config, this._ambientAgent)
+    if (!this.config.enabled) {
+      console.log('[Ambient] 插件已禁用，跳过启动')
+      return this
+    }
 
+    // 如果没有现有目标，创建默认目标
     if (this._goalManager.getAllGoals().length === 0 && this.config.defaultGoals.length > 0) {
-      for (const g of this.config.defaultGoals) this._goalManager.createGoal(g)
+      for (const goalDef of this.config.defaultGoals) {
+        this._goalManager.createGoal(goalDef)
+      }
     }
 
+    // 启动事件监听器
     this._eventWatcher = new EventWatcher(this._goalManager, this._framework)
     this._eventWatcher.start()
 
-    this._explorerLoop = new ExplorerLoop(
-      this._goalManager,
-      this._decisionEngine,
-      this._reflector,
-      this._executor,
-      this._scheduler,
-      this._memory,
-      { tickInterval: this.config.tickInterval }
-    )
+    // 动态更新description显示支持的事件
+    const events = Array.from(this._eventWatcher._relevantEvents).join(', ')
+    this.description = `Ambient Agent - 持续后台运行的智能代理，用于主动监控和执行操作
+支持的事件：${events}`
+
+    // 启动探索循环
+    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 ──
+    // ambient_goals - 列出/创建/更新/删除目标
     framework.registerTool({
       name: 'ambient_goals',
-      description: '管理 Ambient Agent 目标 — 列出/创建/更新/删除/激活/暂停/恢复/分解子目标',
+      description: '管理Ambient Agent目标 - 列出、创建、更新、删除、激活目标',
       inputSchema: z.object({
-        action: z.enum(['list', 'create', 'update', 'delete', 'activate', 'pause', 'resume', 'create_subgoal']),
-        goalId:          z.string().optional(),
-        parentId:        z.string().optional().describe('父目标 ID（create_subgoal 时使用）'),
-        title:           z.string().optional(),
-        description:     z.string().optional(),
-        priority:        z.number().optional(),
-        successCriteria: z.string().optional().describe('明确的成功标准，供 LLM 判断完成'),
-        actions:         z.array(z.any()).optional().describe('行动提示（LLM 参考，非强制）'),
-        conditions:      z.object({
-          events:    z.union([z.string(), z.array(z.string())]).optional(),
-          toolNames: z.union([z.string(), z.array(z.string())]).optional()
-        }).optional(),
-        maxAttempts: z.number().optional()
+        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) => this._handleGoalsTool(args)
+      execute: async (args) => {
+        return this._handleGoalsTool(args)
+      }
     })
 
-    // ── ambient_status ──
+    // ambient_status - 获取当前循环状态
     framework.registerTool({
       name: 'ambient_status',
-      description: '获取 Ambient Agent 运行状态 — 循环状态/活跃目标/最近活动/执行日志',
+      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({
-        includeLog: z.boolean().optional().describe('是否包含执行日志（最近 20 条）')
+        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) => this._handleStatusTool(args)
+      execute: async (args) => {
+        return this._handleThinkTool(args)
+      }
     })
 
-    // ── ambient_remember ──
+    // ambient_remember - 存储/检索/搜索持久化记忆
     framework.registerTool({
       name: 'ambient_remember',
-      description: '操作 Ambient Agent 语义记忆 — 存储/检索/搜索',
+      description: '为Ambient Agent存储或检索持久化记忆',
       inputSchema: z.object({
-        action:  z.enum(['store', 'retrieve', 'search']),
-        content: z.string().optional(),
-        key:     z.string().optional(),
-        tags:    z.array(z.string()).optional(),
-        scope:   z.enum(['long', 'working', 'all']).optional(),
-        goalId:  z.string().optional(),
-        query:   z.string().optional(),
-        limit:   z.number().optional()
+        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) => this._handleRememberTool(args)
+      execute: async (args) => {
+        return this._handleRememberTool(args)
+      }
     })
 
-    // ── ambient_control ──
+    // ambient_control - 暂停/恢复/调整探索循环
     framework.registerTool({
       name: 'ambient_control',
-      description: '控制 Ambient Agent — 暂停/恢复/调整参数',
+      description: '控制Ambient Agent探索循环 - 暂停、恢复或调整设置',
       inputSchema: z.object({
-        action:         z.enum(['pause', 'resume', 'status', 'adjust', 'clear_log']),
-        tickInterval:   z.number().optional(),
-        cooldownPeriod: z.number().optional(),
-        llmCallTimeout: z.number().optional()
+        action: z.enum(['pause', 'resume', 'status', 'adjust']).describe('控制操作'),
+        tickInterval: z.number().optional().describe('新的tick间隔毫秒数（adjust时使用）'),
+        cooldownPeriod: z.number().optional().describe('新的冷却时间毫秒数（adjust时使用）')
       }),
-      execute: async (args) => this._handleControlTool(args)
+      execute: async (args) => {
+        return this._handleControlTool(args)
+      }
     })
   }
 
   _handleGoalsTool(args) {
-    const { action, goalId, parentId, title, description, priority,
-            successCriteria, actions, conditions, maxAttempts } = args
+    const { action, goalId, title, description, priority, actions, conditions } = args
 
     switch (action) {
       case 'list': {
-        const all = this._goalManager.getAllGoals()
+        const allGoals = this._goalManager.getAllGoals()
         return {
           success: true,
-          goals:   all.map(g => ({
-            id: g.id, title: g.title, state: g.state,
-            priority: g.priority, attempts: g.attempts,
-            parentId: g.parentId, subGoalCount: (g.subGoalIds || []).length,
-            eventsQueued: (g.eventsReceived || []).length,
-            lastDecisionAt: g.lastDecisionAt
+          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
           })),
-          stats: {
-            total:     all.length,
-            active:    all.filter(g => g.state === GoalState.ACTIVE).length,
-            pending:   all.filter(g => g.state === GoalState.PENDING).length,
-            completed: all.filter(g => g.state === GoalState.COMPLETED).length,
-            failed:    all.filter(g => g.state === GoalState.FAILED).length
-          }
+          total: allGoals.length,
+          active: this._goalManager.getActiveGoals().length,
+          pending: this._goalManager.getPendingGoals().length
         }
       }
+
       case 'create': {
-        if (!title) return { success: false, error: 'title is required' }
-        const goal = this._goalManager.createGoal({ title, description, priority, actions, conditions, maxAttempts, successCriteria })
+        if (!title) {
+          return { success: false, error: '创建目标需要提供标题' }
+        }
+        const goal = this._goalManager.createGoal({ title, description, priority, actions, conditions })
         return { success: true, goal }
       }
-      case 'create_subgoal': {
-        if (!parentId) return { success: false, error: 'parentId is required' }
-        if (!title)    return { success: false, error: 'title is required' }
-        const sub = this._goalManager.createGoal({ title, description, priority, actions, conditions, maxAttempts, successCriteria }, parentId)
-        return { success: true, goal: sub }
-      }
+
       case 'update': {
-        if (!goalId) return { success: false, error: 'goalId is required' }
+        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.actionHints     = actions
-        if (conditions !== undefined)      updates.conditions      = conditions
-        if (successCriteria !== undefined) updates.successCriteria = successCriteria
-        if (maxAttempts !== undefined)     updates.maxAttempts     = maxAttempts
-        const g = this._goalManager.updateGoal(goalId, updates)
-        return g ? { success: true, goal: g } : { success: false, error: 'Goal not found' }
+        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: '目标未找到或不是待激活状态' }
       }
-      case 'delete':   { if (!goalId) return { success: false, error: 'goalId required' }; return { success: this._goalManager.deleteGoal(goalId) } }
-      case 'activate': { if (!goalId) return { success: false, error: 'goalId required' }; const g = this._goalManager.activateGoal(goalId); return g ? { success: true, goal: g } : { success: false, error: 'Not found or not pending' } }
-      case 'pause':    { if (!goalId) return { success: false, error: 'goalId required' }; const g = this._goalManager.pauseGoal(goalId);    return g ? { success: true, goal: g } : { success: false, error: 'Not found or not active' } }
-      case 'resume':   { if (!goalId) return { success: false, error: 'goalId required' }; const g = this._goalManager.resumeGoal(goalId);   return g ? { success: true, goal: g } : { success: false, error: 'Not found or not paused' } }
-      default: return { success: false, error: `Unknown action: ${action}` }
+
+      default:
+        return { success: false, error: `未知操作: ${action}` }
     }
   }
 
-  _handleStatusTool(args = {}) {
-    const loop = this._explorerLoop
-    if (!loop) return { success: false, error: 'Loop not initialized' }
+  _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
+    }))
 
-    const status = loop.getStatus()
-    const result = {
+    return {
       success: true,
       loop: {
-        running:      status.running,
-        tickCount:    status.tickCount,
-        activeGoals:  status.activeGoals,
-        pendingGoals: status.pendingGoals,
-        config: {
-          tickInterval:   this.config.tickInterval,
-          llmCallTimeout: this.config.llmCallTimeout,
-          actionTimeout:  this.config.actionTimeout
-        }
+        running: loopStatus.running,
+        tickCount: loopStatus.tickCount,
+        lastTick: loopStatus.lastTick,
+        tickInterval: this.config.tickInterval,
+        cooldownPeriod: this.config.cooldownPeriod
       },
-      goals: {
-        active:  this._goalManager.getActiveGoals().map(g => ({
-          id: g.id, title: g.title, priority: g.priority,
-          attempts: g.attempts, eventsQueued: (g.eventsReceived || []).length,
-          lastDecisionAt: g.lastDecisionAt
-        })),
-        pending: this._goalManager.getPendingGoals().map(g => ({ id: g.id, title: g.title }))
-      },
-      recentActivities: status.recentActivities
+      activeGoals,
+      pendingGoals,
+      recentActivities: loopStatus.recentActivities
     }
+  }
+
+  async _handleThinkTool(args) {
+    const { goalId, mode, topic, depth } = args
 
-    if (args.includeLog) {
-      result.executionLog = this._stateStore.loadLog().slice(-20)
+    // 获取活跃代理
+    const agent = this._getActiveAgent()
+    if (!agent) {
+      return { success: false, error: '没有可用的活跃代理' }
     }
 
-    return result
+    // 构建思考提示
+    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, tags, scope, goalId, query, limit } = args
+    const { action, content, key, query, limit } = args
+    const maxResults = limit || 10
 
     switch (action) {
       case 'store': {
-        if (!content) return { success: false, error: 'content required' }
-        const mem = this._memory.store(content, { key, tags, scope: scope || 'long', goalId })
-        return { success: true, memory: mem }
+        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 mems = this._memory.recent(limit || 10, scope || 'all')
-        return { success: true, memories: mems, total: mems.length }
+        const memories = this._memories.slice(-maxResults).reverse()
+        return {
+          success: true,
+          memories,
+          total: this._memories.length
+        }
       }
+
       case 'search': {
-        if (!query) return { success: false, error: 'query required' }
-        const results = this._memory.search(query, { limit: limit || 10, scope: scope || 'all', goalId, tags })
-        return { success: true, results, total: results.length }
+        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: `Unknown action: ${action}` }
+
+      default:
+        return { success: false, error: `未知操作: ${action}` }
     }
   }
 
   _handleControlTool(args) {
-    const { action, tickInterval, cooldownPeriod, llmCallTimeout } = args
-    const loop = this._explorerLoop
+    const { action, tickInterval, cooldownPeriod } = args
 
     switch (action) {
-      case 'pause':   { if (!loop) return { success: false }; loop.pause();  return { success: true, message: 'Paused' } }
-      case 'resume':  { if (!loop) return { success: false }; loop.resume(); return { success: true, message: 'Resumed' } }
-      case 'status':  return this._handleStatusTool()
-      case 'adjust': {
-        if (tickInterval)   this.config.tickInterval   = tickInterval
-        if (cooldownPeriod) this.config.cooldownPeriod = cooldownPeriod
-        if (llmCallTimeout) { this.config.llmCallTimeout = llmCallTimeout; this._decisionEngine._llmCallTimeout = llmCallTimeout }
-        return { success: true, config: this.config }
+      case 'pause': {
+        if (!this._explorerLoop) {
+          return { success: false, error: '探索循环未初始化' }
+        }
+        this._explorerLoop.pause()
+        return { success: true, message: '探索循环已暂停' }
       }
-      case 'clear_log': {
-        this._stateStore._save('execution_log', [])
-        return { success: true, message: 'Log cleared' }
+
+      case 'resume': {
+        if (!this._explorerLoop) {
+          return { success: false, error: '探索循环未初始化' }
+        }
+        this._explorerLoop.resume()
+        return { success: true, message: '探索循环已恢复' }
       }
-      default: return { success: false, error: `Unknown action: ${action}` }
+
+      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._decisionEngine) this._decisionEngine._framework = framework
-    if (this._executor)       this._executor._framework = framework
-    if (this._eventWatcher && this._explorerLoop && this._explorerLoop.isRunning()) {
-      this._eventWatcher.stop()
-      this._eventWatcher = new EventWatcher(this._goalManager, framework)
+    if (this._explorerLoop && this._explorerLoop.isRunning()) {
+      // 用新的框架引用重新启动
+      this._eventWatcher = new EventWatcher(this._goalManager, this._framework)
       this._eventWatcher.start()
     }
   }
 
-  uninstall() {
-    if (this._explorerLoop)  { this._explorerLoop.stop();  this._explorerLoop  = null }
-    if (this._eventWatcher)  { this._eventWatcher.stop();  this._eventWatcher  = null }
-    this._memory && this._memory.clearWorking()
+  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, FailureType }
+module.exports = { AmbientAgentPlugin, GoalState }