foliko 1.0.62 → 1.0.63

package/plugins/ambient-agent-plugin.js

@@ -1,195 +1,320 @@
 /**
- * Ambient Agent 插件
- * 持续后台运行的智能代理，监控事件并主动执行操作
+ * Ambient Agent Plugin v2 — 自主执行引擎
+ *
+ * 核心改造：
+ * 1. DecisionEngine    — 用 LLM 推理替代 FIFO 队列，动态决策下一步
+ * 2. PriorityScheduler — 多维优先级排序（优先级 + 紧迫性 + 事件权重）
+ * 3. ContextBuilder    — 为每次 LLM 决策聚合完整上下文
+ * 4. SemanticMemory    — 关键词索引 + 时间衰减的记忆系统
+ * 5. Reflector v2      — 失败分类 + 差异化恢复策略
  */
 
 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'         // 已失败
+  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'
 }
 
-// 生成唯一ID
 function generateId() {
-  if (require('crypto').randomUUID) {
-    return require('crypto').randomUUID()
-  }
-  return `goal_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  return crypto.randomUUID ? crypto.randomUUID() : `id_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`
 }
 
-// ============================================================================
-// StateStore - 持久化目标和记忆到 .agent/data/ambient/*.json
-// ============================================================================
+// ─────────────────────────────────────────────────────────────────────────────
+// StateStore — 持久化（同原版，增加 executionLog）
+// ─────────────────────────────────────────────────────────────────────────────
+
 class StateStore {
   constructor(persistencePath) {
-    this._persistencePath = persistencePath
+    this._path = persistencePath
     this._ensureDir()
   }
 
   _ensureDir() {
-    if (!fs.existsSync(this._persistencePath)) {
-      fs.mkdirSync(this._persistencePath, { recursive: true })
-    }
+    if (!fs.existsSync(this._path)) fs.mkdirSync(this._path, { recursive: true })
   }
 
-  _getGoalsPath() {
-    return path.join(this._persistencePath, 'goals.json')
-  }
+  _file(name) { return path.join(this._path, `${name}.json`) }
 
-  _getMemoriesPath() {
-    return path.join(this._persistencePath, 'memories.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) }
   }
 
-  saveGoals(goals) {
+  _load(name, fallback) {
     try {
-      fs.writeFileSync(this._getGoalsPath(), JSON.stringify(goals, null, 2))
-    } catch (err) {
-      console.error('[Ambient] 保存目标失败:', err.message)
-    }
+      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
   }
 
-  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 []
+  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))
   }
+  loadLog()            { return this._load('execution_log', []) }
+}
 
-  saveMemories(memories) {
-    try {
-      fs.writeFileSync(this._getMemoriesPath(), JSON.stringify(memories, null, 2))
-    } catch (err) {
-      console.error('[Ambient] 保存记忆失败:', err.message)
-    }
+// ─────────────────────────────────────────────────────────────────────────────
+// SemanticMemory — 替代原始 memories[] 数组
+// 支持：关键词索引检索 · 时间衰减评分 · 工作记忆（临时，不持久）
+// ─────────────────────────────────────────────────────────────────────────────
+
+class SemanticMemory {
+  constructor(stateStore) {
+    this._store  = stateStore
+    this._long   = stateStore.loadMemories()  // 长期记忆（持久化）
+    this._working = []                         // 工作记忆（会话内临时）
   }
 
-  loadMemories() {
-    try {
-      const filePath = this._getMemoriesPath()
-      if (fs.existsSync(filePath)) {
-        const data = fs.readFileSync(filePath, 'utf-8')
-        return JSON.parse(data)
+  /**
+   * 存储记忆
+   * @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)
       }
-    } catch (err) {
-      console.error('[Ambient] 加载记忆失败:', err.message)
+      this._store.saveMemories(this._long)
     }
-    return []
+    return mem
+  }
+
+  /**
+   * 检索记忆（关键词 + 时间衰减评分）
+   * @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)
+  }
+
+  /** 获取最近 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)
   }
+
+  getAll()     { return { long: this._long, working: this._working } }
+  clearWorking() { this._working = [] }
 }
 
-// ============================================================================
-// GoalManager - 管理目标及其生命周期状态
-// ============================================================================
+// ─────────────────────────────────────────────────────────────────────────────
+// GoalManager — 增强版（支持子目标）
+// ─────────────────────────────────────────────────────────────────────────────
+
 class GoalManager {
   constructor(stateStore) {
     this._goals = new Map()
-    this._stateStore = stateStore
-    this._loadGoals()
+    this._store = stateStore
+    this._load()
   }
 
-  _loadGoals() {
-    const savedGoals = this._stateStore.loadGoals()
-    for (const goal of savedGoals) {
-      this._goals.set(goal.id, goal)
-    }
+  _load() {
+    for (const g of this._store.loadGoals()) this._goals.set(g.id, g)
   }
 
   _persist() {
-    const goalsArray = Array.from(this._goals.values())
-    this._stateStore.saveGoals(goalsArray)
+    this._store.saveGoals(Array.from(this._goals.values()))
   }
 
-  createGoal(goalData) {
+  createGoal(data, parentId = null) {
     const goal = {
-      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: []
+      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
     }
     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)
-  }
+  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) }
 
-  getAllGoals() {
-    return Array.from(this._goals.values())
-  }
-
-  getActiveGoals() {
-    return Array.from(this._goals.values()).filter(g => g.state === GoalState.ACTIVE)
+  updateGoal(id, updates) {
+    const g = this._goals.get(id)
+    if (!g) return null
+    Object.assign(g, updates, { updatedAt: Date.now() })
+    this._persist()
+    return g
   }
 
-  getPendingGoals() {
-    return Array.from(this._goals.values()).filter(g => g.state === GoalState.PENDING)
+  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
   }
 
-  updateGoal(id, updates) {
-    const goal = this._goals.get(id)
-    if (!goal) return null
-    Object.assign(goal, updates, { updatedAt: new Date() })
+  completeGoal(id) {
+    const g = this._goals.get(id)
+    if (!g) return null
+    g.state = GoalState.COMPLETED
+    g.completedAt = Date.now()
+    g.updatedAt   = Date.now()
     this._persist()
-    return goal
+    // 自动检查父目标：若所有子目标完成则触发回调
+    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
   }
 
-  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()
+  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()
     this._persist()
-    return goal
+    return g
   }
 
-  completeGoal(id) {
-    const goal = this._goals.get(id)
-    if (!goal) return null
-    goal.state = GoalState.COMPLETED
-    goal.completedAt = new Date()
-    goal.updatedAt = new Date()
+  pauseGoal(id) {
+    const g = this._goals.get(id)
+    if (!g || g.state !== GoalState.ACTIVE) return null
+    g.state = GoalState.PAUSED
+    g.updatedAt = Date.now()
     this._persist()
-    return goal
+    return g
   }
 
-  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()
+  resumeGoal(id) {
+    const g = this._goals.get(id)
+    if (!g || g.state !== GoalState.PAUSED) return null
+    g.state = GoalState.ACTIVE
+    g.updatedAt = Date.now()
     this._persist()
-    return goal
+    return g
   }
 
   deleteGoal(id) {
@@ -199,209 +324,595 @@ class GoalManager {
   }
 
   addEventToGoal(goalId, event) {
-    const goal = this._goals.get(goalId)
-    if (!goal) return
-    goal.eventsReceived.push({
-      event: event.event || event.type,
-      timestamp: new Date()
-    })
+    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()
     this._persist()
   }
 }
 
-// ============================================================================
-// EventWatcher - 订阅框架事件，筛选相关事件
-// ============================================================================
-class EventWatcher {
-  constructor(goalManager, framework) {
+// ─────────────────────────────────────────────────────────────────────────────
+// 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
     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)]
-    ]
+  /**
+   * 构建用于 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)
+    }))
 
-    for (const [event, handler] of events) {
-      this._framework.on(event, handler)
-      this._handlers.push({ event, handler })
+    // 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
     }
   }
 
-  stop() {
-    for (const { event, handler } of this._handlers) {
-      this._framework.off(event, handler)
+  _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)
     }
-    this._handlers = []
+
+    // Agent 忙，跳过这次决策
+    if (llmResponse === null) {
+      return null
+    }
+
+    // 解析 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
   }
 
-  _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 })
-      }
+  /**
+   * 构造决策 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": []
     }
   }
+}
+
+注意：
+- 如果目标已完成，设 shouldComplete=true，action 可为 null
+- 如果目标无法完成（缺少工具/权限/信息），设 shouldFail=true 并填写 failReason
+- 如果需要等待更多事件，action.type 设为 "wait"
+- 如果任务可以分解，优先用 create_subgoal 分解
+- 不要重复刚刚执行过的相同行动`
+  }
 
