feat: v0.4.0 四阶段迭代 — 安全加固 + 工程基线 + 架构重构 + 双 Provider 扩展

P0 安全修复:
- API Key 加密存储（safeStorage 密钥链，版本化前缀，历史明文平滑兼容）
- 间接提示注入防护（SecurityScanHook 工具结果深扫描，网络工具脱敏/本地工具警示分级）
- error:report IPC 断链修复（渲染进程错误上报落 electron-log + 审计）
- abort 信号贯通工具层（run_command/dev-tools 子进程随会话中断终止）
- run_command 沙箱加固（cd 系统目录/敏感文件读取拦截 + chcp 前缀剥离防解析退化）
- .env 真实生效（dotenv 回退加载，应用内配置优先）

P1 工程基础:
- ESLint 9 flat config + 全部 34 条存量 warnings 清零（零容忍基线）
- 测试基线 118 用例 11 文件（token/文件防护/权限/沙箱/注入/命令/引擎/注册表/审计链/摘要分层）
- test:electron 双模式（ELECTRON_RUN_AS_NODE 跑 Electron ABI，SQLite 套件全执行）
- SessionRecorder 多会话隔离 + 9 种 TRACE 事件补全（含最终轮 iteration_end）
- Provider 故障转移（重试耗尽/不可重试一次性切换 fallback + 前端通知）
- MCP 真就绪（等待全部连接完成再广播 tools:ready）
- SLO/HealthChecker 真实接入（60s 巡检 + 托盘状态）
- CONFIG_DEFAULTS 单一来源（消除 SEED 双源漂移）

P2 架构升级:
- handlers.ts 1940 行拆分为 13 个 IPC 域模块（防重入注册 + 多窗口广播）
- AgentEngineManager 每会话独立引擎（LRU 30 + adapter 工厂隔离 abort 信号）
- TaskOrchestrator EngineProvider 改造 + abortByParent 联动中断 SubAgent
- 会话摘要分层上下文（session_summaries 滚动摘要 + 截断游标清理防因果污染）
- 消息编辑重发/重新生成（truncateAfter IPC + store 动作 + UI）
- Markdown 导出 / WebSearch 并行抓取（并发 3）/ 记忆 TF 缓存 / 版本构建期注入

P3 能力扩展:
- OpenAI Adapter（o 系列推理模型 reasoning_effort/max_completion_tokens）
- Anthropic Adapter（原生 Messages API：tool_use 块/角色合并/thinking budget/图片 base64/SSE 事件机）
- 设置页/Onboarding 六 Provider 全链路接入

electron/services/session-recorder.service.ts

@@ -4,9 +4,14 @@
  * 负责将完整的会话执行轨迹写入 session_*.jsonl 文件。
  * 每行一条 JSON 事件，支持事后回放和分析。
  *
+ * P1-6 重构：
+ * 1. 多会话支持——每个会话独立的状态（文件路径/seq），并发会话互不串扰
+ *    （原实现单会话状态，第二个会话 startRecording 会覆盖第一个的录制目标）
+ * 2. 事件签名统一携带 sessionId 参数，与 README 宣称的 9 种事件对齐：
+ *    session_start, context_built, iteration_start, llm_request,
+ *    llm_response, tool_call, tool_result, iteration_end, session_end
+ *
  * 日志格式：SSE-like JSON Lines
- * 事件类型：session_start, context_built, iteration_start, llm_request,
- *          llm_response, tool_call, tool_result, iteration_end, session_end
  *
  * @see docs/MetonaAI-Desktop 架构与交互设计.html — 全链路透明可追踪
  * @see docs/生产级通用 AI Agent 智能体桌面应用：完整设计与构建指南.html — 第十一章
@@ -37,58 +42,76 @@ export interface TraceEvent {
   [key: string]: unknown;
 }
 
