feat: v0.5.0 审计修复版 — 类型基线重建 + 会话隔离 + SubAgent 可观测性 + 三项功能补全

P0 安全与工程基线（止血）:
- .npmrc 移除硬编码 Gitea npm 凭据，改为 GITEA_NPM_AUTH 环境变量注入（已验证未设变量时 401）
- 修复 typecheck 空操作缺陷：solution-style 根 tsconfig 改为双工程真检查（node + web），
  pre-commit 与 CI 门禁恢复拦截能力
- 修复 4 处 v0.4.1 遗留类型错误：confirmation-hook.test 枚举名 FILE_SYSTEM→FILESYSTEM、
  agent.ts VALIDATION 事件 severity 类型谓词收窄、ContextMenu.tsx 导出 attachments 类型
- 补装 v0.4.1 声明但未安装的 node-html-parser 依赖

P1 逻辑缺陷修复（跨模块边界）:
- ConfirmationHook 会话隔离：rememberedDecisions 与 pendingConfirmations 按 sessionId 隔离，
  abortSession 只清本会话 pending（修复 A 会话中断误杀 B 会话确认、拒绝记忆跨会话污染）
- SubAgent 可观测性：orchestrator 六个事件此前全项目零消费者，现接入
  ① subagent:event 生命周期广播（AgentMonitor 新增 SubAgent 状态区）
  ② SubEngine 流事件独立 TRACE 录制（sessionId=taskId 的 JSONL 文件）
- main.ts 启动链路异常兜底：初始化失败时记录日志 + 系统错误对话框 + 退出（原为白屏挂起）

P2 工程强化:
- CI：typecheck 双工程真检查；electron-test 从 experimental（continue-on-error）转正为阻塞门禁；
  GITEA_NPM_AUTH secret 注入说明
- 渲染 bundle 代码分割：单 2630KB chunk 拆为 main 557KB + vendor-react/mui/markdown/icons
  （业务代码变更不再使 vendor 缓存失效）
- database 建表 mcp_servers CHECK 直接含 streamable-http（新库不再依赖迁移 6 立即重建）

P3 功能补全:
- DeepSeek 余额显示：新增 llm:getBalance IPC + LLMSettings 余额卡片（复用适配器原死代码 getBalance）
- FTS5 会话内容搜索：messages_fts 虚表 + INSERT/UPDATE/DELETE 触发器实时同步 +
  存量库 rebuild 迁移 + sessions:searchContent IPC + Sidebar 搜索框标题∪内容联合搜索
  （短语转义防 FTS 运算符注入，按会话聚合展示 snippet）
- 审计日志导出：audit:export IPC（JSONL / CSV RFC 4180 转义）+ LogsSettings 导出按钮

文档一致性大扫除:
- README：工具数统一为 28（原 26/27/30 三口径）、handlers.ts→ipc/、录制事件名更正、
  删除虚构的审计导出/归档宣称与 Schema 虚构字段、MCP 三种传输、配置 key 更正、
  项目结构树对齐实际（settings 10 文件/lib 6 文件/react-virtuoso）、clone 地址改为 Gitea、
  新增 GITEA_NPM_AUTH 配置说明、测试数 207
