diff --git a/README.md b/README.md
index 241375c..b39f78a 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/version-v0.14.15-E8734A?style=flat-square" alt="version">
+  <img src="https://img.shields.io/badge/version-v0.15.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.14.15.exe`
+产出：`release/Metona Ollama Setup v0.15.0.exe`
 
 ## 🛠️ 常用命令
 
@@ -501,7 +501,7 @@ npm start
 ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/ npm run dist
 ```
 
-Output: `release/Metona Ollama Setup v0.14.15.exe`
+Output: `release/Metona Ollama Setup v0.15.0.exe`
 
 ## 🛠️ Common Commands
 
diff --git a/package-lock.json b/package-lock.json
index b1db451..bcba397 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "metona-ollama-desktop",
-  "version": "0.14.15",
+  "version": "0.15.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "metona-ollama-desktop",
-      "version": "0.14.15",
+      "version": "0.15.0",
       "license": "MIT",
       "dependencies": {
         "ffmpeg-static": "^5.2.0",
diff --git a/package.json b/package.json
index ee07d88..b9f987f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "metona-ollama-desktop",
-  "version": "0.14.15",
+  "version": "0.15.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 1c8922f..3175bc8 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.14.15',
+              message: 'Metona Ollama Desktop v0.15.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 f356f1c..58453eb 100644
--- a/src/renderer/components/chat-area.ts
+++ b/src/renderer/components/chat-area.ts
@@ -112,20 +112,22 @@ export function resetAutoScroll(): void {
 /** P1-1: 已渲染消息索引集合，用于稳定增量 diff（替代 DOM querySelectorAll 计数） */
 const _renderedMsgIndices = new Set<number>();
 
+/** R31: 最大渲染消息数（超过此数时仅渲染最近的消息，避免 DOM 过载） */
+const MAX_RENDERED_MESSAGES = 200;
+
 /** 标记当前渲染批次中系统提示词卡片是否已渲染（每会话仅首条 assistant 消息展示） */
 let _sysPromptRendered = false;
 
+/** R31: 增量渲染 — 仅追加新消息，避免全量重建 */
 export function renderMessages(): void {
   const currentSession = state.get<ChatSession | null>(KEYS.CURRENT_SESSION);
   const msgs = currentSession ? currentSession.messages : [];
 
-  // 全量清空重建，避免增量 diff 的边界 bug
-  messagesContainerEl.innerHTML = '';
-  currentPlaceholder = null;
-  _renderedMsgIndices.clear();
-  _sysPromptRendered = false; // 重置：每轮全量渲染时重新判定首条 assistant
-
   if (msgs.length === 0) {
+    messagesContainerEl.innerHTML = '';
+    currentPlaceholder = null;
+    _renderedMsgIndices.clear();
+    _sysPromptRendered = false;
     emptyStateEl.style.display = '';
     messagesContainerEl.style.display = 'none';
     return;
@@ -134,16 +136,52 @@ export function renderMessages(): void {
   emptyStateEl.style.display = 'none';
   messagesContainerEl.style.display = '';
 
-  for (let i = 0; i < msgs.length; i++) {
-    const msg = msgs[i];
-    // 跳过 system 消息（Plan Mode 进度等内部状态消息不展示给用户）
-    if (msg.role === 'system') continue;
-    // 只跳过既无内容也无 think 也无工具的空消息
-    if (msg.role === 'assistant' && !msg.content && !msg.think && (!msg.toolCalls || msg.toolCalls.length === 0)) continue;
-    appendMessageDOM(msgs[i], i);
-    _renderedMsgIndices.add(i);
+  // R31: 增量渲染 — 检查是否需要全量重建
+  const needsFullRebuild = _renderedMsgIndices.size === 0
+    || _renderedMsgIndices.size > msgs.length
+    || Array.from(_renderedMsgIndices).some(idx => idx >= msgs.length);
+
+  if (needsFullRebuild) {
+    // 全量重建（首次加载或消息被截断/压缩后）
+    messagesContainerEl.innerHTML = '';
+    currentPlaceholder = null;
+    _renderedMsgIndices.clear();
+    _sysPromptRendered = false;
+
+    // R31: 仅渲染最近 MAX_RENDERED_MESSAGES 条消息，避免 DOM 过载
+    const startIdx = Math.max(0, msgs.length - MAX_RENDERED_MESSAGES);
+    if (startIdx > 0) {
+      const noticeDiv = document.createElement('div');
+      noticeDiv.className = 'msg-truncated-notice';
+      noticeDiv.style.cssText = 'text-align:center;padding:8px;font-size:12px;color:var(--text-muted);';
+      noticeDiv.textContent = `⋯ 已折叠前 ${startIdx} 条消息，仅显示最近 ${MAX_RENDERED_MESSAGES} 条 ⋯`;
+      messagesContainerEl.appendChild(noticeDiv);
+    }
+
+    for (let i = startIdx; i < msgs.length; i++) {
+      const msg = msgs[i];
+      if (msg.role === 'system') continue;
+      if (msg.role === 'assistant' && !msg.content && !msg.think && (!msg.toolCalls || msg.toolCalls.length === 0)) continue;
+      appendMessageDOM(msgs[i], i);
+      _renderedMsgIndices.add(i);
+    }
+  } else {
+    // R31: 增量追加 — 只渲染新增的消息
+    for (let i = 0; i < msgs.length; i++) {
+      if (_renderedMsgIndices.has(i)) continue;
+      const msg = msgs[i];
+      if (msg.role === 'system') continue;
+      if (msg.role === 'assistant' && !msg.content && !msg.think && (!msg.toolCalls || msg.toolCalls.length === 0)) continue;
+      appendMessageDOM(msgs[i], i);
+      _renderedMsgIndices.add(i);
+    }
   }
 
+  // R38: 为代码块添加复制按钮
+  addCodeBlockCopyButtons();
+  // R40: 为消息添加操作按钮
+  addMessageActions();
+
   scrollToBottom();
 }
 
@@ -353,6 +391,8 @@ export function updateLastAssistantMessage(
     // P0-1: 流式期间纯文本追加（避免每 chunk 全量 Markdown + DOMPurify），最终渲染时才做 Markdown
     if (isFinal) {
       contentDiv.innerHTML = safeMarkdown(safeContent);
+      // R38: 最终渲染后为代码块添加复制按钮
+      addCodeBlockCopyButtons(contentDiv);
     } else {
       contentDiv.textContent = safeContent;
     }
@@ -459,21 +499,53 @@ export function updateToolCallCardInPlaceholder(tc: ToolCallRecord): void {
 export function appendAssistantPlaceholder(): void {
   const div = document.createElement('div');
   div.className = 'message assistant loading';
+  // R34: 增强加载状态 — 添加旋转提示文本
   div.innerHTML = `
     <div class="msg-avatar">🤖</div>
     <div class="msg-body">
       <div class="msg-role">AI</div>
       <div class="msg-content">
         <div class="loading-dots"><span></span><span></span><span></span></div>