+/** 单个会话的录制状态 */
+interface SessionRecordState {
+  filePath: string;
+  seq: number;
+  buffer: string[];
+  flushTimer: NodeJS.Timeout | null;
+  flushing: boolean;
+}
+
 // ===== 服务类 =====
 
 export class SessionRecorder {
-  private filePath: string | null = null;
-  private seq = 0;
-  private sessionId: string | null = null;
-  // #35 修复: 缓冲写入，避免高频 appendFileSync 阻塞主进程（30-50 次/秒 → 每 100ms 批量异步 flush）
-  private buffer: string[] = [];
-  private flushTimer: NodeJS.Timeout | null = null;
-  private flushing = false;
+  /** P1-6: 每会话独立状态（支持并发会话录制） */
+  private sessions = new Map<string, SessionRecordState>();
 
   constructor(private workspacePath: string) {}
 
+  /** 获取指定会话的录制状态（不存在返回 null） */
+  private state(sessionId: string): SessionRecordState | null {
+    return this.sessions.get(sessionId) ?? null;
+  }
+
   /**
    * 开始录制会话
    */
   startRecording(sessionId: string): void {
-    this.sessionId = sessionId;
-    this.seq = 0;
-
     const logsDir = join(this.workspacePath, 'logs');
     if (!existsSync(logsDir)) {
       mkdirSync(logsDir, { recursive: true });
     }
 
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    this.filePath = join(logsDir, `session_${sessionId}_${timestamp}.jsonl`);
+    const filePath = join(logsDir, `session_${sessionId}_${timestamp}.jsonl`);
+
+    this.sessions.set(sessionId, {
+      filePath,
+      seq: 0,
+      buffer: [],
+      flushTimer: null,
+      flushing: false,
+    });
 
     // 写入 session_start 事件
-    this.writeEvent({
+    this.writeEvent(sessionId, {
       event: 'session_start',
       sessionId,
       workspace: this.workspacePath,
     });
 
-    log.info(`Session recording started: ${this.filePath}`);
+    log.info(`Session recording started: ${filePath}`);
   }
 
   /**
-   * 停止录制
+   * 停止录制（P1-6: 按会话停止，不影响其他并发录制）
    */
-  stopRecording(params: {
-    totalIterations: number;
-    totalTokens: number;
-    durationMs: number;
-    terminationReason: string;
-  }): void {
-    if (!this.sessionId || !this.filePath) return;
+  stopRecording(
+    sessionId: string,
+    params: {
+      totalIterations: number;
+      totalTokens: number;
+      durationMs: number;
+      terminationReason: string;
+    },
+  ): void {
+    const state = this.state(sessionId);
+    if (!state) return;
 
-    this.writeEvent({
+    this.writeEvent(sessionId, {
       event: 'session_end',
-      sessionId: this.sessionId,
+      sessionId,
       totalIterations: params.totalIterations,
       totalTokens: params.totalTokens,
       durationMs: params.durationMs,
@@ -96,20 +119,19 @@ export class SessionRecorder {
     });
 
     // #35 修复: 同步 flush 确保最后的 session_end 事件写入文件
-    this.flushSync();
+    this.flushSync(sessionId);
 
-    log.info(`Session recording stopped: ${this.filePath}`);
-    this.filePath = null;
-    this.sessionId = null;
+    log.info(`Session recording stopped: ${state.filePath}`);
+    this.sessions.delete(sessionId);
   }
 
   /**
    * 记录上下文构建
    */
-  recordContextBuilt(params: { tokenCount: number; usageRatio: number }): void {
-    this.writeEvent({
+  recordContextBuilt(sessionId: string, params: { tokenCount: number; usageRatio: number }): void {
+    this.writeEvent(sessionId, {
       event: 'context_built',
-      sessionId: this.sessionId!,
+      sessionId,
       tokens: params.tokenCount,
       ratio: params.usageRatio,
     });
@@ -118,10 +140,10 @@ export class SessionRecorder {
   /**
    * 记录迭代开始
    */
-  recordIterationStart(iteration: number): void {
-    this.writeEvent({
+  recordIterationStart(sessionId: string, iteration: number): void {
+    this.writeEvent(sessionId, {
       event: 'iteration_start',
-      sessionId: this.sessionId!,
+      sessionId,
       iteration,
     });
   }
@@ -130,14 +152,15 @@ export class SessionRecorder {
    * 记录 LLM 请求
    */
   recordLLMRequest(params: {
+    sessionId: string;
     iteration: number;
     provider: string;
     model: string;
     messageCount: number;
   }): void {
-    this.writeEvent({
+    this.writeEvent(params.sessionId, {
       event: 'llm_request',
-      sessionId: this.sessionId!,
+      sessionId: params.sessionId,
       iteration: params.iteration,
       provider: params.provider,
       model: params.model,
@@ -149,14 +172,15 @@ export class SessionRecorder {
    * 记录 LLM 响应
    */
   recordLLMResponse(params: {
+    sessionId: string;
     iteration: number;
     content: string;
     finishReason: string;
     tokenUsage: { input: number; output: number; total: number };
   }): void {
-    this.writeEvent({
+    this.writeEvent(params.sessionId, {
       event: 'llm_response',
-      sessionId: this.sessionId!,
+      sessionId: params.sessionId,
       iteration: params.iteration,
       contentPreview: params.content.slice(0, 200),
       finishReason: params.finishReason,
@@ -168,13 +192,14 @@ export class SessionRecorder {
    * 记录工具调用
    */
   recordToolCall(params: {
+    sessionId: string;
     iteration: number;
     toolName: string;
     args: Record<string, unknown>;
   }): void {
-    this.writeEvent({
+    this.writeEvent(params.sessionId, {
       event: 'tool_call',
-      sessionId: this.sessionId!,
+      sessionId: params.sessionId,
       iteration: params.iteration,
       tool: params.toolName,
       args: params.args,
@@ -185,6 +210,7 @@ export class SessionRecorder {
    * 记录工具结果
    */
   recordToolResult(params: {
+    sessionId: string;
     iteration: number;
     toolName: string;
     success: boolean;
@@ -192,9 +218,9 @@ export class SessionRecorder {
     resultPreview?: string;
     error?: string;
   }): void {
-    this.writeEvent({
+    this.writeEvent(params.sessionId, {
       event: 'tool_result',
-      sessionId: this.sessionId!,
+      sessionId: params.sessionId,
       iteration: params.iteration,
       tool: params.toolName,
       success: params.success,
@@ -207,13 +233,10 @@ export class SessionRecorder {
   /**
    * 记录迭代结束
    */
-  recordIterationEnd(params: {
-    iteration: number;
-    durationMs: number;
-  }): void {
-    this.writeEvent({
+  recordIterationEnd(sessionId: string, params: { iteration: number; durationMs: number }): void {
+    this.writeEvent(sessionId, {
       event: 'iteration_end',
-      sessionId: this.sessionId!,
+      sessionId,
       iteration: params.iteration,
       durationMs: params.durationMs,
     });
@@ -222,8 +245,10 @@ export class SessionRecorder {
   /**
    * 获取录制文件路径
    */
-  getFilePath(): string | null {
-    return this.filePath;
+  getFilePath(sessionId?: string): string | null {
+    if (sessionId) return this.state(sessionId)?.filePath ?? null;
+    const first = this.sessions.values().next().value;
+    return first?.filePath ?? null;
   }
 
   // ===== 私有方法 =====
@@ -231,16 +256,17 @@ export class SessionRecorder {
   /**
    * 写入事件到缓冲区
    *
-   * #35 修复: 改为缓冲写入，定时异步 flush，避免每次 appendFileSync 阻塞主进程
+   * #35 修复: 缓冲写入，定时异步 flush，避免每次 appendFileSync 阻塞主进程
    * 高频事件（30-50 次/秒）先 push 到内存 buffer，每 100ms 批量异步写入文件
    */
-  private writeEvent(data: Record<string, unknown>): void {
-    if (!this.filePath) return;
+  private writeEvent(sessionId: string, data: Record<string, unknown>): void {
+    const state = this.state(sessionId);
+    if (!state) return;
 
     const event: TraceEvent = {
-      seq: this.seq++,
+      seq: state.seq++,
       ts: new Date().toISOString(),
-      sessionId: this.sessionId!,
+      sessionId,
       ...data,
     } as TraceEvent;
 
@@ -248,38 +274,44 @@ export class SessionRecorder {
 
     // 审查修复: buffer 上限防止 OOM — 高频事件持续 flush 失败时避免内存无限增长
     const MAX_BUFFER_SIZE = 1000;
-    if (this.buffer.length >= MAX_BUFFER_SIZE) {
+    if (state.buffer.length >= MAX_BUFFER_SIZE) {
       // 超限时强制同步写入，避免内存无限增长
-      this.flushSync();
+      this.flushSync(sessionId);
     }
-    this.buffer.push(line);
-    if (!this.flushTimer) {
-      this.flushTimer = setTimeout(() => {
-        this.flushTimer = null;
-        void this.flush();
+    state.buffer.push(line);
+    if (!state.flushTimer) {
+      state.flushTimer = setTimeout(() => {
+        const st = this.state(sessionId);
+        if (st) {
+          st.flushTimer = null;
+          void this.flush(sessionId);
+        }
       }, 100);
     }
   }
 
   /**
    * #35 修复: 异步 flush 缓冲区到文件
-   * 审查修复: 用局部变量保存 filePath，防止 stopRecording 将 filePath 置 null 后 appendFile 抛错；
+   * 审查修复: 用局部变量保存 filePath，防止 stopRecording 将状态删除后 appendFile 抛错；
    * 失败时将数据 unshift 回 buffer 避免丢整批数据
    */
-  private async flush(): Promise<void> {
-    if (this.flushing || this.buffer.length === 0 || !this.filePath) return;
-    this.flushing = true;
-    const filePath = this.filePath; // 局部变量，防止中途变 null
-    const data = this.buffer.join('\n') + '\n';
-    this.buffer = [];
+  private async flush(sessionId: string): Promise<void> {
+    const state = this.state(sessionId);
+    if (!state || state.flushing || state.buffer.length === 0) return;
+    state.flushing = true;
+    const filePath = state.filePath; // 局部变量，防止中途状态被删除
+    const data = state.buffer.join('\n') + '\n';
+    state.buffer = [];
     try {
       await promises.appendFile(filePath, data, 'utf-8');
     } catch (error) {
       log.error('Trace event flush failed:', error);
       // 审查修复: 失败时将数据放回 buffer 头部，下次 flush/flushSync 重试
-      this.buffer.unshift(data.trimEnd());
+      const st = this.state(sessionId);
+      if (st) st.buffer.unshift(data.trimEnd());
     } finally {
-      this.flushing = false;
+      const st = this.state(sessionId);
+      if (st) st.flushing = false;
     }
   }
 
@@ -288,20 +320,22 @@ export class SessionRecorder {
    * 用于 stopRecording 确保最后的数据（如 session_end 事件）写入文件
    * 审查修复: 如果异步 flush 正在进行（flushing=true），等待其完成后再写入，避免数据交叉/丢失
    */
-  private flushSync(): void {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
+  private flushSync(sessionId: string): void {
+    const state = this.state(sessionId);
+    if (!state) return;
+    if (state.flushTimer) {
+      clearTimeout(state.flushTimer);
+      state.flushTimer = null;
     }
-    if (this.buffer.length === 0 || !this.filePath) return;
-    const data = this.buffer.join('\n') + '\n';
-    this.buffer = [];
+    if (state.buffer.length === 0) return;
+    const data = state.buffer.join('\n') + '\n';
+    state.buffer = [];
     try {
-      appendFileSync(this.filePath, data, 'utf-8');
+      appendFileSync(state.filePath, data, 'utf-8');
     } catch (error) {
       log.error('Trace event flushSync failed:', error);
       // 审查修复: 失败时将数据放回 buffer，避免数据丢失
-      this.buffer.unshift(data.trimEnd());
+      state.buffer.unshift(data.trimEnd());
     }
   }
 }