- 架构/构建指南/UI UX/IR 标准 4 份 HTML 设计文档同步修正（工具数、表数 10、
  磁盘文件 2 个现状注记、ipc/*.ts 路径）
- eslint.config.js 与开发规范.md 注释对齐零容忍基线与 better-sqlite3 选型

测试: 199→207 用例（新增 ConfirmationHook 跨会话隔离 5 用例 + FTS5 搜索/审计导出 8 用例）
验证: lint 0 problems / typecheck 双工程 0 errors / test:electron 207 全过 / build 成功

electron/harness/hooks/__tests__/confirmation-hook.test.ts

@@ -26,7 +26,7 @@ const SAFE_DEF: MetonaToolDef = {
   name: 'read_file',
   description: 'Read file (test fixture)',
   parameters: { type: 'object', properties: {}, required: [] },
-  category: MetonaToolCategory.FILE_SYSTEM,
+  category: MetonaToolCategory.FILESYSTEM,
   riskLevel: MetonaRiskLevel.SAFE,
   requiresPermission: false,
   timeoutMs: 1_000,
@@ -37,7 +37,7 @@ const HIGH_RISK_DEF_2: MetonaToolDef = {
   name: 'delete_file',
   description: 'Delete file (test fixture)',
   parameters: { type: 'object', properties: {}, required: [] },
-  category: MetonaToolCategory.FILE_SYSTEM,
+  category: MetonaToolCategory.FILESYSTEM,
   riskLevel: MetonaRiskLevel.HIGH,
   requiresPermission: true,
   timeoutMs: 1_000,
@@ -315,3 +315,110 @@ describe('ConfirmationHook — clearPending', () => {
     expect(hook.getPendingConfirmations()).toHaveLength(0);
   });
 });
+
+describe('ConfirmationHook — 跨会话隔离（v0.5.0）', () => {
+  it('A 会话记住拒绝，B 会话同工具仍正常询问（产生新 pending）', async () => {
+    const hook = new ConfirmationHook(makeMockWindow(), null);
+    hook.setToolDefs([HIGH_RISK_DEF]);
+
+    // A 会话记住拒绝
+    const pA = hook.beforeExecute(makeToolCall(), 'sess-a');
+    hook.resolveConfirmation(hook.getPendingConfirmations()[0].toolCallId, false, true, false);
+    expect((await pA).blocked).toBe(true);
+
+    // B 会话同工具 — 不受 A 会话拒绝记忆影响，进入询问流程（产生新 pending）
+    const pB = hook.beforeExecute(makeToolCall(), 'sess-b');
+    const pendingB = hook.getPendingConfirmations();
+    expect(pendingB).toHaveLength(1);
+    hook.resolveConfirmation(pendingB[0].toolCallId, true, false, false);
+    expect((await pB).blocked).toBe(false);
+
+    // A 会话的拒绝记忆仍在（getRememberedDenials 限定 A 会话可见）
+    expect(hook.getRememberedDenials('sess-a')).toHaveLength(1);
+    expect(hook.getRememberedDenials('sess-b')).toHaveLength(0);
+  });
+
+  it('A 会话记住批准，B 会话同工具仍需确认', async () => {
+    const hook = new ConfirmationHook(makeMockWindow(), null);
+    hook.setToolDefs([HIGH_RISK_DEF]);
+
+    // A 会话记住批准
+    const pA = hook.beforeExecute(makeToolCall(), 'sess-a');
+    hook.resolveConfirmation(hook.getPendingConfirmations()[0].toolCallId, true, true, false);
+    expect((await pA).blocked).toBe(false);
+
+    // A 会话后续调用直接放行（无新 pending）
+    const again = await hook.beforeExecute(makeToolCall(), 'sess-a');
+    expect(again.blocked).toBe(false);
+    expect(hook.getPendingConfirmations()).toHaveLength(0);
+
+    // B 会话同工具 — 进入询问流程（批准记忆不跨会话共享）
+    const pB = hook.beforeExecute(makeToolCall(), 'sess-b');
+    expect(hook.getPendingConfirmations()).toHaveLength(1);
+    hook.resolveConfirmation(hook.getPendingConfirmations()[0].toolCallId, true, false, false);
+    expect((await pB).blocked).toBe(false);
+  });
+
+  it('中断 A 会话（clearPending 按会话）不影响 B 会话等待中的确认', async () => {
+    const hook = new ConfirmationHook(makeMockWindow(), null);
+    hook.setToolDefs([HIGH_RISK_DEF]);
+
+    // 两个会话各有一个等待中的确认
+    const pA = hook.beforeExecute(makeToolCall(), 'sess-a');
+    const pB = hook.beforeExecute(makeToolCall(), 'sess-b');
+    expect(hook.getPendingConfirmations()).toHaveLength(2);
+
+    // 中断 A 会话 — 只拒绝 A 的 pending
+    hook.clearPending('sess-a');
+    expect((await pA).blocked).toBe(true);
+
+    // B 会话的 pending 仍在等待，用户批准后正常放行
+    const remaining = hook.getPendingConfirmations();
+    expect(remaining).toHaveLength(1);
+    expect(remaining[0].toolCallId).toBeDefined();
+    hook.resolveConfirmation(remaining[0].toolCallId, true, false, false);
+    expect((await pB).blocked).toBe(false);
+  });
+
+  it('resetRememberedDenial 指定会话时只重置该会话的拒绝记忆', async () => {
+    const hook = new ConfirmationHook(makeMockWindow(), null);
+    hook.setToolDefs([HIGH_RISK_DEF]);
+
+    // A、B 两个会话都记住拒绝
+    const pA = hook.beforeExecute(makeToolCall(), 'sess-a');
+    hook.resolveConfirmation(hook.getPendingConfirmations()[0].toolCallId, false, true, false);
+    await pA;
+    const pB = hook.beforeExecute(makeToolCall(), 'sess-b');
+    hook.resolveConfirmation(hook.getPendingConfirmations()[0].toolCallId, false, true, false);
+    await pB;
+
+    // 重置 A 会话的拒绝记忆 — B 会话的记忆保留
+    expect(hook.resetRememberedDenial('run_command', 'sess-a')).toBe(true);
+    expect(hook.getRememberedDenials('sess-a')).toHaveLength(0);
+    expect(hook.getRememberedDenials('sess-b')).toHaveLength(1);
+
+    // 缺省 sessionId — 重置所有会话
+    expect(hook.resetRememberedDenial('run_command')).toBe(true);
+    expect(hook.getRememberedDenials()).toHaveLength(0);
+  });
+
+  it('setAutoExecute 启用时清除所有会话的拒绝记忆（全局设置优先）', async () => {
+    const hook = new ConfirmationHook(makeMockWindow(), null);
+    hook.setToolDefs([HIGH_RISK_DEF]);
+
+    // 两个会话都记住拒绝
+    for (const sid of ['sess-a', 'sess-b']) {
+      const p = hook.beforeExecute(makeToolCall(), sid);
+      hook.resolveConfirmation(hook.getPendingConfirmations()[0].toolCallId, false, true, false);
+      await p;
+    }
+    expect(hook.getRememberedDenials()).toHaveLength(1); // 聚合去重后同一工具 1 条
+
+    // 启用自动执行 — 所有会话的拒绝记忆被清除
+    hook.setAutoExecute('run_command', true);
+    expect(hook.getRememberedDenials()).toHaveLength(0);
+    // 自动执行放行（任意会话）
+    expect((await hook.beforeExecute(makeToolCall(), 'sess-a')).blocked).toBe(false);
+    expect((await hook.beforeExecute(makeToolCall(), 'sess-b')).blocked).toBe(false);
+  });
+});

electron/harness/hooks/confirmation-hook.ts

@@ -40,8 +40,14 @@ export class ConfirmationHook implements PreToolHook {
   /** 工具定义缓存（由外部设置） */
   private toolDefs = new Map<string, MetonaToolDef>();
 
