feat: 升级至 v0.3.0 — 安全增强、死循环检测、六轮全面审计修复

大版本迭代，新增安全增强、Agent Loop 增强、UI/UX 增强，经六轮全面审计修复所有问题。

新增功能：
- OutputValidator 事实一致性检查 + 幻觉检测
- PromptInjectionDefender 语义级检测（指令性动词密度、角色边界、分隔符嵌套）
- DeadLoopError 死循环检测（连续3轮相同工具调用自动终止）
- PolicyEngine maxFrequency 滑动窗口频率限制
- MemoryManager TF-IDF 语义检索 + IDF 缓存原子替换
- 斜杠命令（/tool /memory /clear /export）+ 快捷键（Ctrl+B/J/Shift+F/N/[/]）
- 专注模式（Ctrl+Shift+F）带面板状态快照保存/恢复

六轮审计修复（共修复 3 CRITICAL + 8 HIGH + 13 MEDIUM + 11 LOW）：

CRITICAL:
- main.ts 传入 createAdapter 而非 reloadAdapter，导致 Provider 切换完全失效
- Ctrl+N/Ctrl+[/Ctrl+] 不同步 agent-store，导致消息发到错误会话
- engine.ts emit('error') 无监听器导致 DONE 事件丢失、前端卡死

HIGH:
- 死循环检测在工具执行之后（移入 PARSING 后 EXECUTING 前）
- deadLoop 事件前端未处理
- ConfirmationHook.clearPending 从未调用导致定时器泄漏
- engine.ts retry abort listener 未移除导致监听器堆积
- MCPManager JSON.parse 无 try-catch 导致初始化崩溃
- sendMessage 自动创建会话不同步 session-store
- setCurrentSession 竞态导致旧请求覆盖新会话数据

MEDIUM:
- toggleFocusMode 覆盖用户原有面板状态
- 正则检测可被常见词绕过
- 频率限制内存泄漏 + customPolicies 覆盖
- LIKE 回退转义未包含反斜杠
- OutputValidator 新功能未传入 toolResults/context
- MemoryConsolidator LLM 调用无超时保护
- AuditService 每次 log 都查询数据库
- browser-window-manager 超时后未停止页面加载
- output-validator URL 比较大小写敏感
- FileReader 无 onerror 导致 Promise 永久挂起
- /clear /export 不关闭斜杠菜单
- 专注模式下 toggleSidebar/toggleDetail 未恢复另一面板快照

LOW:
- abortPromise 事件监听器堆积
- RateLimitHook Map 内存泄漏
- memory.ts await 同步方法
- PolicyEngine 死代码清理
- Orchestrator sessionDepth 会话结束不清理
- workspace.service.ts 元数据插入边界问题

electron/harness/agent-loop/engine.ts

@@ -37,6 +37,16 @@ import { MetonaStreamEventType, MetonaFinishReason } from '../types';
 import { estimateMessagesTokens } from '../utils/token-estimator';
 import log from 'electron-log';
 
