diff --git a/README.md b/README.md
index b39f78a..c79e1f4 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/version-v0.15.0-E8734A?style=flat-square" alt="version">
+  <img src="https://img.shields.io/badge/version-v0.16.0-E8734A?style=flat-square" alt="version">
   <img src="https://img.shields.io/badge/electron-33+-47848F?style=flat-square&logo=electron" alt="electron">
   <img src="https://img.shields.io/badge/typescript-5.7+-3178C6?style=flat-square&logo=typescript" alt="typescript">
   <img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="license">
@@ -253,7 +253,7 @@ npm start
 ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/ npm run dist
 ```
 
-产出：`release/Metona Ollama Setup v0.15.0.exe`
+产出：`release/Metona Ollama Setup v0.16.0.exe`
 
 ## 🛠️ 常用命令
 
@@ -501,7 +501,7 @@ npm start
 ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/ npm run dist
 ```
 
-Output: `release/Metona Ollama Setup v0.15.0.exe`
+Output: `release/Metona Ollama Setup v0.16.0.exe`
 
 ## 🛠️ Common Commands
 
diff --git a/docs/Agentic-Loop详解.md b/docs/Agentic-Loop详解.md
new file mode 100644
index 0000000..c975f38
--- /dev/null
+++ b/docs/Agentic-Loop详解.md
@@ -0,0 +1,636 @@
+# 🔄 Agentic Loop（智能体循环）完全指南
+
+> **一句话定义**：Agentic Loop 是驱动 AI Agent 持续自主完成复杂任务的核心调度循环——让 AI 不断重复"思考 → 行动 → 观察 → 再思考"的闭环过程，直到任务完成。
+
+---
+
+## 目录
+
+- [一、核心概念](#一核心概念)
+- [二、与传统 LLM 的本质区别](#二与传统-llm的本质区别)
+- [三、运作机制：五阶闭环详解](#三运作机制五阶闭环详解)
+- [四、三层分级体系](#四三层分级体系)
+- [五、循环终止条件](#五循环终止条件)
+- [六、核心伪代码实现](#六核心伪代码实现)
+- [七、与主流 Agent 范式的关系](#七与主流-agent-范式的关系)
+- [八、工具调用（Tool Use）六步闭环](#八工具调用tool-use六步闭环)
+- [九、适用场景与不适用场景](#九适用场景与不适用场景)
+- [十、实际应用案例](#十实际应用案例)
+- [十一、关联循环体系](#十一关联循环体系)
+- [十二、行业趋势与未来方向](#十二行业趋势与未来方向)
+- [十三、参考来源](#十三参考来源)
+
+---
+
+## 一、核心概念
+
+### 什么是 Agentic Loop？
+
+**Agentic Loop（智能体循环）**是 AI Agent 架构中的核心运行机制，它让大语言模型（LLM）从传统的"一问一答"模式升级为能够持续自主地完成复杂任务的闭环系统。
+
+如果把普通 AI 比作「随时待命的客服」，只负责被动应答；那带 Loop 的 AI Agent，就是 **不用催促、自主推进的全职实习生**，懂规划、会试错、能复盘、可收尾。
+
+### 为什么需要它？
+
+传统的 LLM 交互是线性的"一问一答"——用户提问，模型一次性生成回答，交互即结束。一旦任务复杂、变数较多，就会直接"摆烂"，需要人不断细化指令、手动推进进度。
+
+而 **Agentic Loop 引入了「循环」和「反馈」两个关键要素**，使 AI 能够根据中间结果动态调整策略，边执行边验证，而不是死板地执行预设流程。
+
+> 💡 **没有 Agent Loop，AI 只是聊天工具；有了 Agent Loop，AI 才是能落地干活的智能体。**
+
+---
+
+## 二、与传统 LLM 的本质区别
+
+| 维度 | 传统 LLM | Agentic Loop |
+|------|----------|--------------|
+| **交互方式** | 线性"一问一答" | 循环式"思考→行动→观察" |
+| **任务能力** | 单次内容生成 | 持续自主完成复杂任务 |
+| **反馈机制** | 无中间反馈 | 基于环境反馈动态调整 |
+| **适应性** | 静态输出 | 动态纠错与策略优化 |
+| **记忆能力** | 无状态 | 可选配持久化记忆 |
+| **工具使用** | 不支持 | 原生支持多工具调用 |
+
+```mermaid
+flowchart LR
+    subgraph Traditional["传统 LLM：单次交互"]
+        A1[用户提问] --> B1[LLM 一次性生成]
+        B1 --> C1[输出结果 · 结束]
+    end
+
+    subgraph Agentic["Agentic Loop：闭环迭代"]
+        A2[设定目标] --> B2[思考决策]
+        B2 --> C2[行动执行]
+        C2 --> D2[观察反馈]
+        D2 --> E2{任务完成?}
+        E2 -->|否| B2
+        E2 -->|是| F2[输出最终结果]
+    end
+```
+
+---
+
+## 三、运作机制：五阶闭环详解
+
+Agentic Loop 的完整工作流包含五个阶段，在多数任务中可简化为持续迭代的三步核心循环。
+
+### 完整五阶段
+
+#### ① 目标感知（Perceive）
+人类只需给出 **最终目标和核心规则**，不用拆解步骤、不用预设细节。例如：
+- "整理一份2026年新媒体行业报告"
+- "排查这段代码的运行漏洞并修复"
+- "规划一周减脂食谱+运动计划"
+
+这一步彻底告别了过去「精准逐字写提示词」的繁琐。
+
+#### ② 思考决策（Reason）
+Agent 结合自身知识库、记忆体系和工具能力，把大目标拆成可落地的小步骤，同时判断：
+- 下一步该做什么？
+- 需要调用什么工具？
+- 优先执行哪项任务？
+
+> **核心区别：步骤不是人定的，是 AI 自己推理出来的。**
+
+#### ③ 行动执行（Act）
+根据决策结果执行具体动作：
+- 🔍 联网搜索信息
+- 💻 调用代码工具 / 执行 Shell 命令
+- 📄 读取本地文件
+- ✍️ 生成文案内容
+- 📊 批量处理数据
+
+这是 AI 从「只会输出文字」到「可以真实做事」的关键一步。
+
+#### ④ 观察反馈（Observe）
+Agent 会主动感知执行后的真实状态：
+- 搜索的信息是否全面？
+- 代码是否运行成功？
+- 生成的内容是否缺漏？
+- 数据是否存在异常？
+
+它不再盲目输出，而是 **能看见自己的执行结果**。
+
+#### ⑤ 复盘修正（Reflect/Correct）
+这是 Loop 最核心的灵魂。Agent 会自我校验：
+- 当前结果是否达标？
+- 有没有遗漏步骤？
+- 有没有错误漏洞？
+- 是否需要调整方法？
+
+如果不满足终止条件，立刻修正策略、重启下一轮循环；如果达标，才终止任务、输出最终结果。
+
+### 核心三步简化版
+
+在实际工程中，五阶段常被精简为最核心的三步循环：
+
+```
+┌─────────────────────────────────────────────┐
+│                                             │
+│   ┌──────────┐    ┌──────────┐    ┌────────┐│
+│   │ 推理     │──▶│ 行动     │──▶│ 观察   ││
+│   │ Reasoning│    │ Acting   │    │Observ. ││
+│   └──────────┘    └──────────┘    └────────┘│
+│         ▲                              │     │
+│         └──────────────────────────────┘     │
+│            未完成则继续循环                    │
+└─────────────────────────────────────────────┘
+```
+
+> **简单总结：思考 → 行动 → 观察 → 评估 → 修正，往复循环，闭环落地。**
+
+---
+
+## 四、三层分级体系
+
+Agentic Loop 不是固定模板，随着记忆存储、工具管理、配套功能完善，可分为三个层级。开发中遇到的绝大多数问题——AI 重复执行相同操作、遗忘前文对话、多轮回答前后逻辑矛盾——根源基本都是 **任务复杂度与智能体层级不匹配**。
+
+### 第一层：基础工具调用循环
+
+**最简形态**，仅依靠大模型调用工具并输出回答，没有持久化记忆、没有外部状态存储。
+
+```
+用户输入 → LLM 推理 → 调用工具 → 观察结果 → 回传 LLM → 输出最终答案
+```
+
+**特点：**
+- ✅ 处理独立、简短的一次性任务完全够用
+- ❌ 无法留存历史对话，每次启动都是全新空白状态
+- ❌ 上下文窗口是唯一临时存储载体，流程结束后所有状态清空
+- ❌ 用于多轮对话时会出现：重复检索运算、遗忘前文决策、前后自相矛盾
+
+**适合场景**：单次问答、简单查询、一次性工具调用
+
+---
+
+### 第二层：内置完整生命周期的循环
+
+升级后，循环内部新增标准化 **记忆操作流程**：
+- 调用大模型前 **读取** 历史记忆数据
+- 智能体完成动作后 **写入/更新** 记忆
+- 整套循环形成完整闭环生命周期
+
+#### 关键区分：记忆增强型 vs 记忆感知型
+
+| 类型 | 说明 | 能力上限 |
+|------|------|----------|
+| **记忆增强型** | 仅被动检索信息注入上下文，不会主动管控内存 | 较低 —— 记忆是外部附加能力 |
+| **记忆感知型** | 将内存作为核心工程模块，主动完成编码、存储、检索、注入、遗忘全套操作 | 较高 —— 在单次/跨会话中持续维护自身推理状态 |
+
+第二层是搭建 **记忆感知型智能体** 的起点。
+
+#### 第二层常见挑战及缓解方案
+
+| 挑战 | 说明 | 缓解方法 |
+|------|------|----------|
+| **检索噪声** | 语义相似但与当前查询实际不相关 | 设置相关性阈值 + 混合检索 + 多级过滤 |
+| **陈旧记忆** | 快速变化领域中数据很快过时 | 设置 TTL（生存时间）策略 + 写时更新模式 |
+| **工具定义过载** | 工具太多导致上下文膨胀，降低选择准确性 | 采用语义工具检索而非穷举所有工具 |
+
+**适合场景**：多轮对话、长周期任务、需要上下文延续的复杂工作流
+
+---
+
+### 第三层：Harness 工程体系级循环
+
+工程师不仅能管控循环内部逻辑，还在循环外围搭建一套 **设计规范、功能完善的 Harness 框架**。系统操作分为两大板块：
+
+| 板块 | 说明 | 示例 |
+|------|------|------|
+| **循环内操作** | 程序自动执行 | 自动加载上下文、执行工具调用 |
+| **循环外操作** | 智能体自主触发 | AI 判断是否需要额外信息、主动请求人工确认 |
+
+#### 第三层必需的三类优化手段
+
+1. **上下文窗口监控**：实时统计每轮 Token 占用，提前预判溢出风险，及时触发压缩
+2. **对话压缩**：用精简摘要替代冗长聊天记录，原始消息永久保存在数据库，支持审计和按需展开
+3. **工具输出离线存储**：完整工具返回结果存入独立日志表，上下文仅保留一行引用标识
+
+> **第三层的核心升级不在于内层的基础循环逻辑，而是循环外围一整套配套支撑系统：数据加载框架、运行约束管控、跨会话持久化存储层。此时整套 Harness 本身已经是一套独立、成熟、可单独运维的工程系统。**
+
+**适合场景**：生产级应用、企业级部署、高可靠性要求的复杂 Agent 系统
+
+```mermaid
+flowchart TB
+    L1["第一层: 基础工具调用循环\n✅ 单次任务 / 简单查询"] --> L2["第二层: 内置记忆的完整生命周期\n✅ 多轮对话 / 长周期任务"]
+    L2 --> L3["第三层: Harness 工程体系\n✅ 生产级 / 企业级部署"]
+    
+    style L1 fill:#e8f5e9,stroke:#4caf50
+    style L2 fill:#fff3e0,stroke:#ff9800
+    style L3 fill:#e3f2fd,stroke:#2196f3
+```
+
+---
+
+## 五、循环终止条件
+
+任何循环都必须设置退出机制。设计完善的 Agentic Loop 会明确定义全部终止规则：
+
+### 主流终止条件
+
+| # | 终止条件 | 说明 |
+|---|----------|------|
+| 1 | **模型输出最终回复** | 无待执行的工具调用（`tool_calls` 为空） |
+| 2 | **系统校验任务完成** | Harness 主动校验目标已达成 |
+| 3 | **达到最大迭代次数** | 默认通常设为 10~20 次，防止无限循环 |
+| 4 | **运行时长超限** | 全局超时保护，双重管控资源消耗 |
+| 5 | **不可恢复的系统错误** | 发生无法自动修复的异常 |
+| 6 | **死循环检测** | 连续多轮重复执行相同操作，无任何进展 |
+| 7 | **Agent 主动结束** | 智能体发出完成标记 |
+
+### ⚠️ 常见误区
+
+> **模型不再发起工具调用 ≠ 用户需求已全部完成**
+
+模型可能输出追问、部分结果或需要补充交互的内容。任务是否真正闭环，需要 **Harness 主动校验**，不能单纯依靠模型停止调用工具来判断。任务流程越长、逻辑越复杂，二者的差距越明显。
+
+### 卡死故障检测
+
+成熟的 Harness 框架会缓存近期全部工具调用记录，识别以下停滞模式后直接终止流程并输出诊断日志：
+
+- 连续三轮用完全相同参数调用同一个工具
+- AI 在两种状态间反复来回切换、毫无进展
+
+---
+
+## 六、核心伪代码实现
+
+以下是所有 AI 智能体、自动化工作流的底层通用代码逻辑（无编程基础也能看懂）：
+
+```python
+# ============================================
+#  Agentic Loop 核心闭环逻辑（通用极简版）
+# ============================================
+
+def agent_loop(目标任务):
+    # ---- 1. 初始化 ----
+    当前状态 = "未完成"
+    最大循环次数 = 20          # 防止无限死循环
+    历史执行记录 = []
+    
+    # ---- 2. 主循环 ----
+    while 当前状态 == "未完成" and 循环次数 < 最大循环次数:
+        
+        # ① 思考决策：根据目标 + 历史反馈 规划下一步动作
+        下一步动作 = llm_思考推理(目标任务, 历史执行记录)
+        
+        # ② 行动执行：调用工具、落地操作
+        执行结果 = 工具执行(下一步动作)
+        
+        # ③ 观察反馈：记录本次执行的所有数据和状态
+        历史执行记录.append({
+            "动作": 下一步动作,
+            "结果": 执行结果,
+            "时间戳": 当前时间()
+        })
+        
+        # ④ 复盘评估：判断是否达标、是否需要优化
+        任务是否完成 = llm_校验(目标任务, 执行结果)
+        
+        if 任务是否完成 == True:
+            当前状态 = "已完成"
+        else:
+            # 未达标，自动修正策略，开启下一轮循环
+            修正策略 = llm_纠错优化(目标任务, 历史执行记录)
+            # （修正策略会自然融入下一轮 llm_思考推理）
+    
+    # ---- 3. 输出最终成果 ----
+    return 最终整合结果(历史执行记录)
+```
+
+### 代码核心解读
+
+| 要点 | 说明 |
+|------|------|
+| **`while` 循环是灵魂** | 普通 AI 没有 `while` 循环，只会执行一次输出；Agent Loop 依靠持续循环实现反复干活、反复优化 |
+| **自带记忆迭代** | 每一轮都记录「动作 + 结果」，下一轮参考历史数据，越循环越精准 |
+| **自带终止机制** | 最大循环次数 + 任务校验双保险，既保证自主迭代又避免无效死循环 |
+
+### 更底层的 LangChain 风格实现
+
+```python
+# ============================================
+#  用 LangChain 实现的核心循环（更接近真实工程）
+# ============================================
+
+while not done:
+    # 1. 构建上下文（system prompt + 历史消息 + 当前输入）
+    messages = build_context(system_prompt, history, current_input)
+    
+    # 2. 调用 LLM API（流式或非流式）
+    response = call_llm(messages)
+    
+    # 3. 解析响应
+    if response.has_tool_calls:
+        # 4a. 有工具调用 → 逐个执行
+        results = execute_tools(response.tool_calls)
+        # 5a. 结果追加到历史
+        history.append(response)
+        history.append(results)
+        # → 回到步骤 1，进入下一次迭代
+    else:
+        # 4b. 无工具调用 → 输出最终回复
+        done = True
+        return response.content
+```
+
+> 一个简单的"帮我查天气"请求通常需要 **2~3 次**迭代；而复杂任务如"帮我改这个 bug"可能需要 **10+ 次**迭代——读文件、运行测试、编辑代码、再运行测试……
+
+---
+
+## 七、与主流 Agent 范式的关系
+
+Agentic Loop 是多个 AI Agent 工程范式的共同基础设施：
+
+### 🔄 ReAct 模式（最基础、最具代表性）
+
+由 Shunyu Yao 等人于 **2022 年**在论文《ReAct: Synergizing Reasoning and Acting in Language Models》中提出。
+
+- **核心思想**：将 **思维链推理（CoT）** 与 **外部环境交互行动** 相结合
+- **解决的问题**：弥补单纯 LLM 缺乏实时信息和容易产生幻觉的缺陷
+- **影响范围**：已成为现代 AI 代理设计的基准，深刻影响了 **LangChain** 和 **LlamaIndex** 等后续框架
+
+**ReAct 的经典执行轨迹示例**（排查线上服务变慢）：
+
+```
+Thought 1: 用户报告服务变慢，我需要先查看监控指标
+Action 1: query_monitoring(service="api-server")
+Observation 1: CPU 使用率 95%，响应时间 P99 > 5s
+
+Thought 2: CPU 飙升且响应慢，可能是慢 SQL 导致的，检查数据库
+Action 2: query_database_logs(time_range="last_hour")
+Observation 2: 发现全表扫描查询 SELECT * FROM orders WHERE ...
+
+Thought 3: 已定位根因——缺少索引导致的全表扫描，通知负责人修复
+Action 3: send_alert(channel="slack", message="发现慢SQL根因...")
+Observation 3: ✅ 告警已发送
+
+Final Answer: 服务变慢的原因是 orders 表缺少索引导致全表扫描，
+             已发送告警给 DBA 团队，建议立即添加索引。
+```
+
+### 📋 Plan-and-Execute（先规划再执行）
+
+在 Loop 中引入更复杂的任务分解和调度机制：
+1. 先制定完整的分步计划（Plan）
+2. 再逐步执行每个子任务（Execute）
+3. 执行过程中可根据结果回溯调整计划
+
+### 🔍 Reflection（反思机制）
+
+在 Loop 中增加 **自我评估和纠错**环节：
+- 每步行动后评估效果
+- 从失败中学习
+- 提升长期表现
+
+### 👤 Human-in-the-Loop（人机协同 / HITL）
+
+将人类作为核心参与者整合到 Agentic 生命周期中（而非仅仅作为监督者）：
+- 满足企业的法律、合规和安全要求
+- AI 在关键节点主动暂停，列出待确认项等待人工审核
+- **不是兜底 bug，而是架构设计的分层逻辑**
+
+### 🤖 Multi-Agent System（多智能体协作）
+
+多个 Agent 各自拥有独立的 Agentic Loop，通过协作模式共同完成任务：
+- **并行模式**：多个 Agent 同时处理不同子任务
+- **顺序模式**：按流水线顺序传递处理
+- **循环模式**：Agent 之间形成协作循环
+
+---
+
+## 八、工具调用（Tool Use）六步闭环
+
+大模型本质上是"静态文本生成器"，训练后无法自动更新知识，也不能执行计算、查询私有数据或操作外部系统。要让模型"感知并行动"，必须把外部能力包装成 **"工具"**，让模型按需调用。
+
+### 六步闭环流程
+
+```
+┌──────────────────────────────────────────────────────┐
+│                                                      │
+│  ① 工具定义 → ② LLM 决策 → ③ 结构化调用              │
+│       ↑                                    │         │
+│       └── ⑥ 最终回答 ← ⑤ 结果回传 ← ④ 执行层运行 ←───┘│
+│                                                      │
+└──────────────────────────────────────────────────────┘
+```
+
+| 步骤 | 操作 | 说明 |
+|------|------|------|
+| **① 工具定义** | 用 JSON Schema 或框架装饰器描述函数名、功能、字段类型与语义 | 供 LLM 读取和理解 |
+| **② LLM 决策** | 将"用户提问 + 可用工具描述"一起输入模型 | 模型内部判断是否需要调用工具 |
+| **③ 结构化调用** | 模型输出 JSON 格式的调用指令 | 如 `{"name": "get_weather", "arguments": {"city": "London"}}` |
+| **④ 执行层截获运行** | 框架根据 JSON 路由到真实函数 | 完成 API 请求、数据库查询、代码运行等 |
+| **⑤ 结果回传** | 函数返回值作为新上下文再喂给 LLM | 让模型基于真实结果继续推理 |
+| **⑥ 最终回答** | 模型结合原始提问与工具观察生成答案 | 若仍缺信息可循环 ②~⑤ |
+
+### LangChain 代码示例
+
+```python
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import tool
+from langchain.agents import create_agent
+
+# ① 定义工具
+@tool
+def get_weather(city: str) -> str:
+    """查询指定城市的天气"""
+    return f"{city}今天晴,25°C"
+
+# ② 创建带工具的 Agent（内部编译出 StateGraph 循环）
+llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+agent = create_agent(llm, [get_weather])
+
+# ③ 运行（自动进入 Agentic Loop）
+result = agent.invoke({
+    "messages": [{"role": "user", "content": "北京今天天气怎么样?"}]
+})
+print(result["messages"][-1].content)
+# → 今天北京天气晴,气温25°C
+```
+
+---
+
+## 九、适用场景与不适用场景
+
+### ✅ 适合使用 Agentic Loop 的场景
+
+| 场景特征 | 典型例子 |
+|----------|----------|
+| **步骤数无法事先确定** | "调研某个技术领域并输出完整报告" |
+| **需要根据中间结果动态调整策略** | 搜索失败时换关键词重试；代码报错时换方案修复 |
+| **任务完成度比速度更重要** | 深度资料分析、复杂代码重构 |
+| **多步骤、长链路任务** | 自动办公流程、多轮内容创作 |
+| **需要自我纠错的能力** | 排查 Bug、调试程序 |
+
+### ❌ 不适合使用 Agentic Loop 的场景
+
+| 场景特征 | 原因 | 更好的选择 |
+|----------|------|------------|
+| **固定序列的工作流** | 高度可预测、步骤固定 | 确定性的代码 Pipeline |
+| **简单任务** | 一次 LLM + 一次工具调用就能解决 | 直接函数调用 |
+| **严格的延迟约束** | 每次迭代都要调 LLM，时间和 Token 成本累积 | 预计算 / 缓存 |
+
+---
+
+## 十、实际应用案例
+
+### 🖥️ 开发场景：Claude Code / Cursor / OpenClaw
+
+每一次与编程助手的交互会话，本质上都是一个 Agentic Loop：
+
+```
+读取用户请求 → 检查代码仓库 → 编辑文件 → 运行测试 → 识别报错 → 再次编辑 → ... → 构建成功
+```
+
+这套 **推理 → 行动 → 观察结果** 的往复流程，如今几乎所有的生产级编程智能体都以它为核心。
+
+### 📊 办公场景
+
+- 自动整理会议纪要 → 提炼重点 → 拆解待办 → 生成执行方案 → 跟进任务进度
+- 读取表格数据 → 分析异常 → 生成可视化报告 → 给出优化建议
+
+### ✍️ 内容场景
+
+- 自主选题 → 搜索资料 → 梳理框架 → 撰写初稿 → 校对纠错 → 优化措辞 → 排版输出
+
+### 🏠 智能硬件场景
+
+扫地机器人避障规划、智能温控调节、自动驾驶路况判断——本质都是持续 **感知 → 决策 → 行动 → 修正** 的小型 Agent Loop 循环。
+
+> **所有「越用越聪明、能自主干活」的 AI，核心都是 Agentic Loop。**
+
+---
+
+## 十一、关联循环体系
+
+Agentic Loop 并非孤立存在，外部多层循环会直接影响其架构设计：
+
+### 三大关联循环
+
+```mermaid
+flowchart TB
+    TL["🔄 训练循环<br/>数据采集 → 梯度更新 → 效果评估 → 版本发布<br/>离线流程 · 周期以天/周计"] 
+    
+    AL["🔄 Agentic Loop（智能体循环）<br/>推理 → 行动 → 观察 → 再推理<br/>在线实时流程 · 以秒计"]
+    
+    FL["🔄 反馈循环<br/>工具返回 → 用户修正 → 量化指标 → 评估监控"]
+    
+    HL["🔄 人工介入循环<br/>AI 暂停 → 人工审核 → 确认/修改 → 继续运行"]
+    
+    AL -->|"产生交互数据"| FL
+    FL -->|"存入记忆库"| TL
+    AL -->|"触及权限边界"| HL
+    HL -->|"确认后继续"| AL
+```
+
+| 循环类型 | 性质 | 周期 | 说明 |
+|----------|------|------|------|
+| **训练循环** | 离线 | 天/周 | 大模型诞生的底层流程；现阶段与 Agentic Loop 完全解耦（模型权重固定） |
+| **反馈循环** | 在线 | 实时 | 每次动作产生的反馈信号（工具返回、用户修正、量化指标）；持续迭代进化的核心 |
+| **人工介入循环** | 按需 | 不定 | AI 遇到无法自主决策的节点时主动暂停，等待人工确认 |
+
+### ⚠️ 关键边界：训练循环 vs Agentic Loop
+
+现阶段两类循环 **完全解耦**：
+- 模型训练完成后权重固定，Agent 在静态权重之上运行
+- 对话中表现出的"记忆""学习""纠错"，**并非更新模型权重**，只是从内存检索历史信息
+- 分清两者边界才能精准定位问题：需要优化记忆存储？还是重新训练大模型？
+
+---
+
+## 十二、行业趋势与未来方向
+
+### AI 技术的三次范式跃迁
+
+```
+判别式 AI ──▶ 生成式 AI ──▶ Agentic AI
+ (分类/预测)    (ChatGPT)    (自主执行任务)
+```
+
+英伟达 CEO 黄仁勋在 **2025 GTC 大会**上宣称：我们即将步入 **Agentic AI 时代**。英伟达称 Agentic AI 为 **"人工智能的下一个前沿"**。
+
+### 从 Prompt Engineering 到 Loop Engineering
+
+> **AI 的竞争，从「单次提示优化」变成了「循环系统设计」。**
+
+| 过去（Prompt Engineering） | 现在（Loop Engineering） |
+|---------------------------|--------------------------|
+| 反复打磨提示词 | 设计更合理的 Agent Loop |
+| 细化指令、预设场景 | 优化推理逻辑、调整循环策略 |
+| 人工弥补 AI 不智能 | 让 AI 自己试错、自己优化 |
+| 单次交互质量 | 循环系统效能 |
+
+### 未来方向：打通全链路持续学习
+
+当前智能体循环、模型训练循环、反馈循环分属三套独立开发体系。未来方向是将它们 **打通闭环**：
+
+```
+Agentic Loop 产出真实交互经验
+        ↓
+  存入记忆库（高质量数据）
+        ↓
+  持续学习技术（Continual Learning）
+        ↓
+  把经验融入模型参数
+        ↓
+  模型越来越强 → Agent 越来越聪明
+```
+
+届时 **记忆存储的数据质量将直接决定训练素材质量**——规整清晰的聊天记录、精准提取的关键信息、可靠的反馈评价，能产出高质量训练数据；杂乱无章、无规划存储的对话，无法用于模型迭代。
+
+---
+
+## 十三、核心价值总结
+
+Agentic Loop 赋予了 AI 系统四大核心能力：
+
+| 能力 | 图标 | 说明 |
+|------|------|------|
+| **自主性 (Autonomy)** | 🧠 | 无需持续人工干预即可持续推进任务 |
+| **目标导向 (Goal-Directed)** | 🎯 | 理解抽象目标并将其转化为具体行动序列 |
+| **动态适应 (Adaptive)** | 🔄 | 通过持续的环境反馈优化策略 |
+| **多模态协作 (Multi-tool)** | 🔗 | 整合多源数据，支持跨工具/跨系统调用 |
+
+### 一句话总结
+
+> **没有 Agentic Loop，AI Agent 就只是一个静态的问答工具；有了它，AI 才真正具备了"持续自主完成复杂任务"的能力。**
+>
+> **单次输出是工具，循环闭环才是智能。**
+
+---
+
+## 参考来源
+
+### 核心论文
+- Yao, S., et al. (2022). **ReAct: Synergizing Reasoning and Acting in Language Models** — [CSDN 解析](https://blog.csdn.net/enjoyedu/article/details/159416232)
+
+### 深度解析文章
+- [解读 Agent Loop（智能体循环）的三层分级体系](https://www.111cn.net/new/602954.htm) — 一聚教程网
+- [看懂 Agent Loop：AI 从「被动问答」到「自主干活」的核心密码](https://cloud.tencent.com/developer/article/2694843) — 腾讯云开发者社区
+- [推理 → 行动 → 观察：用 LangChain + Python 实现一个智能体循环](https://blog.csdn.net/m0_46510245/article/details/161346563)
+- [OpenAI 解析 Codex CLI 核心机制：Agent Loop 工作流程详解](https://www.imooc.com/article/388435)
+- [OpenClaw 源码深度解析：Agent Loop 如何调用 LLM 和工具](https://blog.csdn.net/ha_9527/article/details/158903245)
+- [深入解析 Agent 内部机制：六大核心支柱](https://blog.csdn.net/l01011_/article/details/161116948)
+- [Agent 底层运行逻辑拆解：读懂 Agent Loop 与 Turn 运行本质](https://blog.csdn.net/u013970991/article/details/161750174)
+
+### 设计模式与架构
+- [《Agentic Design Patterns》中文电子书](https://blog.csdn.net/weixin_54416957/article/details/159979689) — 涵盖反思、工具使用、规划、多智能体协作等模式
+- [AI 智能体的系统架构与核心设计模式](https://blog.csdn.net/Code1994/article/details/151221580)
+- [Agentic Design Patterns 第5章：Tool Use 工具调用模式](https://blog.csdn.net/wangyaninglm/article/details/153145056)
+- [LangChain 源码解析：Function Call 是如何被执行的](https://cloud.tencent.com/developer/article/2657653)
+- [Orchestrator 为什么比 Agentic Loop 快：LLM 决策与执行分离](https://so.html5.qq.com/page/real/search_news?docid=70000021_0236a280df558552)
+
+### 行业趋势
+- [2026 版 Agentic AI 从原理到实战完整指南](https://blog.csdn.net/weixin_59191169/article/details/160925182)
+- [CES 2025：Agentic AI 将如何改变未来的工作和生活](https://www.sohu.com/a/844233934_121902920)
+- [2025 GTC 大会：Agentic AI 与 Robotic AI 的未来探讨](https://www.sohu.com/a/875875299_121902920)
+- [IBM: What Is Agentic Reasoning?](https://www.ibm.com/think/topics/agentic-reasoning)
+- [Human-in-the-Loop 人机协同策略](https://blog.csdn.net/Anspire/article/details/150609597)
+- [一文读懂 Agentic AI 技术点滴](http://www.51testing.com/mobile/view.php?itemid=7804918)
+
+---
+
+> 📝 **文档版本**：v2.0（增强版）  
+> 📅 **最后更新**：2026-07-11  
+> 📖 **本文档基于公开技术资料整理，涵盖概念解析、分层体系、代码实现、工程实践与行业趋势
diff --git a/package-lock.json b/package-lock.json
index bcba397..f841e42 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "metona-ollama-desktop",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "metona-ollama-desktop",
-      "version": "0.15.0",
+      "version": "0.16.0",
       "license": "MIT",
       "dependencies": {
         "ffmpeg-static": "^5.2.0",
diff --git a/package.json b/package.json
index b9f987f..ba89bd0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "metona-ollama-desktop",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Metona Ollama - TypeScript + Electron 桌面 AI 聊天客户端",
   "main": "dist/main/main.js",
   "author": "thzxx",
diff --git a/src/main/menu.ts b/src/main/menu.ts
index 3175bc8..c4ded45 100644
--- a/src/main/menu.ts
+++ b/src/main/menu.ts
@@ -101,7 +101,7 @@ export function createMenu(): void {
             dialog.showMessageBox(mainWindow!, {
               type: 'info',
               title: '关于 Metona Ollama',
-              message: 'Metona Ollama Desktop v0.15.0',
+              message: 'Metona Ollama Desktop v0.16.0',
               detail: 'TypeScript + Electron Ollama AI 聊天客户端\n\nhttps://gitee.com/thzxx/metona-ollama',
               icon: getIconPath()
             });
diff --git a/src/renderer/components/chat-area.ts b/src/renderer/components/chat-area.ts
index 2f091d1..525208c 100644
--- a/src/renderer/components/chat-area.ts
+++ b/src/renderer/components/chat-area.ts
@@ -378,15 +378,40 @@ let _streamRenderPending = false;
 let _streamRenderContent = '';
 let _streamRenderThink: string | null = null;
 let _streamRenderModel: string | undefined;
+// R58: 流式渲染优化 — 增量阈值 + 内容指纹，避免高频小片段冗余重渲染
+let _streamLastRenderedLen = 0;     // 上次渲染时的内容长度
+let _streamLastRenderedHash = 0;     // 上次渲染时的内容哈希（简单 DJB2）
+const STREAM_MIN_DELTA = 15;         // 最小增量字符数（不足则跳过本次渲染）
+
+/** R58: 快速 DJB2 哈希 */
+function _djb2(str: string): number {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0x7fffffff;
+  }
+  return hash;
+}
 
 /**
  * 执行实际的流式 Markdown 渲染
+ * R58: 添加增量阈值检查 — 内容增长不足 STREAM_MIN_DELTA 字符时跳过渲染
  */
 function _doStreamRender(): void {
   _streamRenderPending = false;
   const lastMsg = currentPlaceholder;
   if (!lastMsg) return;
 
+  // R58: 增量阈值检查 — 内容变化不足时跳过本次渲染
+  const contentLen = _streamRenderContent.length;
+  const contentHash = _djb2(_streamRenderContent);
+  if (contentLen > 0 && contentHash === _streamLastRenderedHash) return; // 内容完全相同
+  if (contentLen - _streamLastRenderedLen < STREAM_MIN_DELTA && contentLen > 100) {
+    // 内容增长不足且已有内容 → 跳过本次，等下次 rAF
+    return;
+  }
+  _streamLastRenderedLen = contentLen;
+  _streamLastRenderedHash = contentHash;
+
   const contentDiv = lastMsg.querySelector('.msg-content');
   if (contentDiv && _streamRenderContent) {
     // 智能补全不完整的 Markdown 语法后渲染
@@ -460,6 +485,10 @@ export function updateLastAssistantMessage(
         requestAnimationFrame(_doStreamRender);
       }
     }
+  } else if (isFinal) {
+    // R58: 最终渲染时重置增量追踪状态
+    _streamLastRenderedLen = 0;
+    _streamLastRenderedHash = 0;
   }
 
   let thinkBlock = lastMsg.querySelector('.think-block');
diff --git a/src/renderer/index.html b/src/renderer/index.html
index a925268..ee44785 100644
--- a/src/renderer/index.html
+++ b/src/renderer/index.html
@@ -28,7 +28,7 @@
         <div class="header-left">
             <img class="logo" src="./assets/icons/llama.png" alt="logo" />
             <span class="app-title">Metona Ollama</span>
-            <span class="app-version">v0.15.0</span>
+            <span class="app-version">v0.16.0</span>
             <button class="icon-btn help-btn" id="btnHelp" title="使用帮助">
                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                     <circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/>
diff --git a/src/renderer/services/agent-engine.ts b/src/renderer/services/agent-engine.ts
index 779504c..ec02cd5 100644
--- a/src/renderer/services/agent-engine.ts
+++ b/src/renderer/services/agent-engine.ts
@@ -9,19 +9,65 @@ import { state, KEYS } from '../state/state.js';
 import {
   executeTool,
   getEnabledToolDefinitions,
+  getRelevantToolDefinitions,
   needsConfirmation,
   initPlanTracker,
   getPlanTracker,
   formatPlanStatus,
   clearPlanTracker,
 } from './tool-registry.js';
+import {
+  compactOldToolResult,
+  detectOscillation,
+  recordToolCallHistory,
+  detectConsecutiveIdentical,
+  setUserGoal,
+  checkGoalAlignment,
+  resetAllSafetyState,
+  checkRateLimit,
+  classifyError,
+  calculateBackoff,
+  validatePathSandbox,
+  isToolCircuitBroken,
+  recordToolFailure,
+  recordToolSuccess,
+  // R88: 工具结果元数据
+  addResultMetadata,
+  // R97: 错误模式学习
+  recordErrorPattern,
+  // R104: 工具结果去重
+  isDuplicateToolResult,
+  // R109: 工具参数消毒
+  sanitizeToolArgs,
+  // R112: 诊断系统
+  collectDiagnostics,
+  // R113: 命令安全检查
+  checkCommandSafety,
+  // R95: 按工具类型智能截断
+  smartTruncateByToolType,
+  // R99: 工具结果引用解析
+  checkArchivedReferences,
+} from './agent-safety.js';
 import { search, formatMemoryContext, loadAllEntries } from './memory-service.js';
 
 import { showToast } from '../components/toast.js';
 import { logInfo, logWarn, logSuccess, logError, logToolStart, logToolResult, logAgentLoop, logModelResponse, logStreamProgress, resetStreamProgress } from './log-service.js';
 import { getWorkspaceDirPath } from '../components/workspace-panel.js';
 import { generateId } from '../utils/utils.js';
-import { buildContext, estimateTokens, shouldAutoCompress, compressWithLLM, AUTO_COMPRESS_THRESHOLD, recordActualTokens } from './context-manager.js';
+import {
+  buildContext, estimateTokens, shouldAutoCompress, compressWithLLM,
+  AUTO_COMPRESS_THRESHOLD, recordActualTokens, predictContextOverflow, recordTokenUsage,
+  // R91: 上下文压力分级评估
+  getContextPressureLevel,
+  // R93: Token 预算追踪器
+  recordBudgetUsage, setTokenBudgetNumCtx, resetTokenBudget,
+  // R96: 消息角色压缩
+  mergeConsecutiveMessages,
+  // R98: 压缩触发阈值优化
+  getTrendAwareCompressThreshold,
+  // R100: Token 使用统计报告
+  generateTokenReport, formatTokenReport,
+} from './context-manager.js';
 import { runCompletionGate } from './completion-gate.js';
 import { executeHooks } from './hooks.js';
 import { recordIteration, recordToolCall, recordCompletionGate, startSessionMetrics, endSessionMetrics } from './agent-metrics.js';
@@ -43,6 +89,12 @@ const MAX_MESSAGES = 300;           // 上下文硬上限，超过则强制压
 const API_MAX_RETRIES = 2;          // Ollama API 调用失败重试次数
 const MAX_PARALLEL_TOOLS = 5;       // R6: 单批次最大并行工具数
 
+// R51-R54: 工具结果离线存储、震荡检测、死循环检测已迁移至 agent-safety.ts
+// R56: 目标对齐验证也已迁移至 agent-safety.ts
+
+// R55: 语义工具检索 — 缓存当前轮过滤后的工具定义，避免 handleThinking 重复计算
+let _filteredTools: import('../types.js').ToolDefinition[] = [];
+
 /**
  * 计算增量压缩触发阈值（按 token 数而非消息条数）
  * 当上下文 token 占比超过 numCtx 的 30% 时触发压缩
@@ -145,45 +197,91 @@ const SIDE_EFFECT_TOOLS = new Set([
  * 防止单个工具调用挂起导致整个 Agent Loop 卡死
  * 0 = 不限制（仅依赖全局 AbortController）
  */
-const TOOL_TIMEOUT_MAP: Record<string, number> = {
-  read_file: 30_000,          // 读取文件 30s
-  write_file: 15_000,         // 写入文件 15s
-  edit_file: 15_000,          // 编辑文件 15s
-  list_directory: 10_000,     // 列目录 10s
-  search_files: 60_000,       // 搜索文件 60s
-  create_directory: 5_000,    // 创建目录 5s
-  delete_file: 10_000,        // 删除文件 10s
-  move_file: 15_000,          // 移动文件 15s
-  copy_file: 30_000,          // 复制文件 30s（可能大文件）
-  get_file_info: 5_000,       // 获取文件信息 5s
-  tree: 15_000,               // 目录树 15s
-  diff_files: 15_000,         // 文件差异 15s
-  replace_in_files: 30_000,   // 批量替换 30s
-  read_multiple_files: 60_000,// 批量读取 60s
-  web_search: 30_000,         // 网页搜索 30s
-  web_fetch: 60_000,          // 网页抓取 60s
-  download_file: 120_000,     // 下载文件 120s
-  git: 30_000,                // Git 操作 30s
-  compress: 60_000,           // 压缩 60s
-  memory: 5_000,              // 记忆操作 5s
-  session_list: 5_000,        // 会话列表 5s
-  session_read: 10_000,       // 会话读取 10s
-  datetime: 1_000,            // 时间查询 1s
-  calculator: 3_000,          // 计算器 3s
-  random: 1_000,              // 随机数 1s
-  uuid: 1_000,                // UUID 1s
-  json_format: 3_000,         // JSON 格式化 3s
-  hash: 3_000,                // 哈希计算 3s
-  default: 60_000,            // 默认 60s
+/** R3/R108: 工具超时配置（基础超时 + 动态调整） */
+const TOOL_TIMEOUT_MAP: Record<string, { base: number; grade: 'fast' | 'medium' | 'slow' | 'long'; description: string }> = {
+  // fast (<5秒)
+  datetime: { base: 1_000, grade: 'fast', description: '时间查询' },
+  random: { base: 1_000, grade: 'fast', description: '随机数' },
+  uuid: { base: 1_000, grade: 'fast', description: 'UUID' },
+  calculator: { base: 3_000, grade: 'fast', description: '计算器' },
+  json_format: { base: 3_000, grade: 'fast', description: 'JSON 格式化' },
+  hash: { base: 3_000, grade: 'fast', description: '哈希计算' },
+  create_directory: { base: 5_000, grade: 'fast', description: '创建目录' },
+  get_file_info: { base: 5_000, grade: 'fast', description: '获取文件信息' },
+  memory: { base: 5_000, grade: 'fast', description: '记忆操作' },
+  session_list: { base: 5_000, grade: 'fast', description: '会话列表' },
+  
+  // medium (5-15秒)
+  list_directory: { base: 10_000, grade: 'medium', description: '列目录' },
+  delete_file: { base: 10_000, grade: 'medium', description: '删除文件' },
+  write_file: { base: 15_000, grade: 'medium', description: '写入文件' },
+  edit_file: { base: 15_000, grade: 'medium', description: '编辑文件' },
+  move_file: { base: 15_000, grade: 'medium', description: '移动文件' },
+  tree: { base: 15_000, grade: 'medium', description: '目录树' },
+  diff_files: { base: 15_000, grade: 'medium', description: '文件差异' },
+  session_read: { base: 10_000, grade: 'medium', description: '会话读取' },
+  web_search: { base: 30_000, grade: 'medium', description: '网页搜索' },
+  git: { base: 30_000, grade: 'medium', description: 'Git 操作' },
+  
+  // slow (15-60秒)
+  read_file: { base: 30_000, grade: 'slow', description: '读取文件' },
+  copy_file: { base: 30_000, grade: 'slow', description: '复制文件' },
+  replace_in_files: { base: 30_000, grade: 'slow', description: '批量替换' },
+  search_files: { base: 60_000, grade: 'slow', description: '搜索文件' },
+  read_multiple_files: { base: 60_000, grade: 'slow', description: '批量读取' },
+  web_fetch: { base: 60_000, grade: 'slow', description: '网页抓取' },
+  compress: { base: 60_000, grade: 'slow', description: '压缩' },
+  
+  // long (>60秒)
+  download_file: { base: 120_000, grade: 'long', description: '下载文件' },
+  default: { base: 60_000, grade: 'medium', description: '默认工具' },
 };
 
+/** R108: 根据工具参数动态调整超时时间 */
+function getAdjustedToolTimeout(toolName: string, args: Record<string, unknown>): number {
+  const config = TOOL_TIMEOUT_MAP[toolName] ?? TOOL_TIMEOUT_MAP.default;
+  let timeout = config.base;
+  
+  // run_command 特殊处理：根据命令类型调整
+  if (toolName === 'run_command' && args.command) {
+    const cmd = String(args.command);
+    if (cmd.includes('npm install') || cmd.includes('pip install') || cmd.includes('apt-get install')) {
+      timeout = 300_000; // 包安装：5分钟
+    } else if (cmd.includes('build') || cmd.includes('compile') || cmd.includes('make')) {
+      timeout = 180_000; // 编译：3分钟
+    } else if (cmd.includes('test')) {
+      timeout = 120_000; // 测试：2分钟
+    } else {
+      timeout = 120_000; // 默认命令：2分钟
+    }
+  }
+  
+  // web_fetch 特殊处理：视频/大型资源
+  if (toolName === 'web_fetch' && args.url) {
+    const url = String(args.url);
+    if (url.includes('youtube') || url.includes('video') || url.includes('mp4')) {
+      timeout = 90_000;
+    }
+  }
+  
+  // write_file 特殊处理：大文件
+  if (toolName === 'write_file' && args.content) {
+    const contentLen = String(args.content).length;
+    if (contentLen > 100_000) {
+      timeout = 30_000; // 大文件写入
+    }
+  }
+  
+  return timeout;
+}
+
 /** R3: 带超时的工具执行包装器 */
 async function executeToolWithTimeout(
   toolName: string,
   args: Record<string, unknown>,
   abortSignal?: AbortSignal,
 ): Promise<ToolResult> {
-  const timeoutMs = TOOL_TIMEOUT_MAP[toolName] ?? TOOL_TIMEOUT_MAP.default;
+  const timeoutMs = getAdjustedToolTimeout(toolName, args);
   if (timeoutMs <= 0) {
     return executeTool(toolName, args);
   }
@@ -1084,9 +1182,15 @@ async function handleInit(
 ): Promise<void> {
   // 新一轮对话，清空工具缓存
   toolResultCache.clear();
+resetAllSafetyState(); // R51-R56: 重置所有安全状态
+resetTokenBudget(); // R93: 重置 Token 预算追踪
+setTokenBudgetNumCtx(getEffectiveNumCtx()); // R93: 设置当前预算 numCtx
+setUserGoal(userContent); // R56: 设置用户原始目标
 
   const modelSupportsTools = state.get<boolean>('modelSupportsTools', false);
-  const tools = getEnabledToolDefinitions();
+  // R55: 语义工具检索 — 根据用户查询过滤相关工具，减少 token 占用
+  const tools = getRelevantToolDefinitions(userContent);
+  _filteredTools = tools; // 缓存供 handleThinking 使用
   const useTools = tools.length > 0;
 
   ctx.messages.length = 0;
@@ -1568,7 +1672,7 @@ async function handleThinking(
             num_ctx: getEffectiveNumCtx(),
             temperature: state.get<number>('temperature', 0.7)
           },
-          ...(getEnabledToolDefinitions().length > 0 && { tools: getEnabledToolDefinitions() })
+          ...(_filteredTools.length > 0 && { tools: _filteredTools })
         },
         (chunk: OllamaStreamChunk) => {
           if (chunk.message?.thinking) {
@@ -1710,6 +1814,8 @@ async function handleThinking(
       if (estimatedThisLoop > 0) {
         recordActualTokens(ctx.loopPromptEvalCount, ctx.loopEvalCount, estimatedThisLoop, model);
       }
+      // R93: 记录 Token 预算使用
+      recordBudgetUsage(ctx.loopCount, ctx.loopPromptEvalCount, ctx.loopEvalCount, estimatedThisLoop);
     }
   } catch { /* ignore */ }
 
@@ -1845,6 +1951,25 @@ async function handleExecuting(
       toolResultCache.delete(cacheKey);
     }
 
+    // R109: 工具参数消毒 — 防止通过工具参数注入恶意内容
+    call.function.arguments = sanitizeToolArgs(call.function.name, call.function.arguments);
+
+    // R113: 命令安全检查 — 对 run_command 进行风险评估
+    if (call.function.name === 'run_command') {
+      const cmdStr = String(call.function.arguments?.command || '');
+      if (cmdStr) {
+        const cmdSafety = checkCommandSafety(cmdStr);
+        if (cmdSafety.riskLevel === 'forbidden') {
+          logWarn(`R113: 命令安全拦截: ${cmdSafety.reason}`);
+          return [{
+            name: call.function.name, arguments: call.function.arguments,
+            result: { success: false, error: cmdSafety.reason || '命令被安全规则拦截' },
+            status: 'error' as const, timestamp: Date.now()
+          }, null];
+        }
+      }
+    }
+
     // P2-4: 工具参数前置校验 — 参数无效直接返回错误，不执行实际工具，节省一轮迭代
     const paramError = validateToolArgs(call.function.name, call.function.arguments);
     if (paramError) {
@@ -1856,6 +1981,62 @@ async function handleExecuting(
       }, null];
     }
 
+    // R77: 工具调用速率限制 — 防止快速连续调用同一工具浪费资源
+    const rateLimitResult = checkRateLimit(call.function.name);
+    if (!rateLimitResult.allowed) {
+      const waitSec = Math.ceil(rateLimitResult.retryAfterMs / 1000);
+      logWarn(`R77: 速率限制拦截: ${call.function.name}，需等待 ${waitSec}s`);
+      return [{
+        name: call.function.name, arguments: call.function.arguments,
+        result: { success: false, error: `工具「${call.function.name}」调用频率过高，请等待 ${waitSec} 秒后重试。` },
+        status: 'error' as const, timestamp: Date.now()
+      }, null];
+    }
+
+    // R87: 工具熔断器检查 — 连续失败后自动禁用工具
+    const circuitBreaker = isToolCircuitBroken(call.function.name);
+    if (circuitBreaker.broken) {
+      const waitSec = Math.ceil(circuitBreaker.remainingMs / 1000);
+      logWarn(`R87: 熔断器拦截: ${call.function.name}，冷却中（还需 ${waitSec}s）`);
+      return [{
+        name: call.function.name, arguments: call.function.arguments,
+        result: { success: false, error: `工具「${call.function.name}」因连续失败已被暂时禁用，请等待 ${waitSec} 秒后重试，或使用其他方法。` },
+        status: 'error' as const, timestamp: Date.now()
+      }, null];
+    }
+
+    // R79: 路径沙箱验证 — 确保文件操作不超出工作空间边界
+    const FILE_PATH_TOOLS = new Set([
+      'read_file', 'write_file', 'edit_file', 'delete_file', 'create_directory',
+      'list_directory', 'search_files', 'get_file_info', 'tree', 'compress',
+      'move_file', 'copy_file', 'replace_in_files', 'download_file',
+    ]);
+    if (FILE_PATH_TOOLS.has(call.function.name)) {
+      const workspaceDir = getWorkspaceDirPath();
+      if (workspaceDir) {
+        const pathArg = String(call.function.arguments?.path || call.function.arguments?.source || call.function.arguments?.destination || call.function.arguments?.file1 || '');
+        if (pathArg) {
+          const sandboxResult = validatePathSandbox(pathArg, workspaceDir);
+          if (!sandboxResult.valid) {
+            logWarn(`R79: 路径沙箱拦截: ${call.function.name}(${pathArg}) — ${sandboxResult.reason}`);
+            return [{
+              name: call.function.name, arguments: call.function.arguments,
+              result: { success: false, error: sandboxResult.reason || '路径不在工作空间范围内' },
+              status: 'error' as const, timestamp: Date.now()
+            }, null];
+          }
+          // R79: 使用标准化路径替换原始路径，防止路径遍历
+          if (sandboxResult.normalizedPath && sandboxResult.normalizedPath !== pathArg) {
+            if (call.function.arguments?.path) {
+              call.function.arguments.path = sandboxResult.normalizedPath;
+            } else if (call.function.arguments?.source) {
+              call.function.arguments.source = sandboxResult.normalizedPath;
+            }
+          }
+        }
+      }
+    }
+
     // P2-10 修复：queueMicrotask 替代 rAF，在隐藏窗口下不会降频
     await new Promise<void>(r => { queueMicrotask(r); });
     callbacks.onToolCallStart(call);
@@ -1887,8 +2068,9 @@ async function handleExecuting(
       }
     }
 
-    // ── P0-1 修复：区分瞬态错误和永久错误 ──
+    // ── R78: 增强错误分类重试 — 使用 classifyError 区分瞬态/永久/安全错误 ──
     let lastError = '';
+    let classifiedError: import('./agent-safety.js').ClassifiedError | null = null;
     for (let retry = 0; retry <= MAX_RETRIES; retry++) {
       // 重试前检查中止信号
       if (isAborted()) {
@@ -1903,6 +2085,12 @@ async function handleExecuting(
           state.get<AbortController | null>(KEYS.ABORT_CONTROLLER)?.signal)
           .catch(err => ({ success: false, error: err?.message || String(err) }) as ToolResult);
         logToolResult(call.function.name, result.success, result.success ? undefined : result.error);
+        // R87: 记录工具成功/失败到熔断器
+        if (result.success) {
+          recordToolSuccess(call.function.name);
+        } else {
+          recordToolFailure(call.function.name);
+        }
         // 记录 write_file 成功路径及内容指纹，供 FileWriteDedup Hook 做内容级去重
         if (call.function.name === 'write_file' && result.success && call.function.arguments?.path) {
           const { addWrittenFile } = await import('./hooks.js');
@@ -1914,27 +2102,47 @@ async function handleExecuting(
         }, result.success ? cacheKey : null];
       } catch (err) {
         lastError = (err as Error).message;
-        // 永久性错误不重试：文件不存在、权限拒绝、路径不可达
-        if (isPermanentError(lastError)) {
-          logWarn(`工具永久错误（不重试）: ${call.function.name}`, lastError);
+        // R78: 使用错误分类系统替代原有的 isPermanentError
+        classifiedError = classifyError(lastError);
+        
+        // 安全错误或永久错误：不重试
+        if (!classifiedError.shouldRetry) {
+          logWarn(`R78: 工具${classifiedError.class}错误（不重试）: ${call.function.name}`, classifiedError.userMessage);
           return [{
             name: call.function.name, arguments: call.function.arguments,
-            result: { success: false, error: lastError },
+            result: { success: false, error: classifiedError.userMessage },
             status: 'error' as const, timestamp: Date.now()
           }, null];
         }
+        
+        // R78: 检查是否超过最大重试次数
+        if (retry >= (classifiedError.maxRetries || MAX_RETRIES)) {
+          logError(`R78: 工具执行失败（已达最大重试 ${classifiedError.maxRetries}）: ${call.function.name}`, lastError);
+          // R97: 记录错误模式并获取改进建议
+          const errorSuggestion = recordErrorPattern(call.function.name, lastError);
+          if (errorSuggestion) {
+            logWarn(`R97: ${errorSuggestion}`);
+          }
+          return [{
+            name: call.function.name, arguments: call.function.arguments,
+            result: { success: false, error: classifiedError.userMessage },
+            status: 'error' as const, timestamp: Date.now()
+          }, null];
+        }
+        
         if (retry < MAX_RETRIES) {
-          // 瞬态错误：指数退避重试
-          const delay = 500 * Math.pow(2, retry);
-          logWarn(`工具重试 ${retry + 1}/${MAX_RETRIES}: ${call.function.name}（${delay}ms 后）`, lastError);
+          // R78: 使用 calculateBackoff 计算指数退避延迟
+          const delay = calculateBackoff(retry, classifiedError.backoffMs);
+          logWarn(`R78: 工具重试 ${retry + 1}/${classifiedError.maxRetries}: ${call.function.name}（${classifiedError.class}错误，${delay}ms 后）`, lastError);
           await new Promise(r => setTimeout(r, delay));
           continue;
         }
-        logError(`工具执行失败（已达最大重试）: ${call.function.name}`, lastError);
+                logError(`工具执行失败（已达最大重试）: ${call.function.name}`, lastError);
+        // R97: 记录错误模式
+        recordErrorPattern(call.function.name, lastError);
         return [{
           name: call.function.name, arguments: call.function.arguments,
-          result: { success: false, error: lastError },
-          status: 'error' as const, timestamp: Date.now()
+          result: { success: false, error: lastError }, status: 'error' as const, timestamp: Date.now()
         }, null];
       }
     }
@@ -1962,9 +2170,23 @@ async function handleExecuting(
 
     for (const [record, cacheKey] of results) {
       ctx.allToolRecords.push(record);
+      // R88: 为工具结果添加元数据提示（token 估算）
+      const formattedResult = addResultMetadata(formatToolResultForModel(record.name, record.result!));
+      // R104: 检测重复工具结果
+      if (record.status === 'success') {
+        const dedup = isDuplicateToolResult(record.name, formattedResult);
+        if (dedup.duplicate) {
+          logInfo(`R104: 检测到重复工具结果: ${record.name}，添加标记`);
+        }
+      }
+      // R92: 工具结果格式标准化 — 添加统一头信息（工具名、状态、耗时、结果大小）
+      const resultDuration = Date.now() - record.timestamp;
+      const resultSize = formattedResult.length;
+      const sizeCategory = resultSize > 10000 ? 'large' : resultSize > 2000 ? 'medium' : 'small';
+      const r92Header = `[工具:${record.name} 状态:${record.status} 耗时:${resultDuration}ms 大小:${sizeCategory}(${resultSize}字符)]`;
       ctx.messages.push({
         role: 'tool', tool_name: record.name,
-        content: `<<<TOOL_RESULT_START name="${record.name}">>>\n${formatToolResultForModel(record.name, record.result!)}\n<<<TOOL_RESULT_END>>>`
+        content: `<<<TOOL_RESULT_START name="${record.name}">>>\n${r92Header}\n${formattedResult}\n<<<TOOL_RESULT_END>>>`
       });
       // P1-3 优化：移除逐次 nudge 注入，改为 AGENT.md 通用规则
       // 原逻辑：memory/session_read/session_list/spawn_task 后注入额外 user 消息
@@ -2006,13 +2228,15 @@ async function handleObserving(
 ): Promise<void> {
   // 中止检查
   if (isAborted()) return;
-  // 硬限制工具消息数量 — 保留最近 80 条（token感知：压力大时自动缩减）
+  // R91: 上下文压力分级评估 — 根据压力等级选择压缩策略
+  const numCtx = getEffectiveNumCtx();
+  const pressureInfo = getContextPressureLevel(ctx.messages, numCtx);
   {
-    const numCtx = getEffectiveNumCtx();
-    const currentTokens = estimateTokens(ctx.messages.map(m => m.content || '').join(''));
-    const pressureRatio = numCtx > 0 ? currentTokens / numCtx : 0;
-    // 压力小时保留 80 条，压力大时缩减到 40 条
-    const maxToolMsgs = pressureRatio > 0.5 ? 40 : 80;
+    // R91: 根据压力等级动态调整工具消息保留数量
+    const maxToolMsgs = pressureInfo.level === 'critical' ? 30
+      : pressureInfo.level === 'high' ? 40
+      : pressureInfo.level === 'medium' ? 60
+      : 80;
     const toolIndices: number[] = [];
     for (let i = 0; i < ctx.messages.length; i++) {
       if (ctx.messages[i].role === 'tool') toolIndices.push(i);
@@ -2022,7 +2246,7 @@ async function handleObserving(
       for (let i = toRemove.length - 1; i >= 0; i--) {
         ctx.messages.splice(toRemove[i], 1);
       }
-      logInfo(`工具消息裁剪: ${toRemove.length} 条旧结果已移除 (保留最近 ${maxToolMsgs} 条, 压力 ${(pressureRatio * 100).toFixed(0)}%)`);
+      logInfo(`R91: 工具消息裁剪: ${toRemove.length} 条旧结果已移除 (压力:${pressureInfo.level}, 保留 ${maxToolMsgs} 条)`);
     }
   }
 
@@ -2034,6 +2258,75 @@ async function handleObserving(
   // 保存本轮工具调用
   ctx.prevToolCalls = [...ctx.toolCalls];
 
+  // R52: 状态震荡检测 — 检测 A→B→A→B 模式
+  for (const call of ctx.toolCalls) {
+    recordToolCallHistory(call.function.name, call.function.arguments);
+  }
+  if (detectOscillation()) {
+    logWarn('R52: 检测到工具调用震荡模式（A→B→A→B），注入终止信号');
+    ctx.messages.push({
+      role: 'user',
+      content: '⚠️ 检测到你在两种操作之间来回切换但没有进展。请停下来分析当前状态，换一种策略，或基于已有结果给出最终回答。',
+      ephemeral: true,
+    });
+    ctx.maxLoops = Math.min(ctx.maxLoops, ctx.loopCount + 2);
+  }
+
+  // R54: 增强死循环检测 — 连续 3 次完全相同的工具调用（文档标准）
+  const consecutive = detectConsecutiveIdentical(3);
+  if (consecutive.detected) {
+    logWarn(`R54: 检测到连续 ${consecutive.count} 次相同调用: ${consecutive.toolName}，强制终止`);
+    ctx.messages.push({
+      role: 'user',
+      content: `⛔ 检测到连续 ${consecutive.count} 次用完全相同参数调用「${consecutive.toolName}」。这已被系统识别为死循环。立即停止重复调用，基于已有结果给出最终回答。`,
+    });
+    ctx.maxLoops = Math.min(ctx.maxLoops, ctx.loopCount + 1);
+  }
+
+  // R53: 主动上下文压缩 — 使用预测系统提前触发压缩
+  {
+    const numCtx = getEffectiveNumCtx();
+    const currentTokens = estimateTokens(ctx.messages.map(m => m.content || '').join(''));
+    recordTokenUsage(currentTokens, numCtx);
+    const prediction = predictContextOverflow(numCtx);
+    if (prediction.level === 'critical' || (prediction.level === 'warning' && prediction.turnsToOverflow <= 2)) {
+      logWarn(`R53: 主动压缩触发 — ${prediction.message}`);
+      transition(ctx, S.COMPRESSING);
+      return;
+    }
+  }
+
+  // R51: 工具结果离线存储 — 将旧的大工具结果精简为引用
+  if (ctx.loopCount > 5 && ctx.loopCount % 3 === 0) {
+    const compactBefore = ctx.messages.length - 10; // 保留最近 10 条不动
+    let compactedCount = 0;
+    for (let i = 0; i < ctx.messages.length && i < compactBefore; i++) {
+      const m = ctx.messages[i];
+      if (m.role === 'tool' && m.content && m.content.length > 1500 && !m.content.startsWith('[工具结果已归档]')) {
+        ctx.messages[i] = compactOldToolResult(m);
+        compactedCount++;
+      }
+    }
+    if (compactedCount > 0) {
+      logInfo(`R51: 工具结果归档: ${compactedCount} 条旧结果已精简为引用`);
+    }
+  }
+
+  // R56: 目标对齐验证 — 每 8 轮检查 Agent 是否偏离用户原始目标
+  if (ctx.loopCount > 0 && ctx.loopCount % 8 === 0) {
+    const recentToolNames = ctx.allToolRecords.slice(-8).map(r => r.name);
+    const recentContent = ctx.messages.slice(-10).map(m => m.content || '').join(' ').slice(0, 2000);
+    const alignment = checkGoalAlignment(recentToolNames, recentContent, ctx.loopCount);
+    if (!alignment.aligned && alignment.suggestion) {
+      logWarn(`R56: 目标对齐检测 — ${alignment.reason}`);
+      ctx.messages.push({
+        role: 'user',
+        content: `[目标对齐提醒] ${alignment.suggestion}`,
+        ephemeral: true,
+      });
+    }
+  }
+
   // P2-1: 工具调用失败恢复指引 — 同一工具同一参数连续失败2次以上时注入恢复建议
   {
     const errorRecords = ctx.allToolRecords.filter(r => r.status === 'error');
@@ -2057,30 +2350,43 @@ async function handleObserving(
     }
   }
 
+  // R112: 每 15 轮输出诊断报告 + R100: Token 使用统计报告
+  if (ctx.loopCount > 0 && ctx.loopCount % 15 === 0) {
+    try {
+      const { collectDiagnostics, formatDiagnosticsReport } = await import('./agent-safety.js');
+      const diag = collectDiagnostics();
+      logInfo('R112: 诊断报告\n' + formatDiagnosticsReport(diag));
+      // R100: Token 使用统计报告
+      const tokenReport = generateTokenReport(getEffectiveNumCtx());
+      logInfo('R100: ' + formatTokenReport(tokenReport));
+    } catch { /* 诊断失败不影响主流程 */ }
+  }
+
   // 记录本轮迭代度量
   recordIteration(ctx);
 
   // ── post_iteration Hook ──
   executeHooks('post_iteration', ctx, { iterationIndex: ctx.loopCount });
 
-  // ── P1-7: 智能工具结果截断 — 保留 JSON 结构，token 感知软上限 ──
-  // 仅在上下文压力较大时触发（token使用率 > 50%），且截断阈值按当前压力动态调整
+  // R95: 按工具类型智能截断 — 根据压力等级和工具类型选择截断策略
   if (ctx.loopCount > 10 && ctx.loopCount % 5 === 0) {
-    const numCtx = getEffectiveNumCtx();
-    const currentTokens = estimateTokens(ctx.messages.map(m => m.content || '').join(''));
-    const pressureRatio = numCtx > 0 ? currentTokens / numCtx : 0;
-    if (pressureRatio > 0.5) {
+    if (pressureInfo.level === 'high' || pressureInfo.level === 'critical') {
       // 上下文压力大时，截断旧的工具结果（保留最近15条不动）
-      // 截断阈值按压力动态调整：50%压力=8000字符，80%压力=3000字符
-      const maxLen = Math.max(2000, Math.floor(8000 - (pressureRatio - 0.5) * 10000));
+      // R91: 截断阈值按压力等级动态调整
+      const maxLen = pressureInfo.level === 'critical' ? 3000 : 5000;
       const truncateBefore = ctx.messages.length - 15;
+      let truncatedCount = 0;
       for (let i = 0; i < ctx.messages.length && i < truncateBefore; i++) {
         const m = ctx.messages[i];
         if (m.role === 'tool' && m.content && m.content.length > maxLen) {
-          ctx.messages[i] = { ...m, content: smartTruncate(m.content, maxLen) };
+          // R95: 使用按工具类型截断替代通用截断
+          ctx.messages[i] = { ...m, content: smartTruncateByToolType(m.tool_name || 'unknown', m.content, maxLen) };
+          truncatedCount++;
         }
       }
-      logInfo(`工具结果截断: 压力 ${(pressureRatio * 100).toFixed(0)}%, 阈值 ${maxLen} 字符`);
+      if (truncatedCount > 0) {
+        logInfo(`R95: 工具结果按类型截断: ${truncatedCount} 条, 压力 ${pressureInfo.level}, 阈值 ${maxLen} 字符`);
+      }
     }
   }
 
@@ -2139,14 +2445,15 @@ async function handleObserving(
     }
   }
 
-  // ── P0-4: 增量压缩 — 按token使用率触发，防止 Ollama context 超限 ──
-  const numCtx = getEffectiveNumCtx();
-  const currentTokens = estimateTokens(ctx.messages.map(m => m.content || '').join(''));
-  const tokenUsageRatio = numCtx > 0 ? currentTokens / numCtx : 0;
-  // 当 token 使用率超过 30% 或消息数超过动态阈值时触发压缩
-  const compressThreshold = getIncrementalCompressThreshold(numCtx);
-  if (tokenUsageRatio > 0.3 || ctx.messages.length >= compressThreshold) {
-    logWarn(`增量压缩触发: token使用率 ${(tokenUsageRatio * 100).toFixed(0)}%, 消息数 ${ctx.messages.length}/${compressThreshold}`);
+  // R96: 消息角色压缩 — 合并连续相同角色消息，减少消息条数开销
+  if (pressureInfo.level === 'medium' || pressureInfo.level === 'high') {
+    ctx.messages = mergeConsecutiveMessages(ctx.messages);
+  }
+
+  // R98: 趋势感知压缩触发 — 结合趋势预测动态调整压缩阈值
+  const compressDecision = getTrendAwareCompressThreshold(numCtx, ctx.messages);
+  if (compressDecision.shouldCompress) {
+    logWarn(`R98: 压缩触发 (${compressDecision.urgency}) — ${compressDecision.reason}`);
     transition(ctx, S.COMPRESSING);
     return;
   }
@@ -2340,6 +2647,10 @@ async function handleReflecting(
     } else {
       recordCompletionGate(true);
     }
+    // R90: 记录完成门控评分到日志
+    if (gateResult.score < 100) {
+      logInfo(`R90: Completion Gate 评分: ${gateResult.score}/100`);
+    }
   } catch { /* Gate 异常不影响主流程 */ }
 
   logInfo('模型停止工具调用 → ReAct Agent Loop 结束');
diff --git a/src/renderer/services/agent-metrics.ts b/src/renderer/services/agent-metrics.ts
index 09b27ef..7d3644a 100644
--- a/src/renderer/services/agent-metrics.ts
+++ b/src/renderer/services/agent-metrics.ts
@@ -101,9 +101,72 @@ export function endSessionMetrics(): SessionMetrics | null {
     `${formatPercent(getToolSuccessRate(metrics))} 成功率`
   );
   currentMetrics = null;
+  // R84: 持久化度量历史到 localStorage
+  persistMetricsHistory();
   return metrics;
 }
 
+// ═══════════════════════════════════════════════════════════════
+// R84: 度量持久化 — localStorage 存储与恢复
+// ═══════════════════════════════════════════════════════════════
+
+const METRICS_STORAGE_KEY = '_metona_agent_metrics';
+const METRICS_HISTORY_MAX = 100;
+
+/** R84: 将度量历史保存到 localStorage */
+function persistMetricsHistory(): void {
+  try {
+    const recent = sessionMetricsHistory.slice(-METRICS_HISTORY_MAX);
+    const serialized = recent.map(m => ({
+      sessionId: m.sessionId,
+      model: m.model,
+      duration: m.endTime - m.startTime,
+      iterations: m.totalIterations,
+      toolCallCount: m.toolCalls.length,
+      toolSuccessRate: getToolSuccessRate(m),
+      completionGatePassed: m.completionGatePassed,
+      errorPatterns: m.errorPatterns,
+      inputTokens: m.totalInputTokens,
+      outputTokens: m.totalOutputTokens,
+      timestamp: m.endTime,
+    }));
+    localStorage.setItem(METRICS_STORAGE_KEY, JSON.stringify(serialized));
+  } catch {
+    // localStorage 满或不可用时静默忽略
+  }
+}
+
+/** R84: 从 localStorage 恢复度量历史 */
+export function loadMetricsHistory(): void {
+  try {
+    const raw = localStorage.getItem(METRICS_STORAGE_KEY);
+    if (!raw) return;
+    const parsed = JSON.parse(raw) as Array<Record<string, any>>;
+    for (const item of parsed) {
+      sessionMetricsHistory.push({
+        sessionId: item.sessionId || 'unknown',
+        model: item.model || 'unknown',
+        startTime: item.timestamp ? item.timestamp - (item.duration || 0) : 0,
+        endTime: item.timestamp || 0,
+        totalIterations: item.iterations || 0,
+        toolCalls: [],
+        totalInputTokens: item.inputTokens || 0,
+        totalOutputTokens: item.outputTokens || 0,
+        completionGatePassed: item.completionGatePassed || false,
+        errorPatterns: item.errorPatterns || [],
+      });
+    }
+    logInfo(`R84: 恢复了 ${sessionMetricsHistory.length} 条历史度量`);
+  } catch {
+    // 解析失败静默忽略
+  }
+}
+
+/** R84: 获取度量历史（供 UI 仪表盘使用） */
+export function getMetricsHistory(): SessionMetrics[] {
+  return [...sessionMetricsHistory];
+}
+
 // ═══════════════════════════════════════════════════════════════
 // 度量计算
 // ═══════════════════════════════════════════════════════════════
diff --git a/src/renderer/services/agent-safety.ts b/src/renderer/services/agent-safety.ts
new file mode 100644
index 0000000..35fcb2a
--- /dev/null
+++ b/src/renderer/services/agent-safety.ts
@@ -0,0 +1,1609 @@
+/**
+ * Agent Safety — Agent 安全防护与行为治理模块
+ * 
+ * 从 agent-engine.ts 提取的 R51-R56 功能：
+ * - R51: 工具结果离线存储
+ * - R52: 状态震荡检测
+ * - R54: 增强死循环检测
+ * - R56: 目标对齐验证
+ * 
+ * 设计原则：
+ * - 纯函数/可测试，不依赖 OllamaAPI
+ * - 模块级状态隔离，通过 reset* 函数清理
+ */
+
+import type { OllamaMessage } from '../types.js';
+import { logInfo, logWarn } from './log-service.js';
+
+// ═══════════════════════════════════════════════════════════════
+// R51: 工具结果离线存储
+// ═══════════════════════════════════════════════════════════════
+
+/** 会话级缓存，完整结果按 ID 存储，上下文仅保留精简引用 */
+const _toolResultStore = new Map<string, { toolName: string; fullContent: string; timestamp: number }>();
+const TOOL_STORE_MAX = 200;
+
+/** 存储完整工具结果并返回引用 ID */
+export function storeToolResult(toolName: string, fullContent: string): string {
+  const refId = `toolref_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  _toolResultStore.set(refId, { toolName, fullContent, timestamp: Date.now() });
+  // LRU 淘汰
+  if (_toolResultStore.size > TOOL_STORE_MAX) {
+    const oldestKey = _toolResultStore.keys().next().value;
+    if (oldestKey) _toolResultStore.delete(oldestKey);
+  }
+  return refId;
+}
+
+/** 将旧工具结果消息精简为引用格式 */
+export function compactOldToolResult(msg: OllamaMessage): OllamaMessage {
+  if (msg.role !== 'tool' || !msg.content) return msg;
+  if (msg.content.startsWith('[工具结果已归档]')) return msg;
+  if (msg.content.length > 1500) {
+    const refId = storeToolResult(msg.tool_name || 'unknown', msg.content);
+    const summary = msg.content.slice(0, 500);
+    const totalLen = msg.content.length;
+    return {
+      ...msg,
+      content: `${summary}\n\n[工具结果已归档 ref=${refId} 完整内容 ${totalLen} 字符已离线存储，如需查看完整结果请重新调用工具]`,
+    };
+  }
+  return msg;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R52: 状态震荡检测
+// ═══════════════════════════════════════════════════════════════
+
+const _toolCallHistory: string[] = [];
+const MAX_HISTORY_LEN = 8;
+
+/** 检测工具调用序列是否存在震荡模式（A→B→A→B） */
+export function detectOscillation(): boolean {
+  if (_toolCallHistory.length < 4) return false;
+  const len = _toolCallHistory.length;
+  const a = _toolCallHistory[len - 4];
+  const b = _toolCallHistory[len - 3];
+  const c = _toolCallHistory[len - 2];
+  const d = _toolCallHistory[len - 1];
+  return a === c && b === d && a !== b;
+}
+
+/** 记录工具调用到历史序列 */
+export function recordToolCallHistory(toolName: string, args: Record<string, unknown>): void {
+  const key = `${toolName}:${JSON.stringify(args, Object.keys(args).sort()).slice(0, 100)}`;
+  _toolCallHistory.push(key);
+  if (_toolCallHistory.length > MAX_HISTORY_LEN) _toolCallHistory.shift();
+}
+
+/** 重置工具调用历史（新一轮对话开始时） */
+export function resetToolCallHistory(): void {
+  _toolCallHistory.length = 0;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R54: 增强死循环检测
+// ═══════════════════════════════════════════════════════════════
+
+/** 检测连续 N 次完全相同的工具调用 */
+export function detectConsecutiveIdentical(minCount: number): { detected: boolean; toolName: string; count: number } {
+  if (_toolCallHistory.length < minCount) return { detected: false, toolName: '', count: 0 };
+  const recent = _toolCallHistory.slice(-minCount);
+  const allSame = recent.every(k => k === recent[0]);
+  if (allSame) {
+    return { detected: true, toolName: recent[0].split(':')[0], count: minCount };
+  }
+  return { detected: false, toolName: '', count: 0 };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R56: 目标对齐验证
+// ═══════════════════════════════════════════════════════════════
+
+/** 用户原始目标（在 handleInit 时设置） */
+let _userGoal: string = '';
+
+/** 设置用户原始目标 */
+export function setUserGoal(goal: string): void {
+  _userGoal = goal.slice(0, 500); // 限制长度防止占用过多内存
+}
+
+/** 获取用户原始目标 */
+export function getUserGoal(): string {
+  return _userGoal;
+}
+
+/** 重置用户目标 */
+export function resetUserGoal(): void {
+  _userGoal = '';
+}
+
+/** 目标对齐检测结果 */
+export interface GoalAlignmentResult {
+  aligned: boolean;
+  reason: string;
+  suggestion?: string;
+}
+
+/**
+ * R56: 检测 Agent 是否偏离用户原始目标
+ * 
+ * 检测策略：
+ * 1. 提取用户目标中的关键动词和名词
+ * 2. 检查最近 5 轮的工具调用是否与目标关键词相关
+ * 3. 如果连续多轮工具调用都与目标无关，判定为偏离
+ * 
+ * @param recentToolNames 最近 N 轮的工具调用名称列表
+ * @param recentContent 最近 N 轮的模型输出内容摘要
+ * @param loopCount 当前循环计数
+ */
+export function checkGoalAlignment(
+  recentToolNames: string[],
+  recentContent: string,
+  loopCount: number,
+): GoalAlignmentResult {
+  if (!_userGoal || _userGoal.length < 10) {
+    return { aligned: true, reason: '目标太短，跳过对齐检测' };
+  }
+
+  // 仅在循环数 >= 6 时开始检测（前几轮可能是探索阶段）
+  if (loopCount < 6) {
+    return { aligned: true, reason: '前期探索阶段，跳过检测' };
+  }
+
+  const goalLower = _userGoal.toLowerCase();
+  
+  // 提取目标关键词
+  const goalKeywords = extractGoalKeywords(_userGoal);
+  
+  // 检查最近内容是否包含目标关键词
+  const contentLower = recentContent.toLowerCase();
+  const contentMatches = goalKeywords.filter(kw => contentLower.includes(kw.toLowerCase()));
+  
+  // 检查最近的工具调用是否与目标相关
+  // 每种工具与特定目标类型的关联度
+  const toolGoalRelevance = assessToolGoalRelevance(recentToolNames, goalLower);
+  
+  // 如果最近内容中包含目标关键词，认为是对齐的
+  if (contentMatches.length >= 1) {
+    return { aligned: true, reason: `内容中包含目标关键词: ${contentMatches.join(', ')}` };
+  }
+  
+  // 如果工具调用与目标高度相关，认为是对齐的
+  if (toolGoalRelevance.relevant) {
+    return { aligned: true, reason: toolGoalRelevance.reason };
+  }
+  
+  // 偏离判定：内容无关键词 + 工具不相关 + 已过探索阶段
+  return {
+    aligned: false,
+    reason: `最近 ${recentToolNames.length} 轮工具调用 (${recentToolNames.slice(-3).join(', ')}) 与用户目标"${_userGoal.slice(0, 60)}..."可能不相关`,
+    suggestion: `请回顾用户原始任务: "${_userGoal.slice(0, 100)}"。如果当前操作是在为任务做准备，请继续；如果已经偏离，请调整方向。`,
+  };
+}
+
+/** 从用户目标中提取关键词 */
+function extractGoalKeywords(goal: string): string[] {
+  const keywords: string[] = [];
+  
+  // 中文关键词
+  const cnPatterns = [
+    /搜索|查找|查一下|搜一下|检索|查询/g,
+    /写入|创建|生成|保存|输出/g,
+    /运行|执行|编译|构建/g,
+    /读取|查看|打开/g,
+    /修改|编辑|更新|替换/g,
+    /删除|移除|清理/g,
+    /下载|安装/g,
+    /分析|研究|评估|对比/g,
+    /测试|验证|检查/g,
+    /部署|发布/g,
+  ];
+  
+  // 英文关键词
+  const enPatterns = [
+    /\b(search|find|lookup)\b/gi,
+    /\b(write|create|generate|save)\b/gi,
+    /\b(run|execute|build|compile)\b/gi,
+    /\b(read|view|open)\b/gi,
+    /\b(edit|modify|update|replace)\b/gi,
+    /\b(delete|remove|clean)\b/gi,
+    /\b(download|install)\b/gi,
+    /\b(analyze|research|evaluate|compare)\b/gi,
+    /\b(test|verify|check)\b/gi,
+    /\b(deploy|publish)\b/gi,
+  ];
+  
+  for (const p of [...cnPatterns, ...enPatterns]) {
+    const matches = goal.match(p);
+    if (matches) keywords.push(...matches);
+  }
+  
+  // 提取路径/文件名（如果目标中包含）
+  const pathMatches = goal.match(/[\w-]+\.(ts|js|py|json|md|txt|html|css|go|rs|java|cpp|c)/gi);
+  if (pathMatches) keywords.push(...pathMatches);
+  
+  // 提取引号中的内容
+  const quotedMatches = goal.match(/[""']([^""']{3,30})[""']/g);
+  if (quotedMatches) {
+    for (const q of quotedMatches) {
+      keywords.push(q.replace(/[""']/g, ''));
+    }
+  }
+  
+  return [...new Set(keywords)];
+}
+
+/** 评估工具调用与用户目标的相关性 */
+function assessToolGoalRelevance(toolNames: string[], goalLower: string): { relevant: boolean; reason: string } {
+  if (toolNames.length === 0) return { relevant: true, reason: '无工具调用，跳过' };
+  
+  // 文件操作类目标
+  const isFileTask = /文件|目录|file|directory|path|路径/.test(goalLower);
+  // 搜索类目标
+  const isSearchTask = /搜索|查找|查|search|find|grep/.test(goalLower);
+  // 命令执行类目标
+  const isCommandTask = /运行|执行|命令|终端|run|execute|command|shell/.test(goalLower);
+  // 网络类目标
+  const isWebTask = /网页|网站|url|web|fetch|搜索|search/.test(goalLower);
+  // Git 类目标
+  const isGitTask = /git|提交|推送|分支|commit|push|pull/.test(goalLower);
+  // 浏览器类目标
+  const isBrowserTask = /浏览器|网页|截图|browser|screenshot/.test(goalLower);
+  
+  const recentTools = toolNames.slice(-5);
+  
+  if (isFileTask && recentTools.some(t => /read_file|write_file|edit_file|list_directory|search_files|tree/.test(t))) {
+    return { relevant: true, reason: '文件操作与文件类目标相关' };
+  }
+  if (isSearchTask && recentTools.some(t => /search_files|web_search|grep/.test(t))) {
+    return { relevant: true, reason: '搜索操作与搜索类目标相关' };
+  }
+  if (isCommandTask && recentTools.some(t => /run_command/.test(t))) {
+    return { relevant: true, reason: '命令执行与命令类目标相关' };
+  }
+  if (isWebTask && recentTools.some(t => /web_search|web_fetch|browser_open/.test(t))) {
+    return { relevant: true, reason: '网络操作与网络类目标相关' };
+  }
+  if (isGitTask && recentTools.some(t => /git/.test(t))) {
+    return { relevant: true, reason: 'Git 操作与 Git 类目标相关' };
+  }
+  if (isBrowserTask && recentTools.some(t => /browser_/.test(t))) {
+    return { relevant: true, reason: '浏览器操作与浏览器类目标相关' };
+  }
+  
+  // memory 和 plan_track 始终认为相关
+  if (recentTools.some(t => /memory|plan_track/.test(t))) {
+    return { relevant: true, reason: '记忆/计划操作始终相关' };
+  }
+  
+  return { relevant: false, reason: '最近工具调用与目标类型不匹配' };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R63: 工具调用速率限制 — 防止快速连续调用同一工具浪费资源
+// ═══════════════════════════════════════════════════════════════
+
+const _toolCallTimestamps = new Map<string, number[]>();
+const RATE_LIMIT_WINDOW = 60_000; // 60 秒窗口
+const RATE_LIMIT_DEFAULT = 20;    // 默认每分钟最多 20 次
+
+/** R63: 工具特定的速率限制配置 */
+const TOOL_RATE_LIMITS: Record<string, number> = {
+  web_search: 10,      // 每分钟最多 10 次搜索
+  web_fetch: 8,        // 每分钟最多 8 次抓取
+  run_command: 15,     // 每分钟最多 15 次命令
+  browser_open: 8,     // 每分钟最多 8 次浏览器打开
+  download_file: 5,    // 每分钟最多 5 次下载
+};
+
+/** R63: 检查工具调用是否超过速率限制 */
+export function checkRateLimit(toolName: string): { allowed: boolean; retryAfterMs: number } {
+  const limit = TOOL_RATE_LIMITS[toolName] ?? RATE_LIMIT_DEFAULT;
+  const now = Date.now();
+  const timestamps = _toolCallTimestamps.get(toolName) || [];
+  
+  // 清理过期时间戳
+  const valid = timestamps.filter(t => now - t < RATE_LIMIT_WINDOW);
+  
+  if (valid.length >= limit) {
+    // 计算最早过期时间
+    const oldest = valid[0];
+    const retryAfterMs = RATE_LIMIT_WINDOW - (now - oldest);
+    return { allowed: false, retryAfterMs: Math.max(1000, retryAfterMs) };
+  }
+  
+  valid.push(now);
+  _toolCallTimestamps.set(toolName, valid);
+  return { allowed: true, retryAfterMs: 0 };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R66-R67: 错误分类系统 — 区分瞬态/永久错误，指导重试策略
+// ═══════════════════════════════════════════════════════════════
+
+export type ErrorClass = 'transient' | 'permanent' | 'security' | 'unknown';
+
+export interface ClassifiedError {
+  class: ErrorClass;
+  shouldRetry: boolean;
+  maxRetries: number;
+  backoffMs: number;
+  userMessage: string;
+}
+
+/** R66: 瞬态错误模式 — 可重试 */
+const TRANSIENT_PATTERNS = [
+  /timeout|timed?\s*out/i,
+  /ECONNRESET|ECONNREFUSED|ETIMEDOUT/i,
+  /socket\s*hang\s*up/i,
+  /network|connection\s*(refused|reset|closed)/i,
+  /503|502|500/i,
+  /rate\s*limit|429/i,
+  /EAGAIN|EBUSY/i,
+  /temporarily\s*unavailable/i,
+  /超时|连接.*失败|网络.*错误/,
+];
+
+/** R66: 永久错误模式 — 不可重试 */
+const PERMANENT_PATTERNS = [
+  /ENOENT|no\s*such\s*file/i,
+  /EACCES|permission\s*denied/i,
+  /ENOTDIR|EISDIR/i,
+  /invalid\s*(path|argument|parameter)/i,
+  /syntax\s*error/i,
+  /JSON.*parse/i,
+  /not\s*found/i,
+  /文件不存在|路径.*错误|参数.*无效/,
+];
+
+/** R66: 安全错误模式 — 不可重试，需用户介入 */
+const SECURITY_PATTERNS = [
+  /安全警告|security/i,
+  /injection|注入/i,
+  /path\s*traversal|路径遍历/i,
+  /file:\/\/|内网/i,
+];
+
+/** R66: 分类错误并给出重试建议 */
+export function classifyError(error: string): ClassifiedError {
+  const errLower = error.toLowerCase();
+  
+  // 安全错误
+  for (const p of SECURITY_PATTERNS) {
+    if (p.test(error)) {
+      return {
+        class: 'security',
+        shouldRetry: false,
+        maxRetries: 0,
+        backoffMs: 0,
+        userMessage: `安全拦截: ${error.slice(0, 100)}`,
+      };
+    }
+  }
+  
+  // 永久错误
+  for (const p of PERMANENT_PATTERNS) {
+    if (p.test(error)) {
+      return {
+        class: 'permanent',
+        shouldRetry: false,
+        maxRetries: 0,
+        backoffMs: 0,
+        userMessage: `操作失败（不可重试）: ${error.slice(0, 100)}`,
+      };
+    }
+  }
+  
+  // 瞬态错误
+  for (const p of TRANSIENT_PATTERNS) {
+    if (p.test(error)) {
+      return {
+        class: 'transient',
+        shouldRetry: true,
+        maxRetries: 2,
+        backoffMs: 1000,
+        userMessage: `临时错误（可重试）: ${error.slice(0, 100)}`,
+      };
+    }
+  }
+  
+  // 未知错误 — 允许 1 次重试
+  return {
+    class: 'unknown',
+    shouldRetry: true,
+    maxRetries: 1,
+    backoffMs: 500,
+    userMessage: error.slice(0, 100),
+  };
+}
+
+/** R67: 计算指数退避延迟 */
+export function calculateBackoff(attempt: number, baseMs: number): number {
+  return Math.min(baseMs * Math.pow(2, attempt), 10_000); // 上限 10 秒
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R76: 路径沙箱验证 — 确保文件操作不超出工作空间边界
+// ═══════════════════════════════════════════════════════════════
+
+/** R76: 验证路径是否在工作空间范围内 */
+export function validatePathSandbox(
+  path: string,
+  workspaceDir: string,
+): { valid: boolean; reason?: string; normalizedPath?: string } {
+  if (!path) return { valid: false, reason: '路径为空' };
+  if (!workspaceDir) return { valid: true, normalizedPath: path }; // 无工作空间时放行
+  
+  try {
+    // 标准化路径（处理 .. 和 . ）
+    const normalized = normalizePath(path);
+    const normalizedWs = normalizePath(workspaceDir);
+    
+    // 绝对路径检查
+    if (isAbsolute(normalized)) {
+      if (!normalized.toLowerCase().startsWith(normalizedWs.toLowerCase())) {
+        return {
+          valid: false,
+          reason: `路径 "${path}" 不在工作空间 "${workspaceDir}" 范围内`,
+        };
+      }
+    }
+    
+    // 检查路径遍历攻击
+    const relativePath = normalized.toLowerCase().replace(normalizedWs.toLowerCase(), '').replace(/^[\\/]/, '');
+    if (relativePath.includes('..')) {
+      // 允许在工作空间内部的相对路径引用
+      const segments = relativePath.split(/[\\/]/);
+      let depth = 0;
+      for (const seg of segments) {
+        if (seg === '..') depth--;
+        else if (seg && seg !== '.') depth++;
+        if (depth < 0) {
+          return {
+            valid: false,
+            reason: `路径遍历检测: "${path}" 试图超出工作空间边界`,
+          };
+        }
+      }
+    }
+    
+    return { valid: true, normalizedPath: normalized };
+  } catch {
+    return { valid: false, reason: `路径解析失败: ${path}` };
+  }
+}
+
+/** R76: 路径标准化辅助函数 */
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/\/$/, '');
+}
+
+/** R76: 判断是否为绝对路径 */
+function isAbsolute(p: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(p) || p.startsWith('/');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R87: 工具熔断器 — 连续失败后自动禁用工具，防止雪崩
+// ═══════════════════════════════════════════════════════════════
+
+/** 工具失败计数器 */
+const _toolFailureCount = new Map<string, number>();
+const CIRCUIT_BREAKER_THRESHOLD = 5;  // 连续失败 5 次后熔断
+const CIRCUIT_BREAKER_COOLDOWN = 60_000; // 熔断冷却 60 秒
+const _circuitBreakerTripped = new Map<string, number>(); // toolName → trip timestamp
+
+/** R87: 记录工具失败 */
+export function recordToolFailure(toolName: string): void {
+  const count = (_toolFailureCount.get(toolName) || 0) + 1;
+  _toolFailureCount.set(toolName, count);
+  if (count >= CIRCUIT_BREAKER_THRESHOLD) {
+    _circuitBreakerTripped.set(toolName, Date.now());
+    logWarn(`R87: 熔断器触发 — ${toolName} 连续失败 ${count} 次，禁用 60 秒`);
+  }
+}
+
+/** R87: 记录工具成功（重置失败计数） */
+export function recordToolSuccess(toolName: string): void {
+  _toolFailureCount.delete(toolName);
+  _circuitBreakerTripped.delete(toolName);
+}
+
+/** R87: 检查工具是否被熔断 */
+export function isToolCircuitBroken(toolName: string): { broken: boolean; remainingMs: number } {
+  const tripTime = _circuitBreakerTripped.get(toolName);
+  if (!tripTime) return { broken: false, remainingMs: 0 };
+  const elapsed = Date.now() - tripTime;
+  if (elapsed >= CIRCUIT_BREAKER_COOLDOWN) {
+    // 冷却期过了，半开状态：允许调用但保持失败计数
+    _circuitBreakerTripped.delete(toolName);
+    _toolFailureCount.set(toolName, CIRCUIT_BREAKER_THRESHOLD - 1); // 只给一次机会
+    return { broken: false, remainingMs: 0 };
+  }
+  return { broken: true, remainingMs: CIRCUIT_BREAKER_COOLDOWN - elapsed };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R88: 工具结果元数据 — 为模型提供结果大小的上下文提示
+// ═══════════════════════════════════════════════════════════════
+
+/** R88: 估算字符串的 token 数（轻量级，用于工具结果元数据） */
+export function estimateResultTokens(text: string): number {
+  if (!text) return 0;
+  let cn = 0, other = 0;
+  for (const ch of text) {
+    if (/[\u4e00-\u9fff]/.test(ch)) cn++;
+    else other++;
+  }
+  return Math.ceil(cn / 1.5 + other / 4);
+}
+
+/** R88: 为工具结果添加元数据提示，帮助模型理解结果规模 */
+export function addResultMetadata(formattedResult: string): string {
+  const tokens = estimateResultTokens(formattedResult);
+  if (tokens > 500) {
+    return formattedResult + `\n[元数据: ~${tokens} tokens]`;
+  }
+  return formattedResult;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R97: 错误模式学习 — 从重复错误中学习并生成改进建议
+// ═══════════════════════════════════════════════════════════════
+
+interface ErrorPatternEntry {
+  toolName: string;
+  errorSignature: string;
+  count: number;
+  firstSeen: number;
+  lastSeen: number;
+  suggestedFix?: string;
+}
+
+const _errorPatterns = new Map<string, ErrorPatternEntry>();
+const MAX_ERROR_PATTERNS = 50;
+
+/** R97: 已知的错误→建议映射 */
+const ERROR_FIX_MAP: Array<{ pattern: RegExp; fix: string }> = [
+  { pattern: /ENOENT|no such file/i, fix: '检查文件路径是否正确，使用 list_directory 确认文件存在' },
+  { pattern: /EACCES|permission denied/i, fix: '检查文件权限，或尝试使用不同路径' },
+  { pattern: /timeout|timed out/i, fix: '尝试拆分任务为更小的步骤，或增加超时时间' },
+  { pattern: /ECONNRESET|ECONNREFUSED/i, fix: '检查网络连接或目标服务是否可用' },
+  { pattern: /rate limit|429/i, fix: '降低调用频率，添加延迟重试' },
+  { pattern: /JSON.*parse|syntax error/i, fix: '验证输入数据的 JSON 格式是否正确' },
+  { pattern: /tool.*not.*found|unknown tool/i, fix: '检查工具名拼写，使用正确的工具名' },
+  { pattern: /invalid.*argument|参数.*无效/i, fix: '检查工具参数是否符合要求' },
+];
+
+/** R97: 记录错误模式并返回改进建议 */
+export function recordErrorPattern(toolName: string, errorMsg: string): string | undefined {
+  // 提取错误签名（移除具体路径/数值等细节）
+  const signature = errorMsg
+    .replace(/['"]/g, '')
+    .replace(/\/[\w./\\-]+/g, '<path>')
+    .replace(/\d+/g, 'N')
+    .slice(0, 100);
+
+  const key = `${toolName}::${signature}`;
+  const now = Date.now();
+  const existing = _errorPatterns.get(key);
+
+  if (existing) {
+    existing.count++;
+    existing.lastSeen = now;
+  } else {
+    // LRU 淘汰
+    if (_errorPatterns.size >= MAX_ERROR_PATTERNS) {
+      const oldestKey = _errorPatterns.keys().next().value;
+      if (oldestKey) _errorPatterns.delete(oldestKey);
+    }
+    // 查找建议
+    let suggestedFix: string | undefined;
+    for (const { pattern, fix } of ERROR_FIX_MAP) {
+      if (pattern.test(errorMsg)) {
+        suggestedFix = fix;
+        break;
+      }
+    }
+    _errorPatterns.set(key, {
+      toolName, errorSignature: signature, count: 1,
+      firstSeen: now, lastSeen: now, suggestedFix,
+    });
+  }
+
+  // 如果同一错误出现 2+ 次，返回建议
+  const entry = _errorPatterns.get(key);
+  if (entry && entry.count >= 2 && entry.suggestedFix) {
+    return `[错误模式提示] "${toolName}" 已 ${entry.count} 次出现类似错误。建议: ${entry.suggestedFix}`;
+  }
+  return undefined;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R104: 工具结果去重 — 相似结果检测，减少上下文中的冗余
+// ═══════════════════════════════════════════════════════════════
+
+interface ToolResultFingerprint {
+  toolName: string;
+  contentHash: string;
+  timestamp: number;
+  resultLength: number;
+}
+
+const _resultFingerprints: ToolResultFingerprint[] = [];
+const MAX_FINGERPRINTS = 50;
+
+/** R104: 计算内容的简化指纹（用于相似度检测） */
+function computeResultFingerprint(content: string): string {
+  // 取内容的前200字符 + 后100字符作为指纹
+  const head = content.slice(0, 200);
+  const tail = content.slice(-100);
+  let hash = 5381;
+  const combined = head + tail;
+  for (let i = 0; i < combined.length; i++) {
+    hash = ((hash << 5) + hash + combined.charCodeAt(i)) & 0x7fffffff;
+  }
+  return hash.toString(36);
+}
+
+/** R104: 检查工具结果是否与最近的结果高度相似 */
+export function isDuplicateToolResult(toolName: string, resultContent: string): { duplicate: boolean; similarTo?: string } {
+  const hash = computeResultFingerprint(resultContent);
+  const now = Date.now();
+  const DEDUP_WINDOW = 60_000; // 60 秒内的结果视为候选
+
+  // 查找相同工具+相同指纹的结果
+  for (const fp of _resultFingerprints) {
+    if (fp.toolName === toolName && fp.contentHash === hash && (now - fp.timestamp) < DEDUP_WINDOW) {
+      return { duplicate: true, similarTo: `${fp.timestamp}` };
+    }
+  }
+
+  // 记录当前结果
+  _resultFingerprints.push({
+    toolName, contentHash: hash, timestamp: now, resultLength: resultContent.length,
+  });
+  if (_resultFingerprints.length > MAX_FINGERPRINTS) {
+    _resultFingerprints.shift();
+  }
+
+  return { duplicate: false };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R105: 上下文年龄追踪 — 跟踪消息年龄以优化压缩决策
+// ═══════════════════════════════════════════════════════════════
+
+const _messageTimestamps = new Map<number, number>(); // message index → creation timestamp
+
+/** R105: 记录消息创建时间 */
+export function recordMessageAge(msgIndex: number): void {
+  _messageTimestamps.set(msgIndex, Date.now());
+}
+
+/** R105: 获取消息年龄（毫秒），-1 表示未记录 */
+export function getMessageAge(msgIndex: number): number {
+  const ts = _messageTimestamps.get(msgIndex);
+  if (!ts) return -1;
+  return Date.now() - ts;
+}
+
+/** R105: 获取年龄超过阈值的消息索引列表 */
+export function getAgedMessageIndices(thresholdMs: number): number[] {
+  const now = Date.now();
+  const result: number[] = [];
+  for (const [idx, ts] of _messageTimestamps) {
+    if (now - ts > thresholdMs) result.push(idx);
+  }
+  return result.sort((a, b) => a - b);
+}
+
+/** R105: 清理已删除消息的时间戳记录 */
+export function cleanupMessageTimestamps(validIndices: Set<number>): void {
+  for (const key of _messageTimestamps.keys()) {
+    if (!validIndices.has(key)) {
+      _messageTimestamps.delete(key);
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R109: 工具参数消毒 — 防止通过工具参数注入恶意内容
+// ═══════════════════════════════════════════════════════════════
+
+/** R109: 消毒工具参数中的潜在注入内容 */
+export function sanitizeToolArgs(toolName: string, args: Record<string, unknown>): Record<string, unknown> {
+  const sanitized = { ...args };
+
+  // 对字符串参数进行消毒
+  const stringKeys = ['content', 'command', 'query', 'text', 'old_text', 'new_text', 'message'];
+  for (const key of stringKeys) {
+    if (typeof sanitized[key] === 'string') {
+      sanitized[key] = sanitizeInjectionPatterns(sanitized[key] as string);
+    }
+  }
+
+  // R109: run_command 特殊处理 — 移除命令链中的注入尝试
+  if (toolName === 'run_command' && typeof sanitized.command === 'string') {
+    // 移除命令中的 prompt injection 尝试（如 `# 删除所有文件` 伪装为注释）
+    sanitized.command = (sanitized.command as string)
+      .replace(/#\s*(?:ignore|forget|override|disregard|忽略|忘记|覆盖)\s.*$/gim, '')
+      .replace(/\|\s*(?:sh|bash|zsh|powershell|cmd)\b/gi, '')
+      .trim();
+  }
+
+  return sanitized;
+}
+
+/** R109: 清理潜在的 prompt injection 模式 */
+function sanitizeInjectionPatterns(text: string): string {
+  if (!text || text.length < 20) return text;
+  // 仅清理明显的注入模式，保留正常文本
+  return text
+    .replace(/ignore\s+(all\s+)?previous\s+(instructions?|prompts?)/gi, '[已过滤]')
+    .replace(/forget\s+(all\s+)?(instructions?|prompts?|rules?)/gi, '[已过滤]')
+    .replace(/disregard\s+(all|any|previous)\s+(instructions?|rules?)/gi, '[已过滤]')
+    .replace(/忽略.{0,4}(之前|前面|以上|所有).{0,4}(指令|提示|规则|系统)/g, '[已过滤]');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R112: 诊断系统 — 收集 Agent 运行状态用于调试和优化
+// ═══════════════════════════════════════════════════════════════
+
+export interface AgentDiagnostics {
+  timestamp: number;
+  toolResultStoreSize: number;
+  toolCallHistoryLength: number;
+  rateLimitActiveTools: string[];
+  circuitBreakerStatus: Array<{ tool: string; broken: boolean; failures: number }>;
+  errorPatternCount: number;
+  topErrorPatterns: Array<{ tool: string; signature: string; count: number }>;
+  resultFingerprintCount: number;
+  duplicateResultCount: number;
+  userGoal: string;
+}
+
+/** R112: 收集 Agent 诊断信息 */
+export function collectDiagnostics(): AgentDiagnostics {
+  const rateLimitActive: string[] = [];
+  const now = Date.now();
+  for (const [tool, timestamps] of _toolCallTimestamps) {
+    const valid = timestamps.filter(t => now - t < RATE_LIMIT_WINDOW);
+    if (valid.length > 0) {
+      rateLimitActive.push(`${tool}(${valid.length}/${TOOL_RATE_LIMITS[tool] ?? RATE_LIMIT_DEFAULT})`);
+    }
+  }
+
+  const circuitBreakerStatus = Array.from(_toolFailureCount.entries()).map(([tool, count]) => ({
+    tool,
+    broken: _circuitBreakerTripped.has(tool),
+    failures: count,
+  }));
+
+  const topErrorPatterns = Array.from(_errorPatterns.values())
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 5)
+    .map(e => ({ tool: e.toolName, signature: e.errorSignature, count: e.count }));
+
+  const duplicateCount = _resultFingerprints.filter(fp => {
+    // 同一工具同一指纹出现多次
+    return _resultFingerprints.some(other =>
+      other !== fp && other.toolName === fp.toolName && other.contentHash === fp.contentHash
+    );
+  }).length;
+
+  return {
+    timestamp: now,
+    toolResultStoreSize: _toolResultStore.size,
+    toolCallHistoryLength: _toolCallHistory.length,
+    rateLimitActiveTools: rateLimitActive,
+    circuitBreakerStatus,
+    errorPatternCount: _errorPatterns.size,
+    topErrorPatterns,
+    resultFingerprintCount: _resultFingerprints.length,
+    duplicateResultCount: duplicateCount,
+    userGoal: _userGoal.slice(0, 80),
+  };
+}
+
+/** R112: 格式化诊断报告（用于日志输出） */
+export function formatDiagnosticsReport(diag: AgentDiagnostics): string {
+  const lines: string[] = [
+    `Agent Diagnostics Report (${new Date(diag.timestamp).toLocaleTimeString()})`,
+    `${'─'.repeat(50)}`,
+    `Tool Result Store: ${diag.toolResultStoreSize} entries`,
+    `Tool Call History: ${diag.toolCallHistoryLength} entries`,
+    `Rate Limit Active: ${diag.rateLimitActiveTools.length > 0 ? diag.rateLimitActiveTools.join(', ') : 'none'}`,
+    `Circuit Breakers:`,
+  ];
+  for (const cb of diag.circuitBreakerStatus) {
+    lines.push(`  ${cb.broken ? '🔴' : '🟢'} ${cb.tool}: ${cb.failures} failures${cb.broken ? ' (BROKEN)' : ''}`);
+  }
+  lines.push(`Error Patterns: ${diag.errorPatternCount}`);
+  for (const ep of diag.topErrorPatterns) {
+    lines.push(`  ⚠️ ${ep.tool}: "${ep.signature}" (${ep.count}x)`);
+  }
+  lines.push(`Result Fingerprints: ${diag.resultFingerprintCount} (duplicates: ${diag.duplicateResultCount})`);
+  lines.push(`User Goal: "${diag.userGoal}"`);
+  return lines.join('\n');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R113: 命令白名单增强 — 对 run_command 进行更精细的安全控制
+// ═══════════════════════════════════════════════════════════════
+
+/** R113: 高风险命令模式 — 需要用户确认 */
+const HIGH_RISK_COMMAND_PATTERNS = [
+  { pattern: /\brm\s+-rf?\b/i, risk: 'high', reason: '递归删除文件' },
+  { pattern: /\bformat\b/i, risk: 'high', reason: '格式化磁盘' },
+  { pattern: /\bmkfs\b/i, risk: 'high', reason: '创建文件系统' },
+  { pattern: /\bdd\s+if=/i, risk: 'high', reason: '磁盘镜像写入' },
+  { pattern: /\bchmod\s+777\b/i, risk: 'medium', reason: '设置全权限' },
+  { pattern: /\bchown\b/i, risk: 'medium', reason: '修改文件所有者' },
+  { pattern: /\bkill\s+-9\b/i, risk: 'medium', reason: '强制终止进程' },
+  { pattern: /\biptables\b/i, risk: 'high', reason: '修改防火墙规则' },
+  { pattern: /\breg(?:edit|svc)?\s+/i, risk: 'high', reason: '修改注册表' },
+  { pattern: /\bnetsh\b/i, risk: 'medium', reason: '修改网络配置' },
+  { pattern: /\bgit\s+push\s+--force\b/i, risk: 'medium', reason: '强制推送（覆盖远程）' },
+  { pattern: /\bnpm\s+publish\b/i, risk: 'medium', reason: '发布 npm 包' },
+];
+
+/** R113: 禁止的命令模式 — 不可执行 */
+const FORBIDDEN_COMMAND_PATTERNS = [
+  { pattern: /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/i, reason: 'fork 炸弹' },
+  { pattern: /\brm\s+-rf\s+\/\s*$/i, reason: '删除根目录' },
+  { pattern: /\bmkfs\.\w+\s+\/dev\//i, reason: '格式化系统设备' },
+  { pattern: /\bshutdown\b|\breboot\b|\bhalt\b/i, reason: '系统关机/重启' },
+  { pattern: /\b>\s*\/dev\/sda/i, reason: '直接写入磁盘设备' },
+];
+
+/** R113: 检查命令安全性，返回风险评估结果 */
+export function checkCommandSafety(command: string): { safe: boolean; riskLevel: 'none' | 'medium' | 'high' | 'forbidden'; reason?: string } {
+  // 检查禁止的命令
+  for (const { pattern, reason } of FORBIDDEN_COMMAND_PATTERNS) {
+    if (pattern.test(command)) {
+      return { safe: false, riskLevel: 'forbidden', reason: `禁止执行: ${reason}` };
+    }
+  }
+
+  // 检查高风险命令
+  for (const { pattern, risk, reason } of HIGH_RISK_COMMAND_PATTERNS) {
+    if (pattern.test(command)) {
+      return {
+        safe: risk !== 'high', // high risk 需要 confirmation（但不是完全禁止）
+        riskLevel: risk as 'medium' | 'high',
+        reason: `${reason}（风险等级: ${risk}）`,
+      };
+    }
+  }
+
+  return { safe: true, riskLevel: 'none' };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R95: 工具结果按类型智能截断 — 不同工具类型采用不同截断策略
+// ═══════════════════════════════════════════════════════════════
+
+/** R95: 工具类型 → 截断策略映射 */
+const TOOL_TRUNCATE_STRATEGY: Record<string, {
+  /** 优先保留的部分 */
+  preserve: 'head' | 'tail' | 'both' | 'json_keys';
+  /** 默认最大长度 */
+  maxLen: number;
+  /** JSON keys 保留策略（仅当 preserve=json_keys 时生效） */
+  keepKeys?: string[];
+}> = {
+  // 命令输出：保留尾部（最终结果在尾部）
+  run_command: { preserve: 'both', maxLen: 4000 },
+  // 搜索结果：保留头部（最相关的结果在头部）
+  search_files: { preserve: 'head', maxLen: 3000 },
+  web_search: { preserve: 'head', maxLen: 3000 },
+  // 文件读取：保留头部（文件开头通常更重要）
+  read_file: { preserve: 'head', maxLen: 6000 },
+  // 目录列表：保留头部
+  list_directory: { preserve: 'head', maxLen: 2000 },
+  tree: { preserve: 'head', maxLen: 3000 },
+  // 网页抓取：保留头部（标题和摘要）
+  web_fetch: { preserve: 'head', maxLen: 5000 },
+  // Git 输出：保留尾部
+  git: { preserve: 'tail', maxLen: 3000 },
+  // 默认：两端保留
+  _default: { preserve: 'both', maxLen: 4000 },
+};
+
+/**
+ * R95: 按工具类型智能截断工具结果
+ * 不同工具类型的输出有不同的结构特征，截断策略应适配
+ */
+export function smartTruncateByToolType(
+  toolName: string,
+  content: string,
+  maxLen?: number,
+): string {
+  const strategy = TOOL_TRUNCATE_STRATEGY[toolName] || TOOL_TRUNCATE_STRATEGY._default;
+  const limit = maxLen ?? strategy.maxLen;
+
+  if (content.length <= limit) return content;
+
+  const truncateMsg = (originalLen: number, truncatedLen: number) =>
+    `\n... [R95截断: ${originalLen - truncatedLen} 字符已省略]`;
+
+  switch (strategy.preserve) {
+    case 'head':
+      return content.slice(0, limit) + truncateMsg(content.length, limit);
+
+    case 'tail':
+      return truncateMsg(content.length, limit) + content.slice(-limit);
+
+    case 'both': {
+      // 保留前 60% + 后 40%
+      const headLen = Math.floor(limit * 0.6);
+      const tailLen = limit - headLen;
+      return (
+        content.slice(0, headLen) +
+        truncateMsg(content.length, limit) +
+        content.slice(-tailLen)
+      );
+    }
+
+    case 'json_keys': {
+      // 尝试解析 JSON 并保留指定 keys
+      try {
+        const parsed = JSON.parse(content);
+        const kept: Record<string, unknown> = {};
+        if (strategy.keepKeys) {
+          for (const key of strategy.keepKeys) {
+            if (key in parsed) kept[key] = parsed[key];
+          }
+        }
+        let result = JSON.stringify(kept);
+        if (result.length > limit) {
+          // 如果保留 keys 后仍然过长，截断
+          return result.slice(0, limit) + truncateMsg(result.length, limit);
+        }
+        return result;
+      } catch {
+        // JSON 解析失败，回退到 both 策略
+        const headLen = Math.floor(limit * 0.6);
+        const tailLen = limit - headLen;
+        return (
+          content.slice(0, headLen) +
+          truncateMsg(content.length, limit) +
+          content.slice(-tailLen)
+        );
+      }
+    }
+
+    default:
+      return content.slice(0, limit) + truncateMsg(content.length, limit);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R99: 工具结果引用解析 — 从归档存储检索完整工具结果
+// ═══════════════════════════════════════════════════════════════
+
+/**
+ * R99: 根据 refId 检索归档的完整工具结果
+ * 当模型在上下文中看到 [工具结果已归档 ref=xxx] 标记时，
+ * 可以通过此函数获取完整内容
+ */
+export function retrieveToolResult(refId: string): { toolName: string; fullContent: string; timestamp: number } | null {
+  const entry = _toolResultStore.get(refId);
+  if (!entry) return null;
+  return { ...entry };
+}
+
+/**
+ * R99: 从文本中提取工具结果引用 ID
+ * 匹配格式: [工具结果已归档 ref=toolref_xxx_yyy]
+ */
+export function extractToolResultRefs(text: string): string[] {
+  const matches = text.match(/\[工具结果已归档\s+ref=(toolref_[\w_]+)\]/g);
+  if (!matches) return [];
+  return matches.map(m => {
+    const idMatch = m.match(/ref=(toolref_[\w_]+)/);
+    return idMatch ? idMatch[1] : '';
+  }).filter(Boolean);
+}
+
+/**
+ * R99: 检查消息中是否引用了归档的工具结果，
+ * 如果有则返回需要检索的引用信息
+ */
+export function checkArchivedReferences(messages: Array<{ content?: string }>): Array<{ refId: string; toolName: string; fullContent: string }> {
+  const results: Array<{ refId: string; toolName: string; fullContent: string }> = [];
+  const seen = new Set<string>();
+
+  for (const msg of messages) {
+    const content = msg.content || '';
+    if (!content.includes('[工具结果已归档')) continue;
+    const refIds = extractToolResultRefs(content);
+    for (const refId of refIds) {
+      if (seen.has(refId)) continue;
+      seen.add(refId);
+      const retrieved = retrieveToolResult(refId);
+      if (retrieved) {
+        results.push({
+          refId,
+          toolName: retrieved.toolName,
+          fullContent: retrieved.fullContent,
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 统一重置（新会话开始时调用）
+// ═══════════════════════════════════════════════════════════════
+
+export function resetAllSafetyState(): void {
+  _toolResultStore.clear();
+  _toolCallHistory.length = 0;
+  _userGoal = '';
+  _toolCallTimestamps.clear();
+  _toolFailureCount.clear();
+  _circuitBreakerTripped.clear();
+  // R97: 清理错误模式
+  _errorPatterns.clear();
+  // R104: 清理结果指纹
+  _resultFingerprints.length = 0;
+  // R105: 清理消息时间戳
+  _messageTimestamps.clear();
+  // R118: 清理性能分析数据
+  _loopTimings.length = 0;
+  logInfo('Agent Safety: 所有安全状态已重置');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R116: 错误恢复建议增强 — 提供上下文化的错误恢复建议
+// ═══════════════════════════════════════════════════════════════
+
+interface ErrorRecoverySuggestion {
+  toolName: string;
+  error: string;
+  suggestions: string[];
+  severity: 'low' | 'medium' | 'high';
+}
+
+const _errorRecoveryRules: Array<{
+  pattern: RegExp;
+  suggestions: string[];
+  severity: ErrorRecoverySuggestion['severity'];
+}> = [
+  {
+    pattern: /ENOENT|no such file|文件不存在|not found/i,
+    suggestions: [
+      '检查文件路径是否正确（注意大小写和路径分隔符）',
+      '使用 list_dir 确认文件是否存在',
+      '如果文件需要创建，先使用 write_file 创建',
+    ],
+    severity: 'low',
+  },
+  {
+    pattern: /EACCES|permission denied|权限/i,
+    suggestions: [
+      '检查文件权限设置',
+      '尝试使用不同的路径（工作空间目录内）',
+      '联系管理员获取必要权限',
+    ],
+    severity: 'medium',
+  },
+  {
+    pattern: /timeout|超时|timed?\s*out/i,
+    suggestions: [
+      '将任务拆分为更小的步骤',
+      '检查网络连接是否正常',
+      '增加超时时间或重试',
+    ],
+    severity: 'medium',
+  },
+  {
+    pattern: /syntax error|语法错误|parse error/i,
+    suggestions: [
+      '检查代码语法是否正确',
+      '使用 JSON 验证工具检查格式',
+      '查看错误行号定位问题',
+    ],
+    severity: 'high',
+  },
+  {
+    pattern: /connection refused|ECONNREFUSED|连接.*拒绝/i,
+    suggestions: [
+      '确认目标服务是否正在运行',
+      '检查端口号和地址是否正确',
+      '检查防火墙设置',
+    ],
+    severity: 'medium',
+  },
+  {
+    pattern: /rate limit|429|频率/i,
+    suggestions: [
+      '降低请求频率，添加延迟',
+      '等待一段时间后重试',
+      '考虑使用缓存减少请求次数',
+    ],
+    severity: 'low',
+  },
+  {
+    pattern: /out of memory|内存不足|OOM/i,
+    suggestions: [
+      '减少处理的数据量（分批处理）',
+      '检查是否有内存泄漏',
+      '增加系统可用内存',
+    ],
+    severity: 'high',
+  },
+];
+
+/** R116: 获取上下文化的错误恢复建议 */
+export function getErrorRecoverySuggestions(toolName: string, error: string): ErrorRecoverySuggestion {
+  const suggestions: string[] = [];
+  let severity: ErrorRecoverySuggestion['severity'] = 'low';
+  
+  for (const rule of _errorRecoveryRules) {
+    if (rule.pattern.test(error)) {
+      suggestions.push(...rule.suggestions);
+      if (rule.severity === 'high') severity = 'high';
+      else if (rule.severity === 'medium' && severity !== 'high') severity = 'medium';
+    }
+  }
+  
+  // 工具特定的建议
+  if (toolName === 'run_command' && /command not found|命令未找到/i.test(error)) {
+    suggestions.push('检查命令是否已安装（使用 which/where 确认）');
+    suggestions.push('确认命令名称拼写正确');
+  }
+  if (toolName === 'write_file' && /disk full|磁盘已满/i.test(error)) {
+    suggestions.push('清理磁盘空间后重试');
+    suggestions.push('尝试写入到其他磁盘');
+  }
+  if (toolName === 'web_fetch' && /SSL|certificate/i.test(error)) {
+    suggestions.push('检查 URL 是否使用 HTTPS');
+    suggestions.push('确认 SSL 证书是否有效');
+  }
+  
+  // 如果没有匹配到任何规则，提供通用建议
+  if (suggestions.length === 0) {
+    suggestions.push('检查参数是否正确');
+    suggestions.push('尝试简化操作步骤');
+    suggestions.push('查看完整错误信息以获取更多线索');
+  }
+  
+  return { toolName, error, suggestions, severity };
+}
+
+/** R116: 格式化错误恢复建议为可读字符串 */
+export function formatErrorRecovery(suggestion: ErrorRecoverySuggestion): string {
+  const severityIcon = suggestion.severity === 'high' ? '🔴' : suggestion.severity === 'medium' ? '🟡' : '🟢';
+  const lines = [
+    `${severityIcon} 错误恢复建议 (${suggestion.toolName}):`,
+    `错误: ${suggestion.error.slice(0, 200)}`,
+    '建议:',
+  ];
+  for (let i = 0; i < suggestion.suggestions.length; i++) {
+    lines.push(`  ${i + 1}. ${suggestion.suggestions[i]}`);
+  }
+  return lines.join('\n');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R118: Agent 循环性能分析 — 识别 Agent Loop 瓶颈
+// ═══════════════════════════════════════════════════════════════
+
+interface LoopTiming {
+  loop: number;
+  phase: string;
+  durationMs: number;
+  timestamp: number;
+}
+
+const _loopTimings: LoopTiming[] = [];
+const MAX_TIMING_ENTRIES = 200;
+
+/** R118: 记录阶段执行时间 */
+export function recordLoopTiming(loop: number, phase: string, durationMs: number): void {
+  _loopTimings.push({ loop, phase, durationMs, timestamp: Date.now() });
+  if (_loopTimings.length > MAX_TIMING_ENTRIES) {
+    _loopTimings.shift();
+  }
+}
+
+/** R118: 生成性能分析报告 */
+export function generatePerformanceReport(): {
+  totalLoops: number;
+  avgLoopTime: number;
+  slowestPhase: string;
+  phaseTimings: Record<string, { avg: number; max: number; count: number }>;
+  bottlenecks: string[];
+} {
+  if (_loopTimings.length === 0) {
+    return {
+      totalLoops: 0,
+      avgLoopTime: 0,
+      slowestPhase: '',
+      phaseTimings: {},
+      bottlenecks: ['无性能数据'],
+    };
+  }
+  
+  // 按阶段汇总
+  const phaseMap: Record<string, { total: number; max: number; count: number }> = {};
+  const loopTotals: Record<number, number> = {};
+  
+  for (const t of _loopTimings) {
+    if (!phaseMap[t.phase]) {
+      phaseMap[t.phase] = { total: 0, max: 0, count: 0 };
+    }
+    phaseMap[t.phase].total += t.durationMs;
+    phaseMap[t.phase].max = Math.max(phaseMap[t.phase].max, t.durationMs);
+    phaseMap[t.phase].count++;
+    
+    loopTotals[t.loop] = (loopTotals[t.loop] || 0) + t.durationMs;
+  }
+  
+  // 计算平均值
+  const phaseTimings: Record<string, { avg: number; max: number; count: number }> = {};
+  for (const [phase, data] of Object.entries(phaseMap)) {
+    phaseTimings[phase] = {
+      avg: Math.round(data.total / data.count),
+      max: data.max,
+      count: data.count,
+    };
+  }
+  
+  // 找到最慢的阶段
+  let slowestPhase = '';
+  let slowestAvg = 0;
+  for (const [phase, data] of Object.entries(phaseTimings)) {
+    if (data.avg > slowestAvg) {
+      slowestAvg = data.avg;
+      slowestPhase = phase;
+    }
+  }
+  
+  // 计算平均每轮时间
+  const loopTimes = Object.values(loopTotals);
+  const avgLoopTime = loopTimes.length > 0
+    ? Math.round(loopTimes.reduce((s, t) => s + t, 0) / loopTimes.length)
+    : 0;
+  
+  // 识别瓶颈
+  const bottlenecks: string[] = [];
+  if (slowestAvg > 5000) {
+    bottlenecks.push(`⚠️ ${slowestPhase} 阶段平均耗时 ${slowestAvg}ms，是主要瓶颈`);
+  }
+  if (avgLoopTime > 30000) {
+    bottlenecks.push(`⚠️ 平均每轮 ${avgLoopTime}ms，整体速度较慢`);
+  }
+  // 检查是否有异常慢的单次执行
+  for (const [phase, data] of Object.entries(phaseTimings)) {
+    if (data.max > data.avg * 3) {
+      bottlenecks.push(`⚠️ ${phase} 阶段最大耗时 ${data.max}ms 远超平均 ${data.avg}ms，可能存在异常`);
+    }
+  }
+  if (bottlenecks.length === 0) {
+    bottlenecks.push('✅ 未检测到明显性能瓶颈');
+  }
+  
+  return {
+    totalLoops: loopTimes.length,
+    avgLoopTime,
+    slowestPhase,
+    phaseTimings,
+    bottlenecks,
+  };
+}
+
+/** R118: 格式化性能报告 */
+export function formatPerformanceReport(): string {
+  const report = generatePerformanceReport();
+  const lines = [
+    `Agent Loop 性能分析 (${report.totalLoops} 轮)`,
+    `${'─'.repeat(40)}`,
+    `平均每轮耗时: ${report.avgLoopTime}ms`,
+    `最慢阶段: ${report.slowestPhase}`,
+    '',
+    '阶段明细:',
+  ];
+  for (const [phase, data] of Object.entries(report.phaseTimings)) {
+    lines.push(`  ${phase}: avg=${data.avg}ms max=${data.max}ms (${data.count}次)`);
+  }
+  lines.push('');
+  lines.push('瓶颈分析:');
+  for (const b of report.bottlenecks) {
+    lines.push(`  ${b}`);
+  }
+  return lines.join('\n');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R114: 工具调用依赖图 — 分析工具间依赖关系优化并行执行
+// ═══════════════════════════════════════════════════════════════
+
+interface ToolDependency {
+  tool: string;
+  dependsOn: string[]; // 依赖的其他工具（必须先完成）
+  produces: string[];  // 产出（文件路径等）
+  consumes: string[];  // 消费（文件路径等）
+}
+
+/** R114: 从工具调用序列推断依赖关系 */
+export function inferToolDependencies(
+  toolCalls: Array<{ name: string; arguments: Record<string, unknown> }>
+): ToolDependency[] {
+  const dependencies: ToolDependency[] = [];
+  const fileProducers = new Map<string, string>(); // filePath → toolName
+  
+  for (const call of toolCalls) {
+    const dep: ToolDependency = {
+      tool: call.name,
+      dependsOn: [],
+      produces: [],
+      consumes: [],
+    };
+    
+    // write_file/create_directory 产生文件
+    if (call.name === 'write_file' && call.arguments.path) {
+      const path = String(call.arguments.path);
+      dep.produces.push(path);
+      fileProducers.set(path, call.name);
+    }
+    
+    // read_file/edit_file/delete_file 消费文件
+    if (['read_file', 'edit_file', 'delete_file'].includes(call.name) && call.arguments.path) {
+      const path = String(call.arguments.path);
+      dep.consumes.push(path);
+      const producer = fileProducers.get(path);
+      if (producer) {
+        dep.dependsOn.push(producer);
+      }
+    }
+    
+    // run_command 可能消费前面产生的文件
+    if (call.name === 'run_command' && call.arguments.command) {
+      const cmd = String(call.arguments.command);
+      for (const [filePath, producer] of fileProducers) {
+        if (cmd.includes(filePath)) {
+          dep.consumes.push(filePath);
+          dep.dependsOn.push(producer);
+        }
+      }
+    }
+    
+    dependencies.push(dep);
+  }
+  
+  return dependencies;
+}
+
+/** R114: 基于依赖关系对工具调用分组（可并行执行的分为一组） */
+export function groupToolsByDependency(
+  toolCalls: Array<{ name: string; arguments: Record<string, unknown> }>
+): Array<Array<{ name: string; arguments: Record<string, unknown> }>> {
+  const deps = inferToolDependencies(toolCalls);
+  const groups: Array<Array<{ name: string; arguments: Record<string, unknown> }>> = [];
+  const completed = new Set<string>();
+  
+  let remaining = [...toolCalls.map((tc, i) => ({ ...tc, index: i }))];
+  
+  while (remaining.length > 0) {
+    const currentBatch: Array<{ name: string; arguments: Record<string, unknown> }> = [];
+    const batchIndices = new Set<number>();
+    
+    for (const tc of remaining) {
+      const dep = deps[tc.index];
+      // 检查所有依赖是否已完成
+      const canRun = dep.dependsOn.every(d => completed.has(d));
+      if (canRun) {
+        currentBatch.push({ name: tc.name, arguments: tc.arguments });
+        batchIndices.add(tc.index);
+      }
+    }
+    
+    if (currentBatch.length === 0) {
+      // 没有可执行的（可能有循环依赖），强制执行剩余的
+      groups.push(remaining.map(tc => ({ name: tc.name, arguments: tc.arguments })));
+      break;
+    }
+    
+    groups.push(currentBatch);
+    for (const idx of batchIndices) {
+      completed.add(toolCalls[idx].name);
+    }
+    remaining = remaining.filter(tc => !batchIndices.has(tc.index));
+  }
+  
+  return groups;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R117: 记忆搜索相关性调优 — 微调记忆搜索评分权重
+// ═══════════════════════════════════════════════════════════════
+
+export interface MemorySearchConfig {
+  idfWeight: number;       // IDF 权重
+  fuzzyWeight: number;     // 模糊匹配权重
+  phraseBonus: number;     // 多词短语奖励
+  recencyBonus: number;    // 时近性奖励
+  frequencyBonus: number;  // 访问频率奖励
+}
+
+const _memorySearchConfig: MemorySearchConfig = {
+  idfWeight: 1.0,
+  fuzzyWeight: 0.5,
+  phraseBonus: 2.0,
+  recencyBonus: 0.3,
+  frequencyBonus: 0.2,
+};
+
+/** R117: 获取当前记忆搜索配置 */
+export function getMemorySearchConfig(): MemorySearchConfig {
+  return { ..._memorySearchConfig };
+}
+
+/** R117: 更新记忆搜索配置 */
+export function updateMemorySearchConfig(updates: Partial<MemorySearchConfig>): void {
+  Object.assign(_memorySearchConfig, updates);
+  logInfo(`R117: 记忆搜索配置已更新`, JSON.stringify(_memorySearchConfig));
+}
+
+/** R117: 根据搜索效果自动调优 */
+export function autoTuneMemorySearch(
+  avgResultCount: number,
+  avgRelevanceScore: number
+): { tuned: boolean; changes: string[] } {
+  const changes: string[] = [];
+  
+  // 如果结果太多但相关性低，增加 IDF 权重
+  if (avgResultCount > 10 && avgRelevanceScore < 0.3) {
+    _memorySearchConfig.idfWeight += 0.2;
+    changes.push(`IDF 权重增加到 ${_memorySearchConfig.idfWeight.toFixed(1)}（提高区分度）`);
+  }
+  
+  // 如果结果太少，降低模糊匹配阈值
+  if (avgResultCount < 2) {
+    _memorySearchConfig.fuzzyWeight += 0.1;
+    changes.push(`模糊匹配权重增加到 ${_memorySearchConfig.fuzzyWeight.toFixed(1)}（放宽匹配）`);
+  }
+  
+  // 如果相关性分数高但结果少，增加频率奖励
+  if (avgRelevanceScore > 0.7 && avgResultCount < 5) {
+    _memorySearchConfig.frequencyBonus += 0.1;
+    changes.push(`频率奖励增加到 ${_memorySearchConfig.frequencyBonus.toFixed(1)}（优先高频条目）`);
+  }
+  
+  return { tuned: changes.length > 0, changes };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R119: 工具执行队列优先级 — 按重要性排序工具执行
+// ═══════════════════════════════════════════════════════════════
+
+export type ToolPriority = 'critical' | 'high' | 'normal' | 'low';
+
+const TOOL_PRIORITY_MAP: Record<string, ToolPriority> = {
+  // 关键：用户直接请求的操作
+  write_file: 'critical',
+  edit_file: 'critical',
+  delete_file: 'high',
+  
+  // 高：信息获取类
+  read_file: 'high',
+  list_directory: 'high',
+  search_files: 'high',
+  
+  // 普通：辅助工具
+  run_command: 'normal',
+  web_search: 'normal',
+  web_fetch: 'normal',
+  git: 'normal',
+  
+  // 低：非关键
+  memory: 'low',
+  datetime: 'low',
+  calculator: 'low',
+  random: 'low',
+  uuid: 'low',
+};
+
+/** R119: 获取工具优先级 */
+export function getToolPriority(toolName: string): ToolPriority {
+  return TOOL_PRIORITY_MAP[toolName] || 'normal';
+}
+
+/** R119: 按优先级排序工具调用 */
+export function sortToolsByPriority<T extends { name: string }>(
+  tools: T[]
+): T[] {
+  const priorityOrder: Record<ToolPriority, number> = {
+    critical: 0,
+    high: 1,
+    normal: 2,
+    low: 3,
+  };
+  
+  return [...tools].sort((a, b) => {
+    const pa = priorityOrder[getToolPriority(a.name)];
+    const pb = priorityOrder[getToolPriority(b.name)];
+    return pa - pb;
+  });
+}
+
+/** R119: 按优先级分批（同优先级可并行） */
+export function batchToolsByPriority<T extends { name: string }>(
+  tools: T[]
+): T[][] {
+  const batches: T[][] = [];
+  const sorted = sortToolsByPriority(tools);
+  
+  let currentBatch: T[] = [];
+  let currentPriority: ToolPriority | null = null;
+  
+  for (const tool of sorted) {
+    const priority = getToolPriority(tool.name);
+    if (currentPriority === null) {
+      currentPriority = priority;
+    }
+    if (priority !== currentPriority) {
+      if (currentBatch.length > 0) batches.push(currentBatch);
+      currentBatch = [];
+      currentPriority = priority;
+    }
+    currentBatch.push(tool);
+  }
+  
+  if (currentBatch.length > 0) batches.push(currentBatch);
+  return batches;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R124: 压缩上下文中工具引用解析 — 恢复被压缩的工具结果引用
+// ═══════════════════════════════════════════════════════════════
+
+/** R124: 在压缩后的上下文中解析工具引用 */
+export function resolveCompressedReferences(
+  messages: Array<{ role: string; content: string }>
+): { resolved: number; unresolved: string[] } {
+  let resolved = 0;
+  const unresolved: string[] = [];
+  
+  for (const msg of messages) {
+    if (msg.role !== 'tool') continue;
+    const content = msg.content || '';
+    
+    // 查找引用标记
+    const refMatch = content.match(/\[工具结果已归档 ref=(\S+)/);
+    if (refMatch) {
+      const refId = refMatch[1];
+      const stored = _toolResultStore.get(refId);
+      if (stored) {
+        resolved++;
+      } else {
+        unresolved.push(refId);
+      }
+    }
+  }
+  
+  return { resolved, unresolved };
+}
+
+/** R124: 恢复压缩引用为完整内容（仅对指定引用） */
+export function restoreCompressedReference(
+  refId: string,
+  maxLen?: number
+): string | null {
+  const stored = _toolResultStore.get(refId);
+  if (!stored) return null;
+  
+  const content = stored.fullContent;
+  if (maxLen && content.length > maxLen) {
+    return content.slice(0, maxLen) + `\n...(已截断，完整内容 ${content.length} 字符)`;
+  }
+  return content;
+}
+
diff --git a/src/renderer/services/completion-gate.ts b/src/renderer/services/completion-gate.ts
index a72d0b5..3318768 100644
--- a/src/renderer/services/completion-gate.ts
+++ b/src/renderer/services/completion-gate.ts
@@ -105,6 +105,32 @@ const contextEfficiencyCheck: CompletionCheck = {
   },
 };
 
+/** R83: Plan Mode 完成检查 — 验证所有计划步骤是否已标记完成 */
+const planModeCompletionCheck: CompletionCheck = {
+  name: 'planModeCompletion',
+  description: 'Plan Mode 下检查所有计划步骤是否已完成',
+  check: async (ctx: LoopContext) => {
+    if (ctx.mode !== 'plan') return { passed: true, reason: '' };
+    // 从 state 获取 Plan Tracker
+    try {
+      const { getPlanTracker } = await import('./tool-registry.js');
+      const tracker = getPlanTracker();
+      if (!tracker.active || tracker.steps.length === 0) return { passed: true, reason: '' };
+      if (tracker.done < tracker.total) {
+        const remaining = tracker.total - tracker.done;
+        const undoneSteps = tracker.steps.filter(s => !s.done).map(s => s.label).slice(0, 3);
+        return {
+          passed: false,
+          reason: `Plan Mode: 还有 ${remaining} 步未完成（${undoneSteps.join('、')}${remaining > 3 ? '...' : ''}）。请继续执行剩余步骤，或说明为什么这些步骤无法完成。`
+        };
+      }
+      return { passed: true, reason: '' };
+    } catch {
+      return { passed: true, reason: '' };
+    }
+  },
+};
+
 // ═══════════════════════════════════════════════════════════════
 // 检查项注册与管理
 // ═══════════════════════════════════════════════════════════════
@@ -114,6 +140,7 @@ const DEFAULT_ENABLED_CHECKS = new Set([
   'contentQuality',
   'toolResultReview',
   'notThinking',
+  'planModeCompletion',
 ]);
 
 /** 注册表 */
@@ -122,6 +149,7 @@ const checkRegistry = new Map<string, CompletionCheck>([
   ['toolResultReview', toolResultReviewCheck],
   ['notThinking', notThinkingCheck],
   ['contextEfficiency', contextEfficiencyCheck],
+  ['planModeCompletion', planModeCompletionCheck],
 ]);
 
 /** 已启用的检查项 */
@@ -165,54 +193,104 @@ export function getEnabledChecks(): CompletionCheck[] {
 export interface GateResult {
   passed: boolean;
   reason: string;
-  /** 各项检查的详细结果 */
+  /** R90: 各项检查的详细结果 */
   details: Array<{ name: string; passed: boolean; reason: string; durationMs: number }>;
+  /** R90/R127: 完成门控评分（0-100） */
+  score: number;
+  /** R90/R127: 评分明细 */
+  scoreBreakdown: Array<{ check: string; passed: boolean; points: number }>;
 }
 
+/** R127: 各检查项的权重分配 */
+const CHECK_WEIGHTS: Record<string, number> = {
+  contentQuality: 30,
+  toolResultReview: 25,
+  notThinking: 20,
+  contextEfficiency: 15,
+  planModeCompletion: 10,
+};
+
 /**
  * 运行完成门控检查
+ * R90: 返回评分结果，评分基于各检查项的权重
  */
 export async function runCompletionGate(ctx: LoopContext): Promise<GateResult> {
   const checks = getEnabledChecks();
   if (checks.length === 0) {
-    return { passed: true, reason: '', details: [] };
+    return { passed: true, reason: '', details: [], score: 100, scoreBreakdown: [] };
   }
 
   const details: GateResult['details'] = [];
+  const scoreBreakdown: GateResult['scoreBreakdown'] = [];
+  let totalScore = 0;
+  let maxScore = 0;
 
   for (const check of checks) {
     const start = Date.now();
     try {
       const result = await check.check(ctx);
+      const durationMs = Date.now() - start;
+      const weight = CHECK_WEIGHTS[check.name] ?? 10;
+      maxScore += weight;
+
       details.push({
         name: check.name,
         passed: result.passed,
         reason: result.reason,
-        durationMs: Date.now() - start,
+        durationMs,
       });
-      if (!result.passed) {
+
+      scoreBreakdown.push({
+        check: check.name,
+        passed: result.passed,
+        points: result.passed ? weight : 0,
+      });
+
+      if (result.passed) {
+        totalScore += weight;
+      } else {
         logWarn(`Completion Gate: "${check.name}" — ${result.reason}`);
-        return { passed: false, reason: result.reason, details };
+        return {
+          passed: false,
+          reason: result.reason,
+          details,
+          score: Math.round((totalScore / Math.max(1, maxScore)) * 100),
+          scoreBreakdown,
+        };
       }
     } catch (err) {
+      const weight = CHECK_WEIGHTS[check.name] ?? 10;
+      maxScore += weight;
       details.push({
         name: check.name,
         passed: true,
         reason: `检查异常: ${(err as Error).message}`,
         durationMs: Date.now() - start,
       });
+      scoreBreakdown.push({
+        check: check.name,
+        passed: true,
+        points: weight,
+      });
+      totalScore += weight;
     }
   }
 
-  return { passed: true, reason: '', details };
+  return {
+    passed: true,
+    reason: '',
+    details,
+    score: Math.round((totalScore / Math.max(1, maxScore)) * 100),
+    scoreBreakdown,
+  };
 }
 
 /**
- * 生成门控报告（供日志/调试使用）
+ * R127: 生成门控报告（供日志/调试使用）
  */
 export function formatGateReport(result: GateResult): string {
   const status = result.passed ? '✅ 通过' : '❌ 未通过';
-  let report = `Completion Gate ${status}`;
+  let report = `Completion Gate ${status} (评分: ${result.score}/100)`;
   if (!result.passed) {
     report += ` — ${result.reason}`;
   }
@@ -221,5 +299,12 @@ export function formatGateReport(result: GateResult): string {
     const icon = d.passed ? '✅' : '❌';
     report += `\n${icon} ${d.name}: ${d.reason || '通过'} (${d.durationMs}ms)`;
   }
+  // R127: 评分明细
+  if (result.scoreBreakdown.length > 0) {
+    report += `\n${'─'.repeat(40)}\n评分明细:`;
+    for (const s of result.scoreBreakdown) {
+      report += `\n  ${s.passed ? '✅' : '❌'} ${s.check}: ${s.points} 分`;
+    }
+  }
   return report;
 }
diff --git a/src/renderer/services/context-manager.ts b/src/renderer/services/context-manager.ts
index b8a2bca..c3c8d6d 100644
--- a/src/renderer/services/context-manager.ts
+++ b/src/renderer/services/context-manager.ts
@@ -903,7 +903,13 @@ function trimByTokenLimit(messages: OllamaMessage[], maxTokens: number): OllamaM
     return [...systemMsgs, ...recentMsgs];
   }
 
-  // 按重要性降序排列，取能装下的最大数量
+  // R94: 按综合评分降序排列（重要性 + 时近性），取能装下的最大数量
+  const totalOlder = olderMsgs.length;
+  scored.forEach((s, idx) => {
+    // R94: 时近性因子 — 越靠近最近窗口的消息得分越高（0~2 分加成）
+    const recencyRatio = totalOlder > 1 ? idx / (totalOlder - 1) : 1;
+    s.importance += Math.round(recencyRatio * 2);
+  });
   scored.sort((a, b) => b.importance - a.importance);
 
   let usedTokens = 0;
@@ -924,3 +930,959 @@ function trimByTokenLimit(messages: OllamaMessage[], maxTokens: number): OllamaM
 
   return result;
 }
+
+// ═══════════════════════════════════════════════════════════════
+// R91: 上下文压力分级评估 — 三级压力系统指导压缩策略选择
+// ═══════════════════════════════════════════════════════════════
+
+export type ContextPressureLevel = 'low' | 'medium' | 'high' | 'critical';
+
+export interface ContextPressureInfo {
+  level: ContextPressureLevel;
+  tokenUsageRatio: number;   // 0-1
+  messageCount: number;
+  recommendedActions: string[]; // 建议的压缩动作
+}
+
+/**
+ * R91: 评估当前上下文压力等级
+ * - low (<30%): 无需压缩
+ * - medium (30-50%): 轻量压缩（归档旧工具结果、清理 ephemeral）
+ * - high (50-70%): 中等压缩（截断工具结果、合并消息）
+ * - critical (>70%): LLM 压缩
+ */
+export function getContextPressureLevel(
+  messages: OllamaMessage[],
+  numCtx: number,
+): ContextPressureInfo {
+  const totalTokens = messages.reduce((sum, m) => {
+    let t = estimateTokens(m.content || '');
+    if (m.tool_calls?.length) {
+      for (const tc of m.tool_calls) {
+        const argsSize = JSON.stringify(tc.function.arguments || {}).length;
+        t += estimateTokens(tc.function.name) + Math.ceil(argsSize / 4) + 20;
+      }
+    }
+    if (m.images?.length) t += m.images.length * 100;
+    return sum + t;
+  }, 0);
+
+  const ratio = numCtx > 0 ? totalTokens / numCtx : 0;
+  const msgCount = messages.length;
+  const actions: string[] = [];
+
+  let level: ContextPressureLevel;
+  if (ratio > 0.7) {
+    level = 'critical';
+    actions.push('llm_compress', 'truncate_results', 'compact_old', 'merge_messages', 'clear_ephemeral');
+  } else if (ratio > 0.5) {
+    level = 'high';
+    actions.push('truncate_results', 'compact_old', 'merge_messages');
+  } else if (ratio > 0.3) {
+    level = 'medium';
+    actions.push('compact_old', 'clear_ephemeral');
+  } else {
+    level = 'low';
+    if (msgCount > 60) actions.push('compact_old');
+  }
+
+  return { level, tokenUsageRatio: ratio, messageCount: msgCount, recommendedActions: actions };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R93: Token 预算追踪器 — 实时追踪输入/输出 token 与预算比例
+// ═══════════════════════════════════════════════════════════════
+
+interface TokenBudgetEntry {
+  loop: number;
+  inputTokens: number;   // prompt_eval_count
+  outputTokens: number;  // eval_count
+  estimatedTokens: number; // 本地估算值
+  timestamp: number;
+}
+
+const _tokenBudgetHistory: TokenBudgetEntry[] = [];
+const MAX_BUDGET_ENTRIES = 50;
+let _totalInputTokens = 0;
+let _totalOutputTokens = 0;
+let _budgetNumCtx = 131072;
+
+/** R93: 设置当前预算的 numCtx */
+export function setTokenBudgetNumCtx(numCtx: number): void {
+  _budgetNumCtx = numCtx;
+}
+
+/** R93: 记录一轮的 token 消耗 */
+export function recordBudgetUsage(
+  loop: number,
+  inputTokens: number,
+  outputTokens: number,
+  estimatedTokens: number,
+): void {
+  _tokenBudgetHistory.push({
+    loop, inputTokens, outputTokens, estimatedTokens, timestamp: Date.now(),
+  });
+  if (_tokenBudgetHistory.length > MAX_BUDGET_ENTRIES) {
+    _tokenBudgetHistory.shift();
+  }
+  _totalInputTokens += inputTokens;
+  _totalOutputTokens += outputTokens;
+}
+
+/** R93: 获取 Token 预算使用情况 */
+export interface TokenBudgetStatus {
+  totalInput: number;
+  totalOutput: number;
+  totalSpent: number;
+  avgInputPerLoop: number;
+  avgOutputPerLoop: number;
+  budgetNumCtx: number;
+  currentLoopInput: number;
+  budgetUtilization: number; // 当前轮输入占预算比例 0-1
+  trend: 'increasing' | 'stable' | 'decreasing';
+  history: TokenBudgetEntry[];
+}
+
+/** R93: 获取当前 Token 预算状态 */
+export function getTokenBudgetStatus(): TokenBudgetStatus {
+  const history = [..._tokenBudgetHistory];
+  const currentLoop = history.length > 0 ? history[history.length - 1] : null;
+
+  // 计算趋势
+  let trend: 'increasing' | 'stable' | 'decreasing' = 'stable';
+  if (history.length >= 3) {
+    const recent = history.slice(-3);
+    const avg = recent.reduce((s, e) => s + e.inputTokens, 0) / recent.length;
+    const oldest = recent[0].inputTokens;
+    if (avg > oldest * 1.15) trend = 'increasing';
+    else if (avg < oldest * 0.85) trend = 'decreasing';
+  }
+
+  const avgInput = history.length > 0
+    ? Math.round(_totalInputTokens / history.length)
+    : 0;
+  const avgOutput = history.length > 0
+    ? Math.round(_totalOutputTokens / history.length)
+    : 0;
+
+  return {
+    totalInput: _totalInputTokens,
+    totalOutput: _totalOutputTokens,
+    totalSpent: _totalInputTokens + _totalOutputTokens,
+    avgInputPerLoop: avgInput,
+    avgOutputPerLoop: avgOutput,
+    budgetNumCtx: _budgetNumCtx,
+    currentLoopInput: currentLoop?.inputTokens || 0,
+    budgetUtilization: _budgetNumCtx > 0 && currentLoop
+      ? currentLoop.inputTokens / _budgetNumCtx
+      : 0,
+    trend,
+    history,
+  };
+}
+
+/** R93: 重置 Token 预算追踪 */
+export function resetTokenBudget(): void {
+  _tokenBudgetHistory.length = 0;
+  _totalInputTokens = 0;
+  _totalOutputTokens = 0;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R96: 消息角色压缩 — 合并连续相同角色消息，减少消息条数开销
+// ═══════════════════════════════════════════════════════════════
+
+/**
+ * R96: 合并连续相同角色的非工具消息
+ * 规则：
+ * - 连续的 user 消息合并为一条（用分隔符连接）
+ * - 连续的 assistant 消息合并为一条（保留 tool_calls）
+ * - tool 消息不合并（每条对应一个 tool_call）
+ * - system 消息不合并（已有 R17 处理）
+ * - ephemeral 临时消息不合并
+ * - compressed 消息不合并
+ */
+export function mergeConsecutiveMessages(messages: OllamaMessage[]): OllamaMessage[] {
+  if (messages.length <= 2) return messages;
+
+  const result: OllamaMessage[] = [];
+  let mergedCount = 0;
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const last = result[result.length - 1];
+
+    // 不合并的情况
+    if (
+      !last ||
+      msg.role === 'tool' ||
+      msg.role === 'system' ||
+      msg.ephemeral ||
+      msg.compressed ||
+      last.role !== msg.role ||
+      last.ephemeral ||
+      last.compressed ||
+      msg.tool_calls?.length ||  // 有工具调用的 assistant 不合并
+      last.tool_calls?.length
+    ) {
+      result.push(msg);
+      continue;
+    }
+
+    // 合并连续相同角色消息
+    // 限制合并后内容不超过 3000 字符，避免合并后过长
+    const combinedContent = (last.content || '') + '\n\n' + (msg.content || '');
+    if (combinedContent.length > 3000) {
+      result.push(msg);
+      continue;
+    }
+
+    result[result.length - 1] = {
+      ...last,
+      content: combinedContent,
+    };
+    mergedCount++;
+  }
+
+  if (mergedCount > 0) {
+    logInfo(`R96: 消息角色压缩 — 合并了 ${mergedCount} 条连续同角色消息 (${messages.length} → ${result.length})`);
+  }
+
+  return result;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R98: 压缩触发阈值优化 — 结合趋势预测动态调整
+// ═══════════════════════════════════════════════════════════════
+
+/**
+ * R98: 获取结合趋势的压缩触发阈值
+ * 如果 token 使用趋势在快速增长，提前触发压缩
+ * 如果趋势稳定或下降，延后压缩
+ */
+export function getTrendAwareCompressThreshold(
+  numCtx: number,
+  messages: OllamaMessage[],
+): { shouldCompress: boolean; reason: string; urgency: 'low' | 'medium' | 'high' } {
+  const baseThreshold = getAdaptiveCompressThreshold(numCtx);
+  const currentTokens = messages.reduce((sum, m) => {
+    let t = estimateTokens(m.content || '');
+    if (m.tool_calls?.length) {
+      for (const tc of m.tool_calls) {
+        const argsSize = JSON.stringify(tc.function.arguments || {}).length;
+        t += estimateTokens(tc.function.name) + Math.ceil(argsSize / 4) + 20;
+      }
+    }
+    if (m.images?.length) t += m.images.length * 100;
+    return sum + t;
+  }, 0);
+
+  const usageRatio = numCtx > 0 ? currentTokens / numCtx : 0;
+  const prediction = predictContextOverflow(numCtx);
+
+  // 紧急情况：预测即将溢出
+  if (prediction.level === 'critical' || (prediction.level === 'warning' && prediction.turnsToOverflow <= 2)) {
+    return {
+      shouldCompress: true,
+      reason: `趋势预测触发: ${prediction.message}`,
+      urgency: 'high',
+    };
+  }
+
+  // 趋势加速增长 + 使用率超过基础阈值
+  if (prediction.turnsToOverflow > 0 && prediction.turnsToOverflow <= 5 && usageRatio > baseThreshold * 0.8) {
+    return {
+      shouldCompress: true,
+      reason: `趋势加速: ${prediction.turnsToOverflow} 轮后可能溢出，当前使用率 ${(usageRatio * 100).toFixed(0)}%`,
+      urgency: 'medium',
+    };
+  }
+
+  // 标准阈值触发
+  if (usageRatio > baseThreshold) {
+    return {
+      shouldCompress: true,
+      reason: `标准阈值触发: 使用率 ${(usageRatio * 100).toFixed(0)}% > 阈值 ${(baseThreshold * 100).toFixed(0)}%`,
+      urgency: usageRatio > 0.6 ? 'high' : 'medium',
+    };
+  }
+
+  // 消息条数硬阈值
+  const msgThreshold = getIncrementalCompressThresholdMessages(numCtx);
+  if (messages.length >= msgThreshold) {
+    return {
+      shouldCompress: true,
+      reason: `消息条数触发: ${messages.length} >= ${msgThreshold}`,
+      urgency: 'low',
+    };
+  }
+
+  return { shouldCompress: false, reason: '', urgency: 'low' };
+}
+
+/** R98: 消息条数阈值（独立函数，供 engine 复用） */
+function getIncrementalCompressThresholdMessages(numCtx: number): number {
+  const tokenThreshold = Math.floor(numCtx * 0.3);
+  return Math.max(20, Math.min(120, Math.floor(tokenThreshold / 100)));
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R100: Token 使用统计报告 — 生成详细消耗分析
+// ═══════════════════════════════════════════════════════════════
+
+export interface TokenReport {
+  generatedAt: number;
+  session: {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    loopCount: number;
+    avgInputPerLoop: number;
+    avgOutputPerLoop: number;
+  };
+  budget: {
+    numCtx: number;
+    currentUtilization: number;
+    peakUtilization: number;
+    trend: 'increasing' | 'stable' | 'decreasing';
+  };
+  compression: {
+    historyCount: number;
+    avgCompressionRatio: number;
+    lastCompressionRatio: number | null;
+  };
+  warnings: string[];
+}
+
+/**
+ * R100: 生成 Token 使用统计报告
+ */
+export function generateTokenReport(numCtx: number): TokenReport {
+  const budget = getTokenBudgetStatus();
+  const compressionHistory = getCompressionHistory();
+
+  // 计算峰值利用率
+  let peakUtilization = 0;
+  for (const entry of budget.history) {
+    const util = numCtx > 0 ? entry.inputTokens / numCtx : 0;
+    if (util > peakUtilization) peakUtilization = util;
+  }
+
+  const warnings: string[] = [];
+  if (budget.budgetUtilization > 0.7) {
+    warnings.push(`当前轮 token 使用率过高: ${(budget.budgetUtilization * 100).toFixed(0)}%`);
+  }
+  if (budget.trend === 'increasing' && budget.avgInputPerLoop > numCtx * 0.3) {
+    warnings.push(`token 消耗趋势上升，平均每轮 ${budget.avgInputPerLoop} tokens`);
+  }
+  if (compressionHistory.length > 0) {
+    const avgRatio = getAverageCompressionRatio();
+    if (avgRatio > 0.8) {
+      warnings.push(`压缩效率偏低: 平均压缩率 ${(avgRatio * 100).toFixed(0)}% (越低越好)`);
+    }
+  }
+
+  return {
+    generatedAt: Date.now(),
+    session: {
+      totalInputTokens: budget.totalInput,
+      totalOutputTokens: budget.totalOutput,
+      totalTokens: budget.totalSpent,
+      loopCount: budget.history.length,
+      avgInputPerLoop: budget.avgInputPerLoop,
+      avgOutputPerLoop: budget.avgOutputPerLoop,
+    },
+    budget: {
+      numCtx,
+      currentUtilization: budget.budgetUtilization,
+      peakUtilization,
+      trend: budget.trend,
+    },
+    compression: {
+      historyCount: compressionHistory.length,
+      avgCompressionRatio: getAverageCompressionRatio(),
+      lastCompressionRatio: compressionHistory.length > 0
+        ? compressionHistory[compressionHistory.length - 1].compressionRatio
+        : null,
+    },
+    warnings,
+  };
+}
+
+/** R100: 格式化 Token 报告为可读字符串 */
+export function formatTokenReport(report: TokenReport): string {
+  const lines: string[] = [
+    `Token Usage Report (${new Date(report.generatedAt).toLocaleTimeString()})`,
+    `${'─'.repeat(50)}`,
+    `Session:`,
+    `  Total Input:  ${report.session.totalInputTokens.toLocaleString()} tokens`,
+    `  Total Output: ${report.session.totalOutputTokens.toLocaleString()} tokens`,
+    `  Total Spent:  ${report.session.totalTokens.toLocaleString()} tokens`,
+    `  Loops:        ${report.session.loopCount}`,
+    `  Avg In/Loop:  ${report.session.avgInputPerLoop.toLocaleString()} tokens`,
+    `  Avg Out/Loop: ${report.session.avgOutputPerLoop.toLocaleString()} tokens`,
+    `Budget:`,
+    `  numCtx:           ${report.budget.numCtx.toLocaleString()}`,
+    `  Current Usage:    ${(report.budget.currentUtilization * 100).toFixed(1)}%`,
+    `  Peak Usage:       ${(report.budget.peakUtilization * 100).toFixed(1)}%`,
+    `  Trend:            ${report.budget.trend}`,
+    `Compression:`,
+    `  History Count:    ${report.compression.historyCount}`,
+    `  Avg Ratio:        ${(report.compression.avgCompressionRatio * 100).toFixed(0)}%`,
+    `  Last Ratio:       ${report.compression.lastCompressionRatio !== null ? (report.compression.lastCompressionRatio * 100).toFixed(0) + '%' : 'N/A'}`,
+  ];
+  if (report.warnings.length > 0) {
+    lines.push(`Warnings:`);
+    for (const w of report.warnings) {
+      lines.push(`  ⚠️ ${w}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R111: 压缩策略自适应选择 — 根据上下文特征选择快速压缩或 LLM 压缩
+// ═══════════════════════════════════════════════════════════════
+
+export type CompressionStrategy = 'skip' | 'fast' | 'medium' | 'llm';
+
+export interface CompressionDecision {
+  strategy: CompressionStrategy;
+  reason: string;
+  estimatedSavings: number; // 预估节省 token 数
+}
+
+/** R111: 根据上下文压力和消息特征选择最优压缩策略 */
+export function chooseCompressionStrategy(
+  messages: OllamaMessage[],
+  numCtx: number,
+  pressureLevel: string
+): CompressionDecision {
+  const totalTokens = estimateTokens(messages.map(m => m.content || '').join(''));
+  const usageRatio = numCtx > 0 ? totalTokens / numCtx : 0;
+
+  // R120: 如果上下文压力很低且消息不多，跳过压缩
+  if (pressureLevel === 'low' && messages.length < 30) {
+    return {
+      strategy: 'skip',
+      reason: `上下文压力低 (${messages.length} 条消息, ${(usageRatio * 100).toFixed(0)}%)，无需压缩`,
+      estimatedSavings: 0,
+    };
+  }
+
+  // 统计工具结果消息占比
+  const toolMsgs = messages.filter(m => m.role === 'tool');
+  const toolRatio = messages.length > 0 ? toolMsgs.length / messages.length : 0;
+
+  // 如果工具结果占比高，使用快速压缩（截断+归档）
+  if (toolRatio > 0.4 && pressureLevel !== 'critical') {
+    const savings = Math.floor(totalTokens * 0.3);
+    return {
+      strategy: 'fast',
+      reason: `工具结果占比高 (${(toolRatio * 100).toFixed(0)}%)，使用快速截断压缩`,
+      estimatedSavings: savings,
+    };
+  }
+
+  // 中等压力：中等压缩（消息合并+旧消息裁剪）
+  if (pressureLevel === 'medium' || pressureLevel === 'high') {
+    const savings = Math.floor(totalTokens * 0.4);
+    return {
+      strategy: 'medium',
+      reason: `中等压力 (${pressureLevel})，使用消息合并+裁剪`,
+      estimatedSavings: savings,
+    };
+  }
+
+  // 关键压力或高使用率：使用 LLM 摘要压缩
+  if (pressureLevel === 'critical' || usageRatio > 0.75) {
+    const savings = Math.floor(totalTokens * 0.6);
+    return {
+      strategy: 'llm',
+      reason: `高压力 (${pressureLevel}, ${(usageRatio * 100).toFixed(0)}%)，使用 LLM 摘要压缩`,
+      estimatedSavings: savings,
+    };
+  }
+
+  // 默认：快速压缩
+  return {
+    strategy: 'fast',
+    reason: '默认快速压缩',
+    estimatedSavings: Math.floor(totalTokens * 0.2),
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R115: 上下文水印 — 标记不可压缩的关键信息
+// ═══════════════════════════════════════════════════════════════
+
+/** 水印标记：带有此标记的消息在压缩时会被保留 */
+const WATERMARK_PREFIX = '[PRESERVE]';
+const _watermarkedIndices = new Set<number>();
+
+/** R115: 标记消息为不可压缩 */
+export function watermarkMessage(index: number): void {
+  _watermarkedIndices.add(index);
+}
+
+/** R115: 检查消息是否被水印保护 */
+export function isWatermarked(index: number): boolean {
+  return _watermarkedIndices.has(index);
+}
+
+/** R115: 自动为关键消息添加水印 */
+export function autoWatermarkCritical(messages: OllamaMessage[]): number[] {
+  const protectedIndices: number[] = [];
+  
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const content = msg.content || '';
+    
+    // 系统消息始终保护
+    if (msg.role === 'system') {
+      watermarkMessage(i);
+      protectedIndices.push(i);
+      continue;
+    }
+    
+    // 包含错误信息的用户消息保护
+    if (msg.role === 'user' && (content.includes('错误') || content.includes('error') || content.includes('失败'))) {
+      watermarkMessage(i);
+      protectedIndices.push(i);
+      continue;
+    }
+    
+    // 最近 5 条消息保护
+    if (i >= messages.length - 5) {
+      watermarkMessage(i);
+      protectedIndices.push(i);
+    }
+  }
+  
+  return protectedIndices;
+}
+
+/** R115: 清除水印 */
+export function clearWatermarks(): void {
+  _watermarkedIndices.clear();
+}
+
+/** R115: 获取受保护的消息索引列表 */
+export function getWatermarkedIndices(): number[] {
+  return Array.from(_watermarkedIndices).sort((a, b) => a - b);
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R120: 上下文压缩跳过逻辑 — 不值得压缩时跳过
+// ═══════════════════════════════════════════════════════════════
+
+/** R120: 判断是否应该跳过压缩 */
+export function shouldSkipCompression(
+  messages: OllamaMessage[],
+  numCtx: number,
+  recentCompressionRatio: number
+): { skip: boolean; reason: string } {
+  const totalTokens = estimateTokens(messages.map(m => m.content || '').join(''));
+  const usageRatio = numCtx > 0 ? totalTokens / numCtx : 0;
+  
+  // 如果使用率很低，跳过
+  if (usageRatio < 0.2) {
+    return { skip: true, reason: `上下文使用率极低 (${(usageRatio * 100).toFixed(0)}%)，无需压缩` };
+  }
+  
+  // 如果消息数太少，跳过
+  if (messages.length < 10) {
+    return { skip: true, reason: `消息数过少 (${messages.length} 条)，无需压缩` };
+  }
+  
+  // 如果最近压缩收益很低（压缩比 < 10%），跳过
+  if (recentCompressionRatio > 0.9) {
+    return { skip: true, reason: `最近压缩收益低 (压缩比 ${(recentCompressionRatio * 100).toFixed(0)}%)，跳过` };
+  }
+  
+  // 如果大部分消息已经被归档/压缩过，跳过
+  const archivedCount = messages.filter(m => 
+    m.content?.includes('[工具结果已归档]') || m.content?.includes('[PRESERVE]')
+  ).length;
+  if (archivedCount / messages.length > 0.6) {
+    return { skip: true, reason: `大部分消息已归档 (${(archivedCount / messages.length * 100).toFixed(0)}%)，跳过` };
+  }
+  
+  return { skip: false, reason: '' };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R121: 滑动窗口自适应大小 — 根据上下文压力动态调整窗口大小
+// ═══════════════════════════════════════════════════════════════
+
+/** R121: 根据上下文压力获取自适应滑动窗口大小 */
+export function getAdaptiveWindowSize(
+  totalMessages: number,
+  pressureLevel: string,
+  numCtx: number
+): { keepRecent: number; keepSystem: number; reason: string } {
+  const baseWindow = Math.min(totalMessages, 40);
+  
+  switch (pressureLevel) {
+    case 'critical':
+      return {
+        keepRecent: Math.min(baseWindow, 15),
+        keepSystem: 2,
+        reason: '关键压力：保留最近 15 条 + 系统 2 条',
+      };
+    case 'high':
+      return {
+        keepRecent: Math.min(baseWindow, 25),
+        keepSystem: 3,
+        reason: '高压力：保留最近 25 条 + 系统 3 条',
+      };
+    case 'medium':
+      return {
+        keepRecent: Math.min(baseWindow, 35),
+        keepSystem: 5,
+        reason: '中等压力：保留最近 35 条 + 系统 5 条',
+      };
+    case 'low':
+    default:
+      return {
+        keepRecent: Math.min(baseWindow, 50),
+        keepSystem: 5,
+        reason: '低压力：保留最近 50 条 + 系统 5 条',
+      };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R122: Token 趋势分析 — 深度分析 token 使用趋势用于预测性压缩
+// ═══════════════════════════════════════════════════════════════
+
+export interface TrendAnalysis {
+  trend: 'increasing' | 'decreasing' | 'stable';
+  avgGrowthRate: number; // 每轮平均 token 增长量
+  projectedOverflow: number; // 预计几轮后溢出（-1=不会）
+  recommendedAction: string;
+  confidence: number; // 0-1
+}
+
+/** R122: 分析 token 使用趋势 */
+export function analyzeTokenTrend(numCtx: number): TrendAnalysis {
+  if (_tokenUsageTrend.length < 3) {
+    return {
+      trend: 'stable',
+      avgGrowthRate: 0,
+      projectedOverflow: -1,
+      recommendedAction: '数据不足，暂不推荐操作',
+      confidence: 0,
+    };
+  }
+  
+  const points = _tokenUsageTrend;
+  const n = points.length;
+  
+  // 计算平均增长率
+  let totalGrowth = 0;
+  let growthCount = 0;
+  for (let i = 1; i < n; i++) {
+    const growth = points[i].tokens - points[i - 1].tokens;
+    totalGrowth += growth;
+    growthCount++;
+  }
+  const avgGrowthRate = growthCount > 0 ? totalGrowth / growthCount : 0;
+  
+  // 线性回归确定趋势
+  const xs = points.map(p => p.turn);
+  const ys = points.map(p => p.tokens);
+  const xMean = xs.reduce((s, x) => s + x, 0) / n;
+  const yMean = ys.reduce((s, y) => s + y, 0) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (xs[i] - xMean) * (ys[i] - yMean);
+    den += (xs[i] - xMean) ** 2;
+  }
+  const slope = den !== 0 ? num / den : 0;
+  
+  // 判断趋势
+  let trend: TrendAnalysis['trend'];
+  if (slope > 100) trend = 'increasing';
+  else if (slope < -50) trend = 'decreasing';
+  else trend = 'stable';
+  
+  // 预测溢出
+  let projectedOverflow = -1;
+  if (slope > 0) {
+    const currentTokens = points[n - 1].tokens;
+    const remaining = numCtx - currentTokens;
+    projectedOverflow = Math.ceil(remaining / slope);
+    if (projectedOverflow < 0) projectedOverflow = 0;
+  }
+  
+  // 推荐操作
+  let recommendedAction = '';
+  if (trend === 'increasing' && projectedOverflow >= 0 && projectedOverflow <= 5) {
+    recommendedAction = `⚠️ 预计 ${projectedOverflow} 轮后上下文溢出，建议立即压缩`;
+  } else if (trend === 'increasing' && projectedOverflow > 5 && projectedOverflow <= 10) {
+    recommendedAction = `建议在接下来 2-3 轮内进行压缩（${projectedOverflow} 轮后溢出）`;
+  } else if (trend === 'stable') {
+    recommendedAction = 'Token 使用趋势稳定，无需额外操作';
+  } else if (trend === 'decreasing') {
+    recommendedAction = 'Token 使用量在下降，压缩策略生效';
+  }
+  
+  // 置信度：基于数据点数量和趋势一致性
+  let confidence = Math.min(1, n / 10);
+  if (trend === 'stable') confidence *= 0.7;
+  
+  return {
+    trend,
+    avgGrowthRate: Math.round(avgGrowthRate),
+    projectedOverflow,
+    recommendedAction,
+    confidence,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R123: 会话摘要持久化 — 跨会话引用
+// ═══════════════════════════════════════════════════════════════
+
+export interface SessionSummary {
+  id: string;
+  createdAt: number;
+  goal: string;
+  summary: string;
+  toolsUsed: string[];
+  keyFindings: string[];
+  tokenUsage: number;
+}
+
+const SESSION_SUMMARY_KEY = 'metona_session_summaries';
+const MAX_SESSION_SUMMARIES = 10;
+
+/** R123: 保存会话摘要到 localStorage */
+export function saveSessionSummary(summary: SessionSummary): void {
+  try {
+    const existing = loadSessionSummaries();
+    existing.unshift(summary);
+    if (existing.length > MAX_SESSION_SUMMARIES) {
+      existing.length = MAX_SESSION_SUMMARIES;
+    }
+    localStorage.setItem(SESSION_SUMMARY_KEY, JSON.stringify(existing));
+    logInfo(`R123: 会话摘要已保存 (${summary.id})`);
+  } catch (err) {
+    logWarn(`R123: 保存会话摘要失败: ${(err as Error).message}`);
+  }
+}
+
+/** R123: 加载所有会话摘要 */
+export function loadSessionSummaries(): SessionSummary[] {
+  try {
+    const raw = localStorage.getItem(SESSION_SUMMARY_KEY);
+    if (!raw) return [];
+    return JSON.parse(raw) as SessionSummary[];
+  } catch {
+    return [];
+  }
+}
+
+/** R123: 生成当前会话摘要 */
+export function generateSessionSummary(
+  goal: string,
+  messages: OllamaMessage[],
+  toolRecords: Array<{ name: string }>,
+  totalTokens: number
+): SessionSummary {
+  const toolsUsed = [...new Set(toolRecords.map(t => t.name))];
+  const assistantMessages = messages.filter(m => m.role === 'assistant');
+  const lastAssistant = assistantMessages[assistantMessages.length - 1];
+  
+  return {
+    id: `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    createdAt: Date.now(),
+    goal: goal.slice(0, 200),
+    summary: (lastAssistant?.content || '').slice(0, 500),
+    toolsUsed,
+    keyFindings: [],
+    tokenUsage: totalTokens,
+  };
+}
+
+/** R123: 格式化历史会话摘要供注入 */
+export function formatSessionSummariesForContext(summaries: SessionSummary[]): string {
+  if (summaries.length === 0) return '';
+  const lines = ['[历史会话参考]', ''];
+  for (const s of summaries.slice(0, 3)) {
+    const date = new Date(s.createdAt).toLocaleDateString();
+    lines.push(`- ${date}: 目标="${s.goal.slice(0, 60)}..." | 工具=[${s.toolsUsed.join(', ')}] | 结果=${s.summary.slice(0, 100)}...`);
+  }
+  return lines.join('\n');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R125: Agent 状态检查点 — 保存和恢复 Agent 状态
+// ═══════════════════════════════════════════════════════════════
+
+export interface AgentCheckpoint {
+  id: string;
+  timestamp: number;
+  loopCount: number;
+  state: string;
+  messagesSnapshot: OllamaMessage[];
+  toolRecordsCount: number;
+  goal: string;
+}
+
+const _checkpoints: AgentCheckpoint[] = [];
+const MAX_CHECKPOINTS = 5;
+
+/** R125: 创建状态检查点 */
+export function createCheckpoint(
+  loopCount: number,
+  agentState: string,
+  messages: OllamaMessage[],
+  toolRecordsCount: number,
+  goal: string
+): AgentCheckpoint {
+  const checkpoint: AgentCheckpoint = {
+    id: `cp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    timestamp: Date.now(),
+    loopCount,
+    state: agentState,
+    messagesSnapshot: messages.map(m => ({ ...m })),
+    toolRecordsCount,
+    goal,
+  };
+  
+  _checkpoints.push(checkpoint);
+  if (_checkpoints.length > MAX_CHECKPOINTS) {
+    _checkpoints.shift();
+  }
+  
+  logInfo(`R125: 检查点已创建 (loop=${loopCount}, state=${agentState})`);
+  return checkpoint;
+}
+
+/** R125: 获取最近的检查点 */
+export function getLatestCheckpoint(): AgentCheckpoint | null {
+  return _checkpoints.length > 0 ? _checkpoints[_checkpoints.length - 1] : null;
+}
+
+/** R125: 恢复到指定检查点 */
+export function restoreCheckpoint(id: string): AgentCheckpoint | null {
+  const cp = _checkpoints.find(c => c.id === id);
+  if (!cp) {
+    logWarn(`R125: 检查点 ${id} 不存在`);
+    return null;
+  }
+  logInfo(`R125: 恢复到检查点 ${id} (loop=${cp.loopCount})`);
+  return cp;
+}
+
+/** R125: 获取所有检查点 */
+export function getAllCheckpoints(): AgentCheckpoint[] {
+  return [..._checkpoints];
+}
+
+/** R125: 清除所有检查点 */
+export function clearCheckpoints(): void {
+  _checkpoints.length = 0;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// R126: 上下文预算分配 — 按消息类型分配上下文 token 预算
+// ═══════════════════════════════════════════════════════════════
+
+export interface ContextBudgetAllocation {
+  system: number;    // 系统消息预算
+  user: number;      // 用户消息预算
+  assistant: number; // 助手消息预算
+  tool: number;      // 工具结果预算
+  memory: number;    // 记忆注入预算
+  total: number;     // 总预算
+}
+
+/** R126: 默认预算分配比例 */
+const DEFAULT_BUDGET_RATIOS = {
+  system: 0.05,    // 5%
+  user: 0.15,      // 15%
+  assistant: 0.25, // 25%
+  tool: 0.45,      // 45%
+  memory: 0.10,    // 10%
+};
+
+/** R126: 根据消息分布动态调整预算分配 */
+export function allocateContextBudget(
+  messages: OllamaMessage[],
+  numCtx: number
+): ContextBudgetAllocation {
+  const total = numCtx;
+  
+  // 统计各类型消息当前占比
+  const counts = { system: 0, user: 0, assistant: 0, tool: 0 };
+  let memorySize = 0;
+  
+  for (const msg of messages) {
+    if (msg.role in counts) {
+      counts[msg.role as keyof typeof counts]++;
+    }
+    if (msg.content?.includes('[记忆注入]')) {
+      memorySize += estimateTokens(msg.content);
+    }
+  }
+  
+  const totalMsgs = messages.length || 1;
+  
+  // 动态调整：如果工具结果占比过高，增加工具预算
+  const toolRatio = counts.tool / totalMsgs;
+  const ratios = { ...DEFAULT_BUDGET_RATIOS };
+  
+  if (toolRatio > 0.5) {
+    // 工具结果过多，从助手预算中转移一部分给工具
+    const shift = Math.min(0.1, (toolRatio - 0.5) * 0.3);
+    ratios.assistant -= shift;
+    ratios.tool += shift;
+  }
+  
+  // 如果记忆注入很大，增加记忆预算
+  if (memorySize > numCtx * 0.1) {
+    const shift = Math.min(0.05, (memorySize / numCtx - 0.1) * 0.2);
+    ratios.tool -= shift;
+    ratios.memory += shift;
+  }
+  
+  return {
+    system: Math.floor(total * ratios.system),
+    user: Math.floor(total * ratios.user),
+    assistant: Math.floor(total * ratios.assistant),
+    tool: Math.floor(total * ratios.tool),
+    memory: Math.floor(total * ratios.memory),
+    total,
+  };
+}
+
+/** R126: 检查消息是否超出预算 */
+export function checkBudgetOverflow(
+  messages: OllamaMessage[],
+  budget: ContextBudgetAllocation
+): { role: string; current: number; budget: number; overflow: number }[] {
+  const tokensByRole: Record<string, number> = {};
+  for (const msg of messages) {
+    tokensByRole[msg.role] = (tokensByRole[msg.role] || 0) + estimateTokens(msg.content || '');
+  }
+  
+  const overflows: { role: string; current: number; budget: number; overflow: number }[] = [];
+  const budgetMap: Record<string, number> = {
+    system: budget.system,
+    user: budget.user,
+    assistant: budget.assistant,
+    tool: budget.tool,
+  };
+  
+  for (const [role, current] of Object.entries(tokensByRole)) {
+    const bud = budgetMap[role] || Infinity;
+    if (current > bud) {
+      overflows.push({ role, current, budget: bud, overflow: current - bud });
+    }
+  }
+  
+  return overflows;
+}
diff --git a/src/renderer/services/memory-service.ts b/src/renderer/services/memory-service.ts
index a9657b5..8c564cc 100644
--- a/src/renderer/services/memory-service.ts
+++ b/src/renderer/services/memory-service.ts
@@ -41,6 +41,9 @@ export interface MemoryEntry {
   content: string;
   importance: number;  // 1-10
   tags: string[];
+  // R106: 访问追踪 — 用于 TTL 衰减时的保留策略
+  lastAccessed?: number;  // 最后访问时间（毫秒时间戳）
+  accessCount?: number;     // 访问次数
 }
 
 export interface MemorySearchResult extends MemoryEntry {
@@ -283,8 +286,54 @@ export function serializeMemoryMd(entries: MemoryEntry[]): string {
 // 搜索
 // ═══════════════════════════════════════════════════════════════
 
+/**
+ * R101: 计算词项的 IDF（逆文档频率）权重
+ * 在所有记忆条目中出现频率越低的词，IDF 越高
+ */
+function computeIDF(entries: MemoryEntry[], words: string[]): Map<string, number> {
+  const idfMap = new Map<string, number>();
+  const N = entries.length;
+  if (N === 0) return idfMap;
+
+  for (const word of words) {
+    let docFreq = 0;
+    for (const entry of entries) {
+      if (entry.content.toLowerCase().includes(word)) docFreq++;
+    }
+    // IDF = log(N / (df + 1))，加 1 防止除零
+    const idf = Math.log((N + 1) / (docFreq + 1)) + 1;
+    idfMap.set(word, idf);
+  }
+  return idfMap;
+}
+
+/**
+ * R101: 模糊匹配 — 检查两个短字符串的编辑距离是否在阈值内
+ * 仅对长度 <= 10 的短词使用，避免性能开销
+ */
+function fuzzyMatch(a: string, b: string, maxDistance: number): boolean {
+  if (a === b) return true;
+  if (Math.abs(a.length - b.length) > maxDistance) return false;
+  // 简化编辑距离（Levenshtein）
+  const matrix: number[][] = [];
+  for (let i = 0; i <= a.length; i++) matrix[i] = [i];
+  for (let j = 0; j <= b.length; j++) matrix[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost,
+      );
+    }
+  }
+  return matrix[a.length][b.length] <= maxDistance;
+}
+
 /**
  * 关键词搜索记忆
+ * R101: 增强 — IDF 权重 + 模糊匹配 + 多词短语奖励
  */
 export function searchMemory(entries: MemoryEntry[], query: string, limit = 0): MemorySearchResult[] {
   if (!query || entries.length === 0) return [];
@@ -292,6 +341,9 @@ export function searchMemory(entries: MemoryEntry[], query: string, limit = 0):
   const queryLower = query.toLowerCase();
   const queryWords = queryLower.split(/[\s,，。！？、；：""''（）\[\]{}<>`~@#$%^&*+=|\\/.]+/).filter(w => w.length > 1);
 
+  // R101: 预计算 IDF 权重
+  const idfMap = computeIDF(entries, queryWords);
+
   // rule 和 preference 类型的记忆全局生效，始终注入
   // M5: 限制全局注入数量，避免大量 rule/preference 膨胀搜索结果
   const MAX_GLOBAL_INJECT = 10;
@@ -310,28 +362,70 @@ export function searchMemory(entries: MemoryEntry[], query: string, limit = 0):
     const contentLower = entry.content.toLowerCase();
     const tagsLower = entry.tags.map(t => t.toLowerCase());
 
+    // 精确匹配查询字符串
     if (contentLower.includes(queryLower)) score += 50;
+
+    // R101: 多词短语连续匹配奖励
+    if (queryWords.length >= 2 && contentLower.includes(queryWords.join(' '))) {
+      score += 25;
+    }
+
     for (const tag of tagsLower) {
       if (queryLower.includes(tag) || tag.includes(queryLower)) score += 30;
       for (const word of queryWords) {
-        if (tag.includes(word)) score += 15;
+        if (tag.includes(word)) {
+          // R101: 使用 IDF 权重
+          score += 15 * (idfMap.get(word) || 1);
+        }
+        // R101: 对短词进行模糊匹配
+        if (word.length <= 10 && tag.length <= 15 && fuzzyMatch(word, tag, 1)) {
+          score += 8;
+        }
       }
     }
     for (const word of queryWords) {
-      if (contentLower.includes(word)) score += 10;
+      if (contentLower.includes(word)) {
+        // R101: 使用 IDF 权重
+        score += 10 * (idfMap.get(word) || 1);
+      }
+      // R101: 对短词进行模糊匹配
+      if (word.length <= 10) {
+        // 检查内容中是否有编辑距离为 1 的近似词
+        const words = contentLower.split(/\s+/);
+        for (const cw of words) {
+          if (cw.length <= 12 && fuzzyMatch(word, cw, 1)) {
+            score += 5;
+            break; // 每个查询词只奖励一次
+          }
+        }
+      }
     }
 
     score *= (0.5 + entry.importance / 20);
-    if (score > 0) scored.push({ ...entry, score });
+    if (score > 0) scored.push({ ...entry, score: Math.round(score) });
   }
 
   // 去重 + 排序
   const seen = new Set<string>();
   const merged: MemorySearchResult[] = [];
+  const accessedIds: string[] = []; // R106: 需要记录访问的 ID
+
   for (const item of [...alwaysInclude, ...scored.sort((a, b) => b.score - a.score)]) {
     if (!seen.has(item.id)) {
       seen.add(item.id);
       merged.push(item);
+      // R106: 记录访问（但不持久化，只影响本次搜索后的衰减判断）
+      accessedIds.push(item.id);
+    }
+  }
+
+  // R106: 更新原始 entries 中的访问追踪（影响未来的 TTL 衰减）
+  // 注意：这不会立即持久化，在 writeMemoryFile 时才生效
+  for (const id of accessedIds) {
+    const entry = entries.find(e => e.id === id);
+    if (entry) {
+      entry.lastAccessed = Date.now();
+      entry.accessCount = (entry.accessCount || 0) + 1;
     }
   }
 
@@ -443,6 +537,8 @@ export async function loadAllEntries(): Promise<MemoryEntry[]> {
 /** 搜索记忆（读取 MEMORY.md → 解析 → 搜索） */
 export async function search(query: string, limit = 0): Promise<MemorySearchResult[]> {
   try {
+    // R57: 触发 TTL 衰减检查（带节流，不会每次搜索都执行）
+    maybeRunTTLDecay().catch(() => {}); // 非阻塞，失败不影响搜索
     const entries = await loadAllEntries();
     return searchMemory(entries, query, limit);
   } catch (err) {
@@ -812,6 +908,137 @@ function autoCleanEntries(entries: MemoryEntry[]): MemoryEntry[] {
   return entries.filter(e => !evictIds.has(e.id));
 }
 
+// ═══════════════════════════════════════════════════════════════
+// R57: 记忆 TTL 衰减 — 基于时间的自动重要性衰减
+// ═══════════════════════════════════════════════════════════════
+
+/** R57: 上次 TTL 衰减执行时间（避免每次搜索都触发文件写入） */
+let _lastTTLDecayTime = 0;
+const TTL_DECAY_INTERVAL = 6 * 3600 * 1000; // 每 6 小时最多执行一次衰减
+
+/** R57: 从记忆 ID 中提取创建日期 */
+function extractDateFromId(id: string): number {
+  const m = id.match(/mem_(\d{4})(\d{2})(\d{2})_/);
+  if (m) {
+    return new Date(parseInt(m[1]), parseInt(m[2]) - 1, parseInt(m[3])).getTime();
+  }
+  return Date.now(); // 无法解析时视为刚创建
+}
+
+/**
+ * R106: 记录条目访问 — 增强访问频率追踪用于 TTL 衰减时的保留策略
+ * 在搜索匹配、检索时调用
+ */
+export function recordMemoryAccess(entryId: string, entries: MemoryEntry[]): void {
+  const entry = entries.find(e => e.id === entryId);
+  if (entry) {
+    entry.lastAccessed = Date.now();
+    entry.accessCount = (entry.accessCount || 0) + 1;
+  }
+}
+
+/**
+ * R57: 对记忆条目应用 TTL 衰减
+ * 
+ * 衰减规则：
+ * - rule 类型：完全免疫衰减（永久规则）
+ * - preference 类型：轻微衰减（用户偏好通常长期有效）
+ * - fact 类型：按年龄衰减，低重要性的旧事实优先遗忘
+ * - importance 已经 ≤ 2 的 fact 且超过 60 天：自动移除
+ * - R106: 访问频率作为保留因素（最近访问或高频访问的条目优先保留）
+ * 
+ * @param entries 当前所有记忆条目
+ * @returns { decayed: MemoryEntry[], removed: number, changed: boolean }
+ */
+export function applyTTLDecay(entries: MemoryEntry[]): { decayed: MemoryEntry[]; removed: number; changed: boolean } {
+  const now = Date.now();
+  const ONE_DAY = 24 * 3600 * 1000;
+  const removed: string[] = [];
+  let changed = false;
+
+  const decayed = entries.filter(entry => {
+    const createdAt = extractDateFromId(entry.id);
+    const ageDays = (now - createdAt) / ONE_DAY;
+    const lastAccessed = entry.lastAccessed || createdAt;
+    const accessCount = entry.accessCount || 0;
+    const daysSinceAccess = (now - lastAccessed) / ONE_DAY;
+
+    // R106: 访问频率保护 — 最近 30 天内有访问或访问次数 >= 3 的条目优先保留
+    const accessProtected = daysSinceAccess < 30 || accessCount >= 3;
+
+    // rule 类型永久保留
+    if (entry.type === 'rule') return true;
+
+    // preference 类型：90 天以上且 importance ≤ 3 才移除（访问频率可豁免）
+    if (entry.type === 'preference') {
+      if (ageDays > 90 && entry.importance <= 3 && !accessProtected) {
+        removed.push(entry.id);
+        changed = true;
+        return false;
+      }
+      return true;
+    }
+
+    // fact 类型：按年龄和重要性衰减
+    // 衰减公式：每 30 天 importance - 1（仅对 importance < 8 的条目）
+    if (entry.type === 'fact') {
+      // R106: 访问频率保护 — 最近访问过的不易删除
+      if (accessProtected && ageDays < 120) {
+        // 120 天内访问过的 fact 豁免删除
+        return true;
+      }
+      
+      // 超过 60 天且 importance ≤ 2 → 自动移除
+      if (ageDays > 60 && entry.importance <= 2 && !accessProtected) {
+        removed.push(entry.id);
+        changed = true;
+        return false;
+      }
+      // 超过 90 天且 importance ≤ 4 → 自动移除
+      if (ageDays > 90 && entry.importance <= 4 && !accessProtected) {
+        removed.push(entry.id);
+        changed = true;
+        return false;
+      }
+      // 高重要性的 fact 永久保留
+      if (entry.importance >= 8) return true;
+      return true;
+    }
+
+    return true;
+  });
+
+  if (removed.length > 0) {
+    logMemory('TTL 衰减', `自动移除 ${removed.length} 条过期记忆（fact/preference 类型，低重要性+超龄）`);
+  }
+
+  return { decayed, removed: removed.length, changed };
+}
+
+/**
+ * R57: 执行 TTL 衰减并持久化（带节流保护）
+ * 在搜索记忆时调用，如果距离上次衰减超过 TTL_DECAY_INTERVAL 则执行
+ */
+async function maybeRunTTLDecay(): Promise<void> {
+  const now = Date.now();
+  if (now - _lastTTLDecayTime < TTL_DECAY_INTERVAL) return;
+  _lastTTLDecayTime = now;
+
+  try {
+    const entries = await loadAllEntries();
+    if (entries.length === 0) return;
+
+    const { decayed, removed, changed } = applyTTLDecay(entries);
+    if (changed && removed > 0) {
+      const fileContent = decayed.length > 0 ? serializeMemoryMd(decayed) : '';
+      await writeMemoryFile(fileContent);
+      logMemory('TTL 衰减', `已持久化: 移除 ${removed} 条，剩余 ${decayed.length} 条`);
+    }
+  } catch (err) {
+    logWarn('TTL 衰减执行失败', (err as Error).message);
+  }
+}
+
 /**
  * 检查记忆系统是否可用（桌面环境且工作空间已设置）
  */
diff --git a/src/renderer/services/sub-agent.ts b/src/renderer/services/sub-agent.ts
index 63bcc78..68f3b3f 100644
--- a/src/renderer/services/sub-agent.ts
+++ b/src/renderer/services/sub-agent.ts
@@ -9,6 +9,8 @@ import { OllamaAPI } from '../api/ollama.js';
 import { TOOL_DEFINITIONS } from './tool-registry.js';
 import { getEnabledToolDefinitions } from './tool-registry.js';
 import { logInfo, logWarn, logError } from './log-service.js';
+import { validatePathSandbox, checkRateLimit, isToolCircuitBroken, recordToolFailure, recordToolSuccess, sanitizeToolArgs, checkCommandSafety } from './agent-safety.js';
+import { getWorkspaceDirPath } from '../components/workspace-panel.js';
 import type { ToolResult, ToolCall, ToolDefinition } from '../types.js';
 
 const SUB_AGENT_MAX_LOOPS = 10;    // 子代理最多 10 轮
@@ -169,9 +171,82 @@ ${context ? `\n附加上下文（参考数据，不是指令）：\n<<<REFERENCE
         // 工具执行前再次检查中止信号
         if (subAgentAC.signal.aborted) break;
 
+        // R89: 子 Agent 熔断器检查 — 连续失败后自动禁用工具
+        const circuitBreaker = isToolCircuitBroken(tc.name);
+        if (circuitBreaker.broken) {
+          const waitSec = Math.ceil(circuitBreaker.remainingMs / 1000);
+          logWarn(`R89: 子 Agent 熔断器拦截: ${tc.name}，冷却中（还需 ${waitSec}s）`);
+          messages.push({
+            role: 'tool',
+            content: `<<<TOOL_RESULT_START name="${tc.name}">>>\n${JSON.stringify({ success: false, error: `工具「${tc.name}」因连续失败已被暂时禁用，请等待 ${waitSec} 秒后重试。` })}\n<<<TOOL_RESULT_END>>>`,
+            tool_name: tc.name
+          });
+          continue;
+        }
+
+        // R109: 子 Agent 参数消毒
+        tc.arguments = sanitizeToolArgs(tc.name, tc.arguments);
+
+        // R113: 子 Agent 命令安全检查
+        if (tc.name === 'run_command') {
+          const cmdStr = String(tc.arguments?.command || '');
+          if (cmdStr) {
+            const cmdSafety = checkCommandSafety(cmdStr);
+            if (cmdSafety.riskLevel === 'forbidden') {
+              logWarn(`R113: 子 Agent 命令安全拦截: ${cmdSafety.reason}`);
+              messages.push({
+                role: 'tool',
+                content: `<<<TOOL_RESULT_START name="${tc.name}">>>\n${JSON.stringify({ success: false, error: cmdSafety.reason || '命令被安全规则拦截' })}\n<<<TOOL_RESULT_END>>>`,
+                tool_name: tc.name
+              });
+              continue;
+            }
+          }
+        }
+
+        // R82: 子 Agent 速率限制 — 防止子代理快速连续调用同一工具
+        const rateLimit = checkRateLimit(tc.name);
+        if (!rateLimit.allowed) {
+          const waitSec = Math.ceil(rateLimit.retryAfterMs / 1000);
+          logWarn(`R82: 子 Agent 速率限制: ${tc.name}，等待 ${waitSec}s`);
+          messages.push({
+            role: 'tool',
+            content: `<<<TOOL_RESULT_START name="${tc.name}">>>\n${JSON.stringify({ success: false, error: `调用频率过高，等待 ${waitSec}s` })}\n<<<TOOL_RESULT_END>>>`,
+            tool_name: tc.name
+          });
+          continue;
+        }
+
+        // R81: 子 Agent 路径沙箱 — 确保文件操作不超出工作空间
+        const SUB_FILE_TOOLS = new Set(['read_file', 'list_directory', 'search_files', 'web_fetch']);
+        if (SUB_FILE_TOOLS.has(tc.name)) {
+          const wsDir = getWorkspaceDirPath();
+          if (wsDir) {
+            const pathArg = String(tc.arguments?.path || '');
+            if (pathArg) {
+              const sandbox = validatePathSandbox(pathArg, wsDir);
+              if (!sandbox.valid) {
+                logWarn(`R81: 子 Agent 路径沙箱拦截: ${tc.name}(${pathArg}) — ${sandbox.reason}`);
+                messages.push({
+                  role: 'tool',
+                  content: `<<<TOOL_RESULT_START name="${tc.name}">>>\n${JSON.stringify({ success: false, error: sandbox.reason || '路径不在工作空间范围内' })}\n<<<TOOL_RESULT_END>>>`,
+                  tool_name: tc.name
+                });
+                continue;
+              }
+            }
+          }
+        }
+
         try {
           const { executeTool } = await import('./tool-registry.js');
           const result = await executeTool(tc.name, tc.arguments);
+          // R89: 记录工具成功/失败到熔断器
+          if (result.success) {
+            recordToolSuccess(tc.name);
+          } else {
+            recordToolFailure(tc.name);
+          }
           const resultStr = formatResult(tc.name, result);
           messages.push({
             role: 'tool',
diff --git a/src/renderer/services/tool-registry.ts b/src/renderer/services/tool-registry.ts
index 0dbb44e..22fbdf1 100644
--- a/src/renderer/services/tool-registry.ts
+++ b/src/renderer/services/tool-registry.ts
@@ -754,6 +754,91 @@ export function getEnabledToolDefinitions(): ToolDefinition[] {
   return [...builtIn, ..._mcpToolCache];
 }
 
+// R55: 语义工具检索 — 根据用户查询过滤相关工具，减少上下文占用
+
+/** 核心工具集 — 始终包含的关键工具 */
+const CORE_TOOLS = new Set([
+  'read_file', 'write_file', 'list_directory', 'search_files', 'edit_file',
+  'run_command', 'web_search', 'web_fetch', 'memory', 'git',
+]);
+
+/** 工具关键词映射 — 用于语义匹配 */
+const TOOL_KEYWORDS: Record<string, string[]> = {
+  read_file: ['read', 'file', '读取', '文件', '看', '查看', '内容'],
+  write_file: ['write', 'file', '写入', '保存', '创建文件', '输出'],
+  list_directory: ['list', 'directory', '目录', '文件夹', '列'],
+  search_files: ['search', 'find', '搜索', '查找', 'grep', 'find'],
+  create_directory: ['create', 'directory', 'mkdir', '创建目录', '新建'],
+  delete_file: ['delete', 'remove', '删除', 'rm', '移除'],
+  run_command: ['run', 'command', 'shell', '执行', '命令', '终端'],
+  move_file: ['move', 'rename', '移动', '重命名', 'mv'],
+  copy_file: ['copy', '复制', 'cp'],
+  web_fetch: ['fetch', 'url', '网页', '抓取', '获取'],
+  web_search: ['search', 'web', '搜索', '联网', '查', 'google', 'bing'],
+  edit_file: ['edit', 'replace', '编辑', '替换', '修改'],
+  get_file_info: ['info', 'stat', '信息', '属性', '详情'],
+  tree: ['tree', '结构', '树', '目录结构'],
+  download_file: ['download', '下载'],
+  diff_files: ['diff', 'compare', '对比', '差异'],
+  replace_in_files: ['replace', 'batch', '批量替换'],
+  read_multiple_files: ['read', 'multiple', '批量读取'],
+  git: ['git', 'commit', 'push', 'pull', 'branch', '仓库'],
+  compress: ['compress', 'zip', 'tar', '压缩', '解压', 'extract'],
+  memory: ['memory', '记忆', 'remember', 'save', 'rule', '规则'],
+  session_list: ['session', 'history', '会话', '历史'],
+  session_read: ['session', 'read', '读取会话'],
+  spawn_task: ['sub', 'agent', 'delegate', '子代理', '委派'],
+  plan_track: ['plan', 'track', '计划', '进度'],
+  browser_open: ['browser', 'open', '浏览器', '打开网页'],
+  browser_screenshot: ['screenshot', '截图', '屏幕'],
+  browser_evaluate: ['evaluate', 'javascript', 'js', '执行JS'],
+  browser_extract: ['extract', '提取', '内容'],
+  browser_click: ['click', '点击'],
+  browser_type: ['type', 'input', '输入'],
+  browser_scroll: ['scroll', '滚动'],
+  browser_wait: ['wait', '等待'],
+  browser_close: ['close', '关闭浏览器'],
+  datetime: ['time', 'date', '时间', '日期'],
+  calculator: ['calculate', 'math', '计算', '算'],
+  random: ['random', '随机'],
+  uuid: ['uuid', 'guid', '唯一'],
+  json_format: ['json', 'format', '格式化'],
+  hash: ['hash', 'sha', 'md5', '哈希'],
+};
+
+/** R55: 根据用户查询语义过滤工具定义，减少 token 占用 */
+export function getRelevantToolDefinitions(userQuery: string): ToolDefinition[] {
+  const allTools = getEnabledToolDefinitions();
+  // 查询为空或很短时返回全部
+  if (!userQuery || userQuery.length < 5) return allTools;
+
+  const queryLower = userQuery.toLowerCase();
+  const relevantTools = new Set<string>();
+
+  // 核心工具始终包含
+  for (const t of CORE_TOOLS) relevantTools.add(t);
+
+  // 语义匹配
+  for (const [toolName, keywords] of Object.entries(TOOL_KEYWORDS)) {
+    if (relevantTools.has(toolName)) continue;
+    for (const kw of keywords) {
+      if (queryLower.includes(kw.toLowerCase())) {
+        relevantTools.add(toolName);
+        break;
+      }
+    }
+  }
+
+  // 如果匹配到的工具太少，返回全部（避免遗漏）
+  if (relevantTools.size < 8) return allTools;
+
+  const filtered = allTools.filter(t => relevantTools.has(t.function.name));
+  // 确保不过度过滤 — 至少保留 60% 的工具
+  if (filtered.length < allTools.length * 0.6) return allTools;
+
+  return filtered;
+}
+
 /** MCP 工具缓存 */
 let _mcpToolCache: ToolDefinition[] = [];