-  /** 用户选择记忆（同一会话内不再重复询问）— v0.4.1: 值扩展为 { approved, at } 以支持拒绝记忆 TTL */
-  private rememberedDecisions = new Map<string, { approved: boolean; at: number }>();
+  /**
+   * 用户选择记忆（sessionId → toolName → 决策）
+   *
+   * v0.5.0: 从全局 Map 改为按会话隔离的两级 Map — 多会话并发时，
+   * A 会话的"记住拒绝/批准"不再影响 B 会话（与 PolicyEngine 频率限制的会话隔离策略一致）。
+   * 值为 { approved, at } 以支持拒绝记忆 TTL（v0.4.1）。
+   */
+  private rememberedDecisions = new Map<string, Map<string, { approved: boolean; at: number }>>();
 
   /**
    * v0.4.1: 会话内拒绝记忆的 TTL（10 分钟）
@@ -63,6 +69,8 @@ export class ConfirmationHook implements PreToolHook {
       timer: NodeJS.Timeout;
       toolName: string;
       expiresAt: number;
+      /** v0.5.0: 发起确认的会话 ID（clearPending 按会话清理的依据） */
+      sessionId: string;
       /** v0.3.2 批量审批：缓存完整请求信息，供 getPendingConfirmations() 重建 ConfirmationRequest */
       args?: Record<string, unknown>;
       riskLevel?: string;