-  _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
+  /**
+   * 调用 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
       }
+      throw new Error('LLM call failed: ' + e.message)
     }
-    // 检查工具名称过滤器
-    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
+  }
+
+  /**
+   * 解析 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
       }
+
+      // 尝试移除 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 }
     }
-    return true
   }
 }
 
-// ============================================================================
-// Reflector - 评估操作结果，更新目标状态
-// ============================================================================
+// ─────────────────────────────────────────────────────────────────────────────
+// Reflector v2 — 失败分类 + 差异化恢复策略
+// ─────────────────────────────────────────────────────────────────────────────
+
 class Reflector {
-  constructor(goalManager) {
+  constructor(goalManager, memory, stateStore) {
     this._goalManager = goalManager
+    this._memory      = memory
+    this._store       = stateStore
   }
 
-  evaluateOutcome(goal, actionResult) {
-    if (!goal) return null
+  /**
+   * 评估行动结果，返回恢复策略
+   */
+  evaluate(goal, actionResult, decision) {
+    const now = Date.now()
 
-    // 检查错误
-    if (actionResult && actionResult.error) {
-      // 增加尝试次数但不立即失败
+    // —— 成功路径 ——
+    if (actionResult && actionResult.success !== false && !actionResult.error) {
       goal.attempts++
-      return {
-        shouldContinue: goal.attempts < goal.maxAttempts,
-        actionTaken: false
-      }
+      // 将结果摘要写入工作记忆
+      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 }
     }
 
-    // 检查是否成功完成
-    if (actionResult && actionResult.success === true) {
-      goal.attempts++
+    // —— 失败路径：分类处理 ——
+    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 }
+    }
 