-        <span class="loading-text">正在思考...</span>
+        <span class="loading-text" data-hint-index="0">正在思考...</span>
       </div>
     </div>
   `;
   messagesContainerEl.appendChild(div);
   currentPlaceholder = div;
+
+  // R34: 启动旋转提示
+  startLoadingHintRotation(div);
+
   scrollToBottom();
 }
 
+// R34: 加载提示旋转动画
+const LOADING_HINTS = [
+  '正在思考...',
+  '正在分析问题...',
+  '正在组织回答...',
+  '正在查找信息...',
+  '正在生成回复...',
+];
+let _loadingHintInterval: ReturnType<typeof setInterval> | null = null;
+
+function startLoadingHintRotation(el: HTMLElement): void {
+  if (_loadingHintInterval) clearInterval(_loadingHintInterval);
+  let idx = 0;
+  _loadingHintInterval = setInterval(() => {
+    if (!el.isConnected) {
+      if (_loadingHintInterval) clearInterval(_loadingHintInterval);
+      _loadingHintInterval = null;
+      return;
+    }
+    idx = (idx + 1) % LOADING_HINTS.length;
+    const hintEl = el.querySelector('.loading-text');
+    if (hintEl) {
+      hintEl.textContent = LOADING_HINTS[idx];
+    }
+  }, 3000);
+}
+
 export function appendSystemMessage(text: string, tempClass?: string): void {
   const div = document.createElement('div');
   div.style.cssText = 'text-align:center;padding:8px;font-size:12px;color:var(--text-muted);';
@@ -502,6 +574,11 @@ export function resetCurrentPlaceholder(): void {
   if (currentPlaceholder && !currentPlaceholder.isConnected) {
     currentPlaceholder = null;
   }
+  // R34: 清理加载提示旋转
+  if (_loadingHintInterval) {
+    clearInterval(_loadingHintInterval);
+    _loadingHintInterval = null;
+  }
 }
 
 /** 从 DOM 移除当前 placeholder 并清空引用 */
@@ -517,6 +594,83 @@ export function enableAutoScroll(): void {
   if (scrollBtnEl) scrollBtnEl.style.display = 'none';
 }
 
+// ── R38: 代码块复制按钮 ──
+
+/** R38: 为代码块添加复制按钮 */
+function addCodeBlockCopyButtons(scope?: ParentNode): void {
+  const root = scope || messagesContainerEl;
+  const codeBlocks = root.querySelectorAll('pre:not([data-copy-added])');
+  for (const pre of codeBlocks) {
+    pre.setAttribute('data-copy-added', 'true');
+    const btn = document.createElement('button');
+    btn.className = 'code-copy-btn';
+    btn.textContent = '📋 复制';
+    btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:var(--bg-secondary);border:1px solid var(--border-color);border-radius:4px;cursor:pointer;opacity:0;transition:opacity 0.2s;';
+    // 确保 pre 是相对定位
+    if (getComputedStyle(pre).position === 'static') {
+      (pre as HTMLElement).style.position = 'relative';
+    }
+    pre.addEventListener('mouseenter', () => { btn.style.opacity = '1'; });
+    pre.addEventListener('mouseleave', () => { btn.style.opacity = '0'; });
+    btn.addEventListener('click', (e) => {
+      e.preventDefault();
+      const code = pre.querySelector('code');
+      const text = code ? code.textContent : pre.textContent;
+      if (text) {
+        navigator.clipboard.writeText(text).then(() => {
+          btn.textContent = '✅ 已复制';
+          setTimeout(() => { btn.textContent = '📋 复制'; }, 2000);
+        }).catch(() => {
+          btn.textContent = '❌ 失败';
+          setTimeout(() => { btn.textContent = '📋 复制'; }, 2000);
+        });
+      }
+    });
+    pre.appendChild(btn);
+  }
+}
+
+// ── R40: 消息操作按钮 ──
+
+/** R40: 为消息添加操作按钮（复制、重试） */
+function addMessageActions(): void {
+  const messages = messagesContainerEl.querySelectorAll('.message:not([data-actions-added])');
+  for (const msg of messages) {
+    msg.setAttribute('data-actions-added', 'true');
+    const actionBar = document.createElement('div');
+    actionBar.className = 'msg-actions';
+    actionBar.style.cssText = 'position:absolute;top:4px;right:4px;display:flex;gap:4px;opacity:0;transition:opacity 0.2s;';
+
+    // 确保 message 是相对定位
+    if (getComputedStyle(msg).position === 'static') {
+      (msg as HTMLElement).style.position = 'relative';
+    }
+
+    // 复制按钮
+    const copyBtn = document.createElement('button');
+    copyBtn.className = 'msg-action-btn msg-copy-btn';
+    copyBtn.textContent = '📋';
+    copyBtn.title = '复制消息';
+    copyBtn.style.cssText = 'padding:2px 6px;font-size:12px;background:var(--bg-secondary);border:1px solid var(--border-color);border-radius:4px;cursor:pointer;';
+    copyBtn.addEventListener('click', (e) => {
+      e.preventDefault();
+      const contentEl = msg.querySelector('.msg-content');
+      const text = contentEl ? contentEl.textContent : '';
+      if (text) {
+        navigator.clipboard.writeText(text).then(() => {
+          copyBtn.textContent = '✅';
+          setTimeout(() => { copyBtn.textContent = '📋'; }, 2000);
+        }).catch(() => {});
+      }
+    });
+    actionBar.appendChild(copyBtn);
+
+    msg.addEventListener('mouseenter', () => { actionBar.style.opacity = '1'; });
+    msg.addEventListener('mouseleave', () => { actionBar.style.opacity = '0'; });
+    msg.appendChild(actionBar);
+  }
+}
+
 // ── 导出功能 ──
 
 async function nativeSaveFile(defaultName: string, content: string): Promise<void> {
diff --git a/src/renderer/components/input-area.ts b/src/renderer/components/input-area.ts
index c8b3d3f..e3b1698 100644
--- a/src/renderer/components/input-area.ts
+++ b/src/renderer/components/input-area.ts
@@ -90,6 +90,40 @@ export function initInputArea(): void {
     }
   });
 
+  // R39: 全局键盘快捷键
+  document.addEventListener('keydown', (e) => {
+    // Ctrl+K: 清空聊天（需要确认）
+    if ((e.ctrlKey || e.metaKey) && e.key === 'k') {
+      e.preventDefault();
+      if (confirm('确定要清空当前对话吗？')) {
+        clearMessages();
+      }
+    }
+    // Escape: 停止生成（当正在流式输出时）
+    if (e.key === 'Escape' && state.get<boolean>(KEYS.IS_STREAMING)) {
+      e.preventDefault();
+      stopGeneration();
+    }
+    // Ctrl+/: 聚焦输入框
+    if ((e.ctrlKey || e.metaKey) && e.key === '/') {
+      e.preventDefault();
+      chatInputEl.focus();
+    }
+    // Ctrl+Shift+C: 复制最后一条 AI 消息
+    if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key === 'C') {
+      e.preventDefault();
+      const session = state.get<ChatSession | null>(KEYS.CURRENT_SESSION);
+      if (session && session.messages.length > 0) {
+        const lastAssistant = [...session.messages].reverse().find(m => m.role === 'assistant' && m.content);
+        if (lastAssistant) {
+          navigator.clipboard.writeText(lastAssistant.content).then(() => {
+            showToast('已复制最后一条 AI 回复', 'success');
+          }).catch(() => {});
+        }
+      }
+    }
+  });
+
   chatInputEl.addEventListener('input', autoResizeTextarea);
 
   // ── 图片上传：原生文件对话框 ──
diff --git a/src/renderer/index.html b/src/renderer/index.html
index a871db1..a925268 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.14.15</span>
+            <span class="app-version">v0.15.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/main.ts b/src/renderer/main.ts
index 4c86444..93fed57 100644
--- a/src/renderer/main.ts
+++ b/src/renderer/main.ts
@@ -28,6 +28,7 @@ import { initToolConfirmModal } from './components/tool-confirm-modal.js';
 import { initWorkspacePanel, clearToolCardsExternal, clearTerminalExternal, switchToTab } from './components/workspace-panel.js';
 import { initLogPanel, addLog } from './services/log-service.js';
 import { logInfo, logSuccess, logError, logDebug, logInit, logWarn } from './services/log-service.js';
+import { initGlobalErrorHandler, validateConfig } from './services/infra-service.js';
 import { initSearxngModal, closeSearxngModal, loadSearxngConfig } from './components/searxng-modal.js';
 import { initHarnessHooks } from './services/hooks.js';
 import { setAppVersion } from './services/agent-metrics.js';
@@ -319,6 +320,7 @@ async function init(): Promise<void> {
     state.set('thinkEnabled', false);
 
     initLogPanel();  // ← 日志面板最先初始化，确保后续 init 日志能显示
+    initGlobalErrorHandler();  // R42: 全局错误处理器（紧随日志面板之后）
     initToast();
     initLightbox();
     initHeader();
diff --git a/src/renderer/services/agent-engine.ts b/src/renderer/services/agent-engine.ts
index 51742ef..779504c 100644
--- a/src/renderer/services/agent-engine.ts
+++ b/src/renderer/services/agent-engine.ts
@@ -41,6 +41,7 @@ import type {
 const MAX_RETRIES = 2;              // 工具错误自动重试次数
 const MAX_MESSAGES = 300;           // 上下文硬上限，超过则强制压缩
 const API_MAX_RETRIES = 2;          // Ollama API 调用失败重试次数
+const MAX_PARALLEL_TOOLS = 5;       // R6: 单批次最大并行工具数
 
 /**
  * 计算增量压缩触发阈值（按 token 数而非消息条数）
@@ -139,6 +140,85 @@ const SIDE_EFFECT_TOOLS = new Set([
   'browser_open', 'browser_click', 'browser_type', 'browser_close',
 ]);
 
+/**
+ * R3: 工具执行超时配置（毫秒）
+ * 防止单个工具调用挂起导致整个 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: 带超时的工具执行包装器 */
+async function executeToolWithTimeout(
+  toolName: string,
+  args: Record<string, unknown>,
+  abortSignal?: AbortSignal,
+): Promise<ToolResult> {
+  const timeoutMs = TOOL_TIMEOUT_MAP[toolName] ?? TOOL_TIMEOUT_MAP.default;
+  if (timeoutMs <= 0) {
+    return executeTool(toolName, args);
+  }
+
+  const timeoutAC = new AbortController();
+  const timer = setTimeout(() => {
+    timeoutAC.abort(new Error(`工具 ${toolName} 执行超时 (${timeoutMs / 1000}s)`));
+  }, timeoutMs);
+
+  // 如果外部 abort 触发，也中止工具
+  const onExternalAbort = () => { timeoutAC.abort(); };
+  if (abortSignal) {
+    if (abortSignal.aborted) {
+      clearTimeout(timer);
+      return { success: false, error: '用户中止' };
+    }
+    abortSignal.addEventListener('abort', onExternalAbort, { once: true });
+  }
+
+  try {
+    const result = await executeTool(toolName, args);
+    return result;
+  } catch (err) {
+    if (timeoutAC.signal.aborted && !abortSignal?.aborted) {
+      return { success: false, error: `工具 ${toolName} 执行超时 (${timeoutMs / 1000}s)，请尝试拆分任务或优化参数` };
+    }
+    return { success: false, error: (err as Error)?.message || String(err) };
+  } finally {
+    clearTimeout(timer);
+    if (abortSignal) {
+      abortSignal.removeEventListener('abort', onExternalAbort);
+    }
+  }
+}
+
 /** D2/D3: 只读工具白名单 — 允许同参数重复调用（验证场景：写文件后重读、git status、run_command 监控等） */
 const RE_READ_ALLOWED = new Set([
   'read_file', 'list_directory', 'search_files', 'get_file_info', 'tree',
@@ -146,20 +226,62 @@ const RE_READ_ALLOWED = new Set([
   'browser_screenshot', 'browser_extract', 'run_command',
 ]);
 
-/** P0-2: 检测工具调用之间是否存在路径依赖（写入 → 读取/写入同一路径） */
+/** P0-2: 检测工具调用之间是否存在路径依赖（写入 → 读取/写入同一路径）
+ * R27: 增强 — 也检测读-写依赖（读取刚写入的文件需要串行化）
+ */
 function hasPathDependency(call: ToolCall, prevBatch: ToolCall[]): boolean {
-  const callPath = extractWritePath(call);
-  if (!callPath) return false; // 非写操作，无依赖
+  const callWritePath = extractWritePath(call);
+  const callReadPath = extractReadPath(call);
+
   for (const prev of prevBatch) {
-    const prevPath = extractAffectedPath(prev);
-    if (prevPath && pathsConflict(callPath, prevPath)) {
-      logInfo(`串行化: ${prev.function.name}(${prevPath}) → ${call.function.name}(${callPath})`);
+    const prevWritePath = extractWritePath(prev);
+    const prevAffectedPath = extractAffectedPath(prev);
+
+    // 写 → 写：同路径冲突
+    if (callWritePath && prevWritePath && pathsConflict(callWritePath, prevWritePath)) {
+      logInfo(`R27: 串行化(写-写): ${prev.function.name}(${prevWritePath}) → ${call.function.name}(${callWritePath})`);
       return true;
     }
+
+    // R27: 读 → 写：读取刚被修改的路径（需要等待写入完成）
+    if (callWritePath && prevAffectedPath && pathsConflict(callWritePath, prevAffectedPath)) {
+      logInfo(`R27: 串行化(读-写): ${prev.function.name}(${prevAffectedPath}) → ${call.function.name}(${callWritePath})`);
+      return true;
+    }
+
+    // R27: 写 → 读：写入后立即读取同一路径（需要串行化）
+    if (callReadPath && prevWritePath && pathsConflict(callReadPath, prevWritePath)) {
+      logInfo(`R27: 串行化(写-读): ${prev.function.name}(${prevWritePath}) → ${call.function.name}(${callReadPath})`);
+      return true;
+    }
+
+    // R27: run_command 路径依赖 — 如果命令 cwd 指向被修改的路径
+    if (call.function.name === 'run_command' && prevWritePath) {
+      const cmdCwd = String(call.function.arguments?.cwd || '');
+      if (cmdCwd && pathsConflict(cmdCwd, prevWritePath)) {
+        logInfo(`R27: 串行化(命令依赖): ${prev.function.name}(${prevWritePath}) → run_command(${cmdCwd})`);
+        return true;
+      }
+    }
   }
   return false;
 }
 
+/** R27: 提取工具的读取路径（纯读操作，非写操作） */
+function extractReadPath(call: ToolCall): string | null {
+  const args = call.function.arguments;
+  switch (call.function.name) {
+    case 'read_file': return String(args.path || '');
+    case 'list_directory': return String(args.path || '');
+    case 'search_files': return String(args.path || '');
+    case 'get_file_info': return String(args.path || '');
+    case 'tree': return String(args.path || '');
+    case 'diff_files': return String(args.file1 || args.file2 || '');
+    case 'read_multiple_files': return null; // 多文件，难以精确判断
+    default: return null;
+  }
+}
+
 /** 提取工具写入的目标路径（会修改文件系统的操作） */
 function extractWritePath(call: ToolCall): string | null {
   const args = call.function.arguments;
@@ -407,10 +529,42 @@ function parseToolCallsFromText(content: string): ToolCall[] {
   }
 
   // ── 格式4: 函数调用语法 func_name({"key": "value"}) ──
-  // 匹配 read_file({"path": "xxx"})
-  const funcCallRegex = /\b(\w+)\s*\(\s*(\{[^}]*\})\s*\)/g;
-  while ((match = funcCallRegex.exec(content)) !== null) {
-    tryAddCall(match[1], match[2]);
+  // R5: 修复嵌套大括号问题 — 使用平衡括号匹配替代 [^}]*
+  // 旧正则 /\b(\w+)\s*\(\s*(\{[^}]*\})\s*\)/g 无法匹配嵌套 JSON 如 {"a": {"b": 1}}
+  {
+    const funcCallStart = /\b(\w+)\s*\(\s*\{/g;
+    let fcMatch;
+    while ((fcMatch = funcCallStart.exec(content)) !== null) {
+      const toolName = fcMatch[1];
+      const braceStart = fcMatch.index + fcMatch[0].length - 1; // 指向 '{'
+      // 手动平衡匹配大括号
+      let depth = 0;
+      let endIdx = -1;
+      let inString = false;
+      let escapeNext = false;
+      for (let i = braceStart; i < content.length; i++) {
+        const ch = content[i];
+        if (escapeNext) { escapeNext = false; continue; }
+        if (ch === '\\') { escapeNext = true; continue; }
+        if (ch === '"') { inString = !inString; continue; }
+        if (inString) continue;
+        if (ch === '{') depth++;
+        else if (ch === '}') {
+          depth--;
+          if (depth === 0) { endIdx = i; break; }
+        }
+      }
+      if (endIdx > 0) {
+        const jsonStr = content.slice(braceStart, endIdx + 1);
+        // 检查后面是否有闭合括号
+        const afterClose = content.slice(endIdx + 1).match(/^\s*\)/);
+        if (afterClose) {
+          tryAddCall(toolName, jsonStr);
+          // 移动 regex 位置到匹配结束后
+          funcCallStart.lastIndex = endIdx + 1;
+        }
+      }
+    }
   }
 
   if (calls.length > 0) {
@@ -420,8 +574,42 @@ function parseToolCallsFromText(content: string): ToolCall[] {
   return calls;
 }
 
+/** R1: 工具缓存最大条目数，超出时按 LRU 策略淘汰最旧条目 */
+const MAX_TOOL_CACHE_SIZE = 100;
 const toolResultCache = new Map<string, { result: ToolResult; timestamp: number }>();
 
+/**
+ * R1: 向工具缓存写入条目，超出上限时按 LRU 策略淘汰最旧条目。
+ * Map 在 JS 中保持插入顺序，删除+重新插入即实现 LRU 更新。
+ */
+function setToolCache(key: string, entry: { result: ToolResult; timestamp: number }): void {
+  // 如果已存在，先删除以便重新插入到末尾（LRU 更新）
+  if (toolResultCache.has(key)) {
+    toolResultCache.delete(key);
+  }
+  toolResultCache.set(key, entry);
+  // 超出上限时淘汰最旧条目（Map 迭代顺序 = 插入顺序）
+  if (toolResultCache.size > MAX_TOOL_CACHE_SIZE) {
+    const oldestKey = toolResultCache.keys().next().value;
+    if (oldestKey !== undefined) {
+      toolResultCache.delete(oldestKey);
+    }
+  }
+}
+
+/**
+ * R1: 从工具缓存读取条目，命中时将其移到末尾（LRU 更新）。
+ */
+function getToolCache(key: string): { result: ToolResult; timestamp: number } | undefined {
+  const entry = toolResultCache.get(key);
+  if (entry) {
+    // 命中时移到末尾，标记为最近使用
+    toolResultCache.delete(key);
+    toolResultCache.set(key, entry);
+  }
+  return entry;
+}
+
 /** 工具缓存 TTL（毫秒），按工具类型设定。P1-6: default 从 Infinity 改为 60s */
 const CACHE_TTL_MAP: Record<string, number> = {
   web_search: 5 * 60_000,
@@ -665,7 +853,11 @@ async function flushTraces(): Promise<void> {
   if (_traceBuffer.length === 0) return;
   const batch = _traceBuffer.splice(0, _traceBuffer.length);
   const bridge = window.metonaDesktop;
-  if (!bridge?.db) return;
+  if (!bridge?.db) {
+    // R9: 无 DB 桥接时，降级到 localStorage
+    _fallbackSaveTraces(batch);
+    return;
+  }
 
   for (const trace of batch) {
     const entry = {
@@ -680,10 +872,12 @@ async function flushTraces(): Promise<void> {
       error_pattern: trace.errorPattern || null,
       created_at: trace.createdAt
     };
+    let saved = false;
     // 重试最多 TRACE_MAX_RETRIES 次
     for (let attempt = 0; attempt < TRACE_MAX_RETRIES; attempt++) {
       try {
         await bridge.db.saveTrace(entry);
+        saved = true;
         break;
       } catch {
         if (attempt < TRACE_MAX_RETRIES - 1) {
@@ -691,6 +885,28 @@ async function flushTraces(): Promise<void> {
         }
       }
     }
+    // R9: 所有重试都失败时，降级到 localStorage
+    if (!saved) {
+      _fallbackSaveTraces([trace]);
+    }
+  }
+}
+
+/** R9: 轨迹降级存储 — 当 SQLite 写入失败时，将轨迹保存到 localStorage */
+const TRACE_FALLBACK_KEY = '_metona_trace_fallback';
+const TRACE_FALLBACK_MAX = 200; // 最多保留 200 条降级轨迹
+
+function _fallbackSaveTraces(traces: Array<Record<string, any>>): void {
+  try {
+    const existing = JSON.parse(localStorage.getItem(TRACE_FALLBACK_KEY) || '[]');
+    const combined = [...existing, ...traces].slice(-TRACE_FALLBACK_MAX);
+    localStorage.setItem(TRACE_FALLBACK_KEY, JSON.stringify(combined));
+    if (traces.length > 0) {
+      logWarn(`R9: ${traces.length} 条轨迹降级到 localStorage（共 ${combined.length} 条）`);
+    }
+  } catch {
+    // localStorage 也失败时，仅记录日志
+    logWarn(`R9: 轨迹降级存储也失败，${traces.length} 条轨迹丢失`);
   }
 }
 
@@ -778,10 +994,6 @@ function persistLoopContext(ctx: LoopContext): void {
   });
 }
 
-/** 从 state 恢复 LoopContext（暂未实现完整恢复，预留接口） */
-function restoreLoopContext(_sessionId: string): Partial<LoopContext> | null {
-  return state.get<Partial<LoopContext> | null>('_loopContext', null);
-}
 
 // ═══════════════════════════════════════════════════════════════
 // Harness: 状态处理器
@@ -981,15 +1193,13 @@ async function handleInit(
 
   // 上下文窗口管理：滑动窗口 + 摘要压缩 + token 裁剪
   // 钳制：取 min(模型支持值, 用户设置值)，防止手动设置超过模型能力
-  const numCtx = getEffectiveNumCtx();
-  const contextResult = buildContext(ctx.messages, { maxTokens: numCtx, windowSize: 20 });
+  const effectiveNumCtx = getEffectiveNumCtx();
+  const contextResult = buildContext(ctx.messages, { maxTokens: effectiveNumCtx, windowSize: 20 });
   ctx.messages.length = 0;
   ctx.messages.push(...contextResult);
 
-  // 钳制：取 min(模型支持值, 用户设置值)
-  const effectiveNumCtx = getEffectiveNumCtx();
   if (shouldAutoCompress(ctx.messages, effectiveNumCtx)) {
-    logInfo(`自动上下文压缩触发: tokens≈${estimateTokens(ctx.messages.map(m => m.content || '').join(''))} > ${Math.floor(effectiveNumCtx * AUTO_COMPRESS_THRESHOLD)} (50% of ${effectiveNumCtx})`);
+    logInfo(`自动上下文压缩触发: tokens≈${estimateTokens(ctx.messages.map(m => m.content || '').join(''))} > ${Math.floor(effectiveNumCtx * AUTO_COMPRESS_THRESHOLD)} (${Math.round(AUTO_COMPRESS_THRESHOLD * 100)}% of ${effectiveNumCtx})`);
     const compressAC = state.get<AbortController | null>(KEYS.ABORT_CONTROLLER) || new AbortController();
     try {
       const compressed = await compressWithLLM(ctx.messages, api as any, model, { abortController: compressAC });
@@ -1290,10 +1500,18 @@ async function handleThinking(
   // ── API 调用重试循环 — 瞬态错误时指数退避重试，不轻易终止 Agent Loop ──
   let apiRetrySuccess = false;
   let apiLastErr: Error | null = null;
+  // R4: 保留最佳部分内容 — 重试前保存最长的 partial content，全部失败时作为 fallback
+  let _bestPartialContent = '';
+  let _bestPartialThinking = '';
 
   for (let apiAttempt = 0; apiAttempt <= API_MAX_RETRIES; apiAttempt++) {
-    // 每次重试前重置本轮状态（保留之前累积的 content/thinking 不丢弃）
+    // 每次重试前重置本轮状态
     if (apiAttempt > 0) {
+      // R4: 保存本次尝试的部分内容（取最长的）
+      if (ctx.content.length > _bestPartialContent.length) {
+        _bestPartialContent = ctx.content;
+        _bestPartialThinking = ctx.thinking;
+      }
       ctx.content = '';
       ctx.thinking = '';
       ctx.toolCalls.length = 0;
@@ -1424,6 +1642,27 @@ async function handleThinking(
 
       apiLastErr = err as Error;
 
+      // R8: 检测 Ollama 上下文溢出错误 — 自动压缩并重试
+      const errMsg = apiLastErr.message || '';
+      const isContextOverflow = /context.*length|prompt.*too.*long|context.*window|maximum.*context|num_ctx|上下文.*超/i.test(errMsg);
+      if (isContextOverflow && ctx.messages.length > 10) {
+        logWarn(`R8: 检测到上下文溢出错误，触发紧急压缩`, errMsg.slice(0, 100));
+        try {
+          const compressAC = new AbortController();
+          const compressed = await compressWithLLM(ctx.messages, api as any, model, { abortController: compressAC });
+          if (compressed.length < ctx.messages.length) {
+            ctx.messages.length = 0;
+            ctx.messages.push(...compressed);
+            logSuccess(`R8: 紧急压缩完成，剩余 ${ctx.messages.length} 条消息`);
+            // 压缩后直接重试，不消耗重试计数
+            apiAttempt--;
+            continue;
+          }
+        } catch (compressErr) {
+          logWarn('R8: 紧急压缩失败', (compressErr as Error).message);
+        }
+      }
+
       if (apiAttempt < API_MAX_RETRIES) {
         logWarn(`流式调用异常 (尝试 ${apiAttempt + 1}/${API_MAX_RETRIES + 1})`, apiLastErr.message);
         continue;
@@ -1437,6 +1676,12 @@ async function handleThinking(
   // 所有重试都失败
   if (!apiRetrySuccess) {
     logError('流式调用异常（已达最大重试）', apiLastErr?.message || '未知错误');
+    // R4: 使用最佳部分内容作为 fallback（如果当前内容为空但之前有部分内容）
+    if (!ctx.content && _bestPartialContent) {
+      ctx.content = _bestPartialContent;
+      ctx.thinking = _bestPartialThinking || ctx.thinking;
+      logInfo(`R4: 使用最佳部分内容 (${_bestPartialContent.length} 字) 作为回退`);
+    }
     if (ctx.content || ctx.thinking) {
       ctx.messages.push({ role: 'assistant', content: ctx.content || '（模型响应异常）', ...(ctx.thinking && { thinking: ctx.thinking }) });
     }
@@ -1576,7 +1821,7 @@ async function handleExecuting(
       // D4: 有副作用的工具不返回缓存，需实际执行（如 write_file、run_command）
       if (!SIDE_EFFECT_TOOLS.has(call.function.name)) {
         logWarn(`跳过重复工具调用: ${call.function.name}`);
-        const cached = toolResultCache.get(cacheKey);
+        const cached = getToolCache(cacheKey);
         if (cached) {
           return [{
             name: call.function.name, arguments: call.function.arguments,
@@ -1588,7 +1833,7 @@ async function handleExecuting(
       }
     }
 
-    const cachedEntry = toolResultCache.get(cacheKey);
+    const cachedEntry = getToolCache(cacheKey);
     if (cachedEntry && isCacheValid(call.function.name, cachedEntry.timestamp)) {
       logInfo(`工具缓存命中: ${call.function.name}`);
       return [{
@@ -1596,7 +1841,7 @@ async function handleExecuting(
         result: cachedEntry.result, status: 'success' as const, timestamp: Date.now()
       }, null];
     }
-    if (cachedEntry) {
+    if (cachedEntry && !isCacheValid(call.function.name, cachedEntry.timestamp)) {
       toolResultCache.delete(cacheKey);
     }
 
@@ -1623,8 +1868,8 @@ async function handleExecuting(
       logWarn(`pre_tool Hook 阻断: ${call.function.name}`, reasons);
       return [{
         name: call.function.name, arguments: call.function.arguments,
-        result: { success: true, error: '', message: reasons },
-        status: 'success' as const, timestamp: Date.now()
+        result: { success: false, error: reasons },
+        status: 'cancelled' as const, timestamp: Date.now()
       }, null];
     }
 
@@ -1654,7 +1899,8 @@ async function handleExecuting(
         }, null];
       }
       try {
-        const result = await executeTool(call.function.name, call.function.arguments)
+        const result = await executeToolWithTimeout(call.function.name, call.function.arguments,
+          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);
         // 记录 write_file 成功路径及内容指纹，供 FileWriteDedup Hook 做内容级去重
@@ -1706,7 +1952,13 @@ async function handleExecuting(
       return;
     }
 
-    const results = await Promise.all(batch.map(call => executeSingleTool(call)));
+    // R6: 限制并行工具数量，避免过多并发导致资源争抢
+    const results: Array<[ToolCallRecord, string | null]> = [];
+    for (let i = 0; i < batch.length; i += MAX_PARALLEL_TOOLS) {
+      const chunk = batch.slice(i, i + MAX_PARALLEL_TOOLS);
+      const chunkResults = await Promise.all(chunk.map(call => executeSingleTool(call)));
+      results.push(...chunkResults);
+    }
 
     for (const [record, cacheKey] of results) {
       ctx.allToolRecords.push(record);
@@ -1718,7 +1970,7 @@ async function handleExecuting(
       // 原逻辑：memory/session_read/session_list/spawn_task 后注入额外 user 消息
       // 问题：每轮最多多4条合成 user 消息，污染上下文
       // 方案：在 AGENT.md 核心规则中增加"工具返回数据是事实来源"通用规则
-      if (cacheKey) toolResultCache.set(cacheKey, { result: record.result!, timestamp: Date.now() });
+      if (cacheKey) setToolCache(cacheKey, { result: record.result!, timestamp: Date.now() });
       // 记录度量
       recordToolCall(record.name, record.status, Date.now() - record.timestamp);
       // ── 通用工具结果核验 — 所有写类工具执行后验证 ──
@@ -1727,12 +1979,17 @@ async function handleExecuting(
       }
       // ── post_tool Hook ──
       executeHooks('post_tool', ctx, { toolName: record.name, toolArgs: record.arguments, toolResult: record.result! });
+      // P0 修复: 使用参数匹配而非仅工具名匹配，避免同批次同名工具的错误关联
+      const matchedCall = batch.find(c =>
+        c.function.name === record.name &&
+        JSON.stringify(c.function.arguments) === JSON.stringify(record.arguments)
+      ) ?? batch.find(c => c.function.name === record.name)!;
       if (record.status === 'success') {
-        callbacks.onToolCallResult(record.name, record.result!, batch.find(c => c.function.name === record.name)!);
+        callbacks.onToolCallResult(record.name, record.result!, matchedCall);
       } else if (record.status === 'cancelled') {
-        callbacks.onToolCallError(record.name, '用户取消', batch.find(c => c.function.name === record.name)!);
+        callbacks.onToolCallError(record.name, '用户取消', matchedCall);
       } else {
-        callbacks.onToolCallError(record.name, record.result?.error || '执行失败', batch.find(c => c.function.name === record.name)!);
+        callbacks.onToolCallError(record.name, record.result?.error || '执行失败', matchedCall);
       }
     }
   }
@@ -1852,35 +2109,35 @@ async function handleObserving(
     logInfo(`只读工具重复调用（允许验证场景）: ${recentSuccess[0].name}`);
   }
 
-// 每 10 轮清理累积的 ephemeral 消息
-// C7: 保留 Plan Mode 关键 ephemeral 消息（含进度、计划批准等），只清理纯提醒类
-// 但如果上下文使用率已过高（>70%），跳过清理——压缩即将触发，
-// 此时清理会导致压缩 LLM 看不到 Plan Mode 进度等关键状态信息
-if (ctx.loopCount > 1 && ctx.loopCount % 10 === 0) {
-  const numCtx = getEffectiveNumCtx();
-  const usageRatio = numCtx > 0 ? estimateTokens(ctx.messages.map(m => m.content || '').join('')) / numCtx : 0;
-  if (usageRatio > 0.7) {
-    logInfo(`ephemeral 清理跳过: 上下文使用率 ${(usageRatio * 100).toFixed(0)}%, 压缩即将触发`);
-  } else {
-    // C7: 保留含 Plan Mode 关键信息的 ephemeral 消息
-    const PRESERVE_PATTERNS = [
-      /Plan Mode/, /计划已批准/, /计划已拒绝/, /最大计划重试/, 
-      /plan_track/, /当前进度/, /断点续传/,
-    ];
-    let removed = 0;
-    ctx.messages = ctx.messages.filter(m => {
-      if (m.ephemeral) {
-        // 检查是否包含 Plan Mode 关键信息
-        const shouldPreserve = PRESERVE_PATTERNS.some(p => p.test(m.content || ''));
-        if (shouldPreserve) return true;
-        removed++;
-        return false;
-      }
-      return true;
-    });
-    if (removed > 0) logInfo(`ephemeral 清理: ${removed} 条临时消息已移除 (Plan Mode 关键消息已保留)`);
+  // 每 10 轮清理累积的 ephemeral 消息
+  // C7: 保留 Plan Mode 关键 ephemeral 消息（含进度、计划批准等），只清理纯提醒类
+  // 但如果上下文使用率已过高（>70%），跳过清理——压缩即将触发，
+  // 此时清理会导致压缩 LLM 看不到 Plan Mode 进度等关键状态信息
+  if (ctx.loopCount > 1 && ctx.loopCount % 10 === 0) {
+    const numCtx = getEffectiveNumCtx();
+    const usageRatio = numCtx > 0 ? estimateTokens(ctx.messages.map(m => m.content || '').join('')) / numCtx : 0;
+    if (usageRatio > 0.7) {
+      logInfo(`ephemeral 清理跳过: 上下文使用率 ${(usageRatio * 100).toFixed(0)}%, 压缩即将触发`);
+    } else {
+      // C7: 保留含 Plan Mode 关键信息的 ephemeral 消息
+      const PRESERVE_PATTERNS = [
+        /Plan Mode/, /计划已批准/, /计划已拒绝/, /最大计划重试/,
+        /plan_track/, /当前进度/, /断点续传/,
+      ];
+      let removed = 0;
+      ctx.messages = ctx.messages.filter(m => {
+        if (m.ephemeral) {
+          // 检查是否包含 Plan Mode 关键信息
+          const shouldPreserve = PRESERVE_PATTERNS.some(p => p.test(m.content || ''));
+          if (shouldPreserve) return true;
+          removed++;
+          return false;
+        }
+        return true;
+      });
+      if (removed > 0) logInfo(`ephemeral 清理: ${removed} 条临时消息已移除 (Plan Mode 关键消息已保留)`);
+    }
   }
-}
 
   // ── P0-4: 增量压缩 — 按token使用率触发，防止 Ollama context 超限 ──
   const numCtx = getEffectiveNumCtx();
@@ -2066,6 +2323,15 @@ async function handleReflecting(
   }
 
   // ── 正常终止: 模型停止调工具 → 信任模型的判断 ──
+  // pre_completion Hook（可执行最终检查、内容修改等，不阻断但记录结果）
+  try {
+    const hookResult = await executeHooks('pre_completion', ctx);
+    if (!hookResult.allPassed) {
+      const reasons = hookResult.results.filter(r => !r.passed).map(r => r.message).join('; ');
+      logWarn(`pre_completion Hook 提示: ${reasons}`);
+    }
+  } catch { /* Hook 异常不影响主流程 */ }
+
   try {
     const gateResult = await runCompletionGate(ctx);
     if (!gateResult.passed) {
@@ -2117,6 +2383,7 @@ async function handleCompressing(
   model: string,
 ): Promise<void> {
   const numCtx = getEffectiveNumCtx();
+  let actuallyCompressed = false;
   if (shouldAutoCompress(ctx.messages, numCtx)) {
     logInfo('COMPRESSING: 上下文压缩触发');
     const compressAC = state.get<AbortController | null>(KEYS.ABORT_CONTROLLER) || new AbortController();
@@ -2125,6 +2392,7 @@ async function handleCompressing(
       if (compressed.length < ctx.messages.length || estimateTokens(compressed.map(m => m.content || '').join('')) < estimateTokens(ctx.messages.map(m => m.content || '').join(''))) {
         ctx.messages.length = 0;
         ctx.messages.push(...compressed);
+        actuallyCompressed = true;
         logSuccess('COMPRESSING: 完成');
       }
     } catch (err) {
@@ -2132,7 +2400,14 @@ async function handleCompressing(
       logWarn('COMPRESSING: 失败', (err as Error).message);
     }
   }
-  transition(ctx, S.REFLECTING);
+  // P0 修复: 如果压缩未实际发生（如 shouldAutoCompress 返回 false 或压缩未减小体积），
+  // 且当前内容/工具调用为空（说明是从主循环紧急压缩路径进入，而非从 OBSERVING 正常进入），
+  // 则回到 THINKING 而非 REFLECTING，避免模型尚未思考就被错误终止
+  if (!actuallyCompressed && ctx.toolCalls.length === 0 && !ctx.content.trim()) {
+    transition(ctx, S.THINKING);
+  } else {
+    transition(ctx, S.REFLECTING);
+  }
 }
 
 // ═══════════════════════════════════════════════════════════════
@@ -2211,6 +2486,13 @@ export async function runAgentLoop(
   const { setPlanModeActive } = await import('./tool-registry.js');
   setPlanModeActive(mode === 'plan');
 
+  // ── R2: 无进展循环检测 — 跟踪连续无新内容/无新工具调用的迭代 ──
+  let _lastProgressContentLen = 0;
+  let _lastProgressToolCount = 0;
+  let _lastProgressMsgCount = 0;
+  let _noProgressCount = 0;
+  const MAX_NO_PROGRESS = 5; // 连续 5 轮无进展则注入提醒
+
   // ── 状态机主循环 ──
   try {
     // Phase 1: INIT
@@ -2253,7 +2535,7 @@ export async function runAgentLoop(
 
       // Token 感知的动态迭代预算
       const numCtx = getEffectiveNumCtx();
-      const usageRatio = estimateTokens(ctx.messages.map(m => m.content || '').join('')) / numCtx;
+      const usageRatio = numCtx > 0 ? estimateTokens(ctx.messages.map(m => m.content || '').join('')) / numCtx : 0;
 
       // 上下文使用率过高时触发紧急压缩（不限制轮次，而是回收上下文空间）
       if (usageRatio > 0.8 && ctx.state === S.THINKING) {
@@ -2300,12 +2582,49 @@ export async function runAgentLoop(
           // handleCompressing 内部会 transition 到 REFLECTING
           break;
 
-        default:
-          logWarn(`未知状态: ${ctx.state}，强制终止`);
-          transition(ctx, S.TERMINATED);
+default:
+  // R7: 状态机恢复 — 尝试恢复到安全状态而非直接终止
+  logWarn(`未知状态: ${ctx.state}，尝试恢复`);
+  // 尝试恢复到 THINKING（最安全的状态，会重新调用 LLM）
+  if (ctx.loopCount < ctx.maxLoops && ctx.messages.length > 0) {
+    logInfo(`R7: 从未知状态 ${ctx.state} 恢复到 THINKING`);
+    ctx.state = S.THINKING;
+    state.set('_loopState', S.THINKING);
+  } else {
+    logWarn(`R7: 恢复条件不满足，强制终止`);
+    transition(ctx, S.TERMINATED);
+  }
       }
 
       persistLoopContext(ctx);
+
+      // ── R2: 无进展循环检测 ──
+      // 每轮结束时检查是否有新内容生成、新工具调用或新消息
+      const currentContentLen = ctx.content.length;
+      const currentToolCount = ctx.allToolRecords.length;
+      const currentMsgCount = ctx.messages.length;
+      const hasProgress =
+        currentContentLen > _lastProgressContentLen ||
+        currentToolCount > _lastProgressToolCount ||
+        currentMsgCount > _lastProgressMsgCount + 2; // +2 容差：允许少量系统注入
+      if (hasProgress) {
+        _noProgressCount = 0;
+        _lastProgressContentLen = currentContentLen;
+        _lastProgressToolCount = currentToolCount;
+        _lastProgressMsgCount = currentMsgCount;
+      } else {
+        _noProgressCount++;
+        if (_noProgressCount >= MAX_NO_PROGRESS) {
+          logWarn(`R2: 检测到连续 ${_noProgressCount} 轮无进展，注入强制终止信号`);
+          ctx.messages.push({
+            role: 'user',
+            content: '⚠️ 系统检测到连续多轮无新进展。请基于已有结果立即给出最终回答，不要再重复之前的操作。',
+            ephemeral: true,
+          });
+          ctx.maxLoops = Math.min(ctx.maxLoops, ctx.loopCount + 1);
+          _noProgressCount = 0; // 重置，避免重复注入
+        }
+      }
     }
   } catch (err) {
     if ((err as Error).name === 'AbortError') {
diff --git a/src/renderer/services/context-manager.ts b/src/renderer/services/context-manager.ts
index 5bd2d4b..b8a2bca 100644
--- a/src/renderer/services/context-manager.ts
+++ b/src/renderer/services/context-manager.ts
@@ -7,6 +7,159 @@
 import type { OllamaMessage, OllamaStreamChunk } from '../types.js';
 import { logInfo, logWarn, logSuccess, logError } from './log-service.js';
 
+// ── R12: 压缩去重 — 内容指纹追踪 ──
+
+/** DJB2 哈希函数，用于消息内容指纹 */
+function djb2Hash(str: string): string {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0x7fffffff;
+  }
+  return hash.toString(36);
+}
+
+/** 记录已压缩消息批次的内容指纹，避免重复压缩相同内容 */
+const _compressedContentHashes = new Set<string>();
+const MAX_COMPRESSED_HASHES = 100;
+
+/** R12: 计算消息批次的内容指纹 */
+function computeMessagesHash(messages: OllamaMessage[]): string {
+  const content = messages.map(m => `${m.role}:${(m.content || '').slice(0, 200)}`).join('|');
+  return djb2Hash(content);
+}
+
+/** R12: 检查消息批次是否已被压缩过 */
+function isAlreadyCompressed(messages: OllamaMessage[]): boolean {
+  if (messages.length === 0) return true;
+  const hash = computeMessagesHash(messages);
+  return _compressedContentHashes.has(hash);
+}
+
+/** R12: 记录已压缩的消息批次指纹 */
+function markAsCompressed(messages: OllamaMessage[]): void {
+  const hash = computeMessagesHash(messages);
+  _compressedContentHashes.add(hash);
+  // LRU 式淘汰：超过上限时移除最早的
+  if (_compressedContentHashes.size > MAX_COMPRESSED_HASHES) {
+    const firstKey = _compressedContentHashes.values().next().value;
+    if (firstKey) _compressedContentHashes.delete(firstKey);
+  }
+}
+
+// ── R18: 上下文使用率预测 ──
+
+/** 上下文使用率趋势数据点 */
+interface TokenUsagePoint {
+  turn: number;
+  tokens: number;
+  numCtx: number;
+  timestamp: number;
+}
+
+const _tokenUsageTrend: TokenUsagePoint[] = [];
+const MAX_TREND_POINTS = 20;
+let _currentTurn = 0;
+
+/** R18: 上下文预警级别 */
+export type ContextWarningLevel = 'safe' | 'notice' | 'warning' | 'critical';
+
+/** R18: 上下文预测结果 */
+export interface ContextPrediction {
+  level: ContextWarningLevel;
+  currentUsage: number;    // 0-1
+  predictedUsage: number;  // 预测下一轮的使用率
+  turnsToOverflow: number; // 预计多少轮后溢出（-1 表示不会溢出）
+  message: string;
+}
+
+/** R18: 记录当前轮次的 token 使用量 */
+export function recordTokenUsage(tokens: number, numCtx: number): void {
+  _currentTurn++;
+  _tokenUsageTrend.push({
+    turn: _currentTurn,
+    tokens,
+    numCtx,
+    timestamp: Date.now(),
+  });
+  if (_tokenUsageTrend.length > MAX_TREND_POINTS) {
+    _tokenUsageTrend.shift();
+  }
+}
+
+/** R18: 预测上下文溢出风险 */
+export function predictContextOverflow(numCtx: number): ContextPrediction {
+  const currentTokens = _tokenUsageTrend.length > 0
+    ? _tokenUsageTrend[_tokenUsageTrend.length - 1].tokens
+    : 0;
+  const currentUsage = currentTokens / numCtx;
+
+  // 至少需要 3 个数据点才能做线性回归预测
+  if (_tokenUsageTrend.length < 3) {
+    const level: ContextWarningLevel = currentUsage > 0.8 ? 'critical'
+      : currentUsage > 0.6 ? 'warning'
+      : currentUsage > 0.4 ? 'notice'
+      : 'safe';
+    return {
+      level,
+      currentUsage,
+      predictedUsage: currentUsage,
+      turnsToOverflow: -1,
+      message: level === 'safe' ? '' : `当前上下文使用率 ${(currentUsage * 100).toFixed(0)}%`,
+    };
+  }
+
+  // 线性回归：y = ax + b，预测未来 token 增长
+  const n = _tokenUsageTrend.length;
+  const xs = _tokenUsageTrend.map(p => p.turn);
+  const ys = _tokenUsageTrend.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 numerator = 0, denominator = 0;
+  for (let i = 0; i < n; i++) {
+    numerator += (xs[i] - xMean) * (ys[i] - yMean);
+    denominator += (xs[i] - xMean) ** 2;
+  }
+  const slope = denominator !== 0 ? numerator / denominator : 0;
+  const intercept = yMean - slope * xMean;
+
+  // 预测下一轮
+  const nextTurn = _currentTurn + 1;
+  const predictedTokens = Math.max(0, slope * nextTurn + intercept);
+  const predictedUsage = predictedTokens / numCtx;
+
+  // 计算预计多少轮后溢出
+  let turnsToOverflow = -1;
+  if (slope > 0) {
+    turnsToOverflow = Math.ceil((numCtx - intercept) / slope - _currentTurn);
+    if (turnsToOverflow < 0) turnsToOverflow = 0;
+  }
+
+  // 确定预警级别
+  const maxUsage = Math.max(currentUsage, predictedUsage);
+  let level: ContextWarningLevel;
+  let message = '';
+
+  if (maxUsage > 0.85 || turnsToOverflow === 0) {
+    level = 'critical';
+    message = `⚠️ 上下文即将溢出！当前 ${currentTokens}/${numCtx} tokens (${(currentUsage * 100).toFixed(0)}%)，预计 ${turnsToOverflow} 轮后溢出`;
+  } else if (maxUsage > 0.7 || (turnsToOverflow >= 1 && turnsToOverflow <= 3)) {
+    level = 'warning';
+    message = `⚠️ 上下文使用率较高 (${(currentUsage * 100).toFixed(0)}%)，预计 ${turnsToOverflow} 轮后可能溢出，建议压缩`;
+  } else if (maxUsage > 0.5) {
+    level = 'notice';
+    message = `上下文使用率 ${(currentUsage * 100).toFixed(0)}%，趋势正常`;
+  } else {
+    level = 'safe';
+  }
+
+  return { level, currentUsage, predictedUsage, turnsToOverflow, message };
+}
+
+/** R18: 获取 token 使用趋势数据（供调试用） */
+export function getTokenUsageTrend(): TokenUsagePoint[] {
+  return [..._tokenUsageTrend];
+}
+
 // ── Token 校准系统 ──
 
 /** 校准比例：actualTokens / estimatedTokens，基于 Ollama 返回的实际计数动态修正 */
@@ -67,6 +220,40 @@ export function getTokenCalibration(): { ratio: number; samples: number } {
 /** 自动压缩阈值：当消息 token 占 context window 比例超过此值时触发自动压缩 */
 export const AUTO_COMPRESS_THRESHOLD = 0.3;
 
+/** R14: 自适应压缩阈值 — 根据模型上下文长度动态调整 */
+export function getAdaptiveCompressThreshold(numCtx: number): number {
+  // 小上下文模型（<8K）：更早触发压缩（40%），留更多余量
+  // 中等上下文（8K-32K）：标准阈值（30%）
+  // 大上下文（>32K）：稍晚触发（25%），避免过于频繁压缩
+  if (numCtx < 8192) return 0.4;
+  if (numCtx > 32768) return 0.25;
+  return AUTO_COMPRESS_THRESHOLD;
+}
+
+/** R19: 压缩效果指标 */
+export interface CompressionMetrics {
+  beforeMessages: number;
+  afterMessages: number;
+  beforeTokens: number;
+  afterTokens: number;
+  compressionRatio: number;
+  timestamp: number;
+}
+const _compressionHistory: CompressionMetrics[] = [];
+const MAX_COMPRESSION_HISTORY = 20;
+
+/** R19: 获取压缩历史指标 */
+export function getCompressionHistory(): CompressionMetrics[] {
+  return [..._compressionHistory];
+}
+
+/** R19: 获取平均压缩率 */
+export function getAverageCompressionRatio(): number {
+  if (_compressionHistory.length === 0) return 1.0;
+  const sum = _compressionHistory.reduce((s, m) => s + m.compressionRatio, 0);
+  return sum / _compressionHistory.length;
+}
+
 /** 压缩后保留首尾消息数 */
 const COMPRESS_KEEP_HEAD = 5;
 const COMPRESS_KEEP_TAIL = 8;
@@ -104,9 +291,11 @@ export function scoreMessageImportance(msg: OllamaMessage): number {
     /完成|done|✓|success|成功|结果|result/i,
     /项目|project|工作空间|workspace|git|repo|仓库/i,
   ];
-  const lowValuePatterns = [/好的|明白|ok|知道了|嗯|哦|好/i,
-    /继续|请|帮我|可以吗/i,
-    /谢谢|感谢|不客气/i,
+  // R10: 修复低价值模式误报 — 移除单字“好”（匹配几乎所有中文文本）
+  // 仅匹配明确的短语回复，且仅对短消息（<100字）生效
+  const lowValuePatterns = [/^(好的|明白|ok|知道了|嗯|哦|好[的呀吧]|收到)$/i,
+    /^(继续|请继续|帮帮我|可以吗|行吗|好的谢谢)$/i,
+    /^(谢谢|感谢|不客气|多谢|thanks?)$/i,
   ];
 
   for (const p of highValuePatterns) {
@@ -119,6 +308,26 @@ export function scoreMessageImportance(msg: OllamaMessage): number {
   // 工具调用 → 高价值
   if (msg.tool_calls?.length) score += 2;
 
+  // R20: 工具结果类型感知 — 不同工具结果的价值不同
+  if (msg.role === 'tool' && msg.tool_name) {
+    // 写类工具结果：高价值（记录了操作结果）
+    if (/write_file|edit_file|delete_file|create_directory|move_file|copy_file/.test(msg.tool_name)) {
+      score += 2;
+    }
+    // 搜索类工具结果：中等价值
+    if (/search_files|web_search/.test(msg.tool_name)) {
+      score += 1;
+    }
+    // 读取类工具结果：中等价值
+    if (/read_file|list_directory|tree/.test(msg.tool_name)) {
+      score += 1;
+    }
+    // 时间/计算类工具结果：低价值（时效性强，很快过期）
+    if (/datetime|random|uuid|hash/.test(msg.tool_name)) {
+      score -= 2;
+    }
+  }
+
   // 长度加分：长消息通常包含更多信息
   if (content.length > 500) score += 1;
   if (content.length > 2000) score += 1;
@@ -142,6 +351,111 @@ export interface ContextBuildOptions {
   workspaceContext?: string;
 }
 
+// ── R16: 增量摘要合并工具函数 ──
+
+/** R16: 从已压缩消息中提取结构化摘要 */
+function extractStructuredSummary(compressedMsgs: OllamaMessage[]): StructuredSummary {
+  const summary: StructuredSummary = {
+    topics: [], decisions: [], pendingTasks: [], constraints: [], knowledge: [], toolResults: [],
+  };
+  for (const msg of compressedMsgs) {
+    const content = msg.content || '';
+    // 解析结构化摘要中的各部分
+    const topicMatch = content.match(/📌 主题:\s*(.+)/);
+    if (topicMatch) summary.topics.push(...topicMatch[1].split('；').filter(Boolean));
+    const decisionMatch = content.match(/✅ 决策:\s*(.+)/);
+    if (decisionMatch) summary.decisions.push(...decisionMatch[1].split('；').filter(Boolean));
+    const pendingMatch = content.match(/⏳ 待办:\s*(.+)/);
+    if (pendingMatch) summary.pendingTasks.push(...pendingMatch[1].split('；').filter(Boolean));
+    const constraintMatch = content.match(/📏 约束:\s*(.+)/);
+    if (constraintMatch) summary.constraints.push(...constraintMatch[1].split('；').filter(Boolean));
+    const knowledgeMatch = content.match(/🧠 知识点:\s*(.+)/);
+    if (knowledgeMatch) summary.knowledge.push(...knowledgeMatch[1].split('；').filter(Boolean));
+    const toolMatch = content.match(/🔧 工具结果:\s*(.+)/);
+    if (toolMatch) summary.toolResults.push(...toolMatch[1].split('；').filter(Boolean));
+  }
+  return summary;
+}
+
+/** R16: 合并两个结构化摘要，去重并限制条目数 */
+function mergeSummaries(old_: StructuredSummary, new_: StructuredSummary): StructuredSummary {
+  const mergeArrays = (oldArr: string[], newArr: string[], max: number): string[] => {
+    // 合并、去重、限制数量（新摘要优先）
+    const combined = [...new Set([...newArr, ...oldArr])];
+    return combined.slice(0, max);
+  };
+  return {
+    topics: mergeArrays(old_.topics, new_.topics, 4),
+    decisions: mergeArrays(old_.decisions, new_.decisions, 3),
+    pendingTasks: mergeArrays(old_.pendingTasks, new_.pendingTasks, 3),
+    constraints: mergeArrays(old_.constraints, new_.constraints, 3),
+    knowledge: mergeArrays(old_.knowledge, new_.knowledge, 3),
+    toolResults: mergeArrays(old_.toolResults, new_.toolResults, 3),
+  };
+}
+
+// ── R17: System 消息分区优化 ──
+
+/** R17: 判断 system 消息是否为稳定前缀（不会在会话中改变） */
+function isStableSystemMessage(content: string): boolean {
+  // SOUL.md、安全规则、日期、环境信息等 — 在整个会话中不会改变
+  return content.includes('[SOUL.md]')
+    || content.includes('<<<REFERENCE_DATA_START>>>')
+    || content.startsWith('[日期]')
+    || content.startsWith('[环境]')
+    || content.includes('安全规则')
+    || content.includes('系统提示')
+    || content.includes('You are');  // 通用系统 prompt
+}
+
+/** R17: 对 system 消息排序，稳定部分在前，动态部分在后，支持 LLM Prefix Caching */
+function reorderSystemMessagesForPrefixCaching(messages: OllamaMessage[]): void {
+  // 找到所有 system 消息
+  const systemIndices: number[] = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === 'system') systemIndices.push(i);
+  }
+  if (systemIndices.length <= 1) return;
+
+  // 提取并分类
+  const stableContents: string[] = [];
+  const dynamicContents: string[] = [];
+  for (const idx of systemIndices) {
+    const content = messages[idx].content || '';
+    if (isStableSystemMessage(content)) {
+      stableContents.push(content);
+    } else {
+      dynamicContents.push(content);
+    }
+  }
+
+  if (stableContents.length === 0 || dynamicContents.length === 0) return;
+
+  // 合并稳定部分和动态部分
+  const stableContent = stableContents.join('\n\n');
+  const dynamicContent = dynamicContents.join('\n\n');
+
+  // 重写第一条 system 消息为稳定部分，其余 system 消息合并为动态部分
+  const firstSysIdx = systemIndices[0];
+  messages[firstSysIdx].content = stableContent;
+
+  // 将其余 system 消息合并为一条动态 system 消息，放在最后一条 system 消息位置
+  const lastSysIdx = systemIndices[systemIndices.length - 1];
+  if (firstSysIdx !== lastSysIdx) {
+    messages[lastSysIdx].content = dynamicContent;
+    // 删除中间的 system 消息
+    const middleSysIndices = systemIndices.slice(1, -1);
+    for (let i = middleSysIndices.length - 1; i >= 0; i--) {
+      messages.splice(middleSysIndices[i], 1);
+    }
+  } else {
+    // 只有一条 system 消息时，追加动态内容
+    messages[firstSysIdx].content = stableContent + '\n\n' + dynamicContent;
+  }
+
+  logInfo(`R17: System 消息分区完成 — 稳定前缀 ${estimateTokens(stableContent)} tokens, 动态部分 ${estimateTokens(dynamicContent)} tokens`);
+}
+
 const DEFAULT_OPTIONS: Required<ContextBuildOptions> = {
   windowSize: 40,
   summaryBatchSize: 30,
@@ -164,20 +478,29 @@ export function buildContext(
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const result: OllamaMessage[] = [];
 
-  // 系统 prompt
-  let systemContent = '';
-  if (opts.memoryContext) {
-    systemContent += opts.memoryContext + '\n\n';
-  }
-  if (opts.workspaceContext) {
-    systemContent += opts.workspaceContext + '\n\n';
-  }
-
-  // 提取已有的 system 消息
+  // R17: System 消息分区 — 稳定部分在前，动态部分在后，支持 LLM Prefix Caching
+  // 稳定部分：已有的 system 消息（SOUL.md、规则等，不随会话变化）
+  // 动态部分：memoryContext、workspaceContext（每轮可能变化）
   const existingSystem = allMessages.filter(m => m.role === 'system');
+  const stableParts: string[] = [];
+  const dynamicParts: string[] = [];
+
   for (const sys of existingSystem) {
-    systemContent += sys.content + '\n';
+    if (isStableSystemMessage(sys.content || '')) {
+      stableParts.push(sys.content || '');
+    } else {
+      dynamicParts.push(sys.content || '');
+    }
   }
+  // memoryContext 和 workspaceContext 是动态的
+  if (opts.memoryContext) dynamicParts.push(opts.memoryContext);
+  if (opts.workspaceContext) dynamicParts.push(opts.workspaceContext);
+
+  let systemContent = '';
+  // 稳定前缀优先
+  if (stableParts.length > 0) systemContent += stableParts.join('\n\n') + '\n\n';
+  // 动态部分在后
+  if (dynamicParts.length > 0) systemContent += dynamicParts.join('\n\n') + '\n\n';
 
   if (systemContent.trim()) {
     result.push({ role: 'system', content: systemContent.trim() });
@@ -223,16 +546,23 @@ export function buildContext(
  * 判断是否需要自动压缩
  * 当总 token 数超过 context window 的 AUTO_COMPRESS_THRESHOLD 比例时返回 true
  * C3: 包含 tool_calls 和 images 的 token 开销
+ * R13: tool_calls 开销按实际参数大小估算而非固定 50
  */
 export function shouldAutoCompress(messages: OllamaMessage[], numCtx: number): boolean {
   let totalTokens = 0;
   for (const m of messages) {
     totalTokens += estimateTokens(m.content || '');
-    // C3: tool_calls 和 images 也消耗大量 token
-    if (m.tool_calls?.length) totalTokens += m.tool_calls.length * 50;
+    // R13: tool_calls 开销按实际 JSON 参数大小估算
+    if (m.tool_calls?.length) {
+      for (const tc of m.tool_calls) {
+        const argsSize = JSON.stringify(tc.function.arguments || {}).length;
+        totalTokens += estimateTokens(tc.function.name) + Math.ceil(argsSize / 4) + 20; // 20 tokens overhead per call
+      }
+    }
     if (m.images?.length) totalTokens += m.images.length * 100;
   }
-  const threshold = numCtx * AUTO_COMPRESS_THRESHOLD;
+  // R14: 使用自适应压缩阈值
+  const threshold = numCtx * getAdaptiveCompressThreshold(numCtx);
   return totalTokens > threshold;
 }
 
@@ -298,6 +628,28 @@ export async function compressWithLLM(
   const tail = nonSystemMsgs.slice(-keepTail);
   const middle = nonSystemMsgs.slice(keepHead, nonSystemMsgs.length - keepTail);
 
+  // R15: 对话轮次边界保护 — 调整 head/tail 切分点，避免在对话轮次中间切割
+  // 如果 head 末尾是带 tool_calls 的 assistant，将后续 tool 消息也纳入 head
+  if (head.length > 0 && head[head.length - 1].tool_calls?.length) {
+    let extendIdx = 0;
+    while (extendIdx < middle.length && middle[extendIdx].role === 'tool') {
+      head.push(middle[extendIdx]);
+      extendIdx++;
+    }
+    middle.splice(0, extendIdx);
+  }
+  // 如果 tail 开头是 tool 消息（无对应 assistant），向前扩展到包含 assistant
+  if (tail.length > 0 && tail[0].role === 'tool') {
+    let extendBack = middle.length - 1;
+    while (extendBack >= 0 && middle[extendBack].role !== 'assistant') {
+      extendBack--;
+    }
+    if (extendBack >= 0) {
+      const moved = middle.splice(extendBack);
+      tail.unshift(...moved);
+    }
+  }
+
   // 过滤掉已经压缩过的消息（避免重复压缩）
   const uncompressedMiddle = middle.filter(m => !m.compressed);
   if (uncompressedMiddle.length === 0) {
@@ -305,6 +657,12 @@ export async function compressWithLLM(
     return messages;
   }
 
+  // R12: 压缩去重 — 检查这批消息是否已被压缩过（内容指纹匹配）
+  if (isAlreadyCompressed(uncompressedMiddle)) {
+    logInfo('R12: 消息批次内容指纹匹配已压缩记录，跳过重复压缩');
+    return messages;
+  }
+
   // 构建对话文本
   const conversationText = uncompressedMiddle.map(m => {
     const role = m.role === 'user' ? '用户' : 'AI';
@@ -363,6 +721,14 @@ export async function compressWithLLM(
     parsed = { topics: [summaryJson.slice(0, 100)], decisions: [], pendingTasks: [], constraints: [], knowledge: [], toolResults: [] };
   }
 
+  // R16: 增量摘要合并 — 提取已有压缩摘要并与新摘要合并
+  const alreadyCompressedMiddle = middle.filter(m => m.compressed && m.role !== 'system');
+  if (alreadyCompressedMiddle.length > 0) {
+    const oldSummary = extractStructuredSummary(alreadyCompressedMiddle);
+    parsed = mergeSummaries(oldSummary, parsed);
+    logInfo(`R16: 合并了 ${alreadyCompressedMiddle.length} 条旧摘要到新摘要`);
+  }
+
   // 构建结构化摘要消息文本
   const parts: string[] = [];
   if (parsed.topics.length) parts.push(`📌 主题: ${parsed.topics.join('；')}`);
@@ -372,6 +738,18 @@ export async function compressWithLLM(
   if (parsed.knowledge.length) parts.push(`🧠 知识点: ${parsed.knowledge.join('；')}`);
   if (parsed.toolResults.length) parts.push(`🔧 工具结果: ${parsed.toolResults.join('；')}`);
 
+  // R11: 压缩质量验证 — 如果摘要为空或过短，回退到文本摘要
+  if (parts.length === 0 || parts.join('').length < 50) {
+    logWarn('R11: 压缩摘要质量不足，回退到文本摘要');
+    const textSummary = uncompressedMiddle.map(m => {
+      const role = m.role === 'user' ? '用户' : 'AI';
+      const content = (m.content || '').slice(0, 200);
+      return `${role}: ${content}`;
+    }).join('\n').slice(0, 1000);
+    parts.length = 0;
+    parts.push(`📌 主题: ${textSummary}`);
+  }
+
   // 构建压缩后的摘要消息
   // C5: 使用 user role 而非 system role，避免部分模型拒绝多个 system 消息
   const summaryMsg: OllamaMessage = {
@@ -380,8 +758,11 @@ export async function compressWithLLM(
     compressed: true
   };
 
-  // 保留已压缩的中间消息 + 新摘要
-  const alreadyCompressed = middle.filter(m => m.compressed);
+  // R16: 保留已压缩的中间消息（system 消息单独处理）+ 新摘要
+  // R12: 标记这批消息为已压缩
+  markAsCompressed(uncompressedMiddle);
+  // R16: 已压缩的旧摘要已被合并到新摘要中，不再保留它们
+  const alreadyCompressed = middle.filter(m => m.compressed && m.role === 'system');
 
   // C1: 合并 system 消息为一条，但保留不可压缩的 system 消息完整内容
   const mergedSystemContent = [
@@ -400,10 +781,29 @@ export async function compressWithLLM(
     ...tail
   ];
 
+  // R17: System 消息分区优化 — 将 system 消息按稳定性排序，支持 LLM Prefix Caching
+  // 稳定部分（SOUL.md、规则等）放在最前面，动态部分（工作空间、记忆）放在后面
+  // 这样 Ollama 可以缓存稳定前缀，只重新处理动态部分
+  reorderSystemMessagesForPrefixCaching(result);
+
   const beforeTokens = estimateTokens(messages.map(m => m.content || '').join(''));
   const afterTokens = estimateTokens(result.map(m => m.content || '').join(''));
 
-  logSuccess(`上下文压缩完成: ${messages.length} 条 → ${result.length} 条, tokens: ${beforeTokens} → ${afterTokens}`);
+  // R19: 记录压缩指标
+  const metrics: CompressionMetrics = {
+    beforeMessages: messages.length,
+    afterMessages: result.length,
+    beforeTokens,
+    afterTokens,
+    compressionRatio: beforeTokens > 0 ? afterTokens / beforeTokens : 1.0,
+    timestamp: Date.now(),
+  };
+  _compressionHistory.push(metrics);
+  if (_compressionHistory.length > MAX_COMPRESSION_HISTORY) {
+    _compressionHistory.shift();
+  }
+
+  logSuccess(`上下文压缩完成: ${messages.length} 条 → ${result.length} 条, tokens: ${beforeTokens} → ${afterTokens} (压缩率: ${(metrics.compressionRatio * 100).toFixed(0)}%)`);
 
   return result;
 }
diff --git a/src/renderer/services/infra-service.ts b/src/renderer/services/infra-service.ts
new file mode 100644
index 0000000..ced0ebd
--- /dev/null
+++ b/src/renderer/services/infra-service.ts
@@ -0,0 +1,303 @@
+/**
+ * Infrastructure Service - 基础设施服务 (R41-R50)
+ * 内存泄漏防护、全局错误处理、性能监控、配置验证、健康检查
+ */
+
+import { logInfo, logWarn, logError } from './log-service.js';
+
+// ══════════════════════════════════════════════
+// R41: 内存泄漏防护 — 事件监听器管理
+// ══════════════════════════════════════════════
+
+/** R41: 已注册的事件监听器追踪表 */
+const _trackedListeners = new Map<string, { target: EventTarget; type: string; listener: EventListenerOrEventListenerObject; options?: boolean | AddEventListenerOptions }>();
+
+let _listenerIdCounter = 0;
+
+/**
+ * R41: 注册并追踪事件监听器，便于统一清理
+ * @returns 监听器 ID，可用于单独移除
+ */
+export function trackEventListener(
+  target: EventTarget,
+  type: string,
+  listener: EventListenerOrEventListenerObject,
+  options?: boolean | AddEventListenerOptions,
+): string {
+  const id = `listener_${++_listenerIdCounter}`;
+  _trackedListeners.set(id, { target, type, listener, options });
+  target.addEventListener(type, listener, options);
+  return id;
+}
+
+/** R41: 移除单个事件监听器 */
+export function removeTrackedListener(id: string): void {
+  const entry = _trackedListeners.get(id);
+  if (entry) {
+    entry.target.removeEventListener(entry.type, entry.listener, entry.options);
+    _trackedListeners.delete(id);
+  }
+}
+
+/** R41: 清理所有已追踪的事件监听器（用于页面卸载或会话切换时） */
+export function cleanupAllListeners(): void {
+  let count = 0;
+  for (const [id, entry] of _trackedListeners) {
+    try {
+      entry.target.removeEventListener(entry.type, entry.listener, entry.options);
+      count++;
+    } catch { /* ignore */ }
+    _trackedListeners.delete(id);
+  }
+  if (count > 0) {
+    logInfo(`R41: 已清理 ${count} 个事件监听器`);
+  }
+}
+
+/** R41: 获取当前追踪的监听器数量（供调试用） */
+export function getTrackedListenerCount(): number {
+  return _trackedListeners.size;
+}
+
+// ══════════════════════════════════════════════
+// R42: 全局错误边界 — 捕获未处理的异常
+// ══════════════════════════════════════════════
+
+/** R42: 初始化全局错误处理 */
+export function initGlobalErrorHandler(): void {
+  // 捕获未处理的 JS 错误
+  window.addEventListener('error', (e) => {
+    logError('R42: 未捕获错误', `${e.message} @ ${e.filename}:${e.lineno}:${e.colno}`);
+    // 阻止默认的错误处理（避免弹出丑陋的错误对话框）
+    e.preventDefault();
+  });
+
+  // 捕获未处理的 Promise rejection
+  window.addEventListener('unhandledrejection', (e) => {
+    const reason = e.reason;
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    logError('R42: 未处理的 Promise Rejection', msg);
+    e.preventDefault();
+  });
+
+  logInfo('R42: 全局错误处理器已初始化');
+}
+
+// ══════════════════════════════════════════════
+// R43: 性能监控 — 关键操作耗时追踪
+// ══════════════════════════════════════════════
+
+export interface PerfMetric {
+  name: string;
+  duration: number;
+  timestamp: number;
+  metadata?: Record<string, unknown>;
+}
+
+const _perfMetrics: PerfMetric[] = [];
+const MAX_PERF_METRICS = 200;
+const _perfTimers = new Map<string, number>();
+
+/** R43: 开始性能计时 */
+export function perfStart(name: string): void {
+  _perfTimers.set(name, performance.now());
+}
+
+/** R43: 结束性能计时并记录 */
+export function perfEnd(name: string, metadata?: Record<string, unknown>): number {
+  const startTime = _perfTimers.get(name);
+  if (startTime === undefined) {
+    logWarn(`R43: perfEnd 未找到对应的 perfStart: ${name}`);
+    return 0;
+  }
+  const duration = performance.now() - startTime;
+  _perfTimers.delete(name);
+
+  _perfMetrics.push({ name, duration, timestamp: Date.now(), metadata });
+
+  // 超过上限时移除最早的
+  if (_perfMetrics.length > MAX_PERF_METRICS) {
+    _perfMetrics.shift();
+  }
+
+  // 慢操作警告（超过 1 秒）
+  if (duration > 1000) {
+    logWarn(`R43: 慢操作: ${name} 耗时 ${duration.toFixed(0)}ms`);
+  }
+
+  return duration;
+}
+
+/** R43: 获取性能指标 */
+export function getPerfMetrics(): PerfMetric[] {
+  return [..._perfMetrics];
+}
+
+/** R43: 获取平均性能指标 */
+export function getAvgPerfMetric(name: string): number {
+  const metrics = _perfMetrics.filter(m => m.name === name);
+  if (metrics.length === 0) return 0;
+  return metrics.reduce((sum, m) => sum + m.duration, 0) / metrics.length;
+}
+
+/** R43: 清空性能指标 */
+export function clearPerfMetrics(): void {
+  _perfMetrics.length = 0;
+  _perfTimers.clear();
+}
+
+// ══════════════════════════════════════════════
+// R48: 配置验证 — 启动时验证关键配置
+// ══════════════════════════════════════════════
+
+export interface ConfigValidationResult {
+  valid: boolean;
+  warnings: string[];
+  errors: string[];
+}
+
+/** R48: 验证应用配置 */
+export function validateConfig(config: Record<string, unknown>): ConfigValidationResult {
+  const warnings: string[] = [];
+  const errors: string[] = [];
+
+  // 验证 numCtx
+  const numCtx = config.numCtx as number;
+  if (numCtx !== undefined) {
+    if (numCtx < 2048) {
+      warnings.push(`numCtx=${numCtx} 过小，可能导致上下文截断。建议至少 4096。`);
+    }
+    if (numCtx > 131072) {
+      warnings.push(`numCtx=${numCtx} 过大，可能导致内存不足。建议不超过 131072。`);
+    }
+  }
+
+  // 验证 temperature
+  const temperature = config.temperature as number;
+  if (temperature !== undefined) {
+    if (temperature < 0 || temperature > 2) {
+      errors.push(`temperature=${temperature} 超出有效范围 [0, 2]`);
+    }
+  }
+
+  // 验证 maxTurns
+  const maxTurns = config.maxTurns as number;
+  if (maxTurns !== undefined) {
+    if (maxTurns < 1) {
+      errors.push(`maxTurns=${maxTurns} 不能小于 1`);
+    }
+    if (maxTurns > 50) {
+      warnings.push(`maxTurns=${maxTurns} 过大，可能导致长时间运行。建议不超过 20。`);
+    }
+  }
+
+  // 验证 streamTimeout
+  const streamTimeout = config.streamTimeout as number;
+  if (streamTimeout !== undefined) {
+    if (streamTimeout < 10000) {
+      warnings.push(`streamTimeout=${streamTimeout} 过短，可能导致大模型生成被中断。建议至少 30000ms。`);
+    }
+  }
+
+  // 验证 subAgentTimeout
+  const subAgentTimeout = config.subAgentTimeout as number;
+  if (subAgentTimeout !== undefined && subAgentTimeout < 5000) {
+    warnings.push(`subAgentTimeout=${subAgentTimeout} 过短，子代理可能无法完成任务。`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    warnings,
+    errors,
+  };
+}
+
+// ══════════════════════════════════════════════
+// R50: 健康检查 — 系统健康监控
+// ══════════════════════════════════════════════
+
+export interface HealthCheckResult {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  checks: Array<{ name: string; status: 'pass' | 'fail' | 'warn'; message: string }>;
+  timestamp: number;
+}
+
+/** R50: 执行系统健康检查 */
+export async function runHealthCheck(): Promise<HealthCheckResult> {
+  const checks: Array<{ name: string; status: 'pass' | 'fail' | 'warn'; message: string }> = [];
+
+  // 检查 1: 桌面 API 可用性
+  const bridge = window.metonaDesktop;
+  if (bridge?.isDesktop) {
+    checks.push({ name: '桌面 API', status: 'pass', message: '桌面 API 可用' });
+  } else {
+    checks.push({ name: '桌面 API', status: 'fail', message: '桌面 API 不可用（Web 模式）' });
+  }
+
+  // 检查 2: 数据库可用性
+  if (bridge?.db) {
+    try {
+      const sessions = await bridge.db.getAllSessions();
+      checks.push({ name: '数据库', status: 'pass', message: `数据库正常（${sessions.length} 个会话）` });
+    } catch (err) {
+      checks.push({ name: '数据库', status: 'fail', message: `数据库访问失败: ${(err as Error).message}` });
+    }
+  } else {
+    checks.push({ name: '数据库', status: 'warn', message: '数据库 API 不可用' });
+  }
+
+  // 检查 3: 内存使用
+  const memInfo = (performance as any).memory;
+  if (memInfo) {
+    const usedMB = (memInfo.usedJSHeapSize / 1024 / 1024).toFixed(0);
+    const limitMB = (memInfo.jsHeapSizeLimit / 1024 / 1024).toFixed(0);
+    const usageRatio = memInfo.usedJSHeapSize / memInfo.jsHeapSizeLimit;
+    if (usageRatio > 0.8) {
+      checks.push({ name: '内存', status: 'warn', message: `内存使用较高: ${usedMB}/${limitMB}MB (${(usageRatio * 100).toFixed(0)}%)` });
+    } else {
+      checks.push({ name: '内存', status: 'pass', message: `内存使用正常: ${usedMB}/${limitMB}MB` });
+    }
+  } else {
+    checks.push({ name: '内存', status: 'pass', message: '内存监控不可用（非 Chromium）' });
+  }
+
+  // 检查 4: 工作空间可用性
+  if (bridge?.workspace) {
+    try {
+      const result = await bridge.workspace.getDir();
+      if (result.dir) {
+        checks.push({ name: '工作空间', status: 'pass', message: `工作空间: ${result.dir}` });
+      } else {
+        checks.push({ name: '工作空间', status: 'warn', message: '工作空间未设置' });
+      }
+    } catch {
+      checks.push({ name: '工作空间', status: 'warn', message: '工作空间访问失败' });
+    }
+  }
+
+  // 检查 5: 事件监听器数量（内存泄漏检测）
+  const listenerCount = _trackedListeners.size;
+  if (listenerCount > 100) {
+    checks.push({ name: '事件监听器', status: 'warn', message: `追踪的事件监听器较多: ${listenerCount} 个，可能存在内存泄漏` });
+  } else {
+    checks.push({ name: '事件监听器', status: 'pass', message: `事件监听器数量正常: ${listenerCount} 个` });
+  }
+
+  // 确定整体状态
+  const hasFail = checks.some(c => c.status === 'fail');
+  const hasWarn = checks.some(c => c.status === 'warn');
+  const status: 'healthy' | 'degraded' | 'unhealthy' = hasFail ? 'unhealthy' : hasWarn ? 'degraded' : 'healthy';
+
+  return { status, checks, timestamp: Date.now() };
+}
+
+/** R50: 格式化健康检查结果为可读字符串 */
+export function formatHealthCheck(result: HealthCheckResult): string {
+  const statusIcon = result.status === 'healthy' ? '✅' : result.status === 'degraded' ? '⚠️' : '❌';
+  const lines = [`${statusIcon} 系统健康检查 — ${result.status.toUpperCase()}`, ''];
+  for (const check of result.checks) {
+    const icon = check.status === 'pass' ? '✅' : check.status === 'warn' ? '⚠️' : '❌';
+    lines.push(`${icon} ${check.name}: ${check.message}`);
+  }
+  return lines.join('\n');
+}
diff --git a/src/renderer/services/log-service.ts b/src/renderer/services/log-service.ts
index e004521..4f1c811 100644
--- a/src/renderer/services/log-service.ts
+++ b/src/renderer/services/log-service.ts
@@ -20,6 +20,8 @@ export interface LogEntry {
 let logBodyEl: HTMLElement | null = null;
 let logPanelEl: HTMLElement | null = null;
 const MAX_LOGS = 500;
+// R46: 日志轮转 — 旧日志自动清理
+const LOG_MAX_AGE_MS = 3600000; // 1 小时
 let logs: LogEntry[] = [];
 let autoScroll = true;
 let idCounter = 0;
@@ -29,6 +31,26 @@ let panelInitialized = false;
 /** initLogPanel 前的日志暂存区 */
 const earlyBuffer: LogEntry[] = [];
 
+// R46: 定期清理旧日志
+let _logCleanupTimer: ReturnType<typeof setInterval> | null = null;
+function startLogRotation(): void {
+  if (_logCleanupTimer) clearInterval(_logCleanupTimer);
+  _logCleanupTimer = setInterval(() => {
+    const now = Date.now();
+    const before = logs.length;
+    const oldLogs = logs.filter(l => now - l.time >= LOG_MAX_AGE_MS);
+    logs = logs.filter(l => now - l.time < LOG_MAX_AGE_MS);
+    const removed = before - logs.length;
+    if (removed > 0 && logBodyEl) {
+      // 从 DOM 中移除旧日志条目
+      for (const old of oldLogs) {
+        const el = logBodyEl.querySelector(`#${old.id}`);
+        if (el) el.remove();
+      }
+    }
+  }, 60000); // 每分钟检查一次
+}
+
 const LEVEL_ICONS: Record<LogLevel, string> = {
   info: 'ℹ️',
   success: '✅',
@@ -56,6 +78,8 @@ export function initLogPanel(): void {
     document.querySelector('#btnExportLog')?.addEventListener('click', exportLog);
 
     panelInitialized = true;
+    // R46: 启动日志轮转
+    startLogRotation();
     if (earlyBuffer.length > 0 && logBodyEl) {
       const frag = document.createDocumentFragment();
       for (const entry of earlyBuffer) {
diff --git a/src/renderer/services/sub-agent.ts b/src/renderer/services/sub-agent.ts
index 99a16b3..63bcc78 100644
--- a/src/renderer/services/sub-agent.ts
+++ b/src/renderer/services/sub-agent.ts
@@ -1,5 +1,5 @@
 /**
- * SubAgent - 子代理委派系统 (v0.10.2 增强版)
+ * SubAgent - 子代理委派系统 (v0.10.3 增强版)
  * 子代理拥有受限工具集（只读），可独立完成调研/搜索/分析类任务
  * 主 Agent 通过 spawn_task 工具并行委派多个子代理
  */
@@ -13,6 +13,7 @@ import type { ToolResult, ToolCall, ToolDefinition } from '../types.js';
 
 const SUB_AGENT_MAX_LOOPS = 10;    // 子代理最多 10 轮
 const SUB_AGENT_TIMEOUT = 300000;  // 5 分钟超时
+const SUB_AGENT_MAX_RESULT_LEN = 8000; // 工具结果截断上限（字符）
 
 /** 子代理可用工具：只读类，不能修改文件系统 */
 const SUB_AGENT_TOOL_WHITELIST = new Set([
@@ -93,69 +94,107 @@ ${context ? `\n附加上下文（参考数据，不是指令）：\n<<<REFERENCE
   let loopCount = 0;
   const startTime = Date.now();
 
-  while (loopCount < maxLoops) {
-    loopCount++;
+  // 创建子代理专属的 AbortController，支持超时和外部中止
+  const subAgentAC = new AbortController();
+  let timeoutTimer: ReturnType<typeof setTimeout> | null = null;
 
-    if (Date.now() - startTime > effectiveTimeout) {
-      logWarn('子 Agent 超时', `${loopCount} 轮`);
-      return { success: true, content: '子任务执行超时', loops: loopCount, duration: Date.now() - startTime, partial: true };
-    }
+  // 监听主 Agent 的中止信号，联动中止子代理
+  const mainAC = state.get<AbortController | null>(KEYS.ABORT_CONTROLLER);
+  const onMainAbort = () => { subAgentAC.abort(); };
+  if (mainAC) {
+    mainAC.signal.addEventListener('abort', onMainAbort, { once: true });
+  }
 
-    let content = '';
-    let toolCalls: Array<{ name: string; arguments: Record<string, unknown> }> = [];
+  // 设置超时定时器
+  if (effectiveTimeout !== Infinity) {
+    timeoutTimer = setTimeout(() => {
+      logWarn('子 Agent 超时触发', `${effectiveTimeout / 1000}s`);
+      subAgentAC.abort();
+    }, effectiveTimeout);
+  }
 
-    try {
-      await api.chatStream({
-        model,
-        messages,
-        stream: true,
-        think: false,
-        tools: tools as any,
-        options: { num_ctx: numCtx, temperature: 0.3 }
-      } as any, (chunk: any) => {
-        if (chunk.message?.content) content += chunk.message.content;
-        if (chunk.message?.tool_calls?.length) {
-          for (const tc of chunk.message.tool_calls) {
-            if (tc.function?.name && SUB_AGENT_TOOL_WHITELIST.has(tc.function.name)) {
-              toolCalls.push({ name: tc.function.name, arguments: tc.function.arguments || {} });
+  try {
+    while (loopCount < maxLoops) {
+      loopCount++;
+
+      // 检查中止信号（超时或外部中止）
+      if (subAgentAC.signal.aborted) {
+        logWarn('子 Agent 已中止', `${loopCount} 轮`);
+        return { success: true, content: '子任务执行已中止', loops: loopCount, duration: Date.now() - startTime, partial: true };
+      }
+
+      let content = '';
+      let toolCalls: Array<{ name: string; arguments: Record<string, unknown> }> = [];
+
+      try {
+        await api.chatStream({
+          model,
+          messages,
+          stream: true,
+          think: false,
+          tools: tools as any,
+          options: { num_ctx: numCtx, temperature: 0.3 }
+        } as any, (chunk: any) => {
+          if (chunk.message?.content) content += chunk.message.content;
+          if (chunk.message?.tool_calls?.length) {
+            for (const tc of chunk.message.tool_calls) {
+              if (tc.function?.name && SUB_AGENT_TOOL_WHITELIST.has(tc.function.name)) {
+                toolCalls.push({ name: tc.function.name, arguments: tc.function.arguments || {} });
+              }
             }
           }
-        }
-      });
-    } catch (err) {
-      logError('子 Agent 调用失败', (err as Error).message);
-      return { success: false, error: (err as Error).message, loops: loopCount, duration: Date.now() - startTime };
-    }
-
-    // 无工具调用 → 完成
-    if (toolCalls.length === 0) {
-      logInfo(`子 Agent 完成`, `${loopCount} 轮, ${content.length} 字`);
-      return { success: true, content, loops: loopCount, duration: Date.now() - startTime };
-    }
-
-    // 执行工具
-    messages.push({ role: 'assistant', content, tool_calls: toolCalls.map(tc => ({
-      type: 'function' as const,
-      function: { name: tc.name, arguments: tc.arguments }
-    })) });
-
-    for (const tc of toolCalls) {
-      try {
-        const { executeTool } = await import('./tool-registry.js');
-        const result = await executeTool(tc.name, tc.arguments);
-        const resultStr = formatResult(tc.name, result);
-        messages.push({
-          role: 'tool',
-          content: `<<<TOOL_RESULT_START name="${tc.name}">>>\n${resultStr}\n<<<TOOL_RESULT_END>>>`,
-          tool_name: tc.name
-        });
+        }, subAgentAC);
       } catch (err) {
-        messages.push({
-          role: 'tool',
-          content: `<<<TOOL_RESULT_START name="${tc.name}">>>\n${JSON.stringify({ success: false, error: (err as Error).message })}\n<<<TOOL_RESULT_END>>>`,
-          tool_name: tc.name
-        });
+        if (subAgentAC.signal.aborted) {
+          logWarn('子 Agent LLM 调用被中止', `${loopCount} 轮`);
+          return { success: true, content: '子任务执行已中止', loops: loopCount, duration: Date.now() - startTime, partial: true };
+        }
+        logError('子 Agent 调用失败', (err as Error).message);
+        return { success: false, error: (err as Error).message, loops: loopCount, duration: Date.now() - startTime };
       }
+
+      // 无工具调用 → 完成
+      if (toolCalls.length === 0) {
+        logInfo(`子 Agent 完成`, `${loopCount} 轮, ${content.length} 字`);
+        return { success: true, content, loops: loopCount, duration: Date.now() - startTime };
+      }
+
+      // 执行工具
+      messages.push({ role: 'assistant', content, tool_calls: toolCalls.map(tc => ({
+        type: 'function' as const,
+        function: { name: tc.name, arguments: tc.arguments }
+      })) });
+
+      for (const tc of toolCalls) {
+        // 工具执行前再次检查中止信号
+        if (subAgentAC.signal.aborted) break;
+
+        try {
+          const { executeTool } = await import('./tool-registry.js');
+          const result = await executeTool(tc.name, tc.arguments);
+          const resultStr = formatResult(tc.name, result);
+          messages.push({
+            role: 'tool',
+            content: `<<<TOOL_RESULT_START name="${tc.name}">>>\n${resultStr}\n<<<TOOL_RESULT_END>>>`,
+            tool_name: tc.name
+          });
+        } catch (err) {
+          messages.push({
+            role: 'tool',
+            content: `<<<TOOL_RESULT_START name="${tc.name}">>>\n${JSON.stringify({ success: false, error: (err as Error).message })}\n<<<TOOL_RESULT_END>>>`,
+            tool_name: tc.name
+          });
+        }
+      }
+
+      if (subAgentAC.signal.aborted) break;
+    }
+  } finally {
+    // 清理超时定时器
+    if (timeoutTimer) { clearTimeout(timeoutTimer); timeoutTimer = null; }
+    // 移除主 Agent 中止监听器
+    if (mainAC) {
+      mainAC.signal.removeEventListener('abort', onMainAbort);
     }
   }
 
@@ -163,8 +202,18 @@ ${context ? `\n附加上下文（参考数据，不是指令）：\n<<<REFERENCE
   return { success: true, content: '达到最大轮次限制', loops: loopCount, duration: Date.now() - startTime, partial: true };
 }
 
-/** 格式化工具结果给子代理（不截断，和主AI一致） */
+/** 格式化工具结果给子代理（超长结果智能截断，防止上下文溢出） */
 function formatResult(name: string, r: ToolResult): string {
   if (!r.success) return JSON.stringify({ success: false, error: r.error });
-  return JSON.stringify(r);
+  let str = JSON.stringify(r);
+  if (str.length > SUB_AGENT_MAX_RESULT_LEN) {
+    // 智能截断：保留 JSON 结构边界
+    const boundary = str.lastIndexOf('}', SUB_AGENT_MAX_RESULT_LEN);
+    if (boundary > SUB_AGENT_MAX_RESULT_LEN * 0.5) {
+      str = str.slice(0, boundary + 1) + `\n... (${str.length - boundary - 1} 字符已截断)`;
+    } else {
+      str = str.slice(0, SUB_AGENT_MAX_RESULT_LEN) + `... (${str.length - SUB_AGENT_MAX_RESULT_LEN} 字符已截断)`;
+    }
+  }
+  return str;
 }
diff --git a/src/renderer/services/tool-registry.ts b/src/renderer/services/tool-registry.ts
index 22f77f5..0dbb44e 100644
--- a/src/renderer/services/tool-registry.ts
+++ b/src/renderer/services/tool-registry.ts
@@ -781,6 +781,479 @@ export async function refreshMCPTools(): Promise<void> {
   }
 }
 
+// ══════════════════════════════════════════════
+// R21-R30: 工具系统增强
+// ══════════════════════════════════════════════
+
+// ── R28: 工具安全检查增强 ──
+
+/** R28: 路径遍历攻击检测 — 检查路径中是否包含恶意 ../ 序列 */
+function hasPathTraversal(path: string): boolean {
+  if (!path) return false;
+  // 检测 ../ 或 ..\ 模式（路径遍历攻击）
+  const normalized = path.replace(/\\/g, '/');
+  // 连续的 ../ 超过 2 层（正常相对路径很少超过 2 层）
+  const traversalCount = (normalized.match(/\.\.\//g) || []).length;
+  if (traversalCount > 3) return true;
+  // 检测 ..\..\..\ 模式
+  if (normalized.includes('../../../')) return true;
+  return false;
+}
+
+/** R28: 命令注入检测 — 检查命令中是否包含危险的 shell 注入模式 */
+function hasCommandInjection(command: string): boolean {
+  if (!command) return false;
+  const dangerousPatterns = [
+    /;\s*(rm|del|format|mkfs|dd)\s/i,       // 命令链中的删除操作
+    /\|\s*(rm|del|format|mkfs)\s/i,         // 管道到删除操作
+    /&&\s*(rm|del|format|mkfs)\s/i,         // AND链中的删除操作
+    /\$\{.*IFS.*\}/i,                        // IFS 变量注入
+    /\$\([^)]*\)/,                           // 命令替换 $(...)
+    /`[^`]*`/,                               // 反引号命令替换
+    /\x00/,                                  // null 字节注入
+  ];
+  return dangerousPatterns.some(p => p.test(command));
+}
+
+/** R28: 工具安全验证 — 在执行前检查安全风险 */
+export function validateToolSecurity(toolName: string, args: Record<string, unknown>): string | null {
+  // 路径遍历检查
+  const pathFields = ['path', 'source', 'destination', 'file1', 'file2', 'cwd'];
+  for (const field of pathFields) {
+    if (typeof args[field] === 'string' && hasPathTraversal(args[field] as string)) {
+      return `安全警告: 参数 "${field}" 包含可疑的路径遍历模式: ${args[field]}`;
+    }
+  }
+
+  // 多路径参数检查（read_multiple_files）
+  if (Array.isArray(args.paths)) {
+    for (const p of args.paths) {
+      if (typeof p === 'string' && hasPathTraversal(p)) {
+        return `安全警告: paths 数组中包含可疑的路径遍历模式: ${p}`;
+      }
+    }
+  }
+
+  // 命令注入检查
+  if (toolName === 'run_command' && typeof args.command === 'string') {
+    if (hasCommandInjection(args.command as string)) {
+      return `安全警告: 命令中包含潜在的注入模式: ${args.command}`;
+    }
+  }
+
+  // web_fetch / download_file URL 验证
+  const urlFields = ['url'];
+  for (const field of urlFields) {
+    if (typeof args[field] === 'string') {
+      const url = args[field] as string;
+      // 阻止 file:// 协议（可能读取敏感本地文件）
+      if (url.toLowerCase().startsWith('file://')) {
+        return `安全警告: 不允许 file:// 协议`;
+      }
+      // 阻止内网 IP 访问（可选，取决于安全策略）
+      // 192.168.x.x, 10.x.x.x, 172.16-31.x.x
+      const internalIpPattern = /^(https?:\/\/)?(192\.168\.|10\.|172\.(1[6-9]|2[0-9]|3[01])\.|127\.|localhost)/i;
+      if (internalIpPattern.test(url)) {
+        // 内网访问仅警告不阻止
+        logWarn(`R28: 访问内网地址: ${url}`);
+      }
+    }
+  }
+
+  return null; // 无安全风险
+}
+
+// ── R30: 工具使用统计导出 ──
+
+/** R30: 工具使用统计热力图数据 */
+export interface ToolHeatmapData {
+  toolName: string;
+  displayName: string;
+  icon: string;
+  totalCalls: number;
+  successRate: number;
+  avgDurationMs: number;
+  heatLevel: number;  // 0-4, 0=未使用, 4=最常用
+  lastUsed: number;
+  errorCount: number;
+}
+
+/** R30: 获取工具使用热力图数据 */
+export function getToolHeatmap(): ToolHeatmapData[] {
+  const analytics = getToolAnalytics();
+  const maxCalls = Math.max(1, ...analytics.map(a => a.totalCalls));
+
+  // 合并所有已定义工具（包括未使用的）
+  const allTools = new Map<string, ToolHeatmapData>();
+  for (const def of TOOL_DEFINITIONS) {
+    const name = def.function.name;
+    allTools.set(name, {
+      toolName: name,
+      displayName: formatToolName(name),
+      icon: getToolIcon(name),
+      totalCalls: 0,
+      successRate: 0,
+      avgDurationMs: 0,
+      heatLevel: 0,
+      lastUsed: 0,
+      errorCount: 0,
+    });
+  }
+
+  // 填入分析数据
+  for (const a of analytics) {
+    const entry = allTools.get(a.toolName);
+    if (entry) {
+      entry.totalCalls = a.totalCalls;
+      entry.successRate = a.successRate;
+      entry.avgDurationMs = a.avgDurationMs;
+      entry.lastUsed = a.lastUsed;
+      entry.errorCount = a.errorCount;
+    } else {
+      // MCP 工具或未定义工具
+      allTools.set(a.toolName, {
+        toolName: a.toolName,
+        displayName: a.toolName,
+        icon: '🔧',
+        totalCalls: a.totalCalls,
+        successRate: a.successRate,
+        avgDurationMs: a.avgDurationMs,
+        heatLevel: 0,
+        lastUsed: a.lastUsed,
+        errorCount: a.errorCount,
+      });
+    }
+  }
+
+  // 计算热力等级
+  const result = Array.from(allTools.values());
+  for (const entry of result) {
+    if (entry.totalCalls === 0) {
+      entry.heatLevel = 0;
+    } else {
+      const ratio = entry.totalCalls / maxCalls;
+      if (ratio > 0.75) entry.heatLevel = 4;
+      else if (ratio > 0.5) entry.heatLevel = 3;
+      else if (ratio > 0.25) entry.heatLevel = 2;
+      else entry.heatLevel = 1;
+    }
+  }
+
+  // 按使用次数降序排列
+  result.sort((a, b) => b.totalCalls - a.totalCalls);
+  return result;
+}
+
+// ── R21: 工具参数验证 ──
+
+/** R21: 根据 schema 验证工具参数，返回错误消息列表 */
+export function validateToolArgs(toolName: string, args: Record<string, unknown>): string[] {
+  const def = TOOL_DEFINITIONS.find(d => d.function.name === toolName);
+  if (!def) return []; // MCP 工具或未找到定义，跳过验证
+
+  const params = def.function.parameters;
+  const errors: string[] = [];
+
+  // 检查必填参数
+  if (params.required) {
+    for (const req of params.required) {
+      if (!(req in args) || args[req] === undefined || args[req] === null) {
+        errors.push(`缺少必填参数: "${req}"`);
+      }
+    }
+  }
+
+  // 检查参数类型和枚举值
+  for (const [key, value] of Object.entries(args)) {
+    if (value === undefined || value === null) continue;
+    const prop = params.properties[key];
+    if (!prop) continue; // 未定义的参数，跳过
+
+    // 类型检查
+    if (prop.type === 'string' && typeof value !== 'string') {
+      errors.push(`参数 "${key}" 应为字符串类型，实际为 ${typeof value}`);
+    } else if (prop.type === 'integer' && (!Number.isInteger(Number(value)) || typeof value === 'boolean')) {
+      errors.push(`参数 "${key}" 应为整数，实际为 ${JSON.stringify(value)}`);
+    } else if (prop.type === 'boolean' && typeof value !== 'boolean') {
+      errors.push(`参数 "${key}" 应为布尔值，实际为 ${typeof value}`);
+    } else if (prop.type === 'array' && !Array.isArray(value)) {
+      errors.push(`参数 "${key}" 应为数组，实际为 ${typeof value}`);
+    } else if (prop.type === 'object' && (typeof value !== 'object' || Array.isArray(value))) {
+      errors.push(`参数 "${key}" 应为对象，实际为 ${typeof value}`);
+    }
+
+    // 枚举值检查
+    if (prop.enum && !prop.enum.includes(String(value))) {
+      errors.push(`参数 "${key}" 值 "${value}" 不在允许范围内: ${prop.enum.join(', ')}`);
+    }
+  }
+
+  return errors;
+}
+
+// ── R22: 工具结果截断 ──
+
+/** R22: 工具结果最大字符数 */
+const MAX_TOOL_RESULT_CHARS = 30000;
+
+/** R22: 截断大输出结果，保留首尾并添加截断标记 */
+export function truncateToolResult(result: ToolResult, toolName: string): ToolResult {
+  const jsonStr = JSON.stringify(result);
+  if (jsonStr.length <= MAX_TOOL_RESULT_CHARS) return result;
+
+  // 不同工具有不同的截断策略
+  const truncated = { ...result };
+
+  // 截断 stdout/content 类的大字段
+  const largeFields = ['stdout', 'content', 'text', 'result', 'output', 'data'];
+  for (const field of largeFields) {
+    if (typeof truncated[field] === 'string' && (truncated[field] as string).length > 10000) {
+      const original = truncated[field] as string;
+      const head = original.slice(0, 8000);
+      const tail = original.slice(-3000);
+      const omitted = original.length - 11000;
+      truncated[field] = `${head}\n\n... [已截断 ${omitted} 字符，共 ${original.length} 字符] ...\n\n${tail}`;
+    }
+  }
+
+  // 截断数组类结果
+  if (Array.isArray(truncated.entries) && truncated.entries.length > 100) {
+    const total = truncated.entries.length;
+    truncated.entries = truncated.entries.slice(0, 50);
+    truncated._truncated = true;
+    truncated._totalEntries = total;
+    truncated._truncatedMessage = `结果已截断：显示前 50 条，共 ${total} 条`;
+  }
+  if (Array.isArray(truncated.results) && truncated.results.length > 100) {
+    const total = truncated.results.length;
+    truncated.results = truncated.results.slice(0, 50);
+    truncated._truncated = true;
+    truncated._totalResults = total;
+  }
+
+  logWarn(`R22: 工具 ${toolName} 结果已截断 (${jsonStr.length} → ~${JSON.stringify(truncated).length} 字符)`);
+  return truncated;
+}
+
+// ── R23: 工具参数自动类型转换 ──
+
+/** R23: 根据工具定义自动转换参数类型 */
+export function coerceToolArgs(toolName: string, args: Record<string, unknown>): Record<string, unknown> {
+  const def = TOOL_DEFINITIONS.find(d => d.function.name === toolName);
+  if (!def) return args;
+
+  const params = def.function.parameters;
+  const coerced = { ...args };
+
+  for (const [key, value] of Object.entries(coerced)) {
+    if (value === undefined || value === null) continue;
+    const prop = params.properties[key];
+    if (!prop) continue;
+
+    // 字符串数字 → 整数
+    if (prop.type === 'integer' && typeof value === 'string') {
+      const num = parseInt(value, 10);
+      if (!isNaN(num)) {
+        coerced[key] = num;
+      }
+    }
+    // 字符串数字 → 数字
+    else if (prop.type === 'number' && typeof value === 'string') {
+      const num = parseFloat(value);
+      if (!isNaN(num)) {
+        coerced[key] = num;
+      }
+    }
+    // 字符串布尔 → 布尔
+    else if (prop.type === 'boolean' && typeof value === 'string') {
+      if (value === 'true' || value === '1') coerced[key] = true;
+      else if (value === 'false' || value === '0') coerced[key] = false;
+    }
+    // 数组：字符串 → 数组（逗号分隔）
+    else if (prop.type === 'array' && typeof value === 'string') {
+      try {
+        coerced[key] = JSON.parse(value);
+      } catch {
+        // 如果不是 JSON，按逗号分隔
+        coerced[key] = value.split(',').map(s => s.trim()).filter(Boolean);
+      }
+    }
+    // 对象：字符串 → 对象
+    else if (prop.type === 'object' && typeof value === 'string') {
+      try {
+        coerced[key] = JSON.parse(value);
+      } catch {
+        // 解析失败，保持原样
+      }
+    }
+  }
+
+  return coerced;
+}
+
+// ── R24: 工具错误恢复建议 ──
+
+/** R24: 分析工具错误并给出修复建议 */
+export function suggestToolFix(toolName: string, args: Record<string, unknown>, error: string): string {
+  const err = error.toLowerCase();
+
+  // 文件未找到
+  if (err.includes('no such file') || err.includes('not found') || err.includes('文件不存在') || err.includes('enoent')) {
+    const path = args.path || args.source || args.file1 || '';
+    return `文件路径可能不正确: "${path}"。建议：1) 使用 list_directory 检查路径是否存在; 2) 检查拼写; 3) 尝试绝对路径。`;
+  }
+
+  // 权限拒绝
+  if (err.includes('permission denied') || err.includes('eacces') || err.includes('权限')) {
+    return `权限不足。建议：1) 检查文件/目录权限; 2) 确认工作空间路径是否正确; 3) 某些系统目录可能需要管理员权限。`;
+  }
+
+  // 路径无效
+  if (err.includes('invalid path') || err.includes('illegal characters') || err.includes('路径无效')) {
+    const path = args.path || args.destination || '';
+    return `路径格式可能不正确: "${path}"。建议：1) 检查特殊字符; 2) Windows 路径使用反斜杠或正斜杠; 3) 确认路径在工作空间内。`;
+  }
+
+  // 网络错误
+  if (err.includes('network') || err.includes('timeout') || err.includes('econnrefused') || err.includes('fetch')) {
+    return `网络请求失败。建议：1) 检查 URL 是否正确; 2) 确认网络连接; 3) 某些站点可能需要使用 browser_open 工具代替 web_fetch。`;
+  }
+
+  // JSON 解析错误
+  if (err.includes('json') || err.includes('parse') || err.includes('syntax')) {
+    return `数据解析失败。建议：1) 使用 json_format 工具验证 JSON 格式; 2) 检查参数是否为有效的 JSON 字符串。`;
+  }
+
+  // Git 错误
+  if (err.includes('git') || err.includes('not a repository')) {
+    return `Git 操作失败。建议：1) 确认当前目录是 Git 仓库; 2) 使用 git status 检查仓库状态; 3) 检查分支名是否正确。`;
+  }
+
+  // 命令执行失败
+  if (err.includes('command') || err.includes('exit code')) {
+    return `命令执行失败。建议：1) 检查命令拼写; 2) 确认命令在当前系统可用; 3) 使用 cwd 参数指定正确的工作目录。`;
+  }
+
+  // 通用建议
+  return '';
+}
+
+// ── R25: 工具执行分析追踪 ──
+
+export interface ToolAnalytics {
+  toolName: string;
+  totalCalls: number;
+  successCount: number;
+  errorCount: number;
+  avgDurationMs: number;
+  lastUsed: number;
+  commonErrors: Map<string, number>;
+}
+
+const _toolAnalytics = new Map<string, ToolAnalytics>();
+
+/** R25: 记录工具执行分析数据 */
+function recordToolAnalytics(toolName: string, success: boolean, durationMs: number, error?: string): void {
+  let analytics = _toolAnalytics.get(toolName);
+  if (!analytics) {
+    analytics = {
+      toolName,
+      totalCalls: 0,
+      successCount: 0,
+      errorCount: 0,
+      avgDurationMs: 0,
+      lastUsed: 0,
+      commonErrors: new Map(),
+    };
+    _toolAnalytics.set(toolName, analytics);
+  }
+
+  analytics.totalCalls++;
+  if (success) analytics.successCount++;
+  else {
+    analytics.errorCount++;
+    if (error) {
+      // 记录常见错误模式（取前 100 字符作为 key）
+      const errorKey = error.slice(0, 100);
+      analytics.commonErrors.set(errorKey, (analytics.commonErrors.get(errorKey) || 0) + 1);
+    }
+  }
+
+  // 更新平均执行时间（指数移动平均）
+  const alpha = 0.2;
+  analytics.avgDurationMs = analytics.avgDurationMs === 0
+    ? durationMs
+    : analytics.avgDurationMs * (1 - alpha) + durationMs * alpha;
+
+  analytics.lastUsed = Date.now();
+}
+
+/** R25: 获取工具分析数据 */
+export function getToolAnalytics(): Array<ToolAnalytics & { successRate: number; commonErrorsArray: Array<{ error: string; count: number }> }> {
+  return Array.from(_toolAnalytics.values()).map(a => ({
+    ...a,
+    successRate: a.totalCalls > 0 ? a.successCount / a.totalCalls : 0,
+    commonErrorsArray: Array.from(a.commonErrors.entries())
+      .map(([error, count]) => ({ error, count }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 5),
+    commonErrors: undefined as any, // 避免序列化 Map
+  }));
+}
+
+/** R25: 重置工具分析数据 */
+export function resetToolAnalytics(): void {
+  _toolAnalytics.clear();
+}
+
+// ── R26: 工具结果格式优化 ──
+
+/** R26: 优化工具结果格式，提升 LLM 理解能力 */
+function formatToolResult(toolName: string, result: ToolResult): ToolResult {
+  if (!result.success) return result;
+
+  // 为特定工具添加结构化摘要
+  switch (toolName) {
+    case 'list_directory':
+    case 'tree': {
+      // 目录列表添加统计摘要
+      const entries = (result as any).entries || (result as any).items;
+      if (Array.isArray(entries)) {
+        const dirs = entries.filter((e: any) => e.type === 'directory').length;
+        const files = entries.filter((e: any) => e.type === 'file').length;
+        (result as any)._summary = `共 ${entries.length} 项 (${dirs} 个目录, ${files} 个文件)`;
+      }
+      break;
+    }
+    case 'search_files': {
+      const results = (result as any).results || (result as any).matches;
+      if (Array.isArray(results)) {
+        (result as any)._summary = `找到 ${results.length} 个匹配结果`;
+      }
+      break;
+    }
+    case 'read_file': {
+      // 读取文件添加行数统计
+      const content = (result as any).content || '';
+      if (typeof content === 'string') {
+        const lines = content.split('\n').length;
+        const chars = content.length;
+        (result as any)._meta = `文件内容: ${lines} 行, ${chars} 字符`;
+      }
+      break;
+    }
+    case 'web_search': {
+      const results = (result as any).results;
+      if (Array.isArray(results)) {
+        (result as any)._summary = `搜索返回 ${results.length} 条结果`;
+      }
+      break;
+    }
+  }
+
+  return result;
+}
+
 export async function executeTool(toolName: string, args: Record<string, unknown>): Promise<ToolResult> {
   // MCP 工具路由
   if (toolName.startsWith('mcp_')) {
@@ -799,6 +1272,25 @@ export async function executeTool(toolName: string, args: Record<string, unknown
     return { success: false, error: '工具调用仅支持桌面版' };
   }
 
+  // R23: 参数自动类型转换
+  args = coerceToolArgs(toolName, args);
+
+  // R21: 参数验证
+  const validationErrors = validateToolArgs(toolName, args);
+  if (validationErrors.length > 0) {
+    logError(`工具参数验证失败: ${toolName}`, validationErrors.join('; '));
+    return { success: false, error: `参数验证失败: ${validationErrors.join('; ')}` };
+  }
+
+  // R28: 安全验证 — 路径遍历、命令注入防护
+  const securityWarning = validateToolSecurity(toolName, args);
+  if (securityWarning) {
+    logError(`R28: 工具安全拦截: ${toolName}`, securityWarning);
+    return { success: false, error: securityWarning };
+  }
+
+  const startTime = Date.now();
+
   try {
     // 内存工具（不走 IPC，直接处理 MEMORY.md）
     if (toolName === 'memory') {
@@ -992,10 +1484,28 @@ const results = await search(query, limit);
     // 其他工具：IPC 调用（无超时，由 renderer 内部处理）
     const result = await bridge.tool.execute(toolName, args);
     logToolResult(toolName, result.success, result.success ? undefined : result.error);
-    return result;
+
+    // R22: 截断大输出结果
+    const truncatedResult = truncateToolResult(result, toolName);
+    // R26: 优化结果格式
+    const formattedResult = formatToolResult(toolName, truncatedResult);
+
+    // R25: 记录分析数据
+    const duration = Date.now() - startTime;
+    recordToolAnalytics(toolName, formattedResult.success, duration, formattedResult.error);
+
+    return formattedResult;
   } catch (err) {
-    logError(`工具异常: ${toolName}`, (err as Error).message);
-    return { success: false, error: (err as Error).message };
+    const duration = Date.now() - startTime;
+    const errorMsg = (err as Error).message;
+    logError(`工具异常: ${toolName}`, errorMsg);
+
+    // R24: 生成错误恢复建议
+    const suggestion = suggestToolFix(toolName, args, errorMsg);
+    // R25: 记录分析数据
+    recordToolAnalytics(toolName, false, duration, errorMsg);
+
+    return { success: false, error: suggestion ? `${errorMsg}\n\n💡 建议: ${suggestion}` : errorMsg };
   }
 }
 
diff --git a/src/renderer/styles/style.css b/src/renderer/styles/style.css
index e07a387..293f151 100644
--- a/src/renderer/styles/style.css
+++ b/src/renderer/styles/style.css
@@ -4180,3 +4180,50 @@ html, body {
     margin-top: 4px;
     font-weight: 500;
 }
+
+/* ═══ R31-R40: UI/UX 增强 ═══ */
+
+/* R38: 代码块复制按钮 */
+.code-copy-btn {
+    font-family: inherit;
+    color: var(--text-secondary);
+    transition: opacity 0.2s, background 0.2s;
+}
+.code-copy-btn:hover {
+    background: var(--bg-tertiary, rgba(128, 128, 128, 0.15)) !important;
+    color: var(--text-primary);
+}
+
+/* R40: 消息操作按钮 */
+.msg-actions {
+    z-index: 5;
+}
+.msg-action-btn {
+    font-family: inherit;
+    color: var(--text-secondary);
+    transition: background 0.2s, transform 0.1s;
+}
+.msg-action-btn:hover {
+    background: var(--bg-tertiary, rgba(128, 128, 128, 0.2)) !important;
+    transform: scale(1.1);
+}
+.msg-action-btn:active {
+    transform: scale(0.95);
+}
+
+/* R31: 消息截断提示 */
+.msg-truncated-notice {
+    border-top: 1px dashed var(--border-color);
+    border-bottom: 1px dashed var(--border-color);
+    margin: 8px 0;
+    background: var(--bg-secondary, rgba(128, 128, 128, 0.05));
+}
+
+/* R34: 加载提示文本动画 */
+.loading-text {
+    display: inline-block;
+    margin-left: 8px;
+    color: var(--text-muted);
+    font-size: 13px;
+    transition: opacity 0.3s;
+}