@@ -119,8 +127,8 @@ export class ConfirmationHook implements PreToolHook {
     }
     if (enabled) {
       this.autoExecuteTools.add(toolName);
-      // 自动执行时同步清除会话内"拒绝"记忆（避免冲突）
-      this.rememberedDecisions.delete(toolName);
+      // 自动执行时同步清除所有会话的"拒绝"记忆（避免冲突 — 自动执行是跨会话的全局设置）
+      this.clearDenialMemoryAllSessions(toolName);
     } else {
       this.autoExecuteTools.delete(toolName);
     }
@@ -194,9 +202,9 @@ export class ConfirmationHook implements PreToolHook {
       if (autoExecute && approved) {
         this.setAutoExecute(pending.toolName, true);
       }
-      // 会话内记忆（v0.4.1: 拒绝记忆带时间戳，用于 TTL 过期）
+      // 会话内记忆（v0.4.1: 拒绝记忆带时间戳用于 TTL；v0.5.0: 按 pending 所属会话写入）
       if (remember) {
-        this.rememberedDecisions.set(pending.toolName, { approved, at: Date.now() });
+        this.decisionsFor(pending.sessionId).set(pending.toolName, { approved, at: Date.now() });
       }
       this.pendingConfirmations.delete(toolCallId);
     }
@@ -242,7 +250,7 @@ export class ConfirmationHook implements PreToolHook {
           this.setAutoExecute(pending.toolName, true);
         }
         if (remember) {
-          this.rememberedDecisions.set(pending.toolName, { approved, at: Date.now() });
+          this.decisionsFor(pending.sessionId).set(pending.toolName, { approved, at: Date.now() });
         }
       }
     }
@@ -275,44 +283,57 @@ export class ConfirmationHook implements PreToolHook {
   }
 
   /**
-   * v0.4.1: 获取本会话内记住"拒绝"的工具列表（含剩余有效期，供前端展示恢复入口）
+   * v0.4.1: 获取记住"拒绝"的工具列表（含剩余有效期，供前端展示恢复入口）
+   * v0.5.0: 按 sessionId 过滤 — 只返回指定会话的拒绝记忆；未指定时聚合所有会话（按剩余时间最长去重）
    *
    * 拒绝记忆有 TTL（默认 10 分钟），到期自动恢复询问；
    * 此方法返回未过期的拒绝记忆，前端可提供"重新询问"按钮主动重置。
+   *
+   * @param sessionId 会话 ID（前端应传当前会话；缺省时聚合全部会话）
    */