-      // 检查目标是否完成
-      if (goal.actions.length === 0 || goal.attempts >= goal.maxAttempts) {
-        return { shouldContinue: false, goalComplete: true }
-      }
+    // 不同错误类型的恢复策略
+    switch (ftype) {
+      case FailureType.TOOL_NOT_FOUND:
+        // 工具不存在 → 立即失败，不重试
+        return { status: 'fail', reason: `工具不存在: ${errMsg}`, type: ftype }
 
-      return { shouldContinue: true, actionTaken: true }
-    }
+      case FailureType.TIMEOUT:
+        // 超时 → 指数退避后重试
+        return { status: 'retry', backoffMs: Math.min(5000 * Math.pow(2, goal.attempts), 60000) }
 
-    // 工具执行无错误 - 视为成功
-    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
   }
+}
 
-  checkLoopDetection(goal, actionId) {
-    // 如果同一操作连续重复3次，则目标失败
-    if (goal.lastActionId === actionId) {
-      goal.consecutiveSameActions++
-      if (goal.consecutiveSameActions >= 3) {
-        this._goalManager.failGoal(goal.id, '检测到循环：同一操作连续重复3次')
-        return true
+// ─────────────────────────────────────────────────────────────────────────────
+// 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' }
+
+    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 }
+    }
+  }
+
+  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)
       }