+/**
+ * v0.3.0: 死循环错误 — 在 executeOneIterationStream 中抛出，主循环捕获后以 DEAD_LOOP 原因终止
+ */
+class DeadLoopError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DeadLoopError';
+  }
+}
+
 const DEFAULT_CONFIG: AgentLoopConfig = {
   maxIterations: 20,
   timeoutMs: 120_000,
@@ -74,6 +84,9 @@ export class AgentLoopEngine extends EventEmitter {
   /** 正在进行的 run Promise（用于 run lock，防止并发 run 污染状态） */
   private currentRunPromise: Promise<AgentLoopOutput> | null = null;
 
+  /** v0.3.0: 工具调用签名历史（用于死循环检测） */
+  private toolCallHistory: string[] = [];
+
   constructor(
     config: Partial<AgentLoopConfig> = {},
     private adapter: IMetonaProviderAdapter,
@@ -163,6 +176,8 @@ export class AgentLoopEngine extends EventEmitter {
     this.totalTokens = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
     this.abortController = new AbortController();
     this.eventSeq = 0;
+    // v0.3.0: 重置工具调用历史（用于死循环检测）
+    this.toolCallHistory = [];
 
     try {
       await this.transitionTo(AgentLoopState.INIT);
@@ -229,6 +244,9 @@ export class AgentLoopEngine extends EventEmitter {
           return this.finish(TerminationReason.COMPLETED, step.thought?.content);
         }
 
+        // v0.3.0: 死循环检测已移入 executeOneIterationStream 的 PARSING 阶段后，
+        // 通过抛出 DeadLoopError 在此处 catch 块捕获处理
+
         // 执行工具并将结果加入消息
         if (step.toolResults) {
           for (const result of step.toolResults) {
@@ -249,11 +267,17 @@ export class AgentLoopEngine extends EventEmitter {
         return this.finish(TerminationReason.MAX_ITERATIONS);
       return this.finish(TerminationReason.TIMEOUT);
     } catch (error) {
+      // v0.3.0: 捕获 DeadLoopError — 以 DEAD_LOOP 原因终止
+      if (error instanceof DeadLoopError) {
+        return this.finish(TerminationReason.DEAD_LOOP, error.message);
+      }
       const errMsg = (error as Error).message;
       if (this.aborted || errMsg.includes('Aborted')) {
         return this.finish(TerminationReason.USER_INTERRUPT);
       }
-      this.emit('error', { error: errMsg });
+      // v0.3.0 修复: 不使用 emit('error') — Node EventEmitter 对无监听器的 'error' 事件会同步 throw，
+      // 导致 finish() 被中断、DONE 事件丢失、前端卡死。改为日志记录，让 finish 正常执行
+      log.error(`[AgentLoop] Run failed: ${errMsg}`);
       return this.finish(TerminationReason.ERROR, undefined, error as Error);
     }
   }
@@ -424,6 +448,23 @@ export class AgentLoopEngine extends EventEmitter {
         this.accumulateTokens(tokenUsage);
       }
 
+      // v0.3.0 修复: 死循环检测 — 在 PARSING 阶段完成后、EXECUTING 阶段开始前检测
+      // 确保第3轮重复调用的副作用不会产生（工具尚未执行）
+      if (step.toolCalls && step.toolCalls.length > 0) {
+        if (this.detectDeadLoop(step.toolCalls)) {
+          log.warn(`[AgentLoop] Dead loop detected at iteration ${this.currentIteration} (before tool execution)`);
+          this.emit('deadLoop', {
+            iteration: this.currentIteration,
+            runId: this.runId,
+            sessionId: this.currentSessionId,
+          });
+          // 抛出特殊错误，主循环捕获后以 DEAD_LOOP 原因终止
+          throw new DeadLoopError(
+            `Detected a potential infinite loop: the same tool calls were repeated for 3 consecutive iterations. Please refine the approach or provide more specific instructions.`,
+          );
+        }
+      }
+
       // === EXECUTING: 执行工具调用 ===
       if (step.toolCalls && step.toolCalls.length > 0) {
         // transitionTo 已发射 stateChange 事件，无需重复 emit
@@ -456,16 +497,23 @@ export class AgentLoopEngine extends EventEmitter {
           step.toolCalls.map((tc) => executeAndForward(tc)),
         );
         const controller = this.abortController;
+        let onAbort: (() => void) | null = null;
         const abortPromise = new Promise<null>((resolve) => {
           if (this.aborted) return resolve(null);
           if (controller) {
-            controller.signal.addEventListener('abort', () => resolve(null), { once: true });
+            onAbort = () => resolve(null);
+            controller.signal.addEventListener('abort', onAbort, { once: true });
           }
         });
         const raceResult = await Promise.race([toolsPromise, abortPromise]) as
           | PromiseSettledResult<MetonaToolResult>[]
           | null;
 
+        // v0.3.0 修复: 若 toolsPromise 先完成（正常执行），手动移除 abort 监听器，避免监听器堆积
+        if (onAbort && controller && raceResult !== null) {
+          controller.signal.removeEventListener('abort', onAbort);
+        }
+
         if (raceResult === null) {
           // 被 abort 中断，标记步骤并退出
           step.completedAt = Date.now();
@@ -543,6 +591,11 @@ export class AgentLoopEngine extends EventEmitter {
     } catch (error) {
       step.completedAt = Date.now();
       step.state = AgentLoopState.TERMINATED;
+      // v0.3.0 修复: DeadLoopError 抛出时，将 step 加入 iterations 数组，
+      // 确保死循环轮的 LLM thought 内容不丢失（用户可观察 Agent 被终止前的最后思考）
+      if (error instanceof DeadLoopError) {
+        this.iterations.push(step);
+      }
       throw error;
     }
   }
@@ -665,19 +718,25 @@ export class AgentLoopEngine extends EventEmitter {
           const waitMs = Math.max(500, delay + jitter);
           log.warn(`[AgentLoop] Retry ${attempt + 1}/${this.config.retryCount} after ${Math.round(waitMs)}ms: ${(error as Error).message}`);
           await new Promise((resolve, reject) => {
-            const timer = setTimeout(resolve, waitMs);
+            const timer = setTimeout(() => {
+              // v0.3.0 修复: timer 先触发时移除 abort 监听器，避免监听器堆积
+              if (onAbort && signal) signal.removeEventListener('abort', onAbort);
+              resolve(undefined);
+            }, waitMs);
             // 支持 abort 中断等待
             const signal = this.abortController?.signal;
+            let onAbort: (() => void) | null = null;
             if (signal) {
               if (signal.aborted) {
                 clearTimeout(timer);
                 reject(new Error('Aborted'));
                 return;
               }
-              signal.addEventListener('abort', () => {
+              onAbort = () => {
                 clearTimeout(timer);
                 reject(new Error('Aborted'));
-              }, { once: true });
+              };
+              signal.addEventListener('abort', onAbort, { once: true });
             }
           });
         }
@@ -728,6 +787,59 @@ export class AgentLoopEngine extends EventEmitter {
     return estimateMessagesTokens(messages);
   }
 
+  /**
+   * v0.3.0: 死循环检测
+   *
+   * 检测策略：
+   * 将每轮的工具调用序列化为签名字符串，检查最近3轮的签名是否完全相同。
+   * 如果连续3轮使用完全相同的参数调用相同的工具，判定为死循环。
+   *
+   * v0.3.0 修复：
+   * - 对 args 的键进行排序，避免 JSON.stringify 键顺序不一致导致漏报
+   *
+   * @param toolCalls 当前轮次的工具调用
+   * @returns 是否检测到死循环
+   */
+  private detectDeadLoop(toolCalls: MetonaToolCall[]): boolean {
+    // 将当前轮次的工具调用序列化为签名
+    // v0.3.0 修复：使用 stable stringify，对对象键排序，确保相同内容不同键顺序产生相同签名
+    // v0.3.0 修复：添加 visited Set 防循环引用，深度上限防过度递归
+    const stableStringify = (obj: unknown, visited: Set<unknown> = new Set(), depth = 0): string => {
+      if (depth > 10) return '...'; // 深度上限防止过度递归
+      if (obj === null || typeof obj !== 'object') return JSON.stringify(obj);
+      if (visited.has(obj)) return '"[Circular]"'; // 循环引用防护
+      visited.add(obj);
+      try {
+        if (Array.isArray(obj)) return `[${obj.map((v) => stableStringify(v, visited, depth + 1)).join(',')}]`;
+        const keys = Object.keys(obj as Record<string, unknown>).sort();
+        return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify((obj as Record<string, unknown>)[k], visited, depth + 1)}`).join(',')}}`;
+      } finally {
+        visited.delete(obj);
+      }
+    };
+    const signature = toolCalls
+      .map((tc) => `${tc.name}(${stableStringify(tc.args)})`)
+      .join('|');
+
+    this.toolCallHistory.push(signature);
+
+    // 只保留最近5轮的记录（足够检测3轮重复，同时避免内存增长）
+    if (this.toolCallHistory.length > 5) {
+      this.toolCallHistory.shift();
+    }
+
+    // 需要至少3轮数据才能检测
+    if (this.toolCallHistory.length < 3) return false;
+
+    const len = this.toolCallHistory.length;
+    const r1 = this.toolCallHistory[len - 1]; // 当前轮
+    const r2 = this.toolCallHistory[len - 2]; // 上一轮
+    const r3 = this.toolCallHistory[len - 3]; // 上上一轮
+
+    // 连续3轮完全相同 → 死循环
+    return r1 === r2 && r2 === r3;
+  }
+
   /**
    * 上下文压缩 — 将旧消息摘要为一条 system 消息，保留最近 3 轮完整对话
    *