-  getRememberedDenials(): Array<{ toolName: string; expiresInSeconds: number }> {
+  getRememberedDenials(sessionId?: string): Array<{ toolName: string; expiresInSeconds: number }> {
     const now = Date.now();
-    const result: Array<{ toolName: string; expiresInSeconds: number }> = [];
-    for (const [toolName, decision] of this.rememberedDecisions) {
-      if (decision.approved) continue;
-      const elapsed = now - decision.at;
-      if (elapsed >= ConfirmationHook.DENIAL_TTL_MS) {
-        // 已过期 — 顺手清理，避免列表返回过期条目
-        this.rememberedDecisions.delete(toolName);
-        continue;
+    // toolName → 剩余秒数（跨会话聚合时取最长剩余时间）
+    const merged = new Map<string, number>();
+    for (const [sid, decisions] of this.rememberedDecisions) {
+      if (sessionId && sid !== sessionId) continue;
+      for (const [toolName, decision] of decisions) {
+        if (decision.approved) continue;
+        const elapsed = now - decision.at;
+        if (elapsed >= ConfirmationHook.DENIAL_TTL_MS) {
+          // 已过期 — 顺手清理，避免列表返回过期条目
+          decisions.delete(toolName);
+          continue;
+        }
+        const remaining = Math.ceil((ConfirmationHook.DENIAL_TTL_MS - elapsed) / 1000);
+        merged.set(toolName, Math.max(merged.get(toolName) ?? 0, remaining));
       }
-      result.push({
-        toolName,
-        expiresInSeconds: Math.ceil((ConfirmationHook.DENIAL_TTL_MS - elapsed) / 1000),
-      });
     }
-    return result;
+    return Array.from(merged.entries()).map(([toolName, expiresInSeconds]) => ({
+      toolName,
+      expiresInSeconds,
+    }));
   }
 
   /**
    * v0.4.1: 重置指定工具的会话内拒绝记忆（恢复询问）
+   * v0.5.0: sessionId 指定会话；未指定时重置所有会话中该工具的拒绝记忆
    * @returns true 表示重置成功（存在该工具的拒绝记忆）；false 表示没有可重置的记忆
    */
-  resetRememberedDenial(toolName: string): boolean {
-    const decision = this.rememberedDecisions.get(toolName);
-    if (decision && !decision.approved) {
-      this.rememberedDecisions.delete(toolName);
-      return true;
+  resetRememberedDenial(toolName: string, sessionId?: string): boolean {
+    let reset = false;
+    for (const [sid, decisions] of this.rememberedDecisions) {
+      if (sessionId && sid !== sessionId) continue;
+      const decision = decisions.get(toolName);
+      if (decision && !decision.approved) {
+        decisions.delete(toolName);
+        reset = true;
+      }
     }
-    return false;
+    return reset;
   }
 
-  async beforeExecute(toolCall: MetonaToolCall, _sessionId: string): Promise<HookResult> {
+  async beforeExecute(toolCall: MetonaToolCall, sessionId: string): Promise<HookResult> {
     const def = this.toolDefs.get(toolCall.name);
     if (!def) {
       // 未知工具，放行（由 ToolRegistry 处理未知工具错误）
@@ -332,14 +353,15 @@ export class ConfirmationHook implements PreToolHook {
       return { blocked: false };
     }
 
-    // 检查是否有记住的决策（v0.4.1: 拒绝记忆带 TTL，过期后恢复询问）
-    const remembered = this.rememberedDecisions.get(toolCall.name);
-    if (remembered !== undefined) {
+    // 检查本会话记住的决策（v0.4.1: 拒绝记忆带 TTL，过期后恢复询问；v0.5.0: 按会话隔离）
+    const sessionDecisions = this.rememberedDecisions.get(sessionId);
+    const remembered = sessionDecisions?.get(toolCall.name);
+    if (sessionDecisions && remembered !== undefined) {
       const isExpiredDenial =
         !remembered.approved && Date.now() - remembered.at > ConfirmationHook.DENIAL_TTL_MS;
       if (isExpiredDenial) {
         // 拒绝记忆已过期 — 移除并继续走正常确认流程
-        this.rememberedDecisions.delete(toolCall.name);
+        sessionDecisions.delete(toolCall.name);
       } else {
         if (remembered.approved) return { blocked: false };
         return {
@@ -366,7 +388,7 @@ export class ConfirmationHook implements PreToolHook {
     };
 
     // 等待用户响应（带超时）
-    const approved = await this.waitForConfirmation(request);
+    const approved = await this.waitForConfirmation(request, sessionId);
 
     if (!approved) {
       return { blocked: true, reason: `User denied execution of tool "${toolCall.name}"` };
@@ -385,7 +407,7 @@ export class ConfirmationHook implements PreToolHook {
    */
   private lastTimeoutToastAt = 0;
 
-  private waitForConfirmation(request: ConfirmationRequest): Promise<boolean> {
+  private waitForConfirmation(request: ConfirmationRequest, sessionId: string): Promise<boolean> {
     return new Promise<boolean>((resolve) => {
       const expiresAt = Date.now() + this.confirmationTimeoutMs;
 
@@ -430,6 +452,7 @@ export class ConfirmationHook implements PreToolHook {
         timer,
         toolName: request.toolName,
         expiresAt,
+        sessionId,
         // v0.3.2 批量审批：同步缓存完整请求信息，供 getPendingConfirmations() 返回
         args: request.args,
         riskLevel: request.riskLevel,
@@ -447,13 +470,49 @@ export class ConfirmationHook implements PreToolHook {
   }
 
   /**
-   * 清理所有等待中的确认（会话结束时调用）
+   * 清理等待中的确认（会话中断时调用）
+   *
+   * v0.5.0: 支持按会话清理 — 多会话并发时，中断 A 会话只拒绝 A 的 pending，
+   * 不再误杀 B 会话等待中的确认请求（原实现全局清空）。
+   *
+   * @param sessionId 指定会话 ID 时只清理该会话的 pending；缺省时清空全部（紧急路径）
    */
-  clearPending(): void {
-    for (const [, pending] of this.pendingConfirmations) {
+  clearPending(sessionId?: string): void {
+    if (sessionId === undefined) {
+      for (const [, pending] of this.pendingConfirmations) {
+        clearTimeout(pending.timer);
+        pending.resolve(false);
+      }
+      this.pendingConfirmations.clear();
+      return;
+    }
+    for (const [id, pending] of this.pendingConfirmations) {
+      if (pending.sessionId !== sessionId) continue;
       clearTimeout(pending.timer);
       pending.resolve(false);
+      this.pendingConfirmations.delete(id);
+    }
+  }
+
+  // ===== 私有辅助（v0.5.0: 会话隔离） =====
+
+  /** 获取（或创建）指定会话的决策记忆表 */
+  private decisionsFor(sessionId: string): Map<string, { approved: boolean; at: number }> {
+    let decisions = this.rememberedDecisions.get(sessionId);
+    if (!decisions) {
+      decisions = new Map();
+      this.rememberedDecisions.set(sessionId, decisions);
+    }
+    return decisions;
+  }
+
+  /** 清除所有会话中指定工具的拒绝记忆（setAutoExecute 启用时调用） */
+  private clearDenialMemoryAllSessions(toolName: string): void {
+    for (const decisions of this.rememberedDecisions.values()) {
+      const decision = decisions.get(toolName);
+      if (decision && !decision.approved) {
+        decisions.delete(toolName);
+      }
     }
-    this.pendingConfirmations.clear();
   }
 }

electron/harness/orchestration/orchestrator.ts

@@ -24,7 +24,12 @@ import { EventEmitter } from 'events';
 import { nanoid } from 'nanoid';
 import { AgentLoopEngine } from '../agent-loop/engine';
 import type { AgentLoopConfig } from '../agent-loop/types';
-import type { MetonaMessage, MetonaSystemPrompt, MetonaToolDef, IMetonaProviderAdapter } from '../types';
+import type {
+  MetonaMessage,
+  MetonaSystemPrompt,
+  MetonaToolDef,
+  IMetonaProviderAdapter,
+} from '../types';
 import type { ToolRegistry } from '../tools/registry';
 import type { PreToolHook } from '../hooks/pre-tool';
 import type { PostToolHook } from '../hooks/post-tool';
@@ -32,12 +37,28 @@ import log from 'electron-log';
 
 export interface SubAgentResult {
   taskId: string;
+  /** v0.5.0: 委派方（父会话）ID — 供事件消费者按会话过滤 */
+  parentSessionId: string;
   result: string;
   success: boolean;
   durationMs: number;
   iterations: number;
 }
 
+/**
+ * v0.5.0: SubAgent 生命周期事件载荷（统一广播给前端 AgentMonitor 展示）
+ */
+export interface SubAgentEvent {
+  taskId: string;
+  parentSessionId: string;
+  description: string;
+  status: 'delegated' | 'running' | 'completed' | 'error';
+  depth: number;
+  durationMs?: number;
+  iterations?: number;
+  error?: string;
+}
+
 /**
  * P2-10: 引擎供给接口（由 AgentEngineManager 实现）
  * orchestrator 不再持有单个引擎引用，而是按需创建独立实例。
@@ -115,9 +136,12 @@ export class TaskOrchestrator extends EventEmitter {
     // ===== 递归深度检查 =====
     const currentDepth = this.sessionDepth.get(params.parentSessionId) ?? 0;
     if (currentDepth >= MAX_DELEGATION_DEPTH) {
-      log.warn(`[Orchestrator] Delegation depth limit reached (${currentDepth}) for session ${params.parentSessionId}`);
+      log.warn(
+        `[Orchestrator] Delegation depth limit reached (${currentDepth}) for session ${params.parentSessionId}`,
+      );
       return {
         taskId,
+        parentSessionId: params.parentSessionId,
         result: `SubAgent delegation depth limit reached (${MAX_DELEGATION_DEPTH}). Cannot delegate further.`,
         success: false,
         durationMs: 0,
@@ -127,7 +151,12 @@ export class TaskOrchestrator extends EventEmitter {
     const depth = currentDepth + 1;
     this.sessionDepth.set(params.parentSessionId, depth);
 
-    this.emit('taskDelegated', { taskId, description: params.description, parentSessionId: params.parentSessionId, depth });
+    this.emit('taskDelegated', {
+      taskId,
+      description: params.description,
+      parentSessionId: params.parentSessionId,
+      depth,
+    });
 
     // ===== 创建独立的引擎实例（P2-10: 独立 adapter，隔离 abort 信号） =====
     const subEngine = new AgentLoopEngine(
@@ -147,6 +176,10 @@ export class TaskOrchestrator extends EventEmitter {
     subEngine.setFallbackAdapter(this.engines.getFallbackAdapter());
     subEngine.setWorkspacePath(this.engines.getWorkspacePath());
 
+    // v0.5.0: 转发 SubEngine 的流式/状态事件（供 TRACE 录制与前端可观测）
+    // 事件以 taskId 为 sessionId，录制到独立 JSONL 文件，不污染父会话的流
+    this.forwardSubEngineEvents(subEngine, taskId);
+
     // ===== 工具白名单设置 =====
     const allowedTools = this.resolveTools(params.tools);
     subEngine.setTools(allowedTools);
@@ -163,11 +196,21 @@ export class TaskOrchestrator extends EventEmitter {
         handle.status = 'error';
         this.activeSubAgents.delete(taskId);
       },
-      getStatus: () => ({ taskId, status: handle.status, description: handle.description, depth: handle.depth }),
+      getStatus: () => ({
+        taskId,
+        status: handle.status,
+        description: handle.description,
+        depth: handle.depth,
+      }),
     };
 
     this.activeSubAgents.set(taskId, handle);
-    this.emit('taskStarted', { taskId, depth });
+    this.emit('taskStarted', {
+      taskId,
+      description: params.description,
+      parentSessionId: params.parentSessionId,
+      depth,
+    });
 
     try {
       // 构建用户消息
@@ -184,7 +227,7 @@ export class TaskOrchestrator extends EventEmitter {
       const output = await subEngine.runStream(
         userMessage,
         taskId,
-        [],  // 子 Agent 无历史
+        [], // 子 Agent 无历史
         systemPrompt,
       );
 
@@ -192,6 +235,7 @@ export class TaskOrchestrator extends EventEmitter {
       const success = output.terminationReason === 'completed';
       const result: SubAgentResult = {
         taskId,
+        parentSessionId: params.parentSessionId,
         result: output.finalAnswer,
         success,
         durationMs,
@@ -202,7 +246,9 @@ export class TaskOrchestrator extends EventEmitter {
       handle.result = result;
       this.emit('taskCompleted', result);
 
-      log.info(`[Orchestrator] SubAgent "${taskId}" (depth=${depth}) ${success ? 'completed' : 'failed'} in ${durationMs}ms, ${output.iterations.length} iterations`);
+      log.info(
+        `[Orchestrator] SubAgent "${taskId}" (depth=${depth}) ${success ? 'completed' : 'failed'} in ${durationMs}ms, ${output.iterations.length} iterations`,
+      );
 
       return result;
     } catch (error) {
@@ -210,6 +256,7 @@ export class TaskOrchestrator extends EventEmitter {
       const errMsg = (error as Error).message;
       const result: SubAgentResult = {
         taskId,
+        parentSessionId: params.parentSessionId,
         result: errMsg,
         success: false,
         durationMs,
@@ -218,7 +265,12 @@ export class TaskOrchestrator extends EventEmitter {
 
       handle.status = 'error';
       handle.result = result;
-      this.emit('taskError', { taskId, error: errMsg });
+      this.emit('taskError', {
+        taskId,
+        parentSessionId: params.parentSessionId,
+        description: params.description,
+        error: errMsg,
+      });
 
       log.error(`[Orchestrator] SubAgent "${taskId}" (depth=${depth}) error: ${errMsg}`);
 
@@ -326,13 +378,25 @@ export class TaskOrchestrator extends EventEmitter {
     const handle = this.activeSubAgents.get(taskId);
     if (handle && handle.status === 'running') {
       handle.status = success ? 'completed' : 'error';
-      handle.result = { taskId, result, success, durationMs: 0, iterations: 0 };
+      handle.result = {
+        taskId,
+        parentSessionId: handle.parentSessionId,
+        result,
+        success,
+        durationMs: 0,
+        iterations: 0,
+      };
       this.activeSubAgents.delete(taskId);
       this.emit('taskCompleted', handle.result);
     }
   }
 
-  getActiveAgentsStatus(): Array<{ taskId: string; status: string; description: string; depth: number }> {
+  getActiveAgentsStatus(): Array<{
+    taskId: string;
+    status: string;
+    description: string;
+    depth: number;
+  }> {
     return Array.from(this.activeSubAgents.values()).map((a) => a.getStatus());
   }
 
@@ -350,4 +414,24 @@ export class TaskOrchestrator extends EventEmitter {
     // 配合 delegate finally 块的 has() 检查：若已被 clear，finally 不再恢复（避免覆盖）。
     this.sessionDepth.clear();
   }
+
+  /**
+   * v0.5.0: 转发 SubEngine 的事件到 orchestrator 事件总线
+   *
+   * SubEngine 不经过 AgentEngineManager 的转发管道（刻意隔离，避免污染父会话流），
+   * 此处将其流式/状态事件重新包装为 subStreamEvent / subStateChange 广播：
+   * - IPC 层监听后录制到独立 TRACE 文件（sessionId = taskId）
+   * - 生命周期事件（taskDelegated 等）另行广播给前端 AgentMonitor
+   *
+   * @param engine SubAgent 的独立引擎实例
+   * @param taskId 子任务 ID（SubEngine runStream 的 sessionId）
+   */
+  private forwardSubEngineEvents(engine: AgentLoopEngine, taskId: string): void {
+    engine.on('streamEvent', (event: Record<string, unknown>) => {
+      this.emit('subStreamEvent', { taskId, event });
+    });
+    engine.on('stateChange', (data: Record<string, unknown>) => {
+      this.emit('subStateChange', { taskId, data });
+    });
+  }
 }