-    } else {
-      goal.consecutiveSameActions = 1
-      goal.lastActionId = actionId
+
+      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 }
+      }
+
+      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
+        })
+      }
+
+      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}` }
     }
-    return false
+  }
+
+  _getAgent() {
+    if (this._framework._mainAgent) return this._framework._mainAgent
+    const agents = this._framework._agents || []
+    return agents.length > 0 ? agents[agents.length - 1] : null
   }
 }
 
-// ============================================================================
-// ExplorerLoop - 主自主循环，决定并执行操作
-// ============================================================================
-class ExplorerLoop {
-  constructor(goalManager, reflector, framework, config) {
+// ─────────────────────────────────────────────────────────────────────────────
+// EventWatcher — 同原版，增加优先级权重传递
+// ─────────────────────────────────────────────────────────────────────────────
+
+class EventWatcher {
+  constructor(goalManager, framework) {
     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._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'
+    ]
   }
 
   start() {
-    if (this._running) return
-    this._running = true
-    this._scheduleNext()
+    for (const type of this._watchedEvents) {
+      this._handlers.push(
+        this._framework.on(type, (data) => this._handle(type, data))
+      )
+    }
   }
 
   stop() {
-    this._running = false
-    if (this._timer) {
-      clearTimeout(this._timer)
-      this._timer = null
-    }
+    for (const h of this._handlers) h()
+    this._handlers = []
   }
 
-  pause() {
-    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 })
+      }
     }
   }
 
-  resume() {
-    if (!this._running) {
-      this._running = true
-      this._scheduleNext()
+  _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
     }
+    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
   }
+}
 
-  isRunning() {
-    return this._running
+// ─────────────────────────────────────────────────────────────────────────────
+// 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 → 退避到期时间
   }
 
+  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,
-      lastTick: this._lastActionTime ? new Date(this._lastActionTime) : null,
-      recentActivities: this._recentActivities.slice(-10),
-      activeGoals: this._goalManager.getActiveGoals().length,
-      pendingGoals: this._goalManager.getPendingGoals().length
+      running:          this._running,
+      tickCount:        this._tickCount,
+      activeGoals:      this._goalManager.getActiveGoals().length,
+      pendingGoals:     this._goalManager.getPendingGoals().length,
+      recentActivities: this._recentActivities.slice(-10)
     }
   }
 
@@ -412,731 +923,435 @@ class ExplorerLoop {
 
   async _tick() {
     if (!this._running) return
+    this._tickCount++
 
-    // 如果处于嵌套执行上下文中，跳过此tick
     try {
-      if (this._framework.getExecutionContext) {
-        const ctx = this._framework.getExecutionContext()
-        if (ctx && ctx.id) {
-          // 跳过此tick，重新调度
-          this._scheduleNext()
-          return
+      // 自动激活无条件的 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 })
         }
       }
-    } catch (e) {
-      // getExecutionContext可能不存在，继续执行
-    }
 
-    this._tickCount++
-    this._lastActionTime = Date.now()
+      // 调度：按优先级排序活跃目标
+      const activeGoals = this._scheduler.schedule(this._goalManager.getActiveGoals())
 
-    try {
-      await this._processGoals()
+      for (const goal of activeGoals) {
+        // 退避检查
+        const backoffUntil = this._backoffMap.get(goal.id)
+        if (backoffUntil && Date.now() < backoffUntil) continue
+
+        await this._processGoal(goal)
+      }
     } catch (err) {
-      console.error('[Ambient] Tick错误:', err.message)
-      this._addActivity('error', { message: err.message })
+      console.error('[Ambient] Tick error:', err.message)
+      this._log('tick_error', { message: err.message })
     }
 
-    // 调度下一次tick
     this._scheduleNext()
   }
 
-  async _processGoals() {
-    const activeGoals = this._goalManager.getActiveGoals()
+  async _processGoal(goal) {
+    const isEventDriven = goal.conditions && goal.conditions.events && goal.conditions.events.length > 0
+    const hasEvents     = (goal.eventsReceived || []).length > 0
 
-    for (const goal of activeGoals) {
-      // 检查冷却时间
-      if (Date.now() - this._lastActionTime < this._config.cooldownPeriod) {
-        continue
-      }
-
-      // 检查目标是否有未处理的事件
-      const hasNewEvents = goal.eventsReceived && goal.eventsReceived.length > 0
+    // 事件驱动目标：无待处理事件则跳过
+    if (isEventDriven && !hasEvents) return
 
-      // 获取下一个操作
-      if (goal.actions && goal.actions.length > 0) {
-        const action = goal.actions[0] // 简单策略：取第一个操作
+    // ── 1. DecisionEngine 决策 ──
+    let decision
+    try {
+      decision = await this._decisionEngine.decide(goal)
+    } catch (err) {
+      this._log('decision_error', { goalId: goal.id, error: err.message })
+      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) 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 })
-        }
+    // ── 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 && outcome.actionTaken) {
-          goal.eventsReceived = []
-          this._goalManager.updateGoal(goal.id, { eventsReceived: [] })
-        }
-      }
+    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 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 })
-      }
+    const action = decision.action
+    if (!action || action.type === 'wait') {
+      this._log('action_wait', { goalId: goal.id, reasoning: decision.reasoning })
+      this._clearEvents(goal)
+      return
     }
-  }
 
-  async _executeAction(action, eventData = null) {
-    if (!this._framework) {
-      return { success: false, error: '框架不可用' }
+    // ── 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
     }
 
-    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}` }
-        }
-        // 如果有事件数据，合并到参数中
-        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: '思考插件不可用' }
-      }
+    // ── 4. 执行行动 ──
+    const eventData = hasEvents ? goal.eventsReceived[0] : null
+    this._log('action_start', { goalId: goal.id, type: action.type, name: action.name })
 
