diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..34e49f61
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,297 @@
+# AGENTS.md
+
+This file provides guidance to Codex (Codex.ai/code) when working with code in this repository.
+
+**重要提示：**
+- 当功能发生变化时，请保持此文件和 `README.md` 同步更新。请更新文档以反映当前状态，但是需要经过我的允许后再修改。
+- 所有的注释和日志优先采用中文，保留必要的专业术语部分。
+- 所有的依赖包的安装都要先进行搜索，综合判断依赖采用的版本，而不是默认采用某个版本。
+- 状态管理上我们全部采用 Jotai 来实现。
+- 这是个开源项目，本地存储优先，善用配置文件优于大部分默认采用 localstorage，不采用本地数据库方案。
+- 保证充分的组件化以及人类的可读性，每次完成改动后都要思考这一点，运行@code-simplifier 来简化优化代码，保持简单直接不过渡设计的风格。
+- 在 UI 设计上采用更现代的方案，UI 组件推荐采用 ShadcnUI，在合适的情况下，用卡片和阴影取代边框，用符合主题的饱满色彩，设置界面要设置背景，为未来做不同主题留下空间。
+- 采用 BDD 行为驱动开发的方案。
+
+## 项目概述
+
+Proma 是一个集成通用 AI Agent 的下一代人工智能软件，采用 Electron 桌面应用架构。
+
+## Monorepo 结构
+
+Bun workspace monorepo：
+
+```
+proma/
+├── packages/
+│   ├── core/       # AI Provider 适配器、代码高亮服务 (Shiki)
+│   ├── shared/     # 共享类型、IPC 通道常量、配置、Agent 工具匹配
+│   └── ui/         # 共享 UI 组件 (CodeBlock, MermaidBlock, useSmoothStream)
+└── apps/
+    └── electron/   # Electron 桌面应用
+        └── src/
+            ├── main/       # 主进程 + 服务层 (main/lib/)
+            ├── preload/    # IPC 上下文桥接
+            └── renderer/   # React UI (Vite + Tailwind + ShadcnUI)
+```
+
+**包命名规范**：`@proma/*` 作用域（`@proma/core`、`@proma/shared`、`@proma/ui`、`@proma/electron`）
+
+**依赖管理**：package.json 中使用 `workspace:*` 引用内部包
+
+## 常用命令
+
+```bash
+# 开发模式（推荐 - 自动启动 Vite + Electron + 热重载）
+bun run dev
+
+# 手动开发模式（调试时更稳定）
+# 终端 1: cd apps/electron && bun run dev:vite
+# 终端 2: cd apps/electron && bun run dev:electron
+
+# 构建并运行
+bun run electron:start
+
+# 仅构建
+bun run electron:build
+
+# 类型检查（所有包）
+bun run typecheck
+
+# 单包类型检查
+cd packages/core && bun run typecheck
+
+# 测试
+bun test
+
+# 打包分发
+cd apps/electron
+bun run dist:mac      # macOS
+bun run dist:win      # Windows
+bun run dist:linux    # Linux
+bun run dist:fast     # 当前架构快速打包
+```
+
+### Electron 构建脚本（`apps/electron/` 目录下）
+
+```bash
+bun run build:main        # esbuild → dist/main.cjs
+bun run build:preload     # esbuild → dist/preload.cjs
+bun run build:renderer    # Vite → dist/renderer/
+bun run build:resources   # 复制 resources/ 到 dist/
+bun run generate:icons    # 生成应用图标
+```
+
+## 运行时环境
+
+使用 Bun 代替 Node.js/npm/pnpm：
+
+- `bun install` 安装依赖，`bun run <script>` 运行脚本
+- `bun test` 运行测试（内置测试运行器，`import { test, expect } from "bun:test"`）
+- Bun 自动加载 .env 文件（无需 dotenv）
+- 优先使用 Bun 原生 API：`Bun.file` > `node:fs`，`Bun.$\`command\`` > `execa`
+
+## 核心架构
+
+### IPC 通信模式（最重要的架构模式）
+
+类型定义 → 主进程处理 → Preload 桥接 → 渲染进程调用：
+
+1. **类型 & 常量**：`@proma/shared` 定义 IPC 通道名称常量和请求/响应类型
+2. **主进程处理**：`main/ipc.ts` 注册 `ipcMain.handle()` 处理器，调用 `main/lib/` 服务
+3. **Preload 桥接**：`preload/index.ts` 通过 `contextBridge.exposeInMainWorld` 暴露类型安全的 API
+4. **渲染进程**：通过 `window.electronAPI.*` 调用，Jotai atoms 中封装调用逻辑
+
+添加新 IPC 通道时，需要同步修改这四个位置。
+
+### 主进程服务层（`main/lib/`）
+
+| 服务 | 职责 |
+|------|------|
+| `channel-manager.ts` | 渠道 CRUD、API Key AES-256-GCM 加密（Electron safeStorage）、连接测试、模型获取 |
+| `conversation-manager.ts` | 对话 CRUD、JSONL 消息存储、置顶、上下文分割 |
+| `chat-service.ts` | AI 流式调用编排、Provider 适配器集成、消息持久化、AbortController |
+| `agent-service.ts` | Agent SDK 调用编排、流式事件转换与推送、AbortController |
+| `agent-session-manager.ts` | Agent 会话 CRUD、JSONL 消息存储 |
+| `agent-prompt-builder.ts` | Agent 系统提示词构建（注入工作区上下文） |
+| `agent-workspace-manager.ts` | 工作区管理、MCP Server 配置、Skills 配置 |
+| `attachment-service.ts` | 附件存储/读取/删除、文件对话框 |
+| `document-parser.ts` | 文档文本提取（PDF/Office/文本文件） |
+| `user-profile-service.ts` | 用户档案持久化 |
+| `settings-service.ts` | 应用设置持久化（主题等） |
+| `config-paths.ts` | `~/.proma/` 目录路径管理 |
+| `runtime-init.ts` | Bun/Git 运行时检测（`bun-finder.ts`、`git-detector.ts`、`shell-env.ts`） |
+
+### AI Provider 适配器（`packages/core/src/providers/`）
+
+基于适配器模式的多 Provider 支持：
+
+- `ProviderAdapter` 接口定义统一的 `sendMessage()` 流式方法
+- **Anthropic**：`anthropic-adapter.ts` — Messages API，支持 extended_thinking
+- **OpenAI / DeepSeek / Custom**：`openai-adapter.ts` — Chat Completions API
+- **Google**：`google-adapter.ts` — Generative Language API
+- `sse-reader.ts`：通用 SSE 流读取器（fetch + ReadableStream）
+- 多模态支持：图片（各 Provider 格式不同）、文档（提取文本注入 `<file>` XML 标签）
+
+### Jotai 状态管理（`renderer/atoms/`）
+
+| Atom 文件 | 管理的状态 |
+|-----------|-----------|
+| `chat-atoms.ts` | 对话列表、当前消息、流式状态（Map 结构支持多对话并行）、模型选择、上下文设置、并排模式、思考模式、待上传附件 |
+| `agent-atoms.ts` | Agent 会话列表、当前会话、流式状态（`AgentStreamState`）、工作区选择、渠道选择、权限/AskUser 请求队列（按 sessionId Map） |
+| `active-view.ts` | 主面板视图切换（'conversations' / 'settings'） |
+| `app-mode.ts` | 应用模式（Chat / Agent） |
+| `settings-tab.ts` | 设置面板当前标签页 |
+| `theme.ts` | 主题模式（light / dark / system） |
+| `user-profile.ts` | 用户档案（姓名 + 头像） |
+| `updater.ts` | 自动更新状态（检查/下载/安装），优雅降级（updater 不可用时保持 idle） |
+
+### 渲染进程组件架构（`renderer/components/`）
+
+- **`app-shell/`**：三面板布局（LeftSidebar | NavigatorPanel | MainContentPanel），侧边栏含模式切换、置顶对话、日期分组列表、流式指示器
+- **`chat/`**：聊天核心 — ChatView（消息加载/流式订阅）、ChatHeader（模型选择/上下文设置）、ChatInput（Tiptap 富文本编辑器）、ChatMessages（消息列表/自动滚动）、ParallelChatMessages（并排模式）
+- **`agent/`**：Agent 模式 — AgentView（纯展示 + 交互，IPC 监听已提升到全局）、AgentHeader（渠道/模型选择）、AgentMessages（消息列表 + 工具活动）、ToolActivityItem（工具调用展示）、WorkspaceSelector（工作区切换）、PermissionBanner/AskUserBanner（权限/问答请求 UI）
+- **`settings/`**：设置面板 — GeneralSettings（用户档案）、AppearanceSettings（主题）、ChannelSettings（渠道管理）、ChannelForm（Provider 配置）、AgentSettings（Agent 渠道/工作区/MCP）、McpServerForm（MCP 服务器配置）、AboutSettings（版本/更新）；含 `primitives/` 可复用表单组件
+- **`file-browser/`**：文件浏览器 — FileBrowser（工作区文件树浏览）
+- **`ai-elements/`**：AI 展示组件 — Markdown 渲染、代码块、Mermaid 图、推理折叠、上下文分割线、富文本输入
+- **`ui/`**：ShadcnUI 组件（new-york 风格，CSS 变量主题）
+
+### 全局 Hooks（`renderer/hooks/`）
+
+| Hook | 职责 |
+|------|------|
+| `useGlobalAgentListeners` | 全局 Agent IPC 监听器，在 `main.tsx` 顶层挂载，使用 `useStore()` 直接操作 atoms。处理流式事件、完成/错误、标题更新、权限请求、AskUser 请求，永不随组件卸载销毁 |
+| `useBackgroundTasks` | 后台任务管理（Agent/Shell 任务的增删改查），按 sessionId 隔离 |
+
+### 渲染进程初始化组件（`renderer/main.tsx`）
+
+| 组件 | 职责 |
+|------|------|
+| `ThemeInitializer` | 从主进程加载主题设置、监听系统主题变化、同步到 DOM |
+| `AgentSettingsInitializer` | 加载 Agent 渠道/模型/工作区设置、订阅 MCP/文件变化事件 |
+| `AgentListenersInitializer` | 挂载 `useGlobalAgentListeners`，全局 Agent IPC 监听 |
+| `UpdaterInitializer` | 订阅主进程推送的自动更新状态变化事件 |
+
+### 本地文件存储（`~/.proma/`）
+
+```
+~/.proma/
+├── channels.json           # 渠道配置（API Key 经 safeStorage 加密）
+├── conversations.json      # 对话索引（元数据，轻量）
+├── conversations/          # 消息存储
+│   └── {uuid}.jsonl        # 每对话一个 JSONL 文件，追加写入
+├── agent-sessions.json     # Agent 会话索引
+├── agent-sessions/         # Agent 会话消息存储
+│   └── {uuid}.jsonl        # 每会话一个 JSONL 文件
+├── workspaces/             # 工作区配置
+│   └── {slug}/
+│       └── config.json     # MCP Server、Skills 等配置
+├── attachments/            # 附件文件
+│   └── {conversationId}/
+│       └── {uuid}.ext
+├── user-profile.json       # 用户档案 { userName, avatar }
+└── settings.json           # 应用设置 { themeMode }
+```
+
+关键设计：JSON 配置 + JSONL 追加日志，无本地数据库，文件可移植。
+
+## 构建工具
+
+- **主进程/Preload**：esbuild (`--bundle --platform=node --format=cjs --external:electron --external:@anthropic-ai/Codex-agent-sdk`)
+- **渲染进程**：Vite + React 插件 + Tailwind CSS + HMR
+- **开发热重载**：渲染进程 Vite HMR 即时生效；主进程/Preload 通过 electronmon 监听 dist 文件变化自动重启
+- **打包分发**：electron-builder（配置见 `electron-builder.yml`）
+
+### 重要：打包配置注意事项
+
+**Agent SDK 打包要求（必须遵守）：**
+- `@anthropic-ai/Codex-agent-sdk` 必须使用 `--external` 参数排除在 esbuild 打包之外
+- SDK 必须通过 electron-builder 的 `files` 配置包含到应用中，而不是 `extraResources`
+- 在 `electron-builder.yml` 的 `files` 配置中添加：
+  ```yaml
+  files:
+    - dist/**/*
+    - package.json
+    - node_modules/@anthropic-ai/Codex-agent-sdk/**/*
+    - "!node_modules/@proma/**"
+  ```
+- 这样 SDK 会被复制到 `app/node_modules/@anthropic-ai/Codex-agent-sdk`，与 dist 和 package.json 同级
+- Node.js 的模块解析会从 `app/dist/main.cjs` 向上查找，能正确找到 `app/node_modules/` 下的 SDK
+
+**为什么不使用 extraResources：**
+- `extraResources` 会将文件复制到 `Contents/Resources/` 目录
+- 使用 `to: app/node_modules/...` 路径时，Node.js 模块解析可能无法正确找到
+- 直接使用 `files` 配置更简单可靠，确保 SDK 在正确的 node_modules 路径下
+
+**修改打包配置时的检查清单：**
+1. ✅ 确认 SDK 在 esbuild 中使用 `--external` 参数
+2. ✅ 确认 SDK 在 `files` 配置中被正确包含
+3. ✅ 本地测试打包后的应用 Agent 功能（使用 `CSC_IDENTITY_AUTO_DISCOVERY=false bunx electron-builder --mac --dir` 快速测试）
+
+**其他依赖的打包策略：**
+- **原则**：只有 `electron` 和 `@anthropic-ai/Codex-agent-sdk` 需要标记为 `--external`
+- `electron`：由 Electron 运行时提供，必须 external
+- `@anthropic-ai/Codex-agent-sdk`：有特殊打包要求（symlink、vendor 等），必须 external + 在 files 中包含
+- **所有其他依赖**（如 `electron-updater`、`undici`、`chokidar` 等）：应该让 esbuild 打包进 `main.cjs`
+  - ✅ 优点：避免遗漏子依赖，简化 electron-builder 配置
+  - ❌ 如果标记为 external：必须在 `electron-builder.yml` 的 `files` 中手动列出所有子依赖
+- **常见错误**：将普通 npm 包标记为 external 但忘记在 `files` 中包含，导致打包后找不到模块（如 `Cannot find module 'universalify'`）
+
+## 代码风格
+
+- 永远不要使用 `any` 类型 — 创建合适的 interface
+- 对象类型优先使用 interface 而不是 type
+- 尽可能使用 `import type` 进行仅类型导入
+- 注释和日志采用中文，保留专业术语
+- **路径别名**：`@/` → `apps/electron/src/renderer/`
+
+## TypeScript 配置
+
+- Module: `"Preserve"` + `"moduleResolution": "bundler"`
+- JSX: `"react-jsx"`，严格模式启用，Target: ESNext
+- 所有包 `"type": "module"`，导入时使用 `.ts` 扩展名
+
+## 版本管理
+
+提交代码时始终递增受影响包的 patch 版本（如 `0.1.18` → `0.1.19`），影响多个包则都要递增。
+
+## Agent SDK 集成架构
+
+基于 `@anthropic-ai/Codex-agent-sdk` 实现 Agent 模式，与 Chat 模式并行：
+
+### 核心流程
+
+```
+用户输入 → agent-service.ts (SDK query) → SDK SDKMessage 流
+→ convertSDKMessage() → AgentEvent[] → webContents.send()
+→ useGlobalAgentListeners (全局 IPC 监听) → store.set(atoms) → React UI
+```
+
+### 关键设计
+
+- **SDK 调用**：`sdk.query({ prompt, options: { apiKey, model, permissionMode: 'bypassPermissions', allowDangerouslySkipPermissions: true, cwd, abortController } })`
+- **事件转换**：`convertSDKMessage()`（`@proma/shared`）将 SDK 原始消息转为统一的 `AgentEvent` 类型
+- **工具匹配**：`packages/shared/src/agent/tool-matching.ts` — 无状态 `ToolIndex` + `extractToolStarts` / `extractToolResults` 解析工具调用
+- **状态管理**：`applyAgentEvent()` 纯函数更新 `AgentStreamState`，支持流式增量更新
+- **全局 IPC 监听**：`useGlobalAgentListeners`（`renderer/hooks/`）在 `main.tsx` 顶层挂载，通过 `useStore()` 直接操作 atoms，永不销毁。确保页面切换（如设置页）时流式输出、权限请求不丢失
+- **权限请求排队**：权限/AskUser 请求按 sessionId 入队到 Map atoms（`allPendingPermissionRequestsAtom` / `allPendingAskUserRequestsAtom`），不区分当前/后台会话，SDK Promise 等待用户回来响应
+- **工作区隔离**：每个工作区独立的 MCP Server 配置和 cwd，Agent 会话按工作区过滤
+
+### 共享类型（`@proma/shared`）
+
+- `AgentEvent`：Agent 事件（text / tool_start / tool_result / done / error）
+- `AgentSessionMeta`：会话元数据（id / title / channelId / workspaceId）
+- `AgentMessage`：持久化消息（role + content blocks）
+- `AgentSendInput`：发送请求输入
+- `AGENT_IPC_CHANNELS`：Agent 相关 IPC 通道常量
+- `WorkspaceCapabilities`：工作区能力（MCP Server 列表 + Skills 列表）
+
+## 创作参考
+
+遵循 [craft-agents-oss](https://github.com/craftship/craft-agents-oss) 的模式：
+
+- **会话管理**：收件箱/归档工作流
+- **权限模式**：safe / ask / allow-all
+- **Agent SDK**：@anthropic-ai/Codex-agent-sdk（[v1 文档](https://platform.Codex.com/docs/en/agent-sdk/typescript)、[v2 文档](https://platform.Codex.com/docs/en/agent-sdk/typescript-v2-preview)）
+- **MCP 集成**：Model Context Protocol 用于外部数据源
+- **凭证存储**：AES-256-GCM 加密
+- **配置位置**：`~/.proma/`（类似 `~/.craft-agent/`）
diff --git a/apps/electron/package.json b/apps/electron/package.json
index 50835a63..153fc3e8 100644
--- a/apps/electron/package.json
+++ b/apps/electron/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@proma/electron",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Proma next gen ai software with general agents - Electron App",
   "main": "dist/main.cjs",
   "author": {
@@ -13,7 +13,7 @@
     "dev": "concurrently -k -n vite,electron -c blue,green \"bun run dev:vite\" \"bun run dev:electron\"",
     "dev:split": "bash scripts/dev-split.sh",
     "dev:vite": "vite dev",
-    "dev:electron": "bun run build:main && bun run build:preload && bun run build:resources && sleep 2 && concurrently -k -n main,preload,app -c yellow,magenta,cyan \"bun run watch:main\" \"bun run watch:preload\" \"bunx electronmon .\"",
+    "dev:electron": "bun run build:main && bun run build:preload && bun run build:resources && sleep 2 && concurrently -k -n main,preload,app -c yellow,magenta,cyan \"bun run watch:main\" \"bun run watch:preload\" \"NODE_ENV=development bunx electronmon .\"",
     "build:main": "esbuild src/main/index.ts --bundle --platform=node --format=cjs --outfile=dist/main.cjs --external:electron --external:@anthropic-ai/claude-agent-sdk",
     "build:preload": "esbuild src/preload/index.ts --bundle --platform=node --format=cjs --outfile=dist/preload.cjs --external:electron",
     "watch:main": "esbuild src/main/index.ts --bundle --platform=node --format=cjs --outfile=dist/main.cjs --external:electron --external:@anthropic-ai/claude-agent-sdk --watch=forever",
diff --git a/apps/electron/src/main/index.ts b/apps/electron/src/main/index.ts
index a3cc6524..6a1b80e4 100644
--- a/apps/electron/src/main/index.ts
+++ b/apps/electron/src/main/index.ts
@@ -2,28 +2,25 @@ import { app, BrowserWindow, Menu, screen, shell } from 'electron'
 import { join } from 'path'
 import { existsSync } from 'fs'
 
-// 清理本地环境中的 ANTHROPIC_* 变量，防止干扰应用的认证流程
-// Electron 桌面应用通过渠道系统管理 API Key，不应受终端环境变量影响
-// 注意：此操作必须在 initializeRuntime()（loadShellEnv）之前执行
-for (const key of Object.keys(process.env)) {
-  if (key.startsWith('ANTHROPIC_')) {
-    delete process.env[key]
-  }
-}
+// 注意：不再在此处清理 ANTHROPIC_* 变量。
+// 清理时机改为 initializeRuntime()（loadShellEnv）之后，
+// 先检测并保存本地环境渠道，再执行全面清理。
+// 详见 app.whenReady() 中的 detectAndSyncLocalChannels + cleanupProviderEnvVars。
 
 import { createApplicationMenu } from './menu'
 import { registerIpcHandlers } from './ipc'
 import { createTray, destroyTray } from './tray'
 import { initializeRuntime } from './lib/runtime-init'
 import { seedDefaultSkills } from './lib/config-paths'
+import { detectAndSyncLocalChannels, cleanupProviderEnvVars } from './lib/local-env-detector'
 import { stopAllAgents } from './lib/agent-service'
 import { stopAllGenerations } from './lib/chat-service'
 import { initAutoUpdater, cleanupUpdater } from './lib/updater/auto-updater'
 import { startWorkspaceWatcher, stopWorkspaceWatcher } from './lib/workspace-watcher'
 import { startChatToolsWatcher, stopChatToolsWatcher } from './lib/chat-tools-watcher'
 import { getIsQuitting, setQuitting } from './lib/app-lifecycle'
-import { feishuBridge } from './lib/feishu-bridge'
-import { getFeishuConfig } from './lib/feishu-config'
+import { feishuBotManager } from './lib/feishu-bot-manager'
+import { listFeishuBots } from './lib/feishu-bot-config'
 
 let mainWindow: BrowserWindow | null = null
 
@@ -112,10 +109,9 @@ function createWindow(): void {
   })
 
   // Load the renderer
-  const isDev = !app.isPackaged
-  if (isDev) {
-    mainWindow.loadURL('http://localhost:5173')
-    mainWindow.webContents.openDevTools()
+  // 开发模式使用 Vite 服务器，生产模式使用本地文件
+  if (process.env.NODE_ENV === 'development') {
+    mainWindow.loadURL('http://localhost:5173/')
   } else {
     mainWindow.loadFile(join(__dirname, 'renderer', 'index.html'))
   }
@@ -128,8 +124,6 @@ function createWindow(): void {
 
   // 拦截页面内导航，外部链接用系统浏览器打开，防止 Electron 窗口被覆盖
   mainWindow.webContents.on('will-navigate', (event, url) => {
-    // 允许开发模式下的 Vite HMR 热重载
-    if (isDev && url.startsWith('http://localhost:')) return
     event.preventDefault()
     if (url.startsWith('http://') || url.startsWith('https://')) {
       shell.openExternal(url)
@@ -166,6 +160,14 @@ app.whenReady().then(async () => {
   // 必须在其他初始化之前执行，确保环境变量正确加载
   await initializeRuntime()
 
+  // 检测本地 Claude Code 环境配置并同步为渠道
+  // 必须在 initializeRuntime()（含 loadShellEnv）之后执行，
+  // 此时 process.env 已包含用户 shell 的完整环境变量。
+  detectAndSyncLocalChannels()
+
+  // 全面清理 Provider 路由变量，防止泄漏到后续 SDK 子进程
+  cleanupProviderEnvVars()
+
   // 同步默认 Skills 模板到 ~/.proma/default-skills/
   seedDefaultSkills()
 
@@ -203,11 +205,11 @@ app.whenReady().then(async () => {
     initAutoUpdater(mainWindow)
   }
 
-  // 飞书 Bridge 自动启动（配置启用时）
-  const feishuConfig = getFeishuConfig()
-  if (feishuConfig.enabled && feishuConfig.appId && feishuConfig.appSecret) {
-    feishuBridge.start().catch((err) => {
-      console.error('[飞书 Bridge] 自动启动失败:', err)
+  // 飞书 Bot 自动启动（启动所有已启用的 Bots）
+  const bots = listFeishuBots().filter((b) => b.enabled)
+  if (bots.length > 0) {
+    feishuBotManager.startAllEnabled(bots).catch((err) => {
+      console.error('[飞书 Bot] 自动启动失败:', err)
     })
   }
 
@@ -243,8 +245,8 @@ app.on('before-quit', () => {
   stopWorkspaceWatcher()
   // 停止 Chat 工具配置文件监听
   stopChatToolsWatcher()
-  // 停止飞书 Bridge
-  feishuBridge.stop()
+  // 停止所有飞书 Bot
+  feishuBotManager.stopAll()
   // Clean up system tray before quitting
   destroyTray()
 })
diff --git a/apps/electron/src/main/ipc.ts b/apps/electron/src/main/ipc.ts
index af504fd6..e887ffe2 100644
--- a/apps/electron/src/main/ipc.ts
+++ b/apps/electron/src/main/ipc.ts
@@ -32,13 +32,11 @@ import type {
   AgentSaveFilesInput,
   AgentSaveWorkspaceFilesInput,
   AgentSavedFile,
-  AgentAttachDirectoryInput,
   WorkspaceAttachDirectoryInput,
-  GetTaskOutputInput,
-  GetTaskOutputResult,
   StopTaskInput,
   WorkspaceMcpConfig,
   SkillMeta,
+  AgentMeta,
   WorkspaceCapabilities,
   FileEntry,
   FileSearchResult,
@@ -58,16 +56,17 @@ import type {
   ChatToolInfo,
   ChatToolState,
   ChatToolMeta,
-  AgentTeamData,
   MoveSessionToWorkspaceInput,
-  FeishuConfigInput,
-  FeishuConfig,
   FeishuBridgeState,
   FeishuTestResult,
   FeishuChatBinding,
   FeishuPresenceReport,
   FeishuNotifyMode,
   FeishuUpdateBindingInput,
+  FeishuBotConfig,
+  FeishuBotConfigInput,
+  FeishuBotStatus,
+  AgentPersona,
 } from '@proma/shared'
 import type { UserProfile, AppSettings } from '../types'
 import { getRuntimeStatus, getGitRepoStatus } from './lib/runtime-init'
@@ -120,8 +119,7 @@ import {
 import { runAgent, stopAgent, generateAgentTitle, saveFilesToAgentSession, saveFilesToWorkspaceFiles, isAgentSessionActive } from './lib/agent-service'
 import { permissionService } from './lib/agent-permission-service'
 import { askUserService } from './lib/agent-ask-user-service'
-import { getAgentTeamData, readAgentOutputFile } from './lib/agent-team-reader'
-import { getAgentSessionWorkspacePath, getAgentWorkspacesDir, getWorkspaceSkillsDir, getWorkspaceFilesDir } from './lib/config-paths'
+import { getAgentSessionWorkspacePath, getAgentWorkspacesDir, getWorkspaceSkillsDir, getWorkspaceFilesDir, getWorkspaceAgentsDir } from './lib/config-paths'
 import {
   listAgentWorkspaces,
   createAgentWorkspace,
@@ -135,11 +133,15 @@ import {
   getAgentWorkspace,
   deleteWorkspaceSkill,
   toggleWorkspaceSkill,
+  getAllWorkspaceAgents,
+  deleteWorkspaceAgent,
+  toggleWorkspaceAgent,
   getWorkspacePermissionMode,
   setWorkspacePermissionMode,
   getWorkspaceAttachedDirectories,
   attachWorkspaceDirectory,
   detachWorkspaceDirectory,
+  deleteWorkspaceFilesDirectory,
 } from './lib/agent-workspace-manager'
 import { getMemoryConfig, setMemoryConfig } from './lib/memory-service'
 import { getAllToolInfos } from './lib/chat-tool-registry'
@@ -158,9 +160,15 @@ import {
   getReleaseByTag,
 } from './lib/github-release-service'
 import { watchAttachedDirectory, unwatchAttachedDirectory } from './lib/workspace-watcher'
-import { getFeishuConfig, saveFeishuConfig, getDecryptedAppSecret } from './lib/feishu-config'
-import { feishuBridge } from './lib/feishu-bridge'
 import { presenceService } from './lib/feishu-presence'
+import { feishuBotManager } from './lib/feishu-bot-manager'
+import {
+  listFeishuBots,
+  saveFeishuBot,
+  deleteFeishuBot,
+  getFeishuBot,
+} from './lib/feishu-bot-config'
+import { getAgentPersona, saveAgentPersona, invalidatePersonaCache } from './lib/agent-persona-service'
 
 /**
  * 注册 IPC 处理器
@@ -795,6 +803,38 @@ export function registerIpcHandlers(): void {
     }
   )
 
+  // 获取工作区子代理列表（含活跃和不活跃，设置页 UI 用）
+  ipcMain.handle(
+    AGENT_IPC_CHANNELS.GET_AGENTS,
+    async (_, workspaceSlug: string): Promise<AgentMeta[]> => {
+      return getAllWorkspaceAgents(workspaceSlug)
+    }
+  )
+
+  // 获取工作区子代理目录绝对路径
+  ipcMain.handle(
+    AGENT_IPC_CHANNELS.GET_AGENTS_DIR,
+    async (_, workspaceSlug: string): Promise<string> => {
+      return getWorkspaceAgentsDir(workspaceSlug)
+    }
+  )
+
+  // 删除工作区子代理
+  ipcMain.handle(
+    AGENT_IPC_CHANNELS.DELETE_AGENT,
+    async (_, workspaceSlug: string, agentSlug: string): Promise<void> => {
+      return deleteWorkspaceAgent(workspaceSlug, agentSlug)
+    }
+  )
+
+  // 切换工作区子代理启用/禁用
+  ipcMain.handle(
+    AGENT_IPC_CHANNELS.TOGGLE_AGENT,
+    async (_, workspaceSlug: string, agentSlug: string, enabled: boolean): Promise<void> => {
+      return toggleWorkspaceAgent(workspaceSlug, agentSlug, enabled)
+    }
+  )
+
   // 发送 Agent 消息（触发 Agent SDK 流式响应）
   ipcMain.handle(
     AGENT_IPC_CHANNELS.SEND_MESSAGE,
@@ -813,24 +853,6 @@ export function registerIpcHandlers(): void {
 
   // ===== Agent 后台任务管理 =====
 
-  // 获取任务输出（保留接口，供未来扩展）
-  ipcMain.handle(
-    AGENT_IPC_CHANNELS.GET_TASK_OUTPUT,
-    async (_, input: GetTaskOutputInput): Promise<GetTaskOutputResult> => {
-      try {
-        // TODO: 实现通过 SDK 的 TaskOutput 获取任务输出
-        console.warn('[IPC] GET_TASK_OUTPUT: 当前版本暂未实现，返回空输出')
-        return {
-          output: '',
-          isComplete: false,
-        }
-      } catch (error) {
-        console.error('[IPC] 获取任务输出失败:', error)
-        throw error
-      }
-    }
-  )
-
   // ===== Agent 权限系统 =====
 
   // 响应权限请求
@@ -1076,24 +1098,6 @@ export function registerIpcHandlers(): void {
     }
   )
 
-  // ===== Agent Teams 数据 =====
-
-  // 获取 Team 聚合数据（团队配置 + 任务列表 + 收件箱）
-  ipcMain.handle(
-    AGENT_IPC_CHANNELS.GET_TEAM_DATA,
-    async (_, sdkSessionId: string): Promise<AgentTeamData | null> => {
-      return getAgentTeamData(sdkSessionId)
-    }
-  )
-
-  // 读取 Teammate 输出文件内容
-  ipcMain.handle(
-    AGENT_IPC_CHANNELS.GET_AGENT_OUTPUT,
-    async (_, filePath: string): Promise<string> => {
-      return readAgentOutputFile(filePath)
-    }
-  )
-
   // ===== Agent 附件 =====
 
   // 保存文件到 Agent session 工作目录
@@ -1140,41 +1144,46 @@ export function registerIpcHandlers(): void {
     }
   )
 
-  // 附加外部目录到 Agent 会话
+  // 打开文件或文件夹选择对话框（同时支持）
   ipcMain.handle(
-    AGENT_IPC_CHANNELS.ATTACH_DIRECTORY,
-    async (_, input: AgentAttachDirectoryInput): Promise<string[]> => {
-      const meta = getAgentSessionMeta(input.sessionId)
-      if (!meta) throw new Error(`会话不存在: ${input.sessionId}`)
+    AGENT_IPC_CHANNELS.OPEN_FILE_OR_FOLDER_DIALOG,
+    async (): Promise<import('@proma/shared').FileOrFolderDialogResult | null> => {
+      const win = BrowserWindow.getFocusedWindow() ?? BrowserWindow.getAllWindows()[0]
+      if (!win) return null
 
-      const existing = meta.attachedDirectories ?? []
-      if (existing.includes(input.directoryPath)) return existing
+      const result = await dialog.showOpenDialog(win, {
+        properties: ['openFile', 'openDirectory', 'multiSelections'],
+        title: '选择文件或文件夹',
+        filters: [
+          { name: '支持的文件', extensions: ['*'] },
+          { name: '所有文件', extensions: ['*'] },
+        ],
+      })
 
-      const updated = [...existing, input.directoryPath]
-      updateAgentSessionMeta(input.sessionId, { attachedDirectories: updated })
-      // 启动附加目录文件监听
-      watchAttachedDirectory(input.directoryPath)
-      return updated
-    }
-  )
+      if (result.canceled || result.filePaths.length === 0) return null
 
-  // 移除会话的附加目录
-  ipcMain.handle(
-    AGENT_IPC_CHANNELS.DETACH_DIRECTORY,
-    async (_, input: AgentAttachDirectoryInput): Promise<string[]> => {
-      const meta = getAgentSessionMeta(input.sessionId)
-      if (!meta) throw new Error(`会话不存在: ${input.sessionId}`)
+      const { readFileSync } = await import('node:fs')
+      const files: Array<{ filename: string; data: string }> = []
+      const folders: Array<{ path: string; name: string }> = []
+      const { statSync } = await import('node:fs')
 
-      const existing = meta.attachedDirectories ?? []
-      const updated = existing.filter((d) => d !== input.directoryPath)
-      updateAgentSessionMeta(input.sessionId, { attachedDirectories: updated })
-      // 停止附加目录文件监听
-      unwatchAttachedDirectory(input.directoryPath)
-      return updated
+      for (const filePath of result.filePaths) {
+        const stats = statSync(filePath)
+        if (stats.isDirectory()) {
+          const name = filePath.split('/').filter(Boolean).pop() || 'folder'
+          folders.push({ path: filePath, name })
+        } else {
+          const filename = filePath.split('/').filter(Boolean).pop() || 'file'
+          const buffer = readFileSync(filePath)
+          files.push({ filename, data: buffer.toString('base64') })
+        }
+      }
+
+      return { files, folders }
     }
   )
 
-  // 附加外部目录到工作区（所有会话可访问）
+  // 关联外部目录到工作区（所有会话可访问）
   ipcMain.handle(
     AGENT_IPC_CHANNELS.ATTACH_WORKSPACE_DIRECTORY,
     async (_, input: WorkspaceAttachDirectoryInput): Promise<string[]> => {
@@ -1202,6 +1211,14 @@ export function registerIpcHandlers(): void {
     }
   )
 
+  // 删除工作区的上传文件目录
+  ipcMain.handle(
+    AGENT_IPC_CHANNELS.DELETE_WORKSPACE_FILES,
+    async (_, workspaceSlug: string): Promise<void> => {
+      deleteWorkspaceFilesDirectory(workspaceSlug)
+    }
+  )
+
   // ===== Agent 文件系统操作 =====
 
   // 获取 session 工作路径
@@ -1291,13 +1308,30 @@ export function registerIpcHandlers(): void {
   // 在系统文件管理器中显示文件
   ipcMain.handle(
     AGENT_IPC_CHANNELS.SHOW_IN_FOLDER,
-    async (_, filePath: string): Promise<void> => {
-      const { resolve } = await import('node:path')
+    async (_, filePath: string, sessionId?: string, workspaceId?: string): Promise<void> => {
+      const { resolve, join, isAbsolute } = await import('node:path')
+
+      let targetPath = filePath
+      
+      // 如果是相对路径且提供了 sessionId 和 workspaceId，构建绝对路径
+      if (!isAbsolute(filePath) && sessionId && workspaceId) {
+        const ws = getAgentWorkspace(workspaceId)
+        if (ws) {
+          const sessionDir = getAgentSessionWorkspacePath(ws.slug, sessionId)
+          targetPath = join(sessionDir, filePath)
+        }
+      }
 
-      const safePath = resolve(filePath)
+      const safePath = resolve(targetPath)
+      
+      // 安全校验：路径必须在 agent-workspaces 目录下或是系统临时目录
       const workspacesRoot = resolve(getAgentWorkspacesDir())
-      if (!safePath.startsWith(workspacesRoot)) {
-        throw new Error('访问路径超出 Agent 工作区范围')
+      const tmpDir = resolve('/private/tmp')
+      const isInWorkspaces = safePath.startsWith(workspacesRoot)
+      const isInTmp = safePath.startsWith(tmpDir)
+      
+      if (!isInWorkspaces && !isInTmp) {
+        throw new Error('访问路径超出允许范围')
       }
 
       shell.showItemInFolder(safePath)
@@ -1428,6 +1462,19 @@ export function registerIpcHandlers(): void {
     }
   )
 
+  // 删除附加目录文件/空目录（无工作区路径限制）
+  ipcMain.handle(
+    AGENT_IPC_CHANNELS.DELETE_ATTACHED_FILE,
+    async (_, filePath: string): Promise<void> => {
+      const { rmSync } = await import('node:fs')
+      const { resolve } = await import('node:path')
+
+      const safePath = resolve(filePath)
+      rmSync(safePath, { recursive: true, force: true })
+      console.log(`[附加目录] 已删除: ${safePath}`)
+    }
+  )
+
   // 搜索工作区文件（用于 @ 引用，递归扫描，支持附加目录）
   ipcMain.handle(
     AGENT_IPC_CHANNELS.SEARCH_WORKSPACE_FILES,
@@ -1587,90 +1634,84 @@ export function registerIpcHandlers(): void {
 
   // ===== 飞书集成 =====
 
-  // 获取飞书配置
-  ipcMain.handle(
-    FEISHU_IPC_CHANNELS.GET_CONFIG,
-    async (): Promise<FeishuConfig> => {
-      return getFeishuConfig()
-    }
-  )
-
-  // 获取解密后的 App Secret
-  ipcMain.handle(
-    FEISHU_IPC_CHANNELS.GET_DECRYPTED_SECRET,
-    async (): Promise<string> => {
-      return getDecryptedAppSecret()
-    }
-  )
-
-  // 保存飞书配置
-  ipcMain.handle(
-    FEISHU_IPC_CHANNELS.SAVE_CONFIG,
-    async (_, input: FeishuConfigInput): Promise<FeishuConfig> => {
-      const config = saveFeishuConfig(input)
-      // 配置变更后自动重启或停止 Bridge
-      if (input.enabled && input.appId && input.appSecret) {
-        await feishuBridge.restart()
-      } else if (!input.enabled) {
-        feishuBridge.stop()
-      }
-      return config
-    }
-  )
-
   // 测试飞书连接
   ipcMain.handle(
     FEISHU_IPC_CHANNELS.TEST_CONNECTION,
     async (_, appId: string, appSecret: string): Promise<FeishuTestResult> => {
-      return feishuBridge.testConnection(appId, appSecret)
+      return feishuBotManager.testConnection(appId, appSecret)
     }
   )
 
-  // 启动飞书 Bridge
+  // 启动飞书 Bridge（旧版兼容：启动所有已启用的 Bots）
   ipcMain.handle(
     FEISHU_IPC_CHANNELS.START_BRIDGE,
     async (): Promise<void> => {
-      await feishuBridge.start()
+      const bots = listFeishuBots().filter((b) => b.enabled)
+      await feishuBotManager.startAllEnabled(bots)
     }
   )
 
-  // 停止飞书 Bridge
+  // 停止飞书 Bridge（旧版兼容：停止所有 Bots）
   ipcMain.handle(
     FEISHU_IPC_CHANNELS.STOP_BRIDGE,
     async (): Promise<void> => {
-      feishuBridge.stop()
+      feishuBotManager.stopAll()
     }
   )
 
-  // 获取飞书 Bridge 状态
+  // 获取飞书 Bridge 状态（旧版兼容：聚合所有 Bot 状态）
   ipcMain.handle(
     FEISHU_IPC_CHANNELS.GET_STATUS,
     async (): Promise<FeishuBridgeState> => {
-      return feishuBridge.getStatus()
+      return feishuBotManager.getAggregateStatus()
     }
   )
 
-  // 获取活跃绑定列表
+  // 获取活跃绑定列表（旧版兼容：从所有 Bots 收集）
   ipcMain.handle(
     FEISHU_IPC_CHANNELS.LIST_BINDINGS,
     async (): Promise<FeishuChatBinding[]> => {
-      return feishuBridge.listBindings()
+      const statuses = feishuBotManager.getAllBotStatuses()
+      const allBindings: FeishuChatBinding[] = []
+      for (const status of statuses) {
+        const bridge = feishuBotManager.getBridge(status.botId)
+        if (bridge) {
+          allBindings.push(...bridge.listBindings())
+        }
+      }
+      return allBindings
     }
   )
 
-  // 更新绑定（工作区/会话）
+  // 更新绑定（工作区/会话）- 旧版兼容：遍历所有 Bots 查找
   ipcMain.handle(
     FEISHU_IPC_CHANNELS.UPDATE_BINDING,
     async (_, input: FeishuUpdateBindingInput): Promise<FeishuChatBinding | null> => {
-      return feishuBridge.updateBinding(input)
+      const statuses = feishuBotManager.getAllBotStatuses()
+      for (const status of statuses) {
+        const bridge = feishuBotManager.getBridge(status.botId)
+        if (bridge) {
+          const result = bridge.updateBinding(input)
+          if (result) return result
+        }
+      }
+      return null
     }
   )
 
-  // 移除绑定
+  // 移除绑定 - 旧版兼容：遍历所有 Bots 查找
   ipcMain.handle(
     FEISHU_IPC_CHANNELS.REMOVE_BINDING,
     async (_, chatId: string): Promise<boolean> => {
-      return feishuBridge.removeBinding(chatId)
+      const statuses = feishuBotManager.getAllBotStatuses()
+      for (const status of statuses) {
+        const bridge = feishuBotManager.getBridge(status.botId)
+        if (bridge) {
+          const result = bridge.removeBinding(chatId)
+          if (result) return true
+        }
+      }
+      return false
     }
   )
 
@@ -1682,11 +1723,117 @@ export function registerIpcHandlers(): void {
     }
   )
 
-  // 设置会话通知模式
+  // 设置会话通知模式（旧版兼容：为所有运行中的 Bots 设置）
   ipcMain.handle(
     FEISHU_IPC_CHANNELS.SET_SESSION_NOTIFY,
     async (_, sessionId: string, mode: FeishuNotifyMode): Promise<void> => {
-      feishuBridge.setSessionNotifyMode(sessionId, mode)
+      const statuses = feishuBotManager.getAllBotStatuses()
+      for (const status of statuses) {
+        const bridge = feishuBotManager.getBridge(status.botId)
+        if (bridge) {
+          bridge.setSessionNotifyMode(sessionId, mode)
+        }
+      }
+    }
+  )
+
+  // ===== 多飞书 Bot 管理 =====
+
+  // 获取所有 Bot 配置
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.LIST_BOTS,
+    async (): Promise<{ bots: FeishuBotConfig[]; migrated: false }> => {
+      // migrated 始终为 false，旧配置迁移已移除
+      return { bots: listFeishuBots(), migrated: false }
+    }
+  )
+
+  // 保存 Bot（新建或更新）
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.SAVE_BOT,
+    async (_, input: FeishuBotConfigInput, existingId?: string): Promise<FeishuBotConfig> => {
+      console.log('[IPC] SAVE_BOT called:', { input, existingId })
+      const bot = saveFeishuBot(input, existingId)
+      console.log('[IPC] SAVE_BOT result:', { botId: bot.id, botName: bot.name, enabled: bot.enabled, hasSecret: !!bot.appSecret })
+      // 如果 Bot 已启用，自动启动
+      if (bot.enabled) {
+        try {
+          console.log('[IPC] Bot enabled, calling updateRunningBotBindings and startBot')
+          // 如果 Bot 已运行，同步更新所有绑定的工作区 ID
+          feishuBotManager.updateRunningBotBindings(bot.id, bot.workspaceId)
+          await feishuBotManager.startBot(bot)
+          console.log('[IPC] startBot completed successfully')
+        } catch (error) {
+          console.error('[IPC] 启动 Bot 失败:', error)
+        }
+      } else {
+        console.log('[IPC] Bot disabled, stopping')
+        feishuBotManager.stopBot(bot.id)
+      }
+      return bot
+    }
+  )
+
+  // 删除 Bot
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.DELETE_BOT,
+    async (_, botId: string): Promise<boolean> => {
+      feishuBotManager.stopBot(botId)
+      return deleteFeishuBot(botId)
+    }
+  )
+
+  // 启动指定 Bot
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.START_BOT,
+    async (_, botId: string): Promise<void> => {
+      const bot = getFeishuBot(botId)
+      if (!bot) {
+        throw new Error(`Bot not found: ${botId}`)
+      }
+      await feishuBotManager.startBot(bot)
+    }
+  )
+
+  // 停止指定 Bot
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.STOP_BOT,
+    async (_, botId: string): Promise<void> => {
+      feishuBotManager.stopBot(botId)
+    }
+  )
+
+  // 获取指定 Bot 状态
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.GET_BOT_STATUS,
+    async (_, botId: string): Promise<FeishuBotStatus | null> => {
+      return feishuBotManager.getBotStatus(botId)
+    }
+  )
+
+  // ===== Agent Persona =====
+
+  // 获取 Agent persona 文件
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.GET_AGENT_PERSONA,
+    async (_, workspaceSlug: string): Promise<AgentPersona> => {
+      return getAgentPersona(workspaceSlug)
+    }
+  )
+
+  // 保存 Agent persona 文件
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.SAVE_AGENT_PERSONA,
+    async (_, workspaceSlug: string, persona: AgentPersona): Promise<void> => {
+      saveAgentPersona(workspaceSlug, persona)
+    }
+  )
+
+  // 使 persona 缓存失效
+  ipcMain.handle(
+    FEISHU_IPC_CHANNELS.INVALIDATE_PERSONA_CACHE,
+    async (_, workspaceSlug?: string): Promise<void> => {
+      invalidatePersonaCache(workspaceSlug)
     }
   )
 
diff --git a/apps/electron/src/main/lib/adapters/claude-agent-adapter.ts b/apps/electron/src/main/lib/adapters/claude-agent-adapter.ts
index 6f1f43c9..aabd7856 100644
--- a/apps/electron/src/main/lib/adapters/claude-agent-adapter.ts
+++ b/apps/electron/src/main/lib/adapters/claude-agent-adapter.ts
@@ -159,6 +159,8 @@ export interface ClaudeAgentQueryOptions extends AgentQueryInput {
   sdkSessionId?: string
   /** 附加的外部目录（SDK additionalDirectories） */
   additionalDirectories?: string[]
+  /** 启用子代理进度摘要（~30s 周期性 AI 生成描述） */
+  agentProgressSummaries?: boolean
 }
 
 // ============================================================================
@@ -352,6 +354,26 @@ export class ClaudeAgentAdapter implements AgentProviderAdapter {
         }
         events.push(...toolStartEvents)
 
+        // 检测 TodoWrite 工具调用
+        for (const block of content) {
+          if (block.type === 'tool_use' && block.name === 'TodoWrite') {
+            const todoBlock = block as { id: string; name: string; input: Record<string, unknown> }
+            const todos = todoBlock.input.todos as Array<{ content: string; status: string; activeForm?: string }>
+            if (Array.isArray(todos)) {
+              events.push({
+                type: 'todo_update',
+                groupId: todoBlock.id,
+                todos: todos.map((t, index) => ({
+                  id: `${todoBlock.id}-todo-${index}`, // 使用 tool_use_id + 索引生成唯一 id
+                  content: t.content,
+                  status: t.status as import('@proma/shared').TodoStatus,
+                  activeForm: t.activeForm,
+                })),
+              })
+            }
+          }
+        }
+
         // 文本累积
         let textContent = ''
         for (const block of content) {
@@ -582,7 +604,7 @@ export class ClaudeAgentAdapter implements AgentProviderAdapter {
       type: 'system'; subtype?: string; status?: string
       task_id?: string; tool_use_id?: string; description?: string; task_type?: string
       // Agent Teams: task_progress 扩展字段
-      last_tool_name?: string; usage?: { total_tokens?: number; tool_uses?: number; duration_ms?: number }
+      last_tool_name?: string; usage?: { total_tokens?: number; tool_uses?: number; duration_ms?: number; total_cost_usd?: number }
       // Agent Teams: task_notification 扩展字段
       summary?: string; output_file?: string
     }
@@ -598,6 +620,7 @@ export class ClaudeAgentAdapter implements AgentProviderAdapter {
         toolUseId: msg.tool_use_id,
         description: msg.description || `Task ${msg.task_id}`,
         taskType: msg.task_type,
+        prompt: (msg as { prompt?: string }).prompt,
         turnId: turnId.value || undefined,
       })
     } else if (msg.subtype === 'task_progress' && msg.task_id) {
@@ -609,6 +632,7 @@ export class ClaudeAgentAdapter implements AgentProviderAdapter {
         // 不设 elapsedSeconds — system task_progress 无真实计时，避免覆盖 tool_progress 的值
         description: msg.description,
         lastToolName: msg.last_tool_name,
+        summary: (msg as { summary?: string }).summary,
         usage: msg.usage ? {
           totalTokens: msg.usage.total_tokens ?? 0,
           toolUses: msg.usage.tool_uses ?? 0,
@@ -629,6 +653,7 @@ export class ClaudeAgentAdapter implements AgentProviderAdapter {
           totalTokens: msg.usage.total_tokens ?? 0,
           toolUses: msg.usage.tool_uses ?? 0,
           durationMs: msg.usage.duration_ms ?? 0,
+          costUsd: msg.usage.total_cost_usd,
         } : undefined,
         turnId: turnId.value || undefined,
       })
@@ -740,6 +765,7 @@ export class ClaudeAgentAdapter implements AgentProviderAdapter {
         ...(options.effort && { effort: options.effort }),
         ...(options.agents && { agents: options.agents }),
         ...(options.agent && { agent: options.agent }),
+        ...(options.agentProgressSummaries != null && { agentProgressSummaries: options.agentProgressSummaries }),
         ...(options.enableFileCheckpointing != null && { enableFileCheckpointing: options.enableFileCheckpointing }),
         ...(options.disallowedTools && { disallowedTools: options.disallowedTools }),
         ...(options.fallbackModel && { fallbackModel: options.fallbackModel }),
diff --git a/apps/electron/src/main/lib/agent-env-builder.ts b/apps/electron/src/main/lib/agent-env-builder.ts
new file mode 100644
index 00000000..11746867
--- /dev/null
+++ b/apps/electron/src/main/lib/agent-env-builder.ts
@@ -0,0 +1,93 @@
+/**
+ * AgentEnvBuilder — SDK 环境变量构建
+ *
+ * 从 AgentOrchestrator 提取的环境变量构建逻辑，负责：
+ * - Provider 路由变量黑名单过滤
+ * - 渠道特定环境变量注入（api_key / vertex / bedrock）
+ * - 代理设置注入
+ * - Windows Shell 配置
+ */
+
+import type { Channel } from '@proma/shared'
+import { isProviderRoutingVar } from '@proma/shared'
+import { normalizeAnthropicBaseUrlForSdk } from '@proma/core'
+import { decryptChannelEnvVars } from './channel-manager'
+import { getEffectiveProxyUrl } from './proxy-settings-service'
+import { getRuntimeStatus } from './runtime-init'
+import { getSdkConfigDir } from './config-paths'
+
+const DEFAULT_ANTHROPIC_URL = 'https://api.anthropic.com'
+
+/**
+ * 构建 SDK 子进程环境变量（渠道感知，完全隔离）
+ *
+ * 使用完整的 Provider 路由变量黑名单过滤 process.env，
+ * 然后根据渠道的 authType 注入对应的环境变量。
+ */
+export async function buildSdkEnv(
+  apiKey: string,
+  channel: Channel,
+): Promise<Record<string, string | undefined>> {
+  const authType = channel.authType || 'api_key'
+
+  // 第1步：从 process.env 继承系统变量，使用完整黑名单过滤所有 Provider 路由变量
+  const cleanEnv: Record<string, string | undefined> = {}
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!isProviderRoutingVar(key)) {
+      cleanEnv[key] = value
+    }
+  }
+
+  // 第2步：构建基础 SDK 环境变量
+  const sdkEnv: Record<string, string | undefined> = {
+    ...cleanEnv,
+    CLAUDE_CODE_MAX_OUTPUT_TOKENS: '64000',
+    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+    CLAUDE_CODE_ENABLE_TASKS: 'true',
+    CLAUDE_CONFIG_DIR: getSdkConfigDir(),
+  }
+
+  // 第3步：根据 authType 注入渠道特定的环境变量
+  if (authType === 'api_key') {
+    sdkEnv.ANTHROPIC_API_KEY = apiKey
+    if (channel.baseUrl && channel.baseUrl !== DEFAULT_ANTHROPIC_URL) {
+      sdkEnv.ANTHROPIC_BASE_URL = normalizeAnthropicBaseUrlForSdk(channel.baseUrl)
+    }
+  } else {
+    const channelEnvVars = decryptChannelEnvVars(channel.id)
+    for (const [key, value] of Object.entries(channelEnvVars)) {
+      sdkEnv[key] = value
+    }
+    if (apiKey) {
+      sdkEnv.ANTHROPIC_AUTH_TOKEN = apiKey
+    }
+  }
+
+  // 第4步：注入代理设置
+  const proxyUrl = await getEffectiveProxyUrl()
+  if (proxyUrl) {
+    sdkEnv.HTTPS_PROXY = proxyUrl
+    sdkEnv.HTTP_PROXY = proxyUrl
+  }
+
+  // 第5步：Windows 平台 Shell 配置
+  if (process.platform === 'win32') {
+    const runtimeStatus = getRuntimeStatus()
+    const shellStatus = runtimeStatus?.shell
+
+    if (shellStatus) {
+      if (shellStatus.gitBash?.available && shellStatus.gitBash.path) {
+        sdkEnv.CLAUDE_CODE_SHELL = shellStatus.gitBash.path
+        console.log(`[EnvBuilder] 配置 Shell 环境: Git Bash (${shellStatus.gitBash.path})`)
+      } else if (shellStatus.wsl?.available) {
+        sdkEnv.CLAUDE_CODE_SHELL = 'wsl'
+        console.log(`[EnvBuilder] 配置 Shell 环境: WSL ${shellStatus.wsl.version} (${shellStatus.wsl.defaultDistro})`)
+      } else {
+        console.warn('[EnvBuilder] Windows 平台未检测到可用的 Shell 环境（Git Bash / WSL）')
+      }
+      sdkEnv.CLAUDE_BASH_NO_LOGIN = '1'
+    }
+  }
+
+  return sdkEnv
+}
diff --git a/apps/electron/src/main/lib/agent-event-bus.ts b/apps/electron/src/main/lib/agent-event-bus.ts
index 778e983b..510589fd 100644
--- a/apps/electron/src/main/lib/agent-event-bus.ts
+++ b/apps/electron/src/main/lib/agent-event-bus.ts
@@ -30,6 +30,8 @@ export type AgentEventMiddleware = (
 export class AgentEventBus {
   private handlers: Set<AgentEventHandler> = new Set()
   private middlewares: AgentEventMiddleware[] = []
+  /** sessionId → 该 session 专用的 handlers（用于跨 Bot 隔离） */
+  private sessionHandlers = new Map<string, Set<AgentEventHandler>>()
 
   /**
    * 发射事件
@@ -39,6 +41,7 @@ export class AgentEventBus {
    */
   emit(sessionId: string, event: AgentEvent): void {
     const dispatch = (): void => {
+      // 全局 handlers
       for (const handler of this.handlers) {
         try {
           handler(sessionId, event)
@@ -46,6 +49,18 @@ export class AgentEventBus {
           console.error(`[AgentEventBus] 事件处理器错误:`, error)
         }
       }
+
+      // session 专属 handlers
+      const sessionHandlers = this.sessionHandlers.get(sessionId)
+      if (sessionHandlers) {
+        for (const handler of sessionHandlers) {
+          try {
+            handler(sessionId, event)
+          } catch (error) {
+            console.error(`[AgentEventBus] Session 事件处理器错误:`, error)
+          }
+        }
+      }
     }
 
     if (this.middlewares.length === 0) {
@@ -86,6 +101,25 @@ export class AgentEventBus {
     }
   }
 
+  /**
+   * 注册指定 session 的事件监听器（精准订阅）
+   *
+   * 用于 SingleBotBridge 等组件，只监听自己拥有的 session 的事件，
+   * 避免跨 Bot 通知问题。
+   */
+  onForSession(sessionId: string, handler: AgentEventHandler): () => void {
+    if (!this.sessionHandlers.has(sessionId)) {
+      this.sessionHandlers.set(sessionId, new Set())
+    }
+    this.sessionHandlers.get(sessionId)!.add(handler)
+    return () => {
+      this.sessionHandlers.get(sessionId)?.delete(handler)
+      if (this.sessionHandlers.get(sessionId)?.size === 0) {
+        this.sessionHandlers.delete(sessionId)
+      }
+    }
+  }
+
   /** 注册中间件（按注册顺序执行） */
   use(middleware: AgentEventMiddleware): void {
     this.middlewares.push(middleware)
@@ -94,6 +128,7 @@ export class AgentEventBus {
   /** 移除所有监听器和中间件 */
   dispose(): void {
     this.handlers.clear()
+    this.sessionHandlers.clear()
     this.middlewares = []
   }
 }
diff --git a/apps/electron/src/main/lib/agent-mcp-builder.ts b/apps/electron/src/main/lib/agent-mcp-builder.ts
new file mode 100644
index 00000000..b8d6c66c
--- /dev/null
+++ b/apps/electron/src/main/lib/agent-mcp-builder.ts
@@ -0,0 +1,128 @@
+/**
+ * AgentMcpBuilder — MCP 服务器配置构建
+ *
+ * 从 AgentOrchestrator 提取的 MCP 配置构建逻辑，负责：
+ * - 工作区 MCP 服务器配置构建
+ * - 内置记忆工具注入（MemOS Cloud）
+ * - Nano Banana 生图工具注入
+ */
+
+import { getWorkspaceMcpConfig } from './agent-workspace-manager'
+import { getMemoryConfig } from './memory-service'
+import { searchMemory, addMemory, formatSearchResult } from './memos-client'
+
+/**
+ * 构建工作区 MCP 服务器配置
+ */
+export function buildMcpServers(workspaceSlug: string | undefined): Record<string, Record<string, unknown>> {
+  const mcpServers: Record<string, Record<string, unknown>> = {}
+  if (!workspaceSlug) return mcpServers
+
+  const mcpConfig = getWorkspaceMcpConfig(workspaceSlug)
+  for (const [name, entry] of Object.entries(mcpConfig.servers ?? {})) {
+    if (!entry.enabled) continue
+    if (name === 'memos-cloud') continue
+
+    if (entry.type === 'stdio' && entry.command) {
+      const mergedEnv: Record<string, string> = {
+        ...(process.env.PATH && { PATH: process.env.PATH }),
+        ...entry.env,
+      }
+      mcpServers[name] = {
+        type: 'stdio',
+        command: entry.command,
+        ...(entry.args && entry.args.length > 0 && { args: entry.args }),
+        ...(Object.keys(mergedEnv).length > 0 && { env: mergedEnv }),
+        required: false,
+        startup_timeout_sec: entry.timeout ?? 30,
+      }
+    } else if ((entry.type === 'http' || entry.type === 'sse') && entry.url) {
+      mcpServers[name] = {
+        type: entry.type,
+        url: entry.url,
+        ...(entry.headers && Object.keys(entry.headers).length > 0 && { headers: entry.headers }),
+        required: false,
+      }
+    }
+  }
+
+  if (Object.keys(mcpServers).length > 0) {
+    console.log(`[McpBuilder] 已加载 ${Object.keys(mcpServers).length} 个 MCP 服务器`)
+  }
+
+  return mcpServers
+}
+
+/**
+ * 注入 SDK 内置记忆工具（全局，不依赖工作区）
+ */
+export async function injectMemoryTools(
+  sdk: typeof import('@anthropic-ai/claude-agent-sdk'),
+  mcpServers: Record<string, Record<string, unknown>>,
+): Promise<void> {
+  const memoryConfig = getMemoryConfig()
+  const memUserId = memoryConfig.userId?.trim() || 'proma-user'
+  if (!memoryConfig.enabled || !memoryConfig.apiKey) return
+
+  try {
+    const { z } = await import('zod')
+    const memosServer = sdk.createSdkMcpServer({
+      name: 'mem',
+      version: '1.0.0',
+      tools: [
+        sdk.tool(
+          'recall_memory',
+          'Search user memories (facts and preferences) from MemOS Cloud. Use this to recall relevant context about the user.',
+          { query: z.string().describe('Search query for memory retrieval'), limit: z.number().optional().describe('Max results (default 6)') },
+          async (args) => {
+            const result = await searchMemory(
+              { apiKey: memoryConfig.apiKey, userId: memUserId, baseUrl: memoryConfig.baseUrl },
+              args.query,
+              args.limit,
+            )
+            return { content: [{ type: 'text' as const, text: formatSearchResult(result) }] }
+          },
+          { annotations: { readOnlyHint: true } },
+        ),
+        sdk.tool(
+          'add_memory',
+          'Store a conversation message pair into MemOS Cloud for long-term memory. Call this after meaningful exchanges worth remembering.',
+          {
+            userMessage: z.string().describe('The user message to store'),
+            assistantMessage: z.string().optional().describe('The assistant response to store'),
+            conversationId: z.string().optional().describe('Conversation ID for grouping'),
+            tags: z.array(z.string()).optional().describe('Tags for categorization'),
+          },
+          async (args) => {
+            await addMemory(
+              { apiKey: memoryConfig.apiKey, userId: memUserId, baseUrl: memoryConfig.baseUrl },
+              args,
+            )
+            return { content: [{ type: 'text' as const, text: 'Memory stored successfully.' }] }
+          },
+        ),
+      ],
+    })
+    mcpServers['mem'] = memosServer as unknown as Record<string, unknown>
+    console.log(`[McpBuilder] 已注入内置记忆工具 (mem)`)
+  } catch (err) {
+    console.error(`[McpBuilder] 注入记忆工具失败:`, err)
+  }
+}
+
+/**
+ * 注入 SDK 内置生图工具（Nano Banana）
+ */
+export async function injectNanoBananaTools(
+  sdk: typeof import('@anthropic-ai/claude-agent-sdk'),
+  mcpServers: Record<string, Record<string, unknown>>,
+  sessionId: string,
+  agentCwd?: string,
+): Promise<void> {
+  try {
+    const { injectNanoBananaMcpServer } = await import('./chat-tools/nano-banana-mcp')
+    await injectNanoBananaMcpServer(sdk, mcpServers, sessionId, agentCwd)
+  } catch (err) {
+    console.error(`[McpBuilder] 注入 Nano Banana MCP 失败:`, err)
+  }
+}
diff --git a/apps/electron/src/main/lib/agent-orchestrator.ts b/apps/electron/src/main/lib/agent-orchestrator.ts
index f77d7b01..09fc9e4b 100644
--- a/apps/electron/src/main/lib/agent-orchestrator.ts
+++ b/apps/electron/src/main/lib/agent-orchestrator.ts
@@ -1,57 +1,28 @@
 /**
- * AgentOrchestrator — Agent 编排层
+ * AgentOrchestrator — Agent 编排层（瘦委托层）
  *
- * 从 agent-service.ts 提取的核心业务逻辑，负责：
+ * 仅负责：
  * - 并发守卫（同一会话不允许并行请求）
- * - 渠道查找 + API Key 解密
- * - 环境变量构建 + SDK 路径解析
- * - 用户/助手消息持久化
- * - 事件流遍历 + 文本累积 + 事件持久化
- * - 错误处理 + 部分内容保存
- * - 自动标题生成
+ * - 创建 SessionRunner 并委托执行
+ * - stop/stopAll 控制
+ * - 标题生成（独立于消息流）
  *
- * 通过 EventBus 分发 AgentEvent，通过 SessionCallbacks 发送控制信号，
- * 完全解耦 Electron IPC，可独立测试（mock Adapter + EventBus）。
+ * 核心执行逻辑已迁移到 SessionRunner。
+ * 环境变量构建 → agent-env-builder.ts
+ * MCP 配置构建 → agent-mcp-builder.ts
+ * 重试与错误分类 → agent-retry-handler.ts
+ * 团队管理 → agent-team-manager.ts
  */
 
-import { randomUUID } from 'node:crypto'
-import { homedir } from 'node:os'
-import { join, dirname } from 'node:path'
-import { existsSync, mkdirSync, symlinkSync } from 'node:fs'
-import { execFileSync } from 'node:child_process'
-import { createRequire } from 'node:module'
-import { app } from 'electron'
-import type { AgentSendInput, AgentEvent, AgentMessage, AgentGenerateTitleInput, AgentProviderAdapter, TypedError, RetryAttempt } from '@proma/shared'
-import { SAFE_TOOLS } from '@proma/shared'
-import type { PermissionRequest, PromaPermissionMode, AskUserRequest } from '@proma/shared'
-import type { ClaudeAgentQueryOptions } from './adapters/claude-agent-adapter'
-import { isPromptTooLongError, friendlyErrorMessage } from './adapters/claude-agent-adapter'
+import type { AgentSendInput, AgentGenerateTitleInput, AgentProviderAdapter } from '@proma/shared'
 import { AgentEventBus } from './agent-event-bus'
-import { decryptApiKey, getChannelById, listChannels } from './channel-manager'
-import { getAdapter, fetchTitle, normalizeAnthropicBaseUrlForSdk } from '@proma/core'
+import { listChannels, decryptApiKey } from './channel-manager'
+import { getAdapter, fetchTitle } from '@proma/core'
 import { getFetchFn } from './proxy-fetch'
 import { getEffectiveProxyUrl } from './proxy-settings-service'
-import { appendAgentMessage, updateAgentSessionMeta, getAgentSessionMeta, getAgentSessionMessages } from './agent-session-manager'
-import { getAgentWorkspace, getWorkspaceMcpConfig, ensurePluginManifest, getWorkspacePermissionMode } from './agent-workspace-manager'
-import { getAgentWorkspacePath, getAgentSessionWorkspacePath, getSdkConfigDir, getWorkspaceFilesDir } from './config-paths'
-import { getWorkspaceAttachedDirectories } from './agent-workspace-manager'
-import { getRuntimeStatus } from './runtime-init'
-import { getSettings } from './settings-service'
-import { buildSystemPromptAppend, buildDynamicContext } from './agent-prompt-builder'
-import { permissionService } from './agent-permission-service'
-import { askUserService } from './agent-ask-user-service'
-import { getMemoryConfig } from './memory-service'
-import { searchMemory, addMemory, formatSearchResult } from './memos-client'
-import {
-  findTeamLeadInboxPath,
-  pollInboxWithRetry,
-  markInboxAsRead,
-  formatInboxPrompt,
-  formatSummaryFallbackPrompt,
-  areAllWorkersIdle,
-  INBOX_RETRY_CONFIG,
-  type TaskNotificationSummary,
-} from './agent-team-reader'
+import { getAgentSessionMessages } from './agent-session-manager'
+import { SessionRunner } from './agent-session-runner'
+import { AgentTeamManager } from './agent-team-manager'
 
 // ===== 类型定义 =====
 
@@ -65,291 +36,12 @@ export interface SessionCallbacks {
   /** 发送流式错误 */
   onError: (error: string) => void
   /** 发送流式完成（携带已持久化的消息列表） */
-  onComplete: (messages?: AgentMessage[]) => void
+  onComplete: (messages?: import('@proma/shared').AgentMessage[]) => void
   /** 发送标题更新 */
   onTitleUpdated: (title: string) => void
 }
 
-// ===== 工具函数 =====
-
-/**
- * 从 stderr 中提取 API 错误信息
- *
- * 解析类似这样的错误：
- * "401 {\"error\":{\"message\":\"...\"}}"
- * "API error: 400 Bad Request ..."
- */
-function extractApiError(stderr: string): { statusCode: number; message: string } | null {
-  if (!stderr) return null
-
-  // 模式 1：JSON 错误格式 - "401 {...}"
-  const jsonMatch = stderr.match(/(\d{3})\s+(\{[^}]*"error"[^}]*\})/s)
-  if (jsonMatch) {
-    try {
-      const statusCode = parseInt(jsonMatch[1]!)
-      const errorObj = JSON.parse(jsonMatch[2]!)
-      const message = errorObj.error?.message || errorObj.message || '未知错误'
-      return { statusCode, message }
-    } catch {
-      // JSON 解析失败，继续尝试其他模式
-    }
-  }
-
-  // 模式 2：API error 格式 - "API error (attempt X/Y): 401 401 {...}"
-  const apiErrorMatch = stderr.match(/API error[^:]*:\s+(\d{3})\s+\d{3}\s+(\{.*?\})/s)
-  if (apiErrorMatch) {
-    try {
-      const statusCode = parseInt(apiErrorMatch[1]!)
-      const errorObj = JSON.parse(apiErrorMatch[2]!)
-      const message = errorObj.error?.message || errorObj.message || '未知错误'
-      return { statusCode, message }
-    } catch {
-      // JSON 解析失败
-    }
-  }
-
-  // 模式 3：直接的状态码 + 消息
-  const simpleMatch = stderr.match(/(\d{3})[:\s]+(.+?)(?:\n|$)/i)
-  if (simpleMatch) {
-    const statusCode = parseInt(simpleMatch[1]!)
-    const message = simpleMatch[2]!.trim()
-    if (statusCode >= 400 && statusCode < 600) {
-      return { statusCode, message }
-    }
-  }
-
-  return null
-}
-
-// ===== 自动重试工具函数 =====
-
-/** 可自动重试的 TypedError 错误码 */
-const AUTO_RETRYABLE_ERROR_CODES: ReadonlySet<string> = new Set([
-  'rate_limited',
-  'provider_error',      // overloaded 映射为 provider_error
-  'service_error',
-  'service_unavailable',
-  'network_error',
-])
-
-/** 判断 typed_error 事件是否可自动重试 */
-function isAutoRetryableTypedError(error: TypedError): boolean {
-  return AUTO_RETRYABLE_ERROR_CODES.has(error.code)
-}
-
-/** 判断 catch 块中的 API 错误是否可自动重试（HTTP 429 / 5xx / 已知可恢复错误模式） */
-function isAutoRetryableCatchError(
-  apiError: { statusCode: number; message: string } | null,
-  rawErrorMessage?: string,
-): boolean {
-  if (apiError) {
-    if (apiError.statusCode === 429 || apiError.statusCode >= 500) return true
-  }
-  // 已知的可恢复错误模式（无 HTTP 状态码但可重试）
-  if (rawErrorMessage) {
-    if (rawErrorMessage.includes('context_management')) return true
-  }
-  return false
-}
-
-/** 最大自动重试次数 */
-const MAX_AUTO_RETRIES = 3
-
-/** 计算重试延迟（指数退避：1s, 2s, 4s） */
-function getRetryDelayMs(attempt: number): number {
-  return Math.min(1000 * Math.pow(2, attempt - 1), 8000)
-}
-
-/**
- * 可中断的定时器
- *
- * 等待指定毫秒，如果 signal 被中止则立即 resolve。
- */
-function timerWithAbort(ms: number, signal: AbortSignal): Promise<void> {
-  return new Promise<void>((resolve) => {
-    if (signal.aborted) { resolve(); return }
-    const tid = setTimeout(resolve, ms)
-    signal.addEventListener('abort', () => { clearTimeout(tid); resolve() }, { once: true })
-  })
-}
-
-/**
- * 解析 SDK cli.js 路径
- *
- * SDK 作为 esbuild external 依赖，require.resolve 可在运行时解析实际路径。
- * 多种策略降级：createRequire → 全局 require → node_modules 手动查找
- *
- * 打包环境下：asar 内的路径需要转换为 asar.unpacked 路径，
- * 因为子进程 (bun) 无法读取 asar 归档内的文件。
- */
-function resolveSDKCliPath(): string {
-  let cliPath: string | null = null
-
-  // 策略 1：createRequire（标准 ESM/CJS 互操作）
-  try {
-    const cjsRequire = createRequire(__filename)
-    const sdkEntryPath = cjsRequire.resolve('@anthropic-ai/claude-agent-sdk')
-    cliPath = join(dirname(sdkEntryPath), 'cli.js')
-    console.log(`[Agent 编排] SDK CLI 路径 (createRequire): ${cliPath}`)
-  } catch (e) {
-    console.warn('[Agent 编排] createRequire 解析 SDK 路径失败:', e)
-  }
-
-  // 策略 2：全局 require（esbuild CJS bundle 可能保留）
-  if (!cliPath) {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const sdkEntryPath = require.resolve('@anthropic-ai/claude-agent-sdk')
-      cliPath = join(dirname(sdkEntryPath), 'cli.js')
-      console.log(`[Agent 编排] SDK CLI 路径 (require.resolve): ${cliPath}`)
-    } catch (e) {
-      console.warn('[Agent 编排] require.resolve 解析 SDK 路径失败:', e)
-    }
-  }
-
-  // 策略 3：从项目根目录手动查找
-  if (!cliPath) {
-    cliPath = join(process.cwd(), 'node_modules', '@anthropic-ai', 'claude-agent-sdk', 'cli.js')
-    console.log(`[Agent 编排] SDK CLI 路径 (手动): ${cliPath}`)
-  }
-
-  // 打包环境：将 .asar/ 路径转换为 .asar.unpacked/
-  if (app.isPackaged && cliPath.includes('.asar')) {
-    cliPath = cliPath.replace(/\.asar([/\\])/, '.asar.unpacked$1')
-    console.log(`[Agent 编排] 转换为 asar.unpacked 路径: ${cliPath}`)
-  }
-
-  return cliPath
-}
-
-/**
- * 获取 Agent SDK 运行时可执行文件
- *
- * 优先级：Node.js → Bun → which node 同步查找 → 字符串 'node'
- *
- * 当 runtimeStatusCache 尚未初始化时（应用启动竞态），
- * 降级到 'node' 字符串可能因 Electron 进程 PATH 不含 node 而触发 ENOENT。
- * 此时用 which/where 同步查找作为兜底，避免 SDK spawn 失败。
- */
-function getAgentExecutable(): { type: 'node' | 'bun'; path: string } {
-  const status = getRuntimeStatus()
-
-  if (status?.node?.available && status.node.path) {
-    return { type: 'node', path: status.node.path }
-  }
-
-  if (status?.bun?.available && status.bun.path) {
-    return { type: 'bun', path: status.bun.path }
-  }
-
-  // runtimeStatusCache 未就绪时，同步查找 node 路径
-  try {
-    const cmd = process.platform === 'win32' ? 'where' : 'which'
-    const nodePath = execFileSync(cmd, ['node'], { encoding: 'utf-8', timeout: 2000 })
-      .trim()
-      .split('\n')[0]
-    if (nodePath && existsSync(nodePath)) {
-      console.warn(`[Agent 编排] runtimeStatusCache 未就绪，同步查找 node: ${nodePath}`)
-      return { type: 'node', path: nodePath }
-    }
-  } catch {
-    // 忽略查找失败，继续降级
-  }
-
-  return { type: 'node', path: 'node' }
-}
-
-/**
- * 确保打包环境下 ripgrep 可被 SDK CLI 找到
- *
- * 通过 symlink 桥接 extraResources → SDK 的 vendor 目录。
- */
-function ensureRipgrepAvailable(cliPath: string): void {
-  if (!app.isPackaged) return
-
-  try {
-    const sdkDir = dirname(cliPath)
-    const arch = process.arch
-    const platform = process.platform
-    const expectedDir = join(sdkDir, 'vendor', 'ripgrep', `${arch}-${platform}`)
-    const resourcesRipgrep = join(process.resourcesPath, 'vendor', 'ripgrep')
-
-    if (existsSync(expectedDir)) return
-
-    if (!existsSync(resourcesRipgrep)) {
-      console.warn(`[Agent 编排] ripgrep 资源不存在: ${resourcesRipgrep}`)
-      return
-    }
-
-    mkdirSync(join(sdkDir, 'vendor', 'ripgrep'), { recursive: true })
-    symlinkSync(resourcesRipgrep, expectedDir, 'junction')
-    console.log(`[Agent 编排] ripgrep symlink 创建成功: ${expectedDir} → ${resourcesRipgrep}`)
-  } catch (error) {
-    console.warn('[Agent 编排] ripgrep symlink 创建失败:', error)
-  }
-}
-
-/** 最大回填消息条数 */
-const MAX_CONTEXT_MESSAGES = 20
-
-/** 单条工具摘要最大字符数 */
-const MAX_TOOL_SUMMARY_LENGTH = 200
-
-/**
- * 从 assistant 消息的 events 中提取工具活动摘要
- *
- * 返回简要的工具名称 + 关键输入信息，帮助新 SDK 会话理解之前做过什么。
- */
-function extractToolSummary(events: import('@proma/shared').AgentEvent[]): string {
-  const summaries: string[] = []
-  for (const event of events) {
-    if (event.type === 'tool_start') {
-      const input = event.input
-      // 提取关键输入参数（如 file_path、command 等）
-      const keyParam = input.file_path ?? input.command ?? input.path ?? input.query ?? ''
-      const paramStr = keyParam ? `: ${String(keyParam).slice(0, 100)}` : ''
-      summaries.push(`[tool: ${event.toolName}${paramStr}]`)
-    }
-  }
-  if (summaries.length === 0) return ''
-  const joined = summaries.join(' ')
-  return joined.length > MAX_TOOL_SUMMARY_LENGTH
-    ? joined.slice(0, MAX_TOOL_SUMMARY_LENGTH) + '...'
-    : joined
-}
-
-/**
- * 构建带历史上下文的 prompt
- *
- * 当 resume 不可用时，将最近消息拼接为上下文注入 prompt，
- * 让新 SDK 会话保留对话记忆。包含文本内容和工具活动摘要。
- */
-function buildContextPrompt(sessionId: string, currentUserMessage: string): string {
-  const allMessages = getAgentSessionMessages(sessionId)
-  if (allMessages.length === 0) return currentUserMessage
-
-  const history = allMessages.slice(0, -1)
-  if (history.length === 0) return currentUserMessage
-
-  const recent = history.slice(-MAX_CONTEXT_MESSAGES)
-  const lines = recent
-    .filter((m) => (m.role === 'user' || m.role === 'assistant') && m.content)
-    .map((m) => {
-      let line = `[${m.role}]: ${m.content}`
-      // assistant 消息附带工具活动摘要，减少迁移后的"失忆"感
-      if (m.role === 'assistant' && m.events && m.events.length > 0) {
-        const toolSummary = extractToolSummary(m.events)
-        if (toolSummary) {
-          line += `\n  工具活动: ${toolSummary}`
-        }
-      }
-      return line
-    })
-
-  if (lines.length === 0) return currentUserMessage
-
-  return `<conversation_history>\n${lines.join('\n')}\n</conversation_history>\n\n${currentUserMessage}`
-}
+// ===== 常量 =====
 
 /** 标题生成 Prompt */
 const TITLE_PROMPT = '根据用户的第一条消息，生成一个简短的对话标题（10字以内）。只输出标题，不要有任何其他内容、标点符号或引号。\n\n用户消息：'
@@ -357,207 +49,54 @@ const TITLE_PROMPT = '根据用户的第一条消息，生成一个简短的对
 /** 标题最大长度 */
 const MAX_TITLE_LENGTH = 20
 
-/** 默认会话标题（用于判断是否需要自动生成） */
-const DEFAULT_SESSION_TITLE = '新 Agent 会话'
-
-/** 默认模型 ID */
-const DEFAULT_MODEL_ID = 'claude-sonnet-4-5-20250929'
-
 // ===== AgentOrchestrator =====
 
 export class AgentOrchestrator {
   private adapter: AgentProviderAdapter
   private eventBus: AgentEventBus
+  private teamManager: AgentTeamManager
   private activeSessions = new Set<string>()
+  private runners = new Map<string, SessionRunner>()
 
   constructor(adapter: AgentProviderAdapter, eventBus: AgentEventBus) {
     this.adapter = adapter
     this.eventBus = eventBus
+    this.teamManager = new AgentTeamManager()
   }
 
   /**
-   * 构建 SDK 环境变量
-   *
-   * 注入 API Key、Base URL、代理、Shell 配置等。
-   */
-  private async buildSdkEnv(
-    apiKey: string,
-    baseUrl: string | undefined,
-  ): Promise<Record<string, string | undefined>> {
-    const DEFAULT_ANTHROPIC_URL = 'https://api.anthropic.com'
-
-    // 从 process.env 继承系统变量，但清理所有 ANTHROPIC_ 前缀的变量，
-    // 防止本地开发环境（如 ANTHROPIC_AUTH_TOKEN、ANTHROPIC_API_KEY、
-    // ANTHROPIC_BASE_URL 等）干扰 SDK 的认证和请求目标。
-    // 即使 index.ts 启动时已清理过一次，initializeRuntime() 中的
-    // loadShellEnv() 可能从 shell 配置文件（~/.zshrc 等）重新注入这些变量。
-    const cleanEnv: Record<string, string | undefined> = {}
-    for (const [key, value] of Object.entries(process.env)) {
-      if (!key.startsWith('ANTHROPIC_')) {
-        cleanEnv[key] = value
-      }
-    }
-
-    const sdkEnv: Record<string, string | undefined> = {
-      ...cleanEnv,
-      ANTHROPIC_API_KEY: apiKey,
-      // 提升输出 token 上限，避免 "exceeded 32000 output token maximum" 错误
-      CLAUDE_CODE_MAX_OUTPUT_TOKENS: '64000',
-      // 启用 Agent Teams（实验性多 Agent 协作）
-      CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
-      // 启用 Tasks 功能
-      CLAUDE_CODE_ENABLE_TASKS: 'true',
-      // 配置隔离：让 SDK 使用独立的配置目录，不读取用户的 ~/.claude.json
-      CLAUDE_CONFIG_DIR: getSdkConfigDir(),
-    }
-
-    // 显式控制 ANTHROPIC_BASE_URL：仅在用户配置了自定义 Base URL 时注入
-    // 使用统一的 normalizeAnthropicBaseUrlForSdk 规范化，SDK 内部会自动拼接 /v1/messages
-    if (baseUrl && baseUrl !== DEFAULT_ANTHROPIC_URL) {
-      sdkEnv.ANTHROPIC_BASE_URL = normalizeAnthropicBaseUrlForSdk(baseUrl)
-    }
-
-    const proxyUrl = await getEffectiveProxyUrl()
-    if (proxyUrl) {
-      sdkEnv.HTTPS_PROXY = proxyUrl
-      sdkEnv.HTTP_PROXY = proxyUrl
-    }
-
-    // Windows 平台：配置 Shell 环境
-    if (process.platform === 'win32') {
-      const runtimeStatus = getRuntimeStatus()
-      const shellStatus = runtimeStatus?.shell
-
-      if (shellStatus) {
-        if (shellStatus.gitBash?.available && shellStatus.gitBash.path) {
-          sdkEnv.CLAUDE_CODE_SHELL = shellStatus.gitBash.path
-          console.log(`[Agent 编排] 配置 Shell 环境: Git Bash (${shellStatus.gitBash.path})`)
-        } else if (shellStatus.wsl?.available) {
-          sdkEnv.CLAUDE_CODE_SHELL = 'wsl'
-          console.log(`[Agent 编排] 配置 Shell 环境: WSL ${shellStatus.wsl.version} (${shellStatus.wsl.defaultDistro})`)
-        } else {
-          console.warn('[Agent 编排] Windows 平台未检测到可用的 Shell 环境（Git Bash / WSL）')
-        }
-        sdkEnv.CLAUDE_BASH_NO_LOGIN = '1'
-      }
-    }
-
-    return sdkEnv
-  }
-
-  /**
-   * 构建工作区 MCP 服务器配置
+   * 发送消息并流式推送事件
    */
-  private buildMcpServers(workspaceSlug: string | undefined): Record<string, Record<string, unknown>> {
-    const mcpServers: Record<string, Record<string, unknown>> = {}
-    if (!workspaceSlug) return mcpServers
-
-    const mcpConfig = getWorkspaceMcpConfig(workspaceSlug)
-    for (const [name, entry] of Object.entries(mcpConfig.servers ?? {})) {
-      if (!entry.enabled) continue
-      if (name === 'memos-cloud') continue
-
-      if (entry.type === 'stdio' && entry.command) {
-        const mergedEnv: Record<string, string> = {
-          ...(process.env.PATH && { PATH: process.env.PATH }),
-          ...entry.env,
-        }
-        mcpServers[name] = {
-          type: 'stdio',
-          command: entry.command,
-          ...(entry.args && entry.args.length > 0 && { args: entry.args }),
-          ...(Object.keys(mergedEnv).length > 0 && { env: mergedEnv }),
-          required: false,
-          startup_timeout_sec: entry.timeout ?? 30,
-        }
-      } else if ((entry.type === 'http' || entry.type === 'sse') && entry.url) {
-        mcpServers[name] = {
-          type: entry.type,
-          url: entry.url,
-          ...(entry.headers && Object.keys(entry.headers).length > 0 && { headers: entry.headers }),
-          required: false,
-        }
-      }
-    }
+  async sendMessage(input: AgentSendInput, callbacks: SessionCallbacks): Promise<void> {
+    const { sessionId } = input
 
-    if (Object.keys(mcpServers).length > 0) {
-      console.log(`[Agent 编排] 已加载 ${Object.keys(mcpServers).length} 个 MCP 服务器`)
+    // 并发保护
+    if (this.activeSessions.has(sessionId)) {
+      console.warn(`[Orchestrator] 会话 ${sessionId} 正在处理中，拒绝新请求`)
+      callbacks.onError('上一条消息仍在处理中，请稍候再试')
+      return
     }
 
-    return mcpServers
-  }
-
-  /**
-   * 注入 SDK 内置记忆工具（全局，不依赖工作区）
-   */
-  private async injectMemoryTools(
-    sdk: typeof import('@anthropic-ai/claude-agent-sdk'),
-    mcpServers: Record<string, Record<string, unknown>>,
-  ): Promise<void> {
-    const memoryConfig = getMemoryConfig()
-    const memUserId = memoryConfig.userId?.trim() || 'proma-user'
-    if (!memoryConfig.enabled || !memoryConfig.apiKey) return
+    this.activeSessions.add(sessionId)
 
     try {
-      const { z } = await import('zod')
-      const memosServer = sdk.createSdkMcpServer({
-        name: 'mem',
-        version: '1.0.0',
-        tools: [
-          sdk.tool(
-            'recall_memory',
-            'Search user memories (facts and preferences) from MemOS Cloud. Use this to recall relevant context about the user.',
-            { query: z.string().describe('Search query for memory retrieval'), limit: z.number().optional().describe('Max results (default 6)') },
-            async (args) => {
-              const result = await searchMemory(
-                { apiKey: memoryConfig.apiKey, userId: memUserId, baseUrl: memoryConfig.baseUrl },
-                args.query,
-                args.limit,
-              )
-              return { content: [{ type: 'text' as const, text: formatSearchResult(result) }] }
-            },
-            { annotations: { readOnlyHint: true } },
-          ),
-          sdk.tool(
-            'add_memory',
-            'Store a conversation message pair into MemOS Cloud for long-term memory. Call this after meaningful exchanges worth remembering.',
-            {
-              userMessage: z.string().describe('The user message to store'),
-              assistantMessage: z.string().optional().describe('The assistant response to store'),
-              conversationId: z.string().optional().describe('Conversation ID for grouping'),
-              tags: z.array(z.string()).optional().describe('Tags for categorization'),
-            },
-            async (args) => {
-              await addMemory(
-                { apiKey: memoryConfig.apiKey, userId: memUserId, baseUrl: memoryConfig.baseUrl },
-                args,
-              )
-              return { content: [{ type: 'text' as const, text: 'Memory stored successfully.' }] }
-            },
-          ),
-        ],
-      })
-      mcpServers['mem'] = memosServer as unknown as Record<string, unknown>
-      console.log(`[Agent 编排] 已注入内置记忆工具 (mem)`)
-    } catch (err) {
-      console.error(`[Agent 编排] 注入记忆工具失败:`, err)
-    }
-  }
+      // 创建 SessionRunner 并执行
+      const runner = new SessionRunner(
+        this.adapter,
+        this.eventBus,
+        this.teamManager,
+        this.activeSessions,
+      )
+      this.runners.set(sessionId, runner)
 
-  /**
-   * 注入 SDK 内置生图工具（Nano Banana）
-   */
-  private async injectNanoBananaTools(
-    sdk: typeof import('@anthropic-ai/claude-agent-sdk'),
-    mcpServers: Record<string, Record<string, unknown>>,
-    sessionId: string,
-    agentCwd?: string,
-  ): Promise<void> {
-    try {
-      const { injectNanoBananaMcpServer } = await import('./chat-tools/nano-banana-mcp')
-      await injectNanoBananaMcpServer(sdk, mcpServers, sessionId, agentCwd)
-    } catch (err) {
-      console.error(`[Agent 编排] 注入 Nano Banana MCP 失败:`, err)
+      await runner.execute(input, callbacks)
+    } catch (error) {
+      // SessionRunner 内部已处理大部分错误并通过 callbacks 通知
+      // 这里只处理未预期的异常
+      console.error(`[Orchestrator] 未预期的异常:`, error)
+    } finally {
+      this.activeSessions.delete(sessionId)
+      this.runners.delete(sessionId)
     }
   }
 
@@ -568,15 +107,11 @@ export class AgentOrchestrator {
    */
   async generateTitle(input: AgentGenerateTitleInput): Promise<string | null> {
     const { userMessage, channelId, modelId } = input
-    console.log('[Agent 标题生成] 开始生成标题:', { channelId, modelId, userMessage: userMessage.slice(0, 50) })
 
     try {
       const channels = listChannels()
       const channel = channels.find((c) => c.id === channelId)
-      if (!channel) {
-        console.warn('[Agent 标题生成] 渠道不存在:', channelId)
-        return null
-      }
+      if (!channel) return null
 
       const apiKey = decryptApiKey(channelId)
       const providerAdapter = getAdapter(channel.provider)
@@ -590,881 +125,24 @@ export class AgentOrchestrator {
       const proxyUrl = await getEffectiveProxyUrl()
       const fetchFn = getFetchFn(proxyUrl)
       const title = await fetchTitle(request, providerAdapter, fetchFn)
-      if (!title) {
-        console.warn('[Agent 标题生成] API 返回空标题')
-        return null
-      }
+      if (!title) return null
 
       const cleaned = title.trim().replace(/^["'""''「《]+|["'""''」》]+$/g, '').trim()
-      const result = cleaned.slice(0, MAX_TITLE_LENGTH) || null
-
-      console.log(`[Agent 标题生成] 生成标题成功: "${result}"`)
-      return result
+      return cleaned.slice(0, MAX_TITLE_LENGTH) || null
     } catch (error) {
-      console.warn('[Agent 标题生成] 生成失败:', error)
+      console.warn('[Orchestrator] 标题生成失败:', error)
       return null
     }
   }
 
-  /**
-   * 流完成后自动生成标题
-   *
-   * 如果会话标题仍为默认值，自动调用标题生成并通过回调通知。
-   */
-  private async autoGenerateTitle(
-    sessionId: string,
-    userMessage: string,
-    channelId: string,
-    modelId: string,
-    callbacks: SessionCallbacks,
-  ): Promise<void> {
-    try {
-      const meta = getAgentSessionMeta(sessionId)
-      if (!meta || meta.title !== DEFAULT_SESSION_TITLE) return
-
-      const title = await this.generateTitle({ userMessage, channelId, modelId })
-      if (!title) return
-
-      updateAgentSessionMeta(sessionId, { title })
-      callbacks.onTitleUpdated(title)
-      console.log(`[Agent 编排] 自动标题生成完成: "${title}"`)
-    } catch (error) {
-      console.warn('[Agent 编排] 自动标题生成失败:', error)
-    }
-  }
-
-  /**
-   * 持久化助手消息（累积的文本 + 事件）
-   */
-  private persistAssistantMessage(
-    sessionId: string,
-    accumulatedText: string,
-    accumulatedEvents: AgentEvent[],
-    resolvedModel: string,
-  ): void {
-    if (!accumulatedText && accumulatedEvents.length === 0) return
-
-    const assistantMsg: AgentMessage = {
-      id: randomUUID(),
-      role: 'assistant',
-      content: accumulatedText,
-      createdAt: Date.now(),
-      model: resolvedModel,
-      events: accumulatedEvents,
-    }
-    appendAgentMessage(sessionId, assistantMsg)
-  }
-
-  /**
-   * 发送消息并流式推送事件
-   *
-   * 核心编排方法，从 agent-service.ts 的 runAgent 提取。
-   * 通过 EventBus 分发 AgentEvent，通过 callbacks 发送控制信号。
-   */
-  async sendMessage(input: AgentSendInput, callbacks: SessionCallbacks): Promise<void> {
-    const { sessionId, userMessage, channelId, modelId, workspaceId, additionalDirectories, customMcpServers, permissionModeOverride, mentionedSkills, mentionedMcpServers } = input
-    const stderrChunks: string[] = []
-
-    // 0. 并发保护
-    if (this.activeSessions.has(sessionId)) {
-      console.warn(`[Agent 编排] 会话 ${sessionId} 正在处理中，拒绝新请求`)
-      callbacks.onError('上一条消息仍在处理中，请稍候再试')
-      return
-    }
-
-    // 1. Windows 平台：检查 Shell 环境可用性
-    if (process.platform === 'win32') {
-      const runtimeStatus = getRuntimeStatus()
-      const shellStatus = runtimeStatus?.shell
-
-      if (shellStatus && !shellStatus.gitBash?.available && !shellStatus.wsl?.available) {
-        const errorMsg = `Windows 平台需要 Git Bash 或 WSL 环境才能运行 Agent。
-
-当前状态：
-- Git Bash: ${shellStatus.gitBash?.error || '未检测到'}
-- WSL: ${shellStatus.wsl?.error || '未检测到'}
-
-解决方案：
-1. 安装 Git for Windows（推荐）: https://git-scm.com/download/win
-2. 或启用 WSL: https://learn.microsoft.com/zh-cn/windows/wsl/install
-
-安装完成后请重启应用。`
-
-        callbacks.onError(errorMsg)
-        return
-      }
-    }
-
-    // 2. 获取渠道信息并解密 API Key
-    const channel = getChannelById(channelId)
-    if (!channel) {
-      callbacks.onError('渠道不存在')
-      return
-    }
-
-    let apiKey: string
-    try {
-      apiKey = decryptApiKey(channelId)
-    } catch {
-      callbacks.onError('解密 API Key 失败')
-      return
-    }
-
-    // 3. 构建环境变量
-    // 同步凭证到 process.env（SDK in-process 代码可能直接读取 process.env）
-    // 先清理再注入，确保 SDK 无论从 env 选项还是 process.env 都拿到正确值
-    delete process.env.ANTHROPIC_API_KEY
-    delete process.env.ANTHROPIC_AUTH_TOKEN
-    delete process.env.ANTHROPIC_BASE_URL
-    process.env.ANTHROPIC_API_KEY = apiKey
-    // 使用与 buildSdkEnv 相同的规范化逻辑，确保 process.env 和 sdkEnv 中的 URL 一致
-    if (channel.baseUrl && channel.baseUrl !== 'https://api.anthropic.com') {
-      process.env.ANTHROPIC_BASE_URL = normalizeAnthropicBaseUrlForSdk(channel.baseUrl)
-    }
-
-    const sdkEnv = await this.buildSdkEnv(apiKey, channel.baseUrl)
-
-    // 4. 读取已有的 SDK session ID（用于 resume）
-    const sessionMeta = getAgentSessionMeta(sessionId)
-    let existingSdkSessionId = sessionMeta?.sdkSessionId
-    console.log(`[Agent 编排] 会话 resume 状态: sdkSessionId=${existingSdkSessionId || '无'}`)
-
-    // 5. 持久化用户消息
-    const userMsg: AgentMessage = {
-      id: randomUUID(),
-      role: 'user',
-      content: userMessage,
-      createdAt: Date.now(),
-    }
-    appendAgentMessage(sessionId, userMsg)
-
-    // 6. 注册活跃会话
-    this.activeSessions.add(sessionId)
-
-    // 7. 状态初始化
-    let accumulatedText = ''
-    const accumulatedEvents: AgentEvent[] = []
-    let resolvedModel = modelId || DEFAULT_MODEL_ID
-    let agentExec: { type: 'node' | 'bun'; path: string } | undefined
-    let agentCwd: string | undefined
-    let workspaceSlug: string | undefined
-    let workspace: import('@proma/shared').AgentWorkspace | undefined
-
-    try {
-      // 8. 动态导入 SDK
-      const sdk = await import('@anthropic-ai/claude-agent-sdk')
-
-      // 9. 构建 SDK query
-      const cliPath = resolveSDKCliPath()
-      agentExec = getAgentExecutable()
-
-      if (!existsSync(cliPath)) {
-        const errMsg = `SDK CLI 文件不存在: ${cliPath}`
-        console.error(`[Agent 编排] ${errMsg}`)
-        callbacks.onError(errMsg)
-        return
-      }
-
-      ensureRipgrepAvailable(cliPath)
-
-      console.log(
-        `[Agent 编排] 启动 SDK — CLI: ${cliPath}, 运行时: ${agentExec.type} (${agentExec.path}), 模型: ${modelId || DEFAULT_MODEL_ID}, resume: ${existingSdkSessionId ?? '无'}`,
-      )
-
-      const nullDevice = process.platform === 'win32' ? 'NUL' : '/dev/null'
-      const executableArgs = agentExec.type === 'bun' ? [`--env-file=${nullDevice}`] : []
-
-      // 确定 Agent 工作目录
-      agentCwd = homedir()
-      workspaceSlug = undefined
-      workspace = undefined
-      if (workspaceId) {
-        const ws = getAgentWorkspace(workspaceId)
-        if (ws) {
-          agentCwd = getAgentSessionWorkspacePath(ws.slug, sessionId)
-          workspaceSlug = ws.slug
-          workspace = ws
-          console.log(`[Agent 编排] 使用 session 级别 cwd: ${agentCwd} (${ws.name}/${sessionId})`)
-
-          ensurePluginManifest(ws.slug, ws.name)
-
-          if (existingSdkSessionId) {
-            console.log(`[Agent 编排] 将尝试 resume: ${existingSdkSessionId}`)
-          } else {
-            console.log(`[Agent 编排] 无 sdkSessionId，将作为新会话启动（回填历史上下文）`)
-          }
-        }
-      }
-
-      // 9.5 验证 sdkSessionId 是否仍然有效（SDK 0.2.53 listSessions）
-      if (existingSdkSessionId) {
-        try {
-          const listSessions = (sdk as unknown as {
-            listSessions: (opts: { dir: string }) => Promise<Array<{ sessionId: string }>>
-          }).listSessions
-          const sessions = await listSessions({ dir: agentCwd })
-          const isValid = sessions.some((s: { sessionId: string }) => s.sessionId === existingSdkSessionId)
-          if (!isValid) {
-            console.log(`[Agent 编排] sdkSessionId 已失效 (${existingSdkSessionId})，将使用上下文注入`)
-            existingSdkSessionId = undefined
-            updateAgentSessionMeta(sessionId, { sdkSessionId: undefined })
-          }
-        } catch {
-          // 验证失败不阻塞主流程
-          console.warn(`[Agent 编排] listSessions 验证失败，继续使用现有 sessionId`)
-        }
-      }
-
-      // 10. 构建 MCP 服务器配置 + 记忆工具 + 生图工具 + 自定义工具
-      const mcpServers = this.buildMcpServers(workspaceSlug)
-      await this.injectMemoryTools(sdk, mcpServers)
-      await this.injectNanoBananaTools(sdk, mcpServers, sessionId, agentCwd)
-
-      // 合并外部注入的自定义 MCP 服务器（如飞书群聊工具）
-      if (customMcpServers) {
-        Object.assign(mcpServers, customMcpServers)
-        console.log(`[Agent 编排] 已合并 ${Object.keys(customMcpServers).length} 个自定义 MCP 服务器`)
-      }
-
-      // 11. 构建动态上下文和最终 prompt
-      const dynamicCtx = buildDynamicContext({
-        workspaceName: workspace?.name,
-        workspaceSlug,
-        agentCwd,
-      })
-
-      // 11.5 注入 mention 引用指令（Skill/MCP）— 仅影响 prompt，不影响持久化
-      let enrichedMessage = userMessage
-      if (mentionedSkills?.length || mentionedMcpServers?.length) {
-        const toolLines: string[] = ['用户在消息中明确引用了以下工具，请在本次回复中主动调用：']
-        for (const slug of mentionedSkills ?? []) {
-          const qualifiedName = workspaceSlug
-            ? `proma-workspace-${workspaceSlug}:${slug}`
-            : slug
-          toolLines.push(`- Skill: ${qualifiedName}（请立即调用此 Skill）`)
-        }
-        for (const name of mentionedMcpServers ?? []) {
-          toolLines.push(`- MCP 服务器: ${name}（请使用此 MCP 服务器的工具来完成任务）`)
-        }
-        enrichedMessage = `<mentioned_tools>\n${toolLines.join('\n')}\n</mentioned_tools>\n\n${userMessage}`
-        console.log(`[Agent 编排] 注入 mentioned_tools: ${mentionedSkills?.length ?? 0} skills, ${mentionedMcpServers?.length ?? 0} MCP`)
-      }
-
-      const contextualMessage = `${dynamicCtx}\n\n${enrichedMessage}`
-
-      const isCompactCommand = userMessage.trim() === '/compact'
-      const finalPrompt = isCompactCommand
-        ? '/compact'
-        : existingSdkSessionId
-          ? contextualMessage
-          : buildContextPrompt(sessionId, contextualMessage)
-
-      if (existingSdkSessionId) {
-        console.log(`[Agent 编排] 使用 resume 模式，SDK session ID: ${existingSdkSessionId}`)
-      } else if (finalPrompt !== contextualMessage) {
-        console.log(`[Agent 编排] 无 resume，已回填历史上下文（最近 ${MAX_CONTEXT_MESSAGES} 条消息）`)
-      }
-
-      // 12. 读取应用设置 + 获取权限模式
-      const appSettings = getSettings()
-      const permissionMode: PromaPermissionMode = permissionModeOverride
-        ?? (workspaceSlug
-          ? getWorkspacePermissionMode(workspaceSlug)
-          : (appSettings.agentPermissionMode ?? 'smart'))
-      console.log(`[Agent 编排] 权限模式: ${permissionMode}${permissionModeOverride ? '（外部覆盖）' : ''}`)
-
-      const canUseTool = permissionMode !== 'auto'
-        ? permissionService.createCanUseTool(
-            sessionId,
-            permissionMode,
-            (request: PermissionRequest) => {
-              const event: AgentEvent = { type: 'permission_request', request }
-              this.eventBus.emit(sessionId, event)
-            },
-            (sid, toolInput, signal, sendAskUser) => askUserService.handleAskUserQuestion(sid, toolInput, signal, sendAskUser),
-            (request: AskUserRequest) => {
-              const event: AgentEvent = { type: 'ask_user_request', request }
-              this.eventBus.emit(sessionId, event)
-            },
-          )
-        : undefined
-
-      // 13. 构建 Adapter 查询选项
-      const maxTurns = appSettings.agentMaxTurns && appSettings.agentMaxTurns > 0
-        ? appSettings.agentMaxTurns
-        : undefined
-      const queryOptions: ClaudeAgentQueryOptions = {
-        sessionId,
-        prompt: finalPrompt,
-        model: modelId || DEFAULT_MODEL_ID,
-        cwd: agentCwd,
-        sdkCliPath: cliPath,
-        executable: agentExec,
-        executableArgs,
-        env: sdkEnv,
-        ...(maxTurns != null && { maxTurns }),
-        sdkPermissionMode: permissionMode === 'auto' ? 'bypassPermissions' : 'default',
-        // 始终为 true：Worker 子代理使用 SDK 内部 mailbox 通信，
-        // 若不跳过权限检查会导致 Worker 阻塞超时并提前停止
-        allowDangerouslySkipPermissions: true,
-        ...(canUseTool && { canUseTool }),
-        ...(permissionMode !== 'auto' && { allowedTools: [...SAFE_TOOLS] }),
-        systemPrompt: {
-          type: 'preset',
-          preset: 'claude_code',
-          append: buildSystemPromptAppend({
-            workspaceName: workspace?.name,
-            workspaceSlug,
-            sessionId,
-            permissionMode,
-          }),
-        },
-        resumeSessionId: existingSdkSessionId,
-        ...(Object.keys(mcpServers).length > 0 && { mcpServers }),
-        ...(workspaceSlug && { plugins: [{ type: 'local' as const, path: getAgentWorkspacePath(workspaceSlug) }] }),
-        // 合并用户附加目录 + 工作区附加目录 + 工作区文件目录
-        ...(() => {
-          const allDirs = [...(additionalDirectories || [])]
-          if (workspaceSlug) {
-            // 工作区级附加目录
-            const workspaceDirs = getWorkspaceAttachedDirectories(workspaceSlug)
-            for (const dir of workspaceDirs) {
-              if (!allDirs.includes(dir)) allDirs.push(dir)
-            }
-            // 工作区文件目录
-            const wsFilesDir = getWorkspaceFilesDir(workspaceSlug)
-            if (!allDirs.includes(wsFilesDir)) {
-              allDirs.push(wsFilesDir)
-            }
-          }
-          return allDirs.length > 0 ? { additionalDirectories: allDirs } : {}
-        })(),
-        // SDK 0.2.52+ 新增选项（从 settings 读取）
-        ...(appSettings.agentThinking && { thinking: appSettings.agentThinking }),
-        ...(appSettings.agentEffort && { effort: appSettings.agentEffort }),
-        ...(appSettings.agentMaxBudgetUsd != null && appSettings.agentMaxBudgetUsd > 0 && {
-          maxBudgetUsd: appSettings.agentMaxBudgetUsd,
-        }),
-        onStderr: (data: string) => {
-          stderrChunks.push(data)
-          console.error(`[Agent SDK stderr] ${data}`)
-        },
-        onSessionId: (sdkSessionId: string) => {
-          capturedSdkSessionId = sdkSessionId
-          if (sdkSessionId !== existingSdkSessionId) {
-            try {
-              updateAgentSessionMeta(sessionId, { sdkSessionId })
-              console.log(`[Agent 编排] 已保存 SDK session_id: ${sdkSessionId}`)
-            } catch {
-              // 索引更新失败不影响主流程
-            }
-          }
-        },
-        onModelResolved: (model: string) => {
-          resolvedModel = model
-          console.log(`[Agent 编排] SDK 确认模型: ${resolvedModel}`)
-          // 通知渲染进程更新流式状态中的模型信息
-          const modelEvent: AgentEvent = { type: 'model_resolved', model }
-          this.eventBus.emit(sessionId, modelEvent)
-        },
-        onContextWindow: (cw: number) => {
-          console.log(`[Agent 编排] 缓存 contextWindow: ${cw}`)
-        },
-      }
-
-      console.log(`[Agent 编排] 开始通过 Adapter 遍历事件流...`)
-
-      // 14. 遍历 Adapter 产出的 AgentEvent 流（含自动重试 + Watchdog 死锁检测）
-      let lastRetryableError: string | undefined
-      let retrySucceeded = false
-
-      // Agent Teams 追踪
-      const startedTaskIds = new Set<string>()
-      const completedTaskIds = new Set<string>()
-      const taskNotificationSummaries: TaskNotificationSummary[] = []
-      /** 捕获到的 SDK session ID（用于 auto-resume 的 inbox 查找） */
-      let capturedSdkSessionId = existingSdkSessionId
-      /** Watchdog 触发标记（死锁被检测到时设为 true） */
-      let abortedByWatchdog = false
-
-      for (let attempt = 1; attempt <= MAX_AUTO_RETRIES + 1; attempt++) {
-        // 非首次尝试：等待 + 发送重试事件到 UI
-        if (attempt > 1) {
-          const delayMs = getRetryDelayMs(attempt - 1)
-          const delaySec = delayMs / 1000
-          const attemptData: RetryAttempt = {
-            attempt: attempt - 1,
-            timestamp: Date.now(),
-            reason: lastRetryableError ?? '未知错误',
-            errorMessage: lastRetryableError ?? '',
-            delaySeconds: delaySec,
-          }
-
-          this.eventBus.emit(sessionId, {
-            type: 'retrying',
-            attempt: attempt - 1,
-            maxAttempts: MAX_AUTO_RETRIES,
-            delaySeconds: delaySec,
-            reason: lastRetryableError ?? '未知错误',
-          })
-          this.eventBus.emit(sessionId, { type: 'retry_attempt', attemptData })
-
-          console.log(`[Agent 编排] 第 ${attempt - 1} 次重试，等待 ${delaySec}s...`)
-          await new Promise((r) => setTimeout(r, delayMs))
-
-          // 等待期间如果会话被中止，退出
-          if (!this.activeSessions.has(sessionId)) {
-            this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
-            callbacks.onComplete(getAgentSessionMessages(sessionId))
-            return
-          }
-        }
-
-        let shouldRetryFromTypedError = false
-
-        try {
-          // 获取异步迭代器（手动 .next() 以支持 Promise.race 中断）
-          const queryIterable = this.adapter.query(queryOptions)
-          const queryIterator = queryIterable[Symbol.asyncIterator]()
-
-          // Watchdog 控制器（用于死锁检测后中断事件循环）
-          const loopAbort = new AbortController()
-          abortedByWatchdog = false
-
-          // 启动 Watchdog（每 5 秒检查是否所有 Worker 已 idle 但 Task 工具仍在等待）
-          const WATCHDOG_INTERVAL_MS = 5_000
-          const watchdogDone = (async () => {
-            while (!loopAbort.signal.aborted) {
-              await timerWithAbort(WATCHDOG_INTERVAL_MS, loopAbort.signal)
-              if (loopAbort.signal.aborted) break
-
-              // 仅在有 Worker 启动且未全部完成时检查
-              if (
-                startedTaskIds.size > 0 &&
-                completedTaskIds.size < startedTaskIds.size &&
-                capturedSdkSessionId
-              ) {
-                const allIdle = await areAllWorkersIdle(capturedSdkSessionId, startedTaskIds.size)
-                if (allIdle) {
-                  console.log(
-                    `[Agent 编排] Watchdog: 所有 ${startedTaskIds.size} 个 Worker 已 idle，` +
-                    `Task 工具仍在等待 — 中断以触发 auto-resume`,
-                  )
-                  abortedByWatchdog = true
-                  loopAbort.abort()
-                  break
-                }
-              }
-            }
-          })()
-
-          // 手动事件循环：Promise.race（事件 vs Watchdog 中断）
-          let pendingNext: Promise<IteratorResult<AgentEvent>> | null = null
-          // Teams 活跃时延迟 complete 事件，避免前端提前标记 teammates 为 stopped
-          let deferredCompleteEvent: AgentEvent | null = null
-
-          while (!loopAbort.signal.aborted) {
-            if (!pendingNext) {
-              pendingNext = queryIterator.next()
-            }
-
-            const abortPromise = new Promise<null>((resolve) => {
-              if (loopAbort.signal.aborted) { resolve(null); return }
-              loopAbort.signal.addEventListener('abort', () => resolve(null), { once: true })
-            })
-
-            const raceResult = await Promise.race([
-              pendingNext.then((r) => ({ kind: 'event' as const, result: r })),
-              abortPromise.then(() => ({ kind: 'abort' as const, result: null })),
-            ])
-
-            if (raceResult.kind === 'abort') {
-              // Watchdog 触发：终止事件循环，但不中止 SDK 会话
-              // 注意：pending .next() 可能因 SDK 阻塞而永远不返回，
-              // 因此 .return() 也会排队挂起 — 不能 await，用超时保护
-              pendingNext?.catch(() => {})  // 防止未处理 rejection
-              pendingNext = null
-              const returnPromise = queryIterator.return?.(undefined as never).catch(() => {})
-              // 最多等 1 秒，超时则放弃（generator 稍后 GC 清理）
-              await Promise.race([
-                returnPromise,
-                new Promise<void>((r) => setTimeout(r, 1000)),
-              ])
-              console.log(`[Agent 编排] Watchdog 中断：已退出事件循环`)
-              break
-            }
-
-            const iterResult = raceResult.result
-            if (!iterResult || iterResult.done) break
-
-            pendingNext = null
-            const event = iterResult.value
-
-            // typed_error：判断是否可自动重试
-            if (event.type === 'typed_error') {
-              if (isAutoRetryableTypedError(event.error) && attempt <= MAX_AUTO_RETRIES) {
-                lastRetryableError = event.error.title
-                  ? `${event.error.title}: ${event.error.message}`
-                  : event.error.message
-                console.log(`[Agent 编排] 可重试错误 (typed_error): ${event.error.code} - ${lastRetryableError}`)
-                // 保存部分内容后准备重试
-                this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
-                accumulatedText = ''
-                accumulatedEvents.length = 0
-                shouldRetryFromTypedError = true
-                break  // 跳出事件循环，进入下一次 retry 循环
-              }
-
-              // 不可重试 → 走原有终止逻辑
-              this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
-
-              const errorMsg: AgentMessage = {
-                id: randomUUID(),
-                role: 'status',
-                content: event.error.title
-                  ? `${event.error.title}: ${event.error.message}`
-                  : event.error.message,
-                createdAt: Date.now(),
-                errorCode: event.error.code,
-                errorTitle: event.error.title,
-                errorDetails: event.error.details,
-                errorOriginal: event.error.originalError,
-                errorCanRetry: event.error.canRetry,
-                errorActions: event.error.actions,
-              }
-              appendAgentMessage(sessionId, errorMsg)
-              console.log(`[Agent 编排] 已保存 TypedError 消息: ${event.error.code} - ${event.error.title}`)
-
-              // 如果之前有重试记录，发送 retry_failed
-              if (attempt > 1 && lastRetryableError) {
-                this.eventBus.emit(sessionId, {
-                  type: 'retry_failed',
-                  finalAttempt: {
-                    attempt: attempt - 1,
-                    timestamp: Date.now(),
-                    reason: lastRetryableError,
-                    errorMessage: event.error.message,
-                    delaySeconds: 0,
-                  },
-                })
-              }
-
-              this.eventBus.emit(sessionId, event)
-              // 清理 Watchdog
-              if (!loopAbort.signal.aborted) loopAbort.abort()
-              await watchdogDone
-              try { updateAgentSessionMeta(sessionId, {}) } catch { /* 忽略 */ }
-              callbacks.onComplete(getAgentSessionMessages(sessionId))
-              return
-            }
-
-            // 正常事件处理
-            if (event.type === 'text_delta') {
-              accumulatedText += event.text
-            }
-            accumulatedEvents.push(event)
-
-            // Agent Teams: 当有 teammate 活跃时，延迟 complete 事件
-            // 避免前端收到 complete → 标记所有 teammates 为 stopped → 建议不渲染
-            if (event.type === 'complete' && startedTaskIds.size > 0) {
-              console.log(`[Agent 编排] 延迟 complete 事件（${startedTaskIds.size} 个 teammate 活跃）`)
-              deferredCompleteEvent = event
-              // 不发射到 eventBus，继续等待 auto-resume
-            } else {
-              this.eventBus.emit(sessionId, event)
-            }
-
-            // Agent Teams: 追踪 teammate 任务状态
-            if (event.type === 'task_started') {
-              startedTaskIds.add(event.taskId)
-            } else if (event.type === 'task_notification') {
-              completedTaskIds.add(event.taskId)
-              if (event.summary) {
-                taskNotificationSummaries.push({
-                  taskId: event.taskId,
-                  status: event.status,
-                  summary: event.summary,
-                  outputFile: event.outputFile,
-                })
-              }
-            }
-          }
-
-          // 清理 Watchdog（事件循环正常结束或被 Watchdog 中断）
-          if (!loopAbort.signal.aborted) loopAbort.abort()
-          await watchdogDone
-
-          if (abortedByWatchdog) {
-            console.log(`[Agent 编排] Watchdog 中断了事件循环，将触发 auto-resume`)
-          }
-
-          // typed_error break 触发了 → 继续循环
-          if (shouldRetryFromTypedError) {
-            continue
-          }
-
-          // 正常完成 — 如果之前有重试，发送 retry_cleared
-          if (attempt > 1) {
-            this.eventBus.emit(sessionId, { type: 'retry_cleared' })
-            console.log(`[Agent 编排] 重试成功，已在第 ${attempt} 次尝试后恢复`)
-          }
-          retrySucceeded = true
-
-          // 15. 持久化 assistant 消息
-          this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
-
-          // 16. Agent Teams Auto-Resume：teammates 完成后自动收集结果并汇总
-          //     触发条件：有 teammate 启动过（正常完成或 Watchdog 中断均适用）
-          console.log(`[Agent 编排] Auto-resume 条件检查: startedTasks=${startedTaskIds.size}, sdkSession=${!!capturedSdkSessionId}, active=${this.activeSessions.has(sessionId)}`)
-          if (startedTaskIds.size > 0 && capturedSdkSessionId && this.activeSessions.has(sessionId)) {
-            console.log(`[Agent 编排] Agent Teams 检测到 ${startedTaskIds.size} 个 teammate，启动 auto-resume`)
-
-            // 通知前端：正在收集 teammate 结果
-            this.eventBus.emit(sessionId, {
-              type: 'waiting_resume',
-              message: '正在收集 teammate 工作结果...',
-            })
-
-            // 构造 resume prompt（优先 inbox，fallback 到 summaries）
-            let resumePrompt: string | null = null
-
-            const inboxInfo = await findTeamLeadInboxPath(capturedSdkSessionId)
-            console.log(`[Agent 编排] Inbox 查找结果: ${inboxInfo ? `team=${inboxInfo.teamName}` : '未找到 team'}`)
-            if (inboxInfo) {
-              const unreadMessages = await pollInboxWithRetry(
-                inboxInfo.inboxPath,
-                INBOX_RETRY_CONFIG,
-              )
-              if (unreadMessages.length > 0) {
-                await markInboxAsRead(inboxInfo.inboxPath)
-                resumePrompt = formatInboxPrompt(unreadMessages)
-                console.log(`[Agent 编排] 使用 ${unreadMessages.length} 条 inbox 消息构建 resume prompt`)
-              }
-            }
-
-            // Fallback：用 task_notification summaries
-            if (!resumePrompt && taskNotificationSummaries.length > 0) {
-              console.log(`[Agent 编排] Inbox 为空，使用 ${taskNotificationSummaries.length} 条 task summaries 作为 fallback`)
-              resumePrompt = formatSummaryFallbackPrompt(taskNotificationSummaries)
-            }
-
-            if (resumePrompt && this.activeSessions.has(sessionId)) {
-              const resumeMessageId = randomUUID()
-              this.eventBus.emit(sessionId, { type: 'resume_start', messageId: resumeMessageId })
-
-              // 创建 resume 查询（使用相同的 SDK session ID）
-              let resumeText = ''
-              const resumeEvents: AgentEvent[] = []
-
-              try {
-                const resumeOptions: ClaudeAgentQueryOptions = {
-                  ...queryOptions,
-                  prompt: resumePrompt,
-                  resumeSessionId: capturedSdkSessionId,
-                }
-
-                for await (const event of this.adapter.query(resumeOptions)) {
-                  if (!this.activeSessions.has(sessionId)) break
-
-                  if (event.type === 'text_delta') {
-                    resumeText += event.text
-                  }
-                  resumeEvents.push(event)
-                  this.eventBus.emit(sessionId, event)
-                }
-
-                // 持久化 resume 助手消息
-                if (resumeText || resumeEvents.length > 0) {
-                  this.persistAssistantMessage(sessionId, resumeText, resumeEvents, resolvedModel)
-                }
-
-                console.log(`[Agent 编排] Auto-resume 完成，输出 ${resumeText.length} 字符`)
-              } catch (resumeError) {
-                console.error('[Agent 编排] Auto-resume 失败:', resumeError)
-                // 已流式的部分内容已保存，继续完成流程
-              }
-            } else if (!resumePrompt) {
-              console.log('[Agent 编排] 无可用的 resume 内容（inbox 和 summaries 均为空）')
-            }
-          }
-          try { updateAgentSessionMeta(sessionId, {}) } catch { /* 忽略 */ }
-
-          // 发射延迟的 complete 事件（auto-resume 已完成，前端可安全处理）
-          if (deferredCompleteEvent) {
-            console.log(`[Agent 编排] 发射延迟的 complete 事件`)
-            this.eventBus.emit(sessionId, deferredCompleteEvent)
-          }
-
-          // 发送完成信号
-          callbacks.onComplete(getAgentSessionMessages(sessionId))
-
-          // 异步生成标题
-          this.autoGenerateTitle(sessionId, userMessage, channelId, resolvedModel, callbacks)
-            .catch((err) => console.error('[Agent 编排] 标题生成未捕获异常:', err))
-
-          break  // 成功完成，退出重试循环
-
-        } catch (error) {
-          // 打印 stderr
-          const fullStderr = stderrChunks.join('').trim()
-          if (fullStderr) {
-            console.error(`[Agent 编排] 完整 stderr 输出 (${fullStderr.length} 字符):`)
-            console.error(fullStderr)
-          } else {
-            console.error(`[Agent 编排] stderr 为空`)
-          }
-
-          // 用户主动中止
-          if (!this.activeSessions.has(sessionId)) {
-            console.log(`[Agent 编排] 会话 ${sessionId} 已被用户中止`)
-            this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
-            callbacks.onComplete(getAgentSessionMessages(sessionId))
-            return
-          }
-
-          // 从 stderr 提取 API 错误
-          const stderrOutput = stderrChunks.join('').trim()
-          const apiError = extractApiError(stderrOutput)
-          const rawErrorMessage = error instanceof Error ? error.message : ''
-
-          // 判断是否可重试
-          if (isAutoRetryableCatchError(apiError, rawErrorMessage) && attempt <= MAX_AUTO_RETRIES) {
-            lastRetryableError = apiError
-              ? `API Error ${apiError.statusCode}: ${apiError.message}`
-              : (error instanceof Error ? error.message : '未知错误')
-            console.log(`[Agent 编排] 可重试错误 (catch): ${lastRetryableError}`)
-            // 保存部分内容
-            this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
-            accumulatedText = ''
-            accumulatedEvents.length = 0
-            stderrChunks.length = 0
-            continue  // 进入下一次 retry 循环
-          }
-
-          // 不可重试 — 走原有终止逻辑
-          const errorMessage = error instanceof Error ? error.message : '未知错误'
-          console.error(`[Agent 编排] 执行失败:`, error)
-
-          // 保存已累积的部分内容
-          if (accumulatedText || accumulatedEvents.length > 0) {
-            try {
-              this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
-              console.log(`[Agent 编排] 已保存部分执行结果 (${accumulatedText.length} 字符, ${accumulatedEvents.length} 事件)`)
-            } catch (saveError) {
-              console.error('[Agent 编排] 保存部分内容失败:', saveError)
-            }
-          }
-
-          let userFacingError: string
-          if (apiError) {
-            userFacingError = friendlyErrorMessage(`API 错误 (${apiError.statusCode}):\n${apiError.message}`)
-          } else {
-            userFacingError = friendlyErrorMessage(errorMessage)
-          }
-
-          // 保存错误消息到 JSONL
-          try {
-            // 检测是否为 prompt too long 错误
-            const isPromptTooLong = isPromptTooLongError(
-              userFacingError,
-              error instanceof Error ? (error.stack ?? error.message) : String(error),
-              stderrOutput,
-            )
-
-            const errMsg: AgentMessage = {
-              id: randomUUID(),
-              role: 'status',
-              content: isPromptTooLong
-                ? '上下文过长：当前对话的上下文已超出模型限制，请压缩上下文或开启新会话'
-                : userFacingError,
-              createdAt: Date.now(),
-              errorCode: isPromptTooLong ? 'prompt_too_long' : 'unknown_error',
-              errorTitle: isPromptTooLong ? '上下文过长' : '执行错误',
-              errorOriginal: error instanceof Error ? error.stack : String(error),
-            }
-            appendAgentMessage(sessionId, errMsg)
-            console.log(`[Agent 编排] 已保存错误消息到 JSONL`)
-          } catch (saveError) {
-            console.error('[Agent 编排] 保存错误消息失败:', saveError)
-          }
-
-          // 如果之前有重试记录，发送 retry_failed
-          if (attempt > 1 && lastRetryableError) {
-            this.eventBus.emit(sessionId, {
-              type: 'retry_failed',
-              finalAttempt: {
-                attempt: attempt - 1,
-                timestamp: Date.now(),
-                reason: lastRetryableError,
-                errorMessage: userFacingError,
-                delaySeconds: 0,
-              },
-            })
-          }
-
-          callbacks.onError(userFacingError)
-          callbacks.onComplete(getAgentSessionMessages(sessionId))
-
-          // 根据错误类型决定是否保留 sdkSessionId
-          const shouldClearSession = !apiError || apiError.statusCode >= 500
-          if (existingSdkSessionId && shouldClearSession) {
-            try {
-              updateAgentSessionMeta(sessionId, { sdkSessionId: undefined })
-              console.log(`[Agent 编排] 已清除失效的 sdkSessionId`)
-            } catch { /* 忽略 */ }
-          } else if (existingSdkSessionId && !shouldClearSession) {
-            console.log(`[Agent 编排] 保留 sdkSessionId (API 错误 ${apiError?.statusCode})`)
-          }
-
-          throw error
-        }
-      }
-
-      // 重试循环结束（达到最大次数仍失败）
-      if (!retrySucceeded && lastRetryableError) {
-        this.eventBus.emit(sessionId, {
-          type: 'retry_failed',
-          finalAttempt: {
-            attempt: MAX_AUTO_RETRIES,
-            timestamp: Date.now(),
-            reason: lastRetryableError,
-            errorMessage: `重试 ${MAX_AUTO_RETRIES} 次后仍然失败`,
-            delaySeconds: 0,
-          },
-        })
-
-        // 保存错误消息
-        const retryErrorMsg: AgentMessage = {
-          id: randomUUID(),
-          role: 'status',
-          content: `重试 ${MAX_AUTO_RETRIES} 次后仍然失败: ${lastRetryableError}`,
-          createdAt: Date.now(),
-          errorCode: 'unknown_error',
-          errorTitle: '重试失败',
-        }
-        appendAgentMessage(sessionId, retryErrorMsg)
-
-        callbacks.onError(`重试 ${MAX_AUTO_RETRIES} 次后仍然失败: ${lastRetryableError}`)
-        callbacks.onComplete(getAgentSessionMessages(sessionId))
-      }
-
-    } finally {
-      this.activeSessions.delete(sessionId)
-      permissionService.clearSessionPending(sessionId)
-      askUserService.clearSessionPending(sessionId)
-    }
-  }
-
   /**
    * 中止指定会话的 Agent 执行
-   *
-   * 先从 activeSessions 移除（供 sendMessage catch 块检测用户中止），
-   * 再调用 adapter.abort() 中止底层 SDK 进程。
    */
   stop(sessionId: string): void {
     this.activeSessions.delete(sessionId)
+    this.runners.get(sessionId)?.abort()
     this.adapter.abort(sessionId)
-    console.log(`[Agent 编排] 已中止会话: ${sessionId}`)
+    console.log(`[Orchestrator] 已中止会话: ${sessionId}`)
   }
 
   /** 检查指定会话是否正在处理中 */
@@ -1475,8 +153,14 @@ export class AgentOrchestrator {
   /** 中止所有活跃的 Agent 会话（应用退出时调用） */
   stopAll(): void {
     if (this.activeSessions.size === 0) return
-    console.log(`[Agent 编排] 正在中止所有活跃会话 (${this.activeSessions.size} 个)...`)
+    console.log(`[Orchestrator] 正在中止所有活跃会话 (${this.activeSessions.size} 个)...`)
     this.adapter.dispose()
     this.activeSessions.clear()
+    this.runners.clear()
+  }
+
+  /** 获取团队管理器（供 IPC 层调用） */
+  getTeamManager(): AgentTeamManager {
+    return this.teamManager
   }
-}
\ No newline at end of file
+}
diff --git a/apps/electron/src/main/lib/agent-persona-service.ts b/apps/electron/src/main/lib/agent-persona-service.ts
new file mode 100644
index 00000000..d4cbac6e
--- /dev/null
+++ b/apps/electron/src/main/lib/agent-persona-service.ts
@@ -0,0 +1,203 @@
+/**
+ * Agent 个性化配置服务
+ *
+ * 负责读取和保存工作区的 AGENT.md、USER.md、SOUL.md、MEMORY.md 文件。
+ * 这些文件定义了机器人的身份、性格、用户设定和长期记忆。
+ *
+ * 采用 Read-Through Cache + Write-Through Invalidation 模式：
+ * - personaCache 缓存 { persona, mtime }
+ * - 5 分钟 TTL 兜底，结合文件监听主动失效
+ */
+
+import { readFileSync, writeFileSync, existsSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { getAgentWorkspacePath } from './config-paths'
+import type { AgentPersona } from '@proma/shared'
+
+/** Persona 文件名 */
+export const PERSONA_FILES = {
+  AGENT: 'AGENT.md',
+  USER: 'USER.md',
+  SOUL: 'SOUL.md',
+  MEMORY: 'MEMORY.md',
+} as const
+
+/** 缓存 TTL（毫秒）：5 分钟 */
+const CACHE_TTL_MS = 5 * 60 * 1000
+
+/** 缓存项结构 */
+interface CachedPersona {
+  persona: AgentPersona
+  mtime: number
+}
+
+/** Persona 缓存：workspaceSlug → 缓存项 */
+const personaCache = new Map<string, CachedPersona>()
+
+/**
+ * 获取 persona 文件的完整路径
+ */
+function getPersonaFilePath(workspaceSlug: string, fileName: string): string {
+  return join(getAgentWorkspacePath(workspaceSlug), fileName)
+}
+
+/**
+ * 获取 persona 文件的修改时间
+ *
+ * @returns 文件修改时间（毫秒），文件不存在则返回 0
+ */
+function getPersonaFileMtime(workspaceSlug: string, fileName: string): number {
+  const filePath = getPersonaFilePath(workspaceSlug, fileName)
+  if (!existsSync(filePath)) {
+    return 0
+  }
+
+  try {
+    return statSync(filePath).mtimeMs
+  } catch {
+    return 0
+  }
+}
+
+/**
+ * 读取指定 persona 文件内容
+ *
+ * @returns 文件内容，如果文件不存在则返回空字符串
+ */
+function readPersonaFile(workspaceSlug: string, fileName: string): string {
+  const filePath = getPersonaFilePath(workspaceSlug, fileName)
+  if (!existsSync(filePath)) {
+    return ''
+  }
+
+  try {
+    return readFileSync(filePath, 'utf-8')
+  } catch (error) {
+    console.error(`[Agent Persona] 读取文件失败 ${filePath}:`, error)
+    return ''
+  }
+}
+
+/**
+ * 保存 persona 文件
+ *
+ * @param content 文件内容，为空时删除文件（如果存在）
+ */
+function savePersonaFile(workspaceSlug: string, fileName: string, content: string): void {
+  const filePath = getPersonaFilePath(workspaceSlug, fileName)
+
+  if (!content.trim()) {
+    // 空内容，不创建文件
+    return
+  }
+
+  try {
+    writeFileSync(filePath, content, 'utf-8')
+    console.log(`[Agent Persona] 已保存 ${fileName} 到工作区 ${workspaceSlug}`)
+  } catch (error) {
+    console.error(`[Agent Persona] 保存文件失败 ${filePath}:`, error)
+    throw error
+  }
+}
+
+/**
+ * 获取工作区的所有 persona 文件（带缓存）
+ *
+ * 采用 Read-Through Cache 策略：
+ * 1. 检查缓存是否存在且未过期
+ * 2. 比较缓存 mtime 与文件 mtime（用于检测外部修改）
+ * 3. 缓存有效则返回，否则读取文件并更新缓存
+ */
+export function getAgentPersona(workspaceSlug: string): AgentPersona {
+  const cached = personaCache.get(workspaceSlug)
+  const now = Date.now()
+
+  // 检查缓存是否有效（TTL 内且文件未变化）
+  if (cached && now - cached.mtime < CACHE_TTL_MS) {
+    // 进一步检查文件 mtime 是否变化
+    const agentMtime = getPersonaFileMtime(workspaceSlug, PERSONA_FILES.AGENT)
+    const userMtime = getPersonaFileMtime(workspaceSlug, PERSONA_FILES.USER)
+    const soulMtime = getPersonaFileMtime(workspaceSlug, PERSONA_FILES.SOUL)
+    const memoryMtime = getPersonaFileMtime(workspaceSlug, PERSONA_FILES.MEMORY)
+    const maxMtime = Math.max(agentMtime, userMtime, soulMtime, memoryMtime)
+
+    // 文件未变化，缓存有效
+    if (maxMtime <= cached.mtime) {
+      return cached.persona
+    }
+  }
+
+  // 缓存无效或不存在，重新读取
+  const persona: AgentPersona = {
+    agentMd: readPersonaFile(workspaceSlug, PERSONA_FILES.AGENT),
+    userMd: readPersonaFile(workspaceSlug, PERSONA_FILES.USER),
+    soulMd: readPersonaFile(workspaceSlug, PERSONA_FILES.SOUL),
+    memoryMd: readPersonaFile(workspaceSlug, PERSONA_FILES.MEMORY),
+  }
+
+  // 更新缓存
+  const maxMtime = Math.max(
+    getPersonaFileMtime(workspaceSlug, PERSONA_FILES.AGENT),
+    getPersonaFileMtime(workspaceSlug, PERSONA_FILES.USER),
+    getPersonaFileMtime(workspaceSlug, PERSONA_FILES.SOUL),
+    getPersonaFileMtime(workspaceSlug, PERSONA_FILES.MEMORY),
+  )
+  personaCache.set(workspaceSlug, { persona, mtime: maxMtime || now })
+
+  return persona
+}
+
+/**
+ * 保存工作区的所有 persona 文件
+ *
+ * 采用 Write-Through 策略：保存后立即更新缓存
+ */
+export function saveAgentPersona(workspaceSlug: string, persona: AgentPersona): void {
+  savePersonaFile(workspaceSlug, PERSONA_FILES.AGENT, persona.agentMd)
+  savePersonaFile(workspaceSlug, PERSONA_FILES.USER, persona.userMd)
+  savePersonaFile(workspaceSlug, PERSONA_FILES.SOUL, persona.soulMd)
+  savePersonaFile(workspaceSlug, PERSONA_FILES.MEMORY, persona.memoryMd)
+
+  // 更新缓存
+  const now = Date.now()
+  personaCache.set(workspaceSlug, { persona, mtime: now })
+}
+
+/**
+ * 使工作区的 persona 缓存失效
+ *
+ * @param workspaceSlug 可选，不传则使所有缓存失效
+ */
+export function invalidatePersonaCache(workspaceSlug?: string): void {
+  if (workspaceSlug) {
+    personaCache.delete(workspaceSlug)
+    console.log(`[Agent Persona] 缓存已失效: ${workspaceSlug}`)
+  } else {
+    personaCache.clear()
+    console.log('[Agent Persona] 所有 persona 缓存已失效')
+  }
+}
+
+/**
+ * 保存单个 persona 文件
+ *
+ * 采用 Write-Through 策略：保存后使缓存失效，下次读取时重新加载
+ */
+export function saveAgentPersonaFile(
+  workspaceSlug: string,
+  fileType: keyof typeof PERSONA_FILES,
+  content: string,
+): void {
+  const fileName = PERSONA_FILES[fileType]
+  savePersonaFile(workspaceSlug, fileName, content)
+  // 使该工作区的缓存失效
+  personaCache.delete(workspaceSlug)
+}
+
+/**
+ * 检查工作区是否存在 persona 文件
+ */
+export function hasAgentPersona(workspaceSlug: string): boolean {
+  const persona = getAgentPersona(workspaceSlug)
+  return !!(persona.agentMd || persona.userMd || persona.soulMd || persona.memoryMd)
+}
diff --git a/apps/electron/src/main/lib/agent-prompt-builder.ts b/apps/electron/src/main/lib/agent-prompt-builder.ts
index 8a321a55..073bafa5 100644
--- a/apps/electron/src/main/lib/agent-prompt-builder.ts
+++ b/apps/electron/src/main/lib/agent-prompt-builder.ts
@@ -8,10 +8,11 @@
  * - 动态 per-message 上下文（buildDynamicContext）：注入到用户消息前，每次实时读取磁盘
  */
 
-import type { PromaPermissionMode } from '@proma/shared'
+import type { PromaPermissionMode, AgentPersona } from '@proma/shared'
 import { getUserProfile } from './user-profile-service'
 import { getWorkspaceMcpConfig, getWorkspaceSkills } from './agent-workspace-manager'
 import { getMemoryConfig } from './memory-service'
+import { getAgentPersona } from './agent-persona-service'
 
 // ===== 静态 System Prompt =====
 
@@ -21,6 +22,10 @@ interface SystemPromptContext {
   workspaceSlug?: string
   sessionId: string
   permissionMode: PromaPermissionMode
+  /** 是否注入 Per-Agent persona 内容 */
+  includePersona?: boolean
+  /** 预加载的 persona（避免重复读取） */
+  persona?: AgentPersona
 }
 
 /**
@@ -44,6 +49,26 @@ export function buildSystemPromptAppend(ctx: SystemPromptContext): string {
 调用 Skill 工具时，\`skill\` 参数**必须**使用含命名空间前缀的完整名称（如 \`proma-workspace-${ctx.workspaceSlug}:brainstorming\`）。
 **绝对不可**使用不带前缀的短名称（如 \`brainstorming\`），否则会报 Unknown skill 错误。`)
 
+  // Per-Agent Persona 注入（AGENT.md 和 SOUL.md）
+  if (ctx.includePersona && ctx.workspaceSlug) {
+    // 优先使用预加载的 persona，避免重复读取
+    const persona = ctx.persona ?? getAgentPersona(ctx.workspaceSlug)
+
+    // AGENT.md - 机器人身份描述
+    if (persona.agentMd) {
+      sections.push(`## 机器人身份
+
+${persona.agentMd.trim()}`)
+    }
+
+    // SOUL.md - 机器人性格/风格指导
+    if (persona.soulMd) {
+      sections.push(`## 机器人的说话风格与行为准则
+
+${persona.soulMd.trim()}`)
+    }
+  }
+
   // 用户信息
   sections.push(`## 用户信息
 
@@ -130,6 +155,10 @@ interface DynamicContext {
   workspaceName?: string
   workspaceSlug?: string
   agentCwd?: string
+  /** 是否注入 Per-Agent persona 内容 */
+  includePersona?: boolean
+  /** 预加载的 persona（避免重复读取） */
+  persona?: AgentPersona
 }
 
 /**
@@ -158,6 +187,23 @@ export function buildDynamicContext(ctx: DynamicContext): string {
   if (ctx.workspaceSlug) {
     const wsLines: string[] = []
 
+    // USER.md - 用户设定（注入到动态上下文，因为它可能包含用户偏好等实时信息）
+    if (ctx.includePersona) {
+      // 优先使用预加载的 persona，避免重复读取
+      const persona = ctx.persona ?? getAgentPersona(ctx.workspaceSlug)
+      if (persona.userMd) {
+        sections.push(`## 关于用户
+
+${persona.userMd.trim()}`)
+      }
+      // MEMORY.md - 长期记忆
+      if (persona.memoryMd) {
+        sections.push(`## 长期记忆
+
+${persona.memoryMd.trim()}`)
+      }
+    }
+
     if (ctx.workspaceName) {
       wsLines.push(`工作区: ${ctx.workspaceName}`)
     }
diff --git a/apps/electron/src/main/lib/agent-retry-handler.ts b/apps/electron/src/main/lib/agent-retry-handler.ts
new file mode 100644
index 00000000..2a9e0129
--- /dev/null
+++ b/apps/electron/src/main/lib/agent-retry-handler.ts
@@ -0,0 +1,108 @@
+/**
+ * AgentRetryHandler — 重试与错误分类
+ *
+ * 从 AgentOrchestrator 提取的重试逻辑，负责：
+ * - 可重试错误判断（TypedError / API 错误）
+ * - 指数退避延迟计算
+ * - 可中断定时器
+ */
+
+import type { TypedError } from '@proma/shared'
+
+/** 最大自动重试次数 */
+export const MAX_AUTO_RETRIES = 3
+
+/** 可自动重试的 TypedError 错误码 */
+const AUTO_RETRYABLE_ERROR_CODES: ReadonlySet<string> = new Set([
+  'rate_limited',
+  'provider_error',
+  'service_error',
+  'service_unavailable',
+  'network_error',
+])
+
+/** 判断 typed_error 事件是否可自动重试 */
+export function isAutoRetryableTypedError(error: TypedError): boolean {
+  return AUTO_RETRYABLE_ERROR_CODES.has(error.code)
+}
+
+/** 判断 catch 块中的 API 错误是否可自动重试（HTTP 429 / 5xx / 已知可恢复错误模式） */
+export function isAutoRetryableCatchError(
+  apiError: { statusCode: number; message: string } | null,
+  rawErrorMessage?: string,
+): boolean {
+  if (apiError) {
+    if (apiError.statusCode === 429 || apiError.statusCode >= 500) return true
+  }
+  if (rawErrorMessage) {
+    if (rawErrorMessage.includes('context_management')) return true
+  }
+  return false
+}
+
+/** 计算重试延迟（指数退避：1s, 2s, 4s） */
+export function getRetryDelayMs(attempt: number): number {
+  return Math.min(1000 * Math.pow(2, attempt - 1), 8000)
+}
+
+/**
+ * 可中断的定时器
+ *
+ * 等待指定毫秒，如果 signal 被中止则立即 resolve。
+ */
+export function timerWithAbort(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise<void>((resolve) => {
+    if (signal.aborted) { resolve(); return }
+    const tid = setTimeout(resolve, ms)
+    signal.addEventListener('abort', () => { clearTimeout(tid); resolve() }, { once: true })
+  })
+}
+
+/**
+ * 从 stderr 中提取 API 错误信息
+ *
+ * 解析类似这样的错误：
+ * "401 {\"error\":{\"message\":\"...\"}}"
+ * "API error: 400 Bad Request ..."
+ */
+export function extractApiError(stderr: string): { statusCode: number; message: string } | null {
+  if (!stderr) return null
+
+  // 模式 1：JSON 错误格式 - "401 {...}"
+  const jsonMatch = stderr.match(/(\d{3})\s+(\{[^}]*"error"[^}]*\})/s)
+  if (jsonMatch) {
+    try {
+      const statusCode = parseInt(jsonMatch[1]!)
+      const errorObj = JSON.parse(jsonMatch[2]!)
+      const message = errorObj.error?.message || errorObj.message || '未知错误'
+      return { statusCode, message }
+    } catch {
+      // JSON 解析失败，继续尝试其他模式
+    }
+  }
+
+  // 模式 2：API error 格式 - "API error (attempt X/Y): 401 401 {...}"
+  const apiErrorMatch = stderr.match(/API error[^:]*:\s+(\d{3})\s+\d{3}\s+(\{.*?\})/s)
+  if (apiErrorMatch) {
+    try {
+      const statusCode = parseInt(apiErrorMatch[1]!)
+      const errorObj = JSON.parse(apiErrorMatch[2]!)
+      const message = errorObj.error?.message || errorObj.message || '未知错误'
+      return { statusCode, message }
+    } catch {
+      // JSON 解析失败
+    }
+  }
+
+  // 模式 3：直接的状态码 + 消息
+  const simpleMatch = stderr.match(/(\d{3})[:\s]+(.+?)(?:\n|$)/i)
+  if (simpleMatch) {
+    const statusCode = parseInt(simpleMatch[1]!)
+    const message = simpleMatch[2]!.trim()
+    if (statusCode >= 400 && statusCode < 600) {
+      return { statusCode, message }
+    }
+  }
+
+  return null
+}
diff --git a/apps/electron/src/main/lib/agent-session-runner.ts b/apps/electron/src/main/lib/agent-session-runner.ts
new file mode 100644
index 00000000..845b3145
--- /dev/null
+++ b/apps/electron/src/main/lib/agent-session-runner.ts
@@ -0,0 +1,875 @@
+/**
+ * SessionRunner — 单次会话运行器
+ *
+ * 从 AgentOrchestrator.sendMessage() 提取的核心执行逻辑。
+ * 每次调用创建新实例，持有独立的 AbortController。
+ *
+ * 职责：
+ * - 构建运行上下文（channel, apiKey, env, cwd）
+ * - 持久化用户/助手消息
+ * - 构建 SDK 查询选项（含 agents 参数）
+ * - 执行带重试的事件流循环
+ * - 自动标题生成
+ */
+
+import { randomUUID } from 'node:crypto'
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { existsSync, mkdirSync, symlinkSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { app } from 'electron'
+import type { AgentSendInput, AgentEvent, AgentMessage, AgentProviderAdapter, AgentDefinition, RetryAttempt } from '@proma/shared'
+import { SAFE_TOOLS, ALL_STANDARD_TOOLS } from '@proma/shared'
+import type { PermissionRequest, PromaPermissionMode, AskUserRequest } from '@proma/shared'
+import type { ClaudeAgentQueryOptions } from './adapters/claude-agent-adapter'
+import { isPromptTooLongError, friendlyErrorMessage } from './adapters/claude-agent-adapter'
+import type { AgentEventBus } from './agent-event-bus'
+import { decryptApiKey, getChannelById, listChannels } from './channel-manager'
+import { getAdapter, fetchTitle } from '@proma/core'
+import { getFetchFn } from './proxy-fetch'
+import { getEffectiveProxyUrl } from './proxy-settings-service'
+import { appendAgentMessage, updateAgentSessionMeta, getAgentSessionMeta, getAgentSessionMessages } from './agent-session-manager'
+import { getAgentWorkspace, ensurePluginManifest, getWorkspacePermissionMode, getWorkspaceAgents, loadAgentDefinition } from './agent-workspace-manager'
+import { getAgentWorkspacePath, getAgentSessionWorkspacePath, getWorkspaceFilesDir } from './config-paths'
+import { getWorkspaceAttachedDirectories } from './agent-workspace-manager'
+import { getRuntimeStatus } from './runtime-init'
+import { getSettings } from './settings-service'
+import { buildSystemPromptAppend, buildDynamicContext } from './agent-prompt-builder'
+import { getAgentPersona } from './agent-persona-service'
+import { permissionService } from './agent-permission-service'
+import { askUserService } from './agent-ask-user-service'
+import { buildSdkEnv } from './agent-env-builder'
+import { buildMcpServers, injectMemoryTools, injectNanoBananaTools } from './agent-mcp-builder'
+import {
+  MAX_AUTO_RETRIES,
+  isAutoRetryableTypedError,
+  isAutoRetryableCatchError,
+  getRetryDelayMs,
+  extractApiError,
+} from './agent-retry-handler'
+import type { AgentTeamManager } from './agent-team-manager'
+
+import type { SessionCallbacks } from './agent-orchestrator'
+
+// ===== 工具函数 =====
+
+/** 最大回填消息条数 */
+const MAX_CONTEXT_MESSAGES = 20
+
+/** 单条工具摘要最大字符数 */
+const MAX_TOOL_SUMMARY_LENGTH = 200
+
+/** 标题生成 Prompt */
+const TITLE_PROMPT = '根据用户的第一条消息，生成一个简短的对话标题（10字以内）。只输出标题，不要有任何其他内容、标点符号或引号。\n\n用户消息：'
+
+/** 标题最大长度 */
+const MAX_TITLE_LENGTH = 20
+
+/** 默认会话标题 */
+const DEFAULT_SESSION_TITLE = '新 Agent 会话'
+
+/** 默认模型 ID */
+const DEFAULT_MODEL_ID = 'claude-sonnet-4-5-20250929'
+
+/**
+ * 从 assistant 消息的 events 中提取工具活动摘要
+ */
+function extractToolSummary(events: AgentEvent[]): string {
+  const summaries: string[] = []
+  for (const event of events) {
+    if (event.type === 'tool_start') {
+      const input = event.input
+      const keyParam = input.file_path ?? input.command ?? input.path ?? input.query ?? ''
+      const paramStr = keyParam ? `: ${String(keyParam).slice(0, 100)}` : ''
+      summaries.push(`[tool: ${event.toolName}${paramStr}]`)
+    }
+  }
+  if (summaries.length === 0) return ''
+  const joined = summaries.join(' ')
+  return joined.length > MAX_TOOL_SUMMARY_LENGTH
+    ? joined.slice(0, MAX_TOOL_SUMMARY_LENGTH) + '...'
+    : joined
+}
+
+/**
+ * 构建带历史上下文的 prompt
+ */
+function buildContextPrompt(sessionId: string, currentUserMessage: string): string {
+  const allMessages = getAgentSessionMessages(sessionId)
+  if (allMessages.length === 0) return currentUserMessage
+
+  const history = allMessages.slice(0, -1)
+  if (history.length === 0) return currentUserMessage
+
+  const recent = history.slice(-MAX_CONTEXT_MESSAGES)
+  const lines = recent
+    .filter((m) => (m.role === 'user' || m.role === 'assistant') && m.content)
+    .map((m) => {
+      let line = `[${m.role}]: ${m.content}`
+      if (m.role === 'assistant' && m.events && m.events.length > 0) {
+        const toolSummary = extractToolSummary(m.events)
+        if (toolSummary) {
+          line += `\n  工具活动: ${toolSummary}`
+        }
+      }
+      return line
+    })
+
+  if (lines.length === 0) return currentUserMessage
+
+  return `<conversation_history>\n${lines.join('\n')}\n</conversation_history>\n\n${currentUserMessage}`
+}
+
+/**
+ * 解析 SDK cli.js 路径
+ */
+function resolveSDKCliPath(): string {
+  let cliPath: string | null = null
+
+  try {
+    const cjsRequire = createRequire(__filename)
+    const sdkEntryPath = cjsRequire.resolve('@anthropic-ai/claude-agent-sdk')
+    cliPath = join(dirname(sdkEntryPath), 'cli.js')
+    console.log(`[SessionRunner] SDK CLI 路径 (createRequire): ${cliPath}`)
+  } catch (e) {
+    console.warn('[SessionRunner] createRequire 解析 SDK 路径失败:', e)
+  }
+
+  if (!cliPath) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const sdkEntryPath = require.resolve('@anthropic-ai/claude-agent-sdk')
+      cliPath = join(dirname(sdkEntryPath), 'cli.js')
+      console.log(`[SessionRunner] SDK CLI 路径 (require.resolve): ${cliPath}`)
+    } catch (e) {
+      console.warn('[SessionRunner] require.resolve 解析 SDK 路径失败:', e)
+    }
+  }
+
+  if (!cliPath) {
+    cliPath = join(process.cwd(), 'node_modules', '@anthropic-ai', 'claude-agent-sdk', 'cli.js')
+    console.log(`[SessionRunner] SDK CLI 路径 (手动): ${cliPath}`)
+  }
+
+  if (app.isPackaged && cliPath.includes('.asar')) {
+    cliPath = cliPath.replace(/\.asar([/\\])/, '.asar.unpacked$1')
+    console.log(`[SessionRunner] 转换为 asar.unpacked 路径: ${cliPath}`)
+  }
+
+  return cliPath
+}
+
+/**
+ * 获取 Agent SDK 运行时可执行文件
+ */
+function getAgentExecutable(): { type: 'node' | 'bun'; path: string } {
+  const status = getRuntimeStatus()
+
+  if (status?.node?.available && status.node.path) {
+    return { type: 'node', path: status.node.path }
+  }
+
+  if (status?.bun?.available && status.bun.path) {
+    return { type: 'bun', path: status.bun.path }
+  }
+
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which'
+    const nodePath = execFileSync(cmd, ['node'], { encoding: 'utf-8', timeout: 2000 })
+      .trim()
+      .split('\n')[0]
+    if (nodePath && existsSync(nodePath)) {
+      console.warn(`[SessionRunner] runtimeStatusCache 未就绪，同步查找 node: ${nodePath}`)
+      return { type: 'node', path: nodePath }
+    }
+  } catch {
+    // 忽略查找失败
+  }
+
+  return { type: 'node', path: 'node' }
+}
+
+/**
+ * 确保打包环境下 ripgrep 可被 SDK CLI 找到
+ */
+function ensureRipgrepAvailable(cliPath: string): void {
+  if (!app.isPackaged) return
+
+  try {
+    const sdkDir = dirname(cliPath)
+    const arch = process.arch
+    const platform = process.platform
+    const expectedDir = join(sdkDir, 'vendor', 'ripgrep', `${arch}-${platform}`)
+    const resourcesRipgrep = join(process.resourcesPath, 'vendor', 'ripgrep')
+
+    if (existsSync(expectedDir)) return
+
+    if (!existsSync(resourcesRipgrep)) {
+      console.warn(`[SessionRunner] ripgrep 资源不存在: ${resourcesRipgrep}`)
+      return
+    }
+
+    mkdirSync(join(sdkDir, 'vendor', 'ripgrep'), { recursive: true })
+    symlinkSync(resourcesRipgrep, expectedDir, 'junction')
+    console.log(`[SessionRunner] ripgrep symlink 创建成功: ${expectedDir} → ${resourcesRipgrep}`)
+  } catch (error) {
+    console.warn('[SessionRunner] ripgrep symlink 创建失败:', error)
+  }
+}
+
+// ===== SessionRunner =====
+
+export class SessionRunner {
+  private aborted = false
+
+  constructor(
+    private adapter: AgentProviderAdapter,
+    private eventBus: AgentEventBus,
+    private teamManager: AgentTeamManager,
+    private activeSessions: Set<string>,
+  ) {}
+
+  /** 标记会话为已中止 */
+  abort(): void {
+    this.aborted = true
+  }
+
+  /**
+   * 执行单次会话消息处理
+   */
+  async execute(input: AgentSendInput, callbacks: SessionCallbacks): Promise<void> {
+    const { sessionId, userMessage, channelId, modelId, workspaceId, additionalDirectories, customMcpServers, permissionModeOverride, mentionedSkills, mentionedMcpServers, mentionedAgents, messageMetadata } = input
+    const stderrChunks: string[] = []
+
+    // 1. Windows 平台：检查 Shell 环境可用性
+    if (process.platform === 'win32') {
+      const runtimeStatus = getRuntimeStatus()
+      const shellStatus = runtimeStatus?.shell
+
+      if (shellStatus && !shellStatus.gitBash?.available && !shellStatus.wsl?.available) {
+        const errorMsg = `Windows 平台需要 Git Bash 或 WSL 环境才能运行 Agent。
+
+当前状态：
+- Git Bash: ${shellStatus.gitBash?.error || '未检测到'}
+- WSL: ${shellStatus.wsl?.error || '未检测到'}
+
+解决方案：
+1. 安装 Git for Windows（推荐）: https://git-scm.com/download/win
+2. 或启用 WSL: https://learn.microsoft.com/zh-cn/windows/wsl/install
+
+安装完成后请重启应用。`
+
+        callbacks.onError(errorMsg)
+        return
+      }
+    }
+
+    // 2. 获取渠道信息并解密 API Key
+    const channel = getChannelById(channelId)
+    if (!channel) {
+      callbacks.onError('渠道不存在')
+      return
+    }
+
+    let apiKey: string
+    try {
+      apiKey = decryptApiKey(channelId)
+    } catch {
+      callbacks.onError('解密 API Key 失败')
+      return
+    }
+
+    // 3. 构建 SDK 子进程环境变量
+    const sdkEnv = await buildSdkEnv(apiKey, channel)
+
+    // 4. 读取已有的 SDK session ID（用于 resume）
+    const sessionMeta = getAgentSessionMeta(sessionId)
+    let existingSdkSessionId = sessionMeta?.sdkSessionId
+
+    if (existingSdkSessionId && sessionMeta) {
+      const prevChannelId = sessionMeta.channelId
+      if (prevChannelId && prevChannelId !== channelId) {
+        console.log(`[SessionRunner] 检测到渠道切换 (${prevChannelId} → ${channelId})，放弃 resume`)
+        existingSdkSessionId = undefined
+        updateAgentSessionMeta(sessionId, { sdkSessionId: undefined, channelId })
+      }
+    }
+
+    console.log(`[SessionRunner] 会话 resume 状态: sdkSessionId=${existingSdkSessionId || '无'}`)
+
+    // 5. 持久化用户消息
+    const userMsg: AgentMessage = {
+      id: randomUUID(),
+      role: 'user',
+      content: userMessage,
+      createdAt: Date.now(),
+      ...(messageMetadata && { metadata: messageMetadata }),
+    }
+    appendAgentMessage(sessionId, userMsg)
+
+    // 6. 状态初始化
+    let accumulatedText = ''
+    const accumulatedEvents: AgentEvent[] = []
+    let resolvedModel = modelId || DEFAULT_MODEL_ID
+    let agentCwd: string | undefined
+    let workspaceSlug: string | undefined
+    let workspace: import('@proma/shared').AgentWorkspace | undefined
+    let capturedSdkSessionId = existingSdkSessionId
+
+    try {
+      // 7. 动态导入 SDK
+      const sdk = await import('@anthropic-ai/claude-agent-sdk')
+
+      // 8. 构建 SDK query
+      const cliPath = resolveSDKCliPath()
+      const agentExec = getAgentExecutable()
+
+      if (!existsSync(cliPath)) {
+        callbacks.onError(`SDK CLI 文件不存在: ${cliPath}`)
+        return
+      }
+
+      ensureRipgrepAvailable(cliPath)
+
+      console.log(
+        `[SessionRunner] 启动 SDK — CLI: ${cliPath}, 运行时: ${agentExec.type} (${agentExec.path}), 模型: ${modelId || DEFAULT_MODEL_ID}, resume: ${existingSdkSessionId ?? '无'}`,
+      )
+
+      const nullDevice = process.platform === 'win32' ? 'NUL' : '/dev/null'
+      const executableArgs = agentExec.type === 'bun' ? [`--env-file=${nullDevice}`] : []
+
+      // 确定 Agent 工作目录
+      agentCwd = homedir()
+      workspaceSlug = undefined
+      workspace = undefined
+      if (workspaceId) {
+        const ws = getAgentWorkspace(workspaceId)
+        if (ws) {
+          agentCwd = getAgentSessionWorkspacePath(ws.slug, sessionId)
+          workspaceSlug = ws.slug
+          workspace = ws
+          console.log(`[SessionRunner] 使用 session 级别 cwd: ${agentCwd} (${ws.name}/${sessionId})`)
+          ensurePluginManifest(ws.slug, ws.name)
+
+          if (existingSdkSessionId) {
+            console.log(`[SessionRunner] 将尝试 resume: ${existingSdkSessionId}`)
+          }
+        }
+      }
+
+      // 9. 验证 sdkSessionId 是否仍然有效
+      if (existingSdkSessionId) {
+        try {
+          const listSessions = (sdk as unknown as {
+            listSessions: (opts: { dir: string }) => Promise<Array<{ sessionId: string }>>
+          }).listSessions
+          const sessions = await listSessions({ dir: agentCwd })
+          const isValid = sessions.some((s: { sessionId: string }) => s.sessionId === existingSdkSessionId)
+          if (!isValid) {
+            console.log(`[SessionRunner] sdkSessionId 已失效 (${existingSdkSessionId})，将使用上下文注入`)
+            existingSdkSessionId = undefined
+            updateAgentSessionMeta(sessionId, { sdkSessionId: undefined })
+          }
+        } catch {
+          console.warn(`[SessionRunner] listSessions 验证失败，继续使用现有 sessionId`)
+        }
+      }
+
+      // 10. 构建 MCP 服务器配置
+      const mcpServers = buildMcpServers(workspaceSlug)
+      await injectMemoryTools(sdk, mcpServers)
+      await injectNanoBananaTools(sdk, mcpServers, sessionId, agentCwd)
+
+      if (customMcpServers) {
+        Object.assign(mcpServers, customMcpServers)
+        console.log(`[SessionRunner] 已合并 ${Object.keys(customMcpServers).length} 个自定义 MCP 服务器`)
+      }
+
+      // 11. 构建动态上下文和最终 prompt
+      const persona = workspaceSlug ? getAgentPersona(workspaceSlug) : undefined
+      const dynamicCtx = buildDynamicContext({
+        workspaceName: workspace?.name,
+        workspaceSlug,
+        agentCwd,
+        includePersona: true,
+        persona,
+      })
+
+      let enrichedMessage = userMessage
+      if (mentionedSkills?.length || mentionedMcpServers?.length || mentionedAgents?.length) {
+        const toolLines: string[] = ['用户在消息中明确引用了以下工具，请在本次回复中主动调用：']
+        for (const slug of mentionedSkills ?? []) {
+          const qualifiedName = workspaceSlug
+            ? `proma-workspace-${workspaceSlug}:${slug}`
+            : slug
+          toolLines.push(`- Skill: ${qualifiedName}（请立即调用此 Skill）`)
+        }
+        for (const name of mentionedMcpServers ?? []) {
+          toolLines.push(`- MCP 服务器: ${name}（请使用此 MCP 服务器的工具来完成任务）`)
+        }
+        for (const slug of mentionedAgents ?? []) {
+          toolLines.push(`- 子代理: ${slug}（请通过 Task 工具调用此子代理）`)
+        }
+        enrichedMessage = `<mentioned_tools>\n${toolLines.join('\n')}\n</mentioned_tools>\n\n${userMessage}`
+      }
+
+      const contextualMessage = `${dynamicCtx}\n\n${enrichedMessage}`
+
+      const isCompactCommand = userMessage.trim() === '/compact'
+      const finalPrompt = isCompactCommand
+        ? '/compact'
+        : existingSdkSessionId
+          ? contextualMessage
+          : buildContextPrompt(sessionId, contextualMessage)
+
+      // 12. 读取权限模式
+      const appSettings = getSettings()
+      const permissionMode: PromaPermissionMode = permissionModeOverride
+        ?? (workspaceSlug
+          ? getWorkspacePermissionMode(workspaceSlug)
+          : (appSettings.agentPermissionMode ?? 'smart'))
+
+      const canUseTool = permissionMode !== 'auto'
+        ? permissionService.createCanUseTool(
+            sessionId,
+            permissionMode,
+            (request: PermissionRequest) => {
+              this.eventBus.emit(sessionId, { type: 'permission_request', request })
+            },
+            (sid, toolInput, signal, sendAskUser) => askUserService.handleAskUserQuestion(sid, toolInput, signal, sendAskUser),
+            (request: AskUserRequest) => {
+              this.eventBus.emit(sessionId, { type: 'ask_user_request', request })
+            },
+          )
+        : undefined
+
+      // 13. 加载工作区子代理定义
+      let agentsRecord: Record<string, AgentDefinition> | undefined
+      if (workspaceSlug) {
+        const agentMetas = getWorkspaceAgents(workspaceSlug)
+        if (agentMetas.length > 0) {
+          agentsRecord = {}
+          for (const meta of agentMetas) {
+            const def = loadAgentDefinition(workspaceSlug, meta.slug)
+            if (def) {
+              agentsRecord[meta.slug] = def
+            }
+          }
+          if (Object.keys(agentsRecord).length === 0) agentsRecord = undefined
+        }
+      }
+
+      // 14. 读取子代理配置
+      const enableSubAgents = input.enableSubAgents !== false  // 默认开启
+
+      // 15. 构建 Adapter 查询选项
+      const maxTurns = appSettings.agentMaxTurns && appSettings.agentMaxTurns > 0
+        ? appSettings.agentMaxTurns
+        : undefined
+
+      const baseSystemPromptAppend = buildSystemPromptAppend({
+        workspaceName: workspace?.name,
+        workspaceSlug,
+        sessionId,
+        permissionMode,
+        includePersona: true,
+        persona,
+      })
+
+      const queryOptions: ClaudeAgentQueryOptions = {
+        sessionId,
+        prompt: finalPrompt,
+        model: modelId || DEFAULT_MODEL_ID,
+        cwd: agentCwd,
+        sdkCliPath: cliPath,
+        executable: agentExec,
+        executableArgs,
+        env: sdkEnv,
+        ...(maxTurns != null && { maxTurns }),
+        sdkPermissionMode: permissionMode === 'auto' ? 'bypassPermissions' : 'default',
+        allowDangerouslySkipPermissions: true,
+        ...(canUseTool && { canUseTool }),
+        allowedTools: permissionMode === 'auto'
+          ? (enableSubAgents ? [...ALL_STANDARD_TOOLS] as string[] : [...ALL_STANDARD_TOOLS].filter(t => t !== 'Task' && t !== 'TaskOutput'))
+          : (enableSubAgents ? [...SAFE_TOOLS, 'Task', 'TaskOutput'] as string[] : [...SAFE_TOOLS] as string[]),
+        systemPrompt: {
+          type: 'preset',
+          preset: 'claude_code',
+          append: baseSystemPromptAppend,
+        },
+        resumeSessionId: existingSdkSessionId,
+        ...(agentsRecord && { agents: agentsRecord }),
+        ...(Object.keys(mcpServers).length > 0 && { mcpServers }),
+        ...(workspaceSlug && { plugins: [{ type: 'local' as const, path: getAgentWorkspacePath(workspaceSlug) }] }),
+        ...(() => {
+          const allDirs = [...(additionalDirectories || [])]
+          if (workspaceSlug) {
+            const workspaceDirs = getWorkspaceAttachedDirectories(workspaceSlug)
+            for (const dir of workspaceDirs) {
+              if (!allDirs.includes(dir)) allDirs.push(dir)
+            }
+            const wsFilesDir = getWorkspaceFilesDir(workspaceSlug)
+            if (!allDirs.includes(wsFilesDir)) {
+              allDirs.push(wsFilesDir)
+            }
+          }
+          return allDirs.length > 0 ? { additionalDirectories: allDirs } : {}
+        })(),
+        ...(appSettings.agentThinking && { thinking: appSettings.agentThinking }),
+        ...(appSettings.agentEffort && { effort: appSettings.agentEffort }),
+        ...(appSettings.agentMaxBudgetUsd != null && appSettings.agentMaxBudgetUsd > 0 && {
+          maxBudgetUsd: appSettings.agentMaxBudgetUsd,
+        }),
+        // 启用子代理进度摘要（~30s AI 生成进度描述）
+        agentProgressSummaries: true,
+        onStderr: (data: string) => {
+          stderrChunks.push(data)
+          console.error(`[Agent SDK stderr] ${data}`)
+        },
+        onSessionId: (sdkSessionId: string) => {
+          capturedSdkSessionId = sdkSessionId
+          if (sdkSessionId !== existingSdkSessionId) {
+            try {
+              updateAgentSessionMeta(sessionId, { sdkSessionId, channelId })
+            } catch {
+              // 索引更新失败不影响主流程
+            }
+          }
+        },
+        onModelResolved: (model: string) => {
+          resolvedModel = model
+          this.eventBus.emit(sessionId, { type: 'model_resolved', model })
+        },
+        onContextWindow: (cw: number) => {
+          console.log(`[SessionRunner] 缓存 contextWindow: ${cw}`)
+        },
+      }
+
+      console.log(`[SessionRunner] 开始通过 Adapter 遍历事件流...`)
+
+      // 15. 遍历事件流（含自动重试）
+      let lastRetryableError: string | undefined
+      let retrySucceeded = false
+
+      for (let attempt = 1; attempt <= MAX_AUTO_RETRIES + 1; attempt++) {
+        // 非首次尝试：等待 + 发送重试事件
+        if (attempt > 1) {
+          const delayMs = getRetryDelayMs(attempt - 1)
+          const delaySec = delayMs / 1000
+          const attemptData: RetryAttempt = {
+            attempt: attempt - 1,
+            timestamp: Date.now(),
+            reason: lastRetryableError ?? '未知错误',
+            errorMessage: lastRetryableError ?? '',
+            delaySeconds: delaySec,
+          }
+
+          this.eventBus.emit(sessionId, {
+            type: 'retrying',
+            attempt: attempt - 1,
+            maxAttempts: MAX_AUTO_RETRIES,
+            delaySeconds: delaySec,
+            reason: lastRetryableError ?? '未知错误',
+          })
+          this.eventBus.emit(sessionId, { type: 'retry_attempt', attemptData })
+
+          await new Promise((r) => setTimeout(r, delayMs))
+
+          if (!this.activeSessions.has(sessionId) || this.aborted) {
+            this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
+            callbacks.onComplete(getAgentSessionMessages(sessionId))
+            return
+          }
+        }
+
+        let shouldRetryFromTypedError = false
+
+        try {
+          // 事件流迭代
+          for await (const event of this.adapter.query(queryOptions)) {
+            if (!this.activeSessions.has(sessionId) || this.aborted) break
+
+            // typed_error：判断是否可自动重试
+            if (event.type === 'typed_error') {
+              if (isAutoRetryableTypedError(event.error) && attempt <= MAX_AUTO_RETRIES) {
+                lastRetryableError = event.error.title
+                  ? `${event.error.title}: ${event.error.message}`
+                  : event.error.message
+                this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
+                accumulatedText = ''
+                accumulatedEvents.length = 0
+                shouldRetryFromTypedError = true
+                break
+              }
+
+              // 不可重试 → 终止
+              this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
+
+              const errorMsg: AgentMessage = {
+                id: randomUUID(),
+                role: 'status',
+                content: event.error.title
+                  ? `${event.error.title}: ${event.error.message}`
+                  : event.error.message,
+                createdAt: Date.now(),
+                errorCode: event.error.code,
+                errorTitle: event.error.title,
+                errorDetails: event.error.details,
+                errorOriginal: event.error.originalError,
+                errorCanRetry: event.error.canRetry,
+                errorActions: event.error.actions,
+              }
+              appendAgentMessage(sessionId, errorMsg)
+
+              if (attempt > 1 && lastRetryableError) {
+                this.eventBus.emit(sessionId, {
+                  type: 'retry_failed',
+                  finalAttempt: {
+                    attempt: attempt - 1,
+                    timestamp: Date.now(),
+                    reason: lastRetryableError,
+                    errorMessage: event.error.message,
+                    delaySeconds: 0,
+                  },
+                })
+              }
+
+              this.eventBus.emit(sessionId, event)
+              try { updateAgentSessionMeta(sessionId, {}) } catch { /* 忽略 */ }
+              callbacks.onComplete(getAgentSessionMessages(sessionId))
+              return
+            }
+
+            // 正常事件处理
+            if (event.type === 'text_delta') {
+              accumulatedText += event.text
+            }
+            accumulatedEvents.push(event)
+            this.eventBus.emit(sessionId, event)
+          }
+
+          if (shouldRetryFromTypedError) {
+            continue
+          }
+
+          // 正常完成
+          if (attempt > 1) {
+            this.eventBus.emit(sessionId, { type: 'retry_cleared' })
+          }
+          retrySucceeded = true
+
+          // 持久化助手消息
+          this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
+
+          try { updateAgentSessionMeta(sessionId, {}) } catch { /* 忽略 */ }
+
+          callbacks.onComplete(getAgentSessionMessages(sessionId))
+
+          // 异步生成标题
+          this.autoGenerateTitle(sessionId, userMessage, channelId, resolvedModel, callbacks)
+            .catch((err) => console.error('[SessionRunner] 标题生成异常:', err))
+
+          break
+
+        } catch (error) {
+          const fullStderr = stderrChunks.join('').trim()
+          if (fullStderr) {
+            console.error(`[SessionRunner] 完整 stderr (${fullStderr.length} 字符):`)
+            console.error(fullStderr)
+          }
+
+          // 用户主动中止
+          if (!this.activeSessions.has(sessionId) || this.aborted) {
+            this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
+            callbacks.onComplete(getAgentSessionMessages(sessionId))
+            return
+          }
+
+          // 从 stderr 提取 API 错误
+          const stderrOutput = stderrChunks.join('').trim()
+          const apiError = extractApiError(stderrOutput)
+          const rawErrorMessage = error instanceof Error ? error.message : ''
+
+          // 判断是否可重试
+          if (isAutoRetryableCatchError(apiError, rawErrorMessage) && attempt <= MAX_AUTO_RETRIES) {
+            lastRetryableError = apiError
+              ? `API Error ${apiError.statusCode}: ${apiError.message}`
+              : (error instanceof Error ? error.message : '未知错误')
+            this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
+            accumulatedText = ''
+            accumulatedEvents.length = 0
+            stderrChunks.length = 0
+            continue
+          }
+
+          // 不可重试 — 终止
+          const errorMessage = error instanceof Error ? error.message : '未知错误'
+          console.error(`[SessionRunner] 执行失败:`, error)
+
+          if (accumulatedText || accumulatedEvents.length > 0) {
+            try {
+              this.persistAssistantMessage(sessionId, accumulatedText, accumulatedEvents, resolvedModel)
+            } catch (saveError) {
+              console.error('[SessionRunner] 保存部分内容失败:', saveError)
+            }
+          }
+
+          let userFacingError: string
+          if (apiError) {
+            userFacingError = friendlyErrorMessage(`API 错误 (${apiError.statusCode}):\n${apiError.message}`)
+          } else {
+            userFacingError = friendlyErrorMessage(errorMessage)
+          }
+
+          try {
+            const isPromptTooLong = isPromptTooLongError(
+              userFacingError,
+              error instanceof Error ? (error.stack ?? error.message) : String(error),
+              stderrOutput,
+            )
+
+            const errMsg: AgentMessage = {
+              id: randomUUID(),
+              role: 'status',
+              content: isPromptTooLong
+                ? '上下文过长：当前对话的上下文已超出模型限制，请压缩上下文或开启新会话'
+                : userFacingError,
+              createdAt: Date.now(),
+              errorCode: isPromptTooLong ? 'prompt_too_long' : 'unknown_error',
+              errorTitle: isPromptTooLong ? '上下文过长' : '执行错误',
+              errorOriginal: error instanceof Error ? error.stack : String(error),
+            }
+            appendAgentMessage(sessionId, errMsg)
+          } catch (saveError) {
+            console.error('[SessionRunner] 保存错误消息失败:', saveError)
+          }
+
+          if (attempt > 1 && lastRetryableError) {
+            this.eventBus.emit(sessionId, {
+              type: 'retry_failed',
+              finalAttempt: {
+                attempt: attempt - 1,
+                timestamp: Date.now(),
+                reason: lastRetryableError,
+                errorMessage: userFacingError,
+                delaySeconds: 0,
+              },
+            })
+          }
+
+          callbacks.onError(userFacingError)
+          callbacks.onComplete(getAgentSessionMessages(sessionId))
+
+          const shouldClearSession = !apiError || apiError.statusCode >= 500
+          if (existingSdkSessionId && shouldClearSession) {
+            try {
+              updateAgentSessionMeta(sessionId, { sdkSessionId: undefined })
+            } catch { /* 忽略 */ }
+          }
+
+          throw error
+        }
+      }
+
+      // 重试循环结束（达到最大次数仍失败）
+      if (!retrySucceeded && lastRetryableError) {
+        this.eventBus.emit(sessionId, {
+          type: 'retry_failed',
+          finalAttempt: {
+            attempt: MAX_AUTO_RETRIES,
+            timestamp: Date.now(),
+            reason: lastRetryableError,
+            errorMessage: `重试 ${MAX_AUTO_RETRIES} 次后仍然失败`,
+            delaySeconds: 0,
+          },
+        })
+
+        const retryErrorMsg: AgentMessage = {
+          id: randomUUID(),
+          role: 'status',
+          content: `重试 ${MAX_AUTO_RETRIES} 次后仍然失败: ${lastRetryableError}`,
+          createdAt: Date.now(),
+          errorCode: 'unknown_error',
+          errorTitle: '重试失败',
+        }
+        appendAgentMessage(sessionId, retryErrorMsg)
+
+        callbacks.onError(`重试 ${MAX_AUTO_RETRIES} 次后仍然失败: ${lastRetryableError}`)
+        callbacks.onComplete(getAgentSessionMessages(sessionId))
+      }
+
+    } finally {
+      permissionService.clearSessionPending(sessionId)
+      askUserService.clearSessionPending(sessionId)
+    }
+  }
+
+  /** 持久化助手消息 */
+  private persistAssistantMessage(
+    sessionId: string,
+    accumulatedText: string,
+    accumulatedEvents: AgentEvent[],
+    resolvedModel: string,
+  ): void {
+    if (!accumulatedText && accumulatedEvents.length === 0) return
+
+    // 过滤掉没有实际文本内容的消息（只有工具活动没有文本回复）
+    // 这些工具活动已通过流式事件在前一条消息中展示过
+    if (!accumulatedText) {
+      const hasTextContent = accumulatedEvents.some((e) => e.type === 'text_delta' || e.type === 'text_complete')
+      if (!hasTextContent) return
+    }
+
+    const assistantMsg: AgentMessage = {
+      id: randomUUID(),
+      role: 'assistant',
+      content: accumulatedText,
+      createdAt: Date.now(),
+      model: resolvedModel,
+      events: accumulatedEvents,
+    }
+    appendAgentMessage(sessionId, assistantMsg)
+  }
+
+  /** 自动生成标题 */
+  private async autoGenerateTitle(
+    sessionId: string,
+    userMessage: string,
+    channelId: string,
+    modelId: string,
+    callbacks: SessionCallbacks,
+  ): Promise<void> {
+    try {
+      const meta = getAgentSessionMeta(sessionId)
+      if (!meta || meta.title !== DEFAULT_SESSION_TITLE) return
+
+      const channels = listChannels()
+      const channel = channels.find((c) => c.id === channelId)
+      if (!channel) return
+
+      const apiKey = decryptApiKey(channelId)
+      const providerAdapter = getAdapter(channel.provider)
+      const request = providerAdapter.buildTitleRequest({
+        baseUrl: channel.baseUrl,
+        apiKey,
+        modelId,
+        prompt: TITLE_PROMPT + userMessage,
+      })
+
+      const proxyUrl = await getEffectiveProxyUrl()
+      const fetchFn = getFetchFn(proxyUrl)
+      const title = await fetchTitle(request, providerAdapter, fetchFn)
+      if (!title) return
+
+      const cleaned = title.trim().replace(/^["'""''「《]+|["'""''」》]+$/g, '').trim()
+      const result = cleaned.slice(0, MAX_TITLE_LENGTH) || null
+      if (!result) return
+
+      updateAgentSessionMeta(sessionId, { title: result })
+      callbacks.onTitleUpdated(result)
+    } catch (error) {
+      console.warn('[SessionRunner] 自动标题生成失败:', error)
+    }
+  }
+}
diff --git a/apps/electron/src/main/lib/agent-team-manager.ts b/apps/electron/src/main/lib/agent-team-manager.ts
new file mode 100644
index 00000000..f2943302
--- /dev/null
+++ b/apps/electron/src/main/lib/agent-team-manager.ts
@@ -0,0 +1,97 @@
+/**
+ * AgentTeamManager — 团队动态模式管理
+ *
+ * 负责构建 Lead 编排指令（system prompt 注入），
+ * Claude 作为 Lead 根据任务自行通过 Task 工具创建子代理。
+ */
+
+import type { TeamRunConfig, AgentMeta } from '@proma/shared'
+
+// ===== AgentTeamManager =====
+
+export class AgentTeamManager {
+  /**
+   * 构建 Lead 编排指令（追加到主查询的 system prompt）
+   *
+   * Claude 根据任务自行设计团队，通过 Task 工具动态创建子代理。
+   * 如果工作区有预定义子代理，会列出供 Lead 优先调用。
+   */
+  buildLeadSystemPrompt(config: TeamRunConfig, availableAgents?: AgentMeta[]): string {
+    const sections: string[] = []
+
+    const useAutoExecute = config.autoExecute !== false
+
+    if (useAutoExecute) {
+      // 自动执行模式：跳过确认，直接并行执行
+      sections.push(`<team_orchestration>
+你是团队的 Lead Agent，负责分析用户需求并调度子代理协同完成任务。
+
+## 工作原则
+- 收到用户问题后，立即分析并决定需要哪些子代理
+- 不需要等待用户确认方案，直接开始执行
+- 并行调度子代理以最大化效率
+
+## 执行流程
+
+### 1. 快速分析
+简要说明你的分析计划（1-2 句话），列出即将启动的子代理及其任务方向。格式：
+
+> 🚀 正在启动团队分析...
+> - **[角色名]** → 任务方向
+> - **[角色名]** → 任务方向
+
+### 2. 并行执行
+立即使用 Task 工具**并行**创建所有子代理。每个 Task 调用的 prompt 应包含：
+- 明确的角色定义和专业背景
+- 具体的子任务描述和目标
+- 预期的输出格式和质量要求
+
+### 3. 结果汇总
+所有子代理完成后，综合各子代理的输出，提供结构化的最终报告：
+- 按维度/角色分类整理关键发现
+- 突出重要结论和建议
+- 如有冲突观点，说明分歧并给出你的判断`)
+    } else {
+      // 确认模式：先展示方案，等待用户确认后执行
+      sections.push(`<team_orchestration>
+你现在是团队的 Lead Agent，拥有子代理协作能力。请按以下流程工作：
+
+## 第一阶段：团队规划
+分析用户的任务，设计子代理团队方案。输出格式：
+
+**📋 团队方案**
+
+| 子代理 | 角色 | 任务描述 |
+|--------|------|----------|
+| Agent-1 | 角色名 | 具体任务 |
+| Agent-2 | 角色名 | 具体任务 |
+| ... | ... | ... |
+
+输出方案后，等待用户确认或修改。
+
+## 第二阶段：并行执行
+用户确认后，使用 Task 工具**并行**创建所有子代理。每个 Task 调用的 prompt 应包含：
+- 明确的角色定义和专业背景
+- 具体的子任务描述和目标
+- 预期的输出格式和质量要求
+
+## 第三阶段：结果汇总
+所有子代理完成后，汇总每个子代理的工作结果，向用户提供清晰、完整的最终报告。`)
+    }
+
+    if (availableAgents?.length) {
+      const agentLines = availableAgents.map(
+        (a) => `- **${a.name}**（${a.slug}）：${a.description ?? '无描述'}`,
+      )
+      sections.push(`\n## 可用的预定义子代理\n以下子代理已预先配置，可直接通过 Task 工具按名称调用：\n${agentLines.join('\n')}\n\n优先使用这些预定义子代理来完成匹配的任务，也可根据需要创建新的临时子代理。`)
+    }
+
+    if (config.leadPrompt) {
+      sections.push(`\n## 额外指令\n${config.leadPrompt}`)
+    }
+
+    sections.push('</team_orchestration>')
+
+    return sections.join('\n')
+  }
+}
diff --git a/apps/electron/src/main/lib/agent-team-reader.ts b/apps/electron/src/main/lib/agent-team-reader.ts
deleted file mode 100644
index b38af2bf..00000000
--- a/apps/electron/src/main/lib/agent-team-reader.ts
+++ /dev/null
@@ -1,351 +0,0 @@
-/**
- * Agent Team Reader — 读取 Agent Teams 文件系统数据
- *
- * 职责：
- * - 扫描 ~/.claude/teams/ 查找 team 配置
- * - 读取 ~/.claude/tasks/ 中的任务列表
- * - 读取 agent 收件箱消息
- * - 轮询 inbox 带重试（用于 auto-resume）
- * - 格式化 resume prompt
- */
-
-import { readdir, readFile, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { homedir } from 'node:os'
-import type {
-  TeamConfig,
-  TaskItem,
-  ParsedMailboxMessage,
-  AgentTeamData,
-} from '@proma/shared'
-
-const TEAMS_DIR = join(homedir(), '.claude', 'teams')
-const TASKS_DIR = join(homedir(), '.claude', 'tasks')
-
-// ===== 收件箱消息类型 =====
-
-interface InboxMessage {
-  from: string
-  text: string
-  summary?: string
-  timestamp?: string
-  read?: boolean
-}
-
-// ===== Inbox 重试配置 =====
-
-interface InboxRetryConfig {
-  maxAttempts: number
-  delayMs: number
-}
-
-export const INBOX_RETRY_CONFIG: InboxRetryConfig = {
-  maxAttempts: 5,
-  delayMs: 2000,
-}
-
-// ===== 核心函数 =====
-
-/**
- * 通过 SDK sessionId 查找对应的 team 名称和 inbox 路径
- */
-export async function findTeamLeadInboxPath(
-  sdkSessionId: string,
-): Promise<{ teamName: string; inboxPath: string } | null> {
-  let teamEntries: string[]
-  try {
-    teamEntries = await readdir(TEAMS_DIR)
-  } catch {
-    return null
-  }
-
-  for (const teamName of teamEntries) {
-    const configPath = join(TEAMS_DIR, teamName, 'config.json')
-    try {
-      const raw = await readFile(configPath, 'utf-8')
-      const config = JSON.parse(raw) as { leadSessionId?: string }
-      if (config.leadSessionId === sdkSessionId) {
-        const inboxPath = join(TEAMS_DIR, teamName, 'inboxes', 'team-lead.json')
-        return { teamName, inboxPath }
-      }
-    } catch {
-      continue
-    }
-  }
-  return null
-}
-
-/**
- * 读取 team-lead 收件箱中未读的消息（排除系统类型）
- */
-async function readUnreadTeamLeadMessages(inboxPath: string): Promise<InboxMessage[]> {
-  try {
-    const raw = await readFile(inboxPath, 'utf-8')
-    const messages: InboxMessage[] = JSON.parse(raw)
-    return messages.filter((m) => {
-      if (m.read) return false
-      // 跳过纯系统通知
-      try {
-        const parsed = JSON.parse(m.text) as Record<string, unknown>
-        const t = parsed.type
-        if (
-          t === 'idle_notification' ||
-          t === 'shutdown_request' ||
-          t === 'shutdown_approved' ||
-          t === 'permission_request'
-        ) {
-          return false
-        }
-      } catch {
-        // 不是 JSON，保留
-      }
-      return true
-    })
-  } catch {
-    return []
-  }
-}
-
-/**
- * 将收件箱中所有消息标记为已读
- */
-export async function markInboxAsRead(inboxPath: string): Promise<void> {
-  try {
-    const raw = await readFile(inboxPath, 'utf-8')
-    const messages: InboxMessage[] = JSON.parse(raw)
-    const updated = messages.map((m) => ({ ...m, read: true }))
-    await writeFile(inboxPath, JSON.stringify(updated, null, 2), 'utf-8')
-  } catch {
-    // 忽略错误
-  }
-}
-
-/**
- * 带重试的 inbox 轮询
- *
- * Workers 写入 inbox 有时序延迟，需要多次尝试。
- */
-export async function pollInboxWithRetry(
-  inboxPath: string,
-  config: InboxRetryConfig,
-): Promise<InboxMessage[]> {
-  for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
-    const messages = await readUnreadTeamLeadMessages(inboxPath)
-    if (messages.length > 0) {
-      console.log(`[Team Reader] Inbox 轮询 ${attempt}/${config.maxAttempts}: 找到 ${messages.length} 条消息`)
-      return messages
-    }
-    if (attempt < config.maxAttempts) {
-      console.log(`[Team Reader] Inbox 轮询 ${attempt}/${config.maxAttempts}: 空，${config.delayMs}ms 后重试`)
-      await new Promise<void>((resolve) => setTimeout(resolve, config.delayMs))
-    }
-  }
-  console.log(`[Team Reader] Inbox 轮询: ${config.maxAttempts} 次尝试用尽，仍为空`)
-  return []
-}
-
-/**
- * 格式化未读收件箱消息，作为 auto-resume 的 prompt
- */
-export function formatInboxPrompt(messages: InboxMessage[]): string {
-  const sections = messages.map((m) => {
-    const header = `**来自 ${m.from}**${m.summary ? `（${m.summary}）` : ''}:`
-    let body = m.text
-    try {
-      const parsed = JSON.parse(m.text) as Record<string, unknown>
-      if (typeof parsed.content === 'string') body = parsed.content
-    } catch { /* 非 JSON */ }
-    return `${header}\n${body}`
-  })
-  return (
-    `[系统通知] 你的工作者 Agent 已完成任务，以下是他们发送的完整工作结果：\n\n` +
-    sections.join('\n\n---\n\n') +
-    `\n\n请基于以上工作结果，向用户提供完整、详尽的最终回复。`
-  )
-}
-
-/** task_notification 收集的摘要（用作 inbox 为空时的 fallback） */
-export interface TaskNotificationSummary {
-  taskId: string
-  status: string
-  summary: string
-  outputFile?: string
-}
-
-/**
- * 用 task_notification 的 summaries 构造 fallback resume prompt
- */
-export function formatSummaryFallbackPrompt(summaries: TaskNotificationSummary[]): string {
-  const sections = summaries.map((s) => {
-    const statusLabel = s.status === 'completed' ? '已完成' : s.status
-    return `- **Task ${s.taskId}** (${statusLabel}): ${s.summary}`
-  })
-  return (
-    `[系统通知] 你的工作者 Agent 已完成任务。以下是各任务的完成摘要：\n\n` +
-    sections.join('\n') +
-    `\n\n请基于以上任务摘要，向用户提供完整、详尽的最终回复。`
-  )
-}
-
-/**
- * 检测所有工作者 Agent 是否已进入 idle 状态
- *
- * 用于 Watchdog 死锁检测：Task 工具仍在等待但 Workers 已停止工作。
- */
-export async function areAllWorkersIdle(
-  sdkSessionId: string,
-  startedCount: number,
-): Promise<boolean> {
-  if (startedCount === 0) return false
-  const inboxInfo = await findTeamLeadInboxPath(sdkSessionId)
-  if (!inboxInfo) return false
-  try {
-    const raw = await readFile(inboxInfo.inboxPath, 'utf-8')
-    const messages: InboxMessage[] = JSON.parse(raw)
-    const idleWorkers = new Set<string>()
-    for (const msg of messages) {
-      try {
-        const parsed = JSON.parse(msg.text) as Record<string, unknown>
-        if (parsed.type === 'idle_notification') {
-          idleWorkers.add(msg.from)
-        }
-      } catch { /* 非 JSON */ }
-    }
-    return idleWorkers.size >= startedCount
-  } catch {
-    return false
-  }
-}
-
-// ===== Team 数据聚合（IPC 用） =====
-
-/**
- * 通过 SDK sessionId 获取 Team 聚合数据
- *
- * 供 IPC handler 调用，返回完整的团队信息 + 任务列表 + 收件箱消息。
- */
-export async function getAgentTeamData(sdkSessionId: string): Promise<AgentTeamData | null> {
-  let teamEntries: string[]
-  try {
-    teamEntries = await readdir(TEAMS_DIR)
-  } catch {
-    return null
-  }
-
-  for (const teamName of teamEntries) {
-    const configPath = join(TEAMS_DIR, teamName, 'config.json')
-    try {
-      const raw = await readFile(configPath, 'utf-8')
-      const config: TeamConfig = JSON.parse(raw)
-      if (config.leadSessionId === sdkSessionId) {
-        const tasks = await readTasksForTeam(teamName)
-        const inboxes = await readInboxesForTeam(teamName)
-        return { teamName, team: config, tasks, inboxes }
-      }
-    } catch {
-      continue
-    }
-  }
-
-  return null
-}
-
-/**
- * 读取指定 team 的任务列表
- */
-async function readTasksForTeam(teamName: string): Promise<TaskItem[]> {
-  const tasksDir = join(TASKS_DIR, teamName)
-  let files: string[]
-  try {
-    files = await readdir(tasksDir)
-  } catch {
-    return []
-  }
-
-  const jsonFiles = files
-    .filter((f) => f.endsWith('.json') && !f.startsWith('.'))
-    .sort((a, b) => {
-      const na = parseInt(a, 10)
-      const nb = parseInt(b, 10)
-      if (!isNaN(na) && !isNaN(nb)) return na - nb
-      return a.localeCompare(b)
-    })
-
-  const tasks: TaskItem[] = []
-  for (const file of jsonFiles) {
-    try {
-      const raw = await readFile(join(tasksDir, file), 'utf-8')
-      const task: TaskItem = JSON.parse(raw)
-      tasks.push(task)
-    } catch {
-      continue
-    }
-  }
-
-  return tasks
-}
-
-/**
- * 读取指定 team 的所有 agent 收件箱消息
- */
-async function readInboxesForTeam(teamName: string): Promise<Record<string, ParsedMailboxMessage[]>> {
-  const inboxesDir = join(TEAMS_DIR, teamName, 'inboxes')
-  let files: string[]
-  try {
-    files = await readdir(inboxesDir)
-  } catch {
-    return {}
-  }
-
-  const result: Record<string, ParsedMailboxMessage[]> = {}
-
-  for (const file of files) {
-    if (!file.endsWith('.json') || file.startsWith('.')) continue
-    const agentName = file.replace(/\.json$/, '')
-    try {
-      const raw = await readFile(join(inboxesDir, file), 'utf-8')
-      const messages: InboxMessage[] = JSON.parse(raw)
-      result[agentName] = messages.map(parseMailboxMessage)
-    } catch {
-      continue
-    }
-  }
-
-  return result
-}
-
-/**
- * 解析收件箱消息类型
- */
-function parseMailboxMessage(msg: InboxMessage): ParsedMailboxMessage {
-  try {
-    const parsed = JSON.parse(msg.text) as Record<string, unknown>
-    if (parsed && typeof parsed === 'object' && typeof parsed.type === 'string') {
-      const msgType = parsed.type
-      if (msgType === 'idle_notification') return { ...msg, parsedType: 'idle_notification' }
-      if (msgType === 'shutdown_request') return { ...msg, parsedType: 'shutdown_request' }
-      if (msgType === 'shutdown_approved') return { ...msg, parsedType: 'shutdown_approved' }
-      if (msgType === 'task_assignment') return { ...msg, parsedType: 'task_assignment' }
-    }
-  } catch {
-    // 不是 JSON
-  }
-  return { ...msg, parsedType: 'text' }
-}
-
-/**
- * 读取 Teammate 输出文件内容
- *
- * 安全性：仅允许读取 ~/.claude/ 目录下的文件。
- */
-export async function readAgentOutputFile(filePath: string): Promise<string> {
-  const claudeDir = join(homedir(), '.claude')
-  if (!filePath.startsWith(claudeDir)) {
-    throw new Error('不允许读取 ~/.claude/ 目录之外的文件')
-  }
-  try {
-    return await readFile(filePath, 'utf-8')
-  } catch {
-    return ''
-  }
-}
diff --git a/apps/electron/src/main/lib/agent-workspace-manager.ts b/apps/electron/src/main/lib/agent-workspace-manager.ts
index 5903f224..92e038ea 100644
--- a/apps/electron/src/main/lib/agent-workspace-manager.ts
+++ b/apps/electron/src/main/lib/agent-workspace-manager.ts
@@ -18,8 +18,11 @@ import {
   getWorkspaceSkillsDir,
   getInactiveSkillsDir,
   getDefaultSkillsDir,
+  getWorkspaceFilesDir,
+  getWorkspaceAgentsDir,
+  getWorkspaceAgentsInactiveDir,
 } from './config-paths'
-import type { AgentWorkspace, McpServerEntry, WorkspaceMcpConfig, SkillMeta, WorkspaceCapabilities, PromaPermissionMode } from '@proma/shared'
+import type { AgentWorkspace, McpServerEntry, WorkspaceMcpConfig, SkillMeta, AgentMeta, AgentDefinition, WorkspaceCapabilities, PromaPermissionMode } from '@proma/shared'
 
 /**
  * 工作区索引文件格式
@@ -361,11 +364,12 @@ function parseSkillFrontmatter(content: string, slug: string, enabled: boolean):
 // ===== 工作区能力摘要 =====
 
 /**
- * 获取工作区能力摘要（MCP + Skill 计数）
+ * 获取工作区能力摘要（MCP + Skill + 子代理）
  */
 export function getWorkspaceCapabilities(workspaceSlug: string): WorkspaceCapabilities {
   const mcpConfig = getWorkspaceMcpConfig(workspaceSlug)
   const skills = getWorkspaceSkills(workspaceSlug)
+  const agents = getWorkspaceAgents(workspaceSlug)
 
   const mcpServers = Object.entries(mcpConfig.servers ?? {}).map(([name, entry]) => ({
     name,
@@ -373,7 +377,7 @@ export function getWorkspaceCapabilities(workspaceSlug: string): WorkspaceCapabi
     type: entry.type,
   }))
 
-  return { mcpServers, skills }
+  return { mcpServers, skills, agents }
 }
 
 /**
@@ -465,6 +469,171 @@ export function toggleWorkspaceSkill(workspaceSlug: string, skillSlug: string, e
   console.log(`[Agent 工作区] Skill ${enabled ? '启用' : '禁用'}: ${workspaceSlug}/${skillSlug}`)
 }
 
+// ===== 子代理管理 =====
+
+/**
+ * 获取工作区活跃子代理列表
+ *
+ * 扫描 agents/ 目录，返回已启用的子代理元数据。
+ */
+export function getWorkspaceAgents(workspaceSlug: string): AgentMeta[] {
+  return scanAgentsInDir(getWorkspaceAgentsDir(workspaceSlug), true)
+}
+
+/**
+ * 获取工作区所有子代理（含活跃和不活跃）
+ *
+ * 同时扫描 agents/ 和 agents-inactive/ 目录。用于设置页 UI。
+ */
+export function getAllWorkspaceAgents(workspaceSlug: string): AgentMeta[] {
+  const active = scanAgentsInDir(getWorkspaceAgentsDir(workspaceSlug), true)
+  const inactive = scanAgentsInDir(getWorkspaceAgentsInactiveDir(workspaceSlug), false)
+  return [...active, ...inactive]
+}
+
+/**
+ * 删除工作区子代理
+ */
+export function deleteWorkspaceAgent(workspaceSlug: string, agentSlug: string): void {
+  const agentsDir = getWorkspaceAgentsDir(workspaceSlug)
+  const inactiveDir = getWorkspaceAgentsInactiveDir(workspaceSlug)
+  const activePath = join(agentsDir, agentSlug)
+  const inactivePath = join(inactiveDir, agentSlug)
+
+  const targetPath = existsSync(activePath) ? activePath : existsSync(inactivePath) ? inactivePath : null
+  if (!targetPath) {
+    throw new Error(`子代理不存在: ${agentSlug}`)
+  }
+
+  rmSync(targetPath, { recursive: true, force: true })
+  console.log(`[Agent 工作区] 已删除子代理: ${workspaceSlug}/${agentSlug}`)
+}
+
+/**
+ * 切换工作区子代理的启用/禁用状态
+ *
+ * 在 agents/ 和 agents-inactive/ 之间移动文件夹。
+ */
+export function toggleWorkspaceAgent(workspaceSlug: string, agentSlug: string, enabled: boolean): void {
+  const activeDir = getWorkspaceAgentsDir(workspaceSlug)
+  const inactiveDir = getWorkspaceAgentsInactiveDir(workspaceSlug)
+
+  const srcDir = enabled ? inactiveDir : activeDir
+  const destDir = enabled ? activeDir : inactiveDir
+
+  const srcPath = join(srcDir, agentSlug)
+  const destPath = join(destDir, agentSlug)
+
+  if (!existsSync(srcPath)) {
+    throw new Error(`子代理不存在: ${agentSlug}`)
+  }
+
+  if (existsSync(destPath)) {
+    throw new Error(`目标目录已存在同名子代理: ${agentSlug}`)
+  }
+
+  renameSync(srcPath, destPath)
+  console.log(`[Agent 工作区] 子代理 ${enabled ? '启用' : '禁用'}: ${workspaceSlug}/${agentSlug}`)
+}
+
+/**
+ * 加载子代理完整定义（含 prompt body）
+ *
+ * 读取 AGENT.md 文件，解析 frontmatter 和正文，返回 SDK AgentDefinition。
+ */
+export function loadAgentDefinition(workspaceSlug: string, agentSlug: string): AgentDefinition | null {
+  const agentMdPath = join(getWorkspaceAgentsDir(workspaceSlug), agentSlug, 'AGENT.md')
+  if (!existsSync(agentMdPath)) return null
+
+  try {
+    const content = readFileSync(agentMdPath, 'utf-8')
+    const meta = parseAgentFrontmatter(content, agentSlug, true)
+
+    // 提取正文（frontmatter 之后的内容）
+    const bodyMatch = content.match(/^---\s*\n[\s\S]*?\n---\s*\n([\s\S]*)$/)
+    const prompt = bodyMatch?.[1]?.trim() ?? ''
+
+    return {
+      description: meta.description ?? meta.name,
+      ...(prompt && { prompt }),
+      ...(meta.tools && { tools: meta.tools }),
+      ...(meta.disallowedTools && { disallowedTools: meta.disallowedTools }),
+      ...(meta.maxTurns != null && { maxTurns: meta.maxTurns }),
+    }
+  } catch {
+    console.warn(`[Agent 工作区] 加载子代理定义失败: ${agentSlug}`)
+    return null
+  }
+}
+
+/**
+ * 解析 AGENT.md 的 YAML frontmatter
+ */
+function parseAgentFrontmatter(content: string, slug: string, enabled: boolean): AgentMeta {
+  const meta: AgentMeta = { slug, name: slug, enabled }
+
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/)
+  if (!fmMatch) return meta
+
+  const yaml = fmMatch[1]
+  if (!yaml) return meta
+
+  for (const line of yaml.split('\n')) {
+    const colonIdx = line.indexOf(':')
+    if (colonIdx === -1) continue
+
+    const key = line.slice(0, colonIdx).trim()
+    const value = line.slice(colonIdx + 1).trim().replace(/^["']|["']$/g, '')
+
+    if (key === 'name' && value) meta.name = value
+    if (key === 'description' && value) meta.description = value
+    if (key === 'icon' && value) meta.icon = value
+    if (key === 'maxTurns' && value) {
+      const n = parseInt(value, 10)
+      if (!isNaN(n) && n > 0) meta.maxTurns = n
+    }
+    if (key === 'tools' && value) {
+      meta.tools = value.split(',').map((t) => t.trim()).filter(Boolean)
+    }
+    if (key === 'disallowedTools' && value) {
+      meta.disallowedTools = value.split(',').map((t) => t.trim()).filter(Boolean)
+    }
+  }
+
+  return meta
+}
+
+/**
+ * 扫描指定目录下的子代理
+ */
+function scanAgentsInDir(dir: string, enabled: boolean): AgentMeta[] {
+  const agents: AgentMeta[] = []
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const isDir = entry.isDirectory() || (entry.isSymbolicLink() && statSync(join(dir, entry.name)).isDirectory())
+      if (!isDir) continue
+
+      const agentMdPath = join(dir, entry.name, 'AGENT.md')
+      if (!existsSync(agentMdPath)) continue
+
+      try {
+        const content = readFileSync(agentMdPath, 'utf-8')
+        const meta = parseAgentFrontmatter(content, entry.name, enabled)
+        agents.push(meta)
+      } catch {
+        console.warn(`[Agent 工作区] 解析子代理失败: ${entry.name}`)
+      }
+    }
+  } catch {
+    // 目录可能不存在
+  }
+
+  return agents
+}
+
 // ===== 权限模式管理 =====
 
 /** 工作区配置文件格式 */
@@ -564,3 +733,28 @@ export function detachWorkspaceDirectory(workspaceSlug: string, directoryPath: s
   console.log(`[Agent 工作区] 已移除工作区目录: ${directoryPath} ← ${workspaceSlug}`)
   return updated
 }
+
+/**
+ * 删除工作区上传文件目录的所有内容（保留目录本身）
+ */
+export function deleteWorkspaceFilesDirectory(workspaceSlug: string): void {
+  const dir = getWorkspaceFilesDir(workspaceSlug)
+
+  if (!existsSync(dir)) {
+    return
+  }
+
+  // 删除目录下所有文件和子目录
+  const entries = readdirSync(dir)
+  for (const entry of entries) {
+    const fullPath = join(dir, entry)
+    const stat = statSync(fullPath)
+    if (stat.isDirectory()) {
+      rmSync(fullPath, { recursive: true })
+    } else {
+      rmSync(fullPath)
+    }
+  }
+
+  console.log(`[Agent 工作区] 已清空工作区上传文件目录: ${dir}`)
+}
diff --git a/apps/electron/src/main/lib/channel-manager.ts b/apps/electron/src/main/lib/channel-manager.ts
index 83a76308..2dcdf840 100644
--- a/apps/electron/src/main/lib/channel-manager.ts
+++ b/apps/electron/src/main/lib/channel-manager.ts
@@ -20,6 +20,7 @@ import type {
   FetchModelsInput,
   FetchModelsResult,
   ProviderType,
+  ChannelAuthType,
 } from '@proma/shared'
 import { getFetchFn } from './proxy-fetch'
 import { getEffectiveProxyUrl } from './proxy-settings-service'
@@ -578,3 +579,127 @@ async function fetchGoogleModels(baseUrl: string, apiKey: string, proxyUrl?: str
     models,
   }
 }
+
+// ===== 本地环境渠道 =====
+
+/**
+ * 本地环境检测结果
+ */
+export interface LocalEnvDetection {
+  /** 检测到的认证类型 */
+  authType: ChannelAuthType
+  /** 渠道名称 */
+  name: string
+  /** 确定性 ID（避免重复创建） */
+  id: string
+  /** Base URL（用于 api_key 和 vertex） */
+  baseUrl: string
+  /** API Key（明文，可能为空） */
+  apiKey: string
+  /** 额外环境变量（明文 key-value） */
+  envVars: Record<string, string>
+  /** 推断的模型列表 */
+  models: ChannelModel[]
+}
+
+/**
+ * 加密环境变量 map 中的所有值
+ */
+function encryptEnvVars(plainVars: Record<string, string>): Record<string, string> {
+  const encrypted: Record<string, string> = {}
+  for (const [key, value] of Object.entries(plainVars)) {
+    encrypted[key] = encryptApiKey(value)
+  }
+  return encrypted
+}
+
+/**
+ * 解密渠道的 envVars
+ *
+ * @returns 明文的环境变量 map，如果渠道无 envVars 则返回空对象
+ */
+export function decryptChannelEnvVars(channelId: string): Record<string, string> {
+  const channel = getChannelById(channelId)
+  if (!channel?.envVars) return {}
+
+  const decrypted: Record<string, string> = {}
+  for (const [key, encryptedValue] of Object.entries(channel.envVars)) {
+    try {
+      decrypted[key] = decryptKey(encryptedValue)
+    } catch (error) {
+      console.error(`[渠道管理] 解密环境变量 ${key} 失败:`, error)
+    }
+  }
+  return decrypted
+}
+
+/**
+ * 创建或更新本地环境渠道
+ *
+ * 使用确定性 ID（如 local-env-vertex）：
+ * - 如果该 ID 不存在 → 创建新渠道
+ * - 如果该 ID 已存在 → 更新配置（保留用户对 enabled/models 的修改）
+ */
+export function createOrUpdateLocalEnvChannel(detection: LocalEnvDetection): Channel {
+  const config = readConfig()
+  const existingIndex = config.channels.findIndex((c) => c.id === detection.id)
+  const now = Date.now()
+
+  if (existingIndex !== -1) {
+    // 更新已有渠道：保留 enabled 状态和用户自定义的 models 选择
+    const existing = config.channels[existingIndex]!
+    const updated: Channel = {
+      ...existing,
+      name: detection.name,
+      baseUrl: detection.baseUrl,
+      apiKey: detection.apiKey ? encryptApiKey(detection.apiKey) : existing.apiKey,
+      authType: detection.authType,
+      source: 'local_env',
+      envVars: encryptEnvVars(detection.envVars),
+      updatedAt: now,
+    }
+    config.channels[existingIndex] = updated
+    writeConfig(config)
+    console.log(`[渠道管理] 已更新本地环境渠道: ${updated.name} (${updated.id})`)
+    return updated
+  }
+
+  // 创建新渠道
+  const channel: Channel = {
+    id: detection.id,
+    name: detection.name,
+    provider: 'anthropic',
+    baseUrl: detection.baseUrl,
+    apiKey: detection.apiKey ? encryptApiKey(detection.apiKey) : '',
+    models: detection.models,
+    enabled: true,
+    createdAt: now,
+    updatedAt: now,
+    authType: detection.authType,
+    source: 'local_env',
+    envVars: encryptEnvVars(detection.envVars),
+  }
+
+  config.channels.push(channel)
+  writeConfig(config)
+  console.log(`[渠道管理] 已创建本地环境渠道: ${channel.name} (${channel.id})`)
+  return channel
+}
+
+/**
+ * 移除不再有效的本地环境渠道
+ *
+ * 当用户从 shell 中移除了相关环境变量后，对应的渠道应被清理。
+ */
+export function removeStaleLocalEnvChannels(activeIds: Set<string>): void {
+  const config = readConfig()
+  const before = config.channels.length
+  config.channels = config.channels.filter((c) => {
+    if (c.source !== 'local_env') return true
+    return activeIds.has(c.id)
+  })
+  if (config.channels.length < before) {
+    writeConfig(config)
+    console.log(`[渠道管理] 已移除 ${before - config.channels.length} 个过期的本地环境渠道`)
+  }
+}
diff --git a/apps/electron/src/main/lib/chat-service.ts b/apps/electron/src/main/lib/chat-service.ts
index 5df4c1d6..a406170f 100644
--- a/apps/electron/src/main/lib/chat-service.ts
+++ b/apps/electron/src/main/lib/chat-service.ts
@@ -210,6 +210,15 @@ export async function sendMessage(
     return
   }
 
+  // 1.5 Vertex/Bedrock 渠道仅支持 Agent 模式
+  if (channel.authType === 'vertex' || channel.authType === 'bedrock') {
+    webContents.send(CHAT_IPC_CHANNELS.STREAM_ERROR, {
+      conversationId,
+      error: '该渠道仅支持 Agent 模式（Vertex/Bedrock 需要特殊认证）',
+    })
+    return
+  }
+
   // 2. 解密 API Key
   let apiKey: string
   try {
diff --git a/apps/electron/src/main/lib/chat-tools/nano-banana-tool.ts b/apps/electron/src/main/lib/chat-tools/nano-banana-tool.ts
index c97037ed..01d853a9 100644
--- a/apps/electron/src/main/lib/chat-tools/nano-banana-tool.ts
+++ b/apps/electron/src/main/lib/chat-tools/nano-banana-tool.ts
@@ -340,7 +340,16 @@ export async function executeNanoBananaTool(
       }
     }
 
-    const parts = data.candidates![0].content.parts
+    const candidate = data.candidates[0]
+    if (!candidate) {
+      return {
+        toolCallId: toolCall.id,
+        content: '未生成任何内容',
+        isError: true,
+      }
+    }
+
+    const parts = candidate.content.parts
     console.log(`[Nano Banana] 响应包含 ${parts.length} 个 parts，类型:`, parts.map((p) => p.inlineData ? `image(${p.inlineData.mimeType})` : `text(${(p.text ?? '').slice(0, 30)})`))
     const generatedAttachments: FileAttachment[] = []
     const textParts: string[] = []
diff --git a/apps/electron/src/main/lib/config-paths.ts b/apps/electron/src/main/lib/config-paths.ts
index 53fa9d4e..992413e7 100644
--- a/apps/electron/src/main/lib/config-paths.ts
+++ b/apps/electron/src/main/lib/config-paths.ts
@@ -285,6 +285,42 @@ export function getWorkspaceSkillsDir(slug: string): string {
   return dir
 }
 
+/**
+ * 获取指定工作区的子代理目录路径
+ *
+ * 如果目录不存在则自动创建。
+ *
+ * @param slug 工作区 slug
+ * @returns ~/.proma/agent-workspaces/{slug}/agents/
+ */
+export function getWorkspaceAgentsDir(slug: string): string {
+  const dir = join(getAgentWorkspacePath(slug), 'agents')
+
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+
+  return dir
+}
+
+/**
+ * 获取指定工作区的已禁用子代理目录路径
+ *
+ * 如果目录不存在则自动创建。
+ *
+ * @param slug 工作区 slug
+ * @returns ~/.proma/agent-workspaces/{slug}/agents-inactive/
+ */
+export function getWorkspaceAgentsInactiveDir(slug: string): string {
+  const dir = join(getAgentWorkspacePath(slug), 'agents-inactive')
+
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+
+  return dir
+}
+
 /**
  * 获取工作区文件目录路径
  *
@@ -394,6 +430,15 @@ export function getFeishuBindingsPath(): string {
   return join(getConfigDir(), 'feishu-bindings.json')
 }
 
+/**
+ * 获取飞书多 Bot 配置文件路径
+ *
+ * @returns ~/.proma/feishu-bots.json
+ */
+export function getFeishuBotsConfigPath(): string {
+  return join(getConfigDir(), 'feishu-bots.json')
+}
+
 /**
  * 获取指定 Agent 会话的工作路径
  *
diff --git a/apps/electron/src/main/lib/feishu-binding-store.ts b/apps/electron/src/main/lib/feishu-binding-store.ts
new file mode 100644
index 00000000..9e872272
--- /dev/null
+++ b/apps/electron/src/main/lib/feishu-binding-store.ts
@@ -0,0 +1,73 @@
+/**
+ * 飞书绑定存储
+ *
+ * 负责读取/写入 ~/.proma/feishu-bindings.json。
+ * 支持兼容旧格式（直接数组）并在写入时统一为数组结构。
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { getFeishuBindingsPath } from './config-paths'
+import type { FeishuChatBinding } from '@proma/shared'
+
+interface BindingFileShape {
+  version?: number
+  bindings?: unknown
+}
+
+/**
+ * 读取全部绑定（兼容多种历史格式）
+ */
+export function readAllFeishuBindings(): FeishuChatBinding[] {
+  const path = getFeishuBindingsPath()
+  if (!existsSync(path)) return []
+
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf-8')) as unknown
+
+    if (Array.isArray(raw)) {
+      return raw as FeishuChatBinding[]
+    }
+
+    if (raw && typeof raw === 'object') {
+      const parsed = raw as BindingFileShape
+      if (Array.isArray(parsed.bindings)) {
+        return parsed.bindings as FeishuChatBinding[]
+      }
+    }
+
+    return []
+  } catch (error) {
+    console.error('[飞书绑定存储] 读取失败:', error)
+    return []
+  }
+}
+
+/**
+ * 覆盖写入全部绑定
+ */
+export function writeAllFeishuBindings(bindings: FeishuChatBinding[]): void {
+  const path = getFeishuBindingsPath()
+  try {
+    writeFileSync(path, JSON.stringify(bindings, null, 2), 'utf-8')
+  } catch (error) {
+    console.error('[飞书绑定存储] 写入失败:', error)
+  }
+}
+
+/**
+ * 按 Bot 合并写入，保留其他 Bot 的绑定
+ */
+export function mergeFeishuBindingsForBot(
+  botId: string,
+  ownBindings: FeishuChatBinding[],
+): void {
+  const all = readAllFeishuBindings()
+
+  const others = all.filter((b) => {
+    // 兼容历史数据：旧版本使用 channelId 存 botId
+    const bindingBotId = b.botId ?? b.channelId
+    return bindingBotId !== botId
+  })
+
+  writeAllFeishuBindings([...others, ...ownBindings])
+}
diff --git a/apps/electron/src/main/lib/feishu-bot-config.ts b/apps/electron/src/main/lib/feishu-bot-config.ts
new file mode 100644
index 00000000..d01ae526
--- /dev/null
+++ b/apps/electron/src/main/lib/feishu-bot-config.ts
@@ -0,0 +1,247 @@
+/**
+ * 飞书多 Bot 配置管理
+ *
+ * 负责飞书 Bots 配置的 CRUD 操作、App Secret 加密/解密。
+ * 使用 Electron safeStorage 进行加密（与渠道 API Key 相同模式）。
+ * 数据持久化到 ~/.proma/feishu-bots.json。
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'node:fs'
+import { safeStorage } from 'electron'
+import { getFeishuBotsConfigPath } from './config-paths'
+import type {
+  FeishuBotConfig,
+  FeishuBotsConfig,
+  FeishuBotConfigInput,
+  FeishuNotifyMode,
+} from '@proma/shared'
+
+/** 默认配置版本 */
+const CURRENT_VERSION = 1
+
+/** 默认配置 */
+const DEFAULT_CONFIG: FeishuBotsConfig = {
+  version: CURRENT_VERSION,
+  bots: [],
+  defaultNotifyMode: 'auto',
+}
+
+// ===== 加密/解密 =====
+
+/**
+ * 加密 App Secret
+ *
+ * 使用 Electron safeStorage 加密，底层使用 OS 级加密。
+ *
+ * @returns base64 编码的加密字符串
+ */
+function encryptSecret(plainSecret: string): string {
+  if (!safeStorage.isEncryptionAvailable()) {
+    console.warn('[飞书 Bot 配置] safeStorage 加密不可用，将以明文存储')
+    return plainSecret
+  }
+
+  const encrypted = safeStorage.encryptString(plainSecret)
+  return encrypted.toString('base64')
+}
+
+/**
+ * 解密 App Secret
+ *
+ * @returns 明文 App Secret
+ */
+function decryptSecret(encryptedSecret: string): string {
+  if (!encryptedSecret) return ''
+
+  if (!safeStorage.isEncryptionAvailable()) {
+    return encryptedSecret
+  }
+
+  try {
+    const buffer = Buffer.from(encryptedSecret, 'base64')
+    return safeStorage.decryptString(buffer)
+  } catch (error) {
+    console.error('[飞书 Bot 配置] 解密 App Secret 失败:', error)
+    throw new Error('解密 App Secret 失败')
+  }
+}
+
+// ===== 配置 CRUD =====
+
+/**
+ * 读取 Bots 配置
+ *
+ * 返回的 appSecret 是加密后的，不要直接使用。
+ * 需要明文 Secret 请调用 getDecryptedBotSecret()。
+ */
+export function getFeishuBotsConfig(): FeishuBotsConfig {
+  const configPath = getFeishuBotsConfigPath()
+
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG }
+  }
+
+  try {
+    const raw = readFileSync(configPath, 'utf-8')
+    const data = JSON.parse(raw) as Partial<FeishuBotsConfig>
+    return {
+      ...DEFAULT_CONFIG,
+      ...data,
+    }
+  } catch (error) {
+    console.error('[飞书 Bot 配置] 读取配置文件失败:', error)
+    return { ...DEFAULT_CONFIG }
+  }
+}
+
+/**
+ * 保存 Bots 配置
+ */
+function saveFeishuBotsConfig(config: FeishuBotsConfig): void {
+  const configPath = getFeishuBotsConfigPath()
+  writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8')
+}
+
+/**
+ * 获取所有 Bot 配置列表
+ */
+export function listFeishuBots(): FeishuBotConfig[] {
+  return getFeishuBotsConfig().bots
+}
+
+/**
+ * 根据 ID 获取 Bot 配置
+ */
+export function getFeishuBot(botId: string): FeishuBotConfig | undefined {
+  const config = getFeishuBotsConfig()
+  return config.bots.find((b) => b.id === botId)
+}
+
+/**
+ * 根据 AppID 获取 Bot 配置
+ */
+export function getFeishuBotByAppId(appId: string): FeishuBotConfig | undefined {
+  const config = getFeishuBotsConfig()
+  return config.bots.find((b) => b.appId === appId)
+}
+
+/**
+ * 保存 Bot（新建或更新）
+ *
+ * 接收明文 App Secret，自动加密后存储。
+ * 如果 input.id 存在则更新，否则新建。
+ */
+export function saveFeishuBot(input: FeishuBotConfigInput, existingId?: string): FeishuBotConfig {
+  const config = getFeishuBotsConfig()
+  const now = Date.now()
+  const appId = input.appId.trim()
+
+  if (!appId) {
+    throw new Error('App ID 不能为空')
+  }
+
+  const duplicate = config.bots.find((b) => b.appId === appId && b.id !== existingId)
+  if (duplicate) {
+    throw new Error(`已存在相同 App ID 的 Bot: ${duplicate.name}`)
+  }
+
+  if (existingId) {
+    // 更新现有 Bot
+    const index = config.bots.findIndex((b) => b.id === existingId)
+    if (index === -1) {
+      throw new Error(`Bot not found: ${existingId}`)
+    }
+
+    const existing = config.bots[index]!
+    const nextSecret = input.appSecret ? encryptSecret(input.appSecret) : existing.appSecret
+    if (!nextSecret) {
+      throw new Error('App Secret 不能为空')
+    }
+    const updated: FeishuBotConfig = {
+      id: existing.id,
+      name: input.name,
+      appId,
+      // 空字符串时保留原值
+      appSecret: nextSecret,
+      workspaceId: input.workspaceId,
+      enabled: input.enabled,
+      createdAt: existing.createdAt,
+    }
+    config.bots[index] = updated
+    saveFeishuBotsConfig(config)
+    return updated
+  } else {
+    // 新建 Bot
+    if (!input.appSecret) {
+      throw new Error('新建 Bot 时必须填写 App Secret')
+    }
+
+    const newBot: FeishuBotConfig = {
+      id: crypto.randomUUID(),
+      name: input.name,
+      appId,
+      appSecret: encryptSecret(input.appSecret),
+      workspaceId: input.workspaceId,
+      enabled: input.enabled,
+      createdAt: now,
+    }
+    config.bots.push(newBot)
+    saveFeishuBotsConfig(config)
+    return newBot
+  }
+}
+
+/**
+ * 删除 Bot
+ */
+export function deleteFeishuBot(botId: string): boolean {
+  const config = getFeishuBotsConfig()
+  const index = config.bots.findIndex((b) => b.id === botId)
+  if (index === -1) {
+    return false
+  }
+
+  config.bots.splice(index, 1)
+  saveFeishuBotsConfig(config)
+  return true
+}
+
+/**
+ * 获取解密后的 Bot App Secret
+ *
+ * 用于实际连接飞书 API 时使用。
+ */
+export function getDecryptedBotSecret(botId: string): string {
+  const bot = getFeishuBot(botId)
+  if (!bot) {
+    throw new Error(`Bot not found: ${botId}`)
+  }
+  return decryptSecret(bot.appSecret)
+}
+
+/**
+ * 获取解密后的 Bot App Secret（按 appId 查找）
+ */
+export function getDecryptedBotSecretByAppId(appId: string): string {
+  const bot = getFeishuBotByAppId(appId)
+  if (!bot) {
+    throw new Error(`Bot not found for appId: ${appId}`)
+  }
+  return decryptSecret(bot.appSecret)
+}
+
+/**
+ * 更新默认通知模式
+ */
+export function setDefaultNotifyMode(mode: FeishuNotifyMode): void {
+  const config = getFeishuBotsConfig()
+  config.defaultNotifyMode = mode
+  saveFeishuBotsConfig(config)
+}
+
+/**
+ * 获取默认通知模式
+ */
+export function getDefaultNotifyMode(): FeishuNotifyMode {
+  return getFeishuBotsConfig().defaultNotifyMode
+}
diff --git a/apps/electron/src/main/lib/feishu-bridge.ts b/apps/electron/src/main/lib/feishu-bot-manager.ts
similarity index 65%
rename from apps/electron/src/main/lib/feishu-bridge.ts
rename to apps/electron/src/main/lib/feishu-bot-manager.ts
index 290eca1f..3646d3b9 100644
--- a/apps/electron/src/main/lib/feishu-bridge.ts
+++ b/apps/electron/src/main/lib/feishu-bot-manager.ts
@@ -1,5 +1,5 @@
 /**
- * 飞书 Bridge 服务
+ * 飞书多 Bot 管理器
  *
  * 核心职责：
  * - 通过 WebSocket 长连接接收飞书消息
@@ -7,6 +7,10 @@
  * - 监听 AgentEventBus 事件，累积完整回复后发送到飞书
  * - 管理聊天绑定（chatId ↔ sessionId）
  * - 智能通知路由：桌面发起的会话根据在场状态决定是否发飞书通知
+ *
+ * 架构：
+ * - SingleBotBridge：单个 Bot 的桥接器，包含独立的 WebSocket、client、bindings
+ * - FeishuBotManager：管理多个 SingleBotBridge，支持 startBot/stopBot/startAllEnabled
  */
 
 import { BrowserWindow } from 'electron'
@@ -24,17 +28,20 @@ import type {
   FeishuMessageContext,
   FeishuChatMessage,
   FeishuUpdateBindingInput,
+  FeishuBotStatus,
+  FeishuBotConfig,
 } from '@proma/shared'
 import { FEISHU_IPC_CHANNELS, AGENT_IPC_CHANNELS } from '@proma/shared'
-import { getFeishuConfig, getDecryptedAppSecret } from './feishu-config'
+import { getDecryptedBotSecret, getDefaultNotifyMode } from './feishu-bot-config'
 import { agentEventBus, runAgentHeadless, stopAgent } from './agent-service'
 import { createAgentSession, listAgentSessions, getAgentSessionMeta } from './agent-session-manager'
 import { listAgentWorkspaces, getAgentWorkspace, getWorkspaceCapabilities } from './agent-workspace-manager'
-import { getAgentSessionWorkspacePath, getFeishuBindingsPath } from './config-paths'
-import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
+import { getAgentSessionWorkspacePath } from './config-paths'
+import { mkdirSync, writeFileSync, readdirSync } from 'node:fs'
+import { basename, join } from 'node:path'
 import { getSettings } from './settings-service'
 import { presenceService } from './feishu-presence'
+import { readAllFeishuBindings, mergeFeishuBindingsForBot } from './feishu-binding-store'
 import {
   buildAgentReplyCard,
   buildNotificationCard,
@@ -77,9 +84,17 @@ interface SessionBuffer {
   startedAt: number
 }
 
-// ===== 单例 Bridge =====
+// ===== SingleBotBridge =====
 
-class FeishuBridge {
+/**
+ * 单个飞书 Bot 的桥接器
+ *
+ * 每个 SingleBotBridge 有独立的 WebSocket 连接、client、bindings。
+ * 不直接暴露给外部，由 FeishuBotManager 统一管理。
+ */
+class SingleBotBridge {
+  /** Bot 配置 */
+  private botConfig: FeishuBotConfig
   /** SDK Client（发消息用） */
   private client: InstanceType<typeof import('@larksuiteoapi/node-sdk').Client> | null = null
   /** WebSocket Client */
@@ -101,6 +116,8 @@ class FeishuBridge {
   private sessionNotifyModes = new Map<string, FeishuNotifyMode>()
   /** 默认通知目标 chatId（最后一个与 Bot 交互的飞书聊天） */
   private defaultNotifyChatId: string | null = null
+  /** chatId -> 用户手动选择的目标工作区（用于下一次自动建会话） */
+  private preferredWorkspaceByChat = new Map<string, string>()
 
   /** chatId → 待合并的图片（纯图片消息暂存，等待后续文本一起发送） */
   private pendingImages = new Map<string, FeishuImageAttachment[]>()
@@ -109,6 +126,8 @@ class FeishuBridge {
 
   /** chatId → 最近收到的用户消息 ID（用于群聊 thread reply） */
   private lastUserMessageId = new Map<string, string>()
+  /** chatId → 处理中表情信息（用于完成后移除） */
+  private processingReaction = new Map<string, { messageId: string; reactionId: string }>()
   /** chatId → 群聊信息缓存 */
   private groupInfoCache = new Map<string, FeishuGroupInfo>()
   /** open_id → 用户显示名称缓存 */
@@ -124,29 +143,59 @@ class FeishuBridge {
   private processingChats = new Set<string>()
   private static readonly DEDUP_MAX = 200
 
-  /** EventBus 监听器取消函数 */
-  private eventBusUnsubscribe: (() => void) | null = null
+  /**
+   * 飞书表情回复类型：处理中
+   * 使用 "Typing" 表示正在输入状态
+   * @see https://open.feishu.cn/document/server-docs/im-v1/message-reaction/emojis-introduce
+   */
+  private static readonly REACTION_PROCESSING = 'Typing'
+
+  /** sessionId → EventBus 取消函数（session 级别精准订阅） */
+  private sessionUnsubscribes = new Map<string, () => void>()
+
+  /** 状态变更回调（交由管理器统一广播） */
+  private readonly onStatusChanged?: (status: FeishuBotStatus) => void
+
+  constructor(
+    botConfig: FeishuBotConfig,
+    onStatusChanged?: (status: FeishuBotStatus) => void,
+  ) {
+    this.botConfig = botConfig
+    this.onStatusChanged = onStatusChanged
+  }
+
+  get botId(): string {
+    return this.botConfig.id
+  }
+
+  get appId(): string {
+    return this.botConfig.appId
+  }
 
   // ===== 生命周期 =====
 
   async start(): Promise<void> {
-    const config = getFeishuConfig()
-    if (!config.enabled || !config.appId || !config.appSecret) {
-      throw new Error('请先配置 App ID 和 App Secret')
+    console.log(`[飞书 Bot ${this.botConfig.name}] start() called, enabled=${this.botConfig.enabled}, hasAppId=${!!this.botConfig.appId}, hasSecret=${!!this.botConfig.appSecret}`)
+    if (!this.botConfig.appId || !this.botConfig.appSecret) {
+      const err = 'Bot 缺少配置'
+      console.error(`[飞书 Bot ${this.botConfig.name}] ${err}`)
+      throw new Error(err)
     }
 
     this.updateStatus({ status: 'connecting' })
+    console.log(`[飞书 Bot ${this.botConfig.name}] status set to connecting`)
 
     try {
-      const appSecret = getDecryptedAppSecret()
+      const appSecret = getDecryptedBotSecret(this.botConfig.id)
       const lark = await import('@larksuiteoapi/node-sdk')
 
       // 创建 SDK Client
       this.client = new lark.Client({
-        appId: config.appId,
+        appId: this.botConfig.appId,
         appSecret,
         appType: lark.AppType.SelfBuild,
       })
+      console.log(`[飞书 Bot ${this.botConfig.name}] SDK Client 已创建`)
 
       // 获取 Bot 自身的 open_id（用于群聊 @Bot 精确检测）
       try {
@@ -158,63 +207,65 @@ class FeishuBridge {
           method: 'GET',
           url: 'https://open.feishu.cn/open-apis/bot/v3/info/',
         })
-        console.log('[飞书 Bridge] Bot info 响应:', JSON.stringify(botInfoResp, null, 2))
-        // 飞书 API 返回 bot 在顶层，Lark SDK 可能包装在 data 下，兼容两种
+        console.log(`[飞书 Bot ${this.botConfig.name}] Bot info 响应:`, JSON.stringify(botInfoResp, null, 2))
         this.botOpenId = botInfoResp?.bot?.open_id ?? botInfoResp?.data?.bot?.open_id ?? null
         if (this.botOpenId) {
-          console.log(`[飞书 Bridge] Bot open_id: ${this.botOpenId}`)
+          console.log(`[飞书 Bot ${this.botConfig.name}] Bot open_id: ${this.botOpenId}`)
         } else {
-          console.warn('[飞书 Bridge] 未能获取 Bot open_id，群聊 @Bot 检测将使用回退策略')
+          console.warn(`[飞书 Bot ${this.botConfig.name}] 未能获取 Bot open_id，群聊 @Bot 检测将使用回退策略`)
         }
       } catch (error) {
-        console.warn('[飞书 Bridge] 获取 Bot info 失败（非致命）:', error)
+        console.warn(`[飞书 Bot ${this.botConfig.name}] 获取 Bot info 失败（非致命）:`, error)
       }
 
       // 创建事件分发器
-      // 重要：回调必须立即返回，不能 await 长时间操作
-      // SDK 需要回调返回后发送 ACK 给飞书网关，否则网关会超时重投事件
+      console.log(`[飞书 Bot ${this.botConfig.name}] 注册事件处理器...`)
       const eventDispatcher = new lark.EventDispatcher({}).register({
         'im.message.receive_v1': (data: Record<string, unknown>) => {
+          console.log(`[飞书 Bot ${this.botConfig.name}] ⭐ WebSocket 收到消息事件`)
           this.handleFeishuMessage(data).catch((error) => {
-            console.error('[飞书 Bridge] 处理消息异常:', error)
+            console.error(`[飞书 Bot ${this.botConfig.name}] 处理消息异常:`, error)
           })
         },
       })
+      console.log(`[飞书 Bot ${this.botConfig.name}] 事件处理器注册完成`)
 
       // 创建 WebSocket 长连接
       this.wsClient = new lark.WSClient({
-        appId: config.appId,
+        appId: this.botConfig.appId,
         appSecret,
         loggerLevel: lark.LoggerLevel.warn,
       })
 
       await this.wsClient.start({ eventDispatcher })
 
-      // 注册 EventBus 监听器
-      this.eventBusUnsubscribe = agentEventBus.on((sessionId, event) => {
-        this.handleAgentEvent(sessionId, event)
-      })
-
       // 恢复之前的聊天绑定
       this.loadBindings()
 
+      // 为已恢复的绑定订阅 session 事件
+      for (const binding of this.chatBindings.values()) {
+        this.subscribeToSession(binding.sessionId)
+      }
+
       this.updateStatus({ status: 'connected', connectedAt: Date.now() })
-      console.log('[飞书 Bridge] 已连接')
+      console.log(`[飞书 Bot ${this.botConfig.name}] 已连接`)
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
       this.updateStatus({ status: 'error', errorMessage: message })
-      console.error('[飞书 Bridge] 启动失败:', error)
+      console.error(`[飞书 Bot ${this.botConfig.name}] 启动失败:`, error)
+      throw error
     }
   }
 
   stop(): void {
-    // 取消 EventBus 监听
-    this.eventBusUnsubscribe?.()
-    this.eventBusUnsubscribe = null
+    // 取消所有 session 订阅
+    for (const unsub of this.sessionUnsubscribes.values()) {
+      unsub()
+    }
+    this.sessionUnsubscribes.clear()
 
     // 清理 WebSocket
     if (this.wsClient) {
-      // SDK WSClient 没有显式的 stop 方法，清空引用让 GC 回收
       this.wsClient = null
     }
     this.client = null
@@ -228,65 +279,63 @@ class FeishuBridge {
     this.recentEventIds.clear()
     this.processingChats.clear()
     this.lastUserMessageId.clear()
+    this.preferredWorkspaceByChat.clear()
     this.groupInfoCache.clear()
     this.userNameCache.clear()
     this.defaultNotifyChatId = null
     this.botOpenId = null
 
     this.updateStatus({ status: 'disconnected', activeBindings: 0 })
-    console.log('[飞书 Bridge] 已停止')
-  }
-
-  async restart(): Promise<void> {
-    this.stop()
-    await this.start()
+    console.log(`[飞书 Bot ${this.botConfig.name}] 已停止`)
   }
 
   // ===== 绑定持久化 =====
 
+  private isBindingOwnedByThisBot(binding: FeishuChatBinding): boolean {
+    // 兼容历史数据：旧版本将 botId 存在 channelId 字段
+    const bindingBotId = binding.botId || binding.channelId
+    return bindingBotId === this.botConfig.id
+  }
+
   /** 从磁盘恢复聊天绑定（应用重启后延续之前的会话） */
   private loadBindings(): void {
-    const bindingsPath = getFeishuBindingsPath()
-    if (!existsSync(bindingsPath)) return
+    const bindings = readAllFeishuBindings()
+    const appSettings = getSettings()
 
-    try {
-      const raw = readFileSync(bindingsPath, 'utf-8')
-      const bindings = JSON.parse(raw) as FeishuChatBinding[]
-      const appSettings = getSettings()
-
-      for (const b of bindings) {
-        // 验证对应会话仍然存在
-        const session = getAgentSessionMeta(b.sessionId)
-        if (session) {
-          // 同步最新的渠道和模型设置（用户可能已更改）
-          if (appSettings.agentChannelId) {
-            b.channelId = appSettings.agentChannelId
-          }
-          if (appSettings.agentModelId) {
-            b.modelId = appSettings.agentModelId
-          }
-          this.chatBindings.set(b.chatId, b)
-          this.sessionToChat.set(b.sessionId, b.chatId)
-        }
-      }
-      if (this.chatBindings.size > 0) {
-        console.log(`[飞书 Bridge] 已恢复 ${this.chatBindings.size} 个聊天绑定`)
-        this.updateStatus({ activeBindings: this.chatBindings.size })
+    for (const raw of bindings) {
+      if (!this.isBindingOwnedByThisBot(raw)) continue
+      const session = getAgentSessionMeta(raw.sessionId)
+      if (!session) continue
+
+      const binding: FeishuChatBinding = {
+        ...raw,
+        botId: this.botConfig.id,
+        mode: raw.mode ?? 'agent',
+        chatType: raw.chatType ?? 'p2p',
+        channelId: session.channelId
+          ?? appSettings.agentChannelId
+          ?? (raw.channelId === this.botConfig.id ? '' : raw.channelId),
+        modelId: appSettings.agentModelId ?? raw.modelId,
       }
-    } catch (error) {
-      console.error('[飞书 Bridge] 加载绑定失败:', error)
+
+      this.chatBindings.set(binding.chatId, binding)
+      this.sessionToChat.set(binding.sessionId, binding.chatId)
+      this.preferredWorkspaceByChat.set(binding.chatId, binding.workspaceId)
+    }
+
+    if (this.chatBindings.size > 0) {
+      console.log(`[飞书 Bot ${this.botConfig.name}] 已恢复 ${this.chatBindings.size} 个聊天绑定`)
+      this.updateStatus({ activeBindings: this.chatBindings.size })
     }
   }
 
   /** 持久化聊天绑定到磁盘 */
   private saveBindings(): void {
-    try {
-      const bindings = Array.from(this.chatBindings.values())
-      const bindingsPath = getFeishuBindingsPath()
-      writeFileSync(bindingsPath, JSON.stringify(bindings, null, 2), 'utf-8')
-    } catch (error) {
-      console.error('[飞书 Bridge] 保存绑定失败:', error)
-    }
+    const bindings = Array.from(this.chatBindings.values()).map((binding) => ({
+      ...binding,
+      botId: this.botConfig.id,
+    }))
+    mergeFeishuBindingsForBot(this.botConfig.id, bindings)
   }
 
   // ===== 状态查询 =====
@@ -295,36 +344,101 @@ class FeishuBridge {
     return { ...this.status }
   }
 
+  getBotStatus(): FeishuBotStatus {
+    return {
+      botId: this.botConfig.id,
+      status: this.status.status,
+      connectedAt: this.status.connectedAt,
+      errorMessage: this.status.errorMessage,
+      activeBindings: this.status.activeBindings,
+    }
+  }
+
   listBindings(): FeishuChatBinding[] {
     return Array.from(this.chatBindings.values())
   }
 
+  private isSessionStillBound(sessionId: string, exceptChatId?: string): boolean {
+    for (const binding of this.chatBindings.values()) {
+      if (exceptChatId && binding.chatId === exceptChatId) continue
+      if (binding.sessionId === sessionId) return true
+    }
+    return false
+  }
+
   /** 更新绑定的工作区/会话（从设置页调用） */
   updateBinding(input: FeishuUpdateBindingInput): FeishuChatBinding | null {
     const binding = this.chatBindings.get(input.chatId)
     if (!binding) return null
 
+    const nextSession = input.sessionId !== undefined
+      ? getAgentSessionMeta(input.sessionId)
+      : undefined
+    if (input.sessionId !== undefined && !nextSession) {
+      return null
+    }
+
     if (input.workspaceId !== undefined) {
       binding.workspaceId = input.workspaceId
+      this.preferredWorkspaceByChat.set(input.chatId, input.workspaceId)
     }
     if (input.sessionId !== undefined) {
+      const ensuredSession = nextSession!
+
       // 清理旧反向索引，建立新的
+      const previousSessionId = binding.sessionId
       this.sessionToChat.delete(binding.sessionId)
       binding.sessionId = input.sessionId
       this.sessionToChat.set(input.sessionId, input.chatId)
+
+      // 切换绑定会话时同步工作区，并更新订阅
+      if (ensuredSession.workspaceId) {
+        binding.workspaceId = ensuredSession.workspaceId
+        this.preferredWorkspaceByChat.set(input.chatId, ensuredSession.workspaceId)
+      }
+      this.subscribeToSession(binding.sessionId)
+      if (!this.isSessionStillBound(previousSessionId)) {
+        this.unsubscribeFromSession(previousSessionId)
+      }
     }
 
     this.saveBindings()
     return { ...binding }
   }
 
+  /**
+   * 更新所有绑定的工作区 ID
+   *
+   * 当 Bot 配置中的 workspaceId 发生变化时调用，
+   * 确保所有内存中的 binding 都使用新的 workspaceId。
+   */
+  updateAllBindingsWorkspaceId(newWorkspaceId: string): void {
+    let changed = false
+    for (const binding of this.chatBindings.values()) {
+      if (binding.workspaceId !== newWorkspaceId) {
+        binding.workspaceId = newWorkspaceId
+        this.preferredWorkspaceByChat.set(binding.chatId, newWorkspaceId)
+        changed = true
+      }
+    }
+    if (changed) {
+      this.saveBindings()
+    }
+  }
+
   /** 移除绑定（从设置页调用） */
   removeBinding(chatId: string): boolean {
     const binding = this.chatBindings.get(chatId)
     if (!binding) return false
 
-    this.sessionToChat.delete(binding.sessionId)
+    const sessionId = binding.sessionId
+    this.sessionToChat.delete(sessionId)
     this.chatBindings.delete(chatId)
+    this.preferredWorkspaceByChat.delete(chatId)
+    if (!this.isSessionStillBound(sessionId)) {
+      this.unsubscribeFromSession(sessionId)
+      this.sessionBuffers.delete(sessionId)
+    }
     this.updateStatus({ activeBindings: this.chatBindings.size })
     this.saveBindings()
     return true
@@ -375,11 +489,6 @@ class FeishuBridge {
 
   // ===== 飞书图片处理 =====
 
-  /**
-   * 从飞书下载图片
-   *
-   * 使用 im.messageResource.get API 获取消息中的图片资源。
-   */
   private async downloadFeishuImage(messageId: string, imageKey: string): Promise<Buffer> {
     if (!this.client) throw new Error('飞书 Client 未初始化')
 
@@ -388,7 +497,6 @@ class FeishuBridge {
       params: { type: 'image' },
     })
 
-    // Lark SDK 返回 { writeFile, getReadableStream, headers } 对象
     const stream = resp.getReadableStream()
     const chunks: Buffer[] = []
     for await (const chunk of stream) {
@@ -397,9 +505,6 @@ class FeishuBridge {
     return Buffer.concat(chunks)
   }
 
-  /**
-   * 下载飞书消息中的文件资源
-   */
   private async downloadFeishuFile(messageId: string, fileKey: string): Promise<Buffer> {
     if (!this.client) throw new Error('飞书 Client 未初始化')
 
@@ -416,9 +521,6 @@ class FeishuBridge {
     return Buffer.concat(chunks)
   }
 
-  /**
-   * 保存文件到 Agent session 工作目录
-   */
   private saveFileToSession(
     workspaceSlug: string,
     sessionId: string,
@@ -426,28 +528,32 @@ class FeishuBridge {
     data: Buffer,
   ): string {
     const sessionDir = getAgentSessionWorkspacePath(workspaceSlug, sessionId)
-    const targetPath = join(sessionDir, fileName)
+    const safeFileName = this.sanitizeFileName(fileName, 'feishu-file')
+    const targetPath = join(sessionDir, safeFileName)
 
     mkdirSync(sessionDir, { recursive: true })
     writeFileSync(targetPath, data)
-    console.log(`[飞书 Bridge] 文件已保存: ${targetPath} (${data.length} bytes)`)
+    console.log(`[飞书 Bot ${this.botConfig.name}] 文件已保存: ${targetPath} (${data.length} bytes)`)
 
     return targetPath
   }
 
-  /**
-   * 通过 magic bytes 推断图片 MIME 类型
-   */
+  private sanitizeFileName(fileName: string, fallback: string): string {
+    const base = basename(fileName || '').trim()
+    const cleaned = base
+      .replace(/[\u0000-\u001f\u007f]/g, '')
+      .replace(/[\\/:"*?<>|]/g, '-')
+      .replace(/\s+/g, ' ')
+      .trim()
+    return cleaned || fallback
+  }
+
   private inferImageMediaType(buffer: Buffer): string {
     if (buffer.length < 4) return 'image/jpeg'
 
-    // JPEG: FF D8 FF
     if (buffer[0] === 0xFF && buffer[1] === 0xD8 && buffer[2] === 0xFF) return 'image/jpeg'
-    // PNG: 89 50 4E 47
     if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4E && buffer[3] === 0x47) return 'image/png'
-    // GIF: 47 49 46 38
     if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x38) return 'image/gif'
-    // WebP: 52 49 46 46 ... 57 45 42 50
     if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46 &&
         buffer.length >= 12 && buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50) {
       return 'image/webp'
@@ -456,11 +562,6 @@ class FeishuBridge {
     return 'image/jpeg'
   }
 
-  /**
-   * 保存图片到 Agent session 工作目录
-   *
-   * @returns 图片文件的绝对路径
-   */
   private saveImageToSession(
     workspaceSlug: string,
     sessionId: string,
@@ -475,7 +576,7 @@ class FeishuBridge {
 
     mkdirSync(sessionDir, { recursive: true })
     writeFileSync(targetPath, data)
-    console.log(`[飞书 Bridge] 图片已保存: ${targetPath} (${data.length} bytes)`)
+    console.log(`[飞书 Bot ${this.botConfig.name}] 图片已保存: ${targetPath} (${data.length} bytes)`)
 
     return targetPath
   }
@@ -483,12 +584,17 @@ class FeishuBridge {
   // ===== 飞书消息处理 =====
 
   private async handleFeishuMessage(data: Record<string, unknown>): Promise<void> {
-    if (!this.client) return
+    console.log(`[飞书 Bot ${this.botConfig.name}] 收到消息事件`)
+    
+    if (!this.client) {
+      console.warn(`[飞书 Bot ${this.botConfig.name}] 返回: client 未初始化`)
+      return
+    }
 
     // 事件级去重（飞书网关超时重投时 event_id 相同）
     const eventId = data.event_id as string | undefined
     if (eventId && this.recentEventIds.has(eventId)) {
-      console.log('[飞书 Bridge] 跳过重复事件 (event_id):', eventId)
+      console.log(`[飞书 Bot ${this.botConfig.name}] 返回: 跳过重复事件 (event_id): ${eventId}`)
       return
     }
     if (eventId) {
@@ -497,20 +603,25 @@ class FeishuBridge {
 
     // 解析消息
     const message = (data as { message?: Record<string, unknown> }).message
-    if (!message) return
+    if (!message) {
+      console.log(`[飞书 Bot ${this.botConfig.name}] 返回: 消息体为空`)
+      return
+    }
 
     const sender = (data as { sender?: Record<string, unknown> }).sender
 
-    // 过滤非用户消息（Bot 自己发的消息 sender_type 不是 "user"）
+    // 过滤非用户消息
     const senderType = (sender?.sender_type as string) ?? ''
+    console.log(`[飞书 Bot ${this.botConfig.name}] 发送者类型: ${senderType}`)
     if (senderType !== 'user') {
+      console.log(`[飞书 Bot ${this.botConfig.name}] 返回: 跳过非用户消息, senderType=${senderType}`)
       return
     }
 
-    // 消息级去重（同一条消息被不同 event 包裹时 message_id 相同）
+    // 消息级去重
     const messageId = message.message_id as string
     if (messageId && this.recentMessageIds.has(messageId)) {
-      console.log('[飞书 Bridge] 跳过重复消息 (message_id):', messageId)
+      console.log(`[飞书 Bot ${this.botConfig.name}] 返回: 跳过重复消息 (message_id): ${messageId}`)
       return
     }
     if (messageId) {
@@ -523,22 +634,29 @@ class FeishuBridge {
     const userId = (sender?.sender_id as Record<string, unknown>)?.open_id as string ?? 'unknown'
     const mentions = message.mentions as FeishuMention[] | undefined
 
-    // chatId 级处理锁：同一聊天同时只处理一条消息，防止 bot 回复被重入处理
+    // chatId 级处理锁
     if (this.processingChats.has(chatId)) {
-      console.log('[飞书 Bridge] 跳过重入消息 (chatId lock):', chatId)
+      console.log(`[飞书 Bot ${this.botConfig.name}] 返回: 跳过重入消息 (chatId lock): ${chatId}`)
       return
     }
 
     // 群聊中仅处理 @Bot 的消息
+    console.log(`[飞书 Bot ${this.botConfig.name}] 聊天类型: ${chatType}, mentions:`, JSON.stringify(mentions))
     if (chatType === 'group') {
-      if (!(await this.isBotMentioned(mentions))) {
+      const isMentioned = await this.isBotMentioned(mentions)
+      console.log(`[飞书 Bot ${this.botConfig.name}] 是否被@: ${isMentioned}`)
+      if (!isMentioned) {
+        console.log(`[飞书 Bot ${this.botConfig.name}] 返回: 群聊中未被@`)
         return
       }
     }
 
-    // 记录群聊最近用户消息 ID（用于 thread reply）
-    if (chatType === 'group' && messageId) {
+    // 记录最近用户消息 ID（用于 thread reply 和表情添加）
+    if (messageId) {
       this.lastUserMessageId.set(chatId, messageId)
+      console.log(`[飞书 Bot ${this.botConfig.name}] ⭐ 已记录消息 ID: chatId=${chatId}, messageId=${messageId}`)
+    } else {
+      console.warn(`[飞书 Bot ${this.botConfig.name}] ⭐ 消息 ID 为空，无法记录`)
     }
 
     // 记录最近交互的 chatId 作为默认通知目标
@@ -547,7 +665,7 @@ class FeishuBridge {
     // 仅处理文本、图片、富文本和文件消息
     const supportedTypes = new Set(['text', 'image', 'post', 'file'])
     if (!supportedTypes.has(messageType)) {
-      console.log(`[飞书 Bridge] 不支持的消息类型: ${messageType}`)
+      console.log(`[飞书 Bot ${this.botConfig.name}] 返回: 不支持的消息类型: ${messageType}`)
       await this.sendTextMessage(chatId, '目前仅支持文本、图片和文件消息。')
       return
     }
@@ -560,10 +678,8 @@ class FeishuBridge {
     if (messageType === 'text') {
       const content = JSON.parse(message.content as string) as { text?: string }
       text = content.text?.trim() ?? ''
-      // 去除 @Bot 的占位符（如 @_user_1）
       text = text.replace(/@_user_\d+/g, '').trim()
     } else if (messageType === 'post') {
-      // 富文本消息：提取文本和图片
       const content = JSON.parse(message.content as string) as {
         title?: string
         content?: Array<Array<{ tag: string; text?: string; image_key?: string }>>
@@ -580,7 +696,7 @@ class FeishuBridge {
               const mediaType = this.inferImageMediaType(imageData)
               imageAttachments.push({ imageKey: node.image_key, data: imageData, mediaType })
             } catch (error) {
-              console.error('[飞书 Bridge] 下载富文本图片失败:', error)
+              console.error(`[飞书 Bot ${this.botConfig.name}] 下载富文本图片失败:`, error)
             }
           }
         }
@@ -593,11 +709,11 @@ class FeishuBridge {
           const imageData = await this.downloadFeishuImage(messageId, content.image_key)
           const mediaType = this.inferImageMediaType(imageData)
           if (imageData.length > 10 * 1024 * 1024) {
-            console.warn(`[飞书 Bridge] 图片较大: ${(imageData.length / 1024 / 1024).toFixed(1)}MB`)
+            console.warn(`[飞书 Bot ${this.botConfig.name}] 图片较大: ${(imageData.length / 1024 / 1024).toFixed(1)}MB`)
           }
           imageAttachments.push({ imageKey: content.image_key, data: imageData, mediaType })
         } catch (error) {
-          console.error('[飞书 Bridge] 下载图片失败:', error)
+          console.error(`[飞书 Bot ${this.botConfig.name}] 下载图片失败:`, error)
           await this.sendCardMessage(chatId, buildErrorCard('图片下载失败，请重试。'))
           return
         }
@@ -614,7 +730,7 @@ class FeishuBridge {
           }
           fileAttachments.push({ fileKey: content.file_key, fileName, data: fileData })
         } catch (error) {
-          console.error('[飞书 Bridge] 下载文件失败:', error)
+          console.error(`[飞书 Bot ${this.botConfig.name}] 下载文件失败:`, error)
           await this.sendCardMessage(chatId, buildErrorCard('文件下载失败，请重试。'))
           return
         }
@@ -679,19 +795,22 @@ class FeishuBridge {
       groupName,
     }
 
-    // 加锁：防止命令回复触发的事件被重入处理
+    // 加锁
     this.processingChats.add(chatId)
+    console.log(`[飞书 Bot ${this.botConfig.name}] 开始处理消息: chatId=${chatId}, text=${text?.slice(0, 50)}`)
     try {
       // 命令路由
       if (text.startsWith('/')) {
+        console.log(`[飞书 Bot ${this.botConfig.name}] 处理命令: ${text}`)
         await this.handleCommand(msgCtx, text)
         return
       }
 
-      // 普通消息（文本/图片/文件）→ 转发到会话
+      // 普通消息
       await this.handleUserMessage(msgCtx, text, imageAttachments, fileAttachments)
     } finally {
       this.processingChats.delete(chatId)
+      console.log(`[飞书 Bot ${this.botConfig.name}] 消息处理完成`)
     }
   }
 
@@ -757,11 +876,15 @@ class FeishuBridge {
     overrideWorkspaceId?: string,
   ): Promise<void> {
     const { chatId } = msgCtx
-    const config = getFeishuConfig()
     const appSettings = getSettings()
 
-    // 选择工作区：显式指定 > 飞书配置 > 应用设置 > 第一个工作区
-    let workspaceId = overrideWorkspaceId ?? config.defaultWorkspaceId ?? appSettings.agentWorkspaceId
+    // 选择工作区：显式指定 > 当前聊天已选工作区 > Bot 默认工作区 > 应用设置 > 第一个工作区
+    let workspaceId = overrideWorkspaceId
+      ?? this.preferredWorkspaceByChat.get(chatId)
+      ?? (this.botConfig.workspaceId || appSettings.agentWorkspaceId)
+    if (workspaceId && !getAgentWorkspace(workspaceId)) {
+      workspaceId = undefined
+    }
     if (!workspaceId) {
       const workspaces = await listAgentWorkspaces()
       workspaceId = workspaces[0]?.id
@@ -779,15 +902,16 @@ class FeishuBridge {
       return
     }
 
-    // 创建会话（使用默认标题，首次对话完成后会自动生成标题）
+    // 创建会话
     const session = await createAgentSession(
       title,
       channelId,
       workspaceId,
     )
 
-    // 绑定
+    // 绑定（botId 与 channelId 语义分离）
     const binding: FeishuChatBinding = {
+      botId: this.botConfig.id,
       chatId,
       userId: msgCtx.senderOpenId,
       sessionId: session.id,
@@ -800,11 +924,12 @@ class FeishuBridge {
       createdAt: Date.now(),
     }
     this.chatBindings.set(chatId, binding)
+    this.preferredWorkspaceByChat.set(chatId, workspaceId)
     this.sessionToChat.set(session.id, chatId)
     this.updateStatus({ activeBindings: this.chatBindings.size })
     this.saveBindings()
 
-    // 通知渲染进程刷新会话列表（复用 TITLE_UPDATED 通道触发列表刷新）
+    // 通知渲染进程刷新会话列表
     const windows = BrowserWindow.getAllWindows()
     if (windows.length > 0 && !windows[0]!.isDestroyed()) {
       windows[0]!.webContents.send(AGENT_IPC_CHANNELS.TITLE_UPDATED, {
@@ -812,9 +937,6 @@ class FeishuBridge {
         title: session.title,
       })
     }
-
-    const modeLabel = mode === 'agent' ? 'Agent' : 'Chat'
-    await this.sendMessage(chatId, `✅ 已创建 ${modeLabel} 会话 (${session.id.slice(0, 8)})`)
   }
 
   private async updateBindingMode(msgCtx: FeishuMessageContext, mode: 'agent' | 'chat'): Promise<void> {
@@ -822,6 +944,7 @@ class FeishuBridge {
     const binding = this.chatBindings.get(chatId)
     if (binding) {
       binding.mode = mode
+      this.saveBindings()
       const modeLabel = mode === 'agent' ? 'Agent' : 'Chat'
       await this.sendMessage(chatId, `已切换到 ${modeLabel} 模式`)
     } else {
@@ -837,14 +960,11 @@ class FeishuBridge {
     const binding = this.chatBindings.get(chatId)
     const currentWorkspaceId = binding?.workspaceId
 
-    // 每个工作区最多展示最近 5 个会话
     const MAX_SESSIONS_PER_WS = 5
 
-    // 为所有会话建立全局序号映射（序号 = 全局排序位置，从 1 开始）
     const sessionIndexMap = new Map<string, number>()
     sessions.forEach((s, i) => sessionIndexMap.set(s.id, i + 1))
 
-    // 按工作区分组
     const wsItems: WorkspaceListItem[] = workspaces.map((ws) => {
       const wsSessions = sessions
         .filter((s) => s.workspaceId === ws.id)
@@ -859,7 +979,6 @@ class FeishuBridge {
       return { id: ws.id, name: ws.name, sessions: wsSessions }
     })
 
-    // 未归属工作区的会话
     const orphanSessions = sessions
       .filter((s) => !s.workspaceId || !workspaces.some((w) => w.id === s.workspaceId))
       .slice(0, MAX_SESSIONS_PER_WS)
@@ -893,7 +1012,6 @@ class FeishuBridge {
     const { chatId } = msgCtx
     const sessions = listAgentSessions()
 
-    // 支持序号（如 /switch 1）和 ID 前缀两种方式
     const index = Number(arg)
     const match = Number.isInteger(index) && index >= 1 && index <= sessions.length
       ? sessions[index - 1]
@@ -904,19 +1022,24 @@ class FeishuBridge {
       return
     }
 
-    // 清理旧绑定的反向索引
     const oldBinding = this.chatBindings.get(chatId)
     if (oldBinding) {
+      if (oldBinding.sessionId !== match.id) {
+        stopAgent(oldBinding.sessionId)
+      }
       this.sessionToChat.delete(oldBinding.sessionId)
+      if (!this.isSessionStillBound(oldBinding.sessionId, chatId)) {
+        this.unsubscribeFromSession(oldBinding.sessionId)
+      }
     }
 
     const appSettings = getSettings()
-    const config = getFeishuConfig()
     const binding: FeishuChatBinding = {
+      botId: this.botConfig.id,
       chatId,
       userId: msgCtx.senderOpenId,
       sessionId: match.id,
-      workspaceId: match.workspaceId ?? config.defaultWorkspaceId ?? appSettings.agentWorkspaceId ?? '',
+      workspaceId: match.workspaceId ?? this.botConfig.workspaceId ?? appSettings.agentWorkspaceId ?? '',
       channelId: match.channelId ?? appSettings.agentChannelId ?? '',
       modelId: appSettings.agentModelId ?? undefined,
       mode: 'agent',
@@ -925,7 +1048,9 @@ class FeishuBridge {
       createdAt: Date.now(),
     }
     this.chatBindings.set(chatId, binding)
+    this.preferredWorkspaceByChat.set(chatId, binding.workspaceId)
     this.sessionToChat.set(match.id, chatId)
+    this.subscribeToSession(match.id)
     this.updateStatus({ activeBindings: this.chatBindings.size })
     this.saveBindings()
 
@@ -936,9 +1061,8 @@ class FeishuBridge {
     const { chatId } = msgCtx
     const workspaces = listAgentWorkspaces()
     const binding = this.chatBindings.get(chatId)
-    const currentWorkspaceId = binding?.workspaceId
+    const currentWorkspaceId = binding?.workspaceId ?? this.preferredWorkspaceByChat.get(chatId)
 
-    // 无参数 → 列出所有工作区供选择
     if (!arg) {
       const items = workspaces.map((w, i) => ({
         index: i + 1,
@@ -949,7 +1073,6 @@ class FeishuBridge {
       return
     }
 
-    // 支持序号（如 /workspace 1）和名称两种方式
     const index = Number(arg)
     const match = Number.isInteger(index) && index >= 1 && index <= workspaces.length
       ? workspaces[index - 1]
@@ -963,30 +1086,34 @@ class FeishuBridge {
       return
     }
 
-    // 清理旧绑定（切换工作区后需要用户选择或新建会话）
+    this.preferredWorkspaceByChat.set(chatId, match.id)
+
     if (binding) {
-      this.sessionToChat.delete(binding.sessionId)
+      const previousSessionId = binding.sessionId
+      stopAgent(previousSessionId)
+      this.sessionToChat.delete(previousSessionId)
       this.chatBindings.delete(chatId)
+      this.sessionBuffers.delete(previousSessionId)
+      if (!this.isSessionStillBound(previousSessionId)) {
+        this.unsubscribeFromSession(previousSessionId)
+      }
       this.updateStatus({ activeBindings: this.chatBindings.size })
       this.saveBindings()
     }
 
-    // 更新飞书配置的默认工作区（下次自动创建会话时使用）
-    const { updateFeishuConfigPartial } = await import('./feishu-config')
-    updateFeishuConfigPartial({ defaultWorkspaceId: match.id })
-
-    // 列出该工作区下最近 10 条会话（序号为全局排序位置）
-    const sessions = listAgentSessions()
-    const recentSessions = sessions
+    const allSessions = listAgentSessions()
+    const sessionIndexMap = new Map<string, number>()
+    allSessions.forEach((s, i) => sessionIndexMap.set(s.id, i + 1))
+    const workspaceSessions = allSessions
       .filter((s) => s.workspaceId === match.id)
-      .slice(0, 10)
+      .slice(0, 5)
       .map((s) => ({
         id: s.id,
         title: s.title,
-        index: sessions.indexOf(s) + 1,
+        index: sessionIndexMap.get(s.id) ?? 0,
       }))
 
-    await this.sendCardMessage(chatId, buildWorkspaceSwitchedCard(match.name, recentSessions))
+    await this.sendCardMessage(chatId, buildWorkspaceSwitchedCard(match.name, workspaceSessions))
   }
 
   private async handleNowCommand(msgCtx: FeishuMessageContext): Promise<void> {
@@ -995,7 +1122,6 @@ class FeishuBridge {
 
     const lines: string[] = []
 
-    // 会话信息
     if (binding) {
       const session = getAgentSessionMeta(binding.sessionId)
       lines.push(`**会话**: ${session?.title ?? '未知'} (\`${binding.sessionId.slice(0, 8)}\`)`)
@@ -1004,13 +1130,11 @@ class FeishuBridge {
       lines.push('**会话**: 未绑定（发送消息将自动创建）')
     }
 
-    // 工作区信息
-    const workspaceId = binding?.workspaceId
+    const workspaceId = binding?.workspaceId ?? this.preferredWorkspaceByChat.get(chatId)
     const workspace = workspaceId ? getAgentWorkspace(workspaceId) : undefined
     if (workspace) {
       lines.push(`**工作区**: ${workspace.name} (\`${workspace.slug}\`)`)
 
-      // MCP Servers
       const capabilities = getWorkspaceCapabilities(workspace.slug)
       if (capabilities.mcpServers.length > 0) {
         lines.push('')
@@ -1023,7 +1147,6 @@ class FeishuBridge {
         lines.push('**MCP Servers**: 无')
       }
 
-      // Skills
       if (capabilities.skills.length > 0) {
         lines.push('')
         lines.push('**Skills**:')
@@ -1035,9 +1158,7 @@ class FeishuBridge {
         lines.push('**Skills**: 无')
       }
 
-      // 工作区文件列表
-      const { getAgentWorkspacePath: getWsPath } = await import('./config-paths')
-      const wsPath = getWsPath(workspace.slug)
+      const wsPath = getAgentSessionWorkspacePath(workspace.slug, '')
       try {
         const entries = readdirSync(wsPath, { withFileTypes: true })
         const fileList = entries
@@ -1054,7 +1175,7 @@ class FeishuBridge {
           }
         }
       } catch {
-        // 目录不存在或无法读取，忽略
+        // ignore
       }
     } else {
       lines.push('**工作区**: 未设置')
@@ -1084,14 +1205,12 @@ class FeishuBridge {
     const { chatId } = msgCtx
     let binding = this.chatBindings.get(chatId)
 
-    // 自动创建会话
     if (!binding) {
       await this.createNewSession(msgCtx, 'agent')
       binding = this.chatBindings.get(chatId)
       if (!binding) return
     }
 
-    // 保存飞书图片和文件到 session 工作目录，构建文件引用
     const attachedRefs: string[] = []
     const workspace = binding.workspaceId ? getAgentWorkspace(binding.workspaceId) : undefined
     if (workspace) {
@@ -1112,24 +1231,26 @@ class FeishuBridge {
       ? `<attached_files>\n${attachedRefs.join('\n')}\n</attached_files>\n\n`
       : ''
 
-    // 初始化缓冲
     this.sessionBuffers.set(binding.sessionId, {
       text: '',
       toolSummaries: new Map(),
       startedAt: Date.now(),
     })
 
-    // 发送思考中指示
-    const prefix = this.resolveContextPrefix(chatId)
-    await this.sendMessage(chatId, `${prefix}⏳ Agent 处理中...`)
+    // 订阅该 session 的事件（精准订阅，避免跨 Bot 通知）
+    this.subscribeToSession(binding.sessionId)
+
+    // 获取用户消息 ID，添加 ⏳ 表情表示处理中
+    const userMsgId = this.lastUserMessageId.get(chatId)
+    if (userMsgId) {
+      await this.addReaction(chatId, userMsgId, SingleBotBridge.REACTION_PROCESSING)
+    }
 
     if (binding.mode === 'agent') {
-      // 构建消息：附件引用 + 文本
       const hasAnyAttachment = imageAttachments.length > 0 || fileAttachments.length > 0
       const userText = text || (hasAnyAttachment ? '请查看上面附加的文件。' : '')
       let agentMessage = fileReferences + userText
 
-      // 群聊时注入发送者、群组上下文以及聊天历史到消息
       if (msgCtx.chatType === 'group') {
         const contextParts: string[] = []
         if (msgCtx.groupName) {
@@ -1139,7 +1260,6 @@ class FeishuBridge {
           contextParts.push(`[发送者: ${msgCtx.senderName}]`)
         }
 
-        // 注入群成员列表（方便 Agent @某人）
         const groupInfo = this.groupInfoCache.get(chatId)
         if (groupInfo?.members && groupInfo.members.length > 0) {
           const membersExceptBot = groupInfo.members
@@ -1151,7 +1271,6 @@ class FeishuBridge {
           contextParts.push('[提示: 如需 @某人，请直接使用 @姓名 格式，如 @Alice，系统会自动转换为飞书 @mention]')
         }
 
-        // 获取群聊历史消息作为上下文
         const chatHistory = await this.fetchChatHistory(chatId)
         const historyContext = this.formatChatHistoryContext(chatHistory)
 
@@ -1163,8 +1282,6 @@ class FeishuBridge {
         agentMessage = parts.join('\n')
       }
 
-      // Agent 模式 — fire-and-forget，不阻塞事件回调
-      // 群聊时注入动态 MCP 工具（允许 Agent 主动拉取更多群聊历史）
       let customMcpServers: Record<string, Record<string, unknown>> | undefined
       if (msgCtx.chatType === 'group') {
         const mcpServer = await this.createFeishuChatMcpServer(chatId)
@@ -1173,10 +1290,15 @@ class FeishuBridge {
         }
       }
 
-      // 使用最新的渠道和模型设置（用户可能在运行中更改）
       const latestSettings = getSettings()
-      const channelId = latestSettings.agentChannelId || binding.channelId
+      const sessionMeta = getAgentSessionMeta(binding.sessionId)
+      const channelId = latestSettings.agentChannelId || binding.channelId || sessionMeta?.channelId
       const modelId = latestSettings.agentModelId || binding.modelId
+      if (!channelId) {
+        await this.sendCardMessage(chatId, buildErrorCard('未配置可用渠道，请先在 Proma Agent 设置中选择渠道。'))
+        await this.cleanupSession(binding.sessionId, chatId, true)
+        return
+      }
 
       const input: AgentSendInput = {
         sessionId: binding.sessionId,
@@ -1186,35 +1308,113 @@ class FeishuBridge {
         workspaceId: binding.workspaceId,
         permissionModeOverride: 'auto',
         ...(customMcpServers && { customMcpServers }),
+        messageMetadata: {
+          source: 'feishu',
+          chatId,
+          senderOpenId: msgCtx.senderOpenId,
+          senderName: msgCtx.senderName,
+          messageId: msgCtx.messageId,
+          chatType: msgCtx.chatType,
+          groupName: msgCtx.groupName,
+          botId: this.botConfig.id,
+        },
       }
 
-      runAgentHeadless(input, {
-        onError: (error) => {
-          const errPrefix = this.resolveContextPrefix(chatId)
-          this.sendCardMessage(chatId, buildErrorCard(`${errPrefix}${error}`)).catch(console.error)
-          this.sessionBuffers.delete(binding!.sessionId)
-        },
-        onComplete: () => {
-          // complete 事件由 EventBus listener 处理
-        },
-        onTitleUpdated: (_title) => {
-          // 标题更新可选通知
-        },
-      }).catch((error) => {
-        console.error('[飞书 Bridge] Agent 运行异常:', error)
-      })
+      // 使用 try-finally 确保无论成功或失败，表情都会被移除
+      console.log(`[飞书 Bot ${this.botConfig.name}] 启动 Agent: sessionId=${binding.sessionId}`)
+      try {
+        await runAgentHeadless(input, {
+          // 注意：所有资源清理（buffer、订阅、表情）统一在 handleAgentEvent 中处理
+          // 这里的回调仅用于发送通知，不处理资源清理
+          onError: (error) => {
+            console.error(`[飞书 Bot ${this.botConfig.name}] Agent 错误:`, error)
+            // 错误卡片由 handleAgentEvent 统一发送，避免重复
+          },
+          onComplete: () => {
+            console.log(`[飞书 Bot ${this.botConfig.name}] Agent 完成`)
+            // complete 事件由 EventBus listener 处理
+          },
+          onTitleUpdated: (title) => {
+            console.log(`[飞书 Bot ${this.botConfig.name}] 标题更新: ${title}`)
+            // 标题更新可选通知
+          },
+        })
+        console.log(`[飞书 Bot ${this.botConfig.name}] Agent 运行结束`)
+      } catch (error) {
+        console.error(`[飞书 Bot ${this.botConfig.name}] Agent 运行异常:`, error)
+        // 异常时确保清理资源（表情、buffer、订阅）
+        await this.cleanupSession(binding.sessionId, chatId, true)
+      }
     } else {
-      // Chat 模式 — TODO: Phase 4 实现
       await this.sendMessage(chatId, 'Chat 模式暂未实现，请使用 /agent 切换到 Agent 模式。')
-      this.sessionBuffers.delete(binding.sessionId)
+      await this.cleanupSession(binding.sessionId, chatId, false)
     }
   }
 
   // ===== EventBus 事件处理 =====
 
+  /**
+   * 订阅指定 session 的事件（精准订阅，避免跨 Bot 通知问题）
+   */
+  private subscribeToSession(sessionId: string): void {
+    if (this.sessionUnsubscribes.has(sessionId)) return
+
+    const unsubscribe = agentEventBus.onForSession(sessionId, (sId, event) => {
+      this.handleAgentEvent(sId, event)
+    })
+    this.sessionUnsubscribes.set(sessionId, unsubscribe)
+  }
+
+  /**
+   * 取消订阅指定 session 的事件
+   */
+  private unsubscribeFromSession(sessionId: string): void {
+    const unsub = this.sessionUnsubscribes.get(sessionId)
+    if (unsub) {
+      unsub()
+      this.sessionUnsubscribes.delete(sessionId)
+    }
+  }
+
+  /**
+   * 统一清理会话资源
+   *
+   * 无论会话成功完成还是出错，都需要清理：
+   * 1. 移除飞书"处理中"表情
+   * 2. 清理 session buffer
+   * 3. 取消 EventBus 订阅
+   *
+   * @param sessionId 会话 ID
+   * @param chatId 飞书聊天 ID（用于移除表情）
+   * @param isError 是否为错误状态（影响日志输出）
+   */
+  private async cleanupSession(
+    sessionId: string,
+    chatId: string | undefined,
+    isError: boolean,
+  ): Promise<void> {
+    // 1. 移除表情（如果存在）
+    if (chatId) {
+      try {
+        await this.removeReaction(chatId)
+      } catch (error) {
+        // 表情移除失败不影响主流程
+        console.warn(`[飞书 Bot ${this.botConfig.name}] 移除表情失败:`, error)
+      }
+    }
+
+    // 2. 清理 buffer
+    this.sessionBuffers.delete(sessionId)
+
+    // 3. 取消订阅
+    this.unsubscribeFromSession(sessionId)
+
+    if (isError) {
+      console.log(`[飞书 Bot ${this.botConfig.name}] 会话 ${sessionId.slice(0, 8)} 错误，资源已清理`)
+    }
+  }
+
   private handleAgentEvent(sessionId: string, event: AgentEvent): void {
-    // 对于飞书发起的会话，缓冲由 handleUserMessage 初始化
-    // 对于桌面发起的会话，complete 事件时检查是否需要通知
     const buffer = this.sessionBuffers.get(sessionId)
 
     if (buffer) {
@@ -1233,17 +1433,18 @@ class FeishuBridge {
         this.handleDesktopSessionComplete(sessionId)
       }
     } else if (event.type === 'error') {
+      // 错误事件：获取 chatId 并发送错误卡片
       const chatId = this.sessionToChat.get(sessionId)
       if (chatId) {
         const prefix = this.resolveContextPrefix(chatId)
         this.sendCardMessage(chatId, buildErrorCard(`${prefix}${event.message}`)).catch(console.error)
       }
-      this.sessionBuffers.delete(sessionId)
+      // 统一清理资源（包括移除表情）
+      this.cleanupSession(sessionId, chatId, true).catch(console.error)
     }
   }
 
-  /** 飞书发起的会话完成：发送完整回复到飞书 */
-  private handleFeishuSessionComplete(sessionId: string): void {
+  private async handleFeishuSessionComplete(sessionId: string): Promise<void> {
     const buffer = this.sessionBuffers.get(sessionId)
     if (!buffer) return
 
@@ -1257,46 +1458,40 @@ class FeishuBridge {
 
     const chatId = this.sessionToChat.get(sessionId)
     if (chatId) {
-      this.sendAgentReply(chatId, result).catch(console.error)
+      // 先发送回复
+      try {
+        await this.sendAgentReply(chatId, result)
+      } catch (error) {
+        console.error(`[飞书 Bot ${this.botConfig.name}] 发送回复失败:`, error)
+      }
     }
 
-    this.sessionBuffers.delete(sessionId)
+    // 统一清理资源（包括移除表情、清理 buffer、取消订阅）
+    await this.cleanupSession(sessionId, chatId, false)
   }
 
-  /**
-   * 桌面发起的会话完成：根据通知模式和在场状态决定是否发飞书通知
-   *
-   * - off → 不发
-   * - always → 发
-   * - auto → 用户不在场时才发
-   */
   private handleDesktopSessionComplete(sessionId: string): void {
     if (!this.client || !this.defaultNotifyChatId) return
 
-    const mode = this.sessionNotifyModes.get(sessionId) ?? 'auto'
+    const mode = this.sessionNotifyModes.get(sessionId) ?? getDefaultNotifyMode()
 
     if (mode === 'off') return
     if (mode === 'auto' && presenceService.isUserPresent(sessionId)) return
 
-    // 需要发通知 → 发送简短通知卡片
     this.sendDesktopNotification(sessionId).catch(console.error)
   }
 
-  /** 向飞书发送桌面会话完成通知，并通知渲染进程 */
   private async sendDesktopNotification(sessionId: string): Promise<void> {
     if (!this.defaultNotifyChatId) return
 
-    // 获取会话标题
     const sessions = await listAgentSessions()
     const session = sessions.find((s) => s.id === sessionId)
     const title = session?.title ?? '未命名会话'
     const preview = '任务已完成，请在 Proma 中查看详情。'
 
-    // 发送通知卡片到飞书
     const card = buildNotificationCard(title, preview, [], 0)
     await this.sendCard(this.defaultNotifyChatId, card)
 
-    // 通知渲染进程（用于 Sonner toast + 桌面通知）
     const payload: FeishuNotificationSentPayload = {
       sessionId,
       sessionTitle: title,
@@ -1316,7 +1511,6 @@ class FeishuBridge {
       return
     }
 
-    // 群聊时，将 @Name 转换为飞书 <at> 标签
     const binding = this.chatBindings.get(chatId)
     const processedResult: FormattedAgentResult = {
       ...result,
@@ -1328,10 +1522,8 @@ class FeishuBridge {
     const chunks = splitLongContent(processedResult.text)
 
     if (chunks.length === 1) {
-      // 单条卡片
       await this.sendCardMessage(chatId, buildAgentReplyCard(processedResult, subtitle))
     } else {
-      // 多条消息
       for (let i = 0; i < chunks.length; i++) {
         const chunkResult: FormattedAgentResult = {
           text: chunks[i]!,
@@ -1343,16 +1535,10 @@ class FeishuBridge {
     }
   }
 
-  /**
-   * 将 Agent 文本中的 @Name 转换为飞书卡片 markdown 的 <at id=open_id>Name</at> 格式
-   *
-   * 匹配规则：@Name 中的 Name 必须与群成员缓存中的某个成员名称完全匹配。
-   */
   private convertMentionsToAtTags(text: string, chatId: string): string {
     const groupInfo = this.groupInfoCache.get(chatId)
     if (!groupInfo?.members || groupInfo.members.length === 0) return text
 
-    // 构建 name → openId 映射（排除 Bot 自身）
     const nameToId = new Map<string, string>()
     for (const m of groupInfo.members) {
       if (m.openId !== this.botOpenId) {
@@ -1361,9 +1547,7 @@ class FeishuBridge {
     }
     if (nameToId.size === 0) return text
 
-    // 按名称长度降序排列，避免短名称先匹配导致长名称被截断
     const names = Array.from(nameToId.keys()).sort((a, b) => b.length - a.length)
-    // 构建正则：匹配 @Name（Name 为群成员名称）
     const escaped = names.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
     const pattern = new RegExp(`@(${escaped.join('|')})(?![\\w])`, 'g')
 
@@ -1375,10 +1559,9 @@ class FeishuBridge {
 
   // ===== 飞书 API =====
 
-  /** 向去重集合添加 ID，保持集合大小不超过上限 */
   private addToDedup(set: Set<string>, id: string): void {
     set.add(id)
-    if (set.size > FeishuBridge.DEDUP_MAX) {
+    if (set.size > SingleBotBridge.DEDUP_MAX) {
       const first = set.values().next().value as string
       set.delete(first)
     }
@@ -1386,11 +1569,6 @@ class FeishuBridge {
 
   // ===== 群聊辅助方法 =====
 
-  /**
-   * 从 mention.id 中提取 open_id
-   *
-   * 飞书事件中 mention.id 可能是字符串（如 "all"）或对象 { open_id, union_id, user_id }。
-   */
   private extractMentionOpenId(mention: FeishuMention): string | null {
     const { id } = mention
     if (typeof id === 'string') return id
@@ -1398,23 +1576,26 @@ class FeishuBridge {
     return null
   }
 
-  /**
-   * 检测消息的 mentions 列表中是否包含 @Bot
-   *
-   * 优先用 botOpenId 精确匹配；未获取时尝试重新获取。
-   * 飞书群聊 @所有人 时 mention.id 为 "all"，直接排除。
-   */
   private async isBotMentioned(mentions: FeishuMention[] | undefined): Promise<boolean> {
-    if (!mentions || mentions.length === 0) return false
+    console.log(`[飞书 Bot ${this.botConfig.name}] ⭐ isBotMentioned: mentions=${JSON.stringify(mentions)}, botOpenId=${this.botOpenId || '未获取'}`)
+    
+    if (!mentions || mentions.length === 0) {
+      console.log(`[飞书 Bot ${this.botConfig.name}] ⭐ 没有 mentions，返回 false`)
+      return false
+    }
 
-    // 提取所有 mention 的 open_id，排除 @所有人
     const mentionIds = mentions
       .map((m) => ({ name: m.name, openId: this.extractMentionOpenId(m) }))
       .filter((m) => m.openId && m.openId !== 'all')
-    if (mentionIds.length === 0) return false
+    console.log(`[飞书 Bot ${this.botConfig.name}] ⭐ 解析后的 mentionIds:`, JSON.stringify(mentionIds))
+    
+    if (mentionIds.length === 0) {
+      console.log(`[飞书 Bot ${this.botConfig.name}] ⭐ 没有有效的 mentionIds，返回 false`)
+      return false
+    }
 
-    // 如果 botOpenId 未获取，尝试重新获取
     if (!this.botOpenId && this.client) {
+      console.log(`[飞书 Bot ${this.botConfig.name}] ⭐ botOpenId 为空，尝试延迟获取`)
       try {
         const botInfoResp = await this.client.request<{
           bot?: { open_id?: string }
@@ -1425,32 +1606,26 @@ class FeishuBridge {
         })
         this.botOpenId = botInfoResp?.bot?.open_id ?? botInfoResp?.data?.bot?.open_id ?? null
         if (this.botOpenId) {
-          console.log(`[飞书 Bridge] 延迟获取 Bot open_id 成功: ${this.botOpenId}`)
+          console.log(`[飞书 Bot ${this.botConfig.name}] 延迟获取 Bot open_id 成功: ${this.botOpenId}`)
         }
       } catch (error) {
-        console.warn('[飞书 Bridge] 延迟获取 Bot info 失败:', error)
+        console.warn(`[飞书 Bot ${this.botConfig.name}] 延迟获取 Bot info 失败:`, error)
       }
     }
 
     if (this.botOpenId) {
       const matched = mentionIds.some((m) => m.openId === this.botOpenId)
-      if (!matched) {
-        console.log(`[飞书 Bridge] @Bot 未匹配 — botOpenId=${this.botOpenId}, mentions=[${mentionIds.map((m) => `${m.name}(${m.openId})`).join(', ')}]`)
-      }
+      console.log(`[飞书 Bot ${this.botConfig.name}] ⭐ 匹配结果: ${matched}, botOpenId=${this.botOpenId}, mentions=[${mentionIds.map(m => m.openId).join(', ')}]`)
       return matched
     }
-
-    // botOpenId 仍未获取：拒绝，避免 @其他人误触发
-    console.warn(`[飞书 Bridge] botOpenId 未获取，无法精确匹配，跳过消息（mentions: ${mentionIds.map((m) => `${m.name}(${m.openId})`).join(', ')}）`)
+    
+    console.warn(`[飞书 Bot ${this.botConfig.name}] ⭐ botOpenId 仍然为空，无法匹配`)
     return false
   }
 
-  /**
-   * 获取群聊信息（带缓存，TTL 1 小时）
-   */
   private async getGroupInfo(chatId: string): Promise<FeishuGroupInfo | null> {
     const cached = this.groupInfoCache.get(chatId)
-    if (cached && Date.now() - cached.cachedAt < FeishuBridge.GROUP_CACHE_TTL) {
+    if (cached && Date.now() - cached.cachedAt < SingleBotBridge.GROUP_CACHE_TTL) {
       return cached
     }
 
@@ -1467,21 +1642,17 @@ class FeishuBridge {
       const info: FeishuGroupInfo = { chatId, name, description, members, cachedAt: Date.now() }
       this.groupInfoCache.set(chatId, info)
 
-      // 同时填充 userNameCache
       for (const m of members) {
         this.userNameCache.set(m.openId, m.name)
       }
 
       return info
     } catch (error) {
-      console.warn('[飞书 Bridge] 获取群聊信息失败:', error)
+      console.warn(`[飞书 Bot ${this.botConfig.name}] 获取群聊信息失败:`, error)
       return null
     }
   }
 
-  /**
-   * 拉取群成员列表（最多 200 人，不含机器人）
-   */
   private async fetchGroupMembers(chatId: string): Promise<FeishuGroupMember[]> {
     if (!this.client) return []
 
@@ -1495,16 +1666,11 @@ class FeishuBridge {
         .filter((item) => item.member_id && item.name)
         .map((item) => ({ openId: item.member_id!, name: item.name! }))
     } catch (error) {
-      console.warn('[飞书 Bridge] 获取群成员列表失败:', error)
+      console.warn(`[飞书 Bot ${this.botConfig.name}] 获取群成员列表失败:`, error)
       return []
     }
   }
 
-  /**
-   * 获取用户显示名称（带缓存）
-   *
-   * 失败时回退返回 open_id 前 8 位。
-   */
   private async getUserName(openId: string): Promise<string> {
     const cached = this.userNameCache.get(openId)
     if (cached) return cached
@@ -1522,7 +1688,7 @@ class FeishuBridge {
         return name
       }
     } catch (error) {
-      console.warn('[飞书 Bridge] 获取用户信息失败:', error)
+      console.warn(`[飞书 Bot ${this.botConfig.name}] 获取用户信息失败:`, error)
     }
 
     return openId.slice(0, 8)
@@ -1530,15 +1696,8 @@ class FeishuBridge {
 
   // ===== 群聊消息历史 =====
 
-  /** 默认拉取的群聊历史消息数量 */
   private static readonly DEFAULT_HISTORY_COUNT = 20
 
-  /**
-   * 获取聊天历史消息
-   *
-   * 调用 `im/v1/messages` 接口，按时间倒序拉取指定数量的消息。
-   * 需要 `im:message.group_msg` 权限。
-   */
   private async fetchChatHistory(
     chatId: string,
     options?: {
@@ -1549,7 +1708,7 @@ class FeishuBridge {
     if (!this.client) return []
 
     try {
-      const pageSize = Math.min(options?.pageSize ?? FeishuBridge.DEFAULT_HISTORY_COUNT, 50)
+      const pageSize = Math.min(options?.pageSize ?? SingleBotBridge.DEFAULT_HISTORY_COUNT, 50)
       const endTime = options?.beforeTimestamp
         ? Math.floor(options.beforeTimestamp / 1000).toString()
         : undefined
@@ -1565,7 +1724,7 @@ class FeishuBridge {
       })
 
       if (resp.code !== 0) {
-        console.warn('[飞书 Bridge] 获取聊天历史失败:', resp.msg)
+        console.warn(`[飞书 Bot ${this.botConfig.name}] 获取聊天历史失败:`, resp.msg)
         return []
       }
 
@@ -1573,7 +1732,6 @@ class FeishuBridge {
       const messages: FeishuChatMessage[] = []
 
       for (const item of items) {
-        // 跳过已删除的消息
         if (item.deleted) continue
 
         const senderId = item.sender?.id ?? 'unknown'
@@ -1581,7 +1739,6 @@ class FeishuBridge {
         const msgType = item.msg_type ?? 'unknown'
         const createTime = Number(item.create_time ?? 0)
 
-        // 解析消息内容
         const content = this.parseChatMessageContent(msgType, item.body?.content)
 
         messages.push({
@@ -1594,22 +1751,16 @@ class FeishuBridge {
         })
       }
 
-      // 按时间正序返回（API 返回的是倒序）
       messages.reverse()
-
-      // 异步解析发送者名称（不阻塞返回）
       await this.resolveMessageSenderNames(messages)
 
       return messages
     } catch (error) {
-      console.warn('[飞书 Bridge] 获取聊天历史异常:', error)
+      console.warn(`[飞书 Bot ${this.botConfig.name}] 获取聊天历史异常:`, error)
       return []
     }
   }
 
-  /**
-   * 解析消息内容为可读文本
-   */
   private parseChatMessageContent(msgType: string, rawContent?: string): string {
     if (!rawContent) return '[空消息]'
 
@@ -1620,7 +1771,6 @@ class FeishuBridge {
           return parsed.text ?? ''
         }
         case 'post': {
-          // 富文本消息，提取纯文本
           const parsed = JSON.parse(rawContent) as {
             title?: string
             content?: Array<Array<{ tag: string; text?: string }>>
@@ -1660,9 +1810,6 @@ class FeishuBridge {
     }
   }
 
-  /**
-   * 批量解析消息发送者名称
-   */
   private async resolveMessageSenderNames(messages: FeishuChatMessage[]): Promise<void> {
     const uniqueUserIds = new Set<string>()
     for (const msg of messages) {
@@ -1671,11 +1818,9 @@ class FeishuBridge {
       }
     }
 
-    // 并发获取用户名称（最多 10 个并发）
     const userIds = Array.from(uniqueUserIds).slice(0, 10)
     await Promise.allSettled(userIds.map((id) => this.getUserName(id)))
 
-    // 回填名称
     for (const msg of messages) {
       if (msg.senderType === 'user') {
         msg.senderName = this.userNameCache.get(msg.senderId)
@@ -1685,9 +1830,6 @@ class FeishuBridge {
     }
   }
 
-  /**
-   * 将消息历史格式化为 Agent 可读的上下文文本
-   */
   private formatChatHistoryContext(messages: FeishuChatMessage[]): string {
     if (messages.length === 0) return ''
 
@@ -1708,11 +1850,6 @@ class FeishuBridge {
     ].join('\n')
   }
 
-  /**
-   * 创建飞书群聊 MCP 服务器（动态工具，仅在群聊 Agent 会话中注入）
-   *
-   * 提供 `fetch_group_chat_history` 工具，让 Agent 可以主动拉取更多群聊历史。
-   */
   private async createFeishuChatMcpServer(
     chatId: string,
   ): Promise<Record<string, unknown> | null> {
@@ -1761,19 +1898,14 @@ class FeishuBridge {
         ],
       })
 
-      console.log('[飞书 Bridge] 已创建群聊 MCP 工具')
+      console.log(`[飞书 Bot ${this.botConfig.name}] 已创建群聊 MCP 工具`)
       return server as unknown as Record<string, unknown>
     } catch (error) {
-      console.warn('[飞书 Bridge] 创建群聊 MCP 工具失败:', error)
+      console.warn(`[飞书 Bot ${this.botConfig.name}] 创建群聊 MCP 工具失败:`, error)
       return null
     }
   }
 
-  /**
-   * 解析消息上下文前缀：[工作区名称]->[会话名称]：
-   *
-   * 用于在每条回复的飞书消息开头标注来源，方便用户区分。
-   */
   private resolveContextPrefix(chatId: string): string {
     const binding = this.chatBindings.get(chatId)
     if (!binding) return ''
@@ -1787,7 +1919,6 @@ class FeishuBridge {
     return `[${wsName}]->[${sessName}]：`
   }
 
-  /** 获取卡片 header subtitle 用的上下文描述 */
   private resolveContextSubtitle(chatId: string): string {
     const binding = this.chatBindings.get(chatId)
     if (!binding) return ''
@@ -1813,11 +1944,10 @@ class FeishuBridge {
           content: JSON.stringify({ text }),
         },
       })
-      // 将 Bot 发出的消息 ID 加入去重集合，防止回环
       const sentId = (resp?.data as Record<string, unknown>)?.message_id as string | undefined
       if (sentId) this.addToDedup(this.recentMessageIds, sentId)
     } catch (error) {
-      console.error('[飞书 Bridge] 发送文本消息失败:', error)
+      console.error(`[飞书 Bot ${this.botConfig.name}] 发送文本消息失败:`, error)
     }
   }
 
@@ -1833,17 +1963,71 @@ class FeishuBridge {
           content: JSON.stringify(card),
         },
       })
-      // 将 Bot 发出的消息 ID 加入去重集合，防止回环
       const sentId = (resp?.data as Record<string, unknown>)?.message_id as string | undefined
       if (sentId) this.addToDedup(this.recentMessageIds, sentId)
     } catch (error) {
-      console.error('[飞书 Bridge] 发送卡片消息失败:', error)
+      console.error(`[飞书 Bot ${this.botConfig.name}] 发送卡片消息失败:`, error)
+    }
+  }
+
+  private async addReaction(chatId: string, messageId: string, emojiType: string): Promise<void> {
+    if (!this.client) return
+    if (!messageId) return
+    
+    try {
+      const resp = await this.client.im.messageReaction.create({
+        path: { message_id: messageId },
+        data: { reaction_type: { emoji_type: emojiType } },
+      }) as { code?: number; msg?: string; data?: { reaction_id?: string } }
+
+      // 检查飞书 API 返回码
+      if (resp.code !== 0) return
+
+      // 存储 reaction_id 用于后续删除
+      const reactionId = resp.data?.reaction_id
+      if (reactionId) {
+        this.processingReaction.set(chatId, { messageId, reactionId })
+      }
+    } catch (error) {
+      // 添加表情失败不影响主流程
+    }
+  }
+
+  private async removeReaction(chatId: string): Promise<void> {
+    const reaction = this.processingReaction.get(chatId)
+    if (!reaction || !this.client) {
+      // 没有表情信息时静默返回（可能是之前添加失败或没有消息ID）
+      return
+    }
+    try {
+      console.log(`[飞书 Bot ${this.botConfig.name}] 移除表情回复: messageId=${reaction.messageId}, reactionId=${reaction.reactionId}`)
+      const resp = await this.client.im.messageReaction.delete({
+        path: { message_id: reaction.messageId, reaction_id: reaction.reactionId },
+      }) as { code?: number; msg?: string }
+
+      // 检查飞书 API 返回码
+      if (resp.code !== 0) {
+        console.error(`[飞书 Bot ${this.botConfig.name}] 移除表情失败: code=${resp.code}, msg=${resp.msg}`)
+        // 即使删除失败，也从本地缓存中移除（避免重复尝试）
+        this.processingReaction.delete(chatId)
+        return
+      }
+
+      this.processingReaction.delete(chatId)
+      console.log(`[飞书 Bot ${this.botConfig.name}] 移除表情回复成功`)
+    } catch (error) {
+      console.error(`[飞书 Bot ${this.botConfig.name}] 移除表情回复异常:`, error)
+      // 记录更详细的错误信息
+      if (error instanceof Error) {
+        console.error(`[飞书 Bot ${this.botConfig.name}] 移除错误详情:`, error.message)
+      }
+      // 即使删除失败，也从本地缓存中移除（避免重复尝试）
+      this.processingReaction.delete(chatId)
     }
   }
 
   // ===== 群聊 Thread Reply =====
 
-  /** 回复指定消息（文本，群聊线程回复） */
   private async replyTextMessage(messageId: string, text: string): Promise<void> {
     if (!this.client) return
 
@@ -1858,11 +2042,10 @@ class FeishuBridge {
       const sentId = (resp?.data as Record<string, unknown>)?.message_id as string | undefined
       if (sentId) this.addToDedup(this.recentMessageIds, sentId)
     } catch (error) {
-      console.error('[飞书 Bridge] 回复文本消息失败:', error)
+      console.error(`[飞书 Bot ${this.botConfig.name}] 回复文本消息失败:`, error)
     }
   }
 
-  /** 回复指定消息（卡片，群聊线程回复） */
   private async replyCard(messageId: string, card: Record<string, unknown>): Promise<void> {
     if (!this.client) return
 
@@ -1877,15 +2060,10 @@ class FeishuBridge {
       const sentId = (resp?.data as Record<string, unknown>)?.message_id as string | undefined
       if (sentId) this.addToDedup(this.recentMessageIds, sentId)
     } catch (error) {
-      console.error('[飞书 Bridge] 回复卡片消息失败:', error)
+      console.error(`[飞书 Bot ${this.botConfig.name}] 回复卡片消息失败:`, error)
     }
   }
 
-  /**
-   * 发送文本消息到聊天（自动选择回复或新建）
-   *
-   * 群聊时使用 reply（线程回复），单聊时使用 create。
-   */
   private async sendMessage(chatId: string, text: string): Promise<void> {
     const binding = this.chatBindings.get(chatId)
     const replyToId = binding?.chatType === 'group'
@@ -1899,9 +2077,6 @@ class FeishuBridge {
     }
   }
 
-  /**
-   * 发送卡片消息到聊天（自动选择回复或新建）
-   */
   private async sendCardMessage(chatId: string, card: Record<string, unknown>): Promise<void> {
     const binding = this.chatBindings.get(chatId)
     const replyToId = binding?.chatType === 'group'
@@ -1919,15 +2094,221 @@ class FeishuBridge {
 
   private updateStatus(partial: Partial<FeishuBridgeState>): void {
     this.status = { ...this.status, ...partial }
+    this.onStatusChanged?.(this.getBotStatus())
+  }
+}
+
+// ===== FeishuBotManager =====
+
+/**
+ * 飞书多 Bot 管理器
+ *
+ * 管理多个 SingleBotBridge 实例，支持：
+ * - startBot(botId) / stopBot(botId)
+ * - startAllEnabled() - 启动所有已启用的 Bot
+ * - 获取所有 Bot 的状态
+ */
+export class FeishuBotManager {
+  /** botId → SingleBotBridge 实例 */
+  private bridges = new Map<string, SingleBotBridge>()
 
-    // 广播到渲染进程
+  constructor() {
+    console.log('[飞书 Bot 管理器] 已创建')
+  }
+
+  private emitIpc(channel: string, payload: unknown): void {
     const windows = BrowserWindow.getAllWindows()
     if (windows.length > 0 && !windows[0]!.isDestroyed()) {
-      windows[0]!.webContents.send(FEISHU_IPC_CHANNELS.STATUS_CHANGED, this.status)
+      windows[0]!.webContents.send(channel, payload)
+    }
+  }
+
+  private emitBotStatusChanged(status: FeishuBotStatus): void {
+    this.emitIpc(FEISHU_IPC_CHANNELS.BOT_STATUS_CHANGED, status)
+  }
+
+  private aggregateBridgeStatus(statuses: FeishuBotStatus[]): FeishuBridgeState {
+    if (statuses.length === 0) {
+      return { status: 'disconnected', activeBindings: 0 }
     }
+
+    const hasConnected = statuses.some((s) => s.status === 'connected')
+    const hasConnecting = statuses.some((s) => s.status === 'connecting')
+    const hasError = statuses.some((s) => s.status === 'error')
+    const activeBindings = statuses.reduce((sum, s) => sum + (s.activeBindings ?? 0), 0)
+
+    let status: FeishuBridgeState['status'] = 'disconnected'
+    if (hasConnected) status = 'connected'
+    else if (hasConnecting) status = 'connecting'
+    else if (hasError) status = 'error'
+
+    return {
+      status,
+      activeBindings,
+      connectedAt: statuses.find((s) => s.connectedAt)?.connectedAt,
+      errorMessage: statuses.find((s) => s.errorMessage)?.errorMessage,
+    }
+  }
+
+  private emitAggregateStatusChanged(): void {
+    const aggregated = this.aggregateBridgeStatus(this.getAllBotStatuses())
+    this.emitIpc(FEISHU_IPC_CHANNELS.STATUS_CHANGED, aggregated)
+  }
+
+  getAggregateStatus(): FeishuBridgeState {
+    return this.aggregateBridgeStatus(this.getAllBotStatuses())
+  }
+
+  /**
+   * 启动指定 Bot
+   */
+  async startBot(botConfig: FeishuBotConfig): Promise<void> {
+    console.log(`[飞书 Bot 管理器] startBot called for ${botConfig.name} (${botConfig.id}), already running: ${this.bridges.has(botConfig.id)}`)
+    const existing = this.bridges.get(botConfig.id)
+    if (existing) {
+      const status = existing.getBotStatus().status
+      if (status === 'connected' || status === 'connecting') {
+        console.log(`[飞书 Bot 管理器] Bot ${botConfig.name} 已处于 ${status}，跳过启动`)
+        return
+      }
+
+      // 清理异常状态实例，确保可重试启动
+      existing.stop()
+      this.bridges.delete(botConfig.id)
+    }
+
+    console.log(`[飞书 Bot 管理器] Creating new bridge for ${botConfig.name}`)
+    const bridge = new SingleBotBridge(botConfig, (status) => {
+      this.emitBotStatusChanged(status)
+      this.emitAggregateStatusChanged()
+    })
+    this.bridges.set(botConfig.id, bridge)
+    console.log(`[飞书 Bot 管理器] Calling bridge.start() for ${botConfig.name}`)
+    try {
+      await bridge.start()
+      console.log(`[飞书 Bot 管理器] bridge.start() completed for ${botConfig.name}`)
+      this.emitAggregateStatusChanged()
+    } catch (error) {
+      bridge.stop()
+      this.bridges.delete(botConfig.id)
+      this.emitAggregateStatusChanged()
+      throw error
+    }
+  }
+
+  /**
+   * 停止指定 Bot
+   */
+  stopBot(botId: string): void {
+    const bridge = this.bridges.get(botId)
+    if (!bridge) return
+
+    bridge.stop()
+    this.bridges.delete(botId)
+    this.emitAggregateStatusChanged()
+  }
+
+  /**
+   * 停止所有 Bot
+   */
+  stopAll(): void {
+    for (const [botId] of this.bridges) {
+      this.stopBot(botId)
+    }
+    this.emitAggregateStatusChanged()
+  }
+
+  /**
+   * 启动所有已启用的 Bot
+   */
+  async startAllEnabled(bots: FeishuBotConfig[]): Promise<void> {
+    const enabledBots = bots.filter((b) => b.enabled)
+    console.log(`[飞书 Bot 管理器] 准备启动 ${enabledBots.length} 个已启用 Bot`)
+
+    await Promise.allSettled(
+      enabledBots.map(async (bot) => {
+        try {
+          await this.startBot(bot)
+        } catch (error) {
+          console.error(`[飞书 Bot 管理器] 启动 Bot ${bot.name} 失败:`, error)
+        }
+      })
+    )
+  }
+
+  /**
+   * 获取所有 Bot 的状态
+   */
+  getAllBotStatuses(): FeishuBotStatus[] {
+    return Array.from(this.bridges.values()).map((bridge) => bridge.getBotStatus())
+  }
+
+  /**
+   * 获取指定 Bot 的状态
+   */
+  getBotStatus(botId: string): FeishuBotStatus | null {
+    const bridge = this.bridges.get(botId)
+    return bridge ? bridge.getBotStatus() : null
+  }
+
+  /**
+   * 更新运行中 Bot 的所有绑定工作区 ID
+   *
+   * 当 Bot 配置更新后，如果 Bot 已在运行，同步更新其所有绑定的工作区 ID。
+   */
+  updateRunningBotBindings(botId: string, newWorkspaceId: string): void {
+    const bridge = this.bridges.get(botId)
+    if (bridge) {
+      bridge.updateAllBindingsWorkspaceId(newWorkspaceId)
+    }
+  }
+
+  /**
+   * 获取指定 Bot 的 Bridge（用于绑定操作）
+   */
+  getBridge(botId: string): SingleBotBridge | undefined {
+    return this.bridges.get(botId)
+  }
+
+  /**
+   * 根据 appId 获取 Bridge
+   */
+  getBridgeByAppId(appId: string): SingleBotBridge | undefined {
+    for (const bridge of this.bridges.values()) {
+      if (bridge.appId === appId) return bridge
+    }
+    return undefined
+  }
+
+  /**
+   * 获取所有活跃绑定
+   */
+  listAllBindings(): FeishuChatBinding[] {
+    const allBindings: FeishuChatBinding[] = []
+    for (const bridge of this.bridges.values()) {
+      allBindings.push(...bridge.listBindings())
+    }
+    return allBindings
+  }
+
+  /**
+   * 测试连接
+   */
+  async testConnection(appId: string, appSecret: string): Promise<FeishuTestResult> {
+    // 创建一个临时 bridge 来测试连接
+    const bridge = new SingleBotBridge({
+      id: 'test',
+      name: 'test',
+      appId,
+      appSecret,
+      workspaceId: '',
+      enabled: true,
+      createdAt: 0,
+    })
+    return bridge.testConnection(appId, appSecret)
   }
 }
 
 // ===== 导出单例 =====
 
-export const feishuBridge = new FeishuBridge()
+export const feishuBotManager = new FeishuBotManager()
diff --git a/apps/electron/src/main/lib/feishu-config.ts b/apps/electron/src/main/lib/feishu-config.ts
deleted file mode 100644
index 5ae0258b..00000000
--- a/apps/electron/src/main/lib/feishu-config.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-/**
- * 飞书配置管理
- *
- * 负责飞书 Bot 配置的 CRUD 操作、App Secret 加密/解密。
- * 使用 Electron safeStorage 进行加密（与渠道 API Key 相同模式）。
- * 数据持久化到 ~/.proma/feishu.json。
- */
-
-import { readFileSync, writeFileSync, existsSync } from 'node:fs'
-import { safeStorage } from 'electron'
-import { getFeishuConfigPath } from './config-paths'
-import type { FeishuConfig, FeishuConfigInput } from '@proma/shared'
-
-/** 默认配置 */
-const DEFAULT_CONFIG: FeishuConfig = {
-  enabled: false,
-  appId: '',
-  appSecret: '',
-}
-
-// ===== 加密/解密 =====
-
-/**
- * 加密 App Secret
- *
- * 使用 Electron safeStorage 加密，底层使用 OS 级加密。
- *
- * @returns base64 编码的加密字符串
- */
-function encryptSecret(plainSecret: string): string {
-  if (!safeStorage.isEncryptionAvailable()) {
-    console.warn('[飞书配置] safeStorage 加密不可用，将以明文存储')
-    return plainSecret
-  }
-
-  const encrypted = safeStorage.encryptString(plainSecret)
-  return encrypted.toString('base64')
-}
-
-/**
- * 解密 App Secret
- *
- * @returns 明文 App Secret
- */
-function decryptSecret(encryptedSecret: string): string {
-  if (!encryptedSecret) return ''
-
-  if (!safeStorage.isEncryptionAvailable()) {
-    return encryptedSecret
-  }
-
-  try {
-    const buffer = Buffer.from(encryptedSecret, 'base64')
-    return safeStorage.decryptString(buffer)
-  } catch (error) {
-    console.error('[飞书配置] 解密 App Secret 失败:', error)
-    throw new Error('解密 App Secret 失败')
-  }
-}
-
-// ===== 配置 CRUD =====
-
-/**
- * 读取飞书配置
- *
- * 返回的 appSecret 是加密后的，不要直接使用。
- * 需要明文 Secret 请调用 getDecryptedAppSecret()。
- */
-export function getFeishuConfig(): FeishuConfig {
-  const configPath = getFeishuConfigPath()
-
-  if (!existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG }
-  }
-
-  try {
-    const raw = readFileSync(configPath, 'utf-8')
-    const data = JSON.parse(raw) as Partial<FeishuConfig>
-    return {
-      ...DEFAULT_CONFIG,
-      ...data,
-    }
-  } catch (error) {
-    console.error('[飞书配置] 读取配置文件失败:', error)
-    return { ...DEFAULT_CONFIG }
-  }
-}
-
-/**
- * 保存飞书配置
- *
- * 接收明文 App Secret，自动加密后存储。
- */
-export function saveFeishuConfig(input: FeishuConfigInput): FeishuConfig {
-  const configPath = getFeishuConfigPath()
-  const current = getFeishuConfig()
-
-  const config: FeishuConfig = {
-    enabled: input.enabled,
-    appId: input.appId.trim(),
-    // 空字符串时保留原值（UI 端留空表示不修改）
-    appSecret: input.appSecret ? encryptSecret(input.appSecret) : current.appSecret,
-    defaultWorkspaceId: input.defaultWorkspaceId,
-  }
-
-  writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8')
-  console.log('[飞书配置] 配置已保存')
-
-  return config
-}
-
-/**
- * 获取解密后的 App Secret
- *
- * 用于实际连接飞书 API 时使用。
- */
-export function getDecryptedAppSecret(): string {
-  const config = getFeishuConfig()
-  return decryptSecret(config.appSecret)
-}
-
-/**
- * 更新飞书配置的部分字段
- *
- * 不会修改 appId 和 appSecret，仅更新其他字段。
- */
-export function updateFeishuConfigPartial(updates: Partial<Omit<FeishuConfig, 'appId' | 'appSecret'>>): FeishuConfig {
-  const current = getFeishuConfig()
-  const updated: FeishuConfig = { ...current, ...updates }
-  const configPath = getFeishuConfigPath()
-  writeFileSync(configPath, JSON.stringify(updated, null, 2), 'utf-8')
-  return updated
-}
diff --git a/apps/electron/src/main/lib/local-env-detector.ts b/apps/electron/src/main/lib/local-env-detector.ts
new file mode 100644
index 00000000..243733d0
--- /dev/null
+++ b/apps/electron/src/main/lib/local-env-detector.ts
@@ -0,0 +1,199 @@
+/**
+ * 本地环境检测服务
+ *
+ * 从 process.env 中自动识别用户本地的 Claude Code 环境配置
+ * （Vertex / Bedrock / Direct API），将其转换为 Proma 渠道。
+ *
+ * 检测时机：在 initializeRuntime()（含 loadShellEnv）之后执行，
+ * 此时 process.env 已包含用户 shell 中的完整环境变量。
+ */
+
+import { isProviderRoutingVar } from '@proma/shared'
+import {
+  createOrUpdateLocalEnvChannel,
+  removeStaleLocalEnvChannels,
+} from './channel-manager'
+import type { LocalEnvDetection } from './channel-manager'
+import type { ChannelModel } from '@proma/shared'
+
+/**
+ * 从环境变量中推断模型列表
+ */
+function inferModels(env: Record<string, string | undefined>): ChannelModel[] {
+  const models: ChannelModel[] = []
+  const seen = new Set<string>()
+
+  // 从各模型环境变量中提取
+  const modelVars = [
+    'ANTHROPIC_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_SMALL_FAST_MODEL',
+  ]
+
+  for (const varName of modelVars) {
+    const value = env[varName]
+    if (value && !seen.has(value)) {
+      seen.add(value)
+      models.push({
+        id: value,
+        name: value,
+        enabled: true,
+      })
+    }
+  }
+
+  // 如果没有检测到任何模型，添加默认模型
+  if (models.length === 0) {
+    models.push(
+      { id: 'claude-sonnet-4-5-20250929', name: 'Claude Sonnet 4.5', enabled: true },
+      { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', enabled: true },
+    )
+  }
+
+  return models
+}
+
+/**
+ * 检测 Vertex AI 配置
+ */
+function detectVertex(env: Record<string, string | undefined>): LocalEnvDetection | null {
+  if (env.CLAUDE_CODE_USE_VERTEX !== '1') return null
+
+  const baseUrl = env.ANTHROPIC_VERTEX_BASE_URL
+  const projectId = env.ANTHROPIC_VERTEX_PROJECT_ID
+  const authToken = env.ANTHROPIC_AUTH_TOKEN
+
+  // Vertex 必须有 base URL 或 project ID
+  if (!baseUrl && !projectId) {
+    console.warn('[本地环境检测] 检测到 CLAUDE_CODE_USE_VERTEX=1 但缺少 BASE_URL 和 PROJECT_ID，跳过')
+    return null
+  }
+
+  const envVars: Record<string, string> = {
+    CLAUDE_CODE_USE_VERTEX: '1',
+  }
+
+  if (baseUrl) envVars.ANTHROPIC_VERTEX_BASE_URL = baseUrl
+  if (projectId) envVars.ANTHROPIC_VERTEX_PROJECT_ID = projectId
+  if (authToken) envVars.ANTHROPIC_AUTH_TOKEN = authToken
+  if (env.CLAUDE_CODE_SKIP_VERTEX_AUTH === '1') envVars.CLAUDE_CODE_SKIP_VERTEX_AUTH = '1'
+  if (env.ANTHROPIC_VERTEX_REGION) envVars.ANTHROPIC_VERTEX_REGION = env.ANTHROPIC_VERTEX_REGION
+
+  return {
+    authType: 'vertex',
+    name: '本地 Vertex AI',
+    id: 'local-env-vertex',
+    baseUrl: baseUrl || '',
+    apiKey: authToken || '',
+    envVars,
+    models: inferModels(env),
+  }
+}
+
+/**
+ * 检测 Bedrock 配置
+ */
+function detectBedrock(env: Record<string, string | undefined>): LocalEnvDetection | null {
+  if (env.CLAUDE_CODE_USE_BEDROCK !== '1') return null
+
+  const envVars: Record<string, string> = {
+    CLAUDE_CODE_USE_BEDROCK: '1',
+  }
+
+  if (env.ANTHROPIC_BEDROCK_BASE_URL) envVars.ANTHROPIC_BEDROCK_BASE_URL = env.ANTHROPIC_BEDROCK_BASE_URL
+  if (env.CLAUDE_CODE_SKIP_BEDROCK_AUTH === '1') envVars.CLAUDE_CODE_SKIP_BEDROCK_AUTH = '1'
+  if (env.AWS_REGION) envVars.AWS_REGION = env.AWS_REGION
+  if (env.AWS_ACCESS_KEY_ID) envVars.AWS_ACCESS_KEY_ID = env.AWS_ACCESS_KEY_ID
+  if (env.AWS_SECRET_ACCESS_KEY) envVars.AWS_SECRET_ACCESS_KEY = env.AWS_SECRET_ACCESS_KEY
+  if (env.AWS_SESSION_TOKEN) envVars.AWS_SESSION_TOKEN = env.AWS_SESSION_TOKEN
+  if (env.AWS_PROFILE) envVars.AWS_PROFILE = env.AWS_PROFILE
+
+  return {
+    authType: 'bedrock',
+    name: '本地 Bedrock',
+    id: 'local-env-bedrock',
+    baseUrl: env.ANTHROPIC_BEDROCK_BASE_URL || '',
+    apiKey: '',
+    envVars,
+    models: inferModels(env),
+  }
+}
+
+/**
+ * 检测 Direct API 配置（标准 ANTHROPIC_API_KEY）
+ */
+function detectDirectApi(env: Record<string, string | undefined>): LocalEnvDetection | null {
+  const apiKey = env.ANTHROPIC_API_KEY
+  if (!apiKey) return null
+
+  const envVars: Record<string, string> = {}
+  if (env.ANTHROPIC_BASE_URL) envVars.ANTHROPIC_BASE_URL = env.ANTHROPIC_BASE_URL
+
+  return {
+    authType: 'api_key',
+    name: '本地 Anthropic API',
+    id: 'local-env-direct',
+    baseUrl: env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com',
+    apiKey,
+    envVars,
+    models: inferModels(env),
+  }
+}
+
+/**
+ * 执行本地环境检测并同步到渠道系统
+ *
+ * 检测优先级：Vertex > Bedrock > Direct API
+ * 可以同时存在多个（如 Vertex + Direct 同时配置），每个生成一个渠道。
+ */
+export function detectAndSyncLocalChannels(): void {
+  const env = process.env
+  const activeIds = new Set<string>()
+  const detections: LocalEnvDetection[] = []
+
+  // 按类型检测（可并存）
+  const vertex = detectVertex(env)
+  if (vertex) detections.push(vertex)
+
+  const bedrock = detectBedrock(env)
+  if (bedrock) detections.push(bedrock)
+
+  const direct = detectDirectApi(env)
+  if (direct) detections.push(direct)
+
+  // 同步到渠道系统
+  for (const detection of detections) {
+    createOrUpdateLocalEnvChannel(detection)
+    activeIds.add(detection.id)
+  }
+
+  // 清理不再有效的本地渠道
+  removeStaleLocalEnvChannels(activeIds)
+
+  if (detections.length > 0) {
+    console.log(`[本地环境检测] 检测到 ${detections.length} 个本地渠道: ${detections.map(d => d.name).join(', ')}`)
+  } else {
+    console.log('[本地环境检测] 未检测到本地 Claude Code 环境配置')
+  }
+}
+
+/**
+ * 执行全面的环境变量清理
+ *
+ * 在检测并保存渠道后，从 process.env 中移除所有 Provider 路由变量，
+ * 防止它们泄漏到后续的 SDK 子进程中。
+ */
+export function cleanupProviderEnvVars(): void {
+  let cleaned = 0
+  for (const key of Object.keys(process.env)) {
+    if (isProviderRoutingVar(key)) {
+      delete process.env[key]
+      cleaned++
+    }
+  }
+  if (cleaned > 0) {
+    console.log(`[本地环境检测] 已从 process.env 清理 ${cleaned} 个 Provider 路由变量`)
+  }
+}
diff --git a/apps/electron/src/main/lib/settings-service.ts b/apps/electron/src/main/lib/settings-service.ts
index 9dbc7eb3..81f7341d 100644
--- a/apps/electron/src/main/lib/settings-service.ts
+++ b/apps/electron/src/main/lib/settings-service.ts
@@ -7,7 +7,7 @@
 
 import { readFileSync, writeFileSync, existsSync } from 'node:fs'
 import { getSettingsPath } from './config-paths'
-import { DEFAULT_THEME_MODE } from '../../types'
+import { DEFAULT_THEME_MODE, DEFAULT_CHAT_MESSAGE_LAYOUT, DEFAULT_MESSAGE_BUBBLE_COLORS } from '../../types'
 import type { AppSettings } from '../../types'
 
 /**
@@ -21,6 +21,8 @@ export function getSettings(): AppSettings {
   if (!existsSync(filePath)) {
     return {
       themeMode: DEFAULT_THEME_MODE,
+      chatMessageLayout: DEFAULT_CHAT_MESSAGE_LAYOUT,
+      messageBubbleColors: DEFAULT_MESSAGE_BUBBLE_COLORS,
       onboardingCompleted: false,
       environmentCheckSkipped: false,
       notificationsEnabled: true,
@@ -33,6 +35,8 @@ export function getSettings(): AppSettings {
     return {
       ...data,
       themeMode: data.themeMode || DEFAULT_THEME_MODE,
+      chatMessageLayout: data.chatMessageLayout || DEFAULT_CHAT_MESSAGE_LAYOUT,
+      messageBubbleColors: data.messageBubbleColors || DEFAULT_MESSAGE_BUBBLE_COLORS,
       onboardingCompleted: data.onboardingCompleted ?? false,
       environmentCheckSkipped: data.environmentCheckSkipped ?? false,
       notificationsEnabled: data.notificationsEnabled ?? true,
@@ -41,6 +45,8 @@ export function getSettings(): AppSettings {
     console.error('[设置] 读取失败:', error)
     return {
       themeMode: DEFAULT_THEME_MODE,
+      chatMessageLayout: DEFAULT_CHAT_MESSAGE_LAYOUT,
+      messageBubbleColors: DEFAULT_MESSAGE_BUBBLE_COLORS,
       onboardingCompleted: false,
       environmentCheckSkipped: false,
       notificationsEnabled: true,
diff --git a/apps/electron/src/main/lib/workspace-watcher.ts b/apps/electron/src/main/lib/workspace-watcher.ts
index d7964664..5e339afd 100644
--- a/apps/electron/src/main/lib/workspace-watcher.ts
+++ b/apps/electron/src/main/lib/workspace-watcher.ts
@@ -16,6 +16,7 @@ import type { FSWatcher } from 'node:fs'
 import type { BrowserWindow } from 'electron'
 import { AGENT_IPC_CHANNELS } from '@proma/shared'
 import { getAgentWorkspacesDir } from './config-paths'
+import { PERSONA_FILES } from './agent-persona-service'
 
 /** debounce 延迟（ms） */
 const DEBOUNCE_MS = 500
@@ -52,11 +53,22 @@ export function startWorkspaceWatcher(win: BrowserWindow): void {
       if (!filename || win.isDestroyed()) return
 
       // filename 格式: {slug}/mcp.json 或 {slug}/skills/xxx/SKILL.md 或 {slug}/{sessionId}/file.txt
+      // persona 文件变化也需要刷新 capabilities
       const isCapabilitiesChange =
         filename.endsWith('/mcp.json') ||
         filename.endsWith('\\mcp.json') ||
         filename.includes('/skills/') ||
-        filename.includes('\\skills/')
+        filename.includes('\\skills/') ||
+        filename.includes('/agents/') ||
+        filename.includes('\\agents/') ||
+        filename.includes('/agents-inactive/') ||
+        filename.includes('\\agents-inactive/') ||
+        filename.endsWith('/' + PERSONA_FILES.AGENT) ||
+        filename.endsWith('\\' + PERSONA_FILES.AGENT) ||
+        filename.endsWith('/' + PERSONA_FILES.USER) ||
+        filename.endsWith('\\' + PERSONA_FILES.USER) ||
+        filename.endsWith('/' + PERSONA_FILES.SOUL) ||
+        filename.endsWith('\\' + PERSONA_FILES.SOUL)
 
       if (isCapabilitiesChange) {
         // MCP/Skills 变化 → 通知侧边栏刷新
diff --git a/apps/electron/src/preload/index.ts b/apps/electron/src/preload/index.ts
index b9675ff0..b264d413 100644
--- a/apps/electron/src/preload/index.ts
+++ b/apps/electron/src/preload/index.ts
@@ -5,7 +5,7 @@
  * 使用上下文隔离确保安全性
  */
 
-import { contextBridge, ipcRenderer } from 'electron'
+import { contextBridge, ipcRenderer, webUtils } from 'electron'
 import { IPC_CHANNELS, CHANNEL_IPC_CHANNELS, CHAT_IPC_CHANNELS, AGENT_IPC_CHANNELS, ENVIRONMENT_IPC_CHANNELS, PROXY_IPC_CHANNELS, GITHUB_RELEASE_IPC_CHANNELS, SYSTEM_PROMPT_IPC_CHANNELS, MEMORY_IPC_CHANNELS, CHAT_TOOL_IPC_CHANNELS, FEISHU_IPC_CHANNELS } from '@proma/shared'
 import { USER_PROFILE_IPC_CHANNELS, SETTINGS_IPC_CHANNELS } from '../types'
 import type {
@@ -40,13 +40,11 @@ import type {
   AgentSaveFilesInput,
   AgentSaveWorkspaceFilesInput,
   AgentSavedFile,
-  AgentAttachDirectoryInput,
   WorkspaceAttachDirectoryInput,
-  GetTaskOutputInput,
-  GetTaskOutputResult,
   StopTaskInput,
   WorkspaceMcpConfig,
   SkillMeta,
+  AgentMeta,
   WorkspaceCapabilities,
   FileEntry,
   FileSearchResult,
@@ -68,10 +66,7 @@ import type {
   ChatToolInfo,
   ChatToolState,
   ChatToolMeta,
-  AgentTeamData,
   MoveSessionToWorkspaceInput,
-  FeishuConfig,
-  FeishuConfigInput,
   FeishuBridgeState,
   FeishuTestResult,
   FeishuChatBinding,
@@ -79,6 +74,10 @@ import type {
   FeishuNotifyMode,
   FeishuNotificationSentPayload,
   FeishuUpdateBindingInput,
+  FeishuBotConfig,
+  FeishuBotConfigInput,
+  FeishuBotStatus,
+  AgentPersona,
 } from '@proma/shared'
 import type { UserProfile, AppSettings } from '../types'
 
@@ -106,6 +105,9 @@ export interface ElectronAPI {
   /** 在系统默认浏览器中打开外部链接 */
   openExternal: (url: string) => Promise<void>
 
+  /** 获取文件的本地路径（用于拖拽文件夹，contextIsolation 安全方式） */
+  getFilePath: (file: File) => string
+
   // ===== 渠道管理相关 =====
 
   /** 获取所有渠道列表（apiKey 保持加密态） */
@@ -302,9 +304,6 @@ export interface ElectronAPI {
 
   // ===== Agent 后台任务管理 =====
 
-  /** 获取任务输出 */
-  getTaskOutput: (input: GetTaskOutputInput) => Promise<GetTaskOutputResult>
-
   /** 停止任务 */
   stopTask: (input: StopTaskInput) => Promise<void>
 
@@ -348,6 +347,18 @@ export interface ElectronAPI {
   /** 切换工作区 Skill 启用/禁用 */
   toggleWorkspaceSkill: (workspaceSlug: string, skillSlug: string, enabled: boolean) => Promise<void>
 
+  /** 获取工作区子代理列表（含活跃和不活跃） */
+  getWorkspaceAgents: (workspaceSlug: string) => Promise<AgentMeta[]>
+
+  /** 获取工作区子代理目录绝对路径 */
+  getWorkspaceAgentsDir: (workspaceSlug: string) => Promise<string>
+
+  /** 删除工作区子代理 */
+  deleteWorkspaceAgent: (workspaceSlug: string, agentSlug: string) => Promise<void>
+
+  /** 切换工作区子代理启用/禁用 */
+  toggleWorkspaceAgent: (workspaceSlug: string, agentSlug: string, enabled: boolean) => Promise<void>
+
   /** 订阅 Agent 流式事件（返回清理函数） */
   onAgentStreamEvent: (callback: (event: AgentStreamEvent) => void) => () => void
 
@@ -411,14 +422,6 @@ export interface ElectronAPI {
   /** 响应 AskUser 请求 */
   respondAskUser: (response: AskUserResponse) => Promise<void>
 
-  // ===== Agent Teams 数据 =====
-
-  /** 获取 Team 聚合数据（团队配置 + 任务列表 + 收件箱） */
-  getAgentTeamData: (sdkSessionId: string) => Promise<AgentTeamData | null>
-
-  /** 读取 Teammate 输出文件内容 */
-  getAgentOutput: (filePath: string) => Promise<string>
-
   // ===== Agent 附件 =====
 
   /** 保存文件到 Agent session 工作目录 */
@@ -433,13 +436,10 @@ export interface ElectronAPI {
   /** 打开文件夹选择对话框 */
   openFolderDialog: () => Promise<{ path: string; name: string } | null>
 
-  /** 附加外部目录到 Agent 会话 */
-  attachDirectory: (input: AgentAttachDirectoryInput) => Promise<string[]>
-
-  /** 移除会话的附加目录 */
-  detachDirectory: (input: AgentAttachDirectoryInput) => Promise<string[]>
+  /** 打开文件或文件夹选择对话框（同时支持） */
+  openFileOrFolderDialog: () => Promise<import('@proma/shared').FileOrFolderDialogResult | null>
 
-  /** 附加外部目录到工作区（所有会话可访问） */
+  /** 关联外部目录到工作区（所有会话可访问） */
   attachWorkspaceDirectory: (input: WorkspaceAttachDirectoryInput) => Promise<string[]>
 
   /** 移除工作区的附加目录 */
@@ -448,6 +448,9 @@ export interface ElectronAPI {
   /** 获取工作区附加目录列表 */
   getWorkspaceDirectories: (workspaceSlug: string) => Promise<string[]>
 
+  /** 删除工作区的上传文件目录 */
+  deleteWorkspaceFilesDirectory: (workspaceSlug: string) => Promise<void>
+
   // ===== Agent 文件系统操作 =====
 
   /** 获取 session 工作路径 */
@@ -463,7 +466,7 @@ export interface ElectronAPI {
   openFile: (filePath: string) => Promise<void>
 
   /** 在系统文件管理器中显示文件 */
-  showInFolder: (filePath: string) => Promise<void>
+  showInFolder: (filePath: string, sessionId?: string, workspaceId?: string) => Promise<void>
 
   /** 在新窗口中预览文件 */
   previewFile: (filePath: string) => Promise<void>
@@ -489,6 +492,9 @@ export interface ElectronAPI {
   /** 移动附加目录文件/目录（无工作区路径限制） */
   moveAttachedFile: (filePath: string, targetDir: string) => Promise<void>
 
+  /** 删除附加目录文件/空目录（无工作区路径限制） */
+  deleteAttachedFile: (filePath: string) => Promise<void>
+
   /** 搜索工作区文件（用于 @ 引用，支持附加目录） */
   searchWorkspaceFiles: (rootPath: string, query: string, limit?: number, additionalPaths?: string[]) => Promise<FileSearchResult>
 
@@ -542,19 +548,13 @@ export interface ElectronAPI {
 
   // ===== 飞书集成 =====
 
-  /** 获取飞书配置 */
-  getFeishuConfig: () => Promise<FeishuConfig>
-  /** 获取解密后的 App Secret */
-  getDecryptedFeishuSecret: () => Promise<string>
-  /** 保存飞书配置（appSecret 为明文） */
-  saveFeishuConfig: (input: FeishuConfigInput) => Promise<FeishuConfig>
   /** 测试飞书连接 */
   testFeishuConnection: (appId: string, appSecret: string) => Promise<FeishuTestResult>
-  /** 启动飞书 Bridge */
+  /** 启动飞书 Bridge（兼容：实际启动所有已启用 Bots） */
   startFeishuBridge: () => Promise<void>
-  /** 停止飞书 Bridge */
+  /** 停止飞书 Bridge（兼容：实际停止所有 Bots） */
   stopFeishuBridge: () => Promise<void>
-  /** 获取飞书 Bridge 状态 */
+  /** 获取飞书 Bridge 状态（兼容：聚合所有 Bot 状态） */
   getFeishuStatus: () => Promise<FeishuBridgeState>
   /** 获取活跃绑定列表 */
   listFeishuBindings: () => Promise<FeishuChatBinding[]>
@@ -566,10 +566,36 @@ export interface ElectronAPI {
   reportFeishuPresence: (report: FeishuPresenceReport) => Promise<void>
   /** 设置会话通知模式 */
   setFeishuSessionNotify: (sessionId: string, mode: FeishuNotifyMode) => Promise<void>
-  /** 订阅飞书 Bridge 状态变化 */
+  /** 订阅飞书 Bridge 状态变化（兼容：聚合状态） */
   onFeishuStatusChanged: (callback: (state: FeishuBridgeState) => void) => () => void
   /** 订阅飞书通知已发送事件 */
   onFeishuNotificationSent: (callback: (payload: FeishuNotificationSentPayload) => void) => () => void
+
+  // ===== 多飞书 Bot 管理 =====
+
+  /** 获取所有 Bot 配置 */
+  listFeishuBots: () => Promise<{ bots: FeishuBotConfig[]; migrated: false }>
+  /** 保存 Bot（新建或更新） */
+  saveFeishuBot: (input: FeishuBotConfigInput, existingId?: string) => Promise<FeishuBotConfig>
+  /** 删除 Bot */
+  deleteFeishuBot: (botId: string) => Promise<boolean>
+  /** 启动指定 Bot */
+  startFeishuBot: (botId: string) => Promise<void>
+  /** 停止指定 Bot */
+  stopFeishuBot: (botId: string) => Promise<void>
+  /** 获取指定 Bot 状态 */
+  getFeishuBotStatus: (botId: string) => Promise<FeishuBotStatus | null>
+  /** 订阅 Bot 状态变化 */
+  onFeishuBotStatusChanged: (callback: (status: FeishuBotStatus) => void) => () => void
+
+  // ===== Agent Persona =====
+
+  /** 获取 Agent persona 文件 */
+  getAgentPersona: (workspaceSlug: string) => Promise<AgentPersona>
+  /** 保存 Agent persona 文件 */
+  saveAgentPersona: (workspaceSlug: string, persona: AgentPersona) => Promise<void>
+  /** 使 persona 缓存失效 */
+  invalidatePersonaCache: (workspaceSlug?: string) => Promise<void>
 }
 
 /**
@@ -590,6 +616,10 @@ const electronAPI: ElectronAPI = {
     return ipcRenderer.invoke(IPC_CHANNELS.OPEN_EXTERNAL, url)
   },
 
+  getFilePath: (file: File) => {
+    return webUtils.getPathForFile(file)
+  },
+
   // 渠道管理
   listChannels: () => {
     return ipcRenderer.invoke(CHANNEL_IPC_CHANNELS.LIST)
@@ -847,10 +877,6 @@ const electronAPI: ElectronAPI = {
   },
 
   // Agent 后台任务管理
-  getTaskOutput: (input: GetTaskOutputInput) => {
-    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.GET_TASK_OUTPUT, input)
-  },
-
   stopTask: (input: StopTaskInput) => {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.STOP_TASK, input)
   },
@@ -905,6 +931,22 @@ const electronAPI: ElectronAPI = {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.TOGGLE_SKILL, workspaceSlug, skillSlug, enabled)
   },
 
+  getWorkspaceAgents: (workspaceSlug: string) => {
+    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.GET_AGENTS, workspaceSlug)
+  },
+
+  getWorkspaceAgentsDir: (workspaceSlug: string) => {
+    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.GET_AGENTS_DIR, workspaceSlug)
+  },
+
+  deleteWorkspaceAgent: (workspaceSlug: string, agentSlug: string) => {
+    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.DELETE_AGENT, workspaceSlug, agentSlug)
+  },
+
+  toggleWorkspaceAgent: (workspaceSlug: string, agentSlug: string, enabled: boolean) => {
+    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.TOGGLE_AGENT, workspaceSlug, agentSlug, enabled)
+  },
+
   onAgentStreamEvent: (callback: (event: AgentStreamEvent) => void) => {
     const listener = (_: unknown, event: AgentStreamEvent): void => callback(event)
     ipcRenderer.on(AGENT_IPC_CHANNELS.STREAM_EVENT, listener)
@@ -995,15 +1037,6 @@ const electronAPI: ElectronAPI = {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.ASK_USER_RESPOND, response)
   },
 
-  // Agent Teams 数据
-  getAgentTeamData: (sdkSessionId: string) => {
-    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.GET_TEAM_DATA, sdkSessionId)
-  },
-
-  getAgentOutput: (filePath: string) => {
-    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.GET_AGENT_OUTPUT, filePath)
-  },
-
   // 工作区文件变化通知
   onCapabilitiesChanged: (callback: () => void) => {
     const listener = (): void => callback()
@@ -1034,12 +1067,8 @@ const electronAPI: ElectronAPI = {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.OPEN_FOLDER_DIALOG)
   },
 
-  attachDirectory: (input: AgentAttachDirectoryInput) => {
-    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.ATTACH_DIRECTORY, input)
-  },
-
-  detachDirectory: (input: AgentAttachDirectoryInput) => {
-    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.DETACH_DIRECTORY, input)
+  openFileOrFolderDialog: () => {
+    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.OPEN_FILE_OR_FOLDER_DIALOG)
   },
 
   attachWorkspaceDirectory: (input: WorkspaceAttachDirectoryInput) => {
@@ -1054,6 +1083,10 @@ const electronAPI: ElectronAPI = {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.GET_WORKSPACE_DIRECTORIES, workspaceSlug)
   },
 
+  deleteWorkspaceFilesDirectory: (workspaceSlug: string) => {
+    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.DELETE_WORKSPACE_FILES, workspaceSlug)
+  },
+
   // Agent 文件系统操作
   getAgentSessionPath: (workspaceId: string, sessionId: string) => {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.GET_SESSION_PATH, workspaceId, sessionId)
@@ -1071,8 +1104,8 @@ const electronAPI: ElectronAPI = {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.OPEN_FILE, filePath)
   },
 
-  showInFolder: (filePath: string) => {
-    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.SHOW_IN_FOLDER, filePath)
+  showInFolder: (filePath: string, sessionId?: string, workspaceId?: string) => {
+    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.SHOW_IN_FOLDER, filePath, sessionId, workspaceId)
   },
 
   previewFile: (filePath: string) => {
@@ -1107,6 +1140,10 @@ const electronAPI: ElectronAPI = {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.MOVE_ATTACHED_FILE, filePath, targetDir)
   },
 
+  deleteAttachedFile: (filePath: string) => {
+    return ipcRenderer.invoke(AGENT_IPC_CHANNELS.DELETE_ATTACHED_FILE, filePath)
+  },
+
   searchWorkspaceFiles: (rootPath: string, query: string, limit = 20, additionalPaths?: string[]) => {
     return ipcRenderer.invoke(AGENT_IPC_CHANNELS.SEARCH_WORKSPACE_FILES, rootPath, query, limit, additionalPaths)
   },
@@ -1162,18 +1199,6 @@ const electronAPI: ElectronAPI = {
 
   // ===== 飞书集成 =====
 
-  getFeishuConfig: () => {
-    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.GET_CONFIG)
-  },
-
-  getDecryptedFeishuSecret: () => {
-    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.GET_DECRYPTED_SECRET)
-  },
-
-  saveFeishuConfig: (input: FeishuConfigInput) => {
-    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.SAVE_CONFIG, input)
-  },
-
   testFeishuConnection: (appId: string, appSecret: string) => {
     return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.TEST_CONNECTION, appId, appSecret)
   },
@@ -1221,6 +1246,52 @@ const electronAPI: ElectronAPI = {
     ipcRenderer.on(FEISHU_IPC_CHANNELS.NOTIFICATION_SENT, listener)
     return () => { ipcRenderer.removeListener(FEISHU_IPC_CHANNELS.NOTIFICATION_SENT, listener) }
   },
+
+  // ===== 多飞书 Bot 管理 =====
+
+  listFeishuBots: () => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.LIST_BOTS)
+  },
+
+  saveFeishuBot: (input: FeishuBotConfigInput, existingId?: string) => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.SAVE_BOT, input, existingId)
+  },
+
+  deleteFeishuBot: (botId: string) => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.DELETE_BOT, botId)
+  },
+
+  startFeishuBot: (botId: string) => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.START_BOT, botId)
+  },
+
+  stopFeishuBot: (botId: string) => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.STOP_BOT, botId)
+  },
+
+  getFeishuBotStatus: (botId: string) => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.GET_BOT_STATUS, botId)
+  },
+
+  onFeishuBotStatusChanged: (callback: (status: FeishuBotStatus) => void) => {
+    const listener = (_event: Electron.IpcRendererEvent, status: FeishuBotStatus): void => callback(status)
+    ipcRenderer.on(FEISHU_IPC_CHANNELS.BOT_STATUS_CHANGED, listener)
+    return () => { ipcRenderer.removeListener(FEISHU_IPC_CHANNELS.BOT_STATUS_CHANGED, listener) }
+  },
+
+  // ===== Agent Persona =====
+
+  getAgentPersona: (workspaceSlug: string) => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.GET_AGENT_PERSONA, workspaceSlug)
+  },
+
+  saveAgentPersona: (workspaceSlug: string, persona: AgentPersona) => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.SAVE_AGENT_PERSONA, workspaceSlug, persona)
+  },
+
+  invalidatePersonaCache: (workspaceSlug?: string) => {
+    return ipcRenderer.invoke(FEISHU_IPC_CHANNELS.INVALIDATE_PERSONA_CACHE, workspaceSlug)
+  },
 }
 
 // 将 API 暴露到渲染进程的 window 对象上
diff --git a/apps/electron/src/renderer/atoms/agent-atoms.ts b/apps/electron/src/renderer/atoms/agent-atoms.ts
index 0be63051..1d7f986c 100644
--- a/apps/electron/src/renderer/atoms/agent-atoms.ts
+++ b/apps/electron/src/renderer/atoms/agent-atoms.ts
@@ -7,7 +7,7 @@
 
 import { atom } from 'jotai'
 import { atomFamily } from 'jotai/utils'
-import type { AgentSessionMeta, AgentMessage, AgentEvent, AgentWorkspace, AgentPendingFile, RetryAttempt, PromaPermissionMode, PermissionRequest, AskUserRequest, ThinkingConfig, AgentEffort, TaskUsage, AgentTeamData } from '@proma/shared'
+import type { AgentSessionMeta, AgentMessage, AgentEvent, AgentWorkspace, AgentPendingFile, RetryAttempt, PromaPermissionMode, PermissionRequest, AskUserRequest, ThinkingConfig, AgentEffort, TaskUsage, TeamRunConfig } from '@proma/shared'
 
 /** 活动状态 */
 export type ActivityStatus = 'pending' | 'running' | 'completed' | 'error' | 'backgrounded'
@@ -37,20 +37,6 @@ export interface ActivityGroup {
   children: ToolActivity[]
 }
 
-/** 子代理条目（从 ToolActivity 派生，用于侧面板展示 — TODO: 完善 Team UI 时启用） */
-export interface SubAgentEntry {
-  toolUseId: string
-  toolName: 'Task' | 'Agent'
-  subagentType?: string
-  description: string
-  teamName?: string
-  status: ActivityStatus
-  elapsedSeconds?: number
-  isBackground?: boolean
-  taskId?: string
-  childActivities: ToolActivity[]
-}
-
 /** Teammate 状态枚举 */
 export type TeammateStatus = 'running' | 'completed' | 'failed' | 'stopped'
 
@@ -78,12 +64,18 @@ export interface TeammateState {
   currentToolUseId?: string
   /** 已使用的工具历史记录（最近 N 个，去重） */
   toolHistory: string[]
-  /** 完成时的摘要 */
+  /** 完成时的摘要（AI 生成） */
   summary?: string
+  /** 子代理实际结果（从 tool_result 获取） */
+  result?: string
   /** 完成时输出文件路径 */
   outputFile?: string
   /** 累计用量 */
   usage?: TaskUsage
+  /** Agent 提示词（从 task_started.prompt 获取） */
+  prompt?: string
+  /** AI 生成的进度摘要（来自 task_progress.summary，~30s 更新） */
+  progressSummary?: string
   /** 开始时间戳 */
   startedAt: number
   /** 结束时间戳 */
@@ -93,6 +85,13 @@ export interface TeammateState {
 /** 工具历史最大记录数 */
 const MAX_TOOL_HISTORY = 20
 
+/** 从 teammate 描述/prompt 提取友好名称 */
+export function extractTeammateName(tm: TeammateState): string {
+  if (tm.description && tm.description.length < 80) return tm.description
+  if (tm.description) return tm.description.slice(0, 60) + '...'
+  return `Agent #${tm.index}`
+}
+
 /** 侧面板活跃 Tab */
 export type SidePanelTab = 'team' | 'files'
 
@@ -135,43 +134,11 @@ export function getActivityStatus(activity: ToolActivity): ActivityStatus {
   return 'completed'
 }
 
-/**
- * 合并同层 TodoWrite 活动：多次调用只保留最新 input，置底显示
- *
- * TodoWrite 每次调用都包含完整的 todo 列表，只需展示最新状态。
- */
-function mergeTodoWrites(activities: ToolActivity[]): ToolActivity[] {
-  const todoWrites: ToolActivity[] = []
-  const others: ToolActivity[] = []
-
-  for (const a of activities) {
-    if (a.toolName === 'TodoWrite') {
-      todoWrites.push(a)
-    } else {
-      others.push(a)
-    }
-  }
-
-  if (todoWrites.length === 0) return activities
-
-  const latest = todoWrites[todoWrites.length - 1]!
-  const allDone = todoWrites.every((t) => t.done)
-
-  const merged: ToolActivity = {
-    ...latest,
-    done: allDone,
-    isError: allDone && todoWrites.some((t) => t.isError),
-  }
-
-  return [...others, merged]
-}
-
 /**
  * 将扁平活动列表按 parentToolUseId 分组
  *
  * 返回顶层项（ActivityGroup | ToolActivity），
  * Task 类型的工具作为 group.parent，其子活动嵌套在 children 中。
- * 每层内 TodoWrite 合并去重并置底。
  */
 export function groupActivities(activities: ToolActivity[]): Array<ActivityGroup | ToolActivity> {
   // 过滤幽灵条目：tool_progress 创建的空 input 条目，完成后仍无内容
@@ -179,17 +146,16 @@ export function groupActivities(activities: ToolActivity[]): Array<ActivityGroup
     if (a.done && Object.keys(a.input).length === 0 && !a.result) return false
     return true
   })
-  const processed = mergeTodoWrites(filtered)
 
   const parentIds = new Set<string>()
-  for (const a of processed) {
+  for (const a of filtered) {
     if (a.toolName === 'Task') parentIds.add(a.toolUseId)
   }
 
   const childrenMap = new Map<string, ToolActivity[]>()
   const topLevel: Array<ActivityGroup | ToolActivity> = []
 
-  for (const a of processed) {
+  for (const a of filtered) {
     if (a.parentToolUseId && parentIds.has(a.parentToolUseId)) {
       const children = childrenMap.get(a.parentToolUseId) ?? []
       children.push(a)
@@ -202,7 +168,7 @@ export function groupActivities(activities: ToolActivity[]): Array<ActivityGroup
   return topLevel.map((item) => {
     if ('toolUseId' in item && parentIds.has(item.toolUseId)) {
       const children = childrenMap.get(item.toolUseId) ?? []
-      return { parent: item, children: mergeTodoWrites(children) } as ActivityGroup
+      return { parent: item, children } as ActivityGroup
     }
     return item
   })
@@ -213,217 +179,6 @@ export function isActivityGroup(item: ActivityGroup | ToolActivity): item is Act
   return 'parent' in item && 'children' in item
 }
 
-/**
- * 从 ToolActivity[] 构建 SubAgentEntry[]
- *
- * 将 Task/Agent 提取为顶层条目，
- * 其子活动（parentToolUseId 匹配）嵌套在 childActivities 中。
- */
-export function buildTeamActivityEntries(activities: ToolActivity[]): SubAgentEntry[] {
-  const subAgentIds = new Set<string>()
-  const entries: SubAgentEntry[] = []
-
-  // 第一遍：收集所有 Task/Agent 的 toolUseId
-  for (const a of activities) {
-    if (a.toolName === 'Task' || a.toolName === 'Agent') {
-      subAgentIds.add(a.toolUseId)
-    }
-  }
-
-  if (subAgentIds.size === 0) return []
-
-  // 第二遍：按 parentToolUseId 分组子活动
-  const childrenMap = new Map<string, ToolActivity[]>()
-  for (const a of activities) {
-    if (a.parentToolUseId && subAgentIds.has(a.parentToolUseId)) {
-      const children = childrenMap.get(a.parentToolUseId) ?? []
-      children.push(a)
-      childrenMap.set(a.parentToolUseId, children)
-    }
-  }
-
-  // 第三遍：构建 SubAgentEntry
-  for (const a of activities) {
-    if (a.toolName !== 'Task' && a.toolName !== 'Agent') continue
-
-    const description = typeof a.input.description === 'string'
-      ? a.input.description
-      : typeof a.input.prompt === 'string'
-        ? a.input.prompt
-        : a.intent ?? a.toolName
-
-    entries.push({
-      toolUseId: a.toolUseId,
-      toolName: a.toolName as 'Task' | 'Agent',
-      subagentType: typeof a.input.subagent_type === 'string' ? a.input.subagent_type : undefined,
-      description,
-      teamName: typeof a.input.team_name === 'string' ? a.input.team_name : undefined,
-      status: getActivityStatus(a),
-      elapsedSeconds: a.elapsedSeconds,
-      isBackground: a.isBackground,
-      taskId: a.taskId,
-      childActivities: childrenMap.get(a.toolUseId) ?? [],
-    })
-  }
-
-  return entries
-}
-
-// ============================================================================
-// Team Overview — 从 ToolActivity 提取丰富的团队信息
-// ============================================================================
-
-/** 团队全景信息（从工具调用事件提取） */
-export interface TeamOverview {
-  /** 团队名称（来自 TeamCreate） */
-  teamName?: string
-  /** 团队描述 */
-  teamDescription?: string
-  /** 任务看板项（来自 TaskCreate + TaskUpdate） */
-  tasks: TeamTaskItem[]
-  /** Agent 条目（来自 Agent tool_start） */
-  agents: TeamAgentInfo[]
-}
-
-/** 团队任务项 */
-export interface TeamTaskItem {
-  /** 任务编号（从 result 中解析） */
-  taskNumber?: string
-  /** 任务主题 */
-  subject: string
-  /** 任务描述 */
-  description?: string
-  /** 进行中标签 */
-  activeForm?: string
-  /** 被哪些任务阻塞 */
-  blockedBy: string[]
-  /** 状态（来自 TaskUpdate） */
-  status?: string
-  /** 工具调用 ID */
-  toolUseId: string
-}
-
-/** 团队 Agent 条目 */
-export interface TeamAgentInfo {
-  /** Agent 名称 */
-  name: string
-  /** 描述/角色 */
-  description: string
-  /** 所属团队 */
-  teamName?: string
-  /** Agent 类型 */
-  subagentType?: string
-  /** 是否后台运行 */
-  isBackground?: boolean
-  /** 对应的 toolUseId */
-  toolUseId: string
-  /** Agent 工具状态 */
-  status: ActivityStatus
-  /** 关联的 TeammateState（通过 toolUseId 匹配） */
-  teammate?: TeammateState
-}
-
-/**
- * 从 ToolActivity[] 和 TeammateState[] 提取团队全景信息
- *
- * 解析 TeamCreate、TaskCreate、TaskUpdate、Agent 工具调用，
- * 构建团队名称 + Task Board + Agent 列表。
- */
-export function extractTeamOverview(
-  activities: ToolActivity[],
-  teammates: TeammateState[],
-): TeamOverview | null {
-  let teamName: string | undefined
-  let teamDescription: string | undefined
-  const tasks: TeamTaskItem[] = []
-  const agents: TeamAgentInfo[] = []
-
-  // 按 toolUseId 建立 TeammateState 快速查找表
-  const teammateByToolUseId = new Map<string, TeammateState>()
-  for (const tm of teammates) {
-    if (tm.toolUseId) teammateByToolUseId.set(tm.toolUseId, tm)
-  }
-
-  for (const a of activities) {
-    switch (a.toolName) {
-      case 'TeamCreate': {
-        if (typeof a.input.team_name === 'string') teamName = a.input.team_name
-        if (typeof a.input.description === 'string') teamDescription = a.input.description
-        break
-      }
-
-      case 'TaskCreate': {
-        const subject = typeof a.input.subject === 'string' ? a.input.subject : ''
-        if (!subject) break
-        // 从 result 中解析任务编号（如 "Task #1 created successfully"）
-        let taskNumber: string | undefined
-        if (a.result) {
-          const match = a.result.match(/(?:Task\s+)?#(\d+)/i)
-          if (match) taskNumber = match[1]
-        }
-        tasks.push({
-          taskNumber,
-          subject,
-          description: typeof a.input.description === 'string' ? a.input.description : undefined,
-          activeForm: typeof a.input.activeForm === 'string' ? a.input.activeForm : undefined,
-          blockedBy: [],
-          toolUseId: a.toolUseId,
-        })
-        break
-      }
-
-      case 'TaskUpdate': {
-        const taskId = typeof a.input.taskId === 'string' ? a.input.taskId : undefined
-        if (!taskId) break
-        // 找到匹配的 task，合并数据
-        const task = tasks.find((t) => t.taskNumber === taskId)
-        if (task) {
-          if (Array.isArray(a.input.addBlockedBy)) {
-            for (const dep of a.input.addBlockedBy) {
-              if (typeof dep === 'string' && !task.blockedBy.includes(dep)) {
-                task.blockedBy.push(dep)
-              }
-            }
-          }
-          if (typeof a.input.status === 'string') {
-            task.status = a.input.status
-          }
-        }
-        break
-      }
-
-      case 'Agent': {
-        const name = typeof a.input.name === 'string' ? a.input.name : ''
-        const desc = typeof a.input.description === 'string'
-          ? a.input.description
-          : typeof a.input.prompt === 'string'
-            ? a.input.prompt
-            : ''
-        if (!name && !desc) break
-        agents.push({
-          name: name || 'Agent',
-          description: desc,
-          teamName: typeof a.input.team_name === 'string' ? a.input.team_name : undefined,
-          subagentType: typeof a.input.subagent_type === 'string' ? a.input.subagent_type : undefined,
-          isBackground: a.input.run_in_background === true,
-          toolUseId: a.toolUseId,
-          status: getActivityStatus(a),
-          teammate: teammateByToolUseId.get(a.toolUseId),
-        })
-        break
-      }
-
-      default:
-        break
-    }
-  }
-
-  // 无任何团队信息则返回 null
-  if (!teamName && tasks.length === 0 && agents.length === 0) return null
-
-  return { teamName, teamDescription, tasks, agents }
-}
-
 /**
  * 从持久化消息中重建 Team 数据
  *
@@ -433,99 +188,119 @@ export function extractTeamOverview(
 export function rebuildTeamDataFromMessages(messages: AgentMessage[]): {
   toolActivities: ToolActivity[]
   teammates: TeammateState[]
-  overview: TeamOverview | null
 } | null {
-  // 收集所有 assistant 消息中的 events
-  const allEvents: AgentEvent[] = []
-  for (const msg of messages) {
-    if (msg.events) allEvents.push(...msg.events)
-  }
-  if (allEvents.length === 0) return null
-
-  // 重建 ToolActivity[]
+  // 重建 ToolActivity[]（按 toolUseId 去重，避免重复 key 警告）
   const toolActivities: ToolActivity[] = []
-  for (const event of allEvents) {
-    if (event.type === 'tool_start') {
-      toolActivities.push({
-        toolUseId: event.toolUseId,
-        toolName: event.toolName,
-        input: event.input ?? {},
-        intent: event.intent,
-        displayName: event.displayName,
-        done: false,
-        parentToolUseId: event.parentToolUseId,
-      })
-    } else if (event.type === 'tool_result') {
-      const idx = toolActivities.findIndex((t) => t.toolUseId === event.toolUseId)
-      if (idx >= 0) {
-        toolActivities[idx] = {
-          ...toolActivities[idx]!,
-          result: event.result,
-          isError: event.isError,
-          done: true,
-        }
-      }
-    }
-  }
+  const seenToolUseIds = new Set<string>()
 
-  // 重建 TeammateState[]
+  // 重建 TeammateState[]（按 taskId 去重）
   const teammates: TeammateState[] = []
-  for (const event of allEvents) {
-    if (event.type === 'task_started') {
-      teammates.push({
-        taskId: event.taskId,
-        toolUseId: event.toolUseId,
-        description: event.description,
-        taskType: event.taskType,
-        index: teammates.length + 1,
-        status: 'running',
-        toolHistory: [],
-        startedAt: Date.now(),
-      })
-    } else if (event.type === 'task_progress' && event.taskId) {
-      const idx = teammates.findIndex((t) => t.taskId === event.taskId)
-      if (idx >= 0) {
-        const tm = teammates[idx]!
-        teammates[idx] = {
-          ...tm,
-          progressDescription: event.description ?? tm.progressDescription,
-          usage: event.usage ?? tm.usage,
-          ...(event.lastToolName && {
-            currentToolName: event.lastToolName,
-            currentToolElapsedSeconds: event.elapsedSeconds,
-            toolHistory: appendToolHistory(tm.toolHistory, event.lastToolName),
-          }),
+  const seenTaskIds = new Set<string>()
+
+  let hasTeamActivity = false
+
+  // 按消息顺序处理，使用消息的 createdAt 作为时间戳
+  for (const msg of messages) {
+    if (!msg.events) continue
+    const msgTimestamp = msg.createdAt
+
+    for (const event of msg.events) {
+      // 处理 ToolActivity 相关事件
+      if (event.type === 'tool_start') {
+        if (seenToolUseIds.has(event.toolUseId)) continue
+        seenToolUseIds.add(event.toolUseId)
+        toolActivities.push({
+          toolUseId: event.toolUseId,
+          toolName: event.toolName,
+          input: event.input ?? {},
+          intent: event.intent,
+          displayName: event.displayName,
+          done: false,
+          parentToolUseId: event.parentToolUseId,
+        })
+        if (event.toolName === 'Task' || event.toolName === 'Agent') {
+          hasTeamActivity = true
+        }
+      } else if (event.type === 'tool_result') {
+        const idx = toolActivities.findIndex((t) => t.toolUseId === event.toolUseId)
+        if (idx >= 0) {
+          toolActivities[idx] = {
+            ...toolActivities[idx]!,
+            result: event.result,
+            isError: event.isError,
+            done: true,
+          }
+        }
+        // 如果是 Task 工具，将结果保存到对应的 teammate
+        if (event.toolName === 'Task' || event.toolName === 'Agent') {
+          const tmIdx = teammates.findIndex((t) => t.toolUseId === event.toolUseId)
+          if (tmIdx >= 0) {
+            teammates[tmIdx] = {
+              ...teammates[tmIdx]!,
+              result: event.result,
+            }
+          }
         }
       }
-    } else if (event.type === 'task_notification') {
-      const idx = teammates.findIndex((t) => t.taskId === event.taskId)
-      if (idx >= 0) {
-        const tm = teammates[idx]!
-        teammates[idx] = {
-          ...tm,
-          status: event.status,
-          summary: event.summary,
-          outputFile: event.outputFile,
-          endedAt: Date.now(),
-          ...(event.usage && { usage: event.usage }),
-          currentToolName: undefined,
-          currentToolElapsedSeconds: undefined,
-          currentToolUseId: undefined,
+
+      // 处理 Teammate 相关事件
+      if (event.type === 'task_started') {
+        if (seenTaskIds.has(event.taskId)) continue
+        seenTaskIds.add(event.taskId)
+        teammates.push({
+          taskId: event.taskId,
+          toolUseId: event.toolUseId,
+          description: event.description,
+          taskType: event.taskType,
+          prompt: event.prompt,
+          index: teammates.length + 1,
+          status: 'running',
+          toolHistory: [],
+          startedAt: msgTimestamp, // 使用消息的真实时间戳
+        })
+        hasTeamActivity = true
+      } else if (event.type === 'task_progress' && event.taskId) {
+        const idx = teammates.findIndex((t) => t.taskId === event.taskId)
+        if (idx >= 0) {
+          const tm = teammates[idx]!
+          teammates[idx] = {
+            ...tm,
+            progressDescription: event.description ?? tm.progressDescription,
+            progressSummary: event.summary ?? tm.progressSummary,
+            usage: event.usage ?? tm.usage,
+            ...(event.lastToolName && {
+              currentToolName: event.lastToolName,
+              currentToolElapsedSeconds: event.elapsedSeconds,
+              toolHistory: appendToolHistory(tm.toolHistory, event.lastToolName),
+            }),
+          }
         }
+      } else if (event.type === 'task_notification') {
+        const idx = teammates.findIndex((t) => t.taskId === event.taskId)
+        if (idx >= 0) {
+          const tm = teammates[idx]!
+          teammates[idx] = {
+            ...tm,
+            status: event.status,
+            summary: event.summary,
+            // 条件更新：只在有值时才更新，防止 undefined 覆盖之前的值
+            ...(event.outputFile && { outputFile: event.outputFile }),
+            // 直接使用 SDK 提供的 durationMs 计算 endedAt
+            endedAt: tm.startedAt + (event.usage?.durationMs ?? 0),
+            ...(event.usage && { usage: event.usage }),
+            currentToolName: undefined,
+            currentToolElapsedSeconds: undefined,
+            currentToolUseId: undefined,
+          }
+        }
+        hasTeamActivity = true
       }
     }
   }
 
-  // 检查是否有团队活动
-  const hasTeamActivity = toolActivities.some((a) =>
-    a.toolName === 'TeamCreate' || a.toolName === 'TaskCreate' ||
-    a.toolName === 'Agent' || a.toolName === 'Task',
-  ) || teammates.length > 0
-
   if (!hasTeamActivity) return null
 
-  const overview = extractTeamOverview(toolActivities, teammates)
-  return { toolActivities, teammates, overview }
+  return { toolActivities, teammates }
 }
 
 /** 待自动发送的 Agent 提示（从设置页"对话完成配置"触发） */
@@ -541,6 +316,8 @@ export const agentWorkspacesAtom = atom<AgentWorkspace[]>([])
 export const currentAgentWorkspaceIdAtom = atom<string | null>(null)
 export const agentChannelIdAtom = atom<string | null>(null)
 export const agentModelIdAtom = atom<string | null>(null)
+/** Agent 启用的渠道 ID 列表（多选） */
+export const agentEnabledChannelIdsAtom = atom<string[]>([])
 export const currentAgentSessionIdAtom = atom<string | null>(null)
 export const currentAgentMessagesAtom = atom<AgentMessage[]>([])
 export const agentStreamingStatesAtom = atom<Map<string, AgentStreamState>>(new Map())
@@ -563,35 +340,17 @@ export const agentSidePanelOpenMapAtom = atom<Map<string, boolean>>(new Map())
 /** 侧面板当前活跃 Tab（per-session Map） */
 export const agentSidePanelTabMapAtom = atom<Map<string, SidePanelTab>>(new Map())
 
-/**
- * Team 活动缓存 — 以 sessionId 为 key
- *
- * 流式完成后 agentStreamingStatesAtom 会被清除，
- * 此缓存在清除前保存 Team 活动数据，确保面板内容不丢失。
- */
-export const cachedTeamActivitiesAtom = atom<Map<string, SubAgentEntry[]>>(new Map())
-
-/**
- * Teammate 状态缓存 — 以 sessionId 为 key
- *
- * 流式完成后保存 teammates 快照，确保切换会话后面板数据不丢失。
+/** 本会话文件拖拽区域是否已收起（per-session Map）
+ * 
+ * 用于控制本会话文件区域的 FileDropZone 显示。
+ * 与 workspaceFilesVersionAtom 独立，避免工作区文件变化影响本会话文件的上传提示。
  */
-export const cachedTeammateStatesAtom = atom<Map<string, TeammateState[]>>(new Map())
+export const agentSessionDropZoneDismissedAtom = atom<Map<string, boolean>>(new Map())
 
-/**
- * TeamOverview 缓存 — 以 sessionId 为 key
- *
- * 流式完成后保存 TeamOverview 快照，确保切换 tab 后团队全景数据不丢失。
- */
-export const cachedTeamOverviewsAtom = atom<Map<string, TeamOverview>>(new Map())
+// ===== 子代理配置 Atoms =====
 
-/**
- * 轮询数据缓存 — 以 sessionId 为 key
- *
- * 缓存文件系统轮询得到的 AgentTeamData（tasks + inboxes），
- * 防止组件卸载后通信时间线等数据丢失。
- */
-export const cachedPolledTeamDataAtom = atom<Map<string, AgentTeamData>>(new Map())
+/** 是否启用子代理（Task 工具） */
+export const enableSubAgentsAtom = atom<boolean>(true)
 
 /**
  * 已关闭 Team 面板的 sessionId 集合
@@ -601,58 +360,27 @@ export const cachedPolledTeamDataAtom = atom<Map<string, AgentTeamData>>(new Map
  */
 export const dismissedTeamSessionIdsAtom = atom<Set<string>>(new Set<string>())
 
-/** 当前会话是否有 Team/Task 活动（派生只读原子，同时检查流式状态和缓存） */
+/** 当前会话是否有 Team/Task 活动（基于 teammates 判断） */
 export const hasTeamActivityAtom = atom<boolean>((get) => {
   const currentId = get(currentAgentSessionIdAtom)
   if (!currentId) return false
   if (get(dismissedTeamSessionIdsAtom).has(currentId)) return false
-  // 优先检查流式状态
-  const state = get(agentStreamingStatesAtom).get(currentId)
-  if (state) {
-    const hasActivity = state.toolActivities.some(
-      (a) => a.toolName === 'Task' || a.toolName === 'Agent'
-    )
-    if (hasActivity) return true
-  }
-  // 回退到缓存（流式状态无 Team 活动或不存在时）
-  const cached = get(cachedTeamActivitiesAtom).get(currentId)
-  return cached !== undefined && cached.length > 0
-})
-
-/** 当前会话的 Team 活动数据（派生只读原子，同时读取流式状态和缓存） */
-export const teamActivityEntriesAtom = atom<SubAgentEntry[]>((get) => {
-  const currentId = get(currentAgentSessionIdAtom)
-  if (!currentId) return []
-  if (get(dismissedTeamSessionIdsAtom).has(currentId)) return []
-  // 优先使用流式状态
   const state = get(agentStreamingStatesAtom).get(currentId)
-  if (state && state.toolActivities.length > 0) {
-    const entries = buildTeamActivityEntries(state.toolActivities)
-    if (entries.length > 0) return entries
-  }
-  // 回退到缓存
-  return get(cachedTeamActivitiesAtom).get(currentId) ?? []
+  if (!state) return false
+  return state.teammates.length > 0
 })
 
-/** 运行中的子代理数量（用于 badge 指示器） */
-export const teamActivityCountAtom = atom<number>((get) => {
-  const entries = get(teamActivityEntriesAtom)
-  return entries.filter((e) => e.status === 'running' || e.status === 'backgrounded').length
-})
-
-/** 当前会话的 teammate 状态列表（派生只读原子，优先流式状态，回退缓存） */
+/** 当前会话的 teammate 状态列表（派生只读原子，从 agentStreamingStatesAtom 读取） */
 export const teammateStatesAtom = atom<TeammateState[]>((get) => {
   const currentId = get(currentAgentSessionIdAtom)
   if (!currentId) return []
   if (get(dismissedTeamSessionIdsAtom).has(currentId)) return []
-  // 优先使用流式状态中的 teammates
   const state = get(agentStreamingStatesAtom).get(currentId)
-  if (state && state.teammates.length > 0) return state.teammates
-  // 回退到缓存
-  return get(cachedTeammateStatesAtom).get(currentId) ?? []
+  if (!state) return []
+  return state.teammates
 })
 
-/** 是否有 teammate 活动（综合检查流式状态和缓存） */
+/** 是否有 teammate 活动 */
 export const hasTeammatesAtom = atom<boolean>((get) => {
   return get(teammateStatesAtom).length > 0
 })
@@ -662,20 +390,6 @@ export const runningTeammateCountAtom = atom<number>((get) => {
   return get(teammateStatesAtom).filter((t) => t.status === 'running').length
 })
 
-/** 团队全景信息（派生只读原子，从 toolActivities + teammates 提取，回退到缓存） */
-export const teamOverviewAtom = atom<TeamOverview | null>((get) => {
-  const currentId = get(currentAgentSessionIdAtom)
-  if (!currentId) return null
-  if (get(dismissedTeamSessionIdsAtom).has(currentId)) return null
-  const state = get(agentStreamingStatesAtom).get(currentId)
-  if (state) {
-    const overview = extractTeamOverview(state.toolActivities, state.teammates)
-    if (overview) return overview
-  }
-  // 回退到缓存（流式状态无 Team 数据或不存在时）
-  return get(cachedTeamOverviewsAtom).get(currentId) ?? null
-})
-
 // ===== 权限系统 Atoms =====
 
 /** 当前工作区权限模式 */
@@ -853,15 +567,33 @@ export function applyAgentEvent(
       }
     }
 
-    case 'tool_result':
+    case 'tool_result': {
+      // 更新 toolActivities
+      const nextActivities = prev.toolActivities.map((t) =>
+        t.toolUseId === event.toolUseId
+          ? { ...t, result: event.result, isError: event.isError, done: true, imageAttachments: event.imageAttachments }
+          : t
+      )
+      
+      // 如果是 Task 工具，将结果保存到对应的 teammate
+      let nextTeammates = prev.teammates
+      if (event.toolName === 'Task' || event.toolName === 'Agent') {
+        const tmIdx = prev.teammates.findIndex((t) => t.toolUseId === event.toolUseId)
+        if (tmIdx >= 0) {
+          nextTeammates = [...prev.teammates]
+          nextTeammates[tmIdx] = {
+            ...nextTeammates[tmIdx]!,
+            result: event.result,
+          }
+        }
+      }
+      
       return {
         ...prev,
-        toolActivities: prev.toolActivities.map((t) =>
-          t.toolUseId === event.toolUseId
-            ? { ...t, result: event.result, isError: event.isError, done: true, imageAttachments: event.imageAttachments }
-            : t
-        ),
+        toolActivities: nextActivities,
+        teammates: nextTeammates,
       }
+    }
 
     case 'task_backgrounded':
       return {
@@ -882,6 +614,7 @@ export function applyAgentEvent(
           const updatedTm: TeammateState = {
             ...tm,
             progressDescription: event.description ?? tm.progressDescription,
+            progressSummary: event.summary ?? tm.progressSummary,
             usage: event.usage ?? tm.usage,
             // 更新当前工具名和计时（来自 tool_progress 或 system task_progress）
             ...(event.lastToolName && {
@@ -921,11 +654,27 @@ export function applyAgentEvent(
     case 'task_started': {
       // 查找匹配 toolUseId 的 ToolActivity，更新 intent 和 taskId
       let nextActivities = prev.toolActivities
-      if (event.toolUseId) {
-        const idx = prev.toolActivities.findIndex((t) => t.toolUseId === event.toolUseId)
+      let resolvedToolUseId = event.toolUseId // 局部变量，不修改 event
+
+      if (resolvedToolUseId) {
+        // 通过 toolUseId 匹配并存储 taskId
+        const idx = prev.toolActivities.findIndex((t) => t.toolUseId === resolvedToolUseId)
         if (idx >= 0) {
           nextActivities = prev.toolActivities.map((t) =>
-            t.toolUseId === event.toolUseId
+            t.toolUseId === resolvedToolUseId
+              ? { ...t, intent: event.description, taskId: event.taskId }
+              : t
+          )
+        }
+      } else {
+        // SDK 未提供 toolUseId：启发式匹配最近的未关联子代理 ToolActivity
+        const unlinkedTask = prev.toolActivities.find(
+          (t) => (t.toolName === 'Task' || t.toolName === 'Agent') && !t.done && !t.taskId
+        )
+        if (unlinkedTask) {
+          resolvedToolUseId = unlinkedTask.toolUseId
+          nextActivities = prev.toolActivities.map((t) =>
+            t.toolUseId === resolvedToolUseId
               ? { ...t, intent: event.description, taskId: event.taskId }
               : t
           )
@@ -935,12 +684,13 @@ export function applyAgentEvent(
       if (prev.teammates.some((t) => t.taskId === event.taskId)) {
         return { ...prev, toolActivities: nextActivities }
       }
-      // 创建 TeammateState
+      // 创建 TeammateState（使用解析后的 resolvedToolUseId）
       const newTeammate: TeammateState = {
         taskId: event.taskId,
-        toolUseId: event.toolUseId,
+        toolUseId: resolvedToolUseId,
         description: event.description,
         taskType: event.taskType,
+        prompt: event.prompt,
         index: prev.teammates.length + 1,
         status: 'running',
         toolHistory: [],
@@ -987,7 +737,8 @@ export function applyAgentEvent(
         ...nextTeammates[tmIdx]!,
         status: event.status,
         summary: event.summary,
-        outputFile: event.outputFile,
+        // 条件更新：只在有值时才更新，防止 undefined 覆盖之前的值
+        ...(event.outputFile && { outputFile: event.outputFile }),
         endedAt: Date.now(),
         ...(event.usage && { usage: event.usage }),
         // 任务结束后清除实时工具状态
@@ -995,7 +746,39 @@ export function applyAgentEvent(
         currentToolElapsedSeconds: undefined,
         currentToolUseId: undefined,
       }
-      return { ...prev, teammates: nextTeammates }
+
+      // 同步更新对应的 ToolActivity.done（避免 spinner 在子代理完成后仍然转圈）
+      const isTerminal = event.status === 'completed' || event.status === 'failed' || event.status === 'stopped'
+      let nextActivities = prev.toolActivities
+
+      if (isTerminal) {
+        // 策略 1: 通过 toolUseId 直接匹配
+        // 注意：后台任务（isBackground）的 done 已被 task_backgrounded 设为 true，
+        // 但仍需在 task_notification 时清除 isBackground 标记以正确显示完成状态
+        const notifToolUseId = event.toolUseId ?? nextTeammates[tmIdx]!.toolUseId
+        let matched = false
+        if (notifToolUseId) {
+          const hasMatch = prev.toolActivities.some((t) => t.toolUseId === notifToolUseId && (!t.done || t.isBackground))
+          if (hasMatch) {
+            nextActivities = prev.toolActivities.map((t) =>
+              t.toolUseId === notifToolUseId && (!t.done || t.isBackground)
+                ? { ...t, done: true, isBackground: false, isError: event.status === 'failed' }
+                : t
+            )
+            matched = true
+          }
+        }
+        // 策略 2: 通过 taskId 匹配（task_started 中已在 ToolActivity 上设置 taskId）
+        if (!matched) {
+          nextActivities = prev.toolActivities.map((t) =>
+            t.taskId === event.taskId && (!t.done || t.isBackground)
+              ? { ...t, done: true, isBackground: false, isError: event.status === 'failed' }
+              : t
+          )
+        }
+      }
+
+      return { ...prev, teammates: nextTeammates, toolActivities: nextActivities }
     }
 
     case 'tool_use_summary':
@@ -1013,9 +796,13 @@ export function applyAgentEvent(
       // 等待 STREAM_COMPLETE IPC 回调通过删除流式状态来控制 UI 就绪状态
       // 这避免了用户在后端尚未完成清理时就能发送新消息的竞态条件
       // 同时将仍 running 的 teammates 标记为 stopped（兜底）
+      // 并将所有未完成的 ToolActivity 标记为 done（兜底）
       return {
         ...prev,
         retrying: undefined,
+        toolActivities: prev.toolActivities.map((t) =>
+          t.done ? t : { ...t, done: true }
+        ),
         teammates: prev.teammates.map((tm) =>
           tm.status === 'running'
             ? { ...tm, status: 'stopped' as const, endedAt: Date.now(), currentToolName: undefined, currentToolElapsedSeconds: undefined, currentToolUseId: undefined }
@@ -1114,6 +901,11 @@ export function applyAgentEvent(
       // 提示建议由全局监听器处理，不影响流式状态
       return prev
 
+    case 'todo_update': {
+      // 待办事项更新事件由专门的 atoms 处理，不影响流式状态
+      return prev
+    }
+
     default:
       return prev
   }
@@ -1165,14 +957,7 @@ export const currentAgentErrorAtom = atom<string | null>((get) => {
 export const agentSessionDraftsAtom = atom<Map<string, string>>(new Map())
 
 /**
- * 会话附加目录 Map — 以 sessionId 为 key
- * 存储每个会话通过"附加文件夹"功能关联的外部目录路径列表。
- * 这些路径作为 SDK additionalDirectories 参数传递。
- */
-export const agentAttachedDirectoriesMapAtom = atom<Map<string, string[]>>(new Map())
-
-/**
- * 工作区级附加目录列表（按 workspaceId 存储）
+ * 工作区级关联目录列表（按 workspaceId 存储）
  *
  * 工作区内所有会话共享这些附加目录。
  */
@@ -1243,3 +1028,63 @@ export interface BackgroundTask {
 export const backgroundTasksAtomFamily = atomFamily((sessionId: string) =>
   atom<BackgroundTask[]>([])
 )
+
+// ===== 待办事项列表（Todo List）=====
+
+import type { TodoItem, TodoGroup } from '@proma/shared'
+export type { TodoItem, TodoGroup }
+
+/** 待办事项组状态（扩展 TodoGroup，添加 UI 状态） */
+export interface TodoGroupState extends TodoGroup {
+  /** 用户是否手动关闭 */
+  isDismissed?: boolean
+}
+
+/** 会话的待办事项组 Map（sessionId -> groupId -> TodoGroupState） */
+export const agentTodoGroupsMapAtom = atom<Map<string, Map<string, TodoGroupState>>>(new Map())
+
+/** 当前会话的活动待办事项组（未关闭且未完成的） */
+export const currentSessionActiveTodosAtom = atom<TodoGroupState[]>((get) => {
+  const currentId = get(currentAgentSessionIdAtom)
+  if (!currentId) return []
+  const sessionMap = get(agentTodoGroupsMapAtom).get(currentId)
+  if (!sessionMap) return []
+  return Array.from(sessionMap.values())
+    .filter(g => !g.isDismissed && !g.isCompleted)
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+})
+
+/** 当前会话是否有活动待办事项 */
+export const hasActiveTodosAtom = atom<boolean>((get) => {
+  return get(currentSessionActiveTodosAtom).length > 0
+})
+
+/** 关闭待办事项组的 action */
+export const dismissTodoGroupAtom = atom(
+  null,
+  (get, set, { sessionId, groupId }: { sessionId: string; groupId: string }) => {
+    set(agentTodoGroupsMapAtom, (prev) => {
+      const next = new Map(prev)
+      const sessionMap = next.get(sessionId)
+      if (sessionMap) {
+        const group = sessionMap.get(groupId)
+        if (group) {
+          sessionMap.set(groupId, { ...group, isDismissed: true })
+        }
+      }
+      return next
+    })
+  }
+)
+
+/** 清除会话所有待办事项的 action */
+export const clearSessionTodosAtom = atom(
+  null,
+  (get, set, sessionId: string) => {
+    set(agentTodoGroupsMapAtom, (prev) => {
+      const next = new Map(prev)
+      next.delete(sessionId)
+      return next
+    })
+  }
+)
diff --git a/apps/electron/src/renderer/atoms/app-mode.ts b/apps/electron/src/renderer/atoms/app-mode.ts
index 956d05c4..a4a67d96 100644
--- a/apps/electron/src/renderer/atoms/app-mode.ts
+++ b/apps/electron/src/renderer/atoms/app-mode.ts
@@ -11,3 +11,9 @@ export type AppMode = 'chat' | 'agent'
 
 /** App 模式，自动持久化到 localStorage */
 export const appModeAtom = atomWithStorage<AppMode>('proma-app-mode', 'chat')
+
+/** 追踪 Chat 模式最近活跃的 Tab ID */
+export const lastActiveChatTabIdAtom = atomWithStorage<string | null>('proma-last-active-chat-tab', null)
+
+/** 追踪 Agent 模式最近活跃的 Tab ID */
+export const lastActiveAgentTabIdAtom = atomWithStorage<string | null>('proma-last-active-agent-tab', null)
diff --git a/apps/electron/src/renderer/atoms/chat-message-layout.ts b/apps/electron/src/renderer/atoms/chat-message-layout.ts
new file mode 100644
index 00000000..d537a576
--- /dev/null
+++ b/apps/electron/src/renderer/atoms/chat-message-layout.ts
@@ -0,0 +1,69 @@
+/**
+ * 消息布局模式状态原子
+ *
+ * 管理会话消息显示模式：
+ * - left-aligned: 消息气泡左对齐（当前应用中的形式）
+ * - left-right: 消息气泡左右分布（类似微信，自己发在右边，AI发在左边）
+ *
+ * 使用 localStorage 作为缓存，避免页面加载时闪烁。
+ */
+
+import { atom } from 'jotai'
+import type { ChatMessageLayout } from '../../types'
+
+/** localStorage 缓存键 */
+const LAYOUT_CACHE_KEY = 'proma-chat-message-layout'
+
+/**
+ * 从 localStorage 读取缓存的消息布局模式
+ */
+function getCachedLayout(): ChatMessageLayout {
+  try {
+    const cached = localStorage.getItem(LAYOUT_CACHE_KEY)
+    if (cached === 'left-aligned' || cached === 'left-right') {
+      return cached
+    }
+  } catch {
+    // localStorage 不可用时忽略
+  }
+  return 'left-aligned'
+}
+
+/**
+ * 缓存消息布局模式到 localStorage
+ */
+function cacheLayout(layout: ChatMessageLayout): void {
+  try {
+    localStorage.setItem(LAYOUT_CACHE_KEY, layout)
+  } catch {
+    // localStorage 不可用时忽略
+  }
+}
+
+/** 消息布局模式原子 */
+export const chatMessageLayoutAtom = atom<ChatMessageLayout>(getCachedLayout())
+
+/**
+ * 初始化消息布局设置
+ *
+ * 从主进程加载持久化设置。
+ */
+export async function initializeChatMessageLayout(
+  setLayout: (layout: ChatMessageLayout) => void,
+): Promise<void> {
+  // 从主进程加载持久化设置
+  const settings = await window.electronAPI.getSettings()
+  const layout = settings.chatMessageLayout ?? 'left-aligned'
+  setLayout(layout)
+  cacheLayout(layout)
+}
+
+/**
+ * 更新消息布局模式并持久化
+ *
+ * 同时更新 localStorage 缓存和主进程配置文件。
+ */
+export async function updateChatMessageLayout(layout: ChatMessageLayout): Promise<void> {
+  cacheLayout(layout)
+  await window.electronAPI.updateSettings({ chatMessageLayout: layout })
+}
diff --git a/apps/electron/src/renderer/atoms/feishu-atoms.ts b/apps/electron/src/renderer/atoms/feishu-atoms.ts
index 7259e72f..7872f128 100644
--- a/apps/electron/src/renderer/atoms/feishu-atoms.ts
+++ b/apps/electron/src/renderer/atoms/feishu-atoms.ts
@@ -5,9 +5,15 @@
  */
 
 import { atom } from 'jotai'
-import type { FeishuBridgeState, FeishuNotifyMode, FeishuChatBinding } from '@proma/shared'
+import type {
+  FeishuBridgeState,
+  FeishuNotifyMode,
+  FeishuChatBinding,
+  FeishuBotConfig,
+  FeishuBotStatus,
+} from '@proma/shared'
 
-/** 飞书 Bridge 连接状态 */
+/** 飞书 Bridge 连接状态（单 Bot 兼容） */
 export const feishuBridgeStateAtom = atom<FeishuBridgeState>({
   status: 'disconnected',
   activeBindings: 0,
@@ -24,3 +30,17 @@ export const feishuConnectedAtom = atom((get) => get(feishuBridgeStateAtom).stat
 
 /** 飞书聊天绑定列表 */
 export const feishuBindingsAtom = atom<FeishuChatBinding[]>([])
+
+// ===== 多飞书 Bot 支持 =====
+
+/** 飞书 Bots 配置列表 */
+export const feishuBotsAtom = atom<FeishuBotConfig[]>([])
+
+/** 飞书 Bots 状态 Map<botId, FeishuBotStatus> */
+export const feishuBotStatusesAtom = atom<Map<string, FeishuBotStatus>>(new Map())
+
+/** 当前选中的 Bot ID（用于设置面板） */
+export const feishuSelectedBotIdAtom = atom<string | null>(null)
+
+/** 是否已从旧配置迁移 */
+export const feishuMigratedAtom = atom<boolean>(false)
diff --git a/apps/electron/src/renderer/atoms/index.ts b/apps/electron/src/renderer/atoms/index.ts
index 184f92fc..b694de2f 100644
--- a/apps/electron/src/renderer/atoms/index.ts
+++ b/apps/electron/src/renderer/atoms/index.ts
@@ -9,3 +9,4 @@ export * from './settings-tab'
 export * from './chat-atoms'
 export * from './user-profile'
 export * from './theme'
+export * from './message-bubble-colors'
diff --git a/apps/electron/src/renderer/atoms/message-bubble-colors.ts b/apps/electron/src/renderer/atoms/message-bubble-colors.ts
new file mode 100644
index 00000000..ffc7d116
--- /dev/null
+++ b/apps/electron/src/renderer/atoms/message-bubble-colors.ts
@@ -0,0 +1,75 @@
+/**
+ * 消息气泡颜色状态管理
+ *
+ * 管理用户和 AI 消息气泡的自定义背景颜色。
+ * 使用 CSS 变量实现即时预览，持久化到 ~/.proma/settings.json
+ */
+
+import { atom } from 'jotai'
+import { DEFAULT_MESSAGE_BUBBLE_COLORS } from '../../types'
+import type { MessageBubbleColors } from '../../types'
+
+/** 消息气泡颜色状态 */
+export const messageBubbleColorsAtom = atom<MessageBubbleColors>(DEFAULT_MESSAGE_BUBBLE_COLORS)
+
+/** CSS 变量名常量 */
+const CSS_VAR_USER_MESSAGE = '--user-message-bg'
+const CSS_VAR_ASSISTANT_MESSAGE = '--assistant-message-bg'
+
+/**
+ * 应用颜色配置到 DOM CSS 变量
+ * 注意：当颜色为空字符串时，移除 CSS 变量以让 CSS 使用回退值
+ */
+function applyColorsToDOM(colors: MessageBubbleColors): void {
+  const root = document.documentElement
+  
+  if (colors.userMessageColor) {
+    root.style.setProperty(CSS_VAR_USER_MESSAGE, colors.userMessageColor)
+  } else {
+    root.style.removeProperty(CSS_VAR_USER_MESSAGE)
+  }
+  
+  if (colors.assistantMessageColor) {
+    root.style.setProperty(CSS_VAR_ASSISTANT_MESSAGE, colors.assistantMessageColor)
+  } else {
+    root.style.removeProperty(CSS_VAR_ASSISTANT_MESSAGE)
+  }
+}
+
+/**
+ * 初始化消息气泡颜色
+ * 从主进程加载设置并应用到 DOM
+ */
+export async function initializeMessageBubbleColors(
+  setColors: (colors: MessageBubbleColors) => void,
+): Promise<void> {
+  const settings = await window.electronAPI.getSettings()
+  const colors = settings.messageBubbleColors ?? DEFAULT_MESSAGE_BUBBLE_COLORS
+  setColors(colors)
+  applyColorsToDOM(colors)
+}
+
+/**
+ * 更新消息气泡颜色
+ * 更新设置、持久化到文件，并应用到 DOM
+ */
+export async function updateMessageBubbleColors(
+  updates: Partial<MessageBubbleColors>,
+): Promise<void> {
+  const settings = await window.electronAPI.getSettings()
+  const updated: MessageBubbleColors = {
+    userMessageColor: settings.messageBubbleColors?.userMessageColor ?? '',
+    assistantMessageColor: settings.messageBubbleColors?.assistantMessageColor ?? '',
+    ...updates,
+  }
+  await window.electronAPI.updateSettings({ messageBubbleColors: updated })
+  applyColorsToDOM(updated)
+}
+
+/**
+ * 重置消息气泡颜色为默认值
+ */
+export async function resetMessageBubbleColors(): Promise<void> {
+  await window.electronAPI.updateSettings({ messageBubbleColors: DEFAULT_MESSAGE_BUBBLE_COLORS })
+  applyColorsToDOM(DEFAULT_MESSAGE_BUBBLE_COLORS)
+}
diff --git a/apps/electron/src/renderer/atoms/settings-tab.ts b/apps/electron/src/renderer/atoms/settings-tab.ts
index e6cad945..4fe4f7b3 100644
--- a/apps/electron/src/renderer/atoms/settings-tab.ts
+++ b/apps/electron/src/renderer/atoms/settings-tab.ts
@@ -11,7 +11,7 @@
 
 import { atom } from 'jotai'
 
-export type SettingsTab = 'general' | 'channels' | 'proxy' | 'appearance' | 'about' | 'agent' | 'prompts' | 'tools' | 'feishu' | 'tutorial'
+export type SettingsTab = 'general' | 'channels' | 'proxy' | 'appearance' | 'about' | 'agent' | 'prompts' | 'tools' | 'tutorial' | 'feishu-bots'
 
 /** 当前设置标签页（不持久化，每次打开设置默认显示渠道） */
 export const settingsTabAtom = atom<SettingsTab>('channels')
diff --git a/apps/electron/src/renderer/components/agent/AgentHeader.tsx b/apps/electron/src/renderer/components/agent/AgentHeader.tsx
index 0af58660..dc362937 100644
--- a/apps/electron/src/renderer/components/agent/AgentHeader.tsx
+++ b/apps/electron/src/renderer/components/agent/AgentHeader.tsx
@@ -1,14 +1,14 @@
 /**
  * AgentHeader — Agent 会话头部
  *
- * 显示会话标题（可点击编辑）。
- * 参照 ChatHeader 的编辑模式。
+ * 显示会话标题（可点击编辑）+ 团队模式配置入口。
  */
 
 import * as React from 'react'
 import { useAtomValue, useSetAtom } from 'jotai'
 import { Pencil, Check, X } from 'lucide-react'
-import { agentSessionsAtom } from '@/atoms/agent-atoms'
+import { agentSessionsAtom, enableSubAgentsAtom } from '@/atoms/agent-atoms'
+
 
 /** AgentHeader 属性接口 */
 interface AgentHeaderProps {
@@ -105,6 +105,9 @@ export function AgentHeader({ sessionId }: AgentHeaderProps): React.ReactElement
           >
             <Pencil className="size-3.5" />
           </button>
+          <div className="ml-auto">
+            {/* TeamConfigDrawer 已移除，子代理控制移至输入框 */}
+          </div>
         </div>
       )}
     </div>
diff --git a/apps/electron/src/renderer/components/agent/AgentMessages.tsx b/apps/electron/src/renderer/components/agent/AgentMessages.tsx
index 4500c4da..d309b1d0 100644
--- a/apps/electron/src/renderer/components/agent/AgentMessages.tsx
+++ b/apps/electron/src/renderer/components/agent/AgentMessages.tsx
@@ -35,6 +35,7 @@ import { ToolActivityList } from './ToolActivityItem'
 import { BackgroundTasksPanel } from './BackgroundTasksPanel'
 import { useBackgroundTasks } from '@/hooks/useBackgroundTasks'
 import { userProfileAtom } from '@/atoms/user-profile'
+import { useAgentLayout } from '@/hooks/useChatLayout'
 import { cn } from '@/lib/utils'
 import type { AgentMessage, RetryAttempt } from '@proma/shared'
 import type { ToolActivity, AgentStreamState } from '@/atoms/agent-atoms'
@@ -154,13 +155,15 @@ function extractToolActivities(events: AgentMessage['events']): ToolActivity[] {
           displayName: event.displayName || activities[existingIdx]!.displayName,
         }
       } else {
+        // Task 类型的工具是长时间运行的子代理，初始状态为未完成
+        const isTaskTool = event.toolName === 'Task' || event.toolName === 'Agent'
         activities.push({
           toolUseId: event.toolUseId,
           toolName: event.toolName,
           input: event.input,
           intent: event.intent,
           displayName: event.displayName,
-          done: true,
+          done: isTaskTool ? false : true,
           parentToolUseId: event.parentToolUseId,
         })
       }
@@ -195,6 +198,21 @@ function extractToolActivities(events: AgentMessage['events']): ToolActivity[] {
       if (idx >= 0) {
         activities[idx] = { ...activities[idx]!, intent: event.description, taskId: event.taskId }
       }
+    } else if (event.type === 'task_notification') {
+      // Agent Teams: teammate 任务完成/失败/停止时，更新对应 Task 的 ToolActivity 状态
+      // 后台任务（isBackground）的 done 已被 task_backgrounded 设为 true，需同时清除 isBackground
+      const isTerminal = event.status === 'completed' || event.status === 'failed' || event.status === 'stopped'
+      if (isTerminal && event.toolUseId) {
+        const idx = activities.findIndex((t) => t.toolUseId === event.toolUseId && (!t.done || t.isBackground))
+        if (idx >= 0) {
+          activities[idx] = {
+            ...activities[idx]!,
+            done: true,
+            isBackground: false,
+            isError: event.status === 'failed',
+          }
+        }
+      }
     }
   }
   return activities
@@ -448,31 +466,32 @@ function AgentMessageItem({ message, sessionPath, onRetry, onRetryInNewSession,
 
   if (message.role === 'user') {
     const { files: attachedFiles, text: messageText } = parseAttachedFiles(message.content)
+    const layout = useAgentLayout(true)
 
     return (
-      <Message from="user">
-        <div className="flex items-start gap-2.5 mb-2.5">
+      <Message from="user" className={layout.messageAlignClass}>
+        <div className={`flex items-start gap-2.5 mb-2.5 ${layout.userHeaderFlexClass}`}>
           <UserAvatar avatar={userProfile.avatar} size={35} />
-          <div className="flex flex-col justify-between h-[35px]">
+          <div className={`flex flex-col justify-between h-[35px] ${layout.userInfoAlignClass}`}>
             <span className="text-sm font-semibold text-foreground/60 leading-none">{userProfile.userName}</span>
             <span className="text-[10px] text-foreground/[0.38] leading-none">{formatMessageTime(message.createdAt)}</span>
           </div>
         </div>
-        <MessageContent>
+        <MessageContent className={`${layout.contentPaddingClass} ${layout.contentItemsClass}`}>
           {attachedFiles.length > 0 && (
-            <div className="flex flex-wrap gap-1.5 mb-2">
+            <div className={`flex flex-wrap gap-1.5 mb-2 ${layout.attachmentsClass}`}>
               {attachedFiles.map((file) => (
                 <AttachedFileChip key={file.path} file={file} />
               ))}
             </div>
           )}
           {messageText && (
-            <UserMessageContent>{messageText}</UserMessageContent>
+            <UserMessageContent className={layout.userContentTextClass}>{messageText}</UserMessageContent>
           )}
         </MessageContent>
         {/* 操作按钮（hover 时可见） */}
         {messageText && (
-          <MessageActions className="pl-[46px] mt-0.5">
+          <MessageActions className={`mt-0.5 ${layout.actionsClass}`}>
             <CopyButton content={messageText} />
           </MessageActions>
         )}
@@ -491,15 +510,17 @@ function AgentMessageItem({ message, sessionPath, onRetry, onRetryInNewSession,
           logo={<AssistantLogo model={message.model} />}
         />
         <MessageContent>
-          {toolActivities.length > 0 && (
-            <div className="mb-3">
-              <ToolActivityList activities={toolActivities} />
-            </div>
-          )}
-          <ToolResultInlineImages activities={toolActivities} />
-          {message.content && (
-            <MessageResponse basePath={sessionPath || undefined}>{message.content}</MessageResponse>
-          )}
+          <div className="assistant-message-bubble rounded-[10px] px-3.5 py-2.5 w-fit">
+            {toolActivities.length > 0 && (
+              <div className="mb-3">
+                <ToolActivityList activities={toolActivities} />
+              </div>
+            )}
+            <ToolResultInlineImages activities={toolActivities} />
+            {message.content && (
+              <MessageResponse basePath={sessionPath || undefined}>{message.content}</MessageResponse>
+            )}
+          </div>
         </MessageContent>
         {/* 操作按钮（hover 时可见） */}
         {message.content && (
@@ -525,8 +546,10 @@ function AgentMessageItem({ message, sessionPath, onRetry, onRetryInNewSession,
           }
         />
         <MessageContent>
-          <div className="text-destructive">
-            <MessageResponse>{message.content}</MessageResponse>
+          <div className="assistant-message-bubble rounded-[10px] px-3.5 py-2.5 w-fit">
+            <div className="text-destructive">
+              <MessageResponse>{message.content}</MessageResponse>
+            </div>
           </div>
           {/* 错误操作按钮 */}
           <div className="flex items-center gap-2 mt-3">
@@ -647,23 +670,26 @@ export function AgentMessages({ sessionId, messages, streaming, streamState, ses
                   logo={<AssistantLogo model={agentStreamingModel} />}
                 />
                 <MessageContent>
-                  {retrying && <RetryingNotice retrying={retrying} />}
-                  {toolActivities.length > 0 && (
-                    <div className="mb-3">
-                      <ToolActivityList activities={toolActivities} animate />
-                      {/* 后台任务面板 — 显示在工具活动下方 */}
-                      <BackgroundTasksPanel tasks={backgroundTasks} />
+                  {(retrying || toolActivities.length > 0 || smoothContent) && (
+                    <div className="assistant-message-bubble rounded-[10px] px-3.5 py-2.5 w-fit">
+                      {retrying && <RetryingNotice retrying={retrying} />}
+                      {toolActivities.length > 0 && (
+                        <div className="mb-3">
+                          <ToolActivityList activities={toolActivities} animate />
+                          {/* 后台任务面板 — 显示在工具活动下方 */}
+                          <BackgroundTasksPanel tasks={backgroundTasks} />
+                        </div>
+                      )}
+                      <ToolResultInlineImages activities={toolActivities} />
+                      {smoothContent ? (
+                        <>
+                          <MessageResponse basePath={sessionPath || undefined}>{smoothContent}</MessageResponse>
+                          {streaming && <StreamingIndicator />}
+                        </>
+                      ) : null}
                     </div>
                   )}
-                  <ToolResultInlineImages activities={toolActivities} />
-                  {smoothContent ? (
-                    <>
-                      <MessageResponse basePath={sessionPath || undefined}>{smoothContent}</MessageResponse>
-                      {streaming && <StreamingIndicator />}
-                    </>
-                  ) : (
-                    streaming && toolActivities.length === 0 && !retrying && <MessageLoading startedAt={startedAt} />
-                  )}
+                  {streaming && toolActivities.length === 0 && !retrying && !smoothContent && <MessageLoading startedAt={startedAt} />}
                 </MessageContent>
               </Message>
             )}
diff --git a/apps/electron/src/renderer/components/agent/AgentView.tsx b/apps/electron/src/renderer/components/agent/AgentView.tsx
index c43d1fac..41250005 100644
--- a/apps/electron/src/renderer/components/agent/AgentView.tsx
+++ b/apps/electron/src/renderer/components/agent/AgentView.tsx
@@ -16,10 +16,11 @@
 import * as React from 'react'
 import { useAtom, useAtomValue, useSetAtom, useStore } from 'jotai'
 import { toast } from 'sonner'
-import { Bot, CornerDownLeft, Square, Settings, Paperclip, FolderPlus, X, Copy, Check, Sparkles } from 'lucide-react'
+import { Bot, CornerDownLeft, Square, Settings, Paperclip, FolderPlus, X, Copy, Check, Sparkles, Users } from 'lucide-react'
 import { AgentMessages } from './AgentMessages'
 import { AgentHeader } from './AgentHeader'
 import { ContextUsageBadge } from './ContextUsageBadge'
+import { TodoListPanel } from './TodoListPanel'
 import { PermissionBanner } from './PermissionBanner'
 import { PermissionModeSelector } from './PermissionModeSelector'
 import { AskUserBanner } from './AskUserBanner'
@@ -35,6 +36,7 @@ import {
   agentStreamingStatesAtom,
   agentChannelIdAtom,
   agentModelIdAtom,
+  agentEnabledChannelIdsAtom,
   currentAgentWorkspaceIdAtom,
   agentPendingPromptAtom,
   agentPendingFilesAtom,
@@ -45,14 +47,10 @@ import {
   agentMessageRefreshAtom,
   agentSessionsAtom,
   currentAgentSessionIdAtom,
-  cachedTeamOverviewsAtom,
-  cachedTeammateStatesAtom,
-  cachedTeamActivitiesAtom,
   dismissedTeamSessionIdsAtom,
-  buildTeamActivityEntries,
   rebuildTeamDataFromMessages,
-  agentAttachedDirectoriesMapAtom,
-  workspaceAttachedDirectoriesMapAtom,
+  enableSubAgentsAtom,
+  hasActiveTodosAtom,
 } from '@/atoms/agent-atoms'
 import type { AgentContextStatus } from '@/atoms/agent-atoms'
 import { activeViewAtom } from '@/atoms/active-view'
@@ -69,6 +67,7 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
   const streaming = streamState?.running ?? false
   const [agentChannelId, setAgentChannelId] = useAtom(agentChannelIdAtom)
   const [agentModelId, setAgentModelId] = useAtom(agentModelIdAtom)
+  const agentEnabledChannelIds = useAtomValue(agentEnabledChannelIdsAtom)
   const setActiveView = useSetAtom(activeViewAtom)
   const currentWorkspaceId = useAtomValue(currentAgentWorkspaceIdAtom)
   const [pendingPrompt, setPendingPrompt] = useAtom(agentPendingPromptAtom)
@@ -83,6 +82,7 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
   const streamErrors = useAtomValue(agentStreamErrorsAtom)
   const agentError = streamErrors.get(sessionId) ?? null
   const store = useStore()
+  const [enableSubAgents, setEnableSubAgents] = useAtom(enableSubAgentsAtom)
   const suggestionsMap = useAtomValue(agentPromptSuggestionsAtom)
   const suggestion = suggestionsMap.get(sessionId) ?? null
   const setPromptSuggestions = useSetAtom(agentPromptSuggestionsAtom)
@@ -90,12 +90,6 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
   const setCurrentAgentSessionId = useSetAtom(currentAgentSessionIdAtom)
   const [tabs, setTabs] = useAtom(tabsAtom)
   const [layout, setLayout] = useAtom(splitLayoutAtom)
-  const setAttachedDirsMap = useSetAtom(agentAttachedDirectoriesMapAtom)
-  const attachedDirsMap = useAtomValue(agentAttachedDirectoriesMapAtom)
-  const attachedDirs = attachedDirsMap.get(sessionId) ?? []
-  const wsAttachedDirsMap = useAtomValue(workspaceAttachedDirectoriesMapAtom)
-  const wsAttachedDirs = currentWorkspaceId ? (wsAttachedDirsMap.get(currentWorkspaceId) ?? []) : []
-
   const draftsMap = useAtomValue(agentSessionDraftsAtom)
   const setDraftsMap = useSetAtom(agentSessionDraftsAtom)
   const inputContent = draftsMap.get(sessionId) ?? ''
@@ -115,6 +109,7 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
   const [isDragOver, setIsDragOver] = React.useState(false)
   const [dragFolderWarning, setDragFolderWarning] = React.useState(false)
   const [errorCopied, setErrorCopied] = React.useState(false)
+  const hasActiveTodos = useAtomValue(hasActiveTodosAtom)
 
   // pendingFiles ref（供 addFilesAsAttachments 读取最新列表，避免闭包旧值）
   const pendingFilesRef = React.useRef(pendingFiles)
@@ -122,24 +117,39 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
     pendingFilesRef.current = pendingFiles
   }, [pendingFiles])
 
-  // 渠道已选但模型未选时，自动选择第一个可用模型
+  // 自动选择：当没有选中渠道/模型或选中的渠道不在启用列表时，自动选择第一个可用渠道的第一个模型
   React.useEffect(() => {
-    if (!agentChannelId || agentModelId) return
+    // 已有有效的渠道+模型选择时跳过
+    if (agentChannelId && agentModelId && agentEnabledChannelIds.includes(agentChannelId)) return
 
     window.electronAPI.listChannels().then((channels) => {
-      const channel = channels.find((c) => c.id === agentChannelId && c.enabled)
-      if (!channel) return
-
-      const firstModel = channel.models.find((m) => m.enabled)
-      if (!firstModel) return
+      // 如果有渠道但没模型，先尝试从当前渠道选模型
+      if (agentChannelId && !agentModelId && agentEnabledChannelIds.includes(agentChannelId)) {
+        const channel = channels.find((c) => c.id === agentChannelId && c.enabled)
+        const firstModel = channel?.models.find((m) => m.enabled)
+        if (firstModel) {
+          setAgentModelId(firstModel.id)
+          window.electronAPI.updateSettings({ agentModelId: firstModel.id }).catch(console.error)
+          return
+        }
+      }
 
-      setAgentModelId(firstModel.id)
-      window.electronAPI.updateSettings({
-        agentChannelId,
-        agentModelId: firstModel.id,
-      }).catch(console.error)
+      // 否则从启用的 Agent 渠道中选第一个可用的
+      for (const cid of agentEnabledChannelIds) {
+        const channel = channels.find((c) => c.id === cid && c.enabled)
+        const firstModel = channel?.models.find((m) => m.enabled)
+        if (channel && firstModel) {
+          setAgentChannelId(channel.id)
+          setAgentModelId(firstModel.id)
+          window.electronAPI.updateSettings({
+            agentChannelId: channel.id,
+            agentModelId: firstModel.id,
+          }).catch(console.error)
+          return
+        }
+      }
     }).catch(console.error)
-  }, [agentChannelId, agentModelId, setAgentModelId])
+  }, [agentChannelId, agentModelId, agentEnabledChannelIds, setAgentChannelId, setAgentModelId])
 
   // 获取当前 session 的工作路径（文件浏览器需要）
   React.useEffect(() => {
@@ -148,9 +158,13 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
       return
     }
 
+    console.log('[AgentView] Getting session path for:', sessionId, currentWorkspaceId)
     window.electronAPI
       .getAgentSessionPath(currentWorkspaceId, sessionId)
-      .then(setSessionPath)
+      .then((path) => {
+        console.log('[AgentView] Session path:', path)
+        setSessionPath(path)
+      })
       .catch(() => setSessionPath(null))
   }, [sessionId, currentWorkspaceId])
 
@@ -167,19 +181,7 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
       .catch(() => setWorkspaceFilesPath(null))
   }, [workspaceSlug])
 
-  // 合并工作区文件目录、工作区级附加目录和会话级附加目录，供 @ 引用搜索
-  const allAttachedDirs = React.useMemo(() => {
-    const dirs = [...attachedDirs]
-    // 添加工作区级附加目录
-    for (const d of wsAttachedDirs) {
-      if (!dirs.includes(d)) dirs.push(d)
-    }
-    // 添加工作区共享文件目录
-    if (workspaceFilesPath && !dirs.includes(workspaceFilesPath)) {
-      dirs.unshift(workspaceFilesPath)
-    }
-    return dirs
-  }, [attachedDirs, wsAttachedDirs, workspaceFilesPath])
+
 
   // 监听消息刷新版本号
   const refreshMap = useAtomValue(agentMessageRefreshAtom)
@@ -192,65 +194,37 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
       .then((msgs) => {
         setMessages(msgs)
 
-        // 从持久化消息中重建 Team 数据并填充缓存（页面刷新后恢复）
+        // 从持久化消息中重建 Team 数据，写入 agentStreamingStatesAtom（页面刷新后恢复）
         const teamData = rebuildTeamDataFromMessages(msgs)
-        if (teamData) {
-          if (teamData.overview) {
-            store.set(cachedTeamOverviewsAtom, (prev) => {
-              const map = new Map(prev)
-              map.set(sessionId, teamData.overview!)
-              return map
-            })
-          }
-          if (teamData.teammates.length > 0) {
-            store.set(cachedTeammateStatesAtom, (prev) => {
-              const map = new Map(prev)
-              map.set(sessionId, teamData.teammates)
-              return map
-            })
-          }
-          const entries = buildTeamActivityEntries(teamData.toolActivities)
-          if (entries.length > 0) {
-            store.set(cachedTeamActivitiesAtom, (prev) => {
-              const map = new Map(prev)
-              map.set(sessionId, entries)
-              return map
-            })
-          }
-        }
 
-        // 消息加载完成后，清除已完成的流式状态（running=false 的过渡气泡）
-        // 在同一个微任务中执行，确保 React 在一次渲染中同时显示持久化消息并移除流式气泡
+        // 消息加载完成后，清除流式内容（running=false 的过渡气泡），
+        // 但保留重建的 Team 数据（toolActivities + teammates），确保面板数据不丢失
         setStreamingStates((prev) => {
           const state = prev.get(sessionId)
-          if (!state || state.running) return prev  // 仍在运行中，不清除
           const map = new Map(prev)
-          map.delete(sessionId)
+
+          if (teamData && (teamData.toolActivities.length > 0 || teamData.teammates.length > 0)) {
+            // 有团队数据：保留 teammates（供右侧 Team 面板），清空 toolActivities
+            // toolActivities 已在持久化消息中展示，保留会导致 streaming bubble 重复渲染
+            map.set(sessionId, {
+              running: false,
+              content: '',
+              toolActivities: [],
+              teammates: teamData.teammates,
+              model: state?.model,
+              startedAt: state?.startedAt ?? 0,
+            })
+          } else if (state && !state.running) {
+            // 无团队数据且已完成：直接清除
+            map.delete(sessionId)
+          }
+
           return map
         })
       })
       .catch(console.error)
   }, [sessionId, refreshVersion, setStreamingStates, store])
 
-  // 从会话元数据初始化附加目录
-  const sessions = useAtomValue(agentSessionsAtom)
-  React.useEffect(() => {
-    const meta = sessions.find((s) => s.id === sessionId)
-    const dirs = meta?.attachedDirectories ?? []
-    setAttachedDirsMap((prev) => {
-      const existing = prev.get(sessionId)
-      // 避免不必要的更新
-      if (JSON.stringify(existing) === JSON.stringify(dirs)) return prev
-      const map = new Map(prev)
-      if (dirs.length > 0) {
-        map.set(sessionId, dirs)
-      } else {
-        map.delete(sessionId)
-      }
-      return map
-    })
-  }, [sessionId, sessions, setAttachedDirsMap])
-
   // 自动发送 pending prompt（从设置页"对话完成配置"触发）
   React.useEffect(() => {
     if (!pendingPrompt) return
@@ -263,14 +237,17 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
 
     // 短延时确保 IPC 订阅已就绪
     const timer = setTimeout(() => {
-      // 初始化流式状态
+      // 初始化流式状态（保留历史 teammates）
       setStreamingStates((prev) => {
         const map = new Map(prev)
+        const existingState = map.get(sessionId)
+        // 保留历史 teammates（已完成的子代理）
+        const existingTeammates = existingState?.teammates ?? []
         map.set(sessionId, {
           running: true,
           content: '',
           toolActivities: [],
-          teammates: [],
+          teammates: existingTeammates,
           model: agentModelId || undefined,
           startedAt: Date.now(),
         })
@@ -385,30 +362,6 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
     }
   }, [setPendingFiles])
 
-  /** 附加文件夹（不复制，仅记录路径） */
-  const handleAttachFolder = React.useCallback(async (): Promise<void> => {
-    try {
-      const result = await window.electronAPI.openFolderDialog()
-      if (!result) return
-
-      const updated = await window.electronAPI.attachDirectory({
-        sessionId,
-        directoryPath: result.path,
-      })
-
-      setAttachedDirsMap((prev) => {
-        const map = new Map(prev)
-        map.set(sessionId, updated)
-        return map
-      })
-
-      toast.success(`已附加目录: ${result.name}`)
-    } catch (error) {
-      console.error('[AgentView] 附加文件夹失败:', error)
-      toast.error('附加文件夹失败')
-    }
-  }, [sessionId, setAttachedDirsMap])
-
   /** 移除待发送文件 */
   const handleRemoveFile = React.useCallback((id: string): void => {
     setPendingFiles((prev) => {
@@ -584,12 +537,13 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
 
     // 初始化流式状态
     setStreamingStates((prev) => {
+      const existingState = prev.get(sessionId)
       const map = new Map(prev)
       map.set(sessionId, {
         running: true,
         content: '',
         toolActivities: [],
-        teammates: [],
+        teammates: existingState?.teammates ?? [],  // 保留之前的 teammates，不清空
         model: agentModelId || undefined,
         startedAt: Date.now(),
       })
@@ -605,20 +559,26 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
     }
     setMessages((prev) => [...prev, tempUserMsg])
 
+    // 读取子代理配置
+    const enableSubAgentsValue = store.get(enableSubAgentsAtom)
+
     const input: AgentSendInput = {
       sessionId,
       userMessage: finalMessage,
       channelId: agentChannelId,
       modelId: agentModelId || undefined,
       workspaceId: currentWorkspaceId || undefined,
-      ...(attachedDirs.length > 0 && { additionalDirectories: attachedDirs }),
+      // 子代理配置
+      enableSubAgents: enableSubAgentsValue,
       // 解析用户消息中的 Skill/MCP 引用，传递结构化元数据给后端
       ...(() => {
         const skills = [...effectiveText.matchAll(/\/skill:(\S+)/g)].map(m => m[1]).filter(Boolean) as string[]
         const mcps = [...effectiveText.matchAll(/#mcp:(\S+)/g)].map(m => m[1]).filter(Boolean) as string[]
+        const agents = [...effectiveText.matchAll(/!agent:(\S+)/g)].map(m => m[1]).filter(Boolean) as string[]
         return {
           ...(skills.length > 0 && { mentionedSkills: skills }),
           ...(mcps.length > 0 && { mentionedMcpServers: mcps }),
+          ...(agents.length > 0 && { mentionedAgents: agents }),
         }
       })(),
     }
@@ -634,7 +594,7 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
         return map
       })
     })
-  }, [inputContent, pendingFiles, attachedDirs, sessionId, agentChannelId, agentModelId, currentWorkspaceId, workspaces, streaming, suggestion, store, setStreamingStates, setPendingFiles, setAgentStreamErrors, setPromptSuggestions, setInputContent])
+  }, [inputContent, pendingFiles, sessionId, agentChannelId, agentModelId, currentWorkspaceId, workspaces, streaming, suggestion, store, setStreamingStates, setPendingFiles, setAgentStreamErrors, setPromptSuggestions, setInputContent])
 
   /** 停止生成 */
   const handleStop = React.useCallback((): void => {
@@ -709,11 +669,14 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
     // 初始化流式状态
     setStreamingStates((prev) => {
       const map = new Map(prev)
+      const existingState = map.get(sessionId)
+      // 保留历史 teammates（已完成的子代理）
+      const existingTeammates = existingState?.teammates ?? []
       map.set(sessionId, {
         running: true,
         content: '',
         toolActivities: [],
-        teammates: [],
+        teammates: existingTeammates,
         model: agentModelId || undefined,
         startedAt: Date.now(),
       })
@@ -796,11 +759,14 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
           onCompact={handleCompact}
         />
 
+        {/* 待办事项列表面板 */}
+        {hasActiveTodos && <TodoListPanel sessionId={sessionId} />}
+
         {/* 拖拽文件夹警告 */}
         {dragFolderWarning && (
           <div className="mx-4 mb-2 px-4 py-2.5 rounded-lg bg-amber-500/10 text-amber-600 dark:text-amber-400 text-sm flex items-center gap-2">
             <FolderPlus className="size-4 shrink-0" />
-            <span className="flex-1">不支持拖拽文件夹，请使用"附加文件夹"按钮</span>
+            <span className="flex-1">不支持拖拽文件夹，请在右侧「工作区文件」中关联</span>
             <button
               type="button"
               className="shrink-0 p-0.5 rounded hover:bg-amber-500/10 transition-colors"
@@ -897,9 +863,9 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
               disabled={!agentChannelId}
               autoFocusTrigger={sessionId}
               collapsible
-              workspacePath={sessionPath}
+              workspaceId={currentWorkspaceId}
+              sessionId={sessionId}
               workspaceSlug={workspaceSlug}
-              attachedDirs={allAttachedDirs}
             />
 
             {/* Footer 工具栏 */}
@@ -923,25 +889,30 @@ export function AgentView({ sessionId }: { sessionId: string }): React.ReactElem
                         <p>添加附件</p>
                       </TooltipContent>
                     </Tooltip>
+                    <PermissionModeSelector />
                     <Tooltip>
                       <TooltipTrigger asChild>
                         <Button
                           type="button"
                           variant="ghost"
                           size="icon"
-                          className="size-[30px] rounded-full text-foreground/60 hover:text-foreground"
-                          onClick={handleAttachFolder}
+                          className={cn(
+                            'size-[30px] rounded-full',
+                            enableSubAgents
+                              ? 'text-primary bg-primary/10 hover:bg-primary/20'
+                              : 'text-muted-foreground/40 hover:text-muted-foreground',
+                          )}
+                          onClick={() => setEnableSubAgents(!enableSubAgents)}
                         >
-                          <FolderPlus className="size-5" />
+                          <Bot className="size-4" />
                         </Button>
                       </TooltipTrigger>
                       <TooltipContent side="top">
-                        <p>附加文件夹</p>
+                        <p>{enableSubAgents ? '禁用子代理' : '启用子代理'}</p>
                       </TooltipContent>
                     </Tooltip>
-                    <PermissionModeSelector />
                     <ModelSelector
-                      filterChannelId={agentChannelId}
+                      filterChannelIds={agentEnabledChannelIds.length > 0 ? agentEnabledChannelIds : undefined}
                       externalSelectedModel={externalSelectedModel}
                       onModelSelect={handleModelSelect}
                     />
diff --git a/apps/electron/src/renderer/components/agent/PermissionModeSelector.tsx b/apps/electron/src/renderer/components/agent/PermissionModeSelector.tsx
index a7fa40f3..a75898b1 100644
--- a/apps/electron/src/renderer/components/agent/PermissionModeSelector.tsx
+++ b/apps/electron/src/renderer/components/agent/PermissionModeSelector.tsx
@@ -99,7 +99,7 @@ export function PermissionModeSelector(): React.ReactElement | null {
             <span className="hidden sm:inline">{config.label}</span>
           </button>
         </TooltipTrigger>
-        <TooltipContent side="bottom" className="max-w-[200px]">
+        <TooltipContent side="top" className="max-w-[200px]">
           <p className="font-medium">{config.label}模式</p>
           <p className="text-xs text-muted-foreground mt-0.5">{config.description}</p>
           <p className="text-xs text-muted-foreground mt-1">点击切换模式</p>
diff --git a/apps/electron/src/renderer/components/agent/SidePanel.tsx b/apps/electron/src/renderer/components/agent/SidePanel.tsx
index 435df5ee..d1bfffe4 100644
--- a/apps/electron/src/renderer/components/agent/SidePanel.tsx
+++ b/apps/electron/src/renderer/components/agent/SidePanel.tsx
@@ -9,8 +9,9 @@
  */
 
 import * as React from 'react'
+import { toast } from 'sonner'
 import { useAtom, useAtomValue, useSetAtom } from 'jotai'
-import { PanelRight, X, Users, FolderOpen, ExternalLink, RefreshCw, ChevronRight, Folder, FileText, MoreHorizontal, FolderSearch, Pencil, FolderInput, Info, FolderHeart } from 'lucide-react'
+import { PanelRight, X, Users, FolderOpen, ExternalLink, RefreshCw, ChevronRight, ChevronDown, Folder, FileText, MoreHorizontal, FolderSearch, Pencil, FolderInput, Info, FolderPlus, Trash2 } from 'lucide-react'
 import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs'
 import { Button } from '@/components/ui/button'
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
@@ -20,19 +21,28 @@ import {
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu'
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from '@/components/ui/alert-dialog'
 import { cn } from '@/lib/utils'
+import { Collapsible, CollapsibleContent } from '@/components/ui/collapsible'
 import { FileBrowser, FileDropZone } from '@/components/file-browser'
 import { TeamActivityPanel } from './TeamActivityPanel'
 import {
   agentSidePanelOpenMapAtom,
   agentSidePanelTabMapAtom,
   agentStreamingStatesAtom,
-  cachedTeamActivitiesAtom,
-  buildTeamActivityEntries,
+  dismissedTeamSessionIdsAtom,
   workspaceFilesVersionAtom,
   currentAgentWorkspaceIdAtom,
   agentWorkspacesAtom,
-  agentAttachedDirectoriesMapAtom,
   workspaceAttachedDirectoriesMapAtom,
 } from '@/atoms/agent-atoms'
 import type { SidePanelTab } from '@/atoms/agent-atoms'
@@ -72,124 +82,119 @@ export function SidePanel({ sessionId, sessionPath }: SidePanelProps): React.Rea
 
   // 直接用 sessionId 计算 team 活动（不依赖 currentAgentSessionIdAtom）
   const streamingStates = useAtomValue(agentStreamingStatesAtom)
-  const cachedActivities = useAtomValue(cachedTeamActivitiesAtom)
+  const dismissed = useAtomValue(dismissedTeamSessionIdsAtom)
 
   const hasTeamActivity = React.useMemo(() => {
+    if (dismissed.has(sessionId)) return false
     const state = streamingStates.get(sessionId)
-    if (state) {
-      return state.toolActivities.some(
-        (a) => a.toolName === 'Task' || a.toolName === 'Agent'
-      )
-    }
-    const cached = cachedActivities.get(sessionId)
-    return cached !== undefined && cached.length > 0
-  }, [sessionId, streamingStates, cachedActivities])
+    if (!state) return false
+    return state.teammates.length > 0
+  }, [sessionId, streamingStates, dismissed])
 
   const runningCount = React.useMemo(() => {
     const state = streamingStates.get(sessionId)
-    if (state && state.toolActivities.length > 0) {
-      const entries = buildTeamActivityEntries(state.toolActivities)
-      return entries.filter((e) => e.status === 'running' || e.status === 'backgrounded').length
-    }
-    const cached = cachedActivities.get(sessionId)
-    if (cached) {
-      return cached.filter((e) => e.status === 'running' || e.status === 'backgrounded').length
-    }
-    return 0
-  }, [sessionId, streamingStates, cachedActivities])
+    if (!state) return 0
+    return state.teammates.filter((t) => t.status === 'running').length
+  }, [sessionId, streamingStates])
 
   const filesVersion = useAtomValue(workspaceFilesVersionAtom)
   const setFilesVersion = useSetAtom(workspaceFilesVersionAtom)
   const hasFileChanges = filesVersion > 0
 
+  // 工作区文件上传后，刷新文件列表
+  const handleWorkspaceFilesUploaded = React.useCallback(() => {
+    setFilesVersion((prev) => prev + 1)
+  }, [setFilesVersion])
+
   // 派生当前工作区 slug（用于 FileDropZone IPC 调用）
   const currentWorkspaceId = useAtomValue(currentAgentWorkspaceIdAtom)
   const workspaces = useAtomValue(agentWorkspacesAtom)
   const workspaceSlug = workspaces.find((w) => w.id === currentWorkspaceId)?.slug ?? null
 
-  // 附加目录列表（会话级）
-  const attachedDirsMap = useAtomValue(agentAttachedDirectoriesMapAtom)
-  const setAttachedDirsMap = useSetAtom(agentAttachedDirectoriesMapAtom)
-  const attachedDirs = attachedDirsMap.get(sessionId) ?? []
-
-  // 附加目录列表（工作区级）
+  // 工作区文件列表（关联的外部文件夹）
   const wsAttachedDirsMap = useAtomValue(workspaceAttachedDirectoriesMapAtom)
   const setWsAttachedDirsMap = useSetAtom(workspaceAttachedDirectoriesMapAtom)
+
+  // 文件夹关联成功后更新状态
+  const handleFoldersAttached = React.useCallback((updatedDirs: string[]) => {
+    if (!currentWorkspaceId) return
+    setWsAttachedDirsMap((prev) => {
+      const map = new Map(prev)
+      map.set(currentWorkspaceId, updatedDirs)
+      return map
+    })
+  }, [currentWorkspaceId, setWsAttachedDirsMap])
   const wsAttachedDirs = currentWorkspaceId ? (wsAttachedDirsMap.get(currentWorkspaceId) ?? []) : []
 
-  // 加载工作区级附加目录
+  // 工作区文件目录路径（用于显示上传的文件）
+  const [workspaceFilesPath, setWorkspaceFilesPath] = React.useState<string | null>(null)
+
+  // 加载工作区文件列表（关联的外部文件夹 + workspace-files 目录）
   React.useEffect(() => {
     if (!workspaceSlug || !currentWorkspaceId) return
-    window.electronAPI.getWorkspaceDirectories(workspaceSlug)
-      .then((dirs) => {
-        setWsAttachedDirsMap((prev) => {
-          const map = new Map(prev)
-          map.set(currentWorkspaceId, dirs)
-          return map
-        })
+    
+    // 获取关联的目录和 workspace-files 路径
+    Promise.all([
+      window.electronAPI.getWorkspaceDirectories(workspaceSlug),
+      window.electronAPI.getWorkspaceFilesPath(workspaceSlug),
+    ]).then(([dirs, filesPath]) => {
+      setWsAttachedDirsMap((prev) => {
+        const map = new Map(prev)
+        map.set(currentWorkspaceId, dirs)
+        return map
       })
-      .catch(console.error)
+      setWorkspaceFilesPath(filesPath)
+    }).catch(console.error)
   }, [workspaceSlug, currentWorkspaceId, setWsAttachedDirsMap])
 
-  const handleAttachFolder = React.useCallback(async () => {
+  // 关联工作区文件或文件夹（外部文件/文件夹）
+  const handleAttachWorkspaceFilesOrFolders = React.useCallback(async () => {
+    if (!workspaceSlug || !currentWorkspaceId) return
     try {
-      const result = await window.electronAPI.openFolderDialog()
+      const result = await window.electronAPI.openFileOrFolderDialog()
       if (!result) return
 
-      const updated = await window.electronAPI.attachDirectory({
-        sessionId,
-        directoryPath: result.path,
-      })
-      setAttachedDirsMap((prev) => {
-        const map = new Map(prev)
-        map.set(sessionId, updated)
-        return map
-      })
-    } catch (error) {
-      console.error('[SidePanel] 附加文件夹失败:', error)
-    }
-  }, [sessionId, setAttachedDirsMap])
-
-  const handleDetachDirectory = React.useCallback(async (dirPath: string) => {
-    try {
-      const updated = await window.electronAPI.detachDirectory({
-        sessionId,
-        directoryPath: dirPath,
-      })
-      setAttachedDirsMap((prev) => {
-        const map = new Map(prev)
-        if (updated.length > 0) {
-          map.set(sessionId, updated)
-        } else {
-          map.delete(sessionId)
+      // 处理文件夹关联
+      if (result.folders.length > 0) {
+        let updated = wsAttachedDirsMap.get(currentWorkspaceId) ?? []
+        for (const folder of result.folders) {
+          updated = await window.electronAPI.attachWorkspaceDirectory({
+            workspaceSlug,
+            directoryPath: folder.path,
+          })
         }
-        return map
-      })
-    } catch (error) {
-      console.error('[SidePanel] 移除附加目录失败:', error)
-    }
-  }, [sessionId, setAttachedDirsMap])
+        setWsAttachedDirsMap((prev) => {
+          const map = new Map(prev)
+          map.set(currentWorkspaceId, updated)
+          return map
+        })
+      }
 
-  // 工作区级附加文件夹
-  const handleAttachWorkspaceFolder = React.useCallback(async () => {
-    if (!workspaceSlug || !currentWorkspaceId) return
-    try {
-      const result = await window.electronAPI.openFolderDialog()
-      if (!result) return
+      // 处理文件上传
+      if (result.files.length > 0) {
+        await window.electronAPI.saveFilesToWorkspaceFiles({
+          workspaceSlug,
+          files: result.files,
+        })
+        // 刷新文件列表
+        setFilesVersion((prev) => prev + 1)
+      }
 
-      const updated = await window.electronAPI.attachWorkspaceDirectory({
-        workspaceSlug,
-        directoryPath: result.path,
-      })
-      setWsAttachedDirsMap((prev) => {
-        const map = new Map(prev)
-        map.set(currentWorkspaceId, updated)
-        return map
-      })
+      // 显示提示
+      const folderCount = result.folders.length
+      const fileCount = result.files.length
+      if (folderCount > 0 && fileCount > 0) {
+        toast.success(`已关联 ${folderCount} 个文件夹，上传 ${fileCount} 个文件`)
+      } else if (folderCount > 0) {
+        toast.success(`已关联 ${folderCount} 个文件夹`)
+      } else if (fileCount > 0) {
+        toast.success(`已上传 ${fileCount} 个文件`)
+      }
     } catch (error) {
-      console.error('[SidePanel] 附加工作区文件夹失败:', error)
+      console.error('[SidePanel] 关联失败:', error)
+      toast.error('关联失败')
     }
-  }, [workspaceSlug, currentWorkspaceId, setWsAttachedDirsMap])
+  }, [workspaceSlug, currentWorkspaceId, wsAttachedDirsMap, setWsAttachedDirsMap, setFilesVersion])
 
   const handleDetachWorkspaceDirectory = React.useCallback(async (dirPath: string) => {
     if (!workspaceSlug || !currentWorkspaceId) return
@@ -208,10 +213,22 @@ export function SidePanel({ sessionId, sessionPath }: SidePanelProps): React.Rea
         return map
       })
     } catch (error) {
-      console.error('[SidePanel] 移除工作区附加目录失败:', error)
+      console.error('[SidePanel] 移除工作区文件夹失败:', error)
     }
   }, [workspaceSlug, currentWorkspaceId, setWsAttachedDirsMap])
 
+  // 清空上传文件目录
+  const handleDeleteWorkspaceFiles = React.useCallback(async () => {
+    if (!workspaceSlug) return
+    try {
+      await window.electronAPI.deleteWorkspaceFilesDirectory(workspaceSlug)
+      // 刷新文件列表
+      setFilesVersion((prev) => prev + 1)
+    } catch (error) {
+      console.error('[SidePanel] 清空上传文件失败:', error)
+    }
+  }, [workspaceSlug, setFilesVersion])
+
   // 文件上传完成后递增版本号，触发 FileBrowser 刷新
   const handleFilesUploaded = React.useCallback(() => {
     setFilesVersion((prev) => prev + 1)
@@ -222,22 +239,61 @@ export function SidePanel({ sessionId, sessionPath }: SidePanelProps): React.Rea
     setFilesVersion((prev) => prev + 1)
   }, [setFilesVersion])
 
-  // 面包屑：显示根路径最后两段
-  const breadcrumb = React.useMemo(() => {
-    if (!sessionPath) return ''
-    const parts = sessionPath.split('/').filter(Boolean)
-    return parts.length > 2 ? `.../${parts.slice(-2).join('/')}` : sessionPath
-  }, [sessionPath])
+  // ===== 文件模块展开/折叠状态和高度计算 =====
+  const [sessionFilesExpanded, setSessionFilesExpanded] = React.useState(true)
+  const [workspaceFilesExpanded, setWorkspaceFilesExpanded] = React.useState(true)
+  const [sessionFilesCount, setSessionFilesCount] = React.useState(0)
 
-  // 工作区文件目录路径
-  const [workspaceFilesPath, setWorkspaceFilesPath] = React.useState<string | null>(null)
+  // 监听本会话文件数量变化
   React.useEffect(() => {
-    if (!workspaceSlug) {
-      setWorkspaceFilesPath(null)
+    if (!sessionPath) {
+      setSessionFilesCount(0)
       return
     }
-    window.electronAPI.getWorkspaceFilesPath(workspaceSlug).then(setWorkspaceFilesPath).catch(() => setWorkspaceFilesPath(null))
-  }, [workspaceSlug])
+    window.electronAPI.listDirectory(sessionPath)
+      .then(items => setSessionFilesCount(items.length))
+      .catch(() => setSessionFilesCount(0))
+  }, [sessionPath, filesVersion])
+
+  // 计算本会话文件区域高度（自适应，最大50%）
+  const sessionSectionStyle = React.useMemo(() => {
+    if (!sessionFilesExpanded) {
+      return { height: '32px' } // 仅标题栏高度
+    }
+    
+    const headerHeight = 32 // 标题栏高度
+    const itemHeight = 28   // 每个文件项高度
+    const maxHeightPercent = 50 // 最大占50%
+    
+    if (sessionFilesCount === 0) {
+      return { height: `${headerHeight}px` }
+    }
+    
+    // 计算内容高度（最多显示5个文件项的高度）
+    const maxVisibleItems = 5
+    const visibleItems = Math.min(sessionFilesCount, maxVisibleItems)
+    const contentHeight = visibleItems * itemHeight
+    const totalHeight = headerHeight + contentHeight
+    
+    // 计算百分比高度（基于面板高度约640px）
+    const containerHeight = 640
+    const calculatedPercent = (totalHeight / containerHeight) * 100
+    
+    return { 
+      height: `${Math.min(calculatedPercent, maxHeightPercent)}%`,
+      minHeight: `${headerHeight + itemHeight}px` // 至少显示一个文件项
+    }
+  }, [sessionFilesCount, sessionFilesExpanded])
+
+  // 自动打开：检测到 team 活动时
+  const prevHasTeamRef = React.useRef(hasTeamActivity)
+  React.useEffect(() => {
+    if (hasTeamActivity && !prevHasTeamRef.current) {
+      setIsOpen(true)
+      setActiveTab('team')
+    }
+    prevHasTeamRef.current = hasTeamActivity
+  }, [hasTeamActivity, setIsOpen, setActiveTab])
 
   // 自动打开：文件变化时（仅在有 sessionPath 时）
   const prevFilesVersionRef = React.useRef(filesVersion)
@@ -253,7 +309,7 @@ export function SidePanel({ sessionId, sessionPath }: SidePanelProps): React.Rea
   }, [filesVersion, sessionPath, hasTeamActivity, setIsOpen, setActiveTab])
 
   // 面板是否可显示内容（需要有 sessionPath 或 team 活动）
-  const hasContent = sessionPath || hasTeamActivity || attachedDirs.length > 0
+  const hasContent = sessionPath || hasTeamActivity
 
   return (
     <div
@@ -340,129 +396,141 @@ export function SidePanel({ sessionId, sessionPath }: SidePanelProps): React.Rea
             {/* File Browser Tab */}
             <TabsContent value="files" className="flex-1 overflow-hidden m-0 data-[state=active]:flex data-[state=active]:flex-col">
               {sessionPath && workspaceSlug ? (
-                <div className="flex-1 min-h-0 overflow-y-auto">
-                  {/* ===== 会话文件区 ===== */}
-                  <div className="flex items-center gap-1 px-3 h-[32px] flex-shrink-0">
-                    <FolderOpen className="size-3 text-muted-foreground" />
-                    <span className="text-[11px] font-medium text-muted-foreground">会话文件</span>
-                    <Tooltip>
-                      <TooltipTrigger asChild>
-                        <Info className="size-3 text-muted-foreground/50 cursor-help" />
-                      </TooltipTrigger>
-                      <TooltipContent side="bottom" className="max-w-[200px]">
-                        <p>当前会话的专属文件，仅本次对话的 Agent 可以访问</p>
-                      </TooltipContent>
-                    </Tooltip>
-                    <span className="text-[10px] text-muted-foreground/50 truncate flex-1" title={sessionPath}>
-                      {breadcrumb}
-                    </span>
-                    <Tooltip>
-                      <TooltipTrigger asChild>
-                        <Button
-                          type="button"
-                          variant="ghost"
-                          size="icon"
-                          className="h-5 w-5 flex-shrink-0"
-                          onClick={() => window.electronAPI.openFile(sessionPath).catch(console.error)}
-                        >
-                          <ExternalLink className="size-2.5" />
-                        </Button>
-                      </TooltipTrigger>
-                      <TooltipContent side="bottom">
-                        <p>在 Finder 中打开</p>
-                      </TooltipContent>
-                    </Tooltip>
-                    <Tooltip>
-                      <TooltipTrigger asChild>
-                        <Button
-                          type="button"
-                          variant="ghost"
-                          size="icon"
-                          className="h-5 w-5 flex-shrink-0"
-                          onClick={handleRefresh}
-                        >
-                          <RefreshCw className="size-2.5" />
-                        </Button>
-                      </TooltipTrigger>
-                      <TooltipContent side="bottom">
-                        <p>刷新文件列表</p>
-                      </TooltipContent>
-                    </Tooltip>
+                <div className="flex flex-col flex-1 min-h-0">
+                  {/* ===== 本会话文件区（上方，自适应高度，最大50%） ===== */}
+                  <div 
+                    className="flex flex-col min-h-0 border-b border-dashed border-muted-foreground/20 transition-all duration-300 ease-in-out"
+                    style={sessionSectionStyle}
+                  >
+                    {/* 标题栏 - 可点击展开/折叠 */}
+                    <div 
+                      className="flex items-center gap-1 px-3 h-[32px] flex-shrink-0 cursor-pointer hover:bg-accent/30 rounded-sm transition-colors"
+                      onClick={() => setSessionFilesExpanded(v => !v)}
+                    >
+                      {sessionFilesExpanded ? (
+                        <ChevronDown className="size-3 text-muted-foreground/70" />
+                      ) : (
+                        <ChevronRight className="size-3 text-muted-foreground/70" />
+                      )}
+                      <FolderOpen className="size-3 text-muted-foreground" />
+                      <span className="text-[11px] font-medium text-muted-foreground">本会话文件</span>
+                      {sessionFilesCount > 0 && (
+                        <span className="text-[10px] text-muted-foreground/50 ml-1">({sessionFilesCount})</span>
+                      )}
+                      <Tooltip>
+                        <TooltipTrigger asChild>
+                          <Info className="size-3 text-muted-foreground/50 cursor-help ml-1" />
+                        </TooltipTrigger>
+                        <TooltipContent side="bottom" className="max-w-[200px]">
+                          <p>当前会话的专属文件，仅本次对话的 Agent 可以访问，新对话不继承</p>
+                        </TooltipContent>
+                      </Tooltip>
+                      <div className="flex-1" />
+                      <Tooltip>
+                        <TooltipTrigger asChild>
+                          <Button
+                            type="button"
+                            variant="ghost"
+                            size="icon"
+                            className="h-5 w-5 flex-shrink-0"
+                            onClick={(e) => { e.stopPropagation(); window.electronAPI.openFile(sessionPath).catch(console.error) }}
+                          >
+                            <ExternalLink className="size-2.5" />
+                          </Button>
+                        </TooltipTrigger>
+                        <TooltipContent side="bottom">
+                          <p>在 Finder 中打开</p>
+                        </TooltipContent>
+                      </Tooltip>
+                      <Tooltip>
+                        <TooltipTrigger asChild>
+                          <Button
+                            type="button"
+                            variant="ghost"
+                            size="icon"
+                            className="h-5 w-5 flex-shrink-0"
+                            onClick={(e) => { e.stopPropagation(); handleRefresh() }}
+                          >
+                            <RefreshCw className="size-2.5" />
+                          </Button>
+                        </TooltipTrigger>
+                        <TooltipContent side="bottom">
+                          <p>刷新文件列表</p>
+                        </TooltipContent>
+                      </Tooltip>
+                    </div>
+                    {/* 本会话文件浏览器（可滚动）- 仅查看对话中上传的附件 */}
+                    <Collapsible open={sessionFilesExpanded} className="flex-1 min-h-0">
+                      <CollapsibleContent className="h-full overflow-y-auto data-[state=closed]:hidden">
+                        <FileBrowser rootPath={sessionPath} hideToolbar embedded />
+                      </CollapsibleContent>
+                    </Collapsible>
                   </div>
-                  {/* 附加目录列表（可展开目录树） */}
-                  {attachedDirs.length > 0 && (
-                    <AttachedDirsSection
-                      attachedDirs={attachedDirs}
-                      onDetach={handleDetachDirectory}
-                      refreshVersion={filesVersion}
-                    />
-                  )}
-                  {/* 会话文件浏览器 */}
-                  <FileBrowser rootPath={sessionPath} hideToolbar embedded />
-                  {/* 会话文件拖拽上传区域 */}
-                  <FileDropZone
-                    workspaceSlug={workspaceSlug}
-                    sessionId={sessionId}
-                    target="session"
-                    onFilesUploaded={handleFilesUploaded}
-                    onAttachFolder={handleAttachFolder}
-                  />
-
-                  {/* ===== 分隔线 ===== */}
-                  <div className="mx-3 my-3 border-t border-dashed border-muted-foreground/20" />
-
-                  {/* ===== 工作区文件区 ===== */}
-                  <div className="bg-muted/30 rounded-lg mx-2 mb-2 pb-1">
-                    <div className="flex items-center gap-1 px-2 h-[32px] flex-shrink-0">
-                      <FolderHeart className="size-3 text-primary/70" />
+
+                  {/* ===== 工作区文件区（下方，占据剩余空间） ===== */}
+                  <div className="flex flex-col flex-1 min-h-0">
+                    {/* 标题栏 - 可点击展开/折叠 */}
+                    <div 
+                      className="flex items-center gap-1 px-3 h-[32px] flex-shrink-0 cursor-pointer hover:bg-accent/30 rounded-sm transition-colors"
+                      onClick={() => setWorkspaceFilesExpanded(v => !v)}
+                    >
+                      {workspaceFilesExpanded ? (
+                        <ChevronDown className="size-3 text-primary/70" />
+                      ) : (
+                        <ChevronRight className="size-3 text-primary/70" />
+                      )}
+                      <FolderOpen className="size-3 text-primary/70" />
                       <span className="text-[11px] font-medium text-primary/70">工作区文件</span>
                       <Tooltip>
                         <TooltipTrigger asChild>
-                          <Info className="size-3 text-primary/40 cursor-help" />
+                          <Info className="size-3 text-primary/40 cursor-help ml-1" />
                         </TooltipTrigger>
                         <TooltipContent side="bottom" className="max-w-[220px]">
-                          <p>工作区内所有会话可访问的文件和文件夹，每个新对话都可以自动读取</p>
+                          <p>关联的外部文件夹，工作区内所有会话可访问，Agent 可直接修改原位置的文件</p>
                         </TooltipContent>
                       </Tooltip>
                       <div className="flex-1" />
-                      {workspaceFilesPath && (
-                        <Tooltip>
-                          <TooltipTrigger asChild>
-                            <Button
-                              type="button"
-                              variant="ghost"
-                              size="icon"
-                              className="h-5 w-5 flex-shrink-0"
-                              onClick={() => window.electronAPI.openFile(workspaceFilesPath).catch(console.error)}
-                            >
-                              <ExternalLink className="size-2.5" />
-                            </Button>
-                          </TooltipTrigger>
-                          <TooltipContent side="bottom">
-                            <p>在 Finder 中打开工作区文件目录</p>
-                          </TooltipContent>
-                        </Tooltip>
-                      )}
+                      <Tooltip>
+                        <TooltipTrigger asChild>
+                          <Button
+                            type="button"
+                            variant="ghost"
+                            size="icon"
+                            className="h-5 w-5 flex-shrink-0 text-primary/70 hover:text-primary"
+                            onClick={(e) => { e.stopPropagation(); handleAttachWorkspaceFilesOrFolders() }}
+                          >
+                            <FolderPlus className="size-2.5" />
+                          </Button>
+                        </TooltipTrigger>
+                        <TooltipContent side="bottom">
+                          <p>关联文件或文件夹</p>
+                        </TooltipContent>
+                      </Tooltip>
                     </div>
-                    {/* 工作区级附加目录 */}
-                    {wsAttachedDirs.length > 0 && (
-                      <AttachedDirsSection
-                        attachedDirs={wsAttachedDirs}
-                        onDetach={handleDetachWorkspaceDirectory}
-                        refreshVersion={filesVersion}
-                      />
-                    )}
-                    {/* 工作区文件浏览器 */}
-                    {workspaceFilesPath && (
-                      <FileBrowser rootPath={workspaceFilesPath} hideToolbar embedded />
-                    )}
-                    {/* 工作区文件拖拽上传区域 */}
-                    <FileDropZone
-                      workspaceSlug={workspaceSlug}
-                      target="workspace"
-                      onFilesUploaded={handleFilesUploaded}
-                      onAttachFolder={handleAttachWorkspaceFolder}
-                    />
+                    {/* 工作区文件列表（可滚动） - 支持拖拽 */}
+                    <Collapsible open={workspaceFilesExpanded} className="flex-1 min-h-0">
+                      <CollapsibleContent className="h-full overflow-y-auto data-[state=closed]:hidden relative">
+                        <FileDropZone
+                          workspaceSlug={workspaceSlug ?? ''}
+                          target="workspace"
+                          onFilesUploaded={handleWorkspaceFilesUploaded}
+                          onFoldersAttached={handleFoldersAttached}
+                          className="h-full"
+                          hideUI={wsAttachedDirs.length > 0 || !!workspaceFilesPath}
+                        >
+                          {(wsAttachedDirs.length > 0 || workspaceFilesPath) ? (
+                            <WorkspaceFilesSection
+                              attachedDirs={wsAttachedDirs}
+                              onDetach={handleDetachWorkspaceDirectory}
+                              refreshVersion={filesVersion}
+                              workspaceFilesPath={workspaceFilesPath}
+                              workspaceSlug={workspaceSlug ?? ''}
+                              onDeleteWorkspaceFiles={handleDeleteWorkspaceFiles}
+                            />
+                          ) : null}
+                        </FileDropZone>
+                      </CollapsibleContent>
+                    </Collapsible>
                   </div>
                 </div>
               ) : (
@@ -478,78 +546,142 @@ export function SidePanel({ sessionId, sessionPath }: SidePanelProps): React.Rea
   )
 }
 
-// ===== 附加目录容器（管理选中状态） =====
+// ===== 工作区文件容器（关联的外部文件夹） =====
 
-interface AttachedDirsSectionProps {
+interface WorkspaceFilesSectionProps {
   attachedDirs: string[]
   onDetach: (dirPath: string) => void
   /** 文件版本号，用于自动刷新已展开的目录 */
   refreshVersion: number
+  /** workspace-files 目录路径（用于显示上传的文件） */
+  workspaceFilesPath: string | null
+  /** 工作区 slug（用于删除上传文件目录） */
+  workspaceSlug: string
+  /** 删除上传文件目录（清空所有上传的文件） */
+  onDeleteWorkspaceFiles: () => void
 }
 
-/** 附加目录区域：统一管理所有子项的选中状态 */
-function AttachedDirsSection({ attachedDirs, onDetach, refreshVersion }: AttachedDirsSectionProps): React.ReactElement {
+/** 工作区文件区域：统一管理所有关联的外部文件夹和上传的文件 */
+function WorkspaceFilesSection({ attachedDirs, onDetach, refreshVersion, workspaceFilesPath, workspaceSlug, onDeleteWorkspaceFiles }: WorkspaceFilesSectionProps): React.ReactElement {
   const [selectedPaths, setSelectedPaths] = React.useState<Set<string>>(new Set())
+  // 最后选中的路径（用于 Shift 范围选择的锚点）
+  const lastSelectedPathRef = React.useRef<string | null>(null)
+  // 所有可见文件路径（用于 Shift 范围选择）
+  const allVisiblePathsRef = React.useRef<Set<string>>(new Set())
 
-  const handleSelect = React.useCallback((path: string, ctrlKey: boolean) => {
+  // 注册/注销可见路径
+  const registerVisiblePath = React.useCallback((path: string) => {
+    allVisiblePathsRef.current.add(path)
+  }, [])
+  const unregisterVisiblePath = React.useCallback((path: string) => {
+    allVisiblePathsRef.current.delete(path)
+  }, [])
+
+  const handleSelect = React.useCallback((path: string, ctrlKey: boolean, shiftKey: boolean) => {
     setSelectedPaths((prev) => {
+      if (shiftKey && lastSelectedPathRef.current && allVisiblePathsRef.current.size > 0) {
+        // Shift+点击：范围选择
+        const allPaths = Array.from(allVisiblePathsRef.current)
+        const anchorIndex = allPaths.indexOf(lastSelectedPathRef.current)
+        const targetIndex = allPaths.indexOf(path)
+        if (anchorIndex !== -1 && targetIndex !== -1) {
+          const start = Math.min(anchorIndex, targetIndex)
+          const end = Math.max(anchorIndex, targetIndex)
+          const rangePaths = allPaths.slice(start, end + 1)
+          // 保持之前选中的，添加范围内的
+          return new Set([...prev, ...rangePaths])
+        }
+      }
+      
       if (ctrlKey) {
         // Ctrl+点击：切换选中
         const next = new Set(prev)
         if (next.has(path)) {
           next.delete(path)
+          if (lastSelectedPathRef.current === path) {
+            lastSelectedPathRef.current = null
+          }
         } else {
           next.add(path)
+          lastSelectedPathRef.current = path
         }
         return next
       }
+      
       // 普通点击：单选
+      lastSelectedPathRef.current = path
       return new Set([path])
     })
   }, [])
 
   return (
-    <div className="pt-2.5 pb-1 flex-shrink-0">
-      <div className="text-[11px] font-medium text-muted-foreground mb-1 px-3">附加目录（Agent 可以读取并操作此文件夹）</div>
+    <div className="pt-1 pb-1 flex-shrink-0">
+      {/* workspace-files 目录（显示上传的文件） */}
+      {workspaceFilesPath && (
+        <WorkspaceDirTree
+          key="__workspace_files__"
+          dirPath={workspaceFilesPath}
+          onDetach={() => {}} // 不可分离
+          selectedPaths={selectedPaths}
+          onSelect={handleSelect}
+          refreshVersion={refreshVersion}
+          isSystemDir
+          onDelete={onDeleteWorkspaceFiles}
+          registerVisiblePath={registerVisiblePath}
+          unregisterVisiblePath={unregisterVisiblePath}
+        />
+      )}
       {attachedDirs.map((dir) => (
-        <AttachedDirTree
+        <WorkspaceDirTree
           key={dir}
           dirPath={dir}
           onDetach={() => onDetach(dir)}
           selectedPaths={selectedPaths}
           onSelect={handleSelect}
           refreshVersion={refreshVersion}
+          registerVisiblePath={registerVisiblePath}
+          unregisterVisiblePath={unregisterVisiblePath}
         />
       ))}
     </div>
   )
 }
 
-// ===== 附加目录树组件 =====
+// ===== 工作区目录树组件 =====
 
-interface AttachedDirTreeProps {
+interface WorkspaceDirTreeProps {
   dirPath: string
   onDetach: () => void
   selectedPaths: Set<string>
-  onSelect: (path: string, ctrlKey: boolean) => void
+  onSelect: (path: string, ctrlKey: boolean, shiftKey: boolean) => void
   /** 文件版本号，变化时已展开的目录自动重新加载 */
   refreshVersion: number
+  /** 是否为系统目录（workspace-files/），不可分离，显示特殊名称 */
+  isSystemDir?: boolean
+  /** 系统目录的删除回调（清空目录内容） */
+  onDelete?: () => void
+  /** 注册可见路径（用于 Shift 范围选择） */
+  registerVisiblePath?: (path: string) => void
+  /** 注销可见路径 */
+  unregisterVisiblePath?: (path: string) => void
 }
 
-/** 附加目录根节点：可展开/收起，带移除按钮 */
-function AttachedDirTree({ dirPath, onDetach, selectedPaths, onSelect, refreshVersion }: AttachedDirTreeProps): React.ReactElement {
+/** 工作区目录根节点：可展开/收起，带移除按钮 */
+function WorkspaceDirTree({ dirPath, onDetach, selectedPaths, onSelect, refreshVersion, isSystemDir, onDelete, registerVisiblePath, unregisterVisiblePath }: WorkspaceDirTreeProps): React.ReactElement {
   const [expanded, setExpanded] = React.useState(false)
   const [children, setChildren] = React.useState<FileEntry[]>([])
   const [loaded, setLoaded] = React.useState(false)
+  // 删除确认状态
+  const [showDeleteDialog, setShowDeleteDialog] = React.useState(false)
 
-  const dirName = dirPath.split('/').filter(Boolean).pop() || dirPath
+  const dirName = isSystemDir ? '上传文件' : (dirPath.split('/').filter(Boolean).pop() || dirPath)
 
   // 当 refreshVersion 变化时，已展开的目录自动重新加载
   React.useEffect(() => {
     if (expanded && loaded) {
       window.electronAPI.listAttachedDirectory(dirPath)
         .then((items) => setChildren(items))
-        .catch((err) => console.error('[AttachedDirTree] 刷新失败:', err))
+        .catch((err) => console.error('[WorkspaceDirTree] 刷新失败:', err))
     }
   }, [refreshVersion]) // eslint-disable-line react-hooks/exhaustive-deps
 
@@ -560,12 +692,33 @@ function AttachedDirTree({ dirPath, onDetach, selectedPaths, onSelect, refreshVe
         setChildren(items)
         setLoaded(true)
       } catch (err) {
-        console.error('[AttachedDirTree] 加载失败:', err)
+        console.error('[WorkspaceDirTree] 加载失败:', err)
       }
     }
     setExpanded(!expanded)
   }
 
+  // 处理根节点点击（支持 Shift 范围选择）
+  const handleClick = (e: React.MouseEvent) => {
+    // Shift 多选时阻止默认文本选择行为
+    if (e.shiftKey) {
+      e.preventDefault()
+    }
+    onSelect(dirPath, e.ctrlKey || e.metaKey, e.shiftKey)
+  }
+
+  // 执行删除
+  const handleDelete = async (): Promise<void> => {
+    try {
+      await window.electronAPI.deleteWorkspaceFilesDirectory(dirPath)
+      // 清空选中状态
+      onSelect('', false, false)
+    } catch (err) {
+      console.error('[WorkspaceDirTree] 删除失败:', err)
+    }
+    setShowDeleteDialog(false)
+  }
+
   return (
     <div>
       <div
@@ -586,39 +739,84 @@ function AttachedDirTree({ dirPath, onDetach, selectedPaths, onSelect, refreshVe
         <span className="text-xs truncate flex-1" title={dirPath}>
           {dirName}
         </span>
-        <Button
-          type="button"
-          variant="ghost"
-          size="icon"
-          className="h-5 w-5 opacity-0 group-hover:opacity-100 transition-opacity flex-shrink-0"
-          onClick={(e) => { e.stopPropagation(); onDetach() }}
-        >
-          <X className="size-3" />
-        </Button>
+        {!isSystemDir && (
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            className="h-5 w-5 opacity-0 group-hover:opacity-100 transition-opacity flex-shrink-0"
+            onClick={(e) => { e.stopPropagation(); onDetach() }}
+          >
+            <X className="size-3" />
+          </Button>
+        )}
+        {isSystemDir && (
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            className="h-5 w-5 opacity-0 group-hover:opacity-100 transition-opacity flex-shrink-0 text-destructive hover:text-destructive"
+            onClick={(e) => { e.stopPropagation(); setShowDeleteDialog(true) }}
+          >
+            <Trash2 className="size-3" />
+          </Button>
+        )}
       </div>
       {expanded && children.length === 0 && loaded && (
         <div className="text-[11px] text-muted-foreground/50 py-1" style={{ paddingLeft: 48 }}>
           空文件夹
         </div>
       )}
+
+      {/* 删除确认对话框 */}
+      <AlertDialog open={showDeleteDialog} onOpenChange={setShowDeleteDialog}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>确认清空上传文件</AlertDialogTitle>
+            <AlertDialogDescription>
+              确定要删除"上传文件"目录中的所有文件吗？
+              此操作不可撤销。
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel onClick={() => setShowDeleteDialog(false)}>取消</AlertDialogCancel>
+            <AlertDialogAction onClick={handleDelete} className="bg-destructive text-destructive-foreground hover:bg-destructive/90">
+              删除
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
       {expanded && children.map((child) => (
-        <AttachedDirItem key={child.path} entry={child} depth={1} selectedPaths={selectedPaths} onSelect={onSelect} refreshVersion={refreshVersion} />
+        <WorkspaceDirItem 
+          key={child.path} 
+          entry={child} 
+          depth={1} 
+          selectedPaths={selectedPaths} 
+          onSelect={onSelect} 
+          refreshVersion={refreshVersion}
+          registerVisiblePath={registerVisiblePath}
+          unregisterVisiblePath={unregisterVisiblePath}
+        />
       ))}
     </div>
   )
 }
 
-interface AttachedDirItemProps {
+interface WorkspaceDirItemProps {
   entry: FileEntry
   depth: number
   selectedPaths: Set<string>
-  onSelect: (path: string, ctrlKey: boolean) => void
+  onSelect: (path: string, ctrlKey: boolean, shiftKey: boolean) => void
   /** 文件版本号，变化时已展开的目录自动重新加载 */
   refreshVersion: number
+  /** 注册可见路径（用于 Shift 范围选择） */
+  registerVisiblePath?: (path: string) => void
+  /** 注销可见路径 */
+  unregisterVisiblePath?: (path: string) => void
 }
 
-/** 附加目录子项：递归可展开，支持选中 + 三点菜单（含重命名、移动） */
-function AttachedDirItem({ entry, depth, selectedPaths, onSelect, refreshVersion }: AttachedDirItemProps): React.ReactElement {
+/** 工作区目录子项：递归可展开，支持选中 + 三点菜单（含重命名、移动） */
+function WorkspaceDirItem({ entry, depth, selectedPaths, onSelect, refreshVersion, registerVisiblePath, unregisterVisiblePath }: WorkspaceDirItemProps): React.ReactElement {
   const [expanded, setExpanded] = React.useState(false)
   const [children, setChildren] = React.useState<FileEntry[]>([])
   const [loaded, setLoaded] = React.useState(false)
@@ -629,15 +827,25 @@ function AttachedDirItem({ entry, depth, selectedPaths, onSelect, refreshVersion
   // 当前显示的名称和路径（重命名后更新）
   const [currentName, setCurrentName] = React.useState(entry.name)
   const [currentPath, setCurrentPath] = React.useState(entry.path)
+  // 删除确认状态
+  const [showDeleteDialog, setShowDeleteDialog] = React.useState(false)
 
   const isSelected = selectedPaths.has(currentPath)
 
+  // 注册/注销可见路径（用于 Shift 范围选择）
+  React.useEffect(() => {
+    registerVisiblePath?.(currentPath)
+    return () => {
+      unregisterVisiblePath?.(currentPath)
+    }
+  }, [currentPath])
+
   // 当 refreshVersion 变化时，已展开的文件夹自动重新加载子项
   React.useEffect(() => {
     if (expanded && loaded && entry.isDirectory) {
       window.electronAPI.listAttachedDirectory(currentPath)
         .then((items) => setChildren(items))
-        .catch((err) => console.error('[AttachedDirItem] 刷新子目录失败:', err))
+        .catch((err) => console.error('[WorkspaceDirItem] 刷新子目录失败:', err))
     }
   }, [refreshVersion]) // eslint-disable-line react-hooks/exhaustive-deps
 
@@ -649,15 +857,19 @@ function AttachedDirItem({ entry, depth, selectedPaths, onSelect, refreshVersion
         setChildren(items)
         setLoaded(true)
       } catch (err) {
-        console.error('[AttachedDirItem] 加载子目录失败:', err)
+        console.error('[WorkspaceDirItem] 加载子目录失败:', err)
       }
     }
     setExpanded(!expanded)
   }
 
   const handleClick = (e: React.MouseEvent): void => {
-    onSelect(currentPath, e.ctrlKey || e.metaKey)
-    if (entry.isDirectory) {
+    // Shift 多选时阻止默认文本选择行为
+    if (e.shiftKey) {
+      e.preventDefault()
+    }
+    onSelect(currentPath, e.ctrlKey || e.metaKey, e.shiftKey)
+    if (entry.isDirectory && !e.shiftKey && !e.ctrlKey && !e.metaKey) {
       toggleDir()
     }
   }
@@ -689,11 +901,11 @@ function AttachedDirItem({ entry, depth, selectedPaths, onSelect, refreshVersion
       const parentDir = currentPath.substring(0, currentPath.lastIndexOf('/'))
       const newPath = `${parentDir}/${newName}`
       // 更新选中状态中的路径
-      onSelect(newPath, false)
+      onSelect(newPath, false, false)
       setCurrentName(newName)
       setCurrentPath(newPath)
     } catch (err) {
-      console.error('[AttachedDirItem] 重命名失败:', err)
+      console.error('[WorkspaceDirItem] 重命名失败:', err)
     }
     setIsRenaming(false)
   }
@@ -714,8 +926,20 @@ function AttachedDirItem({ entry, depth, selectedPaths, onSelect, refreshVersion
       const newPath = `${result.path}/${currentName}`
       setCurrentPath(newPath)
     } catch (err) {
-      console.error('[AttachedDirItem] 移动失败:', err)
+      console.error('[WorkspaceDirItem] 移动失败:', err)
+    }
+  }
+
+  // 删除文件/目录
+  const handleDelete = async (): Promise<void> => {
+    try {
+      await window.electronAPI.deleteAttachedFile(currentPath)
+      // 通知父组件刷新（通过选择空路径触发）
+      onSelect('', false, false)
+    } catch (err) {
+      console.error('[WorkspaceDirItem] 删除失败:', err)
     }
+    setShowDeleteDialog(false)
   }
 
   const paddingLeft = 8 + depth * 16
@@ -816,6 +1040,13 @@ function AttachedDirItem({ entry, depth, selectedPaths, onSelect, refreshVersion
                   <FolderInput />
                   移动到...
                 </DropdownMenuItem>
+                <DropdownMenuItem
+                  className="text-xs py-1 [&>svg]:size-3.5 text-destructive focus:text-destructive"
+                  onSelect={() => setShowDeleteDialog(true)}
+                >
+                  <Trash2 />
+                  删除
+                </DropdownMenuItem>
               </DropdownMenuContent>
             </DropdownMenu>
           </div>
@@ -830,8 +1061,37 @@ function AttachedDirItem({ entry, depth, selectedPaths, onSelect, refreshVersion
         </div>
       )}
       {expanded && children.map((child) => (
-        <AttachedDirItem key={child.path} entry={child} depth={depth + 1} selectedPaths={selectedPaths} onSelect={onSelect} refreshVersion={refreshVersion} />
+        <WorkspaceDirItem 
+          key={child.path} 
+          entry={child} 
+          depth={depth + 1} 
+          selectedPaths={selectedPaths} 
+          onSelect={onSelect} 
+          refreshVersion={refreshVersion}
+          registerVisiblePath={registerVisiblePath}
+          unregisterVisiblePath={unregisterVisiblePath}
+        />
       ))}
+
+      {/* 删除确认对话框 */}
+      <AlertDialog open={showDeleteDialog} onOpenChange={setShowDeleteDialog}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>确认删除</AlertDialogTitle>
+            <AlertDialogDescription>
+              确定要删除 <strong>{currentName}</strong> 吗？
+              {entry.isDirectory && '（包含所有子文件）'}
+              此操作不可撤销。
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel onClick={() => setShowDeleteDialog(false)}>取消</AlertDialogCancel>
+            <AlertDialogAction onClick={handleDelete} className="bg-destructive text-destructive-foreground hover:bg-destructive/90">
+              删除
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
     </>
   )
 }
diff --git a/apps/electron/src/renderer/components/agent/SubAgentCard.tsx b/apps/electron/src/renderer/components/agent/SubAgentCard.tsx
new file mode 100644
index 00000000..2c0b2399
--- /dev/null
+++ b/apps/electron/src/renderer/components/agent/SubAgentCard.tsx
@@ -0,0 +1,325 @@
+/**
+ * SubAgentCard — 子代理卡片组件
+ *
+ * 列表展示每个子代理的状态，点击展开显示详细输出。
+ * 数据来自 agentStreamingStatesAtom 的 teammates。
+ */
+
+import * as React from 'react'
+import { useState, useEffect, useMemo, Fragment } from 'react'
+import Markdown from 'react-markdown'
+import remarkGfm from 'remark-gfm'
+import {
+  Bot,
+  Loader2,
+  CheckCircle2,
+  XCircle,
+  StopCircle,
+  ChevronDown,
+  Clock,
+  Wrench,
+  Zap,
+  FolderOpen,
+} from 'lucide-react'
+import { Badge } from '@/components/ui/badge'
+import { Separator } from '@/components/ui/separator'
+import { cn } from '@/lib/utils'
+import { formatElapsed } from './ToolActivityItem'
+import { useAtomValue } from 'jotai'
+import { type TeammateState, extractTeammateName, currentAgentSessionAtom, currentAgentWorkspaceIdAtom } from '@/atoms/agent-atoms'
+
+interface SubAgentCardProps {
+  teammate: TeammateState
+  expanded: boolean
+  onToggle: () => void
+}
+
+export function SubAgentCard({ teammate, expanded, onToggle }: SubAgentCardProps): React.ReactElement {
+  const isRunning = teammate.status === 'running'
+  const isCompleted = teammate.status === 'completed'
+  const isFailed = teammate.status === 'failed' || teammate.status === 'stopped'
+  const elapsed = useElapsed(teammate)
+  const displayName = extractTeammateName(teammate)
+  
+  // 获取当前 session 和 workspace 信息用于打开文件
+  const currentSession = useAtomValue(currentAgentSessionAtom)
+  const currentWorkspaceId = useAtomValue(currentAgentWorkspaceIdAtom)
+  
+  const handleShowInFolder = (e: React.MouseEvent) => {
+    e.stopPropagation()
+    if (teammate.outputFile) {
+      // 判断是否为绝对路径（以 / 开头）
+      const isAbsolutePath = teammate.outputFile.startsWith('/')
+      window.electronAPI.showInFolder(
+        teammate.outputFile,
+        isAbsolutePath ? undefined : currentSession?.id,
+        isAbsolutePath ? undefined : (currentWorkspaceId ?? undefined)
+      ).catch(console.error)
+    }
+  }
+
+  // 当前正在执行的工具名
+  const currentToolName = isRunning ? teammate.currentToolName : null
+
+  // 统计数据
+  const stats = useMemo(() => {
+    const toolCount = teammate.toolHistory.length
+    const totalTokens = teammate.usage?.totalTokens ?? 0
+    return { toolCount, totalTokens }
+  }, [teammate.toolHistory, teammate.usage])
+
+  return (
+    <div
+      className={cn(
+        'rounded-lg transition-all',
+        'bg-foreground/[0.03] dark:bg-foreground/[0.05]',
+        expanded && 'bg-foreground/[0.05] dark:bg-foreground/[0.07] shadow-sm',
+      )}
+    >
+      {/* 折叠头部 */}
+      <button
+        type="button"
+        onClick={onToggle}
+        className="group flex w-full flex-col gap-1.5 px-3 py-2.5 text-left hover:bg-foreground/[0.02] dark:hover:bg-foreground/[0.03] rounded-lg transition-colors"
+      >
+        {/* 头部：状态图标 + 名称 + 耗时 + 展开指示 */}
+        <div className="flex items-center gap-2 w-full">
+          {/* 状态图标 */}
+          <div className="shrink-0">
+            {isRunning ? (
+              <Loader2 className="size-3.5 text-blue-500 animate-spin" />
+            ) : isCompleted ? (
+              <CheckCircle2 className="size-3.5 text-emerald-500" />
+            ) : isFailed ? (
+              <XCircle className="size-3.5 text-red-500" />
+            ) : (
+              <Bot className="size-3.5 text-muted-foreground/50" />
+            )}
+          </div>
+
+          <span className="text-xs font-medium truncate flex-1 min-w-0">
+            {displayName}
+          </span>
+
+          <div className="flex items-center gap-1.5 shrink-0">
+            {teammate.outputFile && (
+              <button
+                type="button"
+                onClick={handleShowInFolder}
+                className="p-1.5 rounded-md hover:bg-primary/10 transition-colors"
+                title="在 Finder 中打开"
+              >
+                <FolderOpen className="size-3.5 text-primary/70" />
+              </button>
+            )}
+            <ChevronDown
+              className={cn(
+                'size-3 text-muted-foreground/40 transition-transform duration-200',
+                expanded && 'rotate-180',
+              )}
+            />
+          </div>
+        </div>
+
+        {/* 运行中：当前工具 + AI 进度摘要 + 工具链 */}
+        {isRunning && (
+          <div className="flex flex-col gap-1.5 w-full">
+            {/* 当前工具（高亮卡片） */}
+            {currentToolName && (
+              <div className="flex items-center gap-1.5 rounded-md bg-blue-500/5 dark:bg-blue-500/10 px-2 py-1">
+                <Wrench className="size-2.5 text-blue-500 animate-pulse" />
+                <span className="text-[11px] text-blue-600 dark:text-blue-400 font-mono truncate flex-1">
+                  {currentToolName}
+                </span>
+              </div>
+            )}
+            {/* AI 进度摘要（agentProgressSummaries） */}
+            {teammate.progressSummary && (
+              <p className="text-[11px] text-muted-foreground/60 italic leading-relaxed line-clamp-2">
+                {teammate.progressSummary}
+              </p>
+            )}
+            {/* 进度描述 */}
+            {!teammate.progressSummary && teammate.progressDescription && (
+              <p className="text-[11px] text-muted-foreground/60 italic leading-relaxed line-clamp-2">
+                {teammate.progressDescription}
+              </p>
+            )}
+            {/* 工具链（最近 5 个工具） */}
+            {teammate.toolHistory.length > 0 && (
+              <div className="flex items-center gap-1 flex-wrap">
+                {teammate.toolHistory.slice(-5).map((tool, i, arr) => (
+                  <Fragment key={`${tool}-${i}`}>
+                    <span className="text-[10px] font-mono text-muted-foreground/50 bg-foreground/[0.04] dark:bg-foreground/[0.06] rounded px-1 py-0.5">
+                      {tool}
+                    </span>
+                    {i < arr.length - 1 && (
+                      <span className="text-[9px] text-muted-foreground/30">→</span>
+                    )}
+                  </Fragment>
+                ))}
+              </div>
+            )}
+          </div>
+        )}
+
+        {/* 已完成：摘要预览 */}
+        {!expanded && isCompleted && teammate.summary && (
+          <p className="text-[11px] text-green-700/70 dark:text-green-400/70 line-clamp-2">
+            {teammate.summary}
+          </p>
+        )}
+
+        {/* 底部统计 */}
+        <div className="flex items-center gap-3 text-[10px] text-muted-foreground/50">
+          {elapsed && (
+            <span className="flex items-center gap-1">
+              <Clock className="size-2.5" />
+              {elapsed}
+            </span>
+          )}
+          {stats.totalTokens > 0 && (
+            <span className="flex items-center gap-1">
+              <Zap className="size-2.5" />
+              {formatTokens(stats.totalTokens)}
+            </span>
+          )}
+          {stats.toolCount > 0 && (
+            <span className="ml-auto text-[10px] text-muted-foreground/40">
+              {stats.toolCount} 个工具
+            </span>
+          )}
+        </div>
+      </button>
+
+      {/* 展开详情 */}
+      {expanded && (
+        <div className="flex flex-col gap-2.5 px-3 pb-3">
+          <Separator />
+
+          {/* AI 进度摘要（运行中展开时显示完整内容） */}
+          {isRunning && teammate.progressSummary && (
+            <DetailSection title="AI 进度摘要" borderColor="border-l-blue-500">
+              <p className="text-[11px] text-muted-foreground/70 leading-relaxed">
+                {teammate.progressSummary}
+              </p>
+            </DetailSection>
+          )}
+
+          {/* 工作摘要（完成后） */}
+          {teammate.summary && (
+            <DetailSection title="工作摘要" borderColor="border-l-green-500">
+              <div className="prose dark:prose-invert max-w-none text-[11px] prose-p:my-0.5 prose-li:leading-relaxed [&>*:first-child]:mt-0 [&>*:last-child]:mb-0 max-h-[300px] overflow-y-auto">
+                <Markdown remarkPlugins={[remarkGfm]}>{teammate.summary}</Markdown>
+              </div>
+            </DetailSection>
+          )}
+
+          {/* 使用量统计 */}
+          {teammate.usage && (
+            <DetailSection title="使用量" borderColor="border-l-violet-500">
+              <div className="flex items-center gap-4 text-[11px] text-muted-foreground/70">
+                <span className="flex items-center gap-1">
+                  <Wrench className="size-2.5" />
+                  {teammate.usage.toolUses} 次工具调用
+                </span>
+                <span className="flex items-center gap-1">
+                  <Zap className="size-2.5" />
+                  {formatTokens(teammate.usage.totalTokens)} tokens
+                </span>
+                {teammate.usage.durationMs > 0 && (
+                  <span className="flex items-center gap-1">
+                    <Clock className="size-2.5" />
+                    {formatElapsed(teammate.usage.durationMs / 1000)}
+                  </span>
+                )}
+              </div>
+            </DetailSection>
+          )}
+
+          {/* 工具使用历史 */}
+          {teammate.toolHistory.length > 0 && (
+            <ToolHistorySection toolHistory={teammate.toolHistory} />
+          )}
+
+          {/* 无详细数据时的提示 */}
+          {!teammate.summary && !teammate.usage && teammate.toolHistory.length === 0 && (
+            <p className="text-[11px] text-muted-foreground/40 text-center py-2">
+              {isRunning ? '等待 Agent 返回进度数据...' : '暂无详细数据'}
+            </p>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}
+
+// ===== 共享子组件 =====
+
+function DetailSection({
+  title,
+  borderColor,
+  children,
+}: {
+  title: string
+  borderColor?: string
+  children: React.ReactNode
+}): React.ReactElement {
+  return (
+    <div className={cn('rounded-md border-l-2 bg-foreground/[0.02] dark:bg-foreground/[0.04] px-3 py-2', borderColor)}>
+      <p className="text-[10px] font-medium text-muted-foreground/60 mb-1.5">{title}</p>
+      {children}
+    </div>
+  )
+}
+
+function ToolHistorySection({ toolHistory }: { toolHistory: string[] }): React.ReactElement {
+  const counts = new Map<string, number>()
+  for (const tool of toolHistory) {
+    counts.set(tool, (counts.get(tool) ?? 0) + 1)
+  }
+  const sorted = Array.from(counts.entries()).sort((a, b) => b[1] - a[1])
+
+  return (
+    <DetailSection title="工具使用" borderColor="border-l-muted-foreground/30">
+      <div className="flex flex-wrap gap-1 mb-2">
+        {sorted.map(([tool, count]) => (
+          <Badge
+            key={tool}
+            variant="secondary"
+            className="h-4 gap-0.5 rounded-full px-1.5 text-[10px] bg-foreground/[0.04] dark:bg-foreground/[0.06]"
+          >
+            {tool}
+            {count > 1 && <span className="text-muted-foreground/50">×{count}</span>}
+          </Badge>
+        ))}
+      </div>
+      <p className="text-[10px] text-muted-foreground/40 font-mono leading-relaxed break-all">
+        {toolHistory.join(' → ')}
+      </p>
+    </DetailSection>
+  )
+}
+
+// ===== Helpers =====
+
+function useElapsed(teammate: TeammateState): string | null {
+  const [now, setNow] = useState(Date.now())
+
+  useEffect(() => {
+    if (teammate.status !== 'running') return
+    const timer = setInterval(() => setNow(Date.now()), 1000)
+    return () => clearInterval(timer)
+  }, [teammate.status])
+
+  if (!teammate.startedAt) return null
+  const endTime = teammate.endedAt ?? now
+  const seconds = Math.max(0, (endTime - teammate.startedAt) / 1000)
+  return formatElapsed(seconds)
+}
+
+function formatTokens(tokens: number): string {
+  if (tokens < 1000) return `${tokens}`
+  if (tokens < 1_000_000) return `${(tokens / 1000).toFixed(1)}K`
+  return `${(tokens / 1_000_000).toFixed(1)}M`
+}
diff --git a/apps/electron/src/renderer/components/agent/TeamActivityPanel.tsx b/apps/electron/src/renderer/components/agent/TeamActivityPanel.tsx
index ef376d4b..85d87756 100644
--- a/apps/electron/src/renderer/components/agent/TeamActivityPanel.tsx
+++ b/apps/electron/src/renderer/components/agent/TeamActivityPanel.tsx
@@ -1,55 +1,25 @@
 /**
  * TeamActivityPanel — Agent Teams 活动面板
  *
- * 展示团队全景：Team 头部 + Task Board + Agent 卡片列表 + 通信时间线。
- * 从 toolActivities 中提取 TeamCreate/TaskCreate/Agent 工具调用的丰富数据。
- * 通过轮询 getAgentTeamData 读取 Agent 间 inbox 通信消息。
+ * 纯事件驱动：所有数据来自 agentStreamingStatesAtom.teammates，
+ * 每个子代理渲染为一个 SubAgentCard。
  */
 
-import { useState, useEffect, useMemo, useCallback, Fragment } from 'react'
-import { useAtomValue, useSetAtom, useStore } from 'jotai'
+import { useState, useCallback } from 'react'
+import { useAtomValue, useSetAtom } from 'jotai'
 import { toast } from 'sonner'
-import Markdown from 'react-markdown'
-import remarkGfm from 'remark-gfm'
 import {
-  teamOverviewAtom,
-  teammateStatesAtom,
-  hasTeammatesAtom,
-  agentSessionsAtom,
   agentStreamingStatesAtom,
   dismissedTeamSessionIdsAtom,
-  cachedPolledTeamDataAtom,
-  type TeamOverview,
-  type TeamTaskItem,
-  type TeamAgentInfo,
-  type TeammateState,
-  type ActivityStatus,
 } from '@/atoms/agent-atoms'
-import { formatElapsed } from './ToolActivityItem'
+import { SubAgentCard } from './SubAgentCard'
 import { ScrollArea } from '@/components/ui/scroll-area'
 import { Badge } from '@/components/ui/badge'
-import { Separator } from '@/components/ui/separator'
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
-import { cn } from '@/lib/utils'
-import type { ParsedMailboxMessage, AgentTeamData, TaskItem } from '@proma/shared'
 import {
-  Users,
+  Bot,
   Loader2,
   CheckCircle2,
-  XCircle,
-  StopCircle,
-  ChevronDown,
-  Clock,
-  Wrench,
-  Zap,
-  FileText,
-  Bot,
-  ListChecks,
-  ArrowRight,
-  Circle,
-  Lock,
-  MessageSquare,
-  Send,
   X,
 } from 'lucide-react'
 
@@ -58,10 +28,11 @@ interface TeamActivityPanelProps {
 }
 
 export function TeamActivityPanel({ sessionId }: TeamActivityPanelProps): React.ReactElement {
-  const overview = useAtomValue(teamOverviewAtom)
-  const teammates = useAtomValue(teammateStatesAtom)
-  const hasTeammates = useAtomValue(hasTeammatesAtom)
+  const streamingStates = useAtomValue(agentStreamingStatesAtom)
+  const dismissed = useAtomValue(dismissedTeamSessionIdsAtom)
   const setDismissed = useSetAtom(dismissedTeamSessionIdsAtom)
+  const teammates = (!dismissed.has(sessionId) && streamingStates.get(sessionId)?.teammates) || []
+  const hasTeammates = teammates.length > 0
   const [expandedId, setExpandedId] = useState<string | null>(null)
 
   // 关闭 Team 面板
@@ -72,86 +43,8 @@ export function TeamActivityPanel({ sessionId }: TeamActivityPanelProps): React.
     })
   }, [sessionId, setDismissed])
 
-  // 基础 agent 列表（来自 tool events）
-  const rawAgentEntries = overview?.agents ?? []
-
-  // 轮询文件系统数据（task 状态 + inbox 通信消息）
-  const sessions = useAtomValue(agentSessionsAtom)
-  const session = sessions.find((s) => s.id === sessionId)
-  const sdkSessionId = session?.sdkSessionId
-  const streamState = useAtomValue(agentStreamingStatesAtom).get(sessionId)
-  const isStreaming = streamState?.running ?? false
-  const store = useStore()
-  const cachedPolled = useAtomValue(cachedPolledTeamDataAtom).get(sessionId)
-  const [polledData, setPolledDataLocal] = useState<AgentTeamData | null>(cachedPolled ?? null)
-
-  // 更新 polledData 同时写入缓存（防止组件卸载后数据丢失）
-  const setPolledData = useCallback((data: AgentTeamData) => {
-    setPolledDataLocal(data)
-    store.set(cachedPolledTeamDataAtom, (prev) => {
-      const map = new Map(prev)
-      map.set(sessionId, data)
-      return map
-    })
-  }, [sessionId, store])
-
-  useEffect(() => {
-    if (!sdkSessionId || !hasTeammates) return
-    const poll = async (): Promise<void> => {
-      try {
-        const data = await window.electronAPI.getAgentTeamData(sdkSessionId)
-        if (data) setPolledData(data)
-      } catch {
-        // 轮询错误不影响 UI
-      }
-    }
-    poll()
-    if (!isStreaming) return
-    const id = setInterval(poll, 2000)
-    return () => clearInterval(id)
-  }, [sdkSessionId, hasTeammates, isStreaming, setPolledData])
-
-  // 用文件系统的真实 task 状态合并 overview tasks
-  const mergedTasks = useMemo(() => {
-    if (!overview?.tasks.length) return overview?.tasks ?? []
-    if (!polledData?.tasks.length) return overview.tasks
-    return overview.tasks.map((t) => {
-      const polledTask = polledData.tasks.find((pt) =>
-        pt.subject === t.subject || (t.taskNumber && pt.id === t.taskNumber),
-      )
-      if (!polledTask) return t
-      return { ...t, status: polledTask.status }
-    })
-  }, [overview?.tasks, polledData?.tasks])
-
-  // 用文件系统 task 状态推算 agent 完成情况
-  const agentEntries = useMemo(() => {
-    if (!rawAgentEntries.length || !polledData?.tasks.length) return rawAgentEntries
-    return rawAgentEntries.map((agent) => {
-      // 已确认完成的保持不变；stopped/failed 允许被 polled data 修正为 completed
-      if (agent.teammate && agent.teammate.status === 'completed') return agent
-      // 按 owner 名称匹配文件系统 task
-      const ownedTask = polledData.tasks.find((pt) => pt.owner === agent.name)
-      if (ownedTask?.status === 'completed') {
-        const updatedTm: TeammateState = agent.teammate
-          ? { ...agent.teammate, status: 'completed', endedAt: agent.teammate.endedAt ?? Date.now() }
-          : {
-              taskId: `polled-${agent.toolUseId}`,
-              description: agent.description,
-              index: 0,
-              status: 'completed',
-              toolHistory: [],
-              startedAt: Date.now(),
-              endedAt: Date.now(),
-            }
-        return { ...agent, teammate: updatedTm, status: 'completed' as ActivityStatus }
-      }
-      return agent
-    })
-  }, [rawAgentEntries, polledData?.tasks])
-
   // 空状态
-  if (!overview && !hasTeammates) {
+  if (!hasTeammates) {
     return (
       <div className="flex h-full items-center justify-center">
         <div className="flex flex-col items-center gap-2.5 text-muted-foreground/60">
@@ -163,52 +56,14 @@ export function TeamActivityPanel({ sessionId }: TeamActivityPanelProps): React.
     )
   }
 
-  const hasAgents = agentEntries.length > 0
-  const displayTeammates = hasAgents ? [] : teammates
-
-  const runningCount = hasAgents
-    ? agentEntries.filter((a) => a.teammate?.status === 'running' || a.status === 'running').length
-    : teammates.filter((t) => t.status === 'running').length
-  const doneCount = hasAgents
-    ? agentEntries.filter((a) => {
-        const s = a.teammate?.status ?? (a.status === 'completed' || a.status === 'error' ? a.status : undefined)
-        return s === 'completed' || s === 'stopped' || s === 'failed' || s === 'error'
-      }).length
-    : teammates.filter((t) => t.status !== 'running').length
-  const totalCount = hasAgents ? agentEntries.length : teammates.length
+  const runningCount = teammates.filter((t) => t.status === 'running').length
+  const doneCount = teammates.filter((t) => t.status !== 'running').length
 
   return (
     <div className="flex h-full flex-col">
-      {/* Team 头部 */}
-      {overview?.teamName && (
-        <div className="border-b px-3 py-2.5">
-          <div className="flex items-center gap-2">
-            <Users className="size-3.5 text-primary" />
-            <span className="text-xs font-semibold">{overview.teamName}</span>
-            <Tooltip>
-              <TooltipTrigger asChild>
-                <button
-                  type="button"
-                  onClick={handleDismiss}
-                  className="ml-auto rounded-md p-0.5 text-muted-foreground/40 hover:text-muted-foreground/70 hover:bg-foreground/[0.05] transition-colors"
-                >
-                  <X className="size-3.5" />
-                </button>
-              </TooltipTrigger>
-              <TooltipContent side="left" className="text-xs">关闭 Team 面板</TooltipContent>
-            </Tooltip>
-          </div>
-          {overview.teamDescription && (
-            <p className="mt-1 text-[11px] text-muted-foreground/70 leading-relaxed">
-              {overview.teamDescription}
-            </p>
-          )}
-        </div>
-      )}
-
       {/* 摘要栏 */}
       <div className="flex items-center gap-2 border-b px-3 py-1.5">
-        <span className="text-[11px] text-muted-foreground">{totalCount} 个 Agent</span>
+        <span className="text-[11px] text-muted-foreground">{teammates.length} 个 Agent</span>
         <div className="ml-auto flex items-center gap-1.5">
           {runningCount > 0 && (
             <Badge variant="secondary" className="h-4.5 gap-1 rounded-full px-1.5 text-[10px] bg-blue-500/10 text-blue-600 dark:text-blue-400">
@@ -222,785 +77,33 @@ export function TeamActivityPanel({ sessionId }: TeamActivityPanelProps): React.
               {doneCount}
             </Badge>
           )}
-          {/* 无 Team 头部时在摘要栏显示关闭按钮 */}
-          {!overview?.teamName && (
-            <Tooltip>
-              <TooltipTrigger asChild>
-                <button
-                  type="button"
-                  onClick={handleDismiss}
-                  className="rounded-md p-0.5 text-muted-foreground/40 hover:text-muted-foreground/70 hover:bg-foreground/[0.05] transition-colors"
-                >
-                  <X className="size-3" />
-                </button>
-              </TooltipTrigger>
-              <TooltipContent side="left" className="text-xs">关闭 Team 面板</TooltipContent>
-            </Tooltip>
-          )}
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <button
+                type="button"
+                onClick={handleDismiss}
+                className="rounded-md p-0.5 text-muted-foreground/40 hover:text-muted-foreground/70 hover:bg-foreground/[0.05] transition-colors"
+              >
+                <X className="size-3" />
+              </button>
+            </TooltipTrigger>
+            <TooltipContent side="left" className="text-xs">关闭 Team 面板</TooltipContent>
+          </Tooltip>
         </div>
       </div>
 
       <ScrollArea className="flex-1">
         <div className="flex flex-col gap-2 p-2">
-          {/* Task Board */}
-          {mergedTasks.length > 0 && (
-            <TaskBoard tasks={mergedTasks} />
-          )}
-
-          {/* Agent 卡片（有 overview 时） */}
-          {hasAgents && agentEntries.map((agent) => (
-            <AgentCard
-              key={agent.toolUseId}
-              agent={agent}
-              expanded={expandedId === agent.toolUseId}
-              onToggle={() => setExpandedId(expandedId === agent.toolUseId ? null : agent.toolUseId)}
-            />
-          ))}
-
-          {/* 回退：TeammateState 卡片（无 overview 时） */}
-          {!hasAgents && displayTeammates.map((tm) => (
-            <TeammateCard
+          {teammates.map((tm) => (
+            <SubAgentCard
               key={tm.taskId}
               teammate={tm}
               expanded={expandedId === tm.taskId}
               onToggle={() => setExpandedId(expandedId === tm.taskId ? null : tm.taskId)}
             />
           ))}
-
-          {/* Agent 通信时间线 */}
-          <MailboxTimeline inboxes={polledData?.inboxes ?? {}} />
         </div>
       </ScrollArea>
     </div>
   )
 }
-
-// ============================================================================
-// TaskBoard — 任务看板
-// ============================================================================
-
-function TaskBoard({ tasks }: { tasks: TeamTaskItem[] }): React.ReactElement {
-  const completedCount = tasks.filter((t) => t.status === 'completed').length
-  const progress = tasks.length > 0 ? (completedCount / tasks.length) * 100 : 0
-
-  return (
-    <div className="rounded-lg bg-foreground/[0.03] dark:bg-foreground/[0.05] px-3 py-2.5">
-      <div className="flex items-center gap-2 mb-2">
-        <ListChecks className="size-3 text-muted-foreground/60" />
-        <span className="text-[11px] font-medium text-muted-foreground">Task Board</span>
-        <span className="text-[10px] text-muted-foreground/50 ml-auto">
-          {completedCount}/{tasks.length}
-        </span>
-      </div>
-
-      {/* 进度条 */}
-      <div className="h-1 rounded-full bg-foreground/[0.06] dark:bg-foreground/[0.1] mb-2 overflow-hidden">
-        <div
-          className="h-full rounded-full bg-green-500/60 transition-all duration-500"
-          style={{ width: `${progress}%` }}
-        />
-      </div>
-
-      {/* 任务列表 */}
-      <div className="flex flex-col gap-1">
-        {tasks.map((task) => (
-          <TaskRow key={task.toolUseId} task={task} />
-        ))}
-      </div>
-    </div>
-  )
-}
-
-function TaskRow({ task }: { task: TeamTaskItem }): React.ReactElement {
-  const isCompleted = task.status === 'completed'
-  const isBlocked = task.blockedBy.length > 0 && !isCompleted
-
-  return (
-    <div className="flex items-start gap-1.5 py-0.5">
-      {/* 状态图标 */}
-      {isCompleted ? (
-        <CheckCircle2 className="size-3 text-green-500 mt-0.5 shrink-0" />
-      ) : isBlocked ? (
-        <Lock className="size-3 text-yellow-500/70 mt-0.5 shrink-0" />
-      ) : task.status === 'in_progress' ? (
-        <Loader2 className="size-3 text-blue-500 animate-spin mt-0.5 shrink-0" />
-      ) : (
-        <Circle className="size-3 text-muted-foreground/30 mt-0.5 shrink-0" />
-      )}
-
-      <div className="flex-1 min-w-0">
-        <div className="flex items-center gap-1">
-          {task.taskNumber && (
-            <span className="text-[10px] font-mono text-muted-foreground/50">#{task.taskNumber}</span>
-          )}
-          <span className={cn(
-            'text-[11px] truncate',
-            isCompleted && 'line-through text-muted-foreground/50',
-          )}>
-            {task.subject}
-          </span>
-        </div>
-        {isBlocked && (
-          <span className="text-[9px] text-yellow-600/60 dark:text-yellow-400/60">
-            等待 #{task.blockedBy.join(', #')}
-          </span>
-        )}
-      </div>
-    </div>
-  )
-}
-
-// ============================================================================
-// MailboxTimeline — Agent 间通信消息时间线
-// ============================================================================
-
-/** 系统消息类型（过滤但计数） */
-const SYSTEM_MESSAGE_TYPES = new Set(['idle_notification', 'shutdown_request', 'shutdown_approved'])
-
-/** 带接收者信息的消息 */
-interface TimelineMessage extends ParsedMailboxMessage {
-  recipient: string
-}
-
-function MailboxTimeline({ inboxes }: { inboxes: Record<string, ParsedMailboxMessage[]> }): React.ReactElement | null {
-  const [collapsed, setCollapsed] = useState(false)
-
-  // 合并所有 inbox 消息，附加接收者名称，按时间排序
-  const { messages, systemCount } = useMemo(() => {
-    const all: TimelineMessage[] = []
-    let sysCount = 0
-
-    for (const [recipient, msgs] of Object.entries(inboxes)) {
-      for (const msg of msgs) {
-        if (SYSTEM_MESSAGE_TYPES.has(msg.parsedType)) {
-          sysCount++
-          continue
-        }
-        all.push({ ...msg, recipient })
-      }
-    }
-
-    // 按时间排序
-    all.sort((a, b) => {
-      if (a.timestamp && b.timestamp) return new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-      if (a.timestamp) return -1
-      if (b.timestamp) return 1
-      return 0
-    })
-
-    return { messages: all, systemCount: sysCount }
-  }, [inboxes])
-
-  // 无消息时不显示
-  if (messages.length === 0 && systemCount === 0) return null
-
-  return (
-    <div className="rounded-lg bg-foreground/[0.03] dark:bg-foreground/[0.05] px-3 py-2.5">
-      {/* 折叠头部 */}
-      <button
-        type="button"
-        onClick={() => setCollapsed(!collapsed)}
-        className="flex w-full items-center gap-2"
-      >
-        <MessageSquare className="size-3 text-muted-foreground/60" />
-        <span className="text-[11px] font-medium text-muted-foreground">Agent 通信</span>
-        <span className="text-[10px] text-muted-foreground/50 ml-auto">
-          {messages.length} 条消息
-          {systemCount > 0 && (
-            <span className="text-muted-foreground/40"> · {systemCount} 系统</span>
-          )}
-        </span>
-        <ChevronDown className={cn(
-          'size-3 text-muted-foreground/40 transition-transform duration-200',
-          collapsed && '-rotate-90',
-        )} />
-      </button>
-
-      {/* 消息列表 */}
-      {!collapsed && messages.length > 0 && (
-        <div className="mt-2 flex flex-col gap-1.5">
-          {messages.map((msg, i) => (
-            <MailboxMessageRow key={i} message={msg} />
-          ))}
-        </div>
-      )}
-    </div>
-  )
-}
-
-function MailboxMessageRow({ message }: { message: TimelineMessage }): React.ReactElement {
-  const isTaskAssignment = message.parsedType === 'task_assignment'
-
-  // 提取可读内容
-  let displayText = message.summary ?? message.text
-  try {
-    const parsed = JSON.parse(message.text) as Record<string, unknown>
-    if (typeof parsed.content === 'string') displayText = parsed.content
-  } catch {
-    // 非 JSON，使用原文
-  }
-
-  return (
-    <div className="flex items-start gap-2 rounded-md bg-foreground/[0.02] dark:bg-foreground/[0.04] px-2.5 py-2">
-      {/* 消息类型图标 */}
-      {isTaskAssignment ? (
-        <Send className="size-3 text-blue-500 mt-0.5 shrink-0" />
-      ) : (
-        <MessageSquare className="size-3 text-muted-foreground/50 mt-0.5 shrink-0" />
-      )}
-
-      <div className="flex-1 min-w-0">
-        {/* 发送者 → 接收者 */}
-        <div className="flex items-center gap-1 mb-0.5">
-          <span className={cn(
-            'text-[10px] font-medium',
-            isTaskAssignment ? 'text-blue-600 dark:text-blue-400' : 'text-muted-foreground/70',
-          )}>
-            {message.from}
-          </span>
-          <ArrowRight className="size-2 text-muted-foreground/30" />
-          <span className="text-[10px] text-muted-foreground/50">{message.recipient}</span>
-          {message.timestamp && (
-            <span className="ml-auto text-[9px] text-muted-foreground/40">
-              {new Date(message.timestamp).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' })}
-            </span>
-          )}
-        </div>
-
-        {/* 消息内容 */}
-        <p className="text-[11px] text-muted-foreground/70 leading-relaxed line-clamp-3 break-all">
-          {displayText}
-        </p>
-      </div>
-    </div>
-  )
-}
-
-// ============================================================================
-// AgentCard — Agent 信息 + TeammateState 实时数据
-// ============================================================================
-
-interface AgentCardProps {
-  agent: TeamAgentInfo
-  expanded: boolean
-  onToggle: () => void
-}
-
-function AgentCard({ agent, expanded, onToggle }: AgentCardProps): React.ReactElement {
-  const tm = agent.teammate
-  const isRunning = tm?.status === 'running' || (!tm && agent.status === 'running')
-  const elapsed = useTeammateElapsed(tm ?? null)
-
-  return (
-    <div className={cn(
-      'rounded-lg transition-colors',
-      'bg-foreground/[0.03] dark:bg-foreground/[0.05]',
-      expanded && 'bg-foreground/[0.05] dark:bg-foreground/[0.07]',
-    )}>
-      <button
-        type="button"
-        onClick={onToggle}
-        className="group flex w-full flex-col gap-1.5 px-3 py-2.5 text-left hover:bg-foreground/[0.02] dark:hover:bg-foreground/[0.03] rounded-lg transition-colors"
-      >
-        {/* 头部：名称 + 类型 + 状态 */}
-        <div className="flex items-center gap-2">
-          <span className="text-xs font-medium">{agent.name}</span>
-          {agent.subagentType && agent.subagentType !== 'general-purpose' && (
-            <Badge variant="outline" className="h-4 rounded-full px-1.5 text-[9px] text-muted-foreground/60">
-              {agent.subagentType}
-            </Badge>
-          )}
-          {agent.isBackground && (
-            <Badge variant="outline" className="h-4 rounded-full px-1.5 text-[9px] text-muted-foreground/60">
-              后台
-            </Badge>
-          )}
-          <div className="ml-auto flex items-center gap-1.5">
-            <TeammateStatusBadge status={tm?.status} activityStatus={agent.status} />
-            <ChevronDown className={cn(
-              'size-3 text-muted-foreground/40 transition-transform duration-200',
-              expanded && 'rotate-180',
-            )} />
-          </div>
-        </div>
-
-        {/* 任务描述 */}
-        <p className={cn('text-[11px] text-muted-foreground/70 leading-relaxed', !expanded && 'line-clamp-2')}>
-          {agent.description}
-        </p>
-
-        {/* 运行中：当前工具 + 进度描述 + 工具链 */}
-        {isRunning && tm && (
-          <div className="flex flex-col gap-1.5">
-            {/* 当前工具（高亮卡片） */}
-            {tm.currentToolName && (
-              <div className="flex items-center gap-1.5 rounded-md bg-blue-500/5 dark:bg-blue-500/10 px-2 py-1">
-                <Wrench className="size-2.5 text-blue-500 animate-pulse" />
-                <span className="text-[11px] text-blue-600 dark:text-blue-400 font-mono truncate flex-1">
-                  {tm.currentToolName}
-                </span>
-                {tm.currentToolElapsedSeconds != null && tm.currentToolElapsedSeconds > 0 && (
-                  <span className="text-[10px] tabular-nums text-muted-foreground/50">
-                    {formatElapsed(tm.currentToolElapsedSeconds)}
-                  </span>
-                )}
-              </div>
-            )}
-            {/* 进度描述（2 行） */}
-            {tm.progressDescription && (
-              <p className="text-[11px] text-muted-foreground/60 italic leading-relaxed line-clamp-2">
-                {tm.progressDescription}
-              </p>
-            )}
-            {/* 工具链（最近 5 个工具） */}
-            {tm.toolHistory.length > 0 && (
-              <div className="flex items-center gap-1 flex-wrap">
-                {tm.toolHistory.slice(-5).map((tool, i, arr) => (
-                  <Fragment key={`${tool}-${i}`}>
-                    <span className="text-[10px] font-mono text-muted-foreground/50 bg-foreground/[0.04] dark:bg-foreground/[0.06] rounded px-1 py-0.5">
-                      {tool}
-                    </span>
-                    {i < arr.length - 1 && (
-                      <span className="text-[9px] text-muted-foreground/30">→</span>
-                    )}
-                  </Fragment>
-                ))}
-              </div>
-            )}
-          </div>
-        )}
-
-        {/* 已完成：摘要 */}
-        {!expanded && tm?.status === 'completed' && tm.summary && (
-          <p className="text-[11px] text-green-700/70 dark:text-green-400/70 line-clamp-2">
-            {tm.summary}
-          </p>
-        )}
-
-        {/* 底部统计 */}
-        <div className="flex items-center gap-3 text-[10px] text-muted-foreground/50">
-          {elapsed && (
-            <span className="flex items-center gap-1">
-              <Clock className="size-2.5" />
-              {elapsed}
-            </span>
-          )}
-          {tm?.usage && (
-            <>
-              <span className="flex items-center gap-1">
-                <Wrench className="size-2.5" />
-                {tm.usage.toolUses}
-              </span>
-              <span className="flex items-center gap-1">
-                <Zap className="size-2.5" />
-                {formatTokens(tm.usage.totalTokens)}
-              </span>
-            </>
-          )}
-          {tm && tm.toolHistory.length > 0 && (
-            <span className="ml-auto text-[10px] text-muted-foreground/40">
-              {tm.toolHistory.length} 个工具
-            </span>
-          )}
-        </div>
-      </button>
-
-      {/* 展开详情 */}
-      {expanded && <AgentDetail agent={agent} />}
-    </div>
-  )
-}
-
-function AgentDetail({ agent }: { agent: TeamAgentInfo }): React.ReactElement {
-  const tm = agent.teammate
-  const hasSummary = !!tm?.summary
-  const hasProgress = tm?.status === 'running' && !!tm.progressDescription
-  const hasToolHistory = tm && tm.toolHistory.length > 0
-  const hasOutput = !!tm?.outputFile
-  const hasUsage = !!tm?.usage
-  const hasAnyContent = hasSummary || hasProgress || hasToolHistory || hasOutput || hasUsage
-
-  return (
-    <div className="flex flex-col gap-2.5 px-3 pb-3">
-      <Separator />
-
-      {/* 工作摘要 */}
-      {hasSummary && (
-        <DetailSection title="工作摘要" borderColor="border-l-green-500">
-          <MarkdownContent content={tm!.summary!} />
-        </DetailSection>
-      )}
-
-      {/* 当前进度（运行中） */}
-      {hasProgress && (
-        <DetailSection title="当前进度" borderColor="border-l-blue-500">
-          <p className="text-[11px] text-muted-foreground/70 leading-relaxed">
-            {tm!.progressDescription}
-          </p>
-        </DetailSection>
-      )}
-
-      {/* 使用量统计 */}
-      {hasUsage && (
-        <DetailSection title="使用量" borderColor="border-l-violet-500">
-          <div className="flex items-center gap-4 text-[11px] text-muted-foreground/70">
-            <span className="flex items-center gap-1">
-              <Wrench className="size-2.5" />
-              {tm!.usage!.toolUses} 次工具调用
-            </span>
-            <span className="flex items-center gap-1">
-              <Zap className="size-2.5" />
-              {formatTokens(tm!.usage!.totalTokens)} tokens
-            </span>
-            {tm!.usage!.durationMs > 0 && (
-              <span className="flex items-center gap-1">
-                <Clock className="size-2.5" />
-                {formatElapsed(tm!.usage!.durationMs / 1000)}
-              </span>
-            )}
-          </div>
-        </DetailSection>
-      )}
-
-      {/* 工具使用历史 */}
-      {hasToolHistory && (
-        <ToolHistorySection toolHistory={tm!.toolHistory} />
-      )}
-
-      {/* 产出文件 */}
-      {hasOutput && (
-        <OutputFileSection filePath={tm!.outputFile!} />
-      )}
-
-      {/* 无详细数据时的提示 */}
-      {!hasAnyContent && (
-        <p className="text-[11px] text-muted-foreground/40 text-center py-2">
-          {tm?.status === 'running'
-            ? '等待 Agent 返回进度数据...'
-            : agent.status === 'running'
-              ? 'Agent 正在初始化...'
-              : '暂无详细数据'}
-        </p>
-      )}
-    </div>
-  )
-}
-
-// ============================================================================
-// TeammateCard — 回退方案（无 overview 时使用）
-// ============================================================================
-
-interface TeammateCardProps {
-  teammate: TeammateState
-  expanded: boolean
-  onToggle: () => void
-}
-
-function TeammateCard({ teammate, expanded, onToggle }: TeammateCardProps): React.ReactElement {
-  const isRunning = teammate.status === 'running'
-  const elapsed = useTeammateElapsed(teammate)
-
-  return (
-    <div className={cn(
-      'rounded-lg transition-colors',
-      'bg-foreground/[0.03] dark:bg-foreground/[0.05]',
-      expanded && 'bg-foreground/[0.05] dark:bg-foreground/[0.07]',
-    )}>
-      <button
-        type="button"
-        onClick={onToggle}
-        className="group flex w-full flex-col gap-1.5 px-3 py-2.5 text-left hover:bg-foreground/[0.02] dark:hover:bg-foreground/[0.03] rounded-lg transition-colors"
-      >
-        <div className="flex items-center gap-2">
-          <span className="text-[11px] font-mono text-muted-foreground/70">#{teammate.index}</span>
-          <TeammateStatusBadge status={teammate.status} />
-          <ChevronDown className={cn(
-            'ml-auto size-3 text-muted-foreground/40 transition-transform duration-200',
-            expanded && 'rotate-180',
-          )} />
-        </div>
-
-        <p className={cn('text-xs leading-relaxed', !expanded && 'line-clamp-2')}>{teammate.description}</p>
-
-        {isRunning && (
-          <div className="flex flex-col gap-1.5">
-            {teammate.currentToolName && (
-              <div className="flex items-center gap-1.5 rounded-md bg-blue-500/5 dark:bg-blue-500/10 px-2 py-1">
-                <Wrench className="size-2.5 text-blue-500 animate-pulse" />
-                <span className="text-[11px] text-blue-600 dark:text-blue-400 font-mono truncate flex-1">
-                  {teammate.currentToolName}
-                </span>
-                {teammate.currentToolElapsedSeconds != null && teammate.currentToolElapsedSeconds > 0 && (
-                  <span className="text-[10px] tabular-nums text-muted-foreground/50">
-                    {formatElapsed(teammate.currentToolElapsedSeconds)}
-                  </span>
-                )}
-              </div>
-            )}
-            {teammate.progressDescription && (
-              <p className="text-[11px] text-muted-foreground/60 italic leading-relaxed line-clamp-2">
-                {teammate.progressDescription}
-              </p>
-            )}
-            {teammate.toolHistory.length > 0 && (
-              <div className="flex items-center gap-1 flex-wrap">
-                {teammate.toolHistory.slice(-5).map((tool, i, arr) => (
-                  <Fragment key={`${tool}-${i}`}>
-                    <span className="text-[10px] font-mono text-muted-foreground/50 bg-foreground/[0.04] dark:bg-foreground/[0.06] rounded px-1 py-0.5">
-                      {tool}
-                    </span>
-                    {i < arr.length - 1 && (
-                      <span className="text-[9px] text-muted-foreground/30">→</span>
-                    )}
-                  </Fragment>
-                ))}
-              </div>
-            )}
-          </div>
-        )}
-
-        {!expanded && teammate.status === 'completed' && teammate.summary && (
-          <p className="text-[11px] text-green-700/70 dark:text-green-400/70 line-clamp-2">
-            {teammate.summary}
-          </p>
-        )}
-
-        <div className="flex items-center gap-3 text-[10px] text-muted-foreground/50">
-          {elapsed && (
-            <span className="flex items-center gap-1">
-              <Clock className="size-2.5" />
-              {elapsed}
-            </span>
-          )}
-          {teammate.usage && (
-            <>
-              <span className="flex items-center gap-1">
-                <Wrench className="size-2.5" />
-                {teammate.usage.toolUses}
-              </span>
-              <span className="flex items-center gap-1">
-                <Zap className="size-2.5" />
-                {formatTokens(teammate.usage.totalTokens)}
-              </span>
-            </>
-          )}
-        </div>
-      </button>
-
-      {expanded && (
-        <div className="flex flex-col gap-2.5 px-3 pb-3">
-          <Separator />
-          {teammate.summary && (
-            <DetailSection title="工作摘要" borderColor="border-l-green-500">
-              <MarkdownContent content={teammate.summary} />
-            </DetailSection>
-          )}
-          {teammate.status === 'running' && teammate.progressDescription && (
-            <DetailSection title="当前进度" borderColor="border-l-blue-500">
-              <p className="text-[11px] text-muted-foreground/70 leading-relaxed">
-                {teammate.progressDescription}
-              </p>
-            </DetailSection>
-          )}
-          {teammate.usage && (
-            <DetailSection title="使用量" borderColor="border-l-violet-500">
-              <div className="flex items-center gap-4 text-[11px] text-muted-foreground/70">
-                <span className="flex items-center gap-1">
-                  <Wrench className="size-2.5" />
-                  {teammate.usage.toolUses} 次工具调用
-                </span>
-                <span className="flex items-center gap-1">
-                  <Zap className="size-2.5" />
-                  {formatTokens(teammate.usage.totalTokens)} tokens
-                </span>
-                {teammate.usage.durationMs > 0 && (
-                  <span className="flex items-center gap-1">
-                    <Clock className="size-2.5" />
-                    {formatElapsed(teammate.usage.durationMs / 1000)}
-                  </span>
-                )}
-              </div>
-            </DetailSection>
-          )}
-          {teammate.toolHistory.length > 0 && (
-            <ToolHistorySection toolHistory={teammate.toolHistory} />
-          )}
-          {teammate.outputFile && (
-            <OutputFileSection filePath={teammate.outputFile} />
-          )}
-          {!teammate.summary && !teammate.usage && teammate.toolHistory.length === 0 && !teammate.outputFile && (
-            <p className="text-[11px] text-muted-foreground/40 text-center py-2">
-              {teammate.status === 'running' ? '等待 Agent 返回进度数据...' : '暂无详细数据'}
-            </p>
-          )}
-        </div>
-      )}
-    </div>
-  )
-}
-
-// ============================================================================
-// 共享子组件
-// ============================================================================
-
-function TeammateStatusBadge({
-  status,
-  activityStatus,
-}: {
-  status?: TeammateState['status']
-  activityStatus?: string
-}): React.ReactElement {
-  const s = status ?? (activityStatus === 'completed' ? 'completed' : activityStatus === 'error' ? 'failed' : 'running')
-  switch (s) {
-    case 'running':
-      return (
-        <Badge variant="secondary" className="h-4 gap-1 rounded-full px-1.5 text-[10px] bg-blue-500/10 text-blue-600 dark:text-blue-400">
-          <Loader2 className="size-2 animate-spin" />
-          运行中
-        </Badge>
-      )
-    case 'completed':
-      return (
-        <Badge variant="secondary" className="h-4 gap-1 rounded-full px-1.5 text-[10px] bg-green-500/10 text-green-600 dark:text-green-400">
-          <CheckCircle2 className="size-2" />
-          已完成
-        </Badge>
-      )
-    case 'failed':
-      return (
-        <Badge variant="secondary" className="h-4 gap-1 rounded-full px-1.5 text-[10px] bg-red-500/10 text-red-600 dark:text-red-400">
-          <XCircle className="size-2" />
-          失败
-        </Badge>
-      )
-    case 'stopped':
-      return (
-        <Badge variant="secondary" className="h-4 gap-1 rounded-full px-1.5 text-[10px] bg-yellow-500/10 text-yellow-600 dark:text-yellow-400">
-          <StopCircle className="size-2" />
-          已停止
-        </Badge>
-      )
-    default:
-      return (
-        <Badge variant="secondary" className="h-4 gap-1 rounded-full px-1.5 text-[10px] bg-muted text-muted-foreground/60">
-          <Circle className="size-2" />
-          等待中
-        </Badge>
-      )
-  }
-}
-
-function DetailSection({
-  title,
-  borderColor,
-  children,
-}: {
-  title: string
-  borderColor?: string
-  children: React.ReactNode
-}): React.ReactElement {
-  return (
-    <div className={cn('rounded-md border-l-2 bg-foreground/[0.02] dark:bg-foreground/[0.04] px-3 py-2', borderColor)}>
-      <p className="text-[10px] font-medium text-muted-foreground/60 mb-1.5">{title}</p>
-      {children}
-    </div>
-  )
-}
-
-function ToolHistorySection({ toolHistory }: { toolHistory: string[] }): React.ReactElement {
-  const counts = new Map<string, number>()
-  for (const tool of toolHistory) {
-    counts.set(tool, (counts.get(tool) ?? 0) + 1)
-  }
-  const sorted = Array.from(counts.entries()).sort((a, b) => b[1] - a[1])
-
-  return (
-    <DetailSection title="工具使用" borderColor="border-l-muted-foreground/30">
-      <div className="flex flex-wrap gap-1 mb-2">
-        {sorted.map(([tool, count]) => (
-          <Badge
-            key={tool}
-            variant="secondary"
-            className="h-4 gap-0.5 rounded-full px-1.5 text-[10px] bg-foreground/[0.04] dark:bg-foreground/[0.06]"
-          >
-            {tool}
-            {count > 1 && <span className="text-muted-foreground/50">×{count}</span>}
-          </Badge>
-        ))}
-      </div>
-      <p className="text-[10px] text-muted-foreground/40 font-mono leading-relaxed break-all">
-        {toolHistory.join(' → ')}
-      </p>
-    </DetailSection>
-  )
-}
-
-function OutputFileSection({ filePath }: { filePath: string }): React.ReactElement {
-  const [content, setContent] = useState<string | null>(null)
-  const [loading, setLoading] = useState(true)
-
-  useEffect(() => {
-    setLoading(true)
-    window.electronAPI
-      .getAgentOutput(filePath)
-      .then((text) => setContent(text))
-      .catch(() => setContent(null))
-      .finally(() => setLoading(false))
-  }, [filePath])
-
-  return (
-    <DetailSection title="产出文件" borderColor="border-l-amber-500">
-      <div className="flex items-center gap-1.5 mb-1.5">
-        <FileText className="size-2.5 text-muted-foreground/50" />
-        <span className="text-[10px] font-mono text-muted-foreground/50 truncate">{filePath}</span>
-      </div>
-      {loading ? (
-        <div className="flex items-center gap-1.5 text-[11px] text-muted-foreground/50">
-          <Loader2 className="size-2.5 animate-spin" />
-          加载中...
-        </div>
-      ) : content ? (
-        <div className="max-h-[200px] overflow-auto rounded bg-foreground/[0.02] dark:bg-foreground/[0.04] p-2">
-          <MarkdownContent content={content} />
-        </div>
-      ) : (
-        <p className="text-[10px] text-muted-foreground/40">无法读取文件内容</p>
-      )}
-    </DetailSection>
-  )
-}
-
-function MarkdownContent({ content }: { content: string }): React.ReactElement {
-  return (
-    <div className="prose dark:prose-invert max-w-none text-[11px] prose-p:my-0.5 prose-li:leading-relaxed prose-pre:my-0 [&>*:first-child]:mt-0 [&>*:last-child]:mb-0">
-      <Markdown remarkPlugins={[remarkGfm]}>{content}</Markdown>
-    </div>
-  )
-}
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function formatTokens(tokens: number): string {
-  if (tokens < 1000) return `${tokens}`
-  if (tokens < 1_000_000) return `${(tokens / 1000).toFixed(1)}K`
-  return `${(tokens / 1_000_000).toFixed(1)}M`
-}
-
-/** 实时耗时 — 支持 TeammateState 或 null */
-function useTeammateElapsed(teammate: TeammateState | null): string | null {
-  const [now, setNow] = useState(Date.now())
-
-  useEffect(() => {
-    if (!teammate || teammate.status !== 'running') return
-    const timer = setInterval(() => setNow(Date.now()), 1000)
-    return () => clearInterval(timer)
-  }, [teammate?.status])
-
-  if (!teammate) return null
-  const endTime = teammate.endedAt ?? now
-  const durationMs = endTime - teammate.startedAt
-  const seconds = Math.max(0, durationMs / 1000)
-  return formatElapsed(seconds)
-}
diff --git a/apps/electron/src/renderer/components/agent/TodoListPanel.tsx b/apps/electron/src/renderer/components/agent/TodoListPanel.tsx
new file mode 100644
index 00000000..5af7796e
--- /dev/null
+++ b/apps/electron/src/renderer/components/agent/TodoListPanel.tsx
@@ -0,0 +1,192 @@
+/**
+ * TodoListPanel — 待办事项列表面板
+ *
+ * 显示在消息输入框上方，展示当前任务的待办事项列表和进度。
+ */
+
+import * as React from 'react'
+import { useAtom, useSetAtom } from 'jotai'
+import { ChevronDown, ChevronUp, X, CheckCircle2, Circle, Loader2, ListTodo } from 'lucide-react'
+import { cn } from '@/lib/utils'
+import type { TodoGroupState, TodoItem } from '@/atoms/agent-atoms'
+import { agentTodoGroupsMapAtom, currentAgentSessionIdAtom, dismissTodoGroupAtom } from '@/atoms/agent-atoms'
+
+/** TodoListPanel 属性 */
+interface TodoListPanelProps {
+  /** 当前会话 ID */
+  sessionId: string
+}
+
+/** 单个待办事项项 */
+function TodoItemRow({ todo }: { todo: TodoItem }): React.ReactElement {
+  const getStatusIcon = () => {
+    switch (todo.status) {
+      case 'completed':
+        return <CheckCircle2 className="size-4 text-green-500 shrink-0" />
+      case 'in_progress':
+        return <Loader2 className="size-4 text-blue-500 animate-spin shrink-0" />
+      case 'pending':
+      default:
+        return <Circle className="size-4 text-muted-foreground/50 shrink-0" />
+    }
+  }
+
+  const getStatusText = () => {
+    if (todo.status === 'in_progress' && todo.activeForm) {
+      return todo.activeForm
+    }
+    return todo.content
+  }
+
+  const isCompleted = todo.status === 'completed'
+  const isInProgress = todo.status === 'in_progress'
+
+  return (
+    <div className="flex items-start gap-2 py-1">
+      {getStatusIcon()}
+      <span
+        className={cn(
+          'text-sm leading-relaxed',
+          isCompleted && 'text-muted-foreground line-through',
+          isInProgress && 'text-foreground font-medium',
+          !isCompleted && !isInProgress && 'text-muted-foreground'
+        )}
+      >
+        {getStatusText()}
+      </span>
+    </div>
+  )
+}
+
+/** 待办事项组卡片 */
+function TodoGroupCard({
+  group,
+  sessionId,
+}: {
+  group: TodoGroupState
+  sessionId: string
+}): React.ReactElement {
+  const [isExpanded, setIsExpanded] = React.useState(true)
+  const dismissGroup = useSetAtom(dismissTodoGroupAtom)
+
+  const completedCount = group.todos.filter((t) => t.status === 'completed').length
+  const totalCount = group.todos.length
+  const progress = totalCount > 0 ? (completedCount / totalCount) * 100 : 0
+
+  const handleDismiss = () => {
+    dismissGroup({ sessionId, groupId: group.groupId })
+  }
+
+  return (
+    <div className="bg-card/95 backdrop-blur-sm border rounded-lg shadow-lg overflow-hidden">
+      {/* 标题栏 */}
+      <div className="flex items-center gap-2 px-3 py-2 bg-muted/50 border-b">
+        <ListTodo className="size-4 text-primary shrink-0" />
+        <span className="text-sm font-medium flex-1">任务进度</span>
+        <span className="text-xs text-muted-foreground">
+          {completedCount}/{totalCount} 已完成
+        </span>
+        <button
+          type="button"
+          onClick={() => setIsExpanded(!isExpanded)}
+          className="p-1 rounded hover:bg-muted transition-colors"
+          title={isExpanded ? '收起' : '展开'}
+        >
+          {isExpanded ? (
+            <ChevronDown className="size-4 text-muted-foreground" />
+          ) : (
+            <ChevronUp className="size-4 text-muted-foreground" />
+          )}
+        </button>
+        <button
+          type="button"
+          onClick={handleDismiss}
+          className="p-1 rounded hover:bg-muted transition-colors"
+          title="关闭"
+        >
+          <X className="size-4 text-muted-foreground" />
+        </button>
+      </div>
+
+      {/* 进度条 */}
+      <div className="h-1 bg-muted">
+        <div
+          className="h-full bg-primary transition-all duration-300 ease-out"
+          style={{ width: `${progress}%` }}
+        />
+      </div>
+
+      {/* 待办事项列表 */}
+      {isExpanded && (
+        <div className="px-3 py-2 max-h-[200px] overflow-y-auto">
+          <div className="space-y-0.5">
+            {group.todos.map((todo) => (
+              <TodoItemRow key={todo.id} todo={todo} />
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
+/** 待办事项列表面板 */
+export function TodoListPanel({ sessionId }: TodoListPanelProps): React.ReactElement | null {
+  const [todoGroupsMap] = useAtom(agentTodoGroupsMapAtom)
+  const sessionMap = todoGroupsMap.get(sessionId)
+
+  if (!sessionMap) return null
+
+  // 获取活动（未关闭且未完成）的待办事项组，按更新时间倒序
+  const activeGroups = Array.from(sessionMap.values())
+    .filter((g) => !g.isDismissed && !g.isCompleted)
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+
+  if (activeGroups.length === 0) return null
+
+  // 只显示最新的一个待办事项组
+  const latestGroup = activeGroups[0]
+  if (!latestGroup) return null
+
+  return (
+    <div className="px-4 py-2 border-t bg-background/95">
+      <TodoGroupCard group={latestGroup} sessionId={sessionId} />
+    </div>
+  )
+}
+
+/** Hook：更新待办事项状态（从 AgentEvent） */
+export function useTodoUpdater() {
+  const [todoGroupsMap, setTodoGroupsMap] = useAtom(agentTodoGroupsMapAtom)
+  const currentSessionId = useAtom(currentAgentSessionIdAtom)
+
+  const updateTodos = React.useCallback(
+    (sessionId: string, groupId: string, todos: TodoItem[]) => {
+      setTodoGroupsMap((prev) => {
+        const next = new Map(prev)
+        let sessionMap = next.get(sessionId)
+        if (!sessionMap) {
+          sessionMap = new Map()
+          next.set(sessionId, sessionMap)
+        }
+
+        const existingGroup = sessionMap.get(groupId)
+        const isCompleted = todos.every((t) => t.status === 'completed')
+
+        sessionMap.set(groupId, {
+          groupId,
+          todos,
+          createdAt: existingGroup?.createdAt ?? Date.now(),
+          updatedAt: Date.now(),
+          isCompleted,
+          isDismissed: existingGroup?.isDismissed ?? false,
+        })
+
+        return next
+      })
+    },
+    [setTodoGroupsMap]
+  )
+
+  return { updateTodos, todoGroupsMap, currentSessionId }
+}
diff --git a/apps/electron/src/renderer/components/agent/ToolActivityItem.tsx b/apps/electron/src/renderer/components/agent/ToolActivityItem.tsx
index 814e568e..e9ffa1fb 100644
--- a/apps/electron/src/renderer/components/agent/ToolActivityItem.tsx
+++ b/apps/electron/src/renderer/components/agent/ToolActivityItem.tsx
@@ -21,7 +21,6 @@ import {
   Globe,
   BookOpen,
   Zap,
-  ListTodo,
   Wrench,
   CheckCircle2,
   XCircle,
@@ -30,7 +29,6 @@ import {
   ChevronRight,
   MessageCircleDashed,
   Plus,
-  Users,
   ImagePlus,
   Download,
 } from 'lucide-react'
@@ -69,14 +67,6 @@ const TOOL_ICONS: Record<string, React.ComponentType<{ className?: string }>> =
   WebSearch: Globe,
   NotebookEdit: BookOpen,
   Skill: Zap,
-  TodoWrite: ListTodo,
-  TodoRead: ListTodo,
-  TaskCreate: ListTodo,
-  TaskUpdate: ListTodo,
-  TaskGet: ListTodo,
-  TaskList: ListTodo,
-  TeamCreate: Users,
-  Agent: Users,
   generate_image: ImagePlus,
 }
 
@@ -227,28 +217,6 @@ function getInputSummary(toolName: string, input: Record<string, unknown>): stri
     const desc = input.description ?? input.prompt
     if (typeof desc === 'string') return desc.length > 80 ? desc.slice(0, 80) + '…' : desc
   }
-  // TaskCreate：显示 subject
-  if (toolName === 'TaskCreate') {
-    const subject = input.subject
-    if (typeof subject === 'string') return subject.length > 80 ? subject.slice(0, 80) + '…' : subject
-  }
-  // TaskUpdate：显示状态变更
-  if (toolName === 'TaskUpdate') {
-    const parts: string[] = []
-    if (typeof input.taskId === 'string') parts.push(`#${input.taskId}`)
-    if (typeof input.status === 'string') parts.push(input.status)
-    if (typeof input.subject === 'string') parts.push(input.subject.length > 60 ? input.subject.slice(0, 60) + '…' : input.subject)
-    return parts.length > 0 ? parts.join(' ') : null
-  }
-  // TaskGet / TaskList：显示 taskId 或 reason
-  if (toolName === 'TaskGet') {
-    const taskId = input.taskId
-    if (typeof taskId === 'string') return `#${taskId}`
-  }
-  if (toolName === 'TaskList') {
-    const reason = input.reason
-    if (typeof reason === 'string') return reason.length > 80 ? reason.slice(0, 80) + '…' : reason
-  }
   // Read：显示文件路径
   if (toolName === 'Read') {
     const fp = input.file_path ?? input.filePath
@@ -273,30 +241,6 @@ function getInputSummary(toolName: string, input: Record<string, unknown>): stri
       return filename
     }
   }
-  // TodoWrite：显示任务数量
-  if (toolName === 'TodoWrite') {
-    const todos = input.todos
-    if (Array.isArray(todos)) return `${todos.length} 项任务`
-  }
-  // TeamCreate：显示 team_name + description
-  if (toolName === 'TeamCreate') {
-    const name = input.team_name
-    const desc = input.description
-    if (typeof name === 'string') {
-      if (typeof desc === 'string') return `${name} · ${desc.length > 60 ? desc.slice(0, 60) + '…' : desc}`
-      return name
-    }
-  }
-  // Agent：显示 name + description
-  if (toolName === 'Agent') {
-    const agentName = input.name
-    const desc = input.description ?? input.prompt
-    if (typeof agentName === 'string' && typeof desc === 'string') {
-      return `${agentName} · ${desc.length > 60 ? desc.slice(0, 60) + '…' : desc}`
-    }
-    if (typeof desc === 'string') return desc.length > 80 ? desc.slice(0, 80) + '…' : desc
-    if (typeof agentName === 'string') return agentName
-  }
   // generate_image (Nano Banana MCP)：显示 prompt
   if (toolName === 'generate_image') {
     const prompt = input.prompt
@@ -315,49 +259,6 @@ function formatInput(input: Record<string, unknown>): string {
   try { return JSON.stringify(filtered, null, 2) } catch { return '[不可序列化]' }
 }
 
-// ===== TodoWrite 可视化 =====
-
-interface TodoItem {
-  content: string
-  status: 'pending' | 'in_progress' | 'completed'
-  activeForm?: string
-}
-
-function parseTodoItems(input: Record<string, unknown>): TodoItem[] | null {
-  if (input.todos && Array.isArray(input.todos)) {
-    return (input.todos as Array<Record<string, unknown>>).map((t) => ({
-      content: String(t.subject ?? t.content ?? ''),
-      status: (t.status as TodoItem['status']) ?? 'pending',
-      activeForm: typeof t.activeForm === 'string' ? t.activeForm : undefined,
-    }))
-  }
-  return null
-}
-
-function TodoList({ items }: { items: TodoItem[] }): React.ReactElement {
-  return (
-    <div className="pl-5 space-y-0.5 border-l-2 border-muted ml-[5px]">
-      {items.map((todo, i) => (
-        <div
-          key={i}
-          className={cn(
-            'flex items-center gap-2 text-[13px]',
-            SIZE.row,
-            todo.status === 'completed' && 'opacity-50',
-          )}
-        >
-          {todo.status === 'pending' && <Circle className={cn(SIZE.icon, 'text-muted-foreground/50')} />}
-          {todo.status === 'in_progress' && <Loader2 className={cn(SIZE.spinner, 'animate-spin text-blue-500')} />}
-          {todo.status === 'completed' && <CheckCircle2 className={cn(SIZE.icon, 'text-green-500')} />}
-          <span className={cn('truncate flex-1', todo.status === 'completed' && 'line-through')}>
-            {todo.status === 'in_progress' && todo.activeForm ? todo.activeForm : todo.content}
-          </span>
-        </div>
-      ))}
-    </div>
-  )
-}
-
 // ===== 活动行 =====
 
 export interface ActivityRowProps {
@@ -751,25 +652,6 @@ export function ToolActivityList({ activities, animate = false }: ToolActivityLi
 
         const activity = item as ToolActivity
 
-        // TodoWrite / TaskCreate 特殊渲染
-        if (activity.toolName === 'TodoWrite' || activity.toolName === 'TaskCreate') {
-          const todos = parseTodoItems(activity.input)
-          if (todos && todos.length > 0) {
-            return (
-              <React.Fragment key={activity.toolUseId}>
-                <ActivityRow
-                  activity={activity}
-                  index={i}
-                  animate={animate}
-                  // 不传递 onOpenDetails，TodoWrite/TaskCreate 不支持点击展开详情
-                  // 因为它们已经有专属的 TodoList 展示
-                />
-                <TodoList items={todos} />
-              </React.Fragment>
-            )
-          }
-        }
-
         return (
           <React.Fragment key={activity.toolUseId}>
             <ActivityRow
diff --git a/apps/electron/src/renderer/components/agent/index.ts b/apps/electron/src/renderer/components/agent/index.ts
index b6db985d..a5d92ece 100644
--- a/apps/electron/src/renderer/components/agent/index.ts
+++ b/apps/electron/src/renderer/components/agent/index.ts
@@ -8,3 +8,4 @@ export * from './AgentMessages'
 export * from './ToolActivityItem'
 export * from './WorkspaceSelector'
 export * from './ContextUsageBadge'
+export * from './TodoListPanel'
diff --git a/apps/electron/src/renderer/components/agent/mention-suggestions.tsx b/apps/electron/src/renderer/components/agent/mention-suggestions.tsx
index 82082443..8ca6896b 100644
--- a/apps/electron/src/renderer/components/agent/mention-suggestions.tsx
+++ b/apps/electron/src/renderer/components/agent/mention-suggestions.tsx
@@ -8,7 +8,7 @@
 import type React from 'react'
 import { ReactRenderer } from '@tiptap/react'
 import type { SuggestionOptions } from '@tiptap/suggestion'
-import { Sparkles, Server } from 'lucide-react'
+import { Sparkles, Server, Bot } from 'lucide-react'
 import { MentionList } from './MentionList'
 import type { MentionListRef } from './MentionList'
 import { createMentionPopup, positionPopup } from './mention-popup-utils'
@@ -172,3 +172,43 @@ export function createMcpMentionSuggestion(
     mentionActiveRef,
   )
 }
+
+// ===== 子代理配置 =====
+
+export interface AgentMentionItem {
+  id: string
+  name: string
+  description?: string
+}
+
+export function createAgentMentionSuggestion(
+  workspaceSlugRef: React.RefObject<string | null>,
+  mentionActiveRef: React.MutableRefObject<boolean>,
+) {
+  return createMentionSuggestion<AgentMentionItem>(
+    {
+      char: '!',
+      emptyText: '无匹配子代理',
+      fetchItems: async (slug, q) => {
+        const caps = await window.electronAPI.getWorkspaceCapabilities(slug)
+        return caps.agents
+          .filter((a) => a.enabled)
+          .filter((a) => !q || a.name.toLowerCase().includes(q) || (a.slug ?? '').toLowerCase().includes(q))
+          .map((a) => ({ id: a.slug, name: a.name, description: a.description }))
+      },
+      keyExtractor: (item) => item.id,
+      renderItem: (item) => (
+        <>
+          <Bot className="size-3.5 text-blue-500 flex-shrink-0" />
+          <span className="truncate font-medium flex-1 min-w-0">{item.name}</span>
+          {item.description && (
+            <span className="truncate text-[10px] text-muted-foreground/50 max-w-[120px]">{item.description}</span>
+          )}
+        </>
+      ),
+      toCommand: (item) => ({ id: item.id, label: item.name }),
+    },
+    workspaceSlugRef,
+    mentionActiveRef,
+  )
+}
diff --git a/apps/electron/src/renderer/components/ai-elements/message.tsx b/apps/electron/src/renderer/components/ai-elements/message.tsx
index 8bc5276e..5acf64f2 100644
--- a/apps/electron/src/renderer/components/ai-elements/message.tsx
+++ b/apps/electron/src/renderer/components/ai-elements/message.tsx
@@ -121,8 +121,7 @@ export function MessageContent({
     <div
       className={cn(
         'flex w-full max-w-full min-w-0 flex-col gap-2 overflow-hidden pl-[46px]',
-        'group-[.is-user]:text-foreground',
-        'group-[.is-assistant]:text-foreground',
+        'text-foreground',
         className
       )}
       {...props}
@@ -332,8 +331,10 @@ export const MessageResponse = React.memo(
 /** 折叠行数阈值 */
 const COLLAPSE_LINE_THRESHOLD = 4
 
-/** 将文本中的 @file:路径、/skill:名称、#mcp:名称 替换为样式化 chip */
-const MENTION_RE = /@file:(\S+)|\/skill:(\S+)|#mcp:(\S+)/g
+/** 将文本中的 @file:路径、/skill:名称、#mcp:名称 替换为样式化 chip
+ * 注意：文件路径可能包含空格，使用非贪婪匹配直到遇到下一个 mention 或行尾
+ */
+const MENTION_RE = /@file:([\s\S]*?)(?=\s@file:|\s\/skill:|\s#mcp:|$)|\/skill:(\S+)|#mcp:(\S+)/g
 
 function renderTextWithMentions(text: string): React.ReactNode {
   const parts: React.ReactNode[] = []
@@ -353,7 +354,7 @@ function renderTextWithMentions(text: string): React.ReactNode {
 
     if (match[1]) {
       // @file: 文件引用 — 蓝色 chip
-      const filePath = match[1]
+      const filePath = match[1].trim()
       const fileName = filePath.split('/').pop() || filePath
       parts.push(
         <span key={key} className="inline-flex items-center gap-0.5 bg-primary/10 text-primary rounded px-1 py-[1px] text-[13px] font-medium whitespace-nowrap align-baseline" title={filePath}>
@@ -423,8 +424,18 @@ export const UserMessageContent = React.memo(
       setIsExpanded((prev) => !prev)
     }, [])
 
+    const isRightAligned = className?.includes('text-right')
+
     return (
-      <div className={cn('relative rounded-[10px] bg-foreground/[0.045] dark:bg-foreground/[0.08] px-3.5 py-2.5', shouldCollapse && !isExpanded && 'pb-6', className)} {...props}>
+      <div
+        className={cn(
+          'user-message-bubble relative rounded-[10px] px-3.5 py-2.5 w-fit',
+          shouldCollapse && !isExpanded && 'pb-6',
+          isRightAligned && 'ml-auto',
+          className
+        )}
+        {...props}
+      >
         <div
           ref={contentRef}
           className={cn(
@@ -442,7 +453,7 @@ export const UserMessageContent = React.memo(
             className={cn(
               'flex items-center gap-1 text-xs text-foreground/40 hover:text-foreground/70 transition-colors mt-1',
               !isExpanded &&
-                'absolute bottom-0 left-0 right-0 px-3.5 pb-2.5 pt-4 rounded-b-[10px] bg-gradient-to-t from-foreground/[0.045] dark:from-foreground/[0.08] to-transparent'
+                'collapse-gradient absolute bottom-0 left-0 right-0 px-3.5 pb-2.5 pt-4 rounded-b-[10px]'
             )}
           >
             {isExpanded ? (
diff --git a/apps/electron/src/renderer/components/ai-elements/rich-text-input.tsx b/apps/electron/src/renderer/components/ai-elements/rich-text-input.tsx
index 745755a2..d83aed72 100644
--- a/apps/electron/src/renderer/components/ai-elements/rich-text-input.tsx
+++ b/apps/electron/src/renderer/components/ai-elements/rich-text-input.tsx
@@ -5,7 +5,7 @@
  *
  * 功能：
  * - StarterKit + Placeholder + Underline + Link + CodeBlockLowlight
- * - 可选 Mention 扩展（@ 引用文件、/ 触发 Skill、# 触发 MCP）
+ * - 可选 Mention 扩展（@ 引用文件、/ 触发 Skill、# 触发 MCP、! 触发子代理）
  * - htmlToMarkdown 转换
  * - IME composition 处理
  * - Enter 提交 / Shift+Enter 换行
@@ -26,7 +26,7 @@ import { ChevronsDownUp, ChevronsUpDown } from 'lucide-react'
 import { Tooltip, TooltipTrigger, TooltipContent } from '@/components/ui/tooltip'
 import { cn } from '@/lib/utils'
 import { createFileMentionSuggestion } from '@/components/file-browser/file-mention-suggestion'
-import { createSkillMentionSuggestion, createMcpMentionSuggestion } from '@/components/agent/mention-suggestions'
+import { createSkillMentionSuggestion, createMcpMentionSuggestion, createAgentMentionSuggestion } from '@/components/agent/mention-suggestions'
 
 // 创建 lowlight 实例，使用常见语言
 const lowlight = createLowlight(common)
@@ -119,6 +119,7 @@ function htmlToMarkdown(html: string): string {
         if (dataType === 'mention') {
           if (suggestionChar === '/') return `/skill:${dataId}`
           if (suggestionChar === '#') return `#mcp:${dataId}`
+          if (suggestionChar === '!') return `!agent:${dataId}`
           return `@file:${dataId}`
         }
         return children
@@ -184,12 +185,12 @@ interface RichTextInputProps {
   autoFocusTrigger?: string | null
   /** 是否支持手动折叠（内容较长时显示折叠按钮） */
   collapsible?: boolean
-  /** 工作区根路径（启用 @ 引用文件功能时需要） */
-  workspacePath?: string | null
-  /** 工作区 slug（启用 / Skill 和 # MCP 功能时需要） */
+  /** 工作区 ID（启用 @ 引用文件功能时需要） */
+  workspaceId?: string | null
+  /** 会话 ID（启用 @ 引用文件功能时需要） */
+  sessionId?: string | null
+  /** 工作区 slug（启用 / Skill、# MCP 和 @ 引用文件功能时需要） */
   workspaceSlug?: string | null
-  /** 附加目录路径列表（@ 引用时一并搜索） */
-  attachedDirs?: string[]
   className?: string
 }
 
@@ -210,9 +211,9 @@ export function RichTextInput({
   disabled = false,
   autoFocusTrigger,
   collapsible = false,
-  workspacePath,
+  workspaceId,
+  sessionId,
   workspaceSlug,
-  attachedDirs = [],
 }: RichTextInputProps): React.ReactElement {
   const [isExpanded, setIsExpanded] = useState(false)
   // 手动折叠状态：用户主动折叠输入框
@@ -229,22 +230,22 @@ export function RichTextInput({
   onPasteFilesRef.current = onPasteFiles
   // Mention 活跃状态（阻止 Enter 发送消息）
   const mentionActiveRef = useRef(false)
-  // 工作区路径引用（给 Suggestion 使用）
-  const workspacePathRef = useRef<string | null>(workspacePath ?? null)
-  workspacePathRef.current = workspacePath ?? null
-  // 附加目录路径引用（给 Suggestion 使用）
-  const attachedDirsRef = useRef<string[]>(attachedDirs)
-  attachedDirsRef.current = attachedDirs
-  // 工作区 slug 引用（给 Skill/MCP Suggestion 使用）
+  // 工作区 ID 引用（给文件 Mention Suggestion 使用）
+  const workspaceIdRef = useRef<string | null>(workspaceId ?? null)
+  workspaceIdRef.current = workspaceId ?? null
+  // 会话 ID 引用（给文件 Mention Suggestion 使用）
+  const sessionIdRef = useRef<string | null>(sessionId ?? null)
+  sessionIdRef.current = sessionId ?? null
+  // 工作区 slug 引用（给 Skill/MCP/文件 Mention Suggestion 使用）
   const workspaceSlugRef = useRef<string | null>(workspaceSlug ?? null)
   workspaceSlugRef.current = workspaceSlug ?? null
 
-  // 是否启用 Mention 功能（需要工作区路径或 slug）
-  const hasMentionSupport = !!(workspacePath || workspaceSlug)
+  // 是否启用 Mention 功能（需要工作区信息）
+  const hasMentionSupport = !!(workspaceId && sessionId) || !!workspaceSlug
 
-  // Mention Suggestion 配置（稳定引用，不随 workspacePath 变化重建）
+  // Mention Suggestion 配置（稳定引用）
   const mentionSuggestion = useMemo(
-    () => createFileMentionSuggestion(workspacePathRef, mentionActiveRef, attachedDirsRef),
+    () => createFileMentionSuggestion(workspaceIdRef, sessionIdRef, workspaceSlugRef, mentionActiveRef),
     [],
   )
 
@@ -260,6 +261,12 @@ export function RichTextInput({
     [],
   )
 
+  // Agent Suggestion 配置（! 触发）
+  const agentSuggestion = useMemo(
+    () => createAgentMentionSuggestion(workspaceSlugRef, mentionActiveRef),
+    [],
+  )
+
   const editor = useEditor({
     extensions: [
       StarterKit.configure({
@@ -287,7 +294,7 @@ export function RichTextInput({
         emptyEditorClass: 'is-editor-empty',
       }),
       // Mention 扩展：仅在 Agent 模式（有工作区）时启用
-      // @ 引用文件、/ 触发 Skill、# 触发 MCP
+      // @ 引用文件、/ 触发 Skill、# 触发 MCP、! 触发子代理
       ...(hasMentionSupport ? [
         Mention.extend({
           addAttributes() {
@@ -310,6 +317,7 @@ export function RichTextInput({
             let chipClass = 'mention-chip'
             if (char === '/') chipClass = 'skill-mention-chip'
             else if (char === '#') chipClass = 'mcp-mention-chip'
+            else if (char === '!') chipClass = 'agent-mention-chip'
             return [
               'span',
               {
@@ -326,6 +334,7 @@ export function RichTextInput({
             mentionSuggestion,
             skillSuggestion,
             mcpSuggestion,
+            agentSuggestion,
           ],
         }),
       ] : []),
@@ -596,6 +605,30 @@ export function RichTextInput({
           mask-repeat: no-repeat;
           flex-shrink: 0;
         }
+        .agent-mention-chip {
+          background-color: hsl(210 70% 55% / 0.15);
+          color: hsl(210 70% 45%);
+          border-radius: 4px;
+          padding: 1px 4px 1px 2px;
+          font-size: 13px;
+          font-weight: 500;
+          white-space: nowrap;
+          display: inline-flex;
+          align-items: center;
+          gap: 2px;
+          vertical-align: baseline;
+        }
+        .agent-mention-chip::before {
+          content: '';
+          display: inline-block;
+          width: 12px;
+          height: 12px;
+          background-color: currentColor;
+          mask-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke='currentColor' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M12 8V4H8'/%3E%3Crect width='16' height='12' x='4' y='8' rx='2'/%3E%3Cpath d='M2 14h2'/%3E%3Cpath d='M20 14h2'/%3E%3Cpath d='M15 13v2'/%3E%3Cpath d='M9 13v2'/%3E%3C/svg%3E");
+          mask-size: contain;
+          mask-repeat: no-repeat;
+          flex-shrink: 0;
+        }
       `}</style>
     </div>
   )
diff --git a/apps/electron/src/renderer/components/app-shell/LeftSidebar.tsx b/apps/electron/src/renderer/components/app-shell/LeftSidebar.tsx
index 2f1da5a6..c65dba4c 100644
--- a/apps/electron/src/renderer/components/app-shell/LeftSidebar.tsx
+++ b/apps/electron/src/renderer/components/app-shell/LeftSidebar.tsx
@@ -11,12 +11,12 @@
 import * as React from 'react'
 import { useAtom, useSetAtom, useAtomValue } from 'jotai'
 import { toast } from 'sonner'
-import { Pin, PinOff, Settings, Plus, Trash2, Pencil, ChevronDown, ChevronRight, Plug, Zap, PanelLeftClose, PanelLeftOpen, ArrowRightLeft } from 'lucide-react'
+import { Pin, PinOff, Settings, Plus, Trash2, Pencil, ChevronDown, ChevronRight, Plug, Zap, Bot, PanelLeftClose, PanelLeftOpen, ArrowRightLeft } from 'lucide-react'
 import { cn } from '@/lib/utils'
 import { Tooltip, TooltipTrigger, TooltipContent } from '@/components/ui/tooltip'
 import { ModeSwitcher } from './ModeSwitcher'
 import { activeViewAtom } from '@/atoms/active-view'
-import { appModeAtom } from '@/atoms/app-mode'
+import { appModeAtom, lastActiveChatTabIdAtom, lastActiveAgentTabIdAtom } from '@/atoms/app-mode'
 import { settingsTabAtom } from '@/atoms/settings-tab'
 import {
   conversationsAtom,
@@ -38,6 +38,7 @@ import {
   workspaceCapabilitiesVersionAtom,
   agentSidePanelOpenMapAtom,
   agentSidePanelTabMapAtom,
+  agentSessionDropZoneDismissedAtom,
 } from '@/atoms/agent-atoms'
 import {
   tabsAtom,
@@ -160,6 +161,8 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
   const selectedModel = useAtomValue(selectedModelAtom)
   const streamingIds = useAtomValue(streamingConversationIdsAtom)
   const mode = useAtomValue(appModeAtom)
+  const setLastChatTab = useSetAtom(lastActiveChatTabIdAtom)
+  const setLastAgentTab = useSetAtom(lastActiveAgentTabIdAtom)
   const hasUpdate = useAtomValue(hasUpdateAtom)
   const hasEnvironmentIssues = useAtomValue(hasEnvironmentIssuesAtom)
   const promptConfig = useAtomValue(promptConfigAtom)
@@ -191,6 +194,7 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
   const setConvPromptId = useSetAtom(conversationPromptIdAtom)
   const setAgentSidePanelOpen = useSetAtom(agentSidePanelOpenMapAtom)
   const setAgentSidePanelTab = useSetAtom(agentSidePanelTabMapAtom)
+  const setAgentSessionDropZoneDismissed = useSetAtom(agentSessionDropZoneDismissedAtom)
 
   /** 清理 per-conversation/session Map atoms 条目 */
   const cleanupMapAtoms = React.useCallback((id: string) => {
@@ -207,7 +211,8 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
     setConvPromptId(deleteKey)
     setAgentSidePanelOpen(deleteKey)
     setAgentSidePanelTab(deleteKey)
-  }, [setConvModels, setConvContextLength, setConvThinking, setConvParallel, setConvPromptId, setAgentSidePanelOpen, setAgentSidePanelTab])
+    setAgentSessionDropZoneDismissed(deleteKey)
+  }, [setConvModels, setConvContextLength, setConvThinking, setConvParallel, setConvPromptId, setAgentSidePanelOpen, setAgentSidePanelTab, setAgentSessionDropZoneDismissed])
 
   const currentWorkspaceSlug = React.useMemo(() => {
     if (!currentWorkspaceId) return null
@@ -294,6 +299,8 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
       setTabs(result.tabs)
       setLayout(result.layout)
       setCurrentConversationId(meta.id)
+      // 追踪最近活跃的 Chat Tab
+      setLastChatTab(meta.id)
       // 确保在对话视图
       setActiveView('conversations')
       setActiveItem('all-chats')
@@ -314,6 +321,8 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
     setCurrentConversationId(id)
     setActiveView('conversations')
     setActiveItem('all-chats')
+    // 追踪最近活跃的 Chat Tab
+    setLastChatTab(id)
   }
 
   /** 请求删除对话（弹出确认框） */
@@ -404,6 +413,8 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
       setCurrentAgentSessionId(meta.id)
       setActiveView('conversations')
       setActiveItem('all-chats')
+      // 追踪最近活跃的 Agent Tab
+      setLastAgentTab(meta.id)
     } catch (error) {
       console.error('[侧边栏] 创建 Agent 会话失败:', error)
     }
@@ -417,6 +428,8 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
     setCurrentAgentSessionId(id)
     setActiveView('conversations')
     setActiveItem('all-chats')
+    // 追踪最近活跃的 Agent Tab
+    setLastAgentTab(id)
   }
 
   /** 重命名 Agent 会话标题 */
@@ -520,12 +533,25 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
     />
   )
 
-  // ===== 折叠状态：精简图标视图 =====
-  if (sidebarCollapsed) {
-    return (
+  // ===== 侧边栏：折叠/展开两种状态切换，展开时无固定留白栏 =====
+  return (
+    <div
+      className={cn(
+        "h-full flex flex-col bg-background overflow-hidden relative",
+        sidebarCollapsed ? "w-12" : "w-[280px]"
+      )}
+      style={{
+        transition: 'width 300ms cubic-bezier(0.4, 0, 0.2, 1)',
+        willChange: 'width',
+        contain: 'layout paint',
+      }}
+    >
+      {/* 折叠状态：仅显示 48px 图标栏 */}
       <div
-        className="h-full flex flex-col items-center bg-background transition-[width] duration-300"
-        style={{ width: 48, flexShrink: 0 }}
+        className={cn(
+          'absolute inset-0 flex flex-col items-center bg-background z-20 transition-opacity duration-200',
+          sidebarCollapsed ? 'opacity-100 pointer-events-auto' : 'opacity-0 pointer-events-none'
+        )}
       >
         {/* 顶部留空，避开 macOS 红绿灯 */}
         <div className="pt-[50px]" />
@@ -587,245 +613,262 @@ export function LeftSidebar({ width }: LeftSidebarProps): React.ReactElement {
             <TooltipContent side="right">设置</TooltipContent>
           </Tooltip>
         </div>
-
-        {deleteDialog}
-        {moveDialog}
       </div>
-    )
-  }
 
-  // ===== 展开状态：完整侧边栏 =====
-  return (
-    <div
-      className="h-full flex flex-col bg-background transition-[width] duration-300"
-      style={{ width: width ?? 280, minWidth: 180, flexShrink: 1 }}
-    >
-      {/* 顶部留空，避开 macOS 红绿灯 */}
-      <div className="pt-[50px]">
-        {/* 模式切换器 + 折叠按钮 */}
-        <div className="flex items-start gap-1 pr-1">
-          <div className="flex-1 min-w-0">
-            <ModeSwitcher />
+      {/* 展开状态：完整 280px 侧边栏，从左侧滑入 */}
+      <div
+        className={cn(
+          'absolute inset-0 w-[280px] bg-background flex flex-col',
+          sidebarCollapsed ? 'pointer-events-none' : 'pointer-events-auto'
+        )}
+        style={{
+          transform: sidebarCollapsed ? 'translateX(-100%)' : 'translateX(0)',
+          transition: 'transform 300ms cubic-bezier(0.4, 0, 0.2, 1)',
+          willChange: 'transform',
+          contain: 'layout paint',
+        }}
+      >
+        {/* 内容区域 */}
+        <div className="h-full flex flex-col">
+            {/* 顶部留空，避开 macOS 红绿灯 */}
+            <div className="pt-[50px]">
+              {/* 模式切换器 + 折叠按钮 */}
+              <div className="flex items-start gap-1 pr-1">
+            <div className="flex-1 min-w-0">
+              <ModeSwitcher />
+            </div>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <button
+                  onClick={() => setSidebarCollapsed(true)}
+                  className="mt-2 size-10 flex items-center justify-center rounded-[10px] text-foreground/40 hover:bg-foreground/[0.04] hover:text-foreground/60 transition-colors titlebar-no-drag"
+                >
+                  <PanelLeftClose size={18} />
+                </button>
+              </TooltipTrigger>
+              <TooltipContent side="right">收起侧边栏</TooltipContent>
+            </Tooltip>
           </div>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <button
-                onClick={() => setSidebarCollapsed(true)}
-                className="mt-2 size-10 flex items-center justify-center rounded-[10px] text-foreground/40 hover:bg-foreground/[0.04] hover:text-foreground/60 transition-colors titlebar-no-drag"
-              >
-                <PanelLeftClose size={18} />
-              </button>
-            </TooltipTrigger>
-            <TooltipContent side="right">收起侧边栏</TooltipContent>
-          </Tooltip>
-        </div>
-      </div>
-
-      {/* Agent 模式：工作区选择器 */}
-      {mode === 'agent' && (
-        <div className="px-3 pt-3">
-          <WorkspaceSelector />
         </div>
-      )}
-
-      {/* 新对话/新会话按钮 */}
-      <div className="px-3 pt-2">
-        <button
-          onClick={mode === 'agent' ? handleNewAgentSession : handleNewConversation}
-          className="w-full flex items-center gap-2 px-3 py-2 rounded-[10px] text-[13px] font-medium text-foreground/70 bg-foreground/[0.04] hover:bg-foreground/[0.08] transition-colors duration-100 titlebar-no-drag border border-dashed border-foreground/10 hover:border-foreground/20"
-        >
-          <Plus size={14} />
-          <span>{mode === 'agent' ? '新会话' : '新对话'}</span>
-        </button>
-      </div>
-
-      {/* Chat 模式：导航菜单（置顶区域） */}
-      {mode === 'chat' && (
-        <div className="flex flex-col gap-1 pt-3 px-3">
-          <SidebarItem
-            icon={<Pin size={16} />}
-            label="置顶对话"
-            suffix={
-              pinnedConversations.length > 0 ? (
-                pinnedExpanded
-                  ? <ChevronDown size={14} className="text-foreground/40" />
-                  : <ChevronRight size={14} className="text-foreground/40" />
-              ) : undefined
-            }
-            onClick={() => handleItemClick('pinned')}
-          />
+  
+        {/* Agent 模式：工作区选择器 */}
+        {mode === 'agent' && (
+          <div className="px-3 pt-3">
+            <WorkspaceSelector />
+          </div>
+        )}
+  
+        {/* 新对话/新会话按钮 */}
+        <div className="px-3 pt-2">
+          <button
+            onClick={mode === 'agent' ? handleNewAgentSession : handleNewConversation}
+            className="w-full flex items-center gap-2 px-3 py-2 rounded-[10px] text-[13px] font-medium text-foreground/70 bg-foreground/[0.04] hover:bg-foreground/[0.08] transition-colors duration-100 titlebar-no-drag border border-dashed border-foreground/10 hover:border-foreground/20"
+          >
+            <Plus size={14} />
+            <span>{mode === 'agent' ? '新会话' : '新对话'}</span>
+          </button>
         </div>
-      )}
-
-      {/* Chat 模式：置顶对话区域 */}
-      {mode === 'chat' && pinnedExpanded && pinnedConversations.length > 0 && (
-        <div className="px-3 pt-1 pb-1">
-          <div className="flex flex-col gap-0.5 pl-1 border-l-2 border-primary/20 ml-2">
-            {pinnedConversations.map((conv) => (
-              <ConversationItem
-                key={`pinned-${conv.id}`}
-                conversation={conv}
-                active={conv.id === activeTabId}
-                hovered={conv.id === hoveredId}
-                streaming={streamingIds.has(conv.id)}
-                showPinIcon={false}
-                onSelect={() => handleSelectConversation(conv.id, conv.title)}
-                onRequestDelete={() => handleRequestDelete(conv.id)}
-                onRename={handleRename}
-                onTogglePin={handleTogglePin}
-                onMouseEnter={() => setHoveredId(conv.id)}
-                onMouseLeave={() => setHoveredId(null)}
-              />
-            ))}
+  
+        {/* Chat 模式：导航菜单（置顶区域） */}
+        {mode === 'chat' && (
+          <div className="flex flex-col gap-1 pt-3 px-3">
+            <SidebarItem
+              icon={<Pin size={16} />}
+              label="置顶对话"
+              suffix={
+                pinnedConversations.length > 0 ? (
+                  pinnedExpanded
+                    ? <ChevronDown size={14} className="text-foreground/40" />
+                    : <ChevronRight size={14} className="text-foreground/40" />
+                ) : undefined
+              }
+              onClick={() => handleItemClick('pinned')}
+            />
+          </div>
+        )}
+  
+        {/* Chat 模式：置顶对话区域 */}
+        {mode === 'chat' && pinnedExpanded && pinnedConversations.length > 0 && (
+          <div className="px-3 pt-1 pb-1">
+            <div className="flex flex-col gap-0.5 pl-1 border-l-2 border-primary/20 ml-2">
+              {pinnedConversations.map((conv) => (
+                <ConversationItem
+                  key={`pinned-${conv.id}`}
+                  conversation={conv}
+                  active={conv.id === activeTabId}
+                  hovered={conv.id === hoveredId}
+                  streaming={streamingIds.has(conv.id)}
+                  showPinIcon={false}
+                  onSelect={() => handleSelectConversation(conv.id, conv.title)}
+                  onRequestDelete={() => handleRequestDelete(conv.id)}
+                  onRename={handleRename}
+                  onTogglePin={handleTogglePin}
+                  onMouseEnter={() => setHoveredId(conv.id)}
+                  onMouseLeave={() => setHoveredId(null)}
+                />
+              ))}
+            </div>
+          </div>
+        )}
+  
+        {/* Agent 模式：导航菜单（置顶区域） */}
+        {mode === 'agent' && (
+          <div className="flex flex-col gap-1 pt-3 px-3">
+            <SidebarItem
+              icon={<Pin size={16} />}
+              label="置顶会话"
+              suffix={
+                pinnedAgentSessions.length > 0 ? (
+                  pinnedAgentExpanded
+                    ? <ChevronDown size={14} className="text-foreground/40" />
+                    : <ChevronRight size={14} className="text-foreground/40" />
+                ) : undefined
+              }
+              onClick={() => setPinnedAgentExpanded((prev) => !prev)}
+            />
+          </div>
+        )}
+  
+        {/* Agent 模式：置顶会话区域 */}
+        {mode === 'agent' && pinnedAgentExpanded && pinnedAgentSessions.length > 0 && (
+          <div className="px-3 pt-1 pb-1">
+            <div className="flex flex-col gap-0.5 pl-1 border-l-2 border-primary/20 ml-2">
+              {pinnedAgentSessions.map((session) => (
+                <AgentSessionItem
+                  key={`pinned-${session.id}`}
+                  session={session}
+                  active={session.id === activeTabId}
+                  hovered={session.id === hoveredId}
+                  running={agentRunningIds.has(session.id)}
+                  showPinIcon={false}
+                  onSelect={() => handleSelectAgentSession(session.id, session.title)}
+                  onRequestDelete={() => handleRequestDelete(session.id)}
+                  onRequestMove={() => setMoveTargetId(session.id)}
+                  onRename={handleAgentRename}
+                  onTogglePin={handleTogglePinAgent}
+                  onMouseEnter={() => setHoveredId(session.id)}
+                  onMouseLeave={() => setHoveredId(null)}
+                />
+              ))}
+            </div>
           </div>
+        )}
+  
+        {/* 列表区域：根据模式切换 */}
+        <div className="flex-1 overflow-y-auto px-3 pt-2 pb-3 scrollbar-none">
+          {mode === 'chat' ? (
+            /* Chat 模式：对话按日期分组 */
+            conversationGroups.map((group) => (
+              <div key={group.label} className="mb-1">
+                <div className="px-3 pt-2 pb-1 text-[11px] font-medium text-foreground/40 select-none">
+                  {group.label}
+                </div>
+                <div className="flex flex-col gap-0.5">
+                  {group.items.map((conv) => (
+                    <ConversationItem
+                      key={conv.id}
+                      conversation={conv}
+                      active={conv.id === activeTabId}
+                      hovered={conv.id === hoveredId}
+                      streaming={streamingIds.has(conv.id)}
+                      showPinIcon={!!conv.pinned}
+                      onSelect={() => handleSelectConversation(conv.id, conv.title)}
+                      onRequestDelete={() => handleRequestDelete(conv.id)}
+                      onRename={handleRename}
+                      onTogglePin={handleTogglePin}
+                      onMouseEnter={() => setHoveredId(conv.id)}
+                      onMouseLeave={() => setHoveredId(null)}
+                    />
+                  ))}
+                </div>
+              </div>
+            ))
+          ) : (
+            /* Agent 模式：Agent 会话按日期分组 */
+            agentSessionGroups.map((group) => (
+              <div key={group.label} className="mb-1">
+                <div className="px-3 pt-2 pb-1 text-[11px] font-medium text-foreground/40 select-none">
+                  {group.label}
+                </div>
+                <div className="flex flex-col gap-0.5">
+                  {group.items.map((session) => (
+                    <AgentSessionItem
+                      key={session.id}
+                      session={session}
+                      active={session.id === activeTabId}
+                      hovered={session.id === hoveredId}
+                      running={agentRunningIds.has(session.id)}
+                      showPinIcon={!!session.pinned}
+                      onSelect={() => handleSelectAgentSession(session.id, session.title)}
+                      onRequestDelete={() => handleRequestDelete(session.id)}
+                      onRequestMove={() => setMoveTargetId(session.id)}
+                      onRename={handleAgentRename}
+                      onTogglePin={handleTogglePinAgent}
+                      onMouseEnter={() => setHoveredId(session.id)}
+                      onMouseLeave={() => setHoveredId(null)}
+                    />
+                  ))}
+                </div>
+              </div>
+            ))
+          )}
         </div>
-      )}
-
-      {/* Agent 模式：导航菜单（置顶区域） */}
-      {mode === 'agent' && (
-        <div className="flex flex-col gap-1 pt-3 px-3">
+  
+        {/* Agent 模式：工作区能力指示器 */}
+        {mode === 'agent' && capabilities && (
+          <div className="px-3 pb-1">
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <button
+                  onClick={() => { setSettingsTab('agent'); handleItemClick('settings') }}
+                  className="w-full flex items-center gap-3 px-3 py-2 rounded-[10px] text-[12px] text-foreground/50 hover:bg-foreground/[0.04] hover:text-foreground/70 transition-colors titlebar-no-drag"
+                >
+                  <div className="flex items-center gap-2.5 flex-1 min-w-0">
+                    <span className="flex items-center gap-1">
+                      <Plug size={13} className="text-foreground/40" />
+                      <span className="tabular-nums">{capabilities.mcpServers.filter((s) => s.enabled).length}</span>
+                      <span className="text-foreground/30">MCP</span>
+                    </span>
+                    <span className="text-foreground/20">·</span>
+                    <span className="flex items-center gap-1">
+                      <Zap size={13} className="text-foreground/40" />
+                      <span className="tabular-nums">{capabilities.skills.length}</span>
+                      <span className="text-foreground/30">Skills</span>
+                    </span>
+                    {(capabilities.agents?.length ?? 0) > 0 && (
+                      <>
+                        <span className="text-foreground/20">·</span>
+                        <span className="flex items-center gap-1">
+                          <Bot size={13} className="text-foreground/40" />
+                          <span className="tabular-nums">{capabilities.agents.length}</span>
+                          <span className="text-foreground/30">Agents</span>
+                        </span>
+                      </>
+                    )}
+                  </div>
+                </button>
+              </TooltipTrigger>
+              <TooltipContent side="right">点击配置 MCP、Skills 与子代理</TooltipContent>
+            </Tooltip>
+          </div>
+        )}
+  
+        {/* 底部设置 */}
+        <div className="px-3 pb-3">
           <SidebarItem
-            icon={<Pin size={16} />}
-            label="置顶会话"
+            icon={<Settings size={18} />}
+            label="设置"
+            active={activeItem === 'settings'}
+            onClick={() => handleItemClick('settings')}
             suffix={
-              pinnedAgentSessions.length > 0 ? (
-                pinnedAgentExpanded
-                  ? <ChevronDown size={14} className="text-foreground/40" />
-                  : <ChevronRight size={14} className="text-foreground/40" />
+              (hasUpdate || hasEnvironmentIssues) ? (
+                <span className="w-2 h-2 rounded-full bg-red-500" />
               ) : undefined
             }
-            onClick={() => setPinnedAgentExpanded((prev) => !prev)}
           />
         </div>
-      )}
-
-      {/* Agent 模式：置顶会话区域 */}
-      {mode === 'agent' && pinnedAgentExpanded && pinnedAgentSessions.length > 0 && (
-        <div className="px-3 pt-1 pb-1">
-          <div className="flex flex-col gap-0.5 pl-1 border-l-2 border-primary/20 ml-2">
-            {pinnedAgentSessions.map((session) => (
-              <AgentSessionItem
-                key={`pinned-${session.id}`}
-                session={session}
-                active={session.id === activeTabId}
-                hovered={session.id === hoveredId}
-                running={agentRunningIds.has(session.id)}
-                showPinIcon={false}
-                onSelect={() => handleSelectAgentSession(session.id, session.title)}
-                onRequestDelete={() => handleRequestDelete(session.id)}
-                onRequestMove={() => setMoveTargetId(session.id)}
-                onRename={handleAgentRename}
-                onTogglePin={handleTogglePinAgent}
-                onMouseEnter={() => setHoveredId(session.id)}
-                onMouseLeave={() => setHoveredId(null)}
-              />
-            ))}
-          </div>
-        </div>
-      )}
-
-      {/* 列表区域：根据模式切换 */}
-      <div className="flex-1 overflow-y-auto px-3 pt-2 pb-3 scrollbar-none">
-        {mode === 'chat' ? (
-          /* Chat 模式：对话按日期分组 */
-          conversationGroups.map((group) => (
-            <div key={group.label} className="mb-1">
-              <div className="px-3 pt-2 pb-1 text-[11px] font-medium text-foreground/40 select-none">
-                {group.label}
-              </div>
-              <div className="flex flex-col gap-0.5">
-                {group.items.map((conv) => (
-                  <ConversationItem
-                    key={conv.id}
-                    conversation={conv}
-                    active={conv.id === activeTabId}
-                    hovered={conv.id === hoveredId}
-                    streaming={streamingIds.has(conv.id)}
-                    showPinIcon={!!conv.pinned}
-                    onSelect={() => handleSelectConversation(conv.id, conv.title)}
-                    onRequestDelete={() => handleRequestDelete(conv.id)}
-                    onRename={handleRename}
-                    onTogglePin={handleTogglePin}
-                    onMouseEnter={() => setHoveredId(conv.id)}
-                    onMouseLeave={() => setHoveredId(null)}
-                  />
-                ))}
-              </div>
-            </div>
-          ))
-        ) : (
-          /* Agent 模式：Agent 会话按日期分组 */
-          agentSessionGroups.map((group) => (
-            <div key={group.label} className="mb-1">
-              <div className="px-3 pt-2 pb-1 text-[11px] font-medium text-foreground/40 select-none">
-                {group.label}
-              </div>
-              <div className="flex flex-col gap-0.5">
-                {group.items.map((session) => (
-                  <AgentSessionItem
-                    key={session.id}
-                    session={session}
-                    active={session.id === activeTabId}
-                    hovered={session.id === hoveredId}
-                    running={agentRunningIds.has(session.id)}
-                    showPinIcon={!!session.pinned}
-                    onSelect={() => handleSelectAgentSession(session.id, session.title)}
-                    onRequestDelete={() => handleRequestDelete(session.id)}
-                    onRequestMove={() => setMoveTargetId(session.id)}
-                    onRename={handleAgentRename}
-                    onTogglePin={handleTogglePinAgent}
-                    onMouseEnter={() => setHoveredId(session.id)}
-                    onMouseLeave={() => setHoveredId(null)}
-                  />
-                ))}
-              </div>
-            </div>
-          ))
-        )}
-      </div>
-
-      {/* Agent 模式：工作区能力指示器 */}
-      {mode === 'agent' && capabilities && (
-        <div className="px-3 pb-1">
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <button
-                onClick={() => { setSettingsTab('agent'); handleItemClick('settings') }}
-                className="w-full flex items-center gap-3 px-3 py-2 rounded-[10px] text-[12px] text-foreground/50 hover:bg-foreground/[0.04] hover:text-foreground/70 transition-colors titlebar-no-drag"
-              >
-                <div className="flex items-center gap-2.5 flex-1 min-w-0">
-                  <span className="flex items-center gap-1">
-                    <Plug size={13} className="text-foreground/40" />
-                    <span className="tabular-nums">{capabilities.mcpServers.filter((s) => s.enabled).length}</span>
-                    <span className="text-foreground/30">MCP</span>
-                  </span>
-                  <span className="text-foreground/20">·</span>
-                  <span className="flex items-center gap-1">
-                    <Zap size={13} className="text-foreground/40" />
-                    <span className="tabular-nums">{capabilities.skills.length}</span>
-                    <span className="text-foreground/30">Skills</span>
-                  </span>
-                </div>
-              </button>
-            </TooltipTrigger>
-            <TooltipContent side="right">点击配置 MCP 与 Skills</TooltipContent>
-          </Tooltip>
+  
         </div>
-      )}
-
-      {/* 底部设置 */}
-      <div className="px-3 pb-3">
-        <SidebarItem
-          icon={<Settings size={18} />}
-          label="设置"
-          active={activeItem === 'settings'}
-          onClick={() => handleItemClick('settings')}
-          suffix={
-            (hasUpdate || hasEnvironmentIssues) ? (
-              <span className="w-2 h-2 rounded-full bg-red-500" />
-            ) : undefined
-          }
-        />
       </div>
 
       {deleteDialog}
diff --git a/apps/electron/src/renderer/components/app-shell/ModeSwitcher.tsx b/apps/electron/src/renderer/components/app-shell/ModeSwitcher.tsx
index 89d650d3..d3231b26 100644
--- a/apps/electron/src/renderer/components/app-shell/ModeSwitcher.tsx
+++ b/apps/electron/src/renderer/components/app-shell/ModeSwitcher.tsx
@@ -1,10 +1,17 @@
 /**
  * ModeSwitcher - Chat/Agent 模式切换（带滑动指示器）
+ * 切换模式时自动聚焦对应模式最近活跃的 Tab
  */
 
 import * as React from 'react'
-import { useAtom } from 'jotai'
-import { appModeAtom, type AppMode } from '@/atoms/app-mode'
+import { useAtom, useAtomValue, useSetAtom } from 'jotai'
+import {
+  appModeAtom,
+  lastActiveChatTabIdAtom,
+  lastActiveAgentTabIdAtom,
+  type AppMode,
+} from '@/atoms/app-mode'
+import { tabsAtom, splitLayoutAtom, focusTab } from '@/atoms/tab-atoms'
 import { cn } from '@/lib/utils'
 
 const modes: { value: AppMode; label: string }[] = [
@@ -14,6 +21,28 @@ const modes: { value: AppMode; label: string }[] = [
 
 export function ModeSwitcher(): React.ReactElement {
   const [mode, setMode] = useAtom(appModeAtom)
+  const tabs = useAtomValue(tabsAtom)
+  const layout = useAtomValue(splitLayoutAtom)
+  const setLayout = useSetAtom(splitLayoutAtom)
+  const lastChatTab = useAtomValue(lastActiveChatTabIdAtom)
+  const lastAgentTab = useAtomValue(lastActiveAgentTabIdAtom)
+
+  const handleModeSwitch = (newMode: AppMode): void => {
+    if (newMode === mode) return
+
+    const targetTabId = newMode === 'chat' ? lastChatTab : lastAgentTab
+
+    if (targetTabId) {
+      const targetTab = tabs.find((t) => t.id === targetTabId)
+      // 仅当 Tab 存在且类型匹配时聚焦
+      if (targetTab && targetTab.type === newMode) {
+        setLayout(focusTab(layout, targetTabId))
+      }
+    }
+
+    // 切换模式
+    setMode(newMode)
+  }
 
   return (
     <div className="px-2 pt-2">
@@ -28,7 +57,7 @@ export function ModeSwitcher(): React.ReactElement {
         {modes.map(({ value, label }) => (
           <button
             key={value}
-            onClick={() => setMode(value)}
+            onClick={() => handleModeSwitch(value)}
             className={cn(
               'relative z-[1] flex-1 rounded-md px-3 py-1.5 text-sm font-medium transition-colors duration-200',
               mode === value
diff --git a/apps/electron/src/renderer/components/chat/ChatMessageItem.tsx b/apps/electron/src/renderer/components/chat/ChatMessageItem.tsx
index 98290be0..f4cfce0c 100644
--- a/apps/electron/src/renderer/components/chat/ChatMessageItem.tsx
+++ b/apps/electron/src/renderer/components/chat/ChatMessageItem.tsx
@@ -36,6 +36,7 @@ import { InlineEditForm } from './InlineEditForm'
 import { UserAvatar } from './UserAvatar'
 import { getModelLogo } from '@/lib/model-logo'
 import { userProfileAtom } from '@/atoms/user-profile'
+import { useChatLayout } from '@/hooks/useChatLayout'
 import type { ChatMessage } from '@proma/shared'
 import type { InlineEditSubmitPayload } from './InlineEditForm'
 import { ChatToolActivityIndicator } from './ChatToolActivityIndicator'
@@ -110,6 +111,7 @@ export const ChatMessageItem = React.memo(function ChatMessageItem({
   const [deleteDialogOpen, setDeleteDialogOpen] = React.useState(false)
   const [isDeleting, setIsDeleting] = React.useState(false)
   const userProfile = useAtomValue(userProfileAtom)
+  const layout = useChatLayout(message.role === 'user', isParallelMode)
 
   /** 确认删除消息 */
   const handleDeleteConfirm = async (): Promise<void> => {
@@ -129,12 +131,9 @@ export const ChatMessageItem = React.memo(function ChatMessageItem({
     void onSubmitInlineEdit(message, payload)
   }, [message, onSubmitInlineEdit])
 
-  // 并排模式下，user 消息不使用 from="user" 以避免右对齐
-  const messageFrom = isParallelMode ? 'assistant' : message.role
-
   return (
     <>
-      <Message from={messageFrom}>
+      <Message from={message.role} className={layout.messageAlignClass}>
         {/* assistant 头像 + 模型名 + 时间 */}
         {message.role === 'assistant' && (
           <MessageHeader
@@ -152,18 +151,19 @@ export const ChatMessageItem = React.memo(function ChatMessageItem({
 
         {/* user 头像 + 用户名 + 时间 */}
         {message.role === 'user' && (
-          <div className="flex items-start gap-2.5 mb-2.5">
+          <div className={`flex items-start gap-2.5 mb-2.5 ${layout.userHeaderFlexClass}`}>
             <UserAvatar avatar={userProfile.avatar} size={35} />
-            <div className="flex flex-col justify-between h-[35px]">
+            <div className={`flex flex-col justify-between h-[35px] ${layout.userInfoAlignClass}`}>
               <span className="text-sm font-semibold text-foreground/60 leading-none">{userProfile.userName}</span>
               <span className="text-[10px] text-foreground/[0.38] leading-none">{formatMessageTime(message.createdAt)}</span>
             </div>
           </div>
         )}
 
-        <MessageContent>
+        <MessageContent className={`${layout.contentPaddingClass} ${layout.contentItemsClass}`}>
           {message.role === 'assistant' ? (
-            <>
+            /* AI 消息 - 使用气泡容器包装内容 */
+            <div className="assistant-message-bubble rounded-[10px] px-3.5 py-2.5 w-fit">
               {/* 工具活动记录（历史消息） */}
               {message.toolActivities && message.toolActivities.length > 0 && (
                 <ChatToolActivityIndicator activities={message.toolActivities} />
@@ -197,12 +197,12 @@ export const ChatMessageItem = React.memo(function ChatMessageItem({
               {message.attachments && message.attachments.length > 0 && (
                 <MessageAttachments attachments={message.attachments} />
               )}
-            </>
+            </div>
           ) : (
             /* 用户消息 - 附件 + 可折叠文本 / 原地编辑 */
             <>
               {!isInlineEditing && message.attachments && message.attachments.length > 0 && (
-                <MessageAttachments attachments={message.attachments} />
+                <MessageAttachments attachments={message.attachments} className={layout.attachmentsClass} />
               )}
               {isInlineEditing ? (
                 <InlineEditForm
@@ -211,7 +211,7 @@ export const ChatMessageItem = React.memo(function ChatMessageItem({
                   onCancel={() => onCancelInlineEdit?.()}
                 />
               ) : message.content && (
-                <UserMessageContent>{message.content}</UserMessageContent>
+                <UserMessageContent className={layout.userContentTextClass}>{message.content}</UserMessageContent>
               )}
             </>
           )}
@@ -219,7 +219,7 @@ export const ChatMessageItem = React.memo(function ChatMessageItem({
 
         {/* 操作按钮（非 streaming 时显示，hover 时可见） */}
         {(message.content || (message.attachments && message.attachments.length > 0)) && !isStreaming && !isInlineEditing && (
-          <MessageActions className="pl-[46px] mt-0.5">
+          <MessageActions className={`mt-0.5 ${layout.actionsClass}`}>
             <CopyButton content={message.content} />
             {message.role === 'assistant' && conversationId && (
               <MigrateToAgentButton conversationId={conversationId} />
diff --git a/apps/electron/src/renderer/components/chat/ChatMessages.tsx b/apps/electron/src/renderer/components/chat/ChatMessages.tsx
index c2b83fc8..77e2c2ff 100644
--- a/apps/electron/src/renderer/components/chat/ChatMessages.tsx
+++ b/apps/electron/src/renderer/components/chat/ChatMessages.tsx
@@ -333,7 +333,7 @@ export function ChatMessages({
 
             {/* 正在生成 / 停止后等待磁盘消息加载的临时 assistant 消息 */}
             {(streaming || smoothContent || smoothReasoning) && (
-              <Message from="assistant">
+              <Message from="assistant" className="items-start">
                 <MessageHeader
                   model={streamingModel ?? undefined}
                   time={formatMessageTime(Date.now())}
@@ -345,7 +345,7 @@ export function ChatMessages({
                     />
                   }
                 />
-                <MessageContent>
+                <MessageContent className="pl-[46px]">
                   {/* 工具活动指示器 */}
                   <ChatToolActivityIndicator activities={toolActivities} />
 
diff --git a/apps/electron/src/renderer/components/chat/ModelSelector.tsx b/apps/electron/src/renderer/components/chat/ModelSelector.tsx
index 98333f5a..1cac545c 100644
--- a/apps/electron/src/renderer/components/chat/ModelSelector.tsx
+++ b/apps/electron/src/renderer/components/chat/ModelSelector.tsx
@@ -28,12 +28,15 @@ import { cn } from '@/lib/utils'
 import type { Channel, ModelOption } from '@proma/shared'
 
 /** 从渠道列表构建扁平化的模型选项 */
-function buildModelOptions(channels: Channel[], filterChannelId?: string): ModelOption[] {
+function buildModelOptions(channels: Channel[], filterChannelId?: string, filterChannelIds?: string[]): ModelOption[] {
   const options: ModelOption[] = []
 
   for (const channel of channels) {
     if (!channel.enabled) continue
     if (filterChannelId && channel.id !== filterChannelId) continue
+    if (filterChannelIds && !filterChannelIds.includes(channel.id)) continue
+    // Vertex/Bedrock 渠道仅支持 Agent 模式（需要特殊认证，Chat 无法直接调用）
+    if (!filterChannelIds && (channel.authType === 'vertex' || channel.authType === 'bedrock')) continue
 
     for (const model of channel.models) {
       if (!model.enabled) continue
@@ -69,6 +72,8 @@ function groupByChannel(options: ModelOption[]): Map<string, ModelOption[]> {
 interface ModelSelectorProps {
   /** 仅显示此渠道的模型 */
   filterChannelId?: string
+  /** 仅显示这些渠道的模型（多渠道过滤） */
+  filterChannelIds?: string[]
   /** 外部选中模型（不传则用内部 selectedModelAtom） */
   externalSelectedModel?: { channelId: string; modelId: string } | null
   /** 外部选择回调 */
@@ -77,6 +82,7 @@ interface ModelSelectorProps {
 
 export function ModelSelector({
   filterChannelId,
+  filterChannelIds,
   externalSelectedModel,
   onModelSelect,
 }: ModelSelectorProps = {}): React.ReactElement {
@@ -104,7 +110,7 @@ export function ModelSelector({
     }
   }, [open])
 
-  const modelOptions = React.useMemo(() => buildModelOptions(channels, filterChannelId), [channels, filterChannelId])
+  const modelOptions = React.useMemo(() => buildModelOptions(channels, filterChannelId, filterChannelIds), [channels, filterChannelId, filterChannelIds])
   const grouped = React.useMemo(() => groupByChannel(modelOptions), [modelOptions])
 
   // 搜索过滤
diff --git a/apps/electron/src/renderer/components/file-browser/FileBrowser.tsx b/apps/electron/src/renderer/components/file-browser/FileBrowser.tsx
index 62d6c58e..b6265276 100644
--- a/apps/electron/src/renderer/components/file-browser/FileBrowser.tsx
+++ b/apps/electron/src/renderer/components/file-browser/FileBrowser.tsx
@@ -221,11 +221,7 @@ export function FileBrowser({ rootPath, hideToolbar, embedded }: FileBrowserProp
       {error && (
         <div className="px-3 py-2 text-xs text-destructive">{error}</div>
       )}
-      {!error && entries.length === 0 && !loading && (
-        <div className="px-3 py-4 text-xs text-muted-foreground text-center">
-          目录为空
-        </div>
-      )}
+      {/* 空目录时不显示提示，由外部拖拽区域处理 */}
       {entries.map((entry) => (
         <FileTreeItem
           key={entry.path}
@@ -281,7 +277,11 @@ export function FileBrowser({ rootPath, hideToolbar, embedded }: FileBrowserProp
       )}
 
       {/* 文件树 */}
-      {embedded ? fileTree : (
+      {embedded ? (
+        <div className="flex-1 min-h-0">
+          {fileTree}
+        </div>
+      ) : (
         <ScrollArea className="flex-1">
           {fileTree}
         </ScrollArea>
diff --git a/apps/electron/src/renderer/components/file-browser/FileDropZone.tsx b/apps/electron/src/renderer/components/file-browser/FileDropZone.tsx
index c89f8b61..b3a33e88 100644
--- a/apps/electron/src/renderer/components/file-browser/FileDropZone.tsx
+++ b/apps/electron/src/renderer/components/file-browser/FileDropZone.tsx
@@ -1,15 +1,13 @@
 /**
  * FileDropZone — 文件拖拽上传区域
  *
- * 引导用户通过拖拽或点击将文件添加到 Agent 会话目录或工作区文件目录。
+ * 支持拖拽文件/文件夹到目标目录。
  * 文件上传后直接保存到目标目录，FileBrowser 通过版本号自动刷新。
  */
 
 import * as React from 'react'
 import { toast } from 'sonner'
-import { Upload, File, FolderPlus, Loader2 } from 'lucide-react'
-import { Button } from '@/components/ui/button'
-import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import { Upload, Loader2, FolderOpen } from 'lucide-react'
 import { cn } from '@/lib/utils'
 import { fileToBase64 } from '@/lib/file-utils'
 
@@ -22,11 +20,30 @@ interface FileDropZoneProps {
   target?: 'session' | 'workspace'
   /** 上传成功后的回调（触发文件浏览器刷新） */
   onFilesUploaded: () => void
-  /** 附加文件夹回调 */
-  onAttachFolder?: () => void
+  /** 文件夹关联成功后的回调（用于更新界面状态） */
+  onFoldersAttached?: (updatedDirs: string[]) => void
+  /** 自定义类名 */
+  className?: string
+  /** 隐藏 UI（仅保留拖拽功能） */
+  hideUI?: boolean
+  /** 子元素 */
+  children?: React.ReactNode
+  /** 是否为空目录（为空时显示拖拽UI，有内容时隐藏UI但保留拖拽功能） */
+  isEmpty?: boolean
 }
 
-export function FileDropZone({ workspaceSlug, sessionId, target = 'session', onFilesUploaded, onAttachFolder }: FileDropZoneProps): React.ReactElement {
+export function FileDropZone({ 
+  workspaceSlug, 
+  sessionId, 
+  target = 'session', 
+  onFilesUploaded, 
+  onFoldersAttached,
+  className,
+  hideUI,
+  children,
+  isEmpty,
+}: FileDropZoneProps): React.ReactElement {
+  console.log('[FileDropZone] Render, isEmpty:', isEmpty, 'children:', !!children, 'target:', target)
   const [isDragOver, setIsDragOver] = React.useState(false)
   const [isUploading, setIsUploading] = React.useState(false)
 
@@ -49,12 +66,14 @@ export function FileDropZone({ workspaceSlug, sessionId, target = 'session', onF
           workspaceSlug,
           files: fileEntries,
         })
-      } else {
+      } else if (sessionId) {
         await window.electronAPI.saveFilesToAgentSession({
           workspaceSlug,
-          sessionId: sessionId!,
+          sessionId,
           files: fileEntries,
         })
+      } else {
+        throw new Error('sessionId is required for session target')
       }
 
       onFilesUploaded()
@@ -88,29 +107,61 @@ export function FileDropZone({ workspaceSlug, sessionId, target = 'session', onF
 
     const items = Array.from(e.dataTransfer.items)
     const regularFiles: globalThis.File[] = []
-    let hasFolders = false
+    let folderPaths: string[] = []
 
     for (const item of items) {
       if (item.kind !== 'file') continue
       const entry = item.webkitGetAsEntry?.()
       if (entry?.isDirectory) {
-        hasFolders = true
+        // 对于工作区模式，获取文件夹路径
+        if (isWorkspace && onFoldersAttached) {
+          // 使用 Electron webUtils.getPathForFile 安全获取路径（contextIsolation 兼容）
+          const file = item.getAsFile()
+          if (file) {
+            const path = window.electronAPI.getFilePath(file)
+            if (path) {
+              folderPaths.push(path)
+            }
+          }
+        }
       } else {
         const file = item.getAsFile()
         if (file) regularFiles.push(file)
       }
     }
 
-    if (hasFolders) {
-      toast.info('不支持拖拽文件夹', { description: '请使用「附加文件夹」按钮' })
+    // 工作区模式：拖拽文件夹时自动关联
+    if (isWorkspace && folderPaths.length > 0 && onFoldersAttached) {
+      let updatedDirs: string[] = []
+      for (const folderPath of folderPaths) {
+        try {
+          // 从路径提取目录名
+          const folderName = folderPath.split('/').pop() ?? '文件夹'
+          // 调用关联文件夹 API，返回更新后的目录列表
+          updatedDirs = await window.electronAPI.attachWorkspaceDirectory({
+            workspaceSlug,
+            directoryPath: folderPath,
+          })
+          toast.success(`已关联文件夹: ${folderName}`)
+        } catch (error) {
+          console.error('[FileDropZone] 关联文件夹失败:', error)
+          toast.error('关联文件夹失败')
+        }
+      }
+      // 通知父组件更新目录列表状态
+      if (onFoldersAttached && updatedDirs.length > 0) {
+        onFoldersAttached(updatedDirs)
+      }
+      onFilesUploaded()
+      return
     }
 
     if (regularFiles.length > 0) {
       await saveFiles(regularFiles)
     }
-  }, [saveFiles])
+  }, [saveFiles, isWorkspace, workspaceSlug, onFoldersAttached, onFilesUploaded])
 
-  // ===== 按钮点击处理 =====
+  // ===== 按钮点击处理（选择文件）=====
 
   const handleSelectFiles = React.useCallback(async (): Promise<void> => {
     try {
@@ -128,12 +179,14 @@ export function FileDropZone({ workspaceSlug, sessionId, target = 'session', onF
           workspaceSlug,
           files: fileEntries,
         })
-      } else {
+      } else if (sessionId) {
         await window.electronAPI.saveFilesToAgentSession({
           workspaceSlug,
-          sessionId: sessionId!,
+          sessionId,
           files: fileEntries,
         })
+      } else {
+        throw new Error('sessionId is required for session target')
       }
 
       onFilesUploaded()
@@ -146,12 +199,88 @@ export function FileDropZone({ workspaceSlug, sessionId, target = 'session', onF
     }
   }, [workspaceSlug, sessionId, isWorkspace, onFilesUploaded])
 
+  // 拖拽遮罩层（拖拽时显示）
+  const dragOverlay = isDragOver && (
+    <div className="absolute inset-0 z-50 flex flex-col items-center justify-center gap-2 bg-primary/5 border-2 border-primary border-dashed rounded-xl">
+      <FolderOpen className="size-8 text-primary" />
+      <span className="text-sm text-primary font-medium">释放以关联文件/文件夹</span>
+    </div>
+  )
+
+  // 上传中遮罩层
+  const uploadingOverlay = isUploading && (
+    <div className="absolute inset-0 z-50 flex flex-col items-center justify-center gap-2 bg-background/80 rounded-xl">
+      <Loader2 className="size-6 text-muted-foreground animate-spin" />
+      <span className="text-xs text-muted-foreground">正在上传...</span>
+    </div>
+  )
+
+  // 有子元素时的渲染
+  if (children) {
+    // 非空时（isEmpty=false 或 hideUI=true）：隐藏拖拽 UI 但保留功能
+    if (isEmpty === false || hideUI) {
+      return (
+        <div 
+          className={cn('relative h-full', className)}
+          onDragOver={handleDragOver}
+          onDragLeave={handleDragLeave}
+          onDrop={handleDrop}
+        >
+          {children}
+          {dragOverlay}
+          {uploadingOverlay}
+        </div>
+      )
+    }
+    
+    // 空目录时：只显示拖拽 UI，不渲染 children（避免背景遮挡）
+    return (
+      <div className={cn('h-full flex flex-col', className)}>
+        <div
+          className={cn(
+            'relative flex-1 flex flex-col items-center justify-center gap-3 rounded-xl border-2 border-dashed px-3 py-4',
+            'transition-colors duration-200',
+            isDragOver
+              ? 'border-primary bg-primary/5'
+              : 'border-muted-foreground/20 hover:border-muted-foreground/40',
+            isUploading && 'pointer-events-none opacity-60',
+          )}
+          onDragOver={handleDragOver}
+          onDragLeave={handleDragLeave}
+          onDrop={handleDrop}
+        >
+          {isWorkspace ? (
+            <FolderOpen className={cn(
+              'size-8 transition-colors',
+              isDragOver ? 'text-primary' : 'text-muted-foreground/40',
+            )} />
+          ) : (
+            <Upload className={cn(
+              'size-8 transition-colors',
+              isDragOver ? 'text-primary' : 'text-muted-foreground/40',
+            )} />
+          )}
+          <p className="text-xs text-muted-foreground text-center leading-relaxed">
+            拖拽文件或文件夹到此处
+            <br />
+            <span className="text-[10px] text-muted-foreground/50">
+              {isWorkspace ? '工作区内所有会话可访问' : '供 Agent 读取和处理'}
+            </span>
+          </p>
+          {dragOverlay}
+          {uploadingOverlay}
+        </div>
+      </div>
+    )
+  }
+
+  // 无子元素时：默认显示拖拽区域 UI
   return (
-    <div className="flex-shrink-0 px-3 pt-3 pb-1">
+    <div className={cn('h-full flex flex-col', className)}>
       <div
         className={cn(
-          'relative flex flex-col items-center justify-center gap-2 rounded-xl border-2 border-dashed px-3 py-4',
-          'transition-colors duration-200 cursor-default',
+          'relative flex-1 flex flex-col items-center justify-center gap-3 rounded-xl border-2 border-dashed px-3 py-4',
+          'transition-colors duration-200',
           isDragOver
             ? 'border-primary bg-primary/5'
             : 'border-muted-foreground/20 hover:border-muted-foreground/40',
@@ -161,64 +290,26 @@ export function FileDropZone({ workspaceSlug, sessionId, target = 'session', onF
         onDragLeave={handleDragLeave}
         onDrop={handleDrop}
       >
-        {isUploading ? (
-          <>
-            <Loader2 className="size-5 text-muted-foreground animate-spin" />
-            <span className="text-xs text-muted-foreground">正在上传...</span>
-          </>
+        {isWorkspace ? (
+          <FolderOpen className={cn(
+            'size-8 transition-colors',
+            isDragOver ? 'text-primary' : 'text-muted-foreground/40',
+          )} />
         ) : (
-          <>
-            <Upload className={cn(
-              'size-5 transition-colors',
-              isDragOver ? 'text-primary' : 'text-muted-foreground/60',
-            )} />
-            <p className="text-xs text-muted-foreground text-center leading-relaxed">
-              拖拽文件到此处
-              <br />
-              <span className="text-[10px] text-muted-foreground/60">
-                {isWorkspace ? '工作区内所有会话可访问' : '供 Agent 读取和处理'}
-              </span>
-            </p>
-            <div className="flex items-center gap-1.5">
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <Button
-                    type="button"
-                    variant="outline"
-                    size="sm"
-                    className="h-6 text-[11px] px-2 gap-1"
-                    onClick={handleSelectFiles}
-                  >
-                    <File className="size-3" />
-                    选择文件
-                  </Button>
-                </TooltipTrigger>
-                <TooltipContent side="bottom">
-                  <p>{isWorkspace ? '添加文件到工作区文件目录' : '将文件放入 Agent 工作文件夹'}</p>
-                </TooltipContent>
-              </Tooltip>
-              {onAttachFolder && (
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <Button
-                      type="button"
-                      variant="outline"
-                      size="sm"
-                      className="h-6 text-[11px] px-2 gap-1"
-                      onClick={onAttachFolder}
-                    >
-                      <FolderPlus className="size-3" />
-                      附加文件夹
-                    </Button>
-                  </TooltipTrigger>
-                  <TooltipContent side="bottom">
-                    <p>{isWorkspace ? '附加文件夹供工作区所有会话访问' : '告知 Agent 你想处理的文件夹'}</p>
-                  </TooltipContent>
-                </Tooltip>
-              )}
-            </div>
-          </>
+          <Upload className={cn(
+            'size-8 transition-colors',
+            isDragOver ? 'text-primary' : 'text-muted-foreground/40',
+          )} />
         )}
+        <p className="text-xs text-muted-foreground text-center leading-relaxed">
+          拖拽文件或文件夹到此处
+          <br />
+          <span className="text-[10px] text-muted-foreground/50">
+            {isWorkspace ? '工作区内所有会话可访问' : '供 Agent 读取和处理'}
+          </span>
+        </p>
+        {dragOverlay}
+        {uploadingOverlay}
       </div>
     </div>
   )
diff --git a/apps/electron/src/renderer/components/file-browser/FileMentionList.tsx b/apps/electron/src/renderer/components/file-browser/FileMentionList.tsx
index 29aeb141..92051178 100644
--- a/apps/electron/src/renderer/components/file-browser/FileMentionList.tsx
+++ b/apps/electron/src/renderer/components/file-browser/FileMentionList.tsx
@@ -1,12 +1,14 @@
 /**
  * FileMentionList — @ 引用文件下拉列表
  *
- * 显示文件搜索结果，支持键盘导航（上/下/Enter/Escape）。
+ * 显示文件搜索结果，按"本会话文件"和"工作区文件"分组，
+ * 工作区文件进一步按文件夹（上传文件、voc、generated等）分组。
+ * 支持键盘导航（上/下/Enter/Escape）。
  * 通过 React.useImperativeHandle 暴露 onKeyDown 给 TipTap Suggestion。
  */
 
 import * as React from 'react'
-import { Folder, FileText } from 'lucide-react'
+import { Folder, FileText, ChevronRight } from 'lucide-react'
 import { cn } from '@/lib/utils'
 import type { FileIndexEntry } from '@proma/shared'
 
@@ -20,37 +22,107 @@ export interface FileMentionRef {
   onKeyDown: (props: { event: KeyboardEvent }) => boolean
 }
 
+// 文件夹分组
+interface FolderGroup {
+  name: string
+  path: string
+  items: FileIndexEntry[]
+}
+
+// 一级分组（本会话/工作区）
+interface SourceGroup {
+  source: 'session' | 'workspace'
+  name: string
+  // 本会话文件的直接子项
+  items: FileIndexEntry[]
+  // 工作区文件的文件夹分组
+  folders: FolderGroup[]
+}
+
 export const FileMentionList = React.forwardRef<FileMentionRef, FileMentionListProps>(
   function FileMentionList({ items, selectedIndex, onSelect }, ref) {
-    const [localIndex, setLocalIndex] = React.useState(selectedIndex)
     const containerRef = React.useRef<HTMLDivElement>(null)
 
-    // items 变化时重置选中索引
-    React.useEffect(() => {
-      setLocalIndex(0)
+    // 构建分组数据结构
+    const groupedData = React.useMemo(() => {
+      // 按 source 分组
+      const sessionItems = items.filter((item) => item.source === 'session')
+      const workspaceItems = items.filter((item) => item.source === 'workspace')
+
+      // 工作区文件按 folder 分组
+      const folderMap = new Map<string, FolderGroup>()
+      workspaceItems.forEach((item) => {
+        const folderName = item.folder || '其他'
+        const folderPath = item.folderPath || ''
+        if (!folderMap.has(folderName)) {
+          folderMap.set(folderName, { name: folderName, path: folderPath, items: [] })
+        }
+        folderMap.get(folderName)!.items.push(item)
+      })
+
+      const result: SourceGroup[] = []
+      if (sessionItems.length > 0) {
+        result.push({
+          source: 'session',
+          name: '本会话文件',
+          items: sessionItems,
+          folders: [],
+        })
+      }
+
+      if (workspaceItems.length > 0) {
+        result.push({
+          source: 'workspace',
+          name: '工作区文件',
+          items: [],
+          folders: Array.from(folderMap.values()),
+        })
+      }
+
+      return result
     }, [items])
 
+    // 构建扁平化列表用于键盘导航（按显示顺序）
+    const flatItems = React.useMemo(() => {
+      const flat: FileIndexEntry[] = []
+      groupedData.forEach((group) => {
+        if (group.source === 'session') {
+          flat.push(...group.items)
+        } else {
+          group.folders.forEach((folder) => {
+            flat.push(...folder.items)
+          })
+        }
+      })
+      return flat
+    }, [groupedData])
+
     // 滚动选中项到可见区域
     React.useEffect(() => {
       const container = containerRef.current
       if (!container) return
-      const item = container.children[localIndex] as HTMLElement | undefined
+      const buttons = container.querySelectorAll('button[data-item-index]')
+      const item = buttons[selectedIndex] as HTMLElement | undefined
       item?.scrollIntoView({ block: 'nearest' })
-    }, [localIndex])
+    }, [selectedIndex])
 
     // 暴露键盘处理给 TipTap
     React.useImperativeHandle(ref, () => ({
       onKeyDown: ({ event }) => {
         if (event.key === 'ArrowUp') {
-          setLocalIndex((prev) => (prev <= 0 ? items.length - 1 : prev - 1))
+          const newIndex = selectedIndex <= 0 ? flatItems.length - 1 : selectedIndex - 1
+          const item = flatItems[newIndex]
+          if (item) onSelect(item)
           return true
         }
         if (event.key === 'ArrowDown') {
-          setLocalIndex((prev) => (prev >= items.length - 1 ? 0 : prev + 1))
+          const newIndex = selectedIndex >= flatItems.length - 1 ? 0 : selectedIndex + 1
+          const item = flatItems[newIndex]
+          if (item) onSelect(item)
           return true
         }
         if (event.key === 'Enter') {
-          const item = items[localIndex]
+          const item = flatItems[selectedIndex]
           if (item) onSelect(item)
           return true
         }
@@ -70,34 +142,94 @@ export const FileMentionList = React.forwardRef<FileMentionRef, FileMentionListP
       )
     }
 
+    // 渲染文件项，根据 depth 缩进
+    const renderFileItem = (item: FileIndexEntry, globalIndex: number) => {
+      // 基础缩进 12px，每层 depth 增加 12px
+      const depth = item.depth ?? 0
+      const paddingLeft = 12 + depth * 12  // 基础 12px + 层级缩进
+      
+      return (
+        <button
+          key={`${item.source}-${item.path}`}
+          type="button"
+          data-item-index={globalIndex}
+          className={cn(
+            'w-full flex items-center gap-1.5 py-1 pr-2.5 text-left text-xs hover:bg-accent transition-colors',
+            globalIndex === selectedIndex && 'bg-accent text-accent-foreground'
+          )}
+          style={{ paddingLeft: `${paddingLeft}px` }}
+          onClick={() => onSelect(item)}
+        >
+          {item.type === 'dir' ? (
+            <Folder className="size-3 flex-shrink-0 text-amber-500" />
+          ) : (
+            <FileText className="size-3 flex-shrink-0 text-muted-foreground" />
+          )}
+          <span className="truncate flex-1">{item.name}</span>
+        </button>
+      )
+    }
+
+    // 计算全局索引
+    let currentIndex = 0
+    const getNextIndex = () => currentIndex++
+
     return (
       <div
         ref={containerRef}
-        className="rounded-lg border bg-popover shadow-lg overflow-y-auto max-h-[280px] min-w-[200px]"
+        className="rounded-lg border bg-popover shadow-lg overflow-y-auto max-h-[360px] min-w-[280px]"
       >
-        {items.map((item, index) => (
-          <button
-            key={item.path}
-            type="button"
-            className={cn(
-              'w-full flex items-center gap-1.5 px-2.5 py-1 text-left text-xs hover:bg-accent transition-colors',
-              index === localIndex && 'bg-accent text-accent-foreground',
-            )}
-            onClick={() => onSelect(item)}
+        {groupedData.map((group, groupIndex) => (
+          <div key={group.source} className={cn('py-1', groupIndex > 0 && 'border-t border-border/50')}
           >
-            {item.type === 'dir' ? (
-              <Folder className="size-3 text-amber-500 flex-shrink-0" />
-            ) : (
-              <FileText className="size-3 text-muted-foreground flex-shrink-0" />
-            )}
-            <span className="truncate flex-1">{item.name}</span>
-            {/* 显示相对路径（当路径不等于文件名时） */}
-            {item.path !== item.name && (
-              <span className="text-[10px] text-muted-foreground/60 truncate max-w-[120px]">
-                {item.path}
+            {/* 一级分组标题：本会话文件 / 工作区文件 */}
+            <div
+              className={cn(
+                'flex items-center gap-1.5 px-2.5 py-1.5 text-[11px] font-medium sticky top-0 bg-popover z-10',
+                group.source === 'session' ? 'text-muted-foreground/80' : 'text-primary/80'
+              )}
+            >
+              <Folder className={cn(
+                'size-3',
+                group.source === 'session' ? 'text-muted-foreground/60' : 'text-primary/60'
+              )} />
+              <span>{group.name}</span>
+              <span className={cn(
+                'text-[10px]',
+                group.source === 'session' ? 'text-muted-foreground/50' : 'text-primary/50'
+              )}>
+                ({group.source === 'session' ? group.items.length : group.folders.reduce((sum, f) => sum + f.items.length, 0)})
               </span>
+            </div>
+
+            {/* 本会话文件：直接显示 */}
+            {group.source === 'session' && (
+              <div>
+                {group.items.map((item) => renderFileItem(item, getNextIndex()))}
+              </div>
+            )}
+
+            {/* 工作区文件：按文件夹分组显示 */}
+            {group.source === 'workspace' && (
+              <div className="pl-2">
+                {group.folders.map((folder) => (
+                  <div key={folder.name} className="mb-1">
+                    {/* 文件夹标题 */}
+                    <div className="flex items-center gap-1 px-2 py-0.5 text-[11px] text-muted-foreground/70">
+                      <ChevronRight className="size-3 text-muted-foreground/40" />
+                      <Folder className="size-3 text-amber-500/70" />
+                      <span className="font-medium">{folder.name}</span>
+                      <span className="text-[10px] text-muted-foreground/40">({folder.items.length})</span>
+                    </div>
+                    {/* 文件夹内文件 */}
+                    <div>
+                      {folder.items.map((item) => renderFileItem(item, getNextIndex()))}
+                    </div>
+                  </div>
+                ))}
+              </div>
             )}
-          </button>
+          </div>
         ))}
       </div>
     )
diff --git a/apps/electron/src/renderer/components/file-browser/file-mention-suggestion.tsx b/apps/electron/src/renderer/components/file-browser/file-mention-suggestion.tsx
index eb1be1af..cccb1a53 100644
--- a/apps/electron/src/renderer/components/file-browser/file-mention-suggestion.tsx
+++ b/apps/electron/src/renderer/components/file-browser/file-mention-suggestion.tsx
@@ -2,7 +2,9 @@
  * FileMentionSuggestion — TipTap Mention Suggestion 配置
  *
  * 工厂函数，创建用于 @ 引用文件的 TipTap Suggestion 配置。
- * 输入 @ 后异步搜索工作区文件，弹出 FileMentionList 浮动列表。
+ * 
+ * 设计原则：所有数据直接通过 IPC 获取，不依赖外部状态。
+ * 输入 @ 后，递归扫描所有目录显示在 FileMentionList 中。
  */
 
 import type React from 'react'
@@ -10,40 +12,147 @@ import { ReactRenderer } from '@tiptap/react'
 import type { SuggestionOptions } from '@tiptap/suggestion'
 import { FileMentionList } from './FileMentionList'
 import type { FileMentionRef } from './FileMentionList'
-import type { FileIndexEntry } from '@proma/shared'
+import type { FileIndexEntry, FileEntry } from '@proma/shared'
 import { createMentionPopup, positionPopup } from '@/components/agent/mention-popup-utils'
 
+/**
+ * 从路径中提取文件夹名称
+ */
+function getFolderName(path: string): string {
+  const parts = path.split('/').filter(Boolean)
+  return parts[parts.length - 1] || path
+}
+
+/**
+ * 递归扫描目录，限制深度
+ */
+async function scanDirectory(
+  dirPath: string,
+  folderName: string,
+  queryLower: string,
+  depth: number = 0,
+  maxDepth: number = 3,
+  listFn: (path: string) => Promise<FileEntry[]>
+): Promise<FileIndexEntry[]> {
+  if (depth > maxDepth) return []
+
+  const items = await listFn(dirPath).catch(() => [])
+  const result: FileIndexEntry[] = []
+
+  for (const item of items) {
+    // 过滤匹配查询
+    if (queryLower && !item.name.toLowerCase().includes(queryLower)) {
+      // 如果当前项不匹配，但如果是目录，仍可能子项匹配，继续递归
+      if (!item.isDirectory) continue
+    }
+
+    result.push({
+      name: item.name,
+      path: item.path,
+      type: (item.isDirectory ? 'dir' : 'file') as 'file' | 'dir',
+      source: 'workspace' as const,
+      folder: folderName,
+      folderPath: dirPath,
+      depth,
+    })
+
+    // 递归扫描子目录
+    if (item.isDirectory) {
+      const subItems = await scanDirectory(item.path, folderName, queryLower, depth + 1, maxDepth, listFn)
+      result.push(...subItems)
+    }
+  }
+
+  return result
+}
+
 /**
  * 创建文件 @ 引用的 Suggestion 配置
- *
- * @param workspacePathRef 当前工作区根路径引用
+ * 
+ * @param workspaceIdRef 当前工作区 ID
+ * @param sessionIdRef 当前会话 ID
+ * @param workspaceSlugRef 当前工作区 slug
  * @param mentionActiveRef 是否正在 mention 模式（用于阻止 Enter 发送消息）
- * @param attachedDirsRef 附加目录路径列表引用（搜索时一并扫描）
  */
 export function createFileMentionSuggestion(
-  workspacePathRef: React.RefObject<string | null>,
+  workspaceIdRef: React.RefObject<string | null>,
+  sessionIdRef: React.RefObject<string | null>,
+  workspaceSlugRef: React.RefObject<string | null>,
   mentionActiveRef: React.MutableRefObject<boolean>,
-  attachedDirsRef?: React.RefObject<string[]>,
 ): Omit<SuggestionOptions<FileIndexEntry>, 'editor'> {
   return {
     char: '@',
     allowSpaces: false,
 
-    // 异步搜索文件
+    // 异步搜索文件（本会话文件 + 工作区文件）
     items: async ({ query }): Promise<FileIndexEntry[]> => {
-      const wsPath = workspacePathRef.current
-      if (!wsPath) return []
+      const workspaceId = workspaceIdRef.current
+      const sessionId = sessionIdRef.current
+      const workspaceSlug = workspaceSlugRef.current
+      const queryLower = (query ?? '').toLowerCase()
+
+      // 如果没有工作区和会话信息，返回空
+      if (!workspaceId || !sessionId) return []
 
       try {
-        const additionalPaths = attachedDirsRef?.current ?? []
-        const result = await window.electronAPI.searchWorkspaceFiles(
-          wsPath,
-          query ?? '',
-          20,
-          additionalPaths.length > 0 ? additionalPaths : undefined,
-        )
-        return result.entries
-      } catch {
+        // 并行获取所有路径信息
+        const [
+          sessionPathResult,
+          workspaceFilesPathResult,
+          attachedDirsResult,
+        ] = await Promise.all([
+          window.electronAPI.getAgentSessionPath(workspaceId, sessionId).catch(() => null),
+          workspaceSlug ? window.electronAPI.getWorkspaceFilesPath(workspaceSlug).catch(() => null) : Promise.resolve(null),
+          workspaceSlug ? window.electronAPI.getWorkspaceDirectories(workspaceSlug).catch(() => []) : Promise.resolve([]),
+        ])
+
+        const allItems: FileIndexEntry[] = []
+
+        // 1. 搜索本会话文件（递归，限制深度3）
+        if (sessionPathResult) {
+          const sessionFiles = await scanDirectory(
+            sessionPathResult,
+            '本会话文件',
+            queryLower,
+            0,
+            3,
+            (path) => window.electronAPI.listDirectory(path)
+          )
+          // 标记为 session source
+          sessionFiles.forEach(item => { item.source = 'session'; item.folder = undefined })
+          allItems.push(...sessionFiles)
+        }
+
+        // 2.1 搜索上传文件目录（递归，限制深度3）
+        if (workspaceFilesPathResult) {
+          const uploadFiles = await scanDirectory(
+            workspaceFilesPathResult,
+            '上传文件',
+            queryLower,
+            0,
+            3,
+            (path) => window.electronAPI.listDirectory(path)
+          )
+          allItems.push(...uploadFiles)
+        }
+
+        // 2.2 搜索关联的外部目录（递归，限制深度3）
+        for (const dir of attachedDirsResult) {
+          const folderName = getFolderName(dir)
+          const attachedFiles = await scanDirectory(
+            dir,
+            folderName,
+            queryLower,
+            0,
+            3,
+            (path) => window.electronAPI.listAttachedDirectory(path)
+          )
+          allItems.push(...attachedFiles)
+        }
+
+        return allItems
+      } catch (error) {
+        console.error('[FileMention] 搜索文件失败:', error)
         return []
       }
     },
diff --git a/apps/electron/src/renderer/components/settings/AgentPersonaEditor.tsx b/apps/electron/src/renderer/components/settings/AgentPersonaEditor.tsx
new file mode 100644
index 00000000..19cf21ec
--- /dev/null
+++ b/apps/electron/src/renderer/components/settings/AgentPersonaEditor.tsx
@@ -0,0 +1,297 @@
+/**
+ * AgentPersonaEditor - Agent 个性化配置编辑器
+ *
+ * 用于编辑工作区的 AGENT.md、USER.md、SOUL.md、MEMORY.md 文件。
+ * 这些文件定义了机器人的身份、性格、用户设定和长期记忆。
+ */
+
+import * as React from 'react'
+import { useAtomValue } from 'jotai'
+import { toast } from 'sonner'
+import { Loader2, Save, FileText, Heart, User, Brain } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { SettingsSection } from './primitives/SettingsSection'
+import { SettingsCard } from './primitives/SettingsCard'
+import { agentWorkspacesAtom } from '@/atoms/agent-atoms'
+import type { AgentPersona } from '@proma/shared'
+
+// ===== 常量 =====
+
+type PersonaTab = 'agent' | 'user' | 'soul' | 'memory'
+
+const TAB_OPTIONS: Array<{ value: PersonaTab; label: string; icon: React.ReactNode; description: string }> = [
+  {
+    value: 'agent',
+    label: 'AGENT.md',
+    icon: <FileText size={14} />,
+    description: '机器人身份描述：机器人是谁、做什么、擅长什么',
+  },
+  {
+    value: 'user',
+    label: 'USER.md',
+    icon: <User size={14} />,
+    description: '用户设定：用户背景、偏好、约束条件',
+  },
+  {
+    value: 'soul',
+    label: 'SOUL.md',
+    icon: <Heart size={14} />,
+    description: '机器人灵魂：说话方式、语气、行为准则',
+  },
+  {
+    value: 'memory',
+    label: 'MEMORY.md',
+    icon: <Brain size={14} />,
+    description: '长期记忆：决策、偏好、持久的事实',
+  },
+]
+
+// ===== 角色描述 =====
+
+/** AGENT.md 模板提示 */
+const AGENT_TEMPLATE = `# 机器人身份
+
+你是 [机器人名称]，一个 [简短描述机器人是什么/做什么]。
+
+## 背景
+[介绍机器人的来历、背景故事]
+
+## 专长
+- [专长 1]
+- [专长 2]
+- [专长 3]
+
+## 行为准则
+[机器人应该遵循的行为准则]`
+
+/** SOUL.md 模板提示 */
+const SOUL_TEMPLATE = `# 说话风格与行为准则
+
+## 语气
+[机器人说话的语气特点，如：幽默/严肃/亲切/专业]
+
+## 常用表达
+[机器人常用的口头禅或表达方式]
+
+## 禁忌
+[机器人不应该做的事或说的话]
+
+## 特殊行为
+[机器人特有的行为模式]`
+
+/** MEMORY.md 模板提示 */
+const MEMORY_TEMPLATE = `# 长期记忆
+
+## 重要决策
+[记录重要的决策和其背后的原因]
+
+## 用户偏好
+[用户喜欢什么、不喜欢什么]
+
+## 持久事实
+[关于用户、项目或任务的持久信息]
+
+## 学习总结
+[从交互中学到的重要经验]`
+
+/** USER.md 模板提示 */
+const USER_TEMPLATE = `# 关于用户
+
+## 基本信息
+- 姓名：[用户姓名]
+- 背景：[用户的职业/背景]
+
+## 偏好
+- [偏好 1]
+- [偏好 2]
+
+## 约束条件
+[用户不希望被怎样对待，或有什么特殊要求]`
+
+// ===== 主组件 =====
+
+export function AgentPersonaEditor(): React.ReactElement {
+  const workspaces = useAtomValue(agentWorkspacesAtom)
+
+  const [selectedWorkspaceId, setSelectedWorkspaceId] = React.useState<string>('')
+  const [activeTab, setActiveTab] = React.useState<PersonaTab>('agent')
+  const [loading, setLoading] = React.useState(false)
+  const [saving, setSaving] = React.useState(false)
+  const [persona, setPersona] = React.useState<AgentPersona>({
+    agentMd: '',
+    userMd: '',
+    soulMd: '',
+    memoryMd: '',
+  })
+  const [hasChanges, setHasChanges] = React.useState(false)
+
+  // 当工作区变化时加载 persona
+  React.useEffect(() => {
+    if (!selectedWorkspaceId) return
+
+    setLoading(true)
+    window.electronAPI.getAgentPersona(selectedWorkspaceId)
+      .then((p) => {
+        setPersona(p)
+        setHasChanges(false)
+      })
+      .catch((err) => {
+        console.error('加载 Persona 失败:', err)
+        toast.error('加载失败')
+      })
+      .finally(() => setLoading(false))
+  }, [selectedWorkspaceId])
+
+  // 自动选择第一个工作区
+  React.useEffect(() => {
+    if (!selectedWorkspaceId && workspaces.length > 0) {
+      setSelectedWorkspaceId(workspaces[0]!.id)
+    }
+  }, [workspaces, selectedWorkspaceId])
+
+  // 跟踪变化
+  const handleChange = React.useCallback((tab: PersonaTab, value: string) => {
+    setPersona((prev) => ({
+      ...prev,
+      [tab === 'agent' ? 'agentMd' : tab === 'user' ? 'userMd' : tab === 'soul' ? 'soulMd' : 'memoryMd']: value,
+    }))
+    setHasChanges(true)
+  }, [])
+
+  // 保存
+  const handleSave = React.useCallback(async () => {
+    if (!selectedWorkspaceId) return
+
+    setSaving(true)
+    try {
+      await window.electronAPI.saveAgentPersona(selectedWorkspaceId, persona)
+      toast.success('已保存')
+      setHasChanges(false)
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : '保存失败')
+    } finally {
+      setSaving(false)
+    }
+  }, [selectedWorkspaceId, persona])
+
+  // 应用模板
+  const handleApplyTemplate = React.useCallback((tab: PersonaTab) => {
+    const template =
+      tab === 'agent' ? AGENT_TEMPLATE : tab === 'user' ? USER_TEMPLATE : tab === 'soul' ? SOUL_TEMPLATE : MEMORY_TEMPLATE
+    handleChange(tab, template)
+    toast.info('已应用模板，请根据需要修改')
+  }, [handleChange])
+
+  const currentContent =
+    activeTab === 'agent' ? persona.agentMd : activeTab === 'user' ? persona.userMd : activeTab === 'soul' ? persona.soulMd : persona.memoryMd
+  const currentTabInfo = TAB_OPTIONS.find((t) => t.value === activeTab)!
+
+  return (
+    <div className="space-y-6">
+      {/* 工作区选择 */}
+      <SettingsSection
+        title="Agent 个性化配置"
+        description="为不同工作区的 Agent 配置不同的身份、性格和用户设定"
+      >
+        <SettingsCard>
+          <div className="px-4 py-3">
+            <label className="text-sm font-medium text-foreground mb-1.5 block">选择工作区</label>
+            <select
+              className="w-full h-9 rounded-md border border-input bg-background px-3 text-sm"
+              value={selectedWorkspaceId}
+              onChange={(e) => setSelectedWorkspaceId(e.target.value)}
+            >
+              <option value="">选择工作区...</option>
+              {workspaces.map((w) => (
+                <option key={w.id} value={w.id}>
+                  {w.name}
+                </option>
+              ))}
+            </select>
+          </div>
+        </SettingsCard>
+      </SettingsSection>
+
+      {/* Tab 选择 */}
+      {selectedWorkspaceId && (
+        <>
+          <div className="flex items-center gap-2">
+            <div className="inline-flex rounded-lg bg-muted p-1 gap-0.5">
+              {TAB_OPTIONS.map((tab) => (
+                <button
+                  key={tab.value}
+                  type="button"
+                  onClick={() => setActiveTab(tab.value)}
+                  className={cn(
+                    'px-3 py-1.5 rounded-md text-sm font-medium transition-colors flex items-center gap-1.5',
+                    activeTab === tab.value
+                      ? 'bg-background text-foreground shadow-sm'
+                      : 'text-muted-foreground hover:text-foreground'
+                  )}
+                >
+                  {tab.icon}
+                  <span>{tab.label}</span>
+                </button>
+              ))}
+            </div>
+
+            <div className="flex-1" />
+
+            <Button
+              size="sm"
+              variant="outline"
+              onClick={() => handleApplyTemplate(activeTab)}
+            >
+              应用模板
+            </Button>
+            <Button
+              size="sm"
+              onClick={handleSave}
+              disabled={saving || !hasChanges}
+            >
+              {saving && <Loader2 size={14} className="animate-spin" />}
+              <Save size={14} className="mr-1.5" />
+              <span>保存</span>
+            </Button>
+          </div>
+
+          {/* Tab 描述 */}
+          <div className="text-sm text-muted-foreground">
+            {currentTabInfo.description}
+          </div>
+
+          {/* 编辑器 */}
+          {loading ? (
+            <div className="flex items-center justify-center py-20">
+              <Loader2 size={24} className="animate-spin text-muted-foreground" />
+            </div>
+          ) : (
+            <textarea
+              className="w-full h-96 rounded-md border border-input bg-background px-3 py-2 text-sm font-mono resize-none focus:outline-none focus:ring-2 focus:ring-primary/50"
+              value={currentContent}
+              onChange={(e) => handleChange(activeTab, e.target.value)}
+              placeholder={
+                activeTab === 'agent'
+                  ? '定义机器人的身份和角色...'
+                  : activeTab === 'user'
+                  ? '定义用户的信息和偏好...'
+                  : '定义机器人的性格和说话风格...'
+              }
+            />
+          )}
+
+          {/* 提示 */}
+          <div className="text-xs text-muted-foreground space-y-1">
+            <p>这些文件会被注入到 Agent 的 system prompt 中，影响 Agent 的行为和回复风格。</p>
+            <p>支持 Markdown 格式。</p>
+          </div>
+        </>
+      )}
+    </div>
+  )
+}
+
+// 工具函数
+function cn(...classes: (string | boolean | undefined)[]): string {
+  return classes.filter(Boolean).join(' ')
+}
diff --git a/apps/electron/src/renderer/components/settings/AgentSettings.tsx b/apps/electron/src/renderer/components/settings/AgentSettings.tsx
index f9c811c0..a5f5e954 100644
--- a/apps/electron/src/renderer/components/settings/AgentSettings.tsx
+++ b/apps/electron/src/renderer/components/settings/AgentSettings.tsx
@@ -10,7 +10,7 @@
 
 import * as React from 'react'
 import { useAtomValue, useSetAtom } from 'jotai'
-import { Plus, Plug, Pencil, Trash2, Sparkles, FolderOpen, MessageSquare, ShieldCheck, ChevronDown, ChevronRight, Brain, ImagePlus, Settings } from 'lucide-react'
+import { Plus, Plug, Pencil, Trash2, Sparkles, FolderOpen, MessageSquare, ShieldCheck, ChevronDown, ChevronRight, Brain, ImagePlus, Settings, Bot } from 'lucide-react'
 import { Button } from '@/components/ui/button'
 import { Switch } from '@/components/ui/switch'
 import { Tooltip, TooltipTrigger, TooltipContent } from '@/components/ui/tooltip'
@@ -33,7 +33,7 @@ import { activeViewAtom } from '@/atoms/active-view'
 import { appModeAtom } from '@/atoms/app-mode'
 import { chatToolsAtom } from '@/atoms/chat-tool-atoms'
 import { settingsTabAtom } from '@/atoms/settings-tab'
-import type { McpServerEntry, SkillMeta, WorkspaceMcpConfig, ThinkingConfig, AgentEffort } from '@proma/shared'
+import type { McpServerEntry, SkillMeta, AgentMeta, WorkspaceMcpConfig, ThinkingConfig, AgentEffort } from '@proma/shared'
 import { SettingsSection, SettingsCard, SettingsRow, SettingsSegmentedControl, SettingsInput } from './primitives'
 import { McpServerForm } from './McpServerForm'
 
@@ -70,6 +70,8 @@ export function AgentSettings(): React.ReactElement {
   const [mcpConfig, setMcpConfig] = React.useState<WorkspaceMcpConfig>({ servers: {} })
   const [skills, setSkills] = React.useState<SkillMeta[]>([])
   const [skillsDir, setSkillsDir] = React.useState('')
+  const [customAgents, setCustomAgents] = React.useState<AgentMeta[]>([])
+  const [agentsDir, setAgentsDir] = React.useState('')
   const [loading, setLoading] = React.useState(true)
 
   /** 加载 MCP 配置和 Skills */
@@ -80,14 +82,18 @@ export function AgentSettings(): React.ReactElement {
     }
 
     try {
-      const [config, skillList, dir] = await Promise.all([
+      const [config, skillList, dir, agentList, aDir] = await Promise.all([
         window.electronAPI.getWorkspaceMcpConfig(workspaceSlug),
         window.electronAPI.getWorkspaceSkills(workspaceSlug),
         window.electronAPI.getWorkspaceSkillsDir(workspaceSlug),
+        window.electronAPI.getWorkspaceAgents(workspaceSlug),
+        window.electronAPI.getWorkspaceAgentsDir(workspaceSlug),
       ])
       setMcpConfig(config)
       setSkills(skillList)
       setSkillsDir(dir)
+      setCustomAgents(agentList)
+      setAgentsDir(aDir)
     } catch (error) {
       console.error('[Agent 设置] 加载工作区配置失败:', error)
     } finally {
@@ -278,6 +284,71 @@ ${skillList}
     }
   }
 
+  /** 删除子代理 */
+  const handleDeleteAgent = async (agentSlug: string, agentName: string): Promise<void> => {
+    if (!confirm(`确定删除子代理「${agentName}」？此操作不可恢复。`)) return
+
+    try {
+      await window.electronAPI.deleteWorkspaceAgent(workspaceSlug, agentSlug)
+      setCustomAgents((prev) => prev.filter((a) => a.slug !== agentSlug))
+      bumpCapabilitiesVersion((v) => v + 1)
+    } catch (error) {
+      console.error('[Agent 设置] 删除子代理失败:', error)
+    }
+  }
+
+  /** 切换子代理启用/禁用 */
+  const handleToggleAgent = async (agentSlug: string, enabled: boolean): Promise<void> => {
+    try {
+      await window.electronAPI.toggleWorkspaceAgent(workspaceSlug, agentSlug, enabled)
+      setCustomAgents((prev) => prev.map((a) => a.slug === agentSlug ? { ...a, enabled } : a))
+      bumpCapabilitiesVersion((v) => v + 1)
+    } catch (error) {
+      console.error('[Agent 设置] 切换子代理状态失败:', error)
+    }
+  }
+
+  /** 构建子代理配置提示词 */
+  const buildAgentPrompt = (): string => {
+    const agentsDirPath = `~/.proma/agent-workspaces/${workspaceSlug}/agents/`
+    const agentList = customAgents.length > 0
+      ? customAgents.map((a) => `- ${a.name} (${a.slug}): ${a.description ?? '无描述'} [${a.enabled ? '启用' : '禁用'}]`).join('\n')
+      : '暂无子代理'
+
+    return `请帮我配置当前工作区的子代理，你要主动来帮我实现，除非不确定的时候才来问我。
+
+## 工作区信息
+- 工作区: ${currentWorkspace.name}
+- 子代理目录: ${agentsDirPath}
+
+## 子代理格式
+每个子代理是 agents/ 目录下的一个子目录，目录名即 slug。
+目录内包含 AGENT.md 文件，格式：
+
+\`\`\`markdown
+---
+name: 子代理显示名称
+description: 何时使用该代理的描述
+tools: Read, Grep, Glob
+maxTurns: 10
+---
+
+子代理的系统提示词，定义其角色和行为...
+\`\`\`
+
+frontmatter 字段说明：
+- name（必填）：显示名称
+- description（必填）：描述何时使用
+- tools（可选）：允许的工具列表（逗号分隔）
+- disallowedTools（可选）：禁止的工具列表
+- maxTurns（可选）：最大轮次
+
+## 当前子代理
+${agentList}
+
+请查看 agents/ 目录了解现有配置，根据我的需求创建或编辑子代理。`
+  }
+
   /** 表单保存回调 */
   const handleFormSaved = (): void => {
     setViewMode('list')
@@ -408,6 +479,73 @@ ${skillList}
           <span>跟 Proma Agent 对话完成配置</span>
         </Button>
       </SettingsSection>
+
+      {/* 区块三：子代理 */}
+      <SettingsSection
+        title="子代理"
+        description="将 AGENT.md 放入工作区 agents/ 目录，在对话中通过 ! 触发引用"
+        action={agentsDir ? (
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <button
+                onClick={() => window.electronAPI.openFile(agentsDir)}
+                className="p-1.5 rounded-md text-muted-foreground hover:text-foreground hover:bg-muted/50 transition-colors"
+              >
+                <FolderOpen size={16} />
+              </button>
+            </TooltipTrigger>
+            <TooltipContent>打开子代理目录</TooltipContent>
+          </Tooltip>
+        ) : undefined}
+      >
+        {loading ? (
+          <div className="text-sm text-muted-foreground py-8 text-center">加载中...</div>
+        ) : customAgents.length === 0 ? (
+          <SettingsCard divided={false}>
+            <div className="text-sm text-muted-foreground py-8 text-center">
+              暂无子代理
+            </div>
+          </SettingsCard>
+        ) : (
+          <SettingsCard>
+            {customAgents.map((agent) => (
+              <SettingsRow
+                key={agent.slug}
+                icon={<Bot size={16} className="text-blue-500" />}
+                label={agent.name}
+                description={agent.description}
+              >
+                <div className="flex items-center gap-2">
+                  <Switch
+                    checked={agent.enabled}
+                    onCheckedChange={(checked) => handleToggleAgent(agent.slug, checked)}
+                  />
+                  <Tooltip>
+                    <TooltipTrigger asChild>
+                      <button
+                        onClick={() => handleDeleteAgent(agent.slug, agent.name)}
+                        className="p-1 rounded text-muted-foreground hover:text-destructive transition-colors"
+                      >
+                        <Trash2 size={14} />
+                      </button>
+                    </TooltipTrigger>
+                    <TooltipContent>删除</TooltipContent>
+                  </Tooltip>
+                </div>
+              </SettingsRow>
+            ))}
+          </SettingsCard>
+        )}
+
+        <Button
+          size="sm"
+          className="w-full"
+          onClick={() => handleConfigViaChat(buildAgentPrompt())}
+        >
+          <MessageSquare size={14} />
+          <span>跟 Proma Agent 对话完成配置</span>
+        </Button>
+      </SettingsSection>
     </div>
   )
 }
diff --git a/apps/electron/src/renderer/components/settings/AppearanceSettings.tsx b/apps/electron/src/renderer/components/settings/AppearanceSettings.tsx
index cf7ade8c..47719dfd 100644
--- a/apps/electron/src/renderer/components/settings/AppearanceSettings.tsx
+++ b/apps/electron/src/renderer/components/settings/AppearanceSettings.tsx
@@ -2,6 +2,7 @@
  * AppearanceSettings - 外观设置页
  *
  * 主题切换（浅色/深色/跟随系统），使用 SettingsSegmentedControl。
+ * 消息卡片颜色自定义（用户消息 / AI 消息）。
  * 通过 Jotai atom 管理状态，持久化到 ~/.proma/settings.json。
  */
 
@@ -12,8 +13,16 @@ import {
   SettingsCard,
   SettingsRow,
   SettingsSegmentedControl,
+  SettingsColorPicker,
 } from './primitives'
 import { themeModeAtom, updateThemeMode } from '@/atoms/theme'
+import {
+  messageBubbleColorsAtom,
+  updateMessageBubbleColors,
+  resetMessageBubbleColors,
+} from '@/atoms/message-bubble-colors'
+import { Button } from '@/components/ui/button'
+import { RotateCcw } from 'lucide-react'
 import type { ThemeMode } from '../../../types'
 
 /** 主题选项 */
@@ -31,32 +40,109 @@ const ZOOM_HINT = isMac
 
 export function AppearanceSettings(): React.ReactElement {
   const [themeMode, setThemeMode] = useAtom(themeModeAtom)
+  const [messageColors, setMessageColors] = useAtom(messageBubbleColorsAtom)
 
   /** 切换主题模式 */
-  const handleThemeChange = React.useCallback((value: string) => {
-    const mode = value as ThemeMode
-    setThemeMode(mode)
-    updateThemeMode(mode)
-  }, [setThemeMode])
+  const handleThemeChange = React.useCallback(
+    (value: string) => {
+      const mode = value as ThemeMode
+      setThemeMode(mode)
+      void updateThemeMode(mode)
+    },
+    [setThemeMode]
+  )
+
+  /** 更新用户消息颜色 */
+  const handleUserColorChange = React.useCallback(
+    (color: string) => {
+      const updated = { ...messageColors, userMessageColor: color }
+      setMessageColors(updated)
+      void updateMessageBubbleColors({ userMessageColor: color })
+    },
+    [messageColors, setMessageColors]
+  )
+
+  /** 更新 AI 消息颜色 */
+  const handleAssistantColorChange = React.useCallback(
+    (color: string) => {
+      const updated = { ...messageColors, assistantMessageColor: color }
+      setMessageColors(updated)
+      void updateMessageBubbleColors({ assistantMessageColor: color })
+    },
+    [messageColors, setMessageColors]
+  )
+
+  /** 重置所有颜色 */
+  const handleResetAllColors = React.useCallback(() => {
+    void resetMessageBubbleColors()
+    setMessageColors({ userMessageColor: '', assistantMessageColor: '' })
+  }, [setMessageColors])
+
+  // 检查是否有自定义颜色
+  const hasCustomColors =
+    messageColors.userMessageColor || messageColors.assistantMessageColor
 
   return (
-    <SettingsSection
-      title="外观设置"
-      description="自定义应用的视觉风格"
-    >
-      <SettingsCard>
-        <SettingsSegmentedControl
-          label="主题模式"
-          description="选择应用的配色方案"
-          value={themeMode}
-          onValueChange={handleThemeChange}
-          options={THEME_OPTIONS}
-        />
-        <SettingsRow
-          label="界面缩放"
-          description={ZOOM_HINT}
-        />
-      </SettingsCard>
-    </SettingsSection>
+    <div className="space-y-6">
+      {/* 主题设置 */}
+      <SettingsSection
+        title="外观设置"
+        description="自定义应用的视觉风格"
+      >
+        <SettingsCard>
+          <SettingsSegmentedControl
+            label="主题模式"
+            description="选择应用的配色方案"
+            value={themeMode}
+            onValueChange={handleThemeChange}
+            options={THEME_OPTIONS}
+          />
+          <SettingsRow
+            label="界面缩放"
+            description={ZOOM_HINT}
+          />
+        </SettingsCard>
+      </SettingsSection>
+
+      {/* 消息气泡颜色设置 */}
+      <SettingsSection
+        title="消息气泡颜色"
+        description="自定义聊天消息的气泡背景颜色"
+        action={
+          hasCustomColors ? (
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={handleResetAllColors}
+              className="text-muted-foreground hover:text-foreground"
+            >
+              <RotateCcw className="w-3.5 h-3.5 mr-1.5" />
+              恢复默认
+            </Button>
+          ) : null
+        }
+      >
+        <SettingsCard>
+          <SettingsRow
+            label="用户消息颜色"
+            description="自己发送的消息气泡背景色"
+          >
+            <SettingsColorPicker
+              value={messageColors.userMessageColor}
+              onChange={handleUserColorChange}
+            />
+          </SettingsRow>
+          <SettingsRow
+            label="AI 消息颜色"
+            description="AI 回复的消息气泡背景色"
+          >
+            <SettingsColorPicker
+              value={messageColors.assistantMessageColor}
+              onChange={handleAssistantColorChange}
+            />
+          </SettingsRow>
+        </SettingsCard>
+      </SettingsSection>
+    </div>
   )
 }
diff --git a/apps/electron/src/renderer/components/settings/ChannelForm.tsx b/apps/electron/src/renderer/components/settings/ChannelForm.tsx
index c93612ae..a514b2bf 100644
--- a/apps/electron/src/renderer/components/settings/ChannelForm.tsx
+++ b/apps/electron/src/renderer/components/settings/ChannelForm.tsx
@@ -99,6 +99,7 @@ function buildPreviewUrl(baseUrl: string, provider: ProviderType): string {
 
 export function ChannelForm({ channel, onSaved, onCancel }: ChannelFormProps): React.ReactElement {
   const isEdit = channel !== null
+  const isLocalEnv = channel?.source === 'local_env'
 
   // 表单状态
   const [name, setName] = React.useState(channel?.name ?? '')
@@ -310,6 +311,13 @@ export function ChannelForm({ channel, onSaved, onCancel }: ChannelFormProps): R
         </div>
       </div>
 
+      {/* 本地环境渠道来源提示 */}
+      {isLocalEnv && (
+        <div className="rounded-lg border border-blue-500/20 bg-blue-500/5 px-4 py-3 text-sm text-blue-600 dark:text-blue-400">
+          此渠道由本地环境变量（~/.zshrc）自动检测生成，凭证信息为只读。你可以修改模型启用状态和渠道开关。
+        </div>
+      )}
+
       {/* 基本信息卡片 */}
       <SettingsSection title="基本信息">
         <SettingsCard>
@@ -319,6 +327,7 @@ export function ChannelForm({ channel, onSaved, onCancel }: ChannelFormProps): R
             onChange={setName}
             placeholder="例如: My Anthropic"
             required
+            disabled={isLocalEnv}
           />
           <SettingsSelect
             label="供应商类型"
@@ -326,6 +335,7 @@ export function ChannelForm({ channel, onSaved, onCancel }: ChannelFormProps): R
             onValueChange={handleProviderChange}
             options={PROVIDER_SELECT_OPTIONS}
             placeholder="选择供应商"
+            disabled={isLocalEnv}
           />
           <SettingsInput
             label="Base URL"
@@ -333,44 +343,50 @@ export function ChannelForm({ channel, onSaved, onCancel }: ChannelFormProps): R
             onChange={setBaseUrl}
             placeholder="https://api.example.com"
             description={baseUrl.trim() ? `预览：${buildPreviewUrl(baseUrl, provider)}` : undefined}
+            disabled={isLocalEnv}
           />
           {/* API Key + 测试连接同行 */}
           <div className="px-4 py-3 space-y-2">
             <div className="flex items-center justify-between">
               <div className="text-sm font-medium text-foreground">API Key</div>
-              <Button
-                variant="outline"
-                size="sm"
-                type="button"
-                onClick={handleTest}
-                disabled={testing || !apiKey.trim() || !baseUrl.trim()}
-                className="h-7 text-xs"
-              >
-                {testing ? (
-                  <Loader2 size={12} className="animate-spin" />
-                ) : (
-                  <Zap size={12} />
-                )}
-                <span>测试连接</span>
-              </Button>
+              {!isLocalEnv && (
+                <Button
+                  variant="outline"
+                  size="sm"
+                  type="button"
+                  onClick={handleTest}
+                  disabled={testing || !apiKey.trim() || !baseUrl.trim()}
+                  className="h-7 text-xs"
+                >
+                  {testing ? (
+                    <Loader2 size={12} className="animate-spin" />
+                  ) : (
+                    <Zap size={12} />
+                  )}
+                  <span>测试连接</span>
+                </Button>
+              )}
             </div>
             <div className="relative">
               <Input
                 type={showApiKey ? 'text' : 'password'}
-                value={apiKey}
+                value={isLocalEnv ? '••••••••' : apiKey}
                 onChange={(e) => setApiKey(e.target.value)}
                 placeholder={isEdit ? '留空则不更新' : '输入 API Key'}
                 required={!isEdit}
                 className="pr-10"
+                disabled={isLocalEnv}
               />
-              <button
-                type="button"
-                onClick={() => setShowApiKey(!showApiKey)}
-                className="absolute right-2 top-1/2 -translate-y-1/2 p-1 text-muted-foreground hover:text-foreground transition-colors"
-                tabIndex={-1}
-              >
-                {showApiKey ? <EyeOff size={16} /> : <Eye size={16} />}
-              </button>
+              {!isLocalEnv && (
+                <button
+                  type="button"
+                  onClick={() => setShowApiKey(!showApiKey)}
+                  className="absolute right-2 top-1/2 -translate-y-1/2 p-1 text-muted-foreground hover:text-foreground transition-colors"
+                  tabIndex={-1}
+                >
+                  {showApiKey ? <EyeOff size={16} /> : <Eye size={16} />}
+                </button>
+              )}
             </div>
             {testResult && (
               <div className={cn(
diff --git a/apps/electron/src/renderer/components/settings/ChannelSettings.tsx b/apps/electron/src/renderer/components/settings/ChannelSettings.tsx
index fd0eb090..4d965f68 100644
--- a/apps/electron/src/renderer/components/settings/ChannelSettings.tsx
+++ b/apps/electron/src/renderer/components/settings/ChannelSettings.tsx
@@ -3,18 +3,18 @@
  *
  * 分为两个区块：
  * 1. 渠道管理 — 所有渠道列表 + 添加/编辑/删除（渠道同时用于 Chat 和 Agent）
- * 2. Agent 供应商 — 从已启用的 Anthropic 渠道中选择默认 Agent 供应商
+ * 2. Agent 供应商 — 启用/禁用 Anthropic 渠道用于 Agent（Switch 多选）
  */
 
 import * as React from 'react'
 import { useAtom } from 'jotai'
-import { Plus, Pencil, Trash2, ExternalLink } from 'lucide-react'
+import { Plus, Pencil, Trash2 } from 'lucide-react'
 import { Button } from '@/components/ui/button'
 import { Switch } from '@/components/ui/switch'
 import { PROVIDER_LABELS } from '@proma/shared'
 import type { Channel } from '@proma/shared'
-import { getChannelLogo, PromaLogo } from '@/lib/model-logo'
-import { agentChannelIdAtom, agentModelIdAtom } from '@/atoms/agent-atoms'
+import { getChannelLogo } from '@/lib/model-logo'
+import { agentChannelIdAtom, agentModelIdAtom, agentEnabledChannelIdsAtom } from '@/atoms/agent-atoms'
 import { SettingsSection, SettingsCard, SettingsRow } from './primitives'
 import { ChannelForm } from './ChannelForm'
 
@@ -28,6 +28,7 @@ export function ChannelSettings(): React.ReactElement {
   const [loading, setLoading] = React.useState(true)
   const [agentChannelId, setAgentChannelId] = useAtom(agentChannelIdAtom)
   const [, setAgentModelId] = useAtom(agentModelIdAtom)
+  const [agentEnabledChannelIds, setAgentEnabledChannelIds] = useAtom(agentEnabledChannelIdsAtom)
 
   /** 加载渠道列表 */
   const loadChannels = React.useCallback(async (): Promise<Channel[]> => {
@@ -47,19 +48,28 @@ export function ChannelSettings(): React.ReactElement {
     loadChannels()
   }, [loadChannels])
 
-  /** 删除渠道 */
+  /** 删除渠道（本地环境渠道不可删除） */
   const handleDelete = async (channel: Channel): Promise<void> => {
+    if (channel.source === 'local_env') return
     if (!confirm(`确定删除渠道「${channel.name}」？此操作不可恢复。`)) return
 
     try {
       await window.electronAPI.deleteChannel(channel.id)
 
-      // 如果删除的是当前 Agent 渠道，清空选择
+      // 从 Agent 启用列表中移除
+      const newEnabledIds = agentEnabledChannelIds.filter((id) => id !== channel.id)
+      if (newEnabledIds.length !== agentEnabledChannelIds.length) {
+        setAgentEnabledChannelIds(newEnabledIds)
+      }
+      // 如果删除的是当前使用中的 Agent 渠道，清空选择
       if (agentChannelId === channel.id) {
         setAgentChannelId(null)
         setAgentModelId(null)
-        await window.electronAPI.updateSettings({ agentChannelId: undefined, agentModelId: undefined })
       }
+      await window.electronAPI.updateSettings({
+        agentEnabledChannelIds: newEnabledIds,
+        ...(agentChannelId === channel.id ? { agentChannelId: undefined, agentModelId: undefined } : {}),
+      })
 
       await loadChannels()
     } catch (error) {
@@ -72,51 +82,47 @@ export function ChannelSettings(): React.ReactElement {
     try {
       await window.electronAPI.updateChannel(channel.id, { enabled: !channel.enabled })
 
-      // 如果禁用的是当前 Agent 渠道，清空选择
-      if (channel.enabled && agentChannelId === channel.id) {
-        setAgentChannelId(null)
-        setAgentModelId(null)
-        await window.electronAPI.updateSettings({ agentChannelId: undefined, agentModelId: undefined })
+      // 如果禁用渠道，同时从 Agent 启用列表中移除
+      if (channel.enabled && agentEnabledChannelIds.includes(channel.id)) {
+        const newEnabledIds = agentEnabledChannelIds.filter((id) => id !== channel.id)
+        setAgentEnabledChannelIds(newEnabledIds)
+        const clearCurrent = agentChannelId === channel.id
+        if (clearCurrent) {
+          setAgentChannelId(null)
+          setAgentModelId(null)
+        }
+        await window.electronAPI.updateSettings({
+          agentEnabledChannelIds: newEnabledIds,
+          ...(clearCurrent ? { agentChannelId: undefined, agentModelId: undefined } : {}),
+        })
       }
 
-      // 加载最新渠道列表并检查是否需要自动选择
-      const updatedChannels = await loadChannels()
-      await checkAndAutoSelectAgentChannel(updatedChannels)
+      await loadChannels()
     } catch (error) {
       console.error('[渠道设置] 切换渠道状态失败:', error)
     }
   }
 
-  /** 选择 Agent 供应商 */
-  const handleSelectAgentProvider = async (channelId: string): Promise<void> => {
-    setAgentChannelId(channelId)
-    setAgentModelId(null)
-    try {
-      await window.electronAPI.updateSettings({ agentChannelId: channelId, agentModelId: undefined })
-    } catch (error) {
-      console.error('[渠道设置] 保存 Agent 供应商失败:', error)
+  /** 切换 Agent 渠道启用状态（多选） */
+  const handleToggleAgentChannel = async (channelId: string, enabled: boolean): Promise<void> => {
+    const newIds = enabled
+      ? [...agentEnabledChannelIds, channelId]
+      : agentEnabledChannelIds.filter((id) => id !== channelId)
+    setAgentEnabledChannelIds(newIds)
+
+    // 如果禁用的是当前使用中的 Agent 渠道，清空当前选择
+    if (!enabled && agentChannelId === channelId) {
+      setAgentChannelId(null)
+      setAgentModelId(null)
     }
-  }
-
-  /** 检查并自动选择 Agent 渠道 */
-  const checkAndAutoSelectAgentChannel = async (channels: Channel[]): Promise<void> => {
-    // 获取可用的 Anthropic 渠道
-    const availableAnthropicChannels = channels.filter(
-      (c) => c.provider === 'anthropic' && c.enabled
-    )
 
-    // 如果当前没有选择 Agent 渠道，或当前选择的渠道不可用，自动选择第一个可用渠道
-    const currentAgentChannel = agentChannelId
-      ? channels.find((c) => c.id === agentChannelId)
-      : null
-    const shouldAutoSelect =
-      !agentChannelId || // 没有选择
-      !currentAgentChannel || // 选择的渠道不存在
-      !currentAgentChannel.enabled || // 选择的渠道已禁用
-      currentAgentChannel.provider !== 'anthropic' // 选择的不是 Anthropic 渠道
-
-    if (shouldAutoSelect && availableAnthropicChannels.length > 0) {
-      await handleSelectAgentProvider(availableAnthropicChannels[0]!.id)
+    try {
+      await window.electronAPI.updateSettings({
+        agentEnabledChannelIds: newIds,
+        ...((!enabled && agentChannelId === channelId) ? { agentChannelId: undefined, agentModelId: undefined } : {}),
+      })
+    } catch (error) {
+      console.error('[渠道设置] 保存 Agent 渠道列表失败:', error)
     }
   }
 
@@ -124,10 +130,7 @@ export function ChannelSettings(): React.ReactElement {
   const handleFormSaved = async (): Promise<void> => {
     setViewMode('list')
     setEditingChannel(null)
-
-    // 加载最新渠道列表并检查是否需要自动选择
-    const updatedChannels = await loadChannels()
-    await checkAndAutoSelectAgentChannel(updatedChannels)
+    await loadChannels()
   }
 
   /** 取消表单 */
@@ -166,9 +169,6 @@ export function ChannelSettings(): React.ReactElement {
           </Button>
         }
       >
-        <SettingsCard>
-          <PromaProviderCard />
-        </SettingsCard>
         {loading ? (
           <div className="text-sm text-muted-foreground py-8 text-center">加载中...</div>
         ) : channels.length === 0 ? (
@@ -198,11 +198,8 @@ export function ChannelSettings(): React.ReactElement {
       {/* 区块二：Agent 供应商 */}
       <SettingsSection
         title="Agent 供应商"
-        description="选择 Agent 模式的默认供应商，上方已启用的 Anthropic 兼容渠道会自动出现在此列表"
+        description="启用或禁用 Anthropic 兼容渠道用于 Agent 模式，可多选。上方已启用的 Anthropic 渠道会自动出现在此列表"
       >
-        <SettingsCard>
-          <PromaProviderCard />
-        </SettingsCard>
         {loading ? (
           <div className="text-sm text-muted-foreground py-8 text-center">加载中...</div>
         ) : anthropicChannels.length === 0 ? (
@@ -217,8 +214,8 @@ export function ChannelSettings(): React.ReactElement {
               <AgentProviderRow
                 key={channel.id}
                 channel={channel}
-                selected={agentChannelId === channel.id}
-                onSelect={() => handleSelectAgentProvider(channel.id)}
+                enabled={agentEnabledChannelIds.includes(channel.id)}
+                onToggle={(enabled) => handleToggleAgentChannel(channel.id, enabled)}
               />
             ))}
           </SettingsCard>
@@ -237,12 +234,24 @@ interface ChannelRowProps {
   onToggle: () => void
 }
 
+/** 认证类型标签 */
+const AUTH_TYPE_LABELS: Record<string, string> = {
+  vertex: 'Vertex AI',
+  bedrock: 'Bedrock',
+}
+
 function ChannelRow({ channel, onEdit, onDelete, onToggle }: ChannelRowProps): React.ReactElement {
   const enabledCount = channel.models.filter((m) => m.enabled).length
+  const isLocalEnv = channel.source === 'local_env'
+  const authLabel = channel.authType ? AUTH_TYPE_LABELS[channel.authType] : undefined
+
+  const isAgentOnly = channel.authType === 'vertex' || channel.authType === 'bedrock'
+
   const description = [
-    PROVIDER_LABELS[channel.provider],
+    authLabel || PROVIDER_LABELS[channel.provider],
+    isLocalEnv ? '本地环境' : undefined,
     enabledCount > 0 ? `${enabledCount} 个模型已启用` : undefined,
-    channel.provider === 'anthropic' ? '可用于 Agent' : undefined,
+    isAgentOnly ? '仅 Agent 模式' : channel.provider === 'anthropic' ? '可用于 Agent' : undefined,
   ]
     .filter(Boolean)
     .join(' · ')
@@ -255,7 +264,7 @@ function ChannelRow({ channel, onEdit, onDelete, onToggle }: ChannelRowProps): R
       className="group"
     >
       <div className="flex items-center gap-2">
-        {/* 操作按钮 */}
+        {/* 编辑按钮 */}
         <button
           onClick={onEdit}
           className="p-1.5 rounded-md text-muted-foreground hover:text-foreground hover:bg-muted/50 transition-colors opacity-0 group-hover:opacity-100"
@@ -263,13 +272,16 @@ function ChannelRow({ channel, onEdit, onDelete, onToggle }: ChannelRowProps): R
         >
           <Pencil size={14} />
         </button>
-        <button
-          onClick={onDelete}
-          className="p-1.5 rounded-md text-muted-foreground hover:text-destructive hover:bg-destructive/10 transition-colors opacity-0 group-hover:opacity-100"
-          title="删除"
-        >
-          <Trash2 size={14} />
-        </button>
+        {/* 删除按钮（本地环境渠道不可删除） */}
+        {!isLocalEnv && (
+          <button
+            onClick={onDelete}
+            className="p-1.5 rounded-md text-muted-foreground hover:text-destructive hover:bg-destructive/10 transition-colors opacity-0 group-hover:opacity-100"
+            title="删除"
+          >
+            <Trash2 size={14} />
+          </button>
+        )}
 
         {/* 启用/关闭开关 */}
         <Switch
@@ -285,11 +297,11 @@ function ChannelRow({ channel, onEdit, onDelete, onToggle }: ChannelRowProps): R
 
 interface AgentProviderRowProps {
   channel: Channel
-  selected: boolean
-  onSelect: () => void
+  enabled: boolean
+  onToggle: (enabled: boolean) => void
 }
 
-function AgentProviderRow({ channel, selected, onSelect }: AgentProviderRowProps): React.ReactElement {
+function AgentProviderRow({ channel, enabled, onToggle }: AgentProviderRowProps): React.ReactElement {
   const enabledCount = channel.models.filter((m) => m.enabled).length
   const description = [
     PROVIDER_LABELS[channel.provider],
@@ -304,42 +316,10 @@ function AgentProviderRow({ channel, selected, onSelect }: AgentProviderRowProps
       icon={<img src={getChannelLogo(channel.baseUrl)} alt="" className="w-8 h-8 rounded" />}
       description={description}
     >
-      <button
-        type="button"
-        onClick={onSelect}
-        className="flex items-center justify-center w-5 h-5 rounded-full border-2 transition-colors"
-        style={{
-          borderColor: selected ? 'hsl(var(--primary))' : 'hsl(var(--border))',
-        }}
-      >
-        {selected && (
-          <span
-            className="w-2.5 h-2.5 rounded-full"
-            style={{ backgroundColor: 'hsl(var(--primary))' }}
-          />
-        )}
-      </button>
-    </SettingsRow>
-  )
-}
-
-// ===== Proma 官方供应商推广卡片 =====
-
-function PromaProviderCard(): React.ReactElement {
-  const handleDownload = (): void => {
-    window.open('http://proma.cool/download', '_blank')
-  }
-
-  return (
-    <SettingsRow
-      label="Proma"
-      icon={<img src={PromaLogo} alt="Proma" className="w-8 h-8 rounded" />}
-      description="Proma 官方供应｜稳定｜靠谱｜丝滑｜简单｜优惠套餐｜可用于 Agent"
-    >
-      <Button size="sm" variant="outline" className="gap-1.5" onClick={handleDownload}>
-        <ExternalLink size={13} />
-        <span>下载后启动</span>
-      </Button>
+      <Switch
+        checked={enabled}
+        onCheckedChange={onToggle}
+      />
     </SettingsRow>
   )
 }
diff --git a/apps/electron/src/renderer/components/settings/FeishuBotsSettings.tsx b/apps/electron/src/renderer/components/settings/FeishuBotsSettings.tsx
new file mode 100644
index 00000000..0061aa97
--- /dev/null
+++ b/apps/electron/src/renderer/components/settings/FeishuBotsSettings.tsx
@@ -0,0 +1,843 @@
+/**
+ * FeishuBotsSettings - 飞书多 Bot 管理设置页
+ *
+ * 管理多个飞书 Bot：
+ * - Bot 列表展示
+ * - 添加/编辑/删除 Bot
+ * - 每个 Bot 的连接状态
+ * - Bot 绑定的工作区
+ * - 每个 Bot 的 Persona 配置（AGENT.md, USER.md, SOUL.md, MEMORY.md）
+ */
+
+import * as React from 'react'
+import { useAtomValue, useSetAtom } from 'jotai'
+import { toast } from 'sonner'
+import {
+  Loader2,
+  Plus,
+  Trash2,
+  Play,
+  Square,
+  Settings,
+  Bot,
+  Heart,
+  FileText,
+  User,
+  Save,
+  Brain,
+} from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { ScrollArea } from '@/components/ui/scroll-area'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select'
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+} from '@/components/ui/alert-dialog'
+import { SettingsSection } from './primitives/SettingsSection'
+import { SettingsCard } from './primitives/SettingsCard'
+import { SettingsInput } from './primitives/SettingsInput'
+import { SettingsSecretInput } from './primitives/SettingsSecretInput'
+import {
+  feishuBotsAtom,
+  feishuBotStatusesAtom,
+  feishuMigratedAtom,
+} from '@/atoms/feishu-atoms'
+import { agentWorkspacesAtom } from '@/atoms/agent-atoms'
+import { cn } from '@/lib/utils'
+import type {
+  FeishuBotConfig,
+  FeishuBotConfigInput,
+  FeishuBotStatus,
+  AgentPersona,
+} from '@proma/shared'
+
+// ===== 常量 =====
+
+/** 连接状态颜色映射 */
+const STATUS_CONFIG = {
+  disconnected: { color: 'bg-gray-400', label: '未连接' },
+  connecting: { color: 'bg-yellow-400 animate-pulse', label: '连接中...' },
+  connected: { color: 'bg-green-500', label: '已连接' },
+  error: { color: 'bg-red-500', label: '连接错误' },
+} as const
+
+type PersonaTab = 'agent' | 'user' | 'soul' | 'memory'
+
+const PERSONA_TABS: Array<{ value: PersonaTab; label: string; icon: React.ReactNode }> = [
+  { value: 'agent', label: 'AGENT.md', icon: <Bot size={12} /> },
+  { value: 'user', label: 'USER.md', icon: <User size={12} /> },
+  { value: 'soul', label: 'SOUL.md', icon: <Heart size={12} /> },
+  { value: 'memory', label: 'MEMORY.md', icon: <Brain size={12} /> },
+]
+
+// ===== Persona 编辑器 =====
+
+interface PersonaEditorProps {
+  workspaceSlug: string
+  onCancel: () => void
+}
+
+function PersonaEditor({ workspaceSlug, onCancel }: PersonaEditorProps): React.ReactElement {
+  const [loading, setLoading] = React.useState(true)
+  const [saving, setSaving] = React.useState(false)
+  const [persona, setPersona] = React.useState<AgentPersona>({
+    agentMd: '',
+    userMd: '',
+    soulMd: '',
+    memoryMd: '',
+  })
+  const [activeTab, setActiveTab] = React.useState<PersonaTab>('agent')
+  const [hasChanges, setHasChanges] = React.useState(false)
+
+  // 加载 persona
+  React.useEffect(() => {
+    window.electronAPI.getAgentPersona(workspaceSlug)
+      .then((p) => {
+        setPersona(p)
+        setHasChanges(false)
+      })
+      .catch((err) => {
+        console.error('加载 Persona 失败:', err)
+        toast.error('加载失败')
+      })
+      .finally(() => setLoading(false))
+  }, [workspaceSlug])
+
+  const handleChange = React.useCallback((tab: PersonaTab, value: string) => {
+    setPersona((prev) => ({
+      ...prev,
+      [tab === 'agent' ? 'agentMd' : tab === 'user' ? 'userMd' : tab === 'soul' ? 'soulMd' : 'memoryMd']: value,
+    }))
+    setHasChanges(true)
+  }, [])
+
+  const handleSave = React.useCallback(async () => {
+    setSaving(true)
+    try {
+      await window.electronAPI.saveAgentPersona(workspaceSlug, persona)
+      toast.success('已保存')
+      setHasChanges(false)
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : '保存失败')
+    } finally {
+      setSaving(false)
+    }
+  }, [workspaceSlug, persona])
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center py-8">
+        <Loader2 size={20} className="animate-spin text-muted-foreground" />
+      </div>
+    )
+  }
+
+  const currentContent =
+    activeTab === 'agent' ? persona.agentMd : activeTab === 'user' ? persona.userMd : activeTab === 'soul' ? persona.soulMd : persona.memoryMd
+
+  return (
+    <div className="space-y-4">
+      {/* Tab 切换 */}
+      <div className="flex items-center gap-2">
+        <div className="inline-flex rounded-lg bg-muted p-1 gap-0.5">
+          {PERSONA_TABS.map((tab) => (
+            <button
+              key={tab.value}
+              type="button"
+              onClick={() => setActiveTab(tab.value)}
+              className={cn(
+                'px-3 py-1.5 rounded-md text-xs font-medium transition-colors flex items-center gap-1.5',
+                activeTab === tab.value
+                  ? 'bg-background text-foreground shadow-sm'
+                  : 'text-muted-foreground hover:text-foreground'
+              )}
+            >
+              {tab.icon}
+              <span>{tab.label}</span>
+            </button>
+          ))}
+        </div>
+        <div className="flex-1" />
+        <Button size="sm" variant="ghost" onClick={onCancel}>
+          关闭
+        </Button>
+        <Button size="sm" onClick={handleSave} disabled={saving || !hasChanges}>
+          {saving && <Loader2 size={12} className="animate-spin" />}
+          <Save size={12} className="mr-1" />
+          保存
+        </Button>
+      </div>
+
+      {/* 描述 */}
+      <p className="text-xs text-muted-foreground">
+        {activeTab === 'agent' && '机器人身份描述：机器人是谁、做什么、擅长什么'}
+        {activeTab === 'user' && '用户设定：用户背景、偏好、约束条件'}
+        {activeTab === 'soul' && '机器人灵魂：说话方式、语气、行为准则'}
+      </p>
+
+      {/* 编辑器 */}
+      <textarea
+        className="w-full h-64 rounded-md border border-input bg-background px-3 py-2 text-sm font-mono resize-none focus:outline-none focus:ring-2 focus:ring-primary/50"
+        value={currentContent}
+        onChange={(e) => handleChange(activeTab, e.target.value)}
+        placeholder={
+          activeTab === 'agent'
+            ? '定义机器人的身份和角色...'
+            : activeTab === 'user'
+            ? '定义用户的信息和偏好...'
+            : '定义机器人的性格和说话风格...'
+        }
+      />
+    </div>
+  )
+}
+
+// ===== Bot 卡片组件 =====
+
+interface BotCardProps {
+  bot: FeishuBotConfig
+  status?: FeishuBotStatus
+  onEdit: (bot: FeishuBotConfig) => void
+  onDelete: (botId: string) => void
+  onToggle: (bot: FeishuBotConfig) => void
+  onEditPersona: (bot: FeishuBotConfig) => void
+}
+
+function BotCard({ bot, status, onEdit, onDelete, onToggle, onEditPersona }: BotCardProps): React.ReactElement {
+  const workspaces = useAtomValue(agentWorkspacesAtom)
+  const currentWorkspace = workspaces.find((w) => w.id === bot.workspaceId)
+  const statusConfig = status
+    ? STATUS_CONFIG[status.status]
+    : STATUS_CONFIG.disconnected
+
+  return (
+    <div className="px-4 py-3 space-y-3">
+      {/* 头部：Bot 图标 + 名称 + 状态 */}
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-3">
+          <div className="flex items-center justify-center w-10 h-10 rounded-lg bg-primary/10 text-primary">
+            <Bot size={20} />
+          </div>
+          <div>
+            <div className="text-sm font-medium text-foreground">{bot.name}</div>
+            <div className="text-xs text-muted-foreground">{bot.appId}</div>
+          </div>
+        </div>
+
+        <div className="flex items-center gap-2">
+          {/* 状态指示器 */}
+          <div className="flex items-center gap-1.5">
+            <span className={cn('w-2 h-2 rounded-full', statusConfig.color)} />
+            <span className="text-xs text-muted-foreground">{statusConfig.label}</span>
+          </div>
+
+          {/* 启动/停止按钮 */}
+          <Button
+            size="icon"
+            variant="ghost"
+            className="h-7 w-7"
+            onClick={() => onToggle(bot)}
+            disabled={status?.status === 'connecting'}
+          >
+            {status?.status === 'connected' ? (
+              <Square size={14} className="text-red-500" />
+            ) : (
+              <Play size={14} className="text-green-500" />
+            )}
+          </Button>
+
+          {/* 人格按钮 */}
+          {bot.workspaceId && (
+            <Button
+              size="icon"
+              variant="ghost"
+              className="h-7 w-7"
+              onClick={() => onEditPersona(bot)}
+              title="编辑人格配置"
+            >
+              <Heart size={14} />
+            </Button>
+          )}
+
+          {/* 设置按钮 */}
+          <Button
+            size="icon"
+            variant="ghost"
+            className="h-7 w-7"
+            onClick={() => onEdit(bot)}
+          >
+            <Settings size={14} />
+          </Button>
+
+          {/* 删除按钮 */}
+          <AlertDialog>
+            <AlertDialogTrigger asChild>
+              <Button
+                size="icon"
+                variant="ghost"
+                className="h-7 w-7 text-muted-foreground hover:text-destructive"
+              >
+                <Trash2 size={14} />
+              </Button>
+            </AlertDialogTrigger>
+            <AlertDialogContent>
+              <AlertDialogHeader>
+                <AlertDialogTitle>删除 Bot</AlertDialogTitle>
+                <AlertDialogDescription>
+                  确定要删除「{bot.name}」吗？此操作不可恢复。
+                </AlertDialogDescription>
+              </AlertDialogHeader>
+              <AlertDialogFooter>
+                <AlertDialogCancel>取消</AlertDialogCancel>
+                <AlertDialogAction onClick={() => onDelete(bot.id)}>
+                  确认删除
+                </AlertDialogAction>
+              </AlertDialogFooter>
+            </AlertDialogContent>
+          </AlertDialog>
+        </div>
+      </div>
+
+      {/* 工作区信息 */}
+      <div className="flex items-center gap-2 text-sm text-muted-foreground">
+        <span>工作区:</span>
+        <span className="text-foreground">
+          {currentWorkspace?.name ?? '未设置'}
+        </span>
+        {status && status.activeBindings > 0 && (
+          <>
+            <span className="text-muted-foreground/50">|</span>
+            <span>{status.activeBindings} 个活跃绑定</span>
+          </>
+        )}
+      </div>
+
+      {/* 错误信息 */}
+      {status?.status === 'error' && status.errorMessage && (
+        <div className="text-xs text-red-500 bg-red-500/10 rounded px-2 py-1">
+          {status.errorMessage}
+        </div>
+      )}
+    </div>
+  )
+}
+
+// ===== Bot 表单组件 =====
+
+interface BotFormProps {
+  bot?: FeishuBotConfig
+  workspaces: Array<{ id: string; name: string }>
+  onSave: (input: FeishuBotConfigInput, existingId?: string) => Promise<void>
+  onCancel: () => void
+}
+
+function BotForm({ bot, workspaces, onSave, onCancel }: BotFormProps): React.ReactElement {
+  const [name, setName] = React.useState(bot?.name ?? '')
+  const [appId, setAppId] = React.useState(bot?.appId ?? '')
+  const [appSecret, setAppSecret] = React.useState('')
+  const [workspaceId, setWorkspaceId] = React.useState(bot?.workspaceId ?? '')
+  const [enabled, setEnabled] = React.useState(bot?.enabled ?? true)
+  const [saving, setSaving] = React.useState(false)
+
+  const handleSave = React.useCallback(async () => {
+    if (!name.trim() || !appId.trim()) {
+      toast.error('请填写 Bot 名称和 App ID')
+      return
+    }
+
+    // 如果填写了 App Secret，先测试连接
+    if (appSecret.trim()) {
+      setSaving(true)
+      try {
+        const testResult = await window.electronAPI.testFeishuConnection(appId.trim(), appSecret.trim())
+        if (!testResult.success) {
+          toast.error(testResult.message || '连接测试失败')
+          return
+        }
+      } catch (err) {
+        toast.error(`连接测试失败: ${err instanceof Error ? err.message : String(err)}`)
+        return
+      } finally {
+        setSaving(false)
+      }
+    }
+
+    setSaving(true)
+    try {
+      await onSave(
+        {
+          name: name.trim(),
+          appId: appId.trim(),
+          appSecret,
+          workspaceId,
+          enabled,
+        },
+        bot?.id
+      )
+      toast.success(bot ? 'Bot 已更新' : 'Bot 已添加')
+      onCancel()
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : '保存失败')
+    } finally {
+      setSaving(false)
+    }
+  }, [name, appId, appSecret, workspaceId, enabled, bot, onSave, onCancel])
+
+  return (
+    <div className="space-y-4">
+      <SettingsInput
+        label="Bot 名称"
+        value={name}
+        onChange={setName}
+        placeholder="例如：开发助手 Bot"
+      />
+
+      <SettingsInput
+        label="App ID"
+        value={appId}
+        onChange={setAppId}
+        placeholder="cli_xxxxxxxxxx"
+      />
+
+      <SettingsSecretInput
+        label="App Secret"
+        value={appSecret}
+        onChange={setAppSecret}
+        placeholder={bot ? '输入新值以更新，或留空保持不变' : '输入 App Secret'}
+      />
+
+      <div className="space-y-1.5">
+        <label className="text-sm font-medium text-foreground">绑定工作区</label>
+        <Select value={workspaceId} onValueChange={setWorkspaceId}>
+          <SelectTrigger>
+            <SelectValue placeholder="选择工作区" />
+          </SelectTrigger>
+          <SelectContent>
+            {workspaces.map((w) => (
+              <SelectItem key={w.id} value={w.id}>
+                {w.name}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+
+      <div className="flex items-center gap-2">
+        <input
+          type="checkbox"
+          id="bot-enabled"
+          checked={enabled}
+          onChange={(e) => setEnabled(e.target.checked)}
+          className="rounded border-input"
+        />
+        <label htmlFor="bot-enabled" className="text-sm text-foreground">
+          启用此 Bot
+        </label>
+      </div>
+
+      <div className="flex items-center gap-3 pt-2">
+        <Button size="sm" onClick={handleSave} disabled={saving || !name.trim() || !appId.trim()}>
+          {saving && <Loader2 size={14} className="animate-spin" />}
+          <span>{saving ? '测试并保存中...' : '保存'}</span>
+        </Button>
+        <Button size="sm" variant="ghost" onClick={onCancel}>
+          取消
+        </Button>
+      </div>
+
+      {/* 提示 */}
+      <p className="text-xs text-muted-foreground">
+        保存时将自动测试连接。如果不填写 App Secret，将跳过连接测试。
+      </p>
+    </div>
+  )
+}
+
+// ===== 主组件 =====
+
+export function FeishuBotsSettings(): React.ReactElement {
+  const setBots = useSetAtom(feishuBotsAtom)
+  const setBotStatuses = useSetAtom(feishuBotStatusesAtom)
+  const setMigrated = useSetAtom(feishuMigratedAtom)
+  const bots = useAtomValue(feishuBotsAtom)
+  const botStatuses = useAtomValue(feishuBotStatusesAtom)
+  const migrated = useAtomValue(feishuMigratedAtom)
+  const workspaces = useAtomValue(agentWorkspacesAtom)
+
+  const [loading, setLoading] = React.useState(true)
+  const [showForm, setShowForm] = React.useState(false)
+  const [editingBot, setEditingBot] = React.useState<FeishuBotConfig | undefined>()
+  const [personaBot, setPersonaBot] = React.useState<FeishuBotConfig | null>(null)
+  const [initialized, setInitialized] = React.useState(false)
+
+  // 加载 Bot 列表
+  React.useEffect(() => {
+    if (initialized) return
+    setInitialized(true)
+
+    Promise.all([
+      window.electronAPI.listFeishuBots(),
+    ]).then(([result]) => {
+      setBots(result.bots)
+      setMigrated(result.migrated)
+      if (result.migrated) {
+        toast.success('已从旧配置迁移到多 Bot 模式')
+      }
+      setLoading(false)
+    }).catch((err) => {
+      console.error('加载 Bot 列表失败:', err)
+      setLoading(false)
+    })
+  }, [initialized, setBots, setMigrated])
+
+  // 订阅 Bot 状态变化
+  React.useEffect(() => {
+    const unsubscribe = window.electronAPI.onFeishuBotStatusChanged((status) => {
+      setBotStatuses((prev) => {
+        const next = new Map(prev)
+        next.set(status.botId, status)
+        return next
+      })
+    })
+    return unsubscribe
+  }, [setBotStatuses])
+
+  // 获取初始 Bot 状态（仅获取当前未缓存的状态）
+  const botStatusesRef = React.useRef(botStatuses)
+  botStatusesRef.current = botStatuses
+  
+  React.useEffect(() => {
+    if (loading || bots.length === 0) return
+
+    bots.forEach(async (bot) => {
+      // 如果已经有状态缓存，跳过
+      if (botStatusesRef.current.has(bot.id)) return
+      
+      try {
+        const status = await window.electronAPI.getFeishuBotStatus(bot.id)
+        if (status) {
+          setBotStatuses((prev) => {
+            // 再次检查，防止在异步获取期间已经被设置
+            if (prev.has(bot.id)) return prev
+            const next = new Map(prev)
+            next.set(bot.id, status)
+            return next
+          })
+        }
+      } catch (err) {
+        console.error(`获取 Bot ${bot.name} 状态失败:`, err)
+      }
+    })
+  }, [loading, bots, setBotStatuses])
+
+  // 应用启动时自动启动所有已启用的 Bot（只执行一次）
+  const autoStartRef = React.useRef(false)
+  React.useEffect(() => {
+    if (loading || bots.length === 0 || autoStartRef.current) return
+    autoStartRef.current = true
+
+    const enabledBots = bots.filter((b) => b.enabled)
+    enabledBots.forEach(async (bot) => {
+      // 如果已经有状态（说明可能已经在运行），跳过
+      if (botStatuses.has(bot.id)) return
+      
+      try {
+        // 设置启动中状态
+        setBotStatuses((prev) => {
+          const next = new Map(prev)
+          next.set(bot.id, {
+            botId: bot.id,
+            status: 'connecting',
+            activeBindings: 0,
+          })
+          return next
+        })
+        
+        await window.electronAPI.startFeishuBot(bot.id)
+        
+        // 启动后获取实际状态
+        const status = await window.electronAPI.getFeishuBotStatus(bot.id)
+        if (status) {
+          setBotStatuses((prev) => {
+            const next = new Map(prev)
+            next.set(bot.id, status)
+            return next
+          })
+        }
+      } catch (err) {
+        console.error(`自动启动 Bot ${bot.name} 失败:`, err)
+        setBotStatuses((prev) => {
+          const next = new Map(prev)
+          next.set(bot.id, {
+            botId: bot.id,
+            status: 'error',
+            errorMessage: err instanceof Error ? err.message : String(err),
+            activeBindings: 0,
+          })
+          return next
+        })
+      }
+    })
+  }, [loading, bots, botStatuses, setBotStatuses])
+
+  // 保存 Bot
+  const handleSave = React.useCallback(async (input: FeishuBotConfigInput, existingId?: string) => {
+    // 获取之前的 Bot 状态（用于判断是否需要停止/重启）
+    const prevBot = existingId ? bots.find((b) => b.id === existingId) : undefined
+    const wasEnabled = prevBot?.enabled ?? false
+    const wasRunning = existingId ? botStatuses.get(existingId)?.status === 'connected' : false
+
+    const savedBot = await window.electronAPI.saveFeishuBot(input, existingId)
+    setBots((prev) => {
+      if (existingId) {
+        return prev.map((b) => (b.id === existingId ? savedBot : b))
+      }
+      return [...prev, savedBot]
+    })
+
+    // 情况 1: 之前启用 -> 现在禁用：停止 Bot
+    if (wasEnabled && !savedBot.enabled && wasRunning) {
+      try {
+        await window.electronAPI.stopFeishuBot(savedBot.id)
+        setBotStatuses((prev) => {
+          const next = new Map(prev)
+          next.delete(savedBot.id)
+          return next
+        })
+        toast.success(`Bot "${savedBot.name}" 已停止`)
+      } catch (err) {
+        console.error(`停止 Bot "${savedBot.name}" 失败:`, err)
+      }
+      return
+    }
+
+    // 情况 2: Bot 是启用的，需要启动或重启
+    if (savedBot.enabled) {
+      // 如果之前在运行且配置变了（特别是密钥），先停止再启动
+      const appIdChanged = prevBot?.appId !== savedBot.appId
+      const secretChanged = input.appSecret.trim() !== ''
+      const configChanged = wasEnabled && (appIdChanged || secretChanged)
+
+      if (wasRunning && configChanged) {
+        try {
+          await window.electronAPI.stopFeishuBot(savedBot.id)
+          // 等待一下确保停止完成
+          await new Promise((resolve) => setTimeout(resolve, 500))
+        } catch (err) {
+          console.error(`重启 Bot "${savedBot.name}" 时停止失败:`, err)
+        }
+      }
+
+      // 如果之前没在运行，或者是编辑且配置变了，启动 Bot
+      const shouldStart = !wasRunning || configChanged || !wasEnabled
+      if (shouldStart) {
+        try {
+          // 设置启动中状态
+          setBotStatuses((prev) => {
+            const next = new Map(prev)
+            next.set(savedBot.id, {
+              botId: savedBot.id,
+              status: 'connecting',
+              activeBindings: 0,
+            })
+            return next
+          })
+
+          await window.electronAPI.startFeishuBot(savedBot.id)
+          
+          // 启动成功后获取实际状态
+          const status = await window.electronAPI.getFeishuBotStatus(savedBot.id)
+          if (status) {
+            setBotStatuses((prev) => {
+              const next = new Map(prev)
+              next.set(savedBot.id, status)
+              return next
+            })
+            
+            if (status.status === 'connected') {
+              toast.success(`Bot "${savedBot.name}" 已连接`)
+            } else if (status.status === 'error') {
+              toast.error(`Bot "${savedBot.name}" 连接失败: ${status.errorMessage}`)
+            }
+          }
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err)
+          setBotStatuses((prev) => {
+            const next = new Map(prev)
+            next.set(savedBot.id, {
+              botId: savedBot.id,
+              status: 'error',
+              errorMessage: errorMsg,
+              activeBindings: 0,
+            })
+            return next
+          })
+          toast.error(`启动 Bot "${savedBot.name}" 失败: ${errorMsg}`)
+          throw err
+        }
+      }
+    }
+  }, [bots, botStatuses, setBots, setBotStatuses])
+
+  // 删除 Bot
+  const handleDelete = React.useCallback(async (botId: string) => {
+    await window.electronAPI.deleteFeishuBot(botId)
+    setBots((prev) => prev.filter((b) => b.id !== botId))
+    setBotStatuses((prev) => {
+      const next = new Map(prev)
+      next.delete(botId)
+      return next
+    })
+    toast.success('Bot 已删除')
+  }, [setBots, setBotStatuses])
+
+  // 启动/停止 Bot
+  const handleToggle = React.useCallback(async (bot: FeishuBotConfig) => {
+    const status = botStatuses.get(bot.id)
+    if (status?.status === 'connected') {
+      await window.electronAPI.stopFeishuBot(bot.id)
+    } else {
+      await window.electronAPI.startFeishuBot(bot.id)
+    }
+  }, [botStatuses])
+
+  // 编辑 Bot
+  const handleEdit = React.useCallback((bot: FeishuBotConfig) => {
+    setEditingBot(bot)
+    setShowForm(true)
+    setPersonaBot(null)
+  }, [])
+
+  // 编辑 Persona
+  const handleEditPersona = React.useCallback((bot: FeishuBotConfig) => {
+    if (!bot.workspaceId) {
+      toast.error('该 Bot 未绑定工作区，请先编辑 Bot 绑定工作区')
+      return
+    }
+    setPersonaBot(bot)
+    setShowForm(false)
+    setEditingBot(undefined)
+  }, [])
+
+  // 添加新 Bot
+  const handleAdd = React.useCallback(() => {
+    setEditingBot(undefined)
+    setShowForm(true)
+    setPersonaBot(null)
+  }, [])
+
+  // 取消编辑
+  const handleCancel = React.useCallback(() => {
+    setShowForm(false)
+    setEditingBot(undefined)
+    setPersonaBot(null)
+  }, [])
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center py-20">
+        <Loader2 size={24} className="animate-spin text-muted-foreground" />
+      </div>
+    )
+  }
+
+  // 获取 persona bot 对应的工作区 slug
+  const personaWorkspace = personaBot?.workspaceId
+    ? workspaces.find((w) => w.id === personaBot.workspaceId)
+    : null
+
+  return (
+    <div className="space-y-6">
+      {/* 迁移提示 */}
+      {migrated && (
+        <div className="p-3 rounded-lg bg-green-500/10 text-green-700 dark:text-green-400 text-sm">
+          已自动迁移旧版飞书配置到多 Bot 模式。
+        </div>
+      )}
+
+      {/* Bot 列表 */}
+      <SettingsSection
+        title="飞书 Bots"
+        description="管理多个飞书机器人，每个 Bot 绑定到不同的工作区"
+        action={
+          <Button size="sm" onClick={handleAdd}>
+            <Plus size={14} />
+            <span className="ml-1.5">添加 Bot</span>
+          </Button>
+        }
+      >
+        {bots.length === 0 ? (
+          <SettingsCard divided={false}>
+            <div className="px-4 py-8 text-center text-sm text-muted-foreground">
+              暂无配置的 Bot。点击上方「添加 Bot」开始配置。
+            </div>
+          </SettingsCard>
+        ) : (
+          <div className="space-y-3">
+            {bots.map((bot) => (
+              <SettingsCard key={bot.id}>
+                <BotCard
+                  bot={bot}
+                  status={botStatuses.get(bot.id)}
+                  onEdit={handleEdit}
+                  onDelete={handleDelete}
+                  onToggle={handleToggle}
+                  onEditPersona={handleEditPersona}
+                />
+              </SettingsCard>
+            ))}
+          </div>
+        )}
+      </SettingsSection>
+
+      {/* 添加/编辑表单 */}
+      {showForm && (
+        <SettingsSection
+          title={editingBot ? '编辑 Bot' : '添加 Bot'}
+          description="配置飞书机器人的连接信息"
+        >
+          <SettingsCard>
+            <div className="px-4 py-4">
+              <BotForm
+                bot={editingBot}
+                workspaces={workspaces.map((w) => ({ id: w.id, name: w.name }))}
+                onSave={handleSave}
+                onCancel={handleCancel}
+              />
+            </div>
+          </SettingsCard>
+        </SettingsSection>
+      )}
+
+      {/* Persona 编辑器 */}
+      {personaBot && personaWorkspace && (
+        <SettingsSection
+          title={`${personaBot.name} - 人格配置`}
+          description={`工作区: ${personaWorkspace.name}`}
+        >
+          <SettingsCard>
+            <div className="px-4 py-4">
+              <PersonaEditor
+                workspaceSlug={personaWorkspace.slug}
+                onCancel={handleCancel}
+              />
+            </div>
+          </SettingsCard>
+        </SettingsSection>
+      )}
+    </div>
+  )
+}
diff --git a/apps/electron/src/renderer/components/settings/FeishuSettings.tsx b/apps/electron/src/renderer/components/settings/FeishuSettings.tsx
deleted file mode 100644
index c872668e..00000000
--- a/apps/electron/src/renderer/components/settings/FeishuSettings.tsx
+++ /dev/null
@@ -1,801 +0,0 @@
-/**
- * FeishuSettings - 飞书集成设置页
- *
- * 双 Tab 布局：
- * - Bot 配置：飞书应用凭证、连接状态、默认配置、创建引导、命令说明
- * - 绑定管理：查看/管理所有活跃的飞书聊天绑定（群聊/单聊的工作区/会话分配）
- */
-
-import * as React from 'react'
-import { useAtomValue, useSetAtom } from 'jotai'
-import { toast } from 'sonner'
-import { Loader2, CheckCircle2, XCircle, ExternalLink, Users, User, Trash2, RefreshCw, Copy, Check } from 'lucide-react'
-import { Button } from '@/components/ui/button'
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@/components/ui/select'
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-  AlertDialogTrigger,
-} from '@/components/ui/alert-dialog'
-import { SettingsSection } from './primitives/SettingsSection'
-import { SettingsCard } from './primitives/SettingsCard'
-import { SettingsInput } from './primitives/SettingsInput'
-import { SettingsSecretInput } from './primitives/SettingsSecretInput'
-import { SettingsSelect } from './primitives/SettingsSelect'
-import { SettingsSegmentedControl } from './primitives/SettingsSegmentedControl'
-import { SettingsRow } from './primitives/SettingsRow'
-import { feishuBridgeStateAtom, feishuBindingsAtom } from '@/atoms/feishu-atoms'
-import { agentWorkspacesAtom, agentSessionsAtom } from '@/atoms/agent-atoms'
-import { cn } from '@/lib/utils'
-import type { FeishuTestResult, FeishuChatBinding } from '@proma/shared'
-
-// ===== 常量 =====
-
-type FeishuTab = 'config' | 'bindings'
-
-const TAB_OPTIONS: Array<{ value: FeishuTab; label: string }> = [
-  { value: 'config', label: 'Bot 配置' },
-  { value: 'bindings', label: '绑定管理' },
-]
-
-/** 连接状态颜色映射 */
-const STATUS_CONFIG = {
-  disconnected: { color: 'bg-gray-400', label: '未连接' },
-  connecting: { color: 'bg-yellow-400 animate-pulse', label: '连接中...' },
-  connected: { color: 'bg-green-500', label: '已连接' },
-  error: { color: 'bg-red-500', label: '连接错误' },
-} as const
-
-/** 通知模式选项 */
-const NOTIFY_MODE_OPTIONS = [
-  { value: 'auto', label: '智能' },
-  { value: 'always', label: '始终' },
-  { value: 'off', label: '关闭' },
-]
-
-/** 飞书批量权限配置 JSON（用于一键复制粘贴到飞书开放平台） */
-const FEISHU_SCOPES_JSON = JSON.stringify({
-  scopes: {
-    tenant: [
-      'contact:contact.base:readonly',
-      'im:chat:readonly',
-      'im:chat.members:read',
-      'im:message',
-      'im:message.group_at_msg:readonly',
-      'im:message.group_msg',
-      'im:message.p2p_msg:readonly',
-      'im:message:send_as_bot',
-      'im:resource',
-    ],
-    user: [],
-  },
-}, null, 2)
-
-// ===== 工具组件 =====
-
-/** 安全地用系统浏览器打开链接 */
-function openLink(url: string): void {
-  window.electronAPI.openExternal(url)
-}
-
-/** 可点击的外部链接组件 */
-function Link({ href, children }: { href: string; children: React.ReactNode }): React.ReactElement {
-  return (
-    <button
-      type="button"
-      className="inline-flex items-center gap-1 text-primary hover:underline cursor-pointer"
-      onClick={() => openLink(href)}
-    >
-      {children}
-      <ExternalLink className="size-3 flex-shrink-0" />
-    </button>
-  )
-}
-
-// ===== 权限配置步骤组件 =====
-
-/** 权限列表展示 + 一键复制批量权限 JSON */
-function PermissionsStep(): React.ReactElement {
-  const [copied, setCopied] = React.useState(false)
-
-  const handleCopy = React.useCallback(() => {
-    navigator.clipboard.writeText(FEISHU_SCOPES_JSON).then(() => {
-      setCopied(true)
-      toast.success('权限配置已复制到剪贴板')
-      setTimeout(() => setCopied(false), 2000)
-    }).catch(() => {
-      toast.error('复制失败')
-    })
-  }, [])
-
-  return (
-    <div className="space-y-1.5">
-      <div className="flex items-center gap-2">
-        <span className="flex-shrink-0 w-5 h-5 rounded-full bg-primary/10 text-primary text-xs font-semibold flex items-center justify-center">4</span>
-        <span className="font-medium text-foreground">配置权限</span>
-      </div>
-      <div className="pl-7 space-y-2 text-muted-foreground">
-        <p>
-          进入「权限管理」页面，点击下方按钮复制权限配置 JSON，
-          然后在飞书开放平台通过「批量开通」粘贴即可一键添加所有权限：
-        </p>
-        <Button
-          size="sm"
-          variant="outline"
-          onClick={handleCopy}
-          className="gap-1.5"
-        >
-          {copied ? <Check size={14} /> : <Copy size={14} />}
-          <span>{copied ? '已复制' : '复制批量权限配置'}</span>
-        </Button>
-        <div className="bg-muted/50 rounded-md p-3 font-mono text-xs space-y-0.5">
-          <div><span className="text-foreground/70">im:message</span> — 获取与发送单聊、群组消息</div>
-          <div><span className="text-foreground/70">im:message:send_as_bot</span> — 以机器人身份发送消息</div>
-          <div><span className="text-foreground/70">im:message.p2p_msg:readonly</span> — 接收用户发给机器人的单聊消息</div>
-          <div><span className="text-foreground/70">im:message.group_at_msg:readonly</span> — 接收群聊中 @机器人 的消息</div>
-          <div><span className="text-foreground/70">im:message.group_msg</span> — 读取群聊历史消息（群聊上下文）</div>
-          <div><span className="text-foreground/70">im:chat:readonly</span> — 获取群组信息</div>
-          <div><span className="text-foreground/70">im:chat.members:read</span> — 获取群成员列表（支持 @某人）</div>
-          <div><span className="text-foreground/70">im:resource</span> — 获取消息中的资源文件（图片、文档等）</div>
-          <div><span className="text-foreground/70">contact:contact.base:readonly</span> — 获取用户基本信息（群聊发送者名称）</div>
-        </div>
-      </div>
-    </div>
-  )
-}
-
-// ===== 绑定卡片组件 =====
-
-interface FeishuBindingCardProps {
-  binding: FeishuChatBinding
-  onUpdate: (chatId: string, updates: { workspaceId?: string; sessionId?: string }) => void
-  onRemove: (chatId: string) => void
-}
-
-function FeishuBindingCard({ binding, onUpdate, onRemove }: FeishuBindingCardProps): React.ReactElement {
-  const workspaces = useAtomValue(agentWorkspacesAtom)
-  const sessions = useAtomValue(agentSessionsAtom)
-
-  const isGroup = binding.chatType === 'group'
-  const displayName = isGroup ? (binding.groupName ?? '未知群组') : '单聊'
-
-  // 当前绑定工作区下的会话列表
-  const workspaceSessions = React.useMemo(
-    () => sessions.filter((s) => s.workspaceId === binding.workspaceId),
-    [sessions, binding.workspaceId]
-  )
-
-  const currentWorkspace = workspaces.find((w) => w.id === binding.workspaceId)
-  const currentSession = sessions.find((s) => s.id === binding.sessionId)
-
-  return (
-    <div className="px-4 py-3 space-y-3">
-      {/* 头部：类型图标 + 名称 + 删除 */}
-      <div className="flex items-center justify-between">
-        <div className="flex items-center gap-2.5">
-          <div className={cn(
-            'flex items-center justify-center w-8 h-8 rounded-lg',
-            isGroup ? 'bg-blue-500/10 text-blue-600 dark:text-blue-400' : 'bg-green-500/10 text-green-600 dark:text-green-400'
-          )}>
-            {isGroup ? <Users size={16} /> : <User size={16} />}
-          </div>
-          <div>
-            <div className="text-sm font-medium text-foreground">{displayName}</div>
-            <div className="text-xs text-muted-foreground">
-              {isGroup ? '群聊' : '私聊'} · {new Date(binding.createdAt).toLocaleDateString('zh-CN')}
-            </div>
-          </div>
-        </div>
-
-        <AlertDialog>
-          <AlertDialogTrigger asChild>
-            <Button size="icon" variant="ghost" className="h-7 w-7 text-muted-foreground hover:text-destructive">
-              <Trash2 size={14} />
-            </Button>
-          </AlertDialogTrigger>
-          <AlertDialogContent>
-            <AlertDialogHeader>
-              <AlertDialogTitle>解除绑定</AlertDialogTitle>
-              <AlertDialogDescription>
-                确定要解除「{displayName}」的飞书聊天绑定吗？解除后下次在飞书发消息会自动创建新绑定。
-              </AlertDialogDescription>
-            </AlertDialogHeader>
-            <AlertDialogFooter>
-              <AlertDialogCancel>取消</AlertDialogCancel>
-              <AlertDialogAction onClick={() => onRemove(binding.chatId)}>
-                确认解除
-              </AlertDialogAction>
-            </AlertDialogFooter>
-          </AlertDialogContent>
-        </AlertDialog>
-      </div>
-
-      {/* 工作区选择 */}
-      <div className="grid grid-cols-[80px_1fr] gap-2 items-center text-sm">
-        <span className="text-muted-foreground">工作区</span>
-        <Select
-          value={binding.workspaceId}
-          onValueChange={(value) => onUpdate(binding.chatId, { workspaceId: value })}
-        >
-          <SelectTrigger className="h-8 text-xs">
-            <SelectValue placeholder="选择工作区">
-              {currentWorkspace?.name ?? '未知工作区'}
-            </SelectValue>
-          </SelectTrigger>
-          <SelectContent>
-            {workspaces.map((w) => (
-              <SelectItem key={w.id} value={w.id}>{w.name}</SelectItem>
-            ))}
-          </SelectContent>
-        </Select>
-
-        {/* 会话显示 */}
-        <span className="text-muted-foreground">会话</span>
-        <Select
-          value={binding.sessionId}
-          onValueChange={(value) => onUpdate(binding.chatId, { sessionId: value })}
-        >
-          <SelectTrigger className="h-8 text-xs">
-            <SelectValue placeholder="选择会话">
-              {currentSession?.title ?? binding.sessionId.slice(0, 8)}
-            </SelectValue>
-          </SelectTrigger>
-          <SelectContent>
-            {workspaceSessions.map((s) => (
-              <SelectItem key={s.id} value={s.id}>
-                {s.title}
-              </SelectItem>
-            ))}
-          </SelectContent>
-        </Select>
-      </div>
-    </div>
-  )
-}
-
-// ===== 绑定管理 Tab =====
-
-function FeishuBindingsTab(): React.ReactElement {
-  const bindings = useAtomValue(feishuBindingsAtom)
-  const setBindings = useSetAtom(feishuBindingsAtom)
-  const bridgeState = useAtomValue(feishuBridgeStateAtom)
-  const [refreshing, setRefreshing] = React.useState(false)
-
-  // 刷新绑定列表
-  const refreshBindings = React.useCallback(async () => {
-    setRefreshing(true)
-    try {
-      const list = await window.electronAPI.listFeishuBindings()
-      setBindings(list)
-    } catch {
-      toast.error('获取绑定列表失败')
-    } finally {
-      setRefreshing(false)
-    }
-  }, [setBindings])
-
-  // 进入 Tab 时自动刷新
-  React.useEffect(() => {
-    refreshBindings()
-  }, [refreshBindings])
-
-  // Bridge 状态变化时也刷新
-  React.useEffect(() => {
-    if (bridgeState.status === 'connected') {
-      refreshBindings()
-    }
-  }, [bridgeState.status, refreshBindings])
-
-  // 更新绑定
-  const handleUpdate = React.useCallback(async (chatId: string, updates: { workspaceId?: string; sessionId?: string }) => {
-    try {
-      const result = await window.electronAPI.updateFeishuBinding({ chatId, ...updates })
-      if (result) {
-        setBindings((prev) => prev.map((b) => b.chatId === chatId ? result : b))
-        toast.success('绑定已更新')
-      }
-    } catch {
-      toast.error('更新绑定失败')
-    }
-  }, [setBindings])
-
-  // 移除绑定
-  const handleRemove = React.useCallback(async (chatId: string) => {
-    try {
-      const ok = await window.electronAPI.removeFeishuBinding(chatId)
-      if (ok) {
-        setBindings((prev) => prev.filter((b) => b.chatId !== chatId))
-        toast.success('绑定已解除')
-      }
-    } catch {
-      toast.error('解除绑定失败')
-    }
-  }, [setBindings])
-
-  // 按类型分组：群聊 + 单聊
-  const groupBindings = bindings.filter((b) => b.chatType === 'group')
-  const p2pBindings = bindings.filter((b) => b.chatType !== 'group')
-
-  return (
-    <div className="space-y-8">
-      <SettingsSection
-        title="绑定管理"
-        description="查看和管理飞书聊天与 Proma 工作区/会话的绑定关系"
-        action={
-          <Button
-            size="sm"
-            variant="outline"
-            onClick={refreshBindings}
-            disabled={refreshing}
-          >
-            <RefreshCw size={14} className={cn(refreshing && 'animate-spin')} />
-            <span className="ml-1.5">刷新</span>
-          </Button>
-        }
-      >
-        {bindings.length === 0 ? (
-          <SettingsCard divided={false}>
-            <div className="px-4 py-8 text-center text-sm text-muted-foreground">
-              暂无活跃绑定。启动 Bridge 后在飞书中发消息即可自动创建绑定。
-            </div>
-          </SettingsCard>
-        ) : (
-          <div className="space-y-4">
-            {/* 群聊绑定 */}
-            {groupBindings.length > 0 && (
-              <div className="space-y-2">
-                <div className="text-xs font-medium text-muted-foreground uppercase tracking-wider">
-                  群聊 ({groupBindings.length})
-                </div>
-                <SettingsCard>
-                  {groupBindings.map((binding) => (
-                    <FeishuBindingCard
-                      key={binding.chatId}
-                      binding={binding}
-                      onUpdate={handleUpdate}
-                      onRemove={handleRemove}
-                    />
-                  ))}
-                </SettingsCard>
-              </div>
-            )}
-
-            {/* 单聊绑定 */}
-            {p2pBindings.length > 0 && (
-              <div className="space-y-2">
-                <div className="text-xs font-medium text-muted-foreground uppercase tracking-wider">
-                  单聊 ({p2pBindings.length})
-                </div>
-                <SettingsCard>
-                  {p2pBindings.map((binding) => (
-                    <FeishuBindingCard
-                      key={binding.chatId}
-                      binding={binding}
-                      onUpdate={handleUpdate}
-                      onRemove={handleRemove}
-                    />
-                  ))}
-                </SettingsCard>
-              </div>
-            )}
-          </div>
-        )}
-      </SettingsSection>
-    </div>
-  )
-}
-
-// ===== Bot 配置 Tab =====
-
-function FeishuConfigTab(): React.ReactElement {
-  const bridgeState = useAtomValue(feishuBridgeStateAtom)
-  const workspaces = useAtomValue(agentWorkspacesAtom)
-
-  // 表单状态
-  const [appId, setAppId] = React.useState('')
-  const [appSecret, setAppSecret] = React.useState('')
-  const [defaultWorkspaceId, setDefaultWorkspaceId] = React.useState('')
-  const [defaultNotifyMode, setDefaultNotifyMode] = React.useState('auto')
-
-  // UI 状态
-  const [loading, setLoading] = React.useState(true)
-  const [testing, setTesting] = React.useState(false)
-  const [testResult, setTestResult] = React.useState<FeishuTestResult | null>(null)
-
-  // 加载配置
-  React.useEffect(() => {
-    Promise.all([
-      window.electronAPI.getFeishuConfig(),
-      window.electronAPI.getDecryptedFeishuSecret().catch(() => ''),
-    ]).then(([config, secret]) => {
-      setAppId(config.appId ?? '')
-      if (secret) setAppSecret(secret)
-      setDefaultWorkspaceId(config.defaultWorkspaceId ?? '')
-      setLoading(false)
-    }).catch(() => setLoading(false))
-  }, [])
-
-  // 工作区选项
-  const workspaceOptions = React.useMemo(
-    () => workspaces.map((w) => ({ value: w.id, label: w.name })),
-    [workspaces]
-  )
-
-  // 保存配置
-  const handleSave = React.useCallback(async () => {
-    if (!appId.trim()) return
-
-    try {
-      await window.electronAPI.saveFeishuConfig({
-        enabled: true,
-        appId: appId.trim(),
-        appSecret: appSecret || '',
-        defaultWorkspaceId: defaultWorkspaceId || undefined,
-      })
-      toast.success('飞书配置已保存')
-    } catch {
-      toast.error('保存飞书配置失败')
-    }
-  }, [appId, appSecret, defaultWorkspaceId])
-
-  // 保存默认配置
-  const handleSaveDefaults = React.useCallback(async () => {
-    try {
-      await window.electronAPI.saveFeishuConfig({
-        enabled: true,
-        appId: appId.trim(),
-        appSecret: '',
-        defaultWorkspaceId: defaultWorkspaceId || undefined,
-      })
-      toast.success('默认配置已保存')
-    } catch {
-      toast.error('保存默认配置失败')
-    }
-  }, [appId, defaultWorkspaceId])
-
-  // 测试连接
-  const handleTestConnection = React.useCallback(async () => {
-    if (!appId.trim() || !appSecret.trim()) {
-      setTestResult({ success: false, message: '请填写 App ID 和 App Secret' })
-      return
-    }
-
-    setTesting(true)
-    setTestResult(null)
-    try {
-      const result = await window.electronAPI.testFeishuConnection(appId.trim(), appSecret.trim())
-      setTestResult(result)
-    } catch (err) {
-      setTestResult({ success: false, message: `测试失败: ${err instanceof Error ? err.message : String(err)}` })
-    } finally {
-      setTesting(false)
-    }
-  }, [appId, appSecret])
-
-  // 启动/停止 Bridge
-  const handleToggleBridge = React.useCallback(async () => {
-    if (bridgeState.status === 'connected' || bridgeState.status === 'connecting') {
-      await window.electronAPI.stopFeishuBridge()
-      toast.success('飞书 Bridge 已停止')
-    } else {
-      try {
-        await window.electronAPI.startFeishuBridge()
-        toast.success('飞书 Bridge 启动中...')
-      } catch (err) {
-        toast.error(err instanceof Error ? err.message : '启动飞书 Bridge 失败')
-      }
-    }
-  }, [bridgeState.status])
-
-  const statusConfig = STATUS_CONFIG[bridgeState.status]
-  const isConnected = bridgeState.status === 'connected' || bridgeState.status === 'connecting'
-
-  if (loading) {
-    return (
-      <div className="flex items-center justify-center py-20">
-        <Loader2 size={24} className="animate-spin text-muted-foreground" />
-      </div>
-    )
-  }
-
-  return (
-    <div className="space-y-8">
-      {/* 连接状态 */}
-      <SettingsSection
-        title="飞书集成"
-        description="连接飞书机器人，在飞书中控制 Proma Agent"
-      >
-        <SettingsCard>
-          <SettingsRow
-            label="Bridge 状态"
-            description={bridgeState.errorMessage ?? undefined}
-          >
-            <div className="flex items-center gap-3">
-              <div className="flex items-center gap-2">
-                <span className={cn('w-2 h-2 rounded-full', statusConfig.color)} />
-                <span className="text-sm text-muted-foreground">{statusConfig.label}</span>
-              </div>
-              <Button
-                size="sm"
-                variant={isConnected ? 'destructive' : 'default'}
-                onClick={handleToggleBridge}
-                disabled={!appId}
-              >
-                {isConnected ? '停止' : '启动'}
-              </Button>
-            </div>
-          </SettingsRow>
-          {bridgeState.activeBindings > 0 && (
-            <SettingsRow label="活跃绑定" description="当前连接的飞书聊天数">
-              <span className="text-sm font-medium">{bridgeState.activeBindings}</span>
-            </SettingsRow>
-          )}
-        </SettingsCard>
-      </SettingsSection>
-
-      {/* Bot 配置 */}
-      <SettingsSection
-        title="Bot 配置"
-        description="从飞书开发者平台获取应用凭证"
-      >
-        <SettingsCard>
-          <SettingsInput
-            label="App ID"
-            value={appId}
-            onChange={setAppId}
-            placeholder="cli_xxxxxxxxxx"
-          />
-          <SettingsSecretInput
-            label="App Secret"
-            value={appSecret}
-            onChange={setAppSecret}
-            placeholder="输入 App Secret"
-          />
-        </SettingsCard>
-
-        <div className="flex items-center gap-3 mt-3">
-          <Button
-            size="sm"
-            variant="outline"
-            onClick={handleTestConnection}
-            disabled={testing || !appId.trim() || !appSecret.trim()}
-          >
-            {testing && <Loader2 size={14} className="animate-spin" />}
-            <span>{testing ? '测试中...' : '测试连接'}</span>
-          </Button>
-          <Button
-            size="sm"
-            onClick={handleSave}
-            disabled={!appId.trim()}
-          >
-            保存配置
-          </Button>
-        </div>
-
-        {testResult && (
-          <div className={cn(
-            'mt-3 p-3 rounded-lg flex items-start gap-2 text-sm',
-            testResult.success ? 'bg-green-500/10 text-green-700 dark:text-green-400' : 'bg-red-500/10 text-red-700 dark:text-red-400'
-          )}>
-            {testResult.success
-              ? <CheckCircle2 size={16} className="flex-shrink-0 mt-0.5" />
-              : <XCircle size={16} className="flex-shrink-0 mt-0.5" />
-            }
-            <span>{testResult.message}{testResult.botName && ` — ${testResult.botName}`}</span>
-          </div>
-        )}
-      </SettingsSection>
-
-      {/* 默认配置 */}
-      <SettingsSection
-        title="默认配置"
-        description="飞书发起新会话时使用的默认设置"
-      >
-        <SettingsCard>
-          <SettingsSegmentedControl
-            label="默认通知模式"
-            description="智能: 离开时才发飞书 | 始终: 总是发 | 关闭: 从不发"
-            value={defaultNotifyMode}
-            onValueChange={setDefaultNotifyMode}
-            options={NOTIFY_MODE_OPTIONS}
-          />
-          {workspaceOptions.length > 0 && (
-            <SettingsSelect
-              label="默认工作区（可在飞书内通过 /workspaces 选择）"
-              value={defaultWorkspaceId}
-              onValueChange={setDefaultWorkspaceId}
-              options={workspaceOptions}
-              placeholder="选择工作区"
-            />
-          )}
-        </SettingsCard>
-
-        <div className="flex items-center mt-3">
-          <Button
-            size="sm"
-            onClick={handleSaveDefaults}
-          >
-            保存默认配置
-          </Button>
-        </div>
-      </SettingsSection>
-
-      {/* 创建飞书 Bot 引导 */}
-      <SettingsSection
-        title="创建飞书 Bot"
-        description="首次使用？按以下步骤在飞书开放平台创建机器人应用"
-      >
-        <SettingsCard divided={false}>
-          <div className="px-4 py-4 space-y-5 text-sm">
-            {/* 步骤 1 */}
-            <div className="space-y-1.5">
-              <div className="flex items-center gap-2">
-                <span className="flex-shrink-0 w-5 h-5 rounded-full bg-primary/10 text-primary text-xs font-semibold flex items-center justify-center">1</span>
-                <span className="font-medium text-foreground">创建自建应用</span>
-              </div>
-              <p className="pl-7 text-muted-foreground">
-                前往{' '}
-                <Link href="https://open.feishu.cn/app">飞书开放平台</Link>
-                {' '}（海外版：
-                <Link href="https://open.larksuite.com/app">Lark 开放平台</Link>
-                ），点击「创建自建应用」，填写应用名称和描述。
-              </p>
-            </div>
-
-            {/* 步骤 2 */}
-            <div className="space-y-1.5">
-              <div className="flex items-center gap-2">
-                <span className="flex-shrink-0 w-5 h-5 rounded-full bg-primary/10 text-primary text-xs font-semibold flex items-center justify-center">2</span>
-                <span className="font-medium text-foreground">获取凭证</span>
-              </div>
-              <p className="pl-7 text-muted-foreground">
-                进入应用详情页，在「凭证与基础信息」中找到{' '}
-                <span className="text-foreground font-medium">App ID</span> 和{' '}
-                <span className="text-foreground font-medium">App Secret</span>，
-                复制到上方的配置表单中。
-              </p>
-            </div>
-
-            {/* 步骤 3 */}
-            <div className="space-y-1.5">
-              <div className="flex items-center gap-2">
-                <span className="flex-shrink-0 w-5 h-5 rounded-full bg-primary/10 text-primary text-xs font-semibold flex items-center justify-center">3</span>
-                <span className="font-medium text-foreground">启用机器人能力</span>
-              </div>
-              <p className="pl-7 text-muted-foreground">
-                进入「添加应用能力」页面，启用「机器人」能力。
-                这样应用才能接收和发送飞书消息。
-              </p>
-            </div>
-
-            {/* 步骤 4 */}
-            <PermissionsStep />
-
-            {/* 步骤 5 */}
-            <div className="space-y-1.5">
-              <div className="flex items-center gap-2">
-                <span className="flex-shrink-0 w-5 h-5 rounded-full bg-primary/10 text-primary text-xs font-semibold flex items-center justify-center">5</span>
-                <span className="font-medium text-foreground">配置事件订阅（关键步骤）</span>
-              </div>
-              <div className="pl-7 space-y-1.5 text-muted-foreground">
-                <p>
-                  进入「事件与回调」页面：
-                </p>
-                <ol className="list-decimal pl-4 space-y-1">
-                  <li>
-                    事件订阅方式选择{' '}
-                    <span className="text-foreground font-medium">「使用长连接接收事件」</span>
-                    （而非 Webhook，无需公网 IP）
-                  </li>
-                  <li>
-                    添加事件{' '}
-                    <code className="bg-muted/50 px-1.5 py-0.5 rounded text-xs text-foreground/80">im.message.receive_v1</code>
-                    {' '}（接收消息）
-                  </li>
-                </ol>
-              </div>
-            </div>
-
-            {/* 步骤 6 */}
-            <div className="space-y-1.5">
-              <div className="flex items-center gap-2">
-                <span className="flex-shrink-0 w-5 h-5 rounded-full bg-primary/10 text-primary text-xs font-semibold flex items-center justify-center">6</span>
-                <span className="font-medium text-foreground">发布应用</span>
-              </div>
-              <p className="pl-7 text-muted-foreground">
-                进入「版本管理与发布」→ 创建版本 → 提交审核。
-                需要企业管理员在{' '}
-                <Link href="https://feishu.cn/admin">管理后台</Link>
-                {' '}审核通过后，机器人才能正常使用。
-              </p>
-            </div>
-
-            {/* 提示 */}
-            <div className="pl-7 p-3 rounded-lg bg-amber-500/10 text-amber-700 dark:text-amber-400 text-xs">
-              版本审核通过并发布后，在飞书中搜索机器人名称添加到聊天，
-              即可通过飞书向 Proma Agent 发送指令。
-            </div>
-          </div>
-        </SettingsCard>
-      </SettingsSection>
-
-      {/* 飞书命令使用说明 */}
-      <SettingsSection
-        title="飞书命令"
-        description="在飞书中向 Bot 发送以下命令"
-      >
-        <SettingsCard divided={false}>
-          <div className="px-4 py-3 space-y-2 text-sm text-muted-foreground">
-            <div className="grid grid-cols-[100px_1fr] gap-y-1.5 gap-x-4">
-              <code className="text-foreground/80 font-mono">/help</code>
-              <span>显示帮助</span>
-              <code className="text-foreground/80 font-mono">/new</code>
-              <span>创建新 Agent 会话</span>
-              {/* <code className="text-foreground/80 font-mono">/chat</code>
-              <span>切换到 Chat 模式</span> */}
-              <code className="text-foreground/80 font-mono">/agent</code>
-              <span>切换到 Agent 模式</span>
-              <code className="text-foreground/80 font-mono">/list</code>
-              <span>列出所有会话</span>
-              <code className="text-foreground/80 font-mono">/stop</code>
-              <span>停止当前 Agent</span>
-              <code className="text-foreground/80 font-mono">/switch</code>
-              <span>切换到已有会话（序号）</span>
-              <code className="text-foreground/80 font-mono">/workspace</code>
-              <span>设置默认工作区</span>
-              <code className="text-foreground/80 font-mono">/now</code>
-              <span>查看当前状态（工作区、会话、MCP、Skills）</span>
-            </div>
-            <p className="pt-2 text-xs">
-              直接发送文本会自动创建新会话或发送到当前绑定的会话。
-            </p>
-          </div>
-        </SettingsCard>
-      </SettingsSection>
-    </div>
-  )
-}
-
-// ===== 主组件 =====
-
-export function FeishuSettings(): React.ReactElement {
-  const [activeTab, setActiveTab] = React.useState<FeishuTab>('config')
-
-  return (
-    <div className="space-y-6">
-      {/* Tab 切换栏 */}
-      <div className="inline-flex rounded-lg bg-muted p-1 gap-0.5">
-        {TAB_OPTIONS.map((tab) => (
-          <button
-            key={tab.value}
-            type="button"
-            onClick={() => setActiveTab(tab.value)}
-            className={cn(
-              'px-4 py-1.5 rounded-md text-sm font-medium transition-colors',
-              activeTab === tab.value
-                ? 'bg-background text-foreground shadow-sm'
-                : 'text-muted-foreground hover:text-foreground'
-            )}
-          >
-            {tab.label}
-          </button>
-        ))}
-      </div>
-
-      {/* Tab 内容 */}
-      {activeTab === 'config' ? <FeishuConfigTab /> : <FeishuBindingsTab />}
-    </div>
-  )
-}
diff --git a/apps/electron/src/renderer/components/settings/GeneralSettings.tsx b/apps/electron/src/renderer/components/settings/GeneralSettings.tsx
index 71f0510e..4bdaddfb 100644
--- a/apps/electron/src/renderer/components/settings/GeneralSettings.tsx
+++ b/apps/electron/src/renderer/components/settings/GeneralSettings.tsx
@@ -16,6 +16,8 @@ import {
   SettingsRow,
   SettingsToggle,
 } from './primitives'
+import { Check } from 'lucide-react'
+import { LABEL_CLASS, DESCRIPTION_CLASS } from './primitives/SettingsUIConstants'
 import { Popover, PopoverTrigger, PopoverContent } from '../ui/popover'
 import { UserAvatar } from '../chat/UserAvatar'
 import { userProfileAtom } from '@/atoms/user-profile'
@@ -23,7 +25,12 @@ import {
   notificationsEnabledAtom,
   updateNotificationsEnabled,
 } from '@/atoms/notifications'
+import {
+  chatMessageLayoutAtom,
+  updateChatMessageLayout,
+} from '@/atoms/chat-message-layout'
 import { cn } from '@/lib/utils'
+import type { ChatMessageLayout } from '../../../types'
 
 /** emoji-mart 选择回调的 emoji 对象类型 */
 interface EmojiMartEmoji {
@@ -35,9 +42,24 @@ interface EmojiMartEmoji {
   shortcodes: string
 }
 
+/** 布局模式定义 */
+const LAYOUT_MODES = [
+  {
+    value: 'left-aligned' as const,
+    label: '左对齐',
+    description: '所有消息左对齐显示',
+  },
+  {
+    value: 'left-right' as const,
+    label: '左右分布',
+    description: '用户消息右对齐，AI 消息左对齐',
+  },
+]
+
 export function GeneralSettings(): React.ReactElement {
   const [userProfile, setUserProfile] = useAtom(userProfileAtom)
   const [notificationsEnabled, setNotificationsEnabled] = useAtom(notificationsEnabledAtom)
+  const [chatMessageLayout, setChatMessageLayout] = useAtom(chatMessageLayoutAtom)
   const [isEditingName, setIsEditingName] = React.useState(false)
   const [nameInput, setNameInput] = React.useState(userProfile.userName)
   const [showEmojiPicker, setShowEmojiPicker] = React.useState(false)
@@ -92,6 +114,12 @@ export function GeneralSettings(): React.ReactElement {
     }
   }
 
+  /** 切换消息布局模式 */
+  const handleLayoutChange = React.useCallback((layout: ChatMessageLayout) => {
+    setChatMessageLayout(layout)
+    updateChatMessageLayout(layout)
+  }, [setChatMessageLayout])
+
   return (
     <div className="space-y-6">
       {/* 用户档案区域 */}
@@ -211,6 +239,113 @@ export function GeneralSettings(): React.ReactElement {
               updateNotificationsEnabled(checked)
             }}
           />
+          {/* 会话显示模式 - 卡片式选择器 */}
+          <div className="px-4 py-3">
+            <div className={cn(LABEL_CLASS)}>会话显示模式</div>
+            <div className={cn(DESCRIPTION_CLASS, 'mt-0.5 mb-3')}>选择消息气泡的排列方式</div>
+            <div className="grid grid-cols-2 gap-3">
+              {LAYOUT_MODES.map((mode) => (
+                <button
+                  key={mode.value}
+                  type="button"
+                  onClick={() => handleLayoutChange(mode.value)}
+                  className={cn(
+                    'relative flex flex-col items-center gap-3 p-3 rounded-xl border-2 transition-all duration-200',
+                    'hover:border-primary/50 hover:bg-foreground/[0.02]',
+                    chatMessageLayout === mode.value
+                      ? 'border-primary bg-primary/[0.03]'
+                      : 'border-border bg-background'
+                  )}
+                >
+                  {/* 预览图 - 高度自适应内容，无多余空白 */}
+                  <div className="w-full rounded-lg bg-muted/50 p-2 flex flex-col gap-1.5">
+                    {mode.value === 'left-aligned' ? (
+                      /* 左对齐模式预览 */
+                      <>
+                        <div className="flex items-center gap-1.5">
+                          <div className="w-4 h-4 rounded-full bg-primary/20 shrink-0" />
+                          <div className="flex-1 space-y-1">
+                            <div className="h-2 w-3/4 bg-foreground/10 rounded" />
+                            <div className="h-2 w-1/2 bg-foreground/10 rounded" />
+                          </div>
+                        </div>
+                        <div className="flex items-center gap-1.5">
+                          <div className="w-4 h-4 rounded-full bg-foreground/10 shrink-0" />
+                          <div className="flex-1 space-y-1">
+                            <div className="h-2 w-2/3 bg-primary/15 rounded" />
+                          </div>
+                        </div>
+                        <div className="flex items-center gap-1.5">
+                          <div className="w-4 h-4 rounded-full bg-primary/20 shrink-0" />
+                          <div className="flex-1 space-y-1">
+                            <div className="h-2 w-4/5 bg-foreground/10 rounded" />
+                            <div className="h-2 w-1/2 bg-foreground/10 rounded" />
+                          </div>
+                        </div>
+                        <div className="flex items-center gap-1.5">
+                          <div className="w-4 h-4 rounded-full bg-foreground/10 shrink-0" />
+                          <div className="flex-1 space-y-1">
+                            <div className="h-2 w-3/5 bg-primary/15 rounded" />
+                          </div>
+                        </div>
+                      </>
+                    ) : (
+                      /* 左右分布模式预览 */
+                      <>
+                        <div className="flex items-center gap-1.5">
+                          <div className="w-4 h-4 rounded-full bg-primary/20 shrink-0" />
+                          <div className="flex-1 space-y-1">
+                            <div className="h-2 w-3/4 bg-foreground/10 rounded" />
+                          </div>
+                        </div>
+                        <div className="flex items-center gap-1.5 flex-row-reverse">
+                          <div className="w-4 h-4 rounded-full bg-foreground/10 shrink-0" />
+                          <div className="flex-1 flex justify-end">
+                            <div className="h-2 w-1/2 bg-primary/15 rounded" />
+                          </div>
+                        </div>
+                        <div className="flex items-center gap-1.5">
+                          <div className="w-4 h-4 rounded-full bg-primary/20 shrink-0" />
+                          <div className="flex-1 space-y-1">
+                            <div className="h-2 w-2/3 bg-foreground/10 rounded" />
+                            <div className="h-2 w-1/3 bg-foreground/10 rounded" />
+                          </div>
+                        </div>
+                        <div className="flex items-center gap-1.5 flex-row-reverse">
+                          <div className="w-4 h-4 rounded-full bg-foreground/10 shrink-0" />
+                          <div className="flex-1 flex justify-end">
+                            <div className="h-2 w-3/5 bg-primary/15 rounded" />
+                          </div>
+                        </div>
+                      </>
+                    )}
+                  </div>
+                  
+                  {/* 底部信息 */}
+                  <div className="flex items-center gap-2 w-full">
+                    {/* 选择框 */}
+                    <div
+                      className={cn(
+                        'w-5 h-5 rounded-full border-2 flex items-center justify-center transition-colors',
+                        chatMessageLayout === mode.value
+                          ? 'border-primary bg-primary'
+                          : 'border-muted-foreground/30'
+                      )}
+                    >
+                      {chatMessageLayout === mode.value && (
+                        <Check className="w-3 h-3 text-primary-foreground" strokeWidth={3} />
+                      )}
+                    </div>
+                    {/* 文字信息 */}
+                    <div className="flex flex-col items-start">
+                      <span className="text-sm font-medium text-foreground">{mode.label}</span>
+                      <span className="text-[11px] text-muted-foreground">{mode.description}</span>
+                    </div>
+                  </div>
+                </button>
+              ))}
+            </div>
+          </div>
         </SettingsCard>
       </SettingsSection>
     </div>
diff --git a/apps/electron/src/renderer/components/settings/SettingsPanel.tsx b/apps/electron/src/renderer/components/settings/SettingsPanel.tsx
index 68766c22..7fc2dcea 100644
--- a/apps/electron/src/renderer/components/settings/SettingsPanel.tsx
+++ b/apps/electron/src/renderer/components/settings/SettingsPanel.tsx
@@ -24,7 +24,7 @@ import { AboutSettings } from './AboutSettings'
 import { AgentSettings } from './AgentSettings'
 import { PromptSettings } from './PromptSettings'
 import { ToolSettings } from './ToolSettings'
-import { FeishuSettings } from './FeishuSettings'
+import { FeishuBotsSettings } from './FeishuBotsSettings'
 import { TutorialViewer } from '../tutorial/TutorialViewer'
 
 /** 设置 Tab 定义 */
@@ -45,7 +45,7 @@ const BASE_TABS: TabItem[] = [
 /** Agent 模式专属 Tab */
 const AGENT_TAB: TabItem = { id: 'agent', label: '配置', icon: <Plug size={16} /> }
 const TOOLS_TAB: TabItem = { id: 'tools', label: '工具', icon: <Wrench size={16} /> }
-const FEISHU_TAB: TabItem = { id: 'feishu', label: '飞书', icon: <MessageSquare size={16} /> }
+const FEISHU_BOTS_TAB: TabItem = { id: 'feishu-bots', label: '飞书 Bots', icon: <MessageSquare size={16} /> }
 const TUTORIAL_TAB: TabItem = { id: 'tutorial', label: '教程', icon: <GraduationCap size={16} /> }
 
 /** 尾部 Tabs */
@@ -73,8 +73,8 @@ function renderTabContent(tab: SettingsTab): React.ReactElement {
       return <AppearanceSettings />
     case 'about':
       return <AboutSettings />
-    case 'feishu':
-      return <FeishuSettings />
+    case 'feishu-bots':
+      return <FeishuBotsSettings />
     case 'tutorial':
       return <TutorialViewer />
   }
@@ -89,9 +89,9 @@ export function SettingsPanel(): React.ReactElement {
   // Agent 模式时在渠道后插入 Agent Tab，工具 tab 两种模式都显示
   const tabs = React.useMemo(() => {
     if (appMode === 'agent') {
-      return [...BASE_TABS, AGENT_TAB, TOOLS_TAB, FEISHU_TAB, TUTORIAL_TAB, ...TAIL_TABS]
+      return [...BASE_TABS, AGENT_TAB, TOOLS_TAB, FEISHU_BOTS_TAB, TUTORIAL_TAB, ...TAIL_TABS]
     }
-    return [...BASE_TABS, TOOLS_TAB, FEISHU_TAB, TUTORIAL_TAB, ...TAIL_TABS]
+    return [...BASE_TABS, TOOLS_TAB, FEISHU_BOTS_TAB, TUTORIAL_TAB, ...TAIL_TABS]
   }, [appMode])
 
   return (
diff --git a/apps/electron/src/renderer/components/settings/primitives/SettingsColorPicker.tsx b/apps/electron/src/renderer/components/settings/primitives/SettingsColorPicker.tsx
new file mode 100644
index 00000000..53775dd6
--- /dev/null
+++ b/apps/electron/src/renderer/components/settings/primitives/SettingsColorPicker.tsx
@@ -0,0 +1,145 @@
+/**
+ * SettingsColorPicker - 颜色选择器原语
+ *
+ * 提供颜色选择功能，包括：
+ * - 原生 color input 选择任意颜色
+ * - 预设颜色快速选择
+ * - 重置为默认（空值）
+ */
+
+import * as React from 'react'
+import { RotateCcw } from 'lucide-react'
+import { cn } from '@/lib/utils'
+import { Button } from '@/components/ui/button'
+
+/** 预设颜色选项 */
+const PRESET_COLORS = [
+  '#3b82f6', // 蓝色
+  '#10b981', // 绿色
+  '#f59e0b', // 橙色
+  '#ef4444', // 红色
+  '#8b5cf6', // 紫色
+  '#ec4899', // 粉色
+  '#06b6d4', // 青色
+  '#84cc16', // 青柠
+]
+
+interface SettingsColorPickerProps {
+  /** 当前颜色值（空字符串表示使用默认） */
+  value: string
+  /** 颜色变化回调 */
+  onChange: (value: string) => void
+  /** 是否允许清空/重置 */
+  allowClear?: boolean
+}
+
+/**
+ * 颜色选择器组件
+ */
+export function SettingsColorPicker({
+  value,
+  onChange,
+  allowClear = true,
+}: SettingsColorPickerProps): React.ReactElement {
+  const colorInputRef = React.useRef<HTMLInputElement>(null)
+
+  /** 处理颜色变化 */
+  const handleColorChange = React.useCallback(
+    (e: React.ChangeEvent<HTMLInputElement>) => {
+      onChange(e.target.value)
+    },
+    [onChange]
+  )
+
+  /** 处理预设颜色点击 */
+  const handlePresetClick = React.useCallback(
+    (color: string) => {
+      onChange(color)
+    },
+    [onChange]
+  )
+
+  /** 处理重置 */
+  const handleReset = React.useCallback(() => {
+    onChange('')
+  }, [onChange])
+
+  /** 点击颜色预览打开选择器 */
+  const handlePreviewClick = React.useCallback(() => {
+    colorInputRef.current?.click()
+  }, [])
+
+  // 当前是否有自定义颜色
+  const hasCustomColor = value && value !== ''
+
+  return (
+    <div className="flex items-center gap-3">
+      {/* 颜色选择器 */}
+      <div className="flex items-center gap-2">
+        {/* 颜色预览/选择按钮 */}
+        <button
+          type="button"
+          onClick={handlePreviewClick}
+          className={cn(
+            'relative w-9 h-9 rounded-lg border-2 transition-all',
+            'hover:scale-105 active:scale-95',
+            hasCustomColor ? 'border-transparent' : 'border-dashed border-muted-foreground/30'
+          )}
+          style={{
+            backgroundColor: hasCustomColor ? value : 'transparent',
+          }}
+          title={hasCustomColor ? value : '选择颜色'}
+        >
+          {!hasCustomColor && (
+            <span className="absolute inset-0 flex items-center justify-center text-muted-foreground/50 text-lg">
+              +
+            </span>
+          )}
+        </button>
+
+        {/* 隐藏的原生 color input */}
+        <input
+          ref={colorInputRef}
+          type="color"
+          value={value || '#3b82f6'}
+          onChange={handleColorChange}
+          className="sr-only"
+          aria-label="选择颜色"
+        />
+
+        {/* 预设颜色 */}
+        <div className="flex items-center gap-1">
+          {PRESET_COLORS.map((color) => (
+            <button
+              key={color}
+              type="button"
+              onClick={() => handlePresetClick(color)}
+              className={cn(
+                'w-5 h-5 rounded-full transition-all',
+                'hover:scale-110 active:scale-95',
+                'focus:outline-none focus:ring-2 focus:ring-offset-1 focus:ring-primary',
+                value === color && 'ring-2 ring-offset-1 ring-primary scale-110'
+              )}
+              style={{ backgroundColor: color }}
+              title={color}
+              aria-label={`选择颜色 ${color}`}
+            />
+          ))}
+        </div>
+      </div>
+
+      {/* 重置按钮 */}
+      {allowClear && hasCustomColor && (
+        <Button
+          variant="ghost"
+          size="icon-sm"
+          onClick={handleReset}
+          title="恢复默认"
+          className="text-muted-foreground hover:text-foreground"
+        >
+          <RotateCcw className="w-3.5 h-3.5" />
+        </Button>
+      )}
+    </div>
+  )
+}
diff --git a/apps/electron/src/renderer/components/settings/primitives/index.ts b/apps/electron/src/renderer/components/settings/primitives/index.ts
index 9d4fc99d..27382c60 100644
--- a/apps/electron/src/renderer/components/settings/primitives/index.ts
+++ b/apps/electron/src/renderer/components/settings/primitives/index.ts
@@ -13,3 +13,4 @@ export * from './SettingsInput'
 export * from './SettingsSecretInput'
 export * from './SettingsSelect'
 export * from './SettingsSegmentedControl'
+export * from './SettingsColorPicker'
diff --git a/apps/electron/src/renderer/components/tabs/TabBar.tsx b/apps/electron/src/renderer/components/tabs/TabBar.tsx
index e4716c7f..11b43712 100644
--- a/apps/electron/src/renderer/components/tabs/TabBar.tsx
+++ b/apps/electron/src/renderer/components/tabs/TabBar.tsx
@@ -30,6 +30,7 @@ import {
 import {
   agentSidePanelOpenMapAtom,
   agentSidePanelTabMapAtom,
+  agentSessionDropZoneDismissedAtom,
 } from '@/atoms/agent-atoms'
 import { conversationPromptIdAtom } from '@/atoms/system-prompt-atoms'
 import { TabBarItem } from './TabBarItem'
@@ -50,6 +51,7 @@ export function TabBar(): React.ReactElement {
   const setConvPromptId = useSetAtom(conversationPromptIdAtom)
   const setAgentSidePanelOpen = useSetAtom(agentSidePanelOpenMapAtom)
   const setAgentSidePanelTab = useSetAtom(agentSidePanelTabMapAtom)
+  const setAgentSessionDropZoneDismissed = useSetAtom(agentSessionDropZoneDismissedAtom)
 
   /** 清理关闭标签对应的 per-conversation/session Map atoms 条目 */
   const cleanupMapAtoms = React.useCallback((tabId: string) => {
@@ -68,7 +70,8 @@ export function TabBar(): React.ReactElement {
     // Agent per-session atoms
     setAgentSidePanelOpen(deleteKey)
     setAgentSidePanelTab(deleteKey)
-  }, [setConvModels, setConvContextLength, setConvThinking, setConvParallel, setConvPromptId, setAgentSidePanelOpen, setAgentSidePanelTab])
+    setAgentSessionDropZoneDismissed(deleteKey)
+  }, [setConvModels, setConvContextLength, setConvThinking, setConvParallel, setConvPromptId, setAgentSidePanelOpen, setAgentSidePanelTab, setAgentSessionDropZoneDismissed])
 
   // 拖拽状态
   const dragState = React.useRef<{
diff --git a/apps/electron/src/renderer/components/ui/tooltip.tsx b/apps/electron/src/renderer/components/ui/tooltip.tsx
index 7c176484..016590f1 100644
--- a/apps/electron/src/renderer/components/ui/tooltip.tsx
+++ b/apps/electron/src/renderer/components/ui/tooltip.tsx
@@ -20,15 +20,17 @@ const TooltipContent = React.forwardRef<
   React.ElementRef<typeof TooltipPrimitive.Content>,
   React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>
 >(({ className, sideOffset = 4, ...props }, ref) => (
-  <TooltipPrimitive.Content
-    ref={ref}
-    sideOffset={sideOffset}
-    className={cn(
-      "z-[100] overflow-hidden rounded-md bg-primary px-3 py-1.5 text-xs text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-      className
-    )}
-    {...props}
-  />
+  <TooltipPrimitive.Portal>
+    <TooltipPrimitive.Content
+      ref={ref}
+      sideOffset={sideOffset}
+      className={cn(
+        "z-[100] overflow-hidden rounded-md bg-primary px-3 py-1.5 text-xs text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+        className
+      )}
+      {...props}
+    />
+  </TooltipPrimitive.Portal>
 ))
 TooltipContent.displayName = TooltipPrimitive.Content.displayName
 
diff --git a/apps/electron/src/renderer/hooks/useChatLayout.ts b/apps/electron/src/renderer/hooks/useChatLayout.ts
new file mode 100644
index 00000000..17f449c3
--- /dev/null
+++ b/apps/electron/src/renderer/hooks/useChatLayout.ts
@@ -0,0 +1,100 @@
+/**
+ * useChatLayout - 聊天布局 Hook
+ *
+ * 统一处理会话显示模式的样式计算，简化组件中的条件判断。
+ */
+
+import { useAtomValue } from 'jotai'
+import { chatMessageLayoutAtom } from '@/atoms/chat-message-layout'
+import type { ChatMessageLayout } from '../../types'
+
+export interface ChatLayoutStyles {
+  /** 是否为左右分布模式 */
+  isLeftRight: boolean
+  /** 当前布局模式 */
+  layout: ChatMessageLayout
+  /** 用户消息是否右对齐 */
+  isUserRightAligned: boolean
+  /** Message 容器的对齐类名 */
+  messageAlignClass: string
+  /** 用户头像区域的 flex 方向类名 */
+  userHeaderFlexClass: string
+  /** 用户名/时间的对齐类名 */
+  userInfoAlignClass: string
+  /** MessageContent 的 padding 类名 */
+  contentPaddingClass: string
+  /** MessageContent 的 items 对齐类名 */
+  contentItemsClass: string
+  /** MessageActions 的类名 */
+  actionsClass: string
+  /** UserMessageContent 的文本对齐类名 */
+  userContentTextClass: string
+  /** 附件容器对齐类名 */
+  attachmentsClass: string
+}
+
+/**
+ * 获取聊天布局样式
+ * @param isUserMessage 是否为用户消息
+ * @param isParallelMode 是否为并排模式
+ */
+export function useChatLayout(
+  isUserMessage: boolean,
+  isParallelMode: boolean = false
+): ChatLayoutStyles {
+  const layout = useAtomValue(chatMessageLayoutAtom)
+  const isLeftRight = layout === 'left-right'
+  
+  // 用户消息在左右分布模式下右对齐（并排模式强制左对齐）
+  const isUserRightAligned = isUserMessage && isLeftRight && !isParallelMode
+
+  return {
+    isLeftRight,
+    layout,
+    isUserRightAligned,
+    
+    // Message 容器对齐
+    messageAlignClass: isUserRightAligned ? 'items-end' : 'items-start',
+    
+    // 用户头像区域
+    userHeaderFlexClass: isUserRightAligned ? 'flex-row-reverse' : '',
+    userInfoAlignClass: isUserRightAligned ? 'items-end' : '',
+    
+    // MessageContent
+    contentPaddingClass: isUserRightAligned ? 'pr-[46px] pl-0' : 'pl-[46px]',
+    contentItemsClass: isUserRightAligned ? 'items-end' : '',
+    
+    // MessageActions
+    actionsClass: isUserRightAligned 
+      ? 'pr-[46px] justify-end' 
+      : 'pl-[46px]',
+    
+    // UserMessageContent
+    userContentTextClass: isUserRightAligned ? 'text-right' : '',
+    
+    // 附件
+    attachmentsClass: isUserRightAligned ? 'items-end' : '',
+  }
+}
+
+/**
+ * 简化版 Hook - 仅用于 Agent 模式（无并排模式）
+ */
+export function useAgentLayout(isUserMessage: boolean): Omit<ChatLayoutStyles, 'isUserRightAligned'> {
+  const layout = useAtomValue(chatMessageLayoutAtom)
+  const isLeftRight = layout === 'left-right'
+  const isRightAligned = isUserMessage && isLeftRight
+
+  return {
+    isLeftRight,
+    layout,
+    messageAlignClass: isRightAligned ? 'items-end' : 'items-start',
+    userHeaderFlexClass: isRightAligned ? 'flex-row-reverse' : '',
+    userInfoAlignClass: isRightAligned ? 'items-end' : '',
+    contentPaddingClass: isRightAligned ? 'pr-[46px] pl-0' : 'pl-[46px]',
+    contentItemsClass: isRightAligned ? 'items-end' : '',
+    actionsClass: isRightAligned ? 'pr-[46px] justify-end' : 'pl-[46px]',
+    userContentTextClass: isRightAligned ? 'text-right' : '',
+    attachmentsClass: isRightAligned ? 'items-end' : '',
+  }
+}
diff --git a/apps/electron/src/renderer/hooks/useGlobalAgentListeners.ts b/apps/electron/src/renderer/hooks/useGlobalAgentListeners.ts
index 075b7c66..c47238d1 100644
--- a/apps/electron/src/renderer/hooks/useGlobalAgentListeners.ts
+++ b/apps/electron/src/renderer/hooks/useGlobalAgentListeners.ts
@@ -20,12 +20,8 @@ import {
   backgroundTasksAtomFamily,
   agentSidePanelOpenMapAtom,
   agentSidePanelTabMapAtom,
-  cachedTeamActivitiesAtom,
-  cachedTeammateStatesAtom,
-  cachedTeamOverviewsAtom,
-  buildTeamActivityEntries,
-  extractTeamOverview,
   applyAgentEvent,
+  agentTodoGroupsMapAtom,
 } from '@/atoms/agent-atoms'
 import {
   notificationsEnabledAtom,
@@ -110,6 +106,14 @@ export function useGlobalAgentListeners(): void {
               intent: event.command || event.intent,
             }]
           })
+        } else if (event.type === 'task_notification') {
+          // 子代理完成/失败/停止时，移除对应的后台任务
+          const isTerminal = event.status === 'completed' || event.status === 'failed' || event.status === 'stopped'
+          if (isTerminal) {
+            store.set(backgroundTasksAtomFamily(sessionId), (prev) =>
+              prev.filter((t) => t.id !== event.taskId)
+            )
+          }
         } else if (event.type === 'tool_result') {
           // 工具完成时，移除对应的后台任务
           store.set(backgroundTasksAtomFamily(sessionId), (prev) =>
@@ -129,6 +133,30 @@ export function useGlobalAgentListeners(): void {
             map.set(sessionId, event.suggestion)
             return map
           })
+        } else if (event.type === 'todo_update') {
+          // 更新待办事项列表
+          store.set(agentTodoGroupsMapAtom, (prev) => {
+            const next = new Map(prev)
+            let sessionMap = next.get(sessionId)
+            if (!sessionMap) {
+              sessionMap = new Map()
+              next.set(sessionId, sessionMap)
+            }
+
+            const existingGroup = sessionMap.get(event.groupId)
+            const isCompleted = event.todos.every((t) => t.status === 'completed')
+
+            sessionMap.set(event.groupId, {
+              groupId: event.groupId,
+              todos: event.todos,
+              createdAt: existingGroup?.createdAt ?? Date.now(),
+              updatedAt: Date.now(),
+              isCompleted,
+              isDismissed: existingGroup?.isDismissed ?? false,
+            })
+
+            return next
+          })
         } else if (event.type === 'permission_request') {
           // 权限请求入队（统一通道，不区分当前/后台会话）
           store.set(allPendingPermissionRequestsAtom, (prev) => {
@@ -188,40 +216,6 @@ export function useGlobalAgentListeners(): void {
           return map
         })
 
-        // 缓存 Team 活动数据（在流式状态被清除前保存，防止面板数据丢失）
-        const streamState = store.get(agentStreamingStatesAtom).get(data.sessionId)
-        if (streamState && streamState.toolActivities.length > 0) {
-          const teamEntries = buildTeamActivityEntries(streamState.toolActivities)
-          if (teamEntries.length > 0) {
-            store.set(cachedTeamActivitiesAtom, (prev) => {
-              const map = new Map(prev)
-              map.set(data.sessionId, teamEntries)
-              return map
-            })
-          }
-        }
-
-        // 缓存 Teammate 状态数据（Agent Teams 功能）
-        if (streamState && streamState.teammates.length > 0) {
-          store.set(cachedTeammateStatesAtom, (prev) => {
-            const map = new Map(prev)
-            map.set(data.sessionId, streamState.teammates)
-            return map
-          })
-        }
-
-        // 缓存 TeamOverview 快照（确保切换 tab 后团队全景数据不丢失）
-        if (streamState && streamState.toolActivities.length > 0) {
-          const overview = extractTeamOverview(streamState.toolActivities, streamState.teammates)
-          if (overview) {
-            store.set(cachedTeamOverviewsAtom, (prev) => {
-              const map = new Map(prev)
-              map.set(data.sessionId, overview)
-              return map
-            })
-          }
-        }
-
         /** 竞态保护：检查该会话是否已有新的流式请求正在运行 */
         const isNewStreamRunning = (): boolean => {
           const state = store.get(agentStreamingStatesAtom).get(data.sessionId)
diff --git a/apps/electron/src/renderer/index.html b/apps/electron/src/renderer/index.html
index 57d4423f..2323adf0 100644
--- a/apps/electron/src/renderer/index.html
+++ b/apps/electron/src/renderer/index.html
@@ -3,6 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; connect-src 'self'; worker-src 'self' blob:;">
     <title>Proma</title>
     <script>
       // 主题初始化脚本（在 React 加载前执行，避免闪烁）
diff --git a/apps/electron/src/renderer/main.tsx b/apps/electron/src/renderer/main.tsx
index 48c9ca83..e47b655e 100644
--- a/apps/electron/src/renderer/main.tsx
+++ b/apps/electron/src/renderer/main.tsx
@@ -28,12 +28,21 @@ import {
   agentEffortAtom,
   agentMaxBudgetUsdAtom,
   agentMaxTurnsAtom,
+  agentEnabledChannelIdsAtom,
 } from './atoms/agent-atoms'
 import { updateStatusAtom, initializeUpdater } from './atoms/updater'
 import {
   notificationsEnabledAtom,
   initializeNotifications,
 } from './atoms/notifications'
+import {
+  chatMessageLayoutAtom,
+  initializeChatMessageLayout,
+} from './atoms/chat-message-layout'
+import {
+  messageBubbleColorsAtom,
+  initializeMessageBubbleColors,
+} from './atoms/message-bubble-colors'
 import { useGlobalAgentListeners } from './hooks/useGlobalAgentListeners'
 import { useGlobalChatListeners } from './hooks/useGlobalChatListeners'
 import { tabsAtom, splitLayoutAtom } from './atoms/tab-atoms'
@@ -107,6 +116,8 @@ function AgentSettingsInitializer(): null {
   const setEffort = useSetAtom(agentEffortAtom)
   const setMaxBudget = useSetAtom(agentMaxBudgetUsdAtom)
   const setMaxTurns = useSetAtom(agentMaxTurnsAtom)
+  const setAgentEnabledChannelIds = useSetAtom(agentEnabledChannelIdsAtom)
+
 
   // 读取当前工作区信息（用于能力变化 diff）
   const currentWorkspaceId = useAtomValue(currentAgentWorkspaceIdAtom)
@@ -141,6 +152,12 @@ function AgentSettingsInitializer(): null {
       if (settings.agentMaxTurns != null) {
         setMaxTurns(settings.agentMaxTurns)
       }
+      // Agent 启用渠道列表（兼容旧数据：如果没有列表但有单选 ID，自动迁移）
+      if (settings.agentEnabledChannelIds && settings.agentEnabledChannelIds.length > 0) {
+        setAgentEnabledChannelIds(settings.agentEnabledChannelIds)
+      } else if (settings.agentChannelId) {
+        setAgentEnabledChannelIds([settings.agentChannelId])
+      }
 
       // 加载工作区列表并恢复上次选中的工作区
       window.electronAPI.listAgentWorkspaces().then((workspaces) => {
@@ -154,7 +171,8 @@ function AgentSettingsInitializer(): null {
         }
       }).catch(console.error)
     }).catch(console.error)
-  }, [setAgentChannelId, setAgentModelId, setAgentWorkspaces, setCurrentWorkspaceId, setPermissionMode, setThinking, setEffort, setMaxBudget, setMaxTurns])
+
+  }, [setAgentChannelId, setAgentModelId, setAgentWorkspaces, setCurrentWorkspaceId, setPermissionMode, setThinking, setEffort, setMaxBudget, setMaxTurns, setAgentEnabledChannelIds])
 
   // 工作区切换时重置能力缓存，预加载基线
   useEffect(() => {
@@ -240,6 +258,36 @@ function NotificationsInitializer(): null {
   return null
 }
 
+/**
+ * 消息布局初始化组件
+ *
+ * 从主进程加载消息布局设置。
+ */
+function ChatMessageLayoutInitializer(): null {
+  const setLayout = useSetAtom(chatMessageLayoutAtom)
+
+  useEffect(() => {
+    initializeChatMessageLayout(setLayout)
+  }, [setLayout])
+
+  return null
+}
+
+/**
+ * 消息气泡颜色初始化组件
+ *
+ * 从主进程加载消息气泡颜色设置并应用到 DOM。
+ */
+function MessageBubbleColorsInitializer(): null {
+  const setColors = useSetAtom(messageBubbleColorsAtom)
+
+  useEffect(() => {
+    void initializeMessageBubbleColors(setColors)
+  }, [setColors])
+
+  return null
+}
+
 /**
  * Chat IPC 监听器初始化组件
  *
@@ -329,13 +377,23 @@ function FeishuInitializer(): null {
     })
 
     // 定期上报在场状态（5 秒间隔 + 焦点变化时即时上报）
+    // 注意：lastInteractionAt 仅由真实交互事件更新，避免失焦期间被心跳刷新。
+    const lastInteractionAtRef = { current: Date.now() }
+    const markInteraction = (): void => {
+      lastInteractionAtRef.current = Date.now()
+    }
     const reportPresence = (): void => {
       const activeSessionId = store.get(currentAgentSessionIdAtom) ?? store.get(currentConversationIdAtom)
       window.electronAPI.reportFeishuPresence({
         activeSessionId,
-        lastInteractionAt: Date.now(),
+        lastInteractionAt: lastInteractionAtRef.current,
       }).catch(() => { /* 忽略 */ })
     }
+
+    window.addEventListener('pointerdown', markInteraction, true)
+    window.addEventListener('keydown', markInteraction, true)
+    window.addEventListener('wheel', markInteraction, { passive: true, capture: true })
+    window.addEventListener('touchstart', markInteraction, { passive: true, capture: true })
     const interval = setInterval(reportPresence, 5000)
     window.addEventListener('focus', reportPresence)
     window.addEventListener('blur', reportPresence)
@@ -344,6 +402,10 @@ function FeishuInitializer(): null {
       cleanupStatus()
       cleanupNotif()
       clearInterval(interval)
+      window.removeEventListener('pointerdown', markInteraction, true)
+      window.removeEventListener('keydown', markInteraction, true)
+      window.removeEventListener('wheel', markInteraction, true)
+      window.removeEventListener('touchstart', markInteraction, true)
       window.removeEventListener('focus', reportPresence)
       window.removeEventListener('blur', reportPresence)
     }
@@ -357,6 +419,8 @@ ReactDOM.createRoot(document.getElementById('root')!).render(
     <ThemeInitializer />
     <AgentSettingsInitializer />
     <NotificationsInitializer />
+    <ChatMessageLayoutInitializer />
+    <MessageBubbleColorsInitializer />
     <ChatListenersInitializer />
     <AgentListenersInitializer />
     <ChatToolInitializer />
diff --git a/apps/electron/src/renderer/styles/globals.css b/apps/electron/src/renderer/styles/globals.css
index 5c760b08..45a8611b 100644
--- a/apps/electron/src/renderer/styles/globals.css
+++ b/apps/electron/src/renderer/styles/globals.css
@@ -23,6 +23,9 @@
     --card-foreground: 0 0% 3.9%;
     --popover: 0 0% 100%;
     --popover-foreground: 0 0% 3.9%;
+    /* 消息卡片颜色 CSS 变量（由用户自定义） */
+    --user-message-bg: '';
+    --assistant-message-bg: '';
   }
 
   .dark {
@@ -191,3 +194,36 @@
 .spinner-cube:nth-child(7) { animation-delay: 0s; }
 .spinner-cube:nth-child(8) { animation-delay: 0.1s; }
 .spinner-cube:nth-child(9) { animation-delay: 0.2s; }
+
+/* ===== 消息气泡自定义颜色 ===== */
+
+/* 用户消息气泡：优先使用自定义颜色，否则使用默认半透明背景 */
+.user-message-bubble {
+  background-color: var(--user-message-bg, hsl(var(--foreground) / 0.045));
+}
+
+.dark .user-message-bubble {
+  background-color: var(--user-message-bg, hsl(var(--foreground) / 0.08));
+}
+
+/* AI 消息气泡：优先使用自定义颜色，否则使用透明背景 */
+.assistant-message-bubble {
+  background-color: var(--assistant-message-bg, transparent);
+}
+
+/* 确保渐变遮罩与自定义颜色协调 */
+.user-message-bubble .collapse-gradient {
+  background: linear-gradient(
+    to top,
+    var(--user-message-bg, hsl(var(--foreground) / 0.045)) 0%,
+    transparent 100%
+  );
+}
+
+.dark .user-message-bubble .collapse-gradient {
+  background: linear-gradient(
+    to top,
+    var(--user-message-bg, hsl(var(--foreground) / 0.08)) 0%,
+    transparent 100%
+  );
+}
diff --git a/apps/electron/src/types/settings.ts b/apps/electron/src/types/settings.ts
index 6228d561..10ba2107 100644
--- a/apps/electron/src/types/settings.ts
+++ b/apps/electron/src/types/settings.ts
@@ -9,9 +9,29 @@ import type { EnvironmentCheckResult, PromaPermissionMode, ThinkingConfig, Agent
 /** 主题模式 */
 export type ThemeMode = 'light' | 'dark' | 'system'
 
+/** 消息布局模式 */
+export type ChatMessageLayout = 'left-aligned' | 'left-right'
+
 /** 默认主题模式 */
 export const DEFAULT_THEME_MODE: ThemeMode = 'dark'
 
+/** 默认消息布局模式 */
+export const DEFAULT_CHAT_MESSAGE_LAYOUT: ChatMessageLayout = 'left-aligned'
+
+/** 消息气泡颜色配置 */
+export interface MessageBubbleColors {
+  /** 用户消息气泡背景色 */
+  userMessageColor: string
+  /** AI 消息气泡背景色 */
+  assistantMessageColor: string
+}
+
+/** 默认消息气泡颜色配置（空字符串表示使用默认样式） */
+export const DEFAULT_MESSAGE_BUBBLE_COLORS: MessageBubbleColors = {
+  userMessageColor: '',
+  assistantMessageColor: '',
+}
+
 /** 应用设置 */
 export interface AppSettings {
   /** 主题模式 */
@@ -20,6 +40,8 @@ export interface AppSettings {
   agentChannelId?: string
   /** Agent 默认模型 ID */
   agentModelId?: string
+  /** Agent 启用的渠道 ID 列表（多选） */
+  agentEnabledChannelIds?: string[]
   /** Agent 当前工作区 ID */
   agentWorkspaceId?: string
   /** 是否已完成 Onboarding 流程 */
@@ -44,6 +66,10 @@ export interface AppSettings {
   agentMaxTurns?: number
   /** 教程推荐横幅是否已关闭 */
   tutorialBannerDismissed?: boolean
+  /** 消息布局模式 */
+  chatMessageLayout?: ChatMessageLayout
+  /** 消息气泡颜色配置 */
+  messageBubbleColors?: MessageBubbleColors
 }
 
 /** 持久化的标签页状态 */
diff --git a/bun.lock b/bun.lock
index d37f3fd5..22a669ef 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "proma",
diff --git a/packages/core/package.json b/packages/core/package.json
index 1b9b8e3b..004ebcdb 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@proma/core",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "license": "Apache-2.0",
   "description": "proma core types,storage and core logic with agents",
   "type": "module",
diff --git a/packages/core/src/highlight/shiki-service.ts b/packages/core/src/highlight/shiki-service.ts
index 89eea94a..88108d8c 100644
--- a/packages/core/src/highlight/shiki-service.ts
+++ b/packages/core/src/highlight/shiki-service.ts
@@ -94,9 +94,43 @@ let highlighterPromise: Promise<ShikiHighlighter> | null = null
 /** 已 resolve 的高亮器实例缓存（同步访问用） */
 let cachedHighlighter: ShikiHighlighter | null = null
 
+/** Shiki 是否初始化失败（CSP 等原因） */
+let shikiInitFailed = false
+
+/**
+ * 创建降级高亮器（纯文本，无高亮）
+ * 当 Shiki 初始化失败时使用
+ */
+function createFallbackHighlighter(): ShikiHighlighter {
+  const fallback = {
+    codeToHtml: (code: string) => `<pre style="margin:0;padding:16px;font-family:monospace;white-space:pre-wrap;word-break:break-word;">${escapeHtml(code)}</pre>`,
+    codeToTokens: (code: string) => ({
+      tokens: code.split('\n').map(line => [{ content: line, color: '#e5e5e5' }]),
+      bgColor: '#1e1e1e',
+      fgColor: '#e5e5e5',
+    }),
+    getLoadedLanguages: () => ['text'],
+    getLoadedThemes: () => ['github-dark'],
+    loadLanguage: async () => {},
+    loadTheme: async () => {},
+  } as unknown as ShikiHighlighter
+  return fallback
+}
+
+/** HTML 转义 */
+function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#039;')
+}
+
 /**
  * 获取或创建 Shiki 高亮器单例
  * 首次调用时懒加载，resolve 后缓存实例供同步使用
+ * CSP 限制时自动降级到纯文本模式
  */
 function getHighlighter(): Promise<ShikiHighlighter> {
   if (!highlighterPromise) {
@@ -106,6 +140,13 @@ function getHighlighter(): Promise<ShikiHighlighter> {
     }).then((hl) => {
       cachedHighlighter = hl
       return hl
+    }).catch(() => {
+      // CSP 限制或其他错误，静默使用降级模式
+      // 这是预期行为，不需要警告用户
+      shikiInitFailed = true
+      const fallback = createFallbackHighlighter()
+      cachedHighlighter = fallback
+      return fallback
     })
   }
   return highlighterPromise
diff --git a/packages/shared/package.json b/packages/shared/package.json
index e86ada9c..1c25557c 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@proma/shared",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "license": "Apache-2.0",
   "description": "Shared types, configs and utilities for proma",
   "type": "module",
diff --git a/packages/shared/src/constants/permission-rules.ts b/packages/shared/src/constants/permission-rules.ts
index 0dbd8d37..9638bb6f 100644
--- a/packages/shared/src/constants/permission-rules.ts
+++ b/packages/shared/src/constants/permission-rules.ts
@@ -12,12 +12,21 @@ export const SAFE_TOOLS: readonly string[] = [
   'Grep',            // 内容搜索
   'WebSearch',       // 网络搜索
   'WebFetch',        // 网页获取
-  'TodoRead',        // Todo 列表读取
-  'TodoWrite',       // Todo 列表写入（无安全风险）
-  'TaskOutput',      // 后台任务输出
+  'TaskOutput',      // Task 子代理输出（SDK Task 工具的结果）
   // 注意：AskUserQuestion 不在此列表 — 由 canUseTool 拦截并展示交互式 UI
 ]
 
+/** 所有标准工具（auto 模式白名单，不含旧工具即可屏蔽） */
+export const ALL_STANDARD_TOOLS: readonly string[] = [
+  'Read', 'Write', 'Edit',   // 文件操作
+  'Bash',                     // Shell 命令
+  'Glob', 'Grep',             // 搜索
+  'WebSearch', 'WebFetch',    // 网络
+  'Task', 'TaskOutput',       // 子代理
+  'Skill',                    // Skill 调用
+  'NotebookEdit',             // Jupyter
+]
+
 /** 安全的 Bash 命令模式（只读操作） */
 export const SAFE_BASH_PATTERNS: readonly RegExp[] = [
   /^git\s+(status|log|diff|show|branch|remote|tag)\b/,
diff --git a/packages/shared/src/constants/provider-env.ts b/packages/shared/src/constants/provider-env.ts
new file mode 100644
index 00000000..c94bd805
--- /dev/null
+++ b/packages/shared/src/constants/provider-env.ts
@@ -0,0 +1,57 @@
+/**
+ * Provider 路由环境变量黑名单
+ *
+ * 这些变量控制 Claude Code CLI 的 Provider 路由（Anthropic Direct / Vertex / Bedrock），
+ * 必须从 SDK 子进程环境中隔离，防止用户本地 Shell 配置干扰 Proma 的渠道系统。
+ *
+ * buildSdkEnv() 在构建子进程环境时会过滤掉这些变量，
+ * 然后仅注入当前选中渠道所需的变量。
+ */
+
+/** 需要精确匹配过滤的 Provider 路由变量 */
+export const PROVIDER_ROUTING_VARS = new Set([
+  // ── Anthropic Direct ──
+  'ANTHROPIC_API_KEY',
+  'ANTHROPIC_BASE_URL',
+  'ANTHROPIC_AUTH_TOKEN',
+  'ANTHROPIC_MODEL',
+  'ANTHROPIC_SMALL_FAST_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+
+  // ── Vertex AI ──
+  'CLAUDE_CODE_USE_VERTEX',
+  'CLAUDE_CODE_SKIP_VERTEX_AUTH',
+  'ANTHROPIC_VERTEX_BASE_URL',
+  'ANTHROPIC_VERTEX_PROJECT_ID',
+  'ANTHROPIC_VERTEX_REGION',
+  'CLOUD_ML_REGION',
+
+  // ── Bedrock ──
+  'CLAUDE_CODE_USE_BEDROCK',
+  'CLAUDE_CODE_SKIP_BEDROCK_AUTH',
+  'ANTHROPIC_BEDROCK_BASE_URL',
+
+  // ── Foundry ──
+  'CLAUDE_CODE_USE_FOUNDRY',
+  'CLAUDE_CODE_SKIP_FOUNDRY_AUTH',
+
+  // ── Claude Code 认证 ──
+  'CLAUDE_CODE_API_KEY_FILE_DESCRIPTOR',
+  'CLAUDE_CODE_OAUTH_TOKEN',
+  'CLAUDE_CODE_REMOTE',
+])
+
+/** 需要前缀匹配过滤的环境变量前缀 */
+export const PROVIDER_ROUTING_PREFIXES = [
+  'ANTHROPIC_',
+]
+
+/**
+ * 判断一个环境变量 key 是否属于 Provider 路由变量（应被过滤）
+ */
+export function isProviderRoutingVar(key: string): boolean {
+  if (PROVIDER_ROUTING_VARS.has(key)) return true
+  return PROVIDER_ROUTING_PREFIXES.some(prefix => key.startsWith(prefix))
+}
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index 1e6b7d7a..cf7cd7a2 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -7,3 +7,4 @@ export * from './config/index'
 export * from './utils/index'
 export * from './agent/index'
 export * from './constants/permission-rules'
+export * from './constants/provider-env'
diff --git a/packages/shared/src/types/agent.ts b/packages/shared/src/types/agent.ts
index 62fb6c5d..15fd909e 100644
--- a/packages/shared/src/types/agent.ts
+++ b/packages/shared/src/types/agent.ts
@@ -224,6 +224,8 @@ export interface TaskUsage {
   toolUses: number
   /** 运行耗时（毫秒） */
   durationMs: number
+  /** 总费用（美元） */
+  costUsd?: number
 }
 
 /**
@@ -271,6 +273,34 @@ export interface AgentToolResultImage {
   mediaType: string
 }
 
+// ===== 待办事项列表类型 =====
+
+/** 待办事项状态 */
+export type TodoStatus = 'pending' | 'in_progress' | 'completed'
+
+/** 单个待办事项 */
+export interface TodoItem {
+  id: string
+  content: string
+  status: TodoStatus
+  /** 进行中的友好描述 */
+  activeForm?: string
+}
+
+/** 待办事项组 */
+export interface TodoGroup {
+  /** 组 ID（基于 tool_use_id） */
+  groupId: string
+  /** 待办事项列表 */
+  todos: TodoItem[]
+  /** 创建时间戳 */
+  createdAt: number
+  /** 最后更新时间 */
+  updatedAt: number
+  /** 是否已完成（所有任务都 completed） */
+  isCompleted: boolean
+}
+
 /**
  * Agent 事件流类型
  *
@@ -285,8 +315,8 @@ export type AgentEvent =
   | { type: 'tool_result'; toolUseId: string; toolName?: string; result: string; isError: boolean; input?: Record<string, unknown>; turnId?: string; parentToolUseId?: string; imageAttachments?: AgentToolResultImage[] }
   // 后台任务
   | { type: 'task_backgrounded'; toolUseId: string; taskId: string; intent?: string; turnId?: string }
-  | { type: 'task_started'; taskId: string; toolUseId?: string; description: string; taskType?: string; turnId?: string }
-  | { type: 'task_progress'; toolUseId: string; elapsedSeconds?: number; turnId?: string; taskId?: string; description?: string; lastToolName?: string; usage?: TaskUsage }
+  | { type: 'task_started'; taskId: string; toolUseId?: string; description: string; taskType?: string; prompt?: string; turnId?: string }
+  | { type: 'task_progress'; toolUseId: string; elapsedSeconds?: number; turnId?: string; taskId?: string; description?: string; lastToolName?: string; usage?: TaskUsage; summary?: string }
   | { type: 'task_notification'; taskId: string; toolUseId?: string; status: 'completed' | 'failed' | 'stopped'; summary: string; outputFile?: string; usage?: TaskUsage; turnId?: string }
   | { type: 'shell_backgrounded'; toolUseId: string; shellId: string; intent?: string; command?: string; turnId?: string }
   | { type: 'shell_killed'; shellId: string; turnId?: string }
@@ -319,6 +349,8 @@ export type AgentEvent =
   // Auto-Resume（Teams 完成后自动收集结果）
   | { type: 'waiting_resume'; message: string }
   | { type: 'resume_start'; messageId: string }
+  // 待办事项列表
+  | { type: 'todo_update'; groupId: string; todos: TodoItem[] }
 
 // ===== Agent 会话管理 =====
 
@@ -379,6 +411,8 @@ export interface AgentMessage {
   errorCanRetry?: boolean
   /** 错误恢复操作（status 消息） */
   errorActions?: RecoveryAction[]
+  /** 消息元数据（如飞书来源：chatId, senderOpenId, senderName, groupName, messageId, chatType） */
+  metadata?: Record<string, unknown>
 }
 
 // ===== Agent 标题生成输入 =====
@@ -441,10 +475,33 @@ export interface SkillMeta {
   enabled: boolean
 }
 
-/** 工作区能力摘要（MCP + Skill 计数） */
+// ===== 子代理元数据 =====
+
+/** 工作区子代理元数据（来自 AGENT.md frontmatter） */
+export interface AgentMeta {
+  /** 目录名（唯一标识） */
+  slug: string
+  /** 显示名称 */
+  name: string
+  /** 何时使用该代理的描述 */
+  description?: string
+  /** 图标标识 */
+  icon?: string
+  /** 活跃 vs 已禁用 */
+  enabled: boolean
+  /** 允许的工具列表 */
+  tools?: string[]
+  /** 禁止的工具列表 */
+  disallowedTools?: string[]
+  /** 最大轮次 */
+  maxTurns?: number
+}
+
+/** 工作区能力摘要（MCP + Skill + 子代理） */
 export interface WorkspaceCapabilities {
   mcpServers: Array<{ name: string; enabled: boolean; type: McpTransportType }>
   skills: SkillMeta[]
+  agents: AgentMeta[]
 }
 
 // ===== Agent 发送输入 =====
@@ -473,6 +530,24 @@ export interface AgentSendInput {
   mentionedSkills?: string[]
   /** 用户通过 #mcp:xxx 引用的 MCP 服务器名称列表 */
   mentionedMcpServers?: string[]
+  /** 用户通过 @agent:xxx 引用的子代理 slug 列表 */
+  mentionedAgents?: string[]
+  /** 消息元数据（如飞书来源：chatId, senderOpenId, senderName, groupName, messageId, chatType） */
+  messageMetadata?: Record<string, unknown>
+  /** 是否启用子代理（Task 工具） */
+  enableSubAgents?: boolean
+}
+
+// ===== Agent Team 类型 =====
+
+/** 团队运行配置（运行时，非持久化） */
+export interface TeamRunConfig {
+  /** 是否启用 Lead 模式 */
+  enableLead: boolean
+  /** Lead 的自定义提示词 */
+  leadPrompt?: string
+  /** 是否跳过用户确认直接执行（默认 true） */
+  autoExecute?: boolean
 }
 
 // ===== 会话迁移输入 =====
@@ -489,26 +564,6 @@ export interface MoveSessionToWorkspaceInput {
 
 // ===== 后台任务管理 =====
 
-/**
- * 获取任务输出请求
- */
-export interface GetTaskOutputInput {
-  /** 任务 ID */
-  taskId: string
-  /** 是否阻塞等待完成（默认 false） */
-  block?: boolean
-}
-
-/**
- * 获取任务输出响应
- */
-export interface GetTaskOutputResult {
-  /** 任务输出内容 */
-  output: string
-  /** 任务是否已完成 */
-  isComplete: boolean
-}
-
 /**
  * 停止任务请求
  */
@@ -565,6 +620,14 @@ export interface FileIndexEntry {
   path: string
   /** 条目类型 */
   type: 'file' | 'dir'
+  /** 文件来源：本会话文件或工作区文件 */
+  source?: 'session' | 'workspace'
+  /** 所属文件夹名称（如 "上传文件", "voc", "generated"） */
+  folder?: string
+  /** 文件夹完整路径 */
+  folderPath?: string
+  /** 在文件夹内的层级深度（0=根，1=子文件夹） */
+  depth?: number
 }
 
 /** 文件搜索结果 */
@@ -604,15 +667,7 @@ export interface AgentSaveWorkspaceFilesInput {
   files: Array<{ filename: string; data: string }>
 }
 
-/** 附加/分离目录的输入参数 */
-export interface AgentAttachDirectoryInput {
-  /** 会话 ID */
-  sessionId: string
-  /** 目录的绝对路径 */
-  directoryPath: string
-}
-
-/** 工作区级附加/分离目录的输入参数 */
+/** 关联外部目录到工作区的输入参数 */
 export interface WorkspaceAttachDirectoryInput {
   /** 工作区 slug */
   workspaceSlug: string
@@ -620,6 +675,14 @@ export interface WorkspaceAttachDirectoryInput {
   directoryPath: string
 }
 
+/** 文件或文件夹选择结果 */
+export interface FileOrFolderDialogResult {
+  /** 选择的文件列表（base64 编码） */
+  files: Array<{ filename: string; data: string }>
+  /** 选择的文件夹路径列表 */
+  folders: Array<{ path: string; name: string }>
+}
+
 // ===== AskUserQuestion 交互式问答类型 =====
 
 /** AskUserQuestion 工具的选项定义 */
@@ -701,86 +764,6 @@ export interface PermissionResponse {
   alwaysAllow: boolean
 }
 
-// ===== Agent Teams 数据类型 =====
-
-/** Team 配置（~/.claude/teams/{name}/config.json） */
-export interface TeamConfig {
-  /** 团队名称 */
-  name: string
-  /** 团队描述 */
-  description?: string
-  /** 创建时间戳 */
-  createdAt: number
-  /** 领导 Agent ID */
-  leadAgentId?: string
-  /** 领导 Agent 的 SDK 会话 ID */
-  leadSessionId?: string
-  /** 团队成员列表 */
-  members: TeamMember[]
-}
-
-/** Team 成员 */
-export interface TeamMember {
-  /** Agent ID */
-  agentId: string
-  /** 显示名称 */
-  name: string
-  /** Agent 类型（如 'general-purpose', 'Explore'） */
-  agentType: string
-  /** 使用的模型 */
-  model?: string
-  /** 颜色标识 */
-  color?: string
-  /** 加入时间戳 */
-  joinedAt?: number
-}
-
-/** 任务项（~/.claude/tasks/{teamName}/） */
-export interface TaskItem {
-  /** 任务 ID */
-  id: string
-  /** 任务标题 */
-  subject: string
-  /** 任务描述 */
-  description?: string
-  /** 进行中的显示文本 */
-  activeForm?: string
-  /** 负责人 Agent 名称 */
-  owner?: string
-  /** 任务状态 */
-  status: 'pending' | 'in_progress' | 'completed'
-  /** 阻塞的任务 ID 列表 */
-  blocks: string[]
-  /** 被阻塞的任务 ID 列表 */
-  blockedBy: string[]
-}
-
-/** 解析后的收件箱消息 */
-export interface ParsedMailboxMessage {
-  /** 发送者名称 */
-  from: string
-  /** 消息文本 */
-  text: string
-  /** 摘要 */
-  summary?: string
-  /** 时间戳 */
-  timestamp?: string
-  /** 解析后的消息类型 */
-  parsedType: 'idle_notification' | 'shutdown_request' | 'shutdown_approved' | 'task_assignment' | 'text'
-}
-
-/** Agent Team 聚合数据（IPC 返回） */
-export interface AgentTeamData {
-  /** 团队名称 */
-  teamName: string
-  /** 团队配置 */
-  team: TeamConfig
-  /** 任务列表 */
-  tasks: TaskItem[]
-  /** 收件箱消息（agent 名称 → 消息列表） */
-  inboxes: Record<string, ParsedMailboxMessage[]>
-}
-
 // ===== IPC 通道常量 =====
 
 /**
@@ -826,8 +809,6 @@ export const AGENT_IPC_CHANNELS = {
   STOP_AGENT: 'agent:stop',
 
   // 后台任务管理
-  /** 获取任务输出 */
-  GET_TASK_OUTPUT: 'agent:get-task-output',
   /** 停止任务 */
   STOP_TASK: 'agent:stop-task',
 
@@ -849,6 +830,16 @@ export const AGENT_IPC_CHANNELS = {
   /** 切换工作区 Skill 启用/禁用 */
   TOGGLE_SKILL: 'agent:toggle-skill',
 
+  // 子代理管理
+  /** 获取工作区子代理列表 */
+  GET_AGENTS: 'agent:get-agents',
+  /** 获取工作区子代理目录绝对路径 */
+  GET_AGENTS_DIR: 'agent:get-agents-dir',
+  /** 删除工作区子代理 */
+  DELETE_AGENT: 'agent:delete-agent',
+  /** 切换工作区子代理启用/禁用 */
+  TOGGLE_AGENT: 'agent:toggle-agent',
+
   // 流式事件（主进程 → 渲染进程推送）
   /** Agent 流式事件 */
   STREAM_EVENT: 'agent:stream:event',
@@ -866,16 +857,16 @@ export const AGENT_IPC_CHANNELS = {
   GET_WORKSPACE_FILES_PATH: 'agent:get-workspace-files-path',
   /** 打开文件夹选择对话框 */
   OPEN_FOLDER_DIALOG: 'agent:open-folder-dialog',
-  /** 附加外部目录到 Agent 会话 */
-  ATTACH_DIRECTORY: 'agent:attach-directory',
-  /** 移除会话的附加目录 */
-  DETACH_DIRECTORY: 'agent:detach-directory',
-  /** 附加外部目录到工作区（所有会话共享） */
+  /** 打开文件或文件夹选择对话框（同时支持） */
+  OPEN_FILE_OR_FOLDER_DIALOG: 'agent:open-file-or-folder-dialog',
+  /** 关联外部目录到工作区（所有会话共享） */
   ATTACH_WORKSPACE_DIRECTORY: 'agent:attach-workspace-directory',
   /** 移除工作区的附加目录 */
   DETACH_WORKSPACE_DIRECTORY: 'agent:detach-workspace-directory',
   /** 获取工作区附加目录列表 */
   GET_WORKSPACE_DIRECTORIES: 'agent:get-workspace-directories',
+  /** 删除工作区的上传文件目录（workspace-files） */
+  DELETE_WORKSPACE_FILES: 'agent:delete-workspace-files',
 
   // 文件系统操作
   /** 获取 session 工作路径 */
@@ -904,6 +895,8 @@ export const AGENT_IPC_CHANNELS = {
   RENAME_ATTACHED_FILE: 'agent:rename-attached-file',
   /** 移动附加目录文件/目录（无工作区路径限制） */
   MOVE_ATTACHED_FILE: 'agent:move-attached-file',
+  /** 删除附加目录文件/空目录（无工作区路径限制） */
+  DELETE_ATTACHED_FILE: 'agent:delete-attached-file',
   /** 搜索工作区文件（用于 @ 引用） */
   SEARCH_WORKSPACE_FILES: 'agent:search-workspace-files',
 
@@ -929,9 +922,4 @@ export const AGENT_IPC_CHANNELS = {
   /** AskUser 响应（渲染进程 → 主进程） */
   ASK_USER_RESPOND: 'agent:ask-user:respond',
 
-  // Agent Teams 数据
-  /** 获取 Team 聚合数据（sdkSessionId → AgentTeamData | null） */
-  GET_TEAM_DATA: 'agent:get-team-data',
-  /** 读取 Teammate 输出文件（filePath → string） */
-  GET_AGENT_OUTPUT: 'agent:get-agent-output',
 } as const
diff --git a/packages/shared/src/types/channel.ts b/packages/shared/src/types/channel.ts
index f5220586..25b24e3f 100644
--- a/packages/shared/src/types/channel.ts
+++ b/packages/shared/src/types/channel.ts
@@ -5,6 +5,23 @@
  * API Key 使用 Electron safeStorage 加密后存储在本地配置文件中。
  */
 
+/**
+ * 渠道认证类型
+ *
+ * - api_key: 标准 API Key 认证（默认）
+ * - vertex: Google Vertex AI 认证（通过 ANTHROPIC_AUTH_TOKEN + Project ID）
+ * - bedrock: AWS Bedrock 认证（通过 AWS 凭证）
+ */
+export type ChannelAuthType = 'api_key' | 'vertex' | 'bedrock'
+
+/**
+ * 渠道来源
+ *
+ * - manual: 用户手动创建
+ * - local_env: 从本地环境变量自动检测
+ */
+export type ChannelSource = 'manual' | 'local_env'
+
 /**
  * 支持的 AI 供应商类型
  */
@@ -88,6 +105,15 @@ export interface Channel {
   createdAt: number
   /** 更新时间戳 */
   updatedAt: number
+  /** 认证类型（默认 'api_key'，向后兼容） */
+  authType?: ChannelAuthType
+  /** 渠道来源：'manual'（手动创建）| 'local_env'（自动检测） */
+  source?: ChannelSource
+  /**
+   * 额外环境变量（加密存储），用于 Vertex/Bedrock 等需要多个环境变量的渠道。
+   * key 为变量名，value 为加密后的 base64 字符串。
+   */
+  envVars?: Record<string, string>
 }
 
 /**
diff --git a/packages/shared/src/types/feishu.ts b/packages/shared/src/types/feishu.ts
index 4114ac27..4cec7b6d 100644
--- a/packages/shared/src/types/feishu.ts
+++ b/packages/shared/src/types/feishu.ts
@@ -58,6 +58,8 @@ export interface FeishuUpdateBindingInput {
 
 /** 飞书聊天 → Proma 会话绑定（内存态，不持久化） */
 export interface FeishuChatBinding {
+  /** 所属 Bot ID（多 Bot 隔离主键） */
+  botId: string
   /** 飞书 chat_id（单聊或群聊） */
   chatId: string
   /** 飞书用户 open_id */
@@ -66,7 +68,7 @@ export interface FeishuChatBinding {
   sessionId: string
   /** 绑定的工作区 ID */
   workspaceId: string
-  /** 渠道 ID */
+  /** Agent 渠道 ID */
   channelId: string
   /** 模型 ID */
   modelId?: string
@@ -184,9 +186,84 @@ export interface FeishuChatMessage {
   createTime: number
 }
 
+// ===== 多飞书 Bot 配置 =====
+
+/** 单个飞书 Bot 配置 */
+export interface FeishuBotConfig {
+  /** 唯一 ID */
+  id: string
+  /** Bot 名称（用户友好） */
+  name: string
+  /** 飞书应用 App ID */
+  appId: string
+  /** 飞书应用 App Secret（safeStorage 加密后的 base64 字符串） */
+  appSecret: string
+  /** 绑定的工作区 ID */
+  workspaceId: string
+  /** 是否启用 */
+  enabled: boolean
+  /** 创建时间（毫秒时间戳） */
+  createdAt: number
+}
+
+/** 飞书 Bots 配置（持久化到 ~/.proma/feishu-bots.json） */
+export interface FeishuBotsConfig {
+  /** 配置版本 */
+  version: number
+  /** Bot 列表 */
+  bots: FeishuBotConfig[]
+  /** 默认通知模式 */
+  defaultNotifyMode: FeishuNotifyMode
+}
+
+/** 保存 Bot 的输入（App Secret 为明文，主进程负责加密） */
+export interface FeishuBotConfigInput {
+  /** Bot 名称 */
+  name: string
+  /** 飞书应用 App ID */
+  appId: string
+  /** 明文 App Secret（空字符串表示不修改） */
+  appSecret: string
+  /** 绑定的工作区 ID */
+  workspaceId: string
+  /** 是否启用 */
+  enabled: boolean
+}
+
+// ===== Per-Agent Persona =====
+
+/** Agent 个性化配置文件 */
+export interface AgentPersona {
+  /** 机器人身份描述（AGENT.md） */
+  agentMd: string
+  /** 用户设定（USER.md） */
+  userMd: string
+  /** 机器人灵魂/性格（SOUL.md） */
+  soulMd: string
+  /** 长期记忆（MEMORY.md）- 决策、偏好、持久事实 */
+  memoryMd: string
+}
+
+// ===== Bot 状态 =====
+
+/** 单个 Bot 的连接状态 */
+export interface FeishuBotStatus {
+  /** Bot ID */
+  botId: string
+  /** 连接状态 */
+  status: FeishuBridgeStatus
+  /** 上次连接成功时间 */
+  connectedAt?: number
+  /** 错误信息 */
+  errorMessage?: string
+  /** 活跃绑定数量 */
+  activeBindings: number
+}
+
 // ===== IPC 通道常量 =====
 
 export const FEISHU_IPC_CHANNELS = {
+  // 旧版单 Bot 配置（兼容）
   /** 获取飞书配置 */
   GET_CONFIG: 'feishu:get-config',
   /** 保存飞书配置 */
@@ -215,4 +292,26 @@ export const FEISHU_IPC_CHANNELS = {
   SET_SESSION_NOTIFY: 'feishu:set-session-notify',
   /** 主进程 → 渲染进程：飞书通知已发送 */
   NOTIFICATION_SENT: 'feishu:notification-sent',
+
+  // 多 Bot 管理
+  /** 获取所有 Bots 配置 */
+  LIST_BOTS: 'feishu:list-bots',
+  /** 保存单个 Bot（新建或更新） */
+  SAVE_BOT: 'feishu:save-bot',
+  /** 删除 Bot */
+  DELETE_BOT: 'feishu:delete-bot',
+  /** 启动指定 Bot */
+  START_BOT: 'feishu:start-bot',
+  /** 停止指定 Bot */
+  STOP_BOT: 'feishu:stop-bot',
+  /** 获取指定 Bot 状态 */
+  GET_BOT_STATUS: 'feishu:get-bot-status',
+  /** Bot 状态变化（主进程 → 渲染进程推送） */
+  BOT_STATUS_CHANGED: 'feishu:bot-status-changed',
+  /** 获取 Agent persona 文件 */
+  GET_AGENT_PERSONA: 'feishu:get-agent-persona',
+  /** 保存 Agent persona 文件 */
+  SAVE_AGENT_PERSONA: 'feishu:save-agent-persona',
+  /** 使 persona 缓存失效 */
+  INVALIDATE_PERSONA_CACHE: 'feishu:invalidate-persona-cache',
 } as const
diff --git a/packages/shared/src/utils/capabilities-diff.test.ts b/packages/shared/src/utils/capabilities-diff.test.ts
index a966b751..4e16174b 100644
--- a/packages/shared/src/utils/capabilities-diff.test.ts
+++ b/packages/shared/src/utils/capabilities-diff.test.ts
@@ -10,6 +10,7 @@ function makeCaps(
   return {
     mcpServers: mcpServers.map((s) => ({ ...s, type: 'stdio' as const })),
     skills: skills.map((s) => ({ ...s })),
+    agents: [],
   }
 }
 
diff --git a/packages/ui/package.json b/packages/ui/package.json
index 16b26ba3..1e8cb78d 100644
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@proma/ui",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "license": "Apache-2.0",
   "description": "Shared UI components for proma",
   "type": "module",
diff --git a/packages/ui/src/code-block/CodeBlock.tsx b/packages/ui/src/code-block/CodeBlock.tsx
index 337931c2..51431040 100644
--- a/packages/ui/src/code-block/CodeBlock.tsx
+++ b/packages/ui/src/code-block/CodeBlock.tsx
@@ -209,7 +209,9 @@ export function CodeBlock({ children }: CodeBlockProps): React.ReactElement {
         // 初始化完成，用同步路径获取最新结果
         if (!cancelled) doHighlight()
       })
-      .catch((error) => console.error('[CodeBlock] 高亮失败:', error))
+      .catch(() => {
+        // 静默处理错误，降级模式会处理纯文本显示
+      })
 
     return () => { cancelled = true }
   }, [trimmedCode, langOrText])