-      return { success: false, error: `未知的操作类型: ${action.type}` }
-    } catch (err) {
-      return { success: false, error: err.message }
-    }
-  }
+    const result  = await this._executor.execute(action, eventData)
+    const outcome = this._reflector.evaluate(goal, result, decision)
 
-  _getActiveAgent() {
-    if (this._framework._mainAgent) {
-      return this._framework._mainAgent
-    }
-    const agents = this._framework._agents || []
-    return agents.length > 0 ? agents[agents.length - 1] : null
-  }
+    // ── 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
 
-  _addActivity(type, data) {
-    this._recentActivities.push({
-      type,
-      data,
-      timestamp: new Date()
-    })
-    // 只保留最近50条活动记录
-    if (this._recentActivities.length > 50) {
-      this._recentActivities = this._recentActivities.slice(-50)
+      case 'retry':
+        this._backoffMap.set(goal.id, Date.now() + (outcome.backoffMs || 5000))
+        this._log('action_backoff', { goalId: goal.id, backoffMs: outcome.backoffMs })
+        break
+
+      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 })
+        }
+        break
     }
+
+    this._clearEvents(goal)
   }
 
-  /**
-   * 通知用户（通过事件发送给消息插件）
-   */
-  _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
-      }
+  _clearEvents(goal) {
+    if ((goal.eventsReceived || []).length > 0) {
+      this._goalManager.updateGoal(goal.id, { eventsReceived: [] })
     }
+  }
 
-    // 发送统一的通知事件
-    this._framework.emit('notification', {
-      title,
-      message,
-      source: 'ambient',
-      level,  // 'info' | 'warning' | 'success' | 'error'
-      sessionId,
-      timestamp: new Date()
-    })
-
-    console.log(`[Ambient:通知] ${title}: ${message}`)
+  _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)
   }
 }
 
-// ============================================================================
-// 主插件类
-// ============================================================================
+// ─────────────────────────────────────────────────────────────────────────────
+// AmbientAgentPlugin v2 — 主插件类
+// ─────────────────────────────────────────────────────────────────────────────
+
 class AmbientAgentPlugin extends Plugin {
   constructor(config = {}) {
     super()
-    this.name = 'ambient'
-    this.version = '1.0.0'
-    this.description = 'Ambient Agent - 持续后台运行的智能代理，用于主动监控和执行操作'
-    this.priority = 18
-    this.system = true
+    this.name        = 'ambient'
+    this.version     = '2.0.0'
+    this.description = 'Ambient Agent v2 — 自主执行引擎（LLM 推理 + 优先级调度）'
+    this.priority    = 18
+    this.system      = true
 
     this.config = {
-      enabled: config.enabled !== false,
-      tickInterval: config.tickInterval || 5000,      // tick间隔（毫秒）
-      cooldownPeriod: config.cooldownPeriod || 3000,  // 冷却时间（毫秒）
+      enabled:        config.enabled !== false,
+      tickInterval:   config.tickInterval  || 5000,
+      cooldownPeriod: config.cooldownPeriod || 3000,
       persistencePath: config.persistencePath || '.agent/data/ambient',
-      defaultGoals: config.defaultGoals || []
+      defaultGoals:   config.defaultGoals || [],
+      llmCallTimeout: config.llmCallTimeout || 30000,
+      actionTimeout:  config.actionTimeout  || 20000
     }
 
-    this._framework = null
-    this._stateStore = null
-    this._goalManager = null
-    this._eventWatcher = null
-    this._reflector = null
-    this._explorerLoop = null
-    this._memories = []
+    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
   }
 
   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()
-
+    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()
     return this
   }
 
   start(framework) {
-    if (!this.config.enabled) {
-      console.log('[Ambient] 插件已禁用，跳过启动')
-      return this
-    }
+    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._goalManager.getAllGoals().length === 0 && this.config.defaultGoals.length > 0) {
-      for (const goalDef of this.config.defaultGoals) {
-        this._goalManager.createGoal(goalDef)
-      }
+      for (const g of this.config.defaultGoals) this._goalManager.createGoal(g)
     }
 
-    // 启动事件监听器
     this._eventWatcher = new EventWatcher(this._goalManager, this._framework)
     this._eventWatcher.start()
 
-    // 动态更新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 = new ExplorerLoop(
+      this._goalManager,
+      this._decisionEngine,
+      this._reflector,
+      this._executor,
+      this._scheduler,
+      this._memory,
+      { tickInterval: this.config.tickInterval }
+    )
     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']).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('激活条件（创建/更新时使用）')
+        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()
       }),
-      execute: async (args) => {
-        return this._handleGoalsTool(args)
-      }
+      execute: async (args) => this._handleGoalsTool(args)
     })
 
-    // ambient_status - 获取当前循环状态
+    // ── 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（分析）',
+      description: '获取 Ambient Agent 运行状态 — 循环状态/活跃目标/最近活动/执行日志',
       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')
+        includeLog: z.boolean().optional().describe('是否包含执行日志（最近 20 条）')
       }),
-      execute: async (args) => {
-        return this._handleThinkTool(args)
-      }
+      execute: async (args) => this._handleStatusTool(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']).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时使用）')
+        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()
       }),
-      execute: async (args) => {
-        return this._handleRememberTool(args)
-      }
+      execute: async (args) => 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']).describe('控制操作'),
-        tickInterval: z.number().optional().describe('新的tick间隔毫秒数（adjust时使用）'),
-        cooldownPeriod: z.number().optional().describe('新的冷却时间毫秒数（adjust时使用）')
+        action:         z.enum(['pause', 'resume', 'status', 'adjust', 'clear_log']),
+        tickInterval:   z.number().optional(),
+        cooldownPeriod: z.number().optional(),
+        llmCallTimeout: z.number().optional()
       }),
-      execute: async (args) => {
-        return this._handleControlTool(args)
-      }
+      execute: async (args) => this._handleControlTool(args)
     })
   }
 
   _handleGoalsTool(args) {
-    const { action, goalId, title, description, priority, actions, conditions } = args
+    const { action, goalId, parentId, title, description, priority,
+            successCriteria, actions, conditions, maxAttempts } = args
 
     switch (action) {
       case 'list': {
-        const allGoals = this._goalManager.getAllGoals()
+        const all = 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
+          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
           })),
-          total: allGoals.length,
-          active: this._goalManager.getActiveGoals().length,
-          pending: this._goalManager.getPendingGoals().length
+          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
+          }
         }
       }
-
       case 'create': {
-        if (!title) {
-          return { success: false, error: '创建目标需要提供标题' }
-        }
-        const goal = this._goalManager.createGoal({ title, description, priority, actions, conditions })
+        if (!title) return { success: false, error: 'title is required' }
+        const goal = this._goalManager.createGoal({ title, description, priority, actions, conditions, maxAttempts, successCriteria })
         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: '更新目标需要提供目标ID' }
-        }
+        if (!goalId) return { success: false, error: 'goalId is required' }
         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 }
+        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' }
       }
-
-      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}` }
+      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}` }
     }
   }
 
-  _handleStatusTool() {
-    if (!this._explorerLoop) {
-      return { success: false, error: '探索循环未初始化' }
-    }
+  _handleStatusTool(args = {}) {
+    const loop = this._explorerLoop
+    if (!loop) return { success: false, error: 'Loop not initialized' }
 
-    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 {
+    const status = loop.getStatus()
+    const result = {
       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: '思考请求已排队，将在代理空闲时处理。'
+        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
         }
-      }
-      return result
+      },
+      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
     }
 
-    // 备用：直接推送消息
-    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}` : '这个目标的优势、劣势和潜在问题是什么？'}`
+    if (args.includeLog) {
+      result.executionLog = this._stateStore.loadLog().slice(-20)
     }
-    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
+    return result
   }
 
   _handleRememberTool(args) {
-    const { action, content, key, query, limit } = args
-    const maxResults = limit || 10
+    const { action, content, key, tags, scope, goalId, query, limit } = args
 
     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 }
+        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 }
       }
-
       case 'retrieve': {
-        const memories = this._memories.slice(-maxResults).reverse()
-        return {
-          success: true,
-          memories,
-          total: this._memories.length
-        }
+        const mems = this._memory.recent(limit || 10, scope || 'all')
+        return { success: true, memories: mems, total: mems.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
-        }
+        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 }
       }
-
-      default:
-        return { success: false, error: `未知操作: ${action}` }
+      default: return { success: false, error: `Unknown action: ${action}` }
     }
   }
 
   _handleControlTool(args) {
-    const { action, tickInterval, cooldownPeriod } = args
+    const { action, tickInterval, cooldownPeriod, llmCallTimeout } = args
+    const loop = this._explorerLoop
 
     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 '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
-        }
-        return {
-          success: true,
-          message: '设置已调整',
-          tickInterval: this.config.tickInterval,
-          cooldownPeriod: this.config.cooldownPeriod
-        }
+        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 }
       }
-
-      default:
-        return { success: false, error: `未知操作: ${action}` }
-    }
-  }
-
-  _getActiveAgent() {
-    if (this._framework._mainAgent) {
-      return this._framework._mainAgent
+      case 'clear_log': {
+        this._stateStore._save('execution_log', [])
+        return { success: true, message: 'Log cleared' }
+      }
+      default: return { success: false, error: `Unknown action: ${action}` }
     }
-    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)
+    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)
       this._eventWatcher.start()
     }
   }
 
-  uninstall(framework) {
-    // 停止探索循环
-    if (this._explorerLoop) {
-      this._explorerLoop.stop()
-      this._explorerLoop = null
-    }
-
-    // 停止事件监听器
-    if (this._eventWatcher) {
-      this._eventWatcher.stop()
-      this._eventWatcher = null
-    }
-
-    // 清除引用
+  uninstall() {
+    if (this._explorerLoop)  { this._explorerLoop.stop();  this._explorerLoop  = null }
+    if (this._eventWatcher)  { this._eventWatcher.stop();  this._eventWatcher  = null }
+    this._memory && this._memory.clearWorking()
     this._framework = null
-    this._goalManager = null
-    this._reflector = null
-    this._stateStore = null
-    this._memories = []
   }
 }
 
-module.exports = { AmbientAgentPlugin, GoalState }
+module.exports = { AmbientAgentPlugin, GoalState, FailureType }