diff --git a/.codex/web-interface-guidelines.md b/.codex/web-interface-guidelines.md
new file mode 100644
index 0000000..c6d1a90
--- /dev/null
+++ b/.codex/web-interface-guidelines.md
@@ -0,0 +1,180 @@
+---
+description: Review UI code for Vercel Web Interface Guidelines compliance
+argument-hint: <file-or-pattern>
+---
+
+# Web Interface Guidelines
+
+Review these files for compliance: $ARGUMENTS
+
+Read files, check against rules below. Output concise but comprehensive—sacrifice grammar for brevity. High signal-to-noise.
+
+## Rules
+
+### Accessibility
+
+- Icon-only buttons need `aria-label`
+- Form controls need `<label>` or `aria-label`
+- Interactive elements need keyboard handlers (`onKeyDown`/`onKeyUp`)
+- `<button>` for actions, `<a>`/`<Link>` for navigation (not `<div onClick>`)
+- Images need `alt` (or `alt=""` if decorative)
+- Decorative icons need `aria-hidden="true"`
+- Async updates (toasts, validation) need `aria-live="polite"`
+- Use semantic HTML (`<button>`, `<a>`, `<label>`, `<table>`) before ARIA
+- Headings hierarchical `<h1>`–`<h6>`; include skip link for main content
+- `scroll-margin-top` on heading anchors
+
+### Focus States
+
+- Interactive elements need visible focus: `focus-visible:ring-*` or equivalent
+- Never `outline-none` / `outline: none` without focus replacement
+- Use `:focus-visible` over `:focus` (avoid focus ring on click)
+- Group focus with `:focus-within` for compound controls
+
+### Forms
+
+- Inputs need `autocomplete` and meaningful `name`
+- Use correct `type` (`email`, `tel`, `url`, `number`) and `inputmode`
+- Never block paste (`onPaste` + `preventDefault`)
+- Labels clickable (`htmlFor` or wrapping control)
+- Disable spellcheck on emails, codes, usernames (`spellCheck={false}`)
+- Checkboxes/radios: label + control share single hit target (no dead zones)
+- Submit button stays enabled until request starts; spinner during request
+- Errors inline next to fields; focus first error on submit
+- Placeholders end with `…` and show example pattern
+- `autocomplete="off"` on non-auth fields to avoid password manager triggers
+- Warn before navigation with unsaved changes (`beforeunload` or router guard)
+
+### Animation
+
+- Honor `prefers-reduced-motion` (provide reduced variant or disable)
+- Animate `transform`/`opacity` only (compositor-friendly)
+- Never `transition: all`—list properties explicitly
+- Set correct `transform-origin`
+- SVG: transforms on `<g>` wrapper with `transform-box: fill-box; transform-origin: center`
+- Animations interruptible—respond to user input mid-animation
+
+### Typography
+
+- `…` not `...`
+- Curly quotes `"` `"` not straight `"`
+- Non-breaking spaces: `10&nbsp;MB`, `⌘&nbsp;K`, brand names
+- Loading states end with `…`: `"Loading…"`, `"Saving…"`
+- `font-variant-numeric: tabular-nums` for number columns/comparisons
+- Use `text-wrap: balance` or `text-pretty` on headings (prevents widows)
+
+### Content Handling
+
+- Text containers handle long content: `truncate`, `line-clamp-*`, or `break-words`
+- Flex children need `min-w-0` to allow text truncation
+- Handle empty states—don't render broken UI for empty strings/arrays
+- User-generated content: anticipate short, average, and very long inputs
+
+### Images
+
+- `<img>` needs explicit `width` and `height` (prevents CLS)
+- Below-fold images: `loading="lazy"`
+- Above-fold critical images: `priority` or `fetchpriority="high"`
+
+### Performance
+
+- Large lists (>50 items): virtualize (`virtua`, `content-visibility: auto`)
+- No layout reads in render (`getBoundingClientRect`, `offsetHeight`, `offsetWidth`, `scrollTop`)
+- Batch DOM reads/writes; avoid interleaving
+- Prefer uncontrolled inputs; controlled inputs must be cheap per keystroke
+- Add `<link rel="preconnect">` for CDN/asset domains
+- Critical fonts: `<link rel="preload" as="font">` with `font-display: swap`
+
+### Navigation & State
+
+- URL reflects state—filters, tabs, pagination, expanded panels in query params
+- Links use `<a>`/`<Link>` (Cmd/Ctrl+click, middle-click support)
+- Deep-link all stateful UI (if uses `useState`, consider URL sync via nuqs or similar)
+- Destructive actions need confirmation modal or undo window—never immediate
+
+### Touch & Interaction
+
+- `touch-action: manipulation` (prevents double-tap zoom delay)
+- `-webkit-tap-highlight-color` set intentionally
+- `overscroll-behavior: contain` in modals/drawers/sheets
+- During drag: disable text selection, `inert` on dragged elements
+- `autoFocus` sparingly—desktop only, single primary input; avoid on mobile
+
+### Safe Areas & Layout
+
+- Full-bleed layouts need `env(safe-area-inset-*)` for notches
+- Avoid unwanted scrollbars: `overflow-x-hidden` on containers, fix content overflow
+- Flex/grid over JS measurement for layout
+
+### Dark Mode & Theming
+
+- `color-scheme: dark` on `<html>` for dark themes (fixes scrollbar, inputs)
+- `<meta name="theme-color">` matches page background
+- Native `<select>`: explicit `background-color` and `color` (Windows dark mode)
+
+### Locale & i18n
+
+- Dates/times: use `Intl.DateTimeFormat` not hardcoded formats
+- Numbers/currency: use `Intl.NumberFormat` not hardcoded formats
+- Detect language via `Accept-Language` / `navigator.languages`, not IP
+- Brand names, code tokens, identifiers: wrap with `translate="no"` to prevent garbled auto-translation
+
+### Hydration Safety
+
+- Inputs with `value` need `onChange` (or use `defaultValue` for uncontrolled)
+- Date/time rendering: guard against hydration mismatch (server vs client)
+- `suppressHydrationWarning` only where truly needed
+
+### Hover & Interactive States
+
+- Buttons/links need `hover:` state (visual feedback)
+- Interactive states increase contrast: hover/active/focus more prominent than rest
+
+### Content & Copy
+
+- Active voice: "Install the CLI" not "The CLI will be installed"
+- Title Case for headings/buttons (Chicago style)
+- Numerals for counts: "8 deployments" not "eight"
+- Specific button labels: "Save API Key" not "Continue"
+- Error messages include fix/next step, not just problem
+- Second person; avoid first person
+- `&` over "and" where space-constrained
+
+### Anti-patterns (flag these)
+
+- `user-scalable=no` or `maximum-scale=1` disabling zoom
+- `onPaste` with `preventDefault`
+- `transition: all`
+- `outline-none` without focus-visible replacement
+- Inline `onClick` navigation without `<a>`
+- `<div>` or `<span>` with click handlers (should be `<button>`)
+- Images without dimensions
+- Large arrays `.map()` without virtualization
+- Form inputs without labels
+- Icon buttons without `aria-label`
+- Hardcoded date/number formats (use `Intl.*`)
+- `autoFocus` without clear justification
+
+## Output Format
+
+Group by file. Use `file:line` format (VS Code clickable). Terse findings.
+
+```text
+## src/Button.tsx
+
+src/Button.tsx:42 - icon button missing aria-label
+src/Button.tsx:18 - input lacks label
+src/Button.tsx:55 - animation missing prefers-reduced-motion
+src/Button.tsx:67 - transition: all → list properties
+
+## src/Modal.tsx
+
+src/Modal.tsx:12 - missing overscroll-behavior: contain
+src/Modal.tsx:34 - "..." → "…"
+
+## src/Card.tsx
+
+✓ pass
+```
+
+State issue + location. Skip explanation unless fix non-obvious. No preamble.
diff --git a/.codex/web-interface-guidelines.md.json b/.codex/web-interface-guidelines.md.json
new file mode 100644
index 0000000..01f8439
--- /dev/null
+++ b/.codex/web-interface-guidelines.md.json
@@ -0,0 +1,24 @@
+{
+  "schema_version": 2,
+  "tool": "web-craft-suite/fetch_web_guidelines.py",
+  "tool_version": "2.0.0",
+  "tool_sha256": "f3d56f1eb68cf36f25ed96bcebfc011f9e4a9bfe7ec42f8e7bf604e3df9ef1e9",
+  "generated_at": "2026-08-08T09:09:07.386778+00:00",
+  "run_id": "0945f220-ddc8-4e5c-9e4f-5d0f6939f3c8",
+  "source": "https://raw.githubusercontent.com/vercel-labs/web-interface-guidelines/main/command.md",
+  "repository": "vercel-labs/web-interface-guidelines",
+  "ref": "main",
+  "path": "command.md",
+  "commit_sha": "4e799d45c17aec1498c269287a83b9dba22b966b",
+  "immutable_source": "https://raw.githubusercontent.com/vercel-labs/web-interface-guidelines/4e799d45c17aec1498c269287a83b9dba22b966b/command.md",
+  "final_url": "https://raw.githubusercontent.com/vercel-labs/web-interface-guidelines/4e799d45c17aec1498c269287a83b9dba22b966b/command.md",
+  "fetched_at": "2026-08-08T09:09:07.386778+00:00",
+  "document": {
+    "path": "web-interface-guidelines.md",
+    "sha256": "eea73cb6dd46fee9faec9973e8e7fe198b5f07ec326f14d276a56e50287e1cab",
+    "bytes": 6939
+  },
+  "content_type": "text/plain",
+  "proxy_used": false,
+  "proxy_source": "none"
+}
diff --git a/.gitignore b/.gitignore
index c171442..b1812d1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,6 @@ resources/singbox/*/sing-box.exe
 .DS_Store
 *.log
 *.map
+
+# 多模态免费网关凭据：打包前由发布环境注入，绝不提交。
+resources/multimodal-gateway.json
diff --git a/AGENTS.md b/AGENTS.md
index db1d494..605a765 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,38 +1,38 @@
 <!-- codex-memory:start -->
 ## 项目记忆（Codex 插件市场自动维护 · 回答前据此 · 勿手动编辑本段）
 **关于用户 / 长期事实（务必遵守）**：
-- 与助手沟通用中文优先
-**当前状态**：已确认失败原因是后端优先选到了需59aiapi私有token的content_url，导致401；正确应选同一结果中的pulseaify mp4。已修改URL提取逻辑优先选择真实视频文件URL，并验证15秒结果可下载播放。
+- 跟AI/沟通用中文，给生成模型的提示词可中英混写。
+- 图片/视频节点统一 composer 风格
+- 背景采用浅色网格风格，控件用悬浮pill
+- 应用候选需按包身份精确匹配
+- 面板改随机用户名/密码/路径,写SQLite+bcrypt
+- 画布做成独立全屏工作台，采用 tldraw 轻量白板中性风格，支持全屏与可拖动缩放，不做聊天内大表单
+- 助手身份使用 kimi-k3
+**当前状态**：首条需求：你好
 **已定决策**：
-- 59aiapi content不直接下载
-- 不再优先使用video_url/content_url
-- 优先选.mp4等真实视频文件URL
-- URL提取不能误选任务API
-- 前端下载应优先使用 dataUrl
-- 下载受保护域名需带Bearer鉴权
-- Seedance 失败点在成品下载阶段
-- 本地craft-website技能已安装校验通过
-- URL 提取只认明确视频字段或文件
-- Seedance 成品下载需带鉴权
-- skill 源 SKILL.md 移除 version
-**下一步**：
-- 重启应用加载新代码后再测
-- 确认热更包含本次修改
-- 失败时查看seedance调试日志
-**关键文件**：/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/electron/lib/canvas.js、/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/renderer/catalog.json、/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/categories/前端/28773__craft-website.zip、/Users/mac/Documents/备份数据/ProjectDown/制作网站 skill/SKILL.md
+- 热更必须递增contentVersion，不能覆盖旧版本
+- 竖屏按9:16换算为1440×2560与2160×3840
+- 2K按2560×1440计算，4K按3840×2160计算。
+- 2K/4K仅对Seedance开放，Grok保持原有限制。
+- 热更版本递增为 1.5.82，避免复用旧版本。
+- Grok 继续保留 480p/720p/1080p，分辨率不扩展。
+- Seedance 支持 2K 和 4K 并透传请求。
+- 发布后验证manifest、bundle和SHA256
+- 2K/4K 是否生成取决于上游模型支持。
+- 模型目录压缩阈值设为 80%
 **历史话题（需其中细节时用下面命令检索）**：
-- 2026-07-19 Seedance视频下载失败修复
-- 2026-07-18 Grok视频比例选项补充
-- 2026-07-18 Grok传图与提示词约定
-- 2026-07-18 Seedance参数修复与热更状态
-- 2026-07-18 插件市场会话起始
-- 2026-07-18 gen-image 技能市场更新
-- 2026-07-18 修复 token 统计不准
-- 2026-07-17 调整语音连接入口位置
-- 2026-07-17 项目闲聊与广汉天气查询
-- 2026-07-17 项目任务待确认
-- 2026-07-17 修复 Codex token 计数
-- 2026-07-17 Respond to hello
+- 2026-08-15 你好
+- 2026-08-14 你好
+- 2026-08-14 简单问候
+- 2026-08-14 修复长会话执行与工具调用问题
+- 2026-08-13 codex-market-app 执行请求断开排查
+- 2026-08-12 确认助手身份与当前工作目录
+- 2026-08-12 修复工具箱路由切模型显示与关闭路由配置边界并发布热更
+- 2026-08-09 修复Windows端Codex会话记录恢复失败并发布热更
+- 2026-08-08 无实质技术内容的空对话
+- 2026-08-08 暂无实质技术内容的对话
+- 2026-08-08 暂无实质技术内容的对话
+- 2026-08-08 暂无实质技术内容的对话
 > 回答涉及本段未列出的历史细节前，先运行 `rg -n "关键词" /Users/mac/.codex/memory/31c67c70b625.md` 查证再答。
 <!-- codex-memory:end -->
 
diff --git a/CANVAS_SPEC.md b/CANVAS_SPEC.md
index 49c26ec..89436fb 100644
--- a/CANVAS_SPEC.md
+++ b/CANVAS_SPEC.md
@@ -52,8 +52,10 @@ canvasRun: (kind, params) => ipcRenderer.invoke("canvas-run", { kind, params }),
   - `endpointPath`：默认 `/v1/images/generations`，允许用户覆盖。
   - **图生图参考图**：`image`（用户上传的 base64 dataURL）→ 主进程 `uploadMedia()` 传图床换公网直链 → 塞进请求体字段 `refField`（默认 `image`，前端高级项可改）。上传失败直接返回 `{ok:false,error}`，不静默降级。流式与非流式两条 body 都带该字段。
   - 错误信息里带上**实际请求的 URL 和 model**，方便排查（如 404 时提示 `POST {url} model={model} → 404`）。
-- **video** `{ mode, prompt, model?, image?, lastFrameImage?, referenceImages?[], ratio?, quality?, seconds?, referenceField?, endpointPath? }` —— **Seedance 2.0**，使用新中转契约。
-  - Seedance 节点通过 CLMM 聚合中转提交，创建端点默认 `/v1/videos`；若分组 `baseUrl` 已以 `/v1` 结尾，拼接时不得产生重复的 `/v1/v1`。
+- **video** `{ mode, prompt, model?, image?, lastFrameImage?, referenceImages?[], ratio?, quality?, seconds?, referenceField?, endpointPath? }` —— **Seedance / Seedance V2**。
+  - 画布分组下拉会识别并优先展示 **Seedance V2**（名称含 `Seedance V2` / `seedance_v2`），与旧 Seedance/CLMM 分组并存。
+  - **Seedance V2** 走 Binghuo 原生：创建端点默认 `/v1/video/generations`，body 使用 `model/prompt/duration/ratio/resolution/images|start_frame|end_frame`。
+  - **旧 Seedance / CLMM** 继续走聚合契约：创建端点默认 `/v1/videos`；若分组 `baseUrl` 已以 `/v1` 结尾，拼接时不得产生重复的 `/v1/v1`。
   - 请求体遵循 CLMM 文档：`model`、`prompt`、`aspect_ratio`、`resolution`、`size`、`seconds`、`mySeconds`、`reference_image_urls`。模型包含 `-Ns` 时使用 `seconds:"1"`；包含 `-gz` 时将 `mySeconds` 固定为模型声明的 N 秒。
   - `mode`：`"text"` 只发送空参考图数组 | `"first"` 发送一张 `reference_image_urls` | `"firstlast"` 发送首尾两张 | `"reference"` 发送多张参考图。旧值 `"image"` 归一为 `"first"`。
   - 图片经 `resolveMat` 处理：`data:` 先上传图床换为公网 URL，`http(s)` 原样发送；上游请求中禁止出现 base64。
@@ -68,7 +70,7 @@ canvasRun: (kind, params) => ipcRenderer.invoke("canvas-run", { kind, params }),
 
 ### 前端节点表单要求（每个能力节点都要能配置）
 - **文生图节点**：提示词 + **模型输入框(带 datalist，可点“拉取模型”从 canvasModels 填充)** + **比例下拉**(1:1 / 16:9 / 9:16 / 4:3 / 3:4 / 3:2) + **清晰度下拉**(1K / 2K / 4K)（前端据此算出 `WxH`，长边：1K=1024,2K=2048,4K=4096，短边=长边×比例取整）+ 折叠的「高级」里放**接口地址**覆盖 + 运行 + 预览/报错。
-- **视频节点**：**模式下拉(图生视频/文生视频)** + 提示词 + 模型输入框(datalist+拉取) + 比例(16:9/9:16/1:1/4:3) + 分辨率(480p/720p/1080p) + 时长(可选 4s/6s/8s) + 高级(接口地址) + 运行 + 预览/报错。图生视频模式吃上游图，文生视频不需要。
+- **视频节点**：**模式下拉(图生视频/文生视频)** + 提示词 + 模型输入框(datalist+拉取) + 比例(16:9/9:16/1:1/4:3) + 分辨率(480p/720p/1080p/2K/4K) + 时长(可选 4s/6s/8s) + 高级(接口地址) + 运行 + 预览/报错。2K/4K 仅透传给中转，是否可用取决于所选 Seedance 模型；官方常规模型通常最高 1080p。图生视频模式吃上游图，文生视频不需要。
 - **TTS 节点**：文本 + 模型输入框 + 音色 + 格式(mp3/wav/opus) + 运行 + 预览。
 - 「拉取模型」按钮：调 `apic.canvasModels()`，把返回的 models 灌进所有模型输入框的 `<datalist>`；失败给 toast。
 - 预置示例(cvSeedSample)里，模型字段留空并加占位提示（如「填入你中转的图像模型，如 flux-pro」），避免又用聊天模型 404。
diff --git a/HANDOFF.md b/HANDOFF.md
index 912297b..5a08b02 100644
--- a/HANDOFF.md
+++ b/HANDOFF.md
@@ -3,65 +3,39 @@
 
 > 核心记忆已写进本项目 `AGENTS.md`（Codex 每次会话自动读）。本文件是更详细的近期快照，供需要时参考；关键信息不依赖本文件。
 
-## 最近会话 · 2026-07-19 08:05 · Seedance视频下载失败修复
+## 最近会话 · 2026-08-15 23:02 · 你好
 
-已确认失败原因是后端优先选到了需59aiapi私有token的content_url，导致401；正确应选同一结果中的pulseaify mp4。已修改URL提取逻辑优先选择真实视频文件URL，并验证15秒结果可下载播放。
+首条需求：你好
 
-**已确定的决策**：
-- 优先选.mp4等真实视频文件URL
-- 不再优先使用video_url/content_url
-- 59aiapi content不直接下载
-- 前端下载优先使用dataUrl
+## 更早会话 · 2026-08-14 07:41 · 你好
+
+首条需求：# Context from my IDE setup: ## Active file: electron/main.js ## Open tabs: - main.js: electron/main.js ## My request: 你好
+最后进展：在，小楼。有什么问题直接说。
+
+**涉及文件**：electron/main.js、main.js、renderer/app.js、/ProjectDown/codex-market-app/renderer/app.js、canvas.js、/ProjectDown/codex-market-app/electron/lib/canvas.js
+
+## 更早会话 · 2026-08-14 06:56 · 简单问候
+
+用户仅进行了两次问候，尚未提出具体项目需求或技术任务。
 
 **下一步**：
-- 重启应用加载新代码后再测
-- 确认热更包含本次修改
-- 失败时查看seedance调试日志
+- 等待用户提供具体需求
 
-**涉及文件**：/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/electron/lib/canvas.js、/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/renderer/catalog.json、/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/categories/前端/28773__craft-website.zip、/Users/mac/Documents/备份数据/ProjectDown/制作网站 skill/SKILL.md
+## 更早会话 · 2026-08-14 06:14 · 修复长会话执行与工具调用问题
 
-## 更早会话 · 2026-07-18 15:50 · Grok视频比例选项补充
-
-已为 Grok 视频节点补充视频格式/比例选择，并让后端按比例和分辨率组合生成真实 size。验证通过，旧画布节点可能仍需确认是否需要迁移已保存 HTML。
+已修复 DeepSeek/Kimi Chat 模式下工具调用参数转换、工具保留及长会话压缩配置问题，避免会话过长后只回复一句而不执行。DeepSeek 默认窗口 64K、Kimi 128K，压缩阈值为 80%，相关测试已全部通过（32/32）。token 统计位置和顶部全局代理入口尚未确认完成。
 
 **已确定的决策**：
-- Grok默认视频格式为16:9
-- 支持16:9、9:16、1:1、4:3、3:4
-- 后端用比例+分辨率生成size
-- 多参考图旧接口继续用aspect_ratio
+- 保留标准 function 工具及完整参数 schema
+- 多模态模式仅移除 view_image 工具
+- DeepSeek 默认窗口设为 64K
+- Kimi 默认窗口设为 128K
+- 模型目录压缩阈值设为 80%
 
 **下一步**：
-- 确认旧画布节点是否需迁移
-- 如需要则补节点恢复兼容逻辑
+- 定位并修复 token 统计进度条位置
+- 移除顶部全局代理模式入口
+- 回归验证 DeepSeek/Kimi 长会话执行
+- 确认 npm test 及界面功能均正常
 
-**涉及文件**：/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/renderer/app.js、/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/electron/lib/canvas.js
-
-## 更早会话 · 2026-07-18 15:36 · Grok传图与提示词约定
-
-Grok 首帧图生视频已按文档对齐：先上传到自家图床，再提交 `image.url` 形式的公网链接；前端比例选项也已补齐并完成 mock 验证。关于指令沟通，中文优先，外部生成模型用中英混写更稳。
-
-**已确定的决策**：
-- 与助手沟通用中文优先
-- 外部生成提示词可中英混写
-- Grok 首帧图先传图床再提交 `image.url`
-
-**涉及文件**：/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/electron/lib/canvas.js、/Users/mac/Documents/备份数据/ProjectDown/codex-market-app/renderer/app.js
-
-## 更早会话 · 2026-07-18 03:24 · Seedance参数修复与热更状态
-
-已修复 Seedance 新接口参数并真实生成成功，确认水印来自上游渠道且请求未发送 watermark。此前 token 进度条与本地 session 统计已改并发布热更 1.5.22，目标仓库为 mhgmh/codex-market-app，backup-bot 仅作上传账号。
-
-**已确定的决策**：
-- 热更目标仓库是 mhgmh/codex-market-app
-- backup-bot 仅作为上传认证账号
-- 热更 minAppVersion 固定为 1.5.0
-- Seedance 使用 /v1/video/generations
-- Seedance 模型当前为 seedance2.0
-- 水印由上游烧录，客户端不加水印
-
-**下一步**：
-- 确认上游是否支持 watermark:false
-- 如需上线 Seedance 修复，发布新热更
-- 必要时实测无水印参数一次
-
-**涉及文件**：electron/lib/token_inject.js、electron/lib/token_usage.js、electron/lib/token_watch.js、renderer/index.html、renderer/styles.css、renderer/app.js、CANVAS_SPEC.md、AGENTS.md
+**涉及文件**：electron/lib/translate.js、electron/lib/router.js
diff --git a/app.js b/app.js
index 3807549..d8e24be 100644
--- a/app.js
+++ b/app.js
@@ -665,6 +665,20 @@ async function sessLoad() {
   try {
     sessData = await apic.sessionsList(false);
     sessLoaded = true;
+    $("#sess-scope").textContent = "当前会话";
+    sessRender();
+  } catch (e) {
+    box.innerHTML = `<div class="empty">加载失败：${esc(e.message || e)}</div>`;
+  }
+}
+
+async function sessLoadAll() {
+  const box = $("#sess-list");
+  box.innerHTML = `<div class="empty"><div class="spinner"></div>加载全部记录…</div>`;
+  try {
+    sessData = await apic.sessionsList({ includeArchived: true, includeSubagent: true });
+    sessLoaded = true;
+    $("#sess-scope").textContent = "全部记录";
     sessRender();
   } catch (e) {
     box.innerHTML = `<div class="empty">加载失败：${esc(e.message || e)}</div>`;
@@ -676,6 +690,7 @@ $("#sess-refresh").addEventListener("click", sessLoad);
 document.querySelector('.tab[data-tab="sessions"]').addEventListener("click", () => {
   if (!sessLoaded) sessLoad();
 });
+$("#sess-fetch-all").addEventListener("click", sessLoadAll);
 $("#sess-export").addEventListener("click", async (ev) => {
   if (!sessCurrent) return;
   const btn = ev.currentTarget;
@@ -707,8 +722,9 @@ $("#sess-import").addEventListener("click", async (ev) => {
   try {
     const r = await apic.sessionsImport();
     if (!r.canceled) {
-      toast(`导入完成：新增 ${r.added}，跳过 ${r.skipped}`, "ok");
-      sessLoad();
+      toast(`恢复完成：新增 ${r.added}，跳过 ${r.skipped}，侧栏重建 ${r.catalogRebuilt || 0} 条 ✅`, "ok");
+      sessLoaded = false;
+      await sessLoad();
     }
   } catch (e) {
     toast(`导入失败：${e.message || e}`, "err");
@@ -1025,6 +1041,12 @@ function renderRouter(st) {
     claudeBtn.textContent = st.claudeApplied ? "取消接入 Claude Code" : "接入 Claude Code";
     claudeBtn.classList.toggle("ghost", !!st.claudeApplied);
   }
+  const codexBtn = $("#router-apply");
+  if (codexBtn) {
+    const applied = !!st.codexApplied;
+    codexBtn.textContent = applied ? "取消本地路由（恢复直连）" : "启用本地路由（高级）";
+    codexBtn.classList.toggle("ghost", applied);
+  }
 
   const box = $("#router-groups");
   if (!st.groups.length) {
@@ -1187,13 +1209,22 @@ $("#router-save-port").addEventListener("click", async () => {
   }
 });
 $("#router-apply").addEventListener("click", async (ev) => {
-  if (!confirm("将修改 Codex 的 config.toml，指向本地路由（会自动备份）。\n注意：启用后账号切换请统一在本软件切，不要再用 cc-switch，以免冲突。\n\n确认？")) return;
+  const applied = routerState && routerState.codexApplied;
+  const message = applied
+    ? "将取消本地路由，并立即从 Codex config.toml / auth.json 清除本工具写入的配置，恢复 Codex 原生登录直连。\n\n确认？"
+    : "将修改 Codex 的 config.toml，指向本地路由（会自动备份）。\n注意：启用后账号切换请统一在本软件切，不要再用 cc-switch，以免冲突。\n\n确认？";
+  if (!confirm(message)) return;
   const btn = ev.currentTarget;
-  busy(btn, true, "配置中…");
+  busy(btn, true, applied ? "取消中…" : "配置中…");
   try {
-    const r = await apic.routerApplyCodex();
+    const r = applied ? await apic.routerDisableCodex() : await apic.routerApplyCodex();
     renderRouter(r.status);
-    toast("已配置到 Codex ✅ 重启 Codex 后即可通过本地路由，之后切分组无需重启", "ok");
+    toast(
+      applied
+        ? "已取消本地路由 ✅ Codex 配置已恢复直连，重启 Codex 后生效"
+        : "已配置到 Codex ✅ 重启 Codex 后即可通过本地路由，之后切分组无需重启",
+      "ok"
+    );
   } catch (e) {
     toast("配置失败：" + (e.message || e), "err");
   } finally {
diff --git a/electron-builder.yml b/electron-builder.yml
index 92c88ad..e7d2dbb 100644
--- a/electron-builder.yml
+++ b/electron-builder.yml
@@ -31,6 +31,8 @@ mac:
   extraResources:
     - from: "resources/singbox/darwin-${arch}"
       to: "singbox/darwin-${arch}"
+    - from: "resources/multimodal-gateway.json"
+      to: "multimodal-gateway.json"
   category: public.app-category.developer-tools
   icon: build/icon.icns
   # —— 未购买 Apple Developer 账号 ——
@@ -78,6 +80,8 @@ win:
   extraResources:
     - from: "resources/singbox/windows-${arch}"
       to: "singbox/windows-${arch}"
+    - from: "resources/multimodal-gateway.json"
+      to: "multimodal-gateway.json"
   icon: build/icon.ico
   target:
     - target: nsis
@@ -93,6 +97,9 @@ nsis:
   createStartMenuShortcut: true
 
 linux:
+  extraResources:
+    - from: "resources/multimodal-gateway.json"
+      to: "multimodal-gateway.json"
   icon: build/icon.png
   category: Development
   target:
diff --git a/electron/lib/canvas.js b/electron/lib/canvas.js
index 66b105e..27ce327 100644
--- a/electron/lib/canvas.js
+++ b/electron/lib/canvas.js
@@ -22,18 +22,51 @@ function uniqStrings(list) {
   return Array.from(new Set((list || []).map((v) => String(v || "").trim()).filter(Boolean)));
 }
 
+function groupText(g) {
+  return `${(g && g.name) || ""} ${(g && g.model) || ""}`.toLowerCase();
+}
+
+function isSeedanceV2Model(model) {
+  return /^(?:bh2\.0-|sd2\.0-|sdvip|gz-sd)/i.test(String(model || "").trim());
+}
+
+function isSeedanceV2Group(g) {
+  const text = groupText(g);
+  return /seedance[\s_-]*v\s*2|seedancev2|seedance_v2/.test(text) || isSeedanceV2Model(g && g.model);
+}
+
+function isSeedanceGroup(g) {
+  return /seedance/.test(groupText(g));
+}
+
+function isGrokGroup(g) {
+  return /grok/.test(groupText(g));
+}
+
 function modelCandidatesForGroup(g) {
   const out = [];
   if (!g) return out;
   if (g.model) out.push(g.model);
   if (Array.isArray(g.oneMillionModels)) out.push(...g.oneMillionModels);
 
-  const name = String(g.name || "").toLowerCase();
-  const model = String(g.model || "").toLowerCase();
-  if (/grok/.test(name) || /grok/.test(model)) {
+  if (isGrokGroup(g)) {
     out.push("grok-video-1.5", "grok-imagine-video-1.5", "grok-imagine-video");
   }
-  if (/seedance/.test(name) || /seedance/.test(model)) {
+  if (isSeedanceV2Group(g)) {
+    out.push(
+      "bh2.0-fast-720p",
+      "bh2.0-720p",
+      "bh2.0-1080p",
+      "bh2.0-mini-720p",
+      "SD2.0-720P",
+      "SD2.0-720P-fast",
+      "SD2.0-1080P",
+      "sdvip720p",
+      "sdvip1080p",
+      "gz-sd720p",
+      "gz-sd1080p"
+    );
+  } else if (isSeedanceGroup(g)) {
     out.push("seedance2.0", "seedance-2.0");
   }
   return uniqStrings(out);
@@ -283,9 +316,10 @@ async function resolveMat(v) {
   throw new Error("素材需为 data URL 或公网 http(s) 地址");
 }
 
-// 当前中转是否可用：ready = 有可用 llmGroup。host 从 baseUrl 解析域名。
+// 当前中转是否可用：ready = 有可用分组。画布节点会按 groupId 显式选用插件专用分组。
 function status() {
-  const llm = router.llmGroup();
+  const usable = router.usableGroups();
+  const llm = router.llmGroup() || (usable && usable[0]);
   if (!llm) return { ready: false, provider: null, reason: "未配置可用中转分组" };
   return {
     ready: true,
@@ -836,17 +870,161 @@ async function runGrokVideoLegacy(base, llm, params) {
   }
 }
 
+// —— Seedance V2（Binghuo 原生）：POST /v1/video/generations + GET /v1/video/generations/:task_id ——
+// 对应 sub2api platform=seedance_v2，与 CLMM /v1/videos 契约分离，避免字段被改写。
+function seedanceV2EndpointPath(endpointPath) {
+  const path = String(endpointPath || "").trim();
+  if (!path) return "/v1/video/generations";
+  // 若用户仍填 CLMM 路径，也归一到 V2 原生路径（sub2api 两边都能进同一 handler，但原生更稳）
+  if (/\/v1\/videos(?:\/generations)?$/i.test(path) || /\/videos(?:\/generations)?$/i.test(path)) {
+    return "/v1/video/generations";
+  }
+  return path;
+}
+
+function seedanceV2DurationSeconds(params, model) {
+  const raw = Number.parseInt(String((params && params.seconds) || ""), 10);
+  if (Number.isInteger(raw) && raw > 0) return raw;
+  const fixed = String(model || "").match(/(?:^|[-_])(\d+)s(?:$|[-_])/i);
+  if (fixed) return Number(fixed[1]) || 5;
+  return 5;
+}
+
+async function runSeedanceV2(base, llm, params) {
+  const model = String(params.model || "").trim();
+  const prompt = String(params.prompt || "").trim();
+  if (!model) return { ok: false, error: "Seedance V2 必须选择模型完整名称" };
+  if (!prompt) return { ok: false, error: "Seedance V2 必须填写提示词" };
+
+  let mode = String(params.mode || "text");
+  if (mode === "image") mode = "first";
+
+  const body = {
+    model,
+    prompt,
+    duration: seedanceV2DurationSeconds(params, model),
+    ratio: String(params.ratio || params.aspectRatio || "16:9"),
+    resolution: clmmResolutionFromParamsV2(params),
+  };
+
+  try {
+    if (mode === "first") {
+      const image = await resolveMat(params.imageUrl || params.image);
+      if (!image) return { ok: false, error: "Seedance V2 首帧图生视频需要首帧图" };
+      body.start_frame = [image];
+    } else if (mode === "firstlast") {
+      const first = await resolveMat(params.imageUrl || params.image);
+      const last = await resolveMat(params.lastFrameImage);
+      if (!first || !last) return { ok: false, error: "首尾帧模式需要首帧和尾帧两张图片" };
+      body.start_frame = [first];
+      body.end_frame = [last];
+    } else if (mode === "reference") {
+      const materials = Array.isArray(params.referenceImages) ? params.referenceImages : [];
+      const refs = (await Promise.all(materials.map((item) => resolveMat(item)))).filter(Boolean);
+      if (!refs.length) return { ok: false, error: "多参考图模式至少需要 1 张参考图" };
+      body.images = refs;
+    } else if (mode !== "text") {
+      return { ok: false, error: "Seedance V2 暂不支持参考视频模式，请改用 文生 / 首帧 / 多参考图" };
+    }
+
+    const createUrl = joinUrl(base, seedanceV2EndpointPath(params.endpointPath));
+    const debugBase = {
+      base: hostOf(base),
+      create_url: createUrl,
+      mode,
+      request: {
+        model: body.model,
+        duration: body.duration,
+        ratio: body.ratio,
+        resolution: body.resolution,
+        image_count: Array.isArray(body.images) ? body.images.length : 0,
+        has_start_frame: Array.isArray(body.start_frame) && body.start_frame.length > 0,
+        has_end_frame: Array.isArray(body.end_frame) && body.end_frame.length > 0,
+      },
+    };
+    seedanceDebugLog({ type: "seedance_v2_video_create", ...debugBase });
+
+    const cres = await fetch(createUrl, {
+      method: "POST",
+      headers: headers(llm.key),
+      body: JSON.stringify(body),
+    });
+    const rawCreate = await cres.text().catch(() => "");
+    if (!cres.ok) {
+      seedanceDebugLog({ type: "seedance_v2_video_create_failed", ...debugBase, status: cres.status, detail: rawCreate.slice(0, 500) });
+      return { ok: false, error: `Seedance V2 建任务失败(${cres.status})：POST ${createUrl} → ${rawCreate.slice(0, 300)}` };
+    }
+
+    let data;
+    try {
+      data = JSON.parse(rawCreate);
+    } catch {
+      seedanceDebugLog({ type: "seedance_v2_video_create_non_json", ...debugBase, detail: rawCreate.slice(0, 500) });
+      return { ok: false, error: `Seedance V2 建任务返回非 JSON：${rawCreate.slice(0, 300)}` };
+    }
+    const taskId = pickTaskId(data);
+    if (!taskId) {
+      seedanceDebugLog({ type: "seedance_v2_video_missing_task_id", ...debugBase, response: JSON.stringify(data).slice(0, 500) });
+      return { ok: false, error: `Seedance V2 建任务未返回 task_id：${JSON.stringify(data).slice(0, 300)}` };
+    }
+    seedanceDebugLog({ type: "seedance_v2_video_accepted", ...debugBase, task_id: taskId });
+
+    // 原生路径：/v1/video/generations/:task_id
+    // 若 createUrl 是 /v1/videos，则沿 createUrl/:id 轮询（sub2api 也会路由到 V2 status）
+    const pollUrl = /\/generations$/i.test(createUrl.replace(/\/$/, ""))
+      ? createUrl.replace(/\/$/, "") + "/" + encodeURIComponent(taskId)
+      : createUrl.replace(/\/$/, "") + "/" + encodeURIComponent(taskId);
+    const pollHeaders = { Authorization: "Bearer " + (llm.key || ""), Accept: "application/json", "User-Agent": "codex-market" };
+    let lastPoll = "";
+    for (let i = 0; i < 300; i++) {
+      await sleep(i === 0 ? 1000 : 3000);
+      try {
+        const pr = await fetch(pollUrl, { headers: pollHeaders });
+        const rawPoll = await pr.text().catch(() => "");
+        if (!pr.ok) {
+          lastPoll = `HTTP ${pr.status}: ${rawPoll.slice(0, 200)}`;
+          continue;
+        }
+        const pd = JSON.parse(rawPoll);
+        const d = pd && pd.data && typeof pd.data === "object" && !Array.isArray(pd.data) ? pd.data : pd;
+        const st = normalizeVideoStatus((d && (d.status || d.state)) || (pd && pd.status));
+        lastPoll = "status=" + st;
+        if (st === "succeeded") {
+          const url = clmmVideoUrlV2(pd) || clmmVideoUrlV2(d);
+          if (!url) return { ok: false, error: `Seedance V2 任务完成但未找到视频地址：${JSON.stringify(pd).slice(0, 300)}` };
+          const b64 = await downloadAsBase64(url, trustedDownloadHeaders(url, llm));
+          seedanceDebugLog({ type: "seedance_v2_video_done", ...debugBase, task_id: taskId, url });
+          return { ok: true, mime: "video/mp4", dataUrl: toDataUrl("video/mp4", b64), url, _model: model };
+        }
+        if (st === "failed") {
+          const err = (d && d.error && (d.error.message || d.error)) || (d && (d.fail_reason || d.message || d.reason)) || (pd && pd.message) || st;
+          seedanceDebugLog({ type: "seedance_v2_video_failed", ...debugBase, task_id: taskId, status: st, response: rawPoll.slice(0, 500) });
+          return { ok: false, error: `Seedance V2 任务失败：${typeof err === "string" ? err : JSON.stringify(err)}` };
+        }
+      } catch (e) {
+        lastPoll = "请求异常：" + String((e && e.message) || e);
+      }
+    }
+    seedanceDebugLog({ type: "seedance_v2_video_timeout", ...debugBase, task_id: taskId, last_poll: lastPoll || "" });
+    return { ok: false, error: `Seedance V2 轮询 15 分钟未完成（task_id=${taskId}，最近一次：${lastPoll || "无"}）` };
+  } catch (e) {
+    return { ok: false, error: "Seedance V2 视频生成异常：" + String((e && e.message) || e) };
+  }
+}
+
 // —— CLMM 视频统一适配：Seedance/Grok 节点都通过中转的 /videos 契约提交 ——
 // 文档契约：POST /videos，字段使用 aspect_ratio/resolution/size/seconds/mySeconds/reference_image_urls。
 function clmmResolutionFromParamsV2(params) {
   const value = String(params.resolution || params.vsize || "720p").trim();
-  return /^(480|720|1080)p$/i.test(value) ? value : "720p";
+  // 2K/4K 由中转和具体模型决定是否可用；客户端只负责保留并透传。
+  return /^(480|720|1080)p$/i.test(value) || /^(2|4)k$/i.test(value) ? value.toLowerCase() : "720p";
 }
 
 function clmmSizeFromParamsV2(params, resolution) {
   const ratio = String(params.aspectRatio || params.ratio || "16:9").trim();
   const match = ratio.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
-  const shortSide = /1080/i.test(resolution) ? 1080 : /480/i.test(resolution) ? 480 : 720;
+  // 采用常见视频尺寸：2K=2560x1440，4K=3840x2160（横屏基准短边）。
+  const shortSide = /4k/i.test(resolution) ? 2160 : /2k/i.test(resolution) ? 1440 : /1080/i.test(resolution) ? 1080 : /480/i.test(resolution) ? 480 : 720;
   if (!match) return `${Math.round(shortSide * 16 / 9)}x${shortSide}`;
   const rw = Number(match[1]);
   const rh = Number(match[2]);
@@ -1016,7 +1194,14 @@ async function run({ kind, params }, onPartial) {
     let r;
     if (kind === "image") r = await runImage(base, g, p, onPartial);
     else if (kind === "tts") r = await runTts(base, g, p);
-    else if (kind === "video") r = await runClmmVideoV2(base, g, p, seedanceDebugLog, "Seedance");
+    else if (kind === "video") {
+      // Seedance V2 分组走 Binghuo 原生；旧 Seedance/CLMM 分组继续走 /v1/videos
+      const forceV2 = isSeedanceV2Model(p.model) || /seedance[\s_-]*v\s*2|seedancev2|\/v1\/video\/generations/i.test(
+        String(p.endpointPath || "") + " " + String(g.name || "") + " " + String(g.model || "")
+      );
+      if (forceV2 || isSeedanceV2Group(g)) r = await runSeedanceV2(base, g, p);
+      else r = await runClmmVideoV2(base, g, p, seedanceDebugLog, "Seedance");
+    }
     else if (kind === "grokVideo") r = await runClmmVideoV2(base, g, p, grokDebugLog, "Grok");
     else return { ok: false, error: "未知的画布任务类型：" + kind };
     const model = (r && r._model) || p.model || g.model;
@@ -1043,6 +1228,11 @@ function groups() {
       model: g.model || "",
       models: modelCandidatesForGroup(g),
       host: hostOf(g.baseUrl),
+      codexImage: !!g.codexImage,
+      codexVideo: !!g.codexVideo,
+      seedanceV2: isSeedanceV2Group(g),
+      seedance: isSeedanceGroup(g),
+      grok: isGrokGroup(g),
     })),
   };
 }
@@ -1066,4 +1256,12 @@ async function listModels(groupId) {
   }
 }
 
-module.exports = { status, groups, run, listModels, downloadAsBase64 };
+module.exports = {
+  status,
+  groups,
+  run,
+  listModels,
+  downloadAsBase64,
+  clmmResolutionFromParamsV2,
+  clmmSizeFromParamsV2,
+};
diff --git a/electron/lib/canvas_store.js b/electron/lib/canvas_store.js
new file mode 100644
index 0000000..8b12d24
--- /dev/null
+++ b/electron/lib/canvas_store.js
@@ -0,0 +1,303 @@
+// 创意画布本地项目库：画布结构与生成媒体分开保存，避免大体积 data URL 污染存档。
+const { app } = require("electron");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+const STORE_VERSION = 1;
+const ID_RE = /^[a-zA-Z0-9_-]{8,80}$/;
+const MEDIA_RE = /^[a-zA-Z0-9_.-]{8,180}$/;
+
+function rootDir() {
+  return path.join(app.getPath("userData"), "canvas-workspaces");
+}
+
+function indexPath() {
+  return path.join(rootDir(), "index.json");
+}
+
+function workspaceDir(id) {
+  assertId(id);
+  return path.join(rootDir(), id);
+}
+
+function workspacePath(id) {
+  return path.join(workspaceDir(id), "canvas.json");
+}
+
+function assertId(id) {
+  if (!ID_RE.test(String(id || ""))) throw new Error("非法画布标识");
+}
+
+function atomicWrite(file, content) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = file + "." + process.pid + ".tmp";
+  fs.writeFileSync(tmp, content);
+  try {
+    fs.renameSync(tmp, file);
+  } catch (err) {
+    // Windows 不一定允许 rename 覆盖现有文件，明确兜底后再完成替换。
+    if (process.platform !== "win32" || !["EEXIST", "EPERM", "EACCES"].includes(err && err.code)) {
+      try { fs.rmSync(tmp, { force: true }); } catch {}
+      throw err;
+    }
+    fs.rmSync(file, { force: true });
+    fs.renameSync(tmp, file);
+  }
+}
+
+async function atomicWriteAsync(file, content) {
+  await fs.promises.mkdir(path.dirname(file), { recursive: true });
+  const tmp = file + "." + process.pid + "." + Date.now() + ".tmp";
+  await fs.promises.writeFile(tmp, content);
+  try {
+    await fs.promises.rename(tmp, file);
+  } catch (err) {
+    if (process.platform !== "win32" || !["EEXIST", "EPERM", "EACCES"].includes(err && err.code)) {
+      try { await fs.promises.rm(tmp, { force: true }); } catch {}
+      throw err;
+    }
+    await fs.promises.rm(file, { force: true });
+    await fs.promises.rename(tmp, file);
+  }
+}
+
+function safeJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function normalizeTitle(value) {
+  const title = String(value || "未命名画布").replace(/[\r\n]+/g, " ").trim();
+  return (title || "未命名画布").slice(0, 60);
+}
+
+function readIndex() {
+  const data = safeJson(indexPath(), { version: STORE_VERSION, workspaces: [] });
+  const workspaces = Array.isArray(data.workspaces) ? data.workspaces : [];
+  return { version: STORE_VERSION, workspaces };
+}
+
+function writeIndex(index) {
+  atomicWrite(indexPath(), JSON.stringify(index, null, 2) + "\n");
+}
+
+function summary(workspace) {
+  const out = workspace && workspace.outputs && typeof workspace.outputs === "object" ? workspace.outputs : {};
+  const assetIds = new Set();
+  for (const value of Object.values(out)) {
+    if (value && value.assetId) assetIds.add(value.assetId);
+    for (const item of value && Array.isArray(value.history) ? value.history : []) {
+      if (item && item.assetId) assetIds.add(item.assetId);
+    }
+  }
+  const materials = workspace && workspace.materials && typeof workspace.materials === "object" ? workspace.materials : {};
+  for (const value of Object.values(materials)) {
+    if (!value || typeof value !== "object") continue;
+    for (const slot of ["image", "first", "last"]) {
+      if (value[slot] && value[slot].assetId) assetIds.add(value[slot].assetId);
+    }
+    for (const item of Array.isArray(value.refs) ? value.refs : []) {
+      if (item && item.assetId) assetIds.add(item.assetId);
+    }
+  }
+  const nodes = workspace && workspace.canvas && workspace.canvas.drawflow && workspace.canvas.drawflow.drawflow;
+  const data = nodes && nodes.Home && nodes.Home.data;
+  return { nodeCount: data ? Object.keys(data).length : 0, mediaCount: assetIds.size };
+}
+
+function updateIndex(workspace) {
+  const index = readIndex();
+  const meta = {
+    id: workspace.id,
+    name: normalizeTitle(workspace.name),
+    createdAt: workspace.createdAt,
+    updatedAt: workspace.updatedAt,
+    ...summary(workspace),
+  };
+  const existing = index.workspaces.findIndex((item) => item.id === meta.id);
+  if (existing >= 0) index.workspaces[existing] = meta;
+  else index.workspaces.push(meta);
+  index.workspaces.sort((a, b) => String(b.updatedAt || "").localeCompare(String(a.updatedAt || "")));
+  writeIndex(index);
+}
+
+function list() {
+  return readIndex().workspaces.sort((a, b) => String(b.updatedAt || "").localeCompare(String(a.updatedAt || "")));
+}
+
+function create(name) {
+  const now = new Date().toISOString();
+  const id = "cv_" + crypto.randomUUID().replace(/-/g, "");
+  const workspace = {
+    version: STORE_VERSION,
+    id,
+    name: normalizeTitle(name),
+    createdAt: now,
+    updatedAt: now,
+    canvas: { drawflow: { drawflow: { Home: { data: {} } } }, module: "Home", zoom: 1, canvasX: 0, canvasY: 0, addCount: 0 },
+    nodeState: {},
+    outputs: {},
+    materials: {},
+  };
+  atomicWrite(workspacePath(id), JSON.stringify(workspace, null, 2) + "\n");
+  updateIndex(workspace);
+  return workspace;
+}
+
+function load(id) {
+  assertId(id);
+  const workspace = safeJson(workspacePath(id), null);
+  if (!workspace || workspace.id !== id) throw new Error("画布记录不存在或已损坏");
+  return workspace;
+}
+
+function rename(id, name) {
+  assertId(id);
+  const title = String(name || "").replace(/[\r\n]+/g, " " ).trim();
+  if (!title) throw new Error("画布名称不能为空");
+  const workspace = load(id);
+  workspace.name = normalizeTitle(title);
+  workspace.updatedAt = new Date().toISOString();
+  atomicWrite(workspacePath(id), JSON.stringify(workspace, null, 2) + "\n");
+  updateIndex(workspace);
+  return { id, name: workspace.name, updatedAt: workspace.updatedAt, ...summary(workspace) };
+}
+
+function save(payload) {
+  if (!payload || typeof payload !== "object") throw new Error("画布保存数据无效");
+  assertId(payload.id);
+  const previous = load(payload.id);
+  const now = new Date().toISOString();
+  const workspace = {
+    version: STORE_VERSION,
+    id: payload.id,
+    name: normalizeTitle(payload.name || previous.name),
+    createdAt: previous.createdAt || now,
+    updatedAt: now,
+    canvas: payload.canvas && typeof payload.canvas === "object" ? payload.canvas : previous.canvas,
+    nodeState: payload.nodeState && typeof payload.nodeState === "object" ? payload.nodeState : {},
+    outputs: payload.outputs && typeof payload.outputs === "object" ? payload.outputs : {},
+    materials: payload.materials && typeof payload.materials === "object" ? payload.materials : {},
+  };
+  atomicWrite(workspacePath(workspace.id), JSON.stringify(workspace, null, 2) + "\n");
+  updateIndex(workspace);
+  return { id: workspace.id, name: workspace.name, updatedAt: workspace.updatedAt, ...summary(workspace) };
+}
+
+function dataUrlParts(dataUrl) {
+  const match = /^data:([^;,]+)?(;base64)?,(.*)$/is.exec(String(dataUrl || ""));
+  if (!match) throw new Error("媒体缓存失败：非法 data URL");
+  const mime = match[1] || "application/octet-stream";
+  const data = Buffer.from(match[3], match[2] ? "base64" : "utf8");
+  if (!data.length) throw new Error("媒体缓存失败：内容为空");
+  return { mime, data };
+}
+
+function extension(mime, kind) {
+  if (/png/i.test(mime)) return "png";
+  if (/jpe?g/i.test(mime)) return "jpg";
+  if (/webp/i.test(mime)) return "webp";
+  if (/gif/i.test(mime)) return "gif";
+  if (/mp4/i.test(mime) || kind === "video" || kind === "grokVideo") return "mp4";
+  if (/wav/i.test(mime)) return "wav";
+  if (/ogg|opus/i.test(mime)) return "opus";
+  if (/mpeg|mp3/i.test(mime) || kind === "tts") return "mp3";
+  return "bin";
+}
+
+function mergeOutputs(snapshotOutputs, storedOutputs) {
+  return {
+    ...(snapshotOutputs && typeof snapshotOutputs === "object" ? snapshotOutputs : {}),
+    ...(storedOutputs && typeof storedOutputs === "object" ? storedOutputs : {}),
+  };
+}
+
+function mergeMaterials(snapshotMaterials, storedMaterials) {
+  const snapshot = snapshotMaterials && typeof snapshotMaterials === "object" ? snapshotMaterials : {};
+  const stored = storedMaterials && typeof storedMaterials === "object" ? storedMaterials : {};
+  const merged = { ...snapshot };
+  for (const [nodeId, storedRefs] of Object.entries(stored)) {
+    const snapshotRefs = snapshot[nodeId] && typeof snapshot[nodeId] === "object" ? snapshot[nodeId] : {};
+    const diskRefs = storedRefs && typeof storedRefs === "object" ? storedRefs : {};
+    const refs = [];
+    const seen = new Set();
+    for (const item of [...(Array.isArray(snapshotRefs.refs) ? snapshotRefs.refs : []), ...(Array.isArray(diskRefs.refs) ? diskRefs.refs : [])]) {
+      if (!item || !item.assetId || seen.has(item.assetId)) continue;
+      seen.add(item.assetId);
+      refs.push(item);
+    }
+    merged[nodeId] = { ...snapshotRefs, ...diskRefs, refs };
+  }
+  return merged;
+}
+
+async function cacheMedia({ workspaceId, nodeId, kind, dataUrl, role, slot, sourceUrl, meta, workspaceState }) {
+  assertId(workspaceId);
+  if (!/^\d+$/.test(String(nodeId || ""))) throw new Error("非法节点标识");
+  const { mime, data } = dataUrlParts(dataUrl);
+  const hash = crypto.createHash("sha256").update(data).digest("hex").slice(0, 16);
+  const assetId = `node-${nodeId}-${Date.now()}-${hash}.${extension(mime, kind)}`;
+  const file = path.join(workspaceDir(workspaceId), "media", assetId);
+  await atomicWriteAsync(file, data);
+  // 文件写入期间可能触发画布自动保存。落盘后重新读取，始终从最新存档合并媒体索引。
+  const previous = load(workspaceId);
+  const workspace = workspaceState && workspaceState.id === workspaceId
+    ? {
+        ...previous,
+        name: normalizeTitle(workspaceState.name || previous.name),
+        canvas: workspaceState.canvas || previous.canvas,
+        nodeState: workspaceState.nodeState || previous.nodeState,
+        outputs: mergeOutputs(workspaceState.outputs, previous.outputs),
+        materials: mergeMaterials(workspaceState.materials, previous.materials),
+      }
+    : previous;
+  const ref = { assetId };
+  if (role === "output") {
+    workspace.outputs = workspace.outputs && typeof workspace.outputs === "object" ? workspace.outputs : {};
+    const previousOutput = workspace.outputs[nodeId];
+    const history = previousOutput && Array.isArray(previousOutput.history) ? previousOutput.history.slice() : [];
+    if (previousOutput && previousOutput.assetId && previousOutput.assetId !== assetId) {
+      history.push({
+        kind: previousOutput.kind,
+        assetId: previousOutput.assetId,
+        sourceUrl: previousOutput.sourceUrl || "",
+        meta: previousOutput.meta || {},
+        cachedAt: previousOutput.cachedAt || workspace.updatedAt || workspace.createdAt,
+      });
+    }
+    workspace.outputs[nodeId] = {
+      kind, assetId, sourceUrl: String(sourceUrl || ""),
+      meta: meta && typeof meta === "object" ? meta : {},
+      cachedAt: new Date().toISOString(),
+      history,
+    };
+  } else if (role === "material") {
+    workspace.materials = workspace.materials && typeof workspace.materials === "object" ? workspace.materials : {};
+    const refs = (workspace.materials[nodeId] = workspace.materials[nodeId] || { refs: [] });
+    if (slot === "refs") refs.refs = (Array.isArray(refs.refs) ? refs.refs : []).concat(ref);
+    else if (["image", "first", "last"].includes(slot)) refs[slot] = ref;
+  }
+  if (role === "output" || role === "material") {
+    workspace.updatedAt = new Date().toISOString();
+    atomicWrite(workspacePath(workspaceId), JSON.stringify(workspace, null, 2) + "\n");
+    updateIndex(workspace);
+  }
+  return { assetId, mime, bytes: data.length };
+}
+
+async function readMedia({ workspaceId, assetId }) {
+  assertId(workspaceId);
+  if (!MEDIA_RE.test(String(assetId || ""))) throw new Error("非法媒体标识");
+  const file = path.join(workspaceDir(workspaceId), "media", assetId);
+  try { await fs.promises.access(file, fs.constants.R_OK); }
+  catch { throw new Error("本地缓存媒体不存在"); }
+  const ext = path.extname(assetId).slice(1).toLowerCase();
+  const mime = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp", gif: "image/gif", mp4: "video/mp4", wav: "audio/wav", mp3: "audio/mpeg", opus: "audio/opus" }[ext] || "application/octet-stream";
+  return { dataUrl: `data:${mime};base64,${(await fs.promises.readFile(file)).toString("base64")}`, mime };
+}
+
+module.exports = { list, create, load, rename, save, cacheMedia, readMedia };
diff --git a/electron/lib/codex.js b/electron/lib/codex.js
index 022e2bc..04e4441 100644
--- a/electron/lib/codex.js
+++ b/electron/lib/codex.js
@@ -3,11 +3,19 @@
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
+const codexDataDir = require("./codex_data_dir");
 
-const CODEX_HOME = path.join(os.homedir(), ".codex");
-const CONFIG_PATH = path.join(CODEX_HOME, "config.toml");
+const DEFAULT_CODEX_HOME = path.join(os.homedir(), ".codex");
 const ENABLED_FILE = "enabled-plugins.toml"; // 备份包里记录启用状态的文件名
 
+function getCodexHome() {
+  try { return codexDataDir.get(); } catch { return DEFAULT_CODEX_HOME; }
+}
+
+function getConfigPath() {
+  return path.join(getCodexHome(), "config.toml");
+}
+
 // 打包时【绝对排除】的隐私 / 垃圾文件（就算勾了也不会被打包上传）
 const BLOCKLIST_NAMES = new Set([
   "auth.json",
@@ -172,8 +180,9 @@ function configPluginHeaders(text) {
 
 // 把选中插件在本机的启用状态，写进备份包的 enabled-plugins.toml。返回记录的 keys。
 function writeEnabledFile(selected, staging) {
-  const srcText = fs.existsSync(CONFIG_PATH)
-    ? fs.readFileSync(CONFIG_PATH, "utf-8")
+  const configPath = getConfigPath();
+  const srcText = fs.existsSync(configPath)
+    ? fs.readFileSync(configPath, "utf-8")
     : "";
   const enabledNow = configPluginHeaders(srcText);
   const keys = selected
@@ -308,9 +317,10 @@ function packageItems(selected, staging, log) {
 function enablePluginsInConfig(keys, log) {
   keys = keys.filter((k) => k);
   if (!keys.length) return;
-  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
-  let text = fs.existsSync(CONFIG_PATH)
-    ? fs.readFileSync(CONFIG_PATH, "utf-8")
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  let text = fs.existsSync(configPath)
+    ? fs.readFileSync(configPath, "utf-8")
     : "";
   const existing = configPluginHeaders(text);
   const toAdd = keys.filter((k) => !existing.has(k));
@@ -319,9 +329,9 @@ function enablePluginsInConfig(keys, log) {
     return;
   }
   // 备份
-  if (fs.existsSync(CONFIG_PATH)) {
-    const bak = CONFIG_PATH + ".bak-exporter"; // config.toml.bak-exporter
-    fs.copyFileSync(CONFIG_PATH, bak);
+  if (fs.existsSync(configPath)) {
+    const bak = configPath + ".bak-exporter"; // config.toml.bak-exporter
+    fs.copyFileSync(configPath, bak);
     log(`  已备份 config.toml -> ${path.basename(bak)}`);
   }
   if (text && !text.endsWith("\n")) {
@@ -333,14 +343,15 @@ function enablePluginsInConfig(keys, log) {
     blocks.push("enabled = true");
     blocks.push("");
   }
-  fs.writeFileSync(CONFIG_PATH, text + blocks.join("\n"), "utf-8");
+  fs.writeFileSync(configPath, text + blocks.join("\n"), "utf-8");
   log(`  已在 config.toml 启用 ${toAdd.length} 个插件：${toAdd.join(", ")}`);
 }
 
 // 把选中的（来自 clone 的）项拷回 ~/.codex，并可选地在 config.toml 里启用插件。
 function restoreItems(selected, log, enable = true) {
+  const codexHome = getCodexHome();
   for (const it of selected) {
-    const dst = path.join(CODEX_HOME, it.rel);
+    const dst = path.join(codexHome, it.rel);
     fs.mkdirSync(path.dirname(dst), { recursive: true });
     log(`  还原 ${it.category}: ${it.name}  -> ${dst}`);
     copyClean(it.path, dst);
@@ -352,9 +363,8 @@ function restoreItems(selected, log, enable = true) {
   log("还原完成 ✅ 重启 codex 生效");
 }
 
-module.exports = {
-  CODEX_HOME,
-  CONFIG_PATH,
+const api = {
+  getCodexHome,
   ENABLED_FILE,
   humanSize,
   dirSize,
@@ -366,3 +376,8 @@ module.exports = {
   enablePluginsInConfig,
   restoreItems,
 };
+
+Object.defineProperty(api, "CODEX_HOME", { enumerable: true, get: getCodexHome });
+Object.defineProperty(api, "CONFIG_PATH", { enumerable: true, get: getConfigPath });
+
+module.exports = api;
diff --git a/electron/lib/codex_data_dir.js b/electron/lib/codex_data_dir.js
new file mode 100644
index 0000000..36f40bc
--- /dev/null
+++ b/electron/lib/codex_data_dir.js
@@ -0,0 +1,94 @@
+// codex_data_dir.js —— 会话相关功能使用的 Codex 数据目录，可由用户覆盖默认 ~/.codex。
+const { app } = require("electron");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const DEFAULT_DIR = path.join(os.homedir(), ".codex");
+let loaded = false;
+let configuredDir = null;
+
+function configFile() {
+  return path.join(app.getPath("userData"), "codex-data-dir.json");
+}
+
+function normalize(dir) {
+  if (typeof dir !== "string" || !dir.trim() || !path.isAbsolute(dir.trim())) return null;
+  return path.resolve(dir.trim());
+}
+
+function load() {
+  if (loaded) return;
+  loaded = true;
+  try {
+    configuredDir = normalize(JSON.parse(fs.readFileSync(configFile(), "utf-8")).path);
+  } catch {}
+}
+
+function get() {
+  load();
+  return configuredDir || DEFAULT_DIR;
+}
+
+function isCodexDataDir(dir) {
+  try {
+    const names = fs.readdirSync(dir);
+    return names.includes("sessions") || names.includes("archived_sessions") || names.includes("config.toml") ||
+      names.includes("auth.json") || names.some((name) => /^state_.*\.sqlite(?:-(?:wal|shm))?$/.test(name));
+  } catch {
+    return false;
+  }
+}
+
+function isDirectory(dir) {
+  try {
+    return fs.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function writeAtomic(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = file + ".tmp-" + process.pid + "-" + Date.now();
+  const fd = fs.openSync(tmp, "w", 0o600);
+  try {
+    fs.writeFileSync(fd, text, "utf-8");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try {
+    fs.renameSync(tmp, file);
+  } finally {
+    try { fs.rmSync(tmp, { force: true }); } catch {}
+  }
+}
+
+function set(dir) {
+  const next = normalize(dir);
+  if (!next || !isDirectory(next)) {
+    throw new Error("请选择存在的 Codex 数据目录");
+  }
+  if (!isCodexDataDir(next)) {
+    throw new Error("所选目录未找到 Codex 数据（sessions、config.toml 或 state_*.sqlite）");
+  }
+  configuredDir = next === DEFAULT_DIR ? null : next;
+  loaded = true;
+  writeAtomic(configFile(), JSON.stringify({ path: configuredDir || "", updatedAt: new Date().toISOString() }, null, 2));
+  return info();
+}
+
+function reset() {
+  configuredDir = null;
+  loaded = true;
+  writeAtomic(configFile(), JSON.stringify({ path: "", updatedAt: new Date().toISOString() }, null, 2));
+  return info();
+}
+
+function info() {
+  const dir = get();
+  return { path: dir, isDefault: dir === DEFAULT_DIR, exists: isDirectory(dir) };
+}
+
+module.exports = { get, set, reset, info, isCodexDataDir };
diff --git a/electron/lib/codex_desktop.js b/electron/lib/codex_desktop.js
new file mode 100644
index 0000000..97ffe95
--- /dev/null
+++ b/electron/lib/codex_desktop.js
@@ -0,0 +1,537 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFile, execFileSync } = require("child_process");
+
+const EXE_NAMES = process.platform === "win32"
+  ? ["ChatGPT.exe", "Codex.exe", "OpenAI ChatGPT.exe", "ChatGPT Desktop.exe", "Codex Desktop.exe"]
+  : ["ChatGPT", "Codex"];
+
+const WIN_PROCESS_NAMES = EXE_NAMES.filter((n) => /\.exe$/i.test(n));
+let lastDiscovery = null;
+
+function existsFile(p) {
+  try {
+    return !!p && fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isWindowsPackagedPath(p) {
+  return process.platform === "win32" && /[\\/]WindowsApps[\\/]|[\\/]Program Files[\\/]WindowsApps[\\/]/i.test(String(p || ""));
+}
+
+function isOwnWindowsAppCandidate(name, appId) {
+  const hay = [name, appId].filter(Boolean).join(" ");
+  return /tokendun|codexmarket|codex-market|td工具箱|td toolbox|插件市场|技能市场/i.test(hay);
+}
+
+function isOpenAiDesktopCandidate(name, appId) {
+  if (isOwnWindowsAppCandidate(name, appId)) return false;
+  const n = String(name || "").trim();
+  const hay = [name, appId].filter(Boolean).join(" ");
+  return /openai|chatgpt/i.test(hay) || /(^|[^a-z])codex([^a-z]|$)/i.test(n);
+}
+
+function addCandidate(out, seen, label, p, opts = {}) {
+  if (!p) return;
+  if (opts.launchType === "appId") {
+    const appId = String(opts.appId || p || "").trim();
+    if (!appId || isOwnWindowsAppCandidate(opts.name || "", appId)) return;
+    const key = "appid:" + appId.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ label, path: appId, appId, name: opts.name || "", launchType: "appId", packaged: true });
+    return;
+  }
+  let abs = "";
+  try {
+    abs = path.resolve(p);
+  } catch {
+    return;
+  }
+  const key = process.platform === "win32" ? abs.toLowerCase() : abs;
+  if (seen.has(key) || !existsFile(abs)) return;
+  seen.add(key);
+  out.push({
+    label,
+    path: abs,
+    launchType: opts.launchType || "exe",
+    packaged: !!opts.packaged || isWindowsPackagedPath(abs),
+  });
+}
+
+function addChecked(report, p) {
+  if (!report || !p) return;
+  try {
+    report.checkedPaths.push(path.resolve(p));
+  } catch {}
+}
+
+function shouldScanDir(name, depth) {
+  if (!name) return false;
+  if (/^(programs)$/i.test(name)) return true;
+  if (/codex|chatgpt|openai/i.test(name)) return true;
+  return depth === 0 && process.platform !== "win32";
+}
+
+function scanDirForExecutables(base, out, seen, opts = {}) {
+  const maxDepth = opts.maxDepth == null ? 4 : opts.maxDepth;
+  const maxEntries = opts.maxEntries == null ? 400 : opts.maxEntries;
+  const maxHits = opts.maxHits == null ? 12 : opts.maxHits;
+  const report = opts.report || null;
+  const targetNames = new Set(EXE_NAMES.map((n) => process.platform === "win32" ? n.toLowerCase() : n));
+  let visited = 0;
+  if (report && base) report.scannedRoots.push(base);
+
+  function walk(dir, depth) {
+    if (!dir || depth > maxDepth || out.length >= maxHits || visited >= maxEntries) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    visited += entries.length;
+    for (const ent of entries) {
+      if (out.length >= maxHits) return;
+      const full = path.join(dir, ent.name);
+      const entName = process.platform === "win32" ? ent.name.toLowerCase() : ent.name;
+      if (ent.isFile() && targetNames.has(entName)) {
+        addCandidate(out, seen, "ChatGPT/Codex 桌面程序（扫描）", full);
+        continue;
+      }
+      if (ent.isDirectory() && depth < maxDepth && shouldScanDir(ent.name, depth)) {
+        walk(full, depth + 1);
+      }
+    }
+  }
+
+  walk(base, 0);
+}
+
+function psJson(script, timeout = 3500) {
+  if (process.platform !== "win32") return null;
+  const shells = ["powershell.exe", "pwsh.exe"];
+  for (const shell of shells) {
+    try {
+      const out = execFileSync(shell, ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
+        encoding: "utf-8",
+        windowsHide: true,
+        timeout,
+      }).trim();
+      if (!out) return null;
+      return JSON.parse(out);
+    } catch {}
+  }
+  return null;
+}
+
+function resolveWindowsShortcut(lnkPath) {
+  if (process.platform !== "win32" || !lnkPath) return null;
+  const script = [
+    "$p=$env:TD_LNK_PATH",
+    "$s=(New-Object -ComObject WScript.Shell).CreateShortcut($p)",
+    "$o=[pscustomobject]@{TargetPath=$s.TargetPath;Arguments=$s.Arguments;WorkingDirectory=$s.WorkingDirectory}",
+    "$o|ConvertTo-Json -Compress",
+  ].join(";");
+  const shells = ["powershell.exe", "pwsh.exe"];
+  for (const shell of shells) {
+    try {
+      const out = execFileSync(shell, ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
+        encoding: "utf-8",
+        env: { ...process.env, TD_LNK_PATH: lnkPath },
+        windowsHide: true,
+        timeout: 2500,
+      }).trim();
+      if (!out) return null;
+      return JSON.parse(out);
+    } catch {}
+  }
+  return null;
+}
+
+function collectWindowsShortcuts(base, out, opts = {}) {
+  if (process.platform !== "win32" || !base) return;
+  const maxDepth = opts.maxDepth == null ? 5 : opts.maxDepth;
+  const maxEntries = opts.maxEntries == null ? 900 : opts.maxEntries;
+  const maxHits = opts.maxHits == null ? 24 : opts.maxHits;
+  let visited = 0;
+
+  function walk(dir, depth) {
+    if (!dir || depth > maxDepth || out.length >= maxHits || visited >= maxEntries) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    visited += entries.length;
+    for (const ent of entries) {
+      if (out.length >= maxHits) return;
+      const full = path.join(dir, ent.name);
+      if (ent.isFile() && /\.lnk$/i.test(ent.name) && /codex|chatgpt|openai/i.test(ent.name)) {
+        out.push(full);
+        continue;
+      }
+      if (ent.isDirectory() && depth < maxDepth && shouldScanDir(ent.name, depth)) {
+        walk(full, depth + 1);
+      }
+    }
+  }
+
+  walk(base, 0);
+}
+
+function addSquirrelShortcutTargets(out, seen, report, shortcut, targetPath, args) {
+  if (!targetPath || !/update\.exe$/i.test(path.basename(targetPath || ""))) return;
+  const m = String(args || "").match(/--processStart\s+(?:"([^"]+)"|([^\s]+))/i);
+  const exeName = (m && (m[1] || m[2])) || "";
+  if (!exeName || !/\.exe$/i.test(exeName)) return;
+  const root = path.dirname(targetPath);
+  let entries = [];
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const appDirs = entries
+    .filter((ent) => ent.isDirectory() && /^app-/i.test(ent.name))
+    .map((ent) => path.join(root, ent.name))
+    .sort()
+    .reverse();
+  for (const dir of appDirs) {
+    const exe = path.join(dir, exeName);
+    addChecked(report, exe);
+    addCandidate(out, seen, "ChatGPT/Codex 桌面程序（开始菜单快捷方式）", exe);
+  }
+  if (report) report.shortcutTargets.push({ shortcut, targetPath, args: args || "", inferred: exeName });
+}
+
+function addWindowsShortcutCandidates(out, seen, report, roots) {
+  const shortcuts = [];
+  for (const root of roots.filter(Boolean)) collectWindowsShortcuts(root, shortcuts);
+  for (const lnk of shortcuts) {
+    if (report) report.shortcuts.push(lnk);
+    const resolved = resolveWindowsShortcut(lnk);
+    if (!resolved) continue;
+    const targetPath = resolved.TargetPath || resolved.targetPath || "";
+    const args = resolved.Arguments || resolved.arguments || "";
+    if (report) report.shortcutTargets.push({ shortcut: lnk, targetPath, args });
+    if (targetPath && /\.exe$/i.test(targetPath) && !/update\.exe$/i.test(path.basename(targetPath))) {
+      addChecked(report, targetPath);
+      addCandidate(out, seen, "ChatGPT/Codex 桌面程序（开始菜单快捷方式）", targetPath);
+      continue;
+    }
+    addSquirrelShortcutTargets(out, seen, report, lnk, targetPath, args);
+  }
+}
+
+function addWindowsAppxCandidates(out, seen, report) {
+  const script = [
+    "$startApps=Get-StartApps | Where-Object { $_.Name -match 'ChatGPT|Codex|OpenAI' -or $_.AppID -match 'ChatGPT|Codex|OpenAI' }",
+    "$startRows=@()",
+    "foreach($a in $startApps){ $startRows += [pscustomobject]@{Name=$a.Name;AppID=$a.AppID} }",
+    "$pkgs=Get-AppxPackage | Where-Object { $_.Name -match 'ChatGPT|Codex|OpenAI' -or $_.PackageFullName -match 'ChatGPT|Codex|OpenAI' }",
+    "$rows=@()",
+    "$appIds=@()",
+    "foreach($p in $pkgs){",
+    "  $loc=$p.InstallLocation",
+    "  if($loc){",
+    "    $manifestPath=Join-Path $loc 'AppxManifest.xml'",
+    "    if(Test-Path -LiteralPath $manifestPath){",
+    "      try{",
+    "        [xml]$manifest=Get-Content -LiteralPath $manifestPath -ErrorAction Stop",
+    "        foreach($app in @($manifest.Package.Applications.Application)){",
+    "          $id=[string]$app.Id",
+    "          if($id){ $appIds += [pscustomobject]@{Package=$p.Name;Family=$p.PackageFamilyName;AppID=($p.PackageFamilyName + '!' + $id);InstallLocation=$loc} }",
+    "        }",
+    "      }catch{}",
+    "    }",
+    "    $exes=Get-ChildItem -LiteralPath $loc -Recurse -Filter *.exe -ErrorAction SilentlyContinue | Where-Object { $_.Name -match 'ChatGPT|Codex|OpenAI' } | Select-Object -First 8",
+    "    foreach($e in $exes){ $rows += [pscustomobject]@{Package=$p.Name;Path=$e.FullName} }",
+    "  }",
+    "}",
+    "[pscustomobject]@{StartApps=$startRows;Packages=$rows;AppIds=$appIds}|ConvertTo-Json -Depth 5 -Compress",
+  ].join(";");
+  const data = psJson(script, 6500);
+  const startApps = data && data.StartApps ? (Array.isArray(data.StartApps) ? data.StartApps : [data.StartApps]) : [];
+  const arr = data && data.Packages ? (Array.isArray(data.Packages) ? data.Packages : [data.Packages]) : [];
+  const appIds = data && data.AppIds ? (Array.isArray(data.AppIds) ? data.AppIds : [data.AppIds]) : [];
+  for (const app of startApps) {
+    const appId = app && app.AppID ? String(app.AppID) : "";
+    const name = app && app.Name ? String(app.Name) : "";
+    if (!appId || !isOpenAiDesktopCandidate(name, appId)) continue;
+    if (report) report.appx.push({ package: "StartApps", name: app.Name || "", appId });
+    addCandidate(out, seen, "ChatGPT/Codex 桌面程序（开始菜单 AppID）", appId, {
+      launchType: "appId",
+      appId,
+      name,
+      packaged: true,
+    });
+  }
+  for (const app of appIds) {
+    const appId = app && app.AppID ? String(app.AppID) : "";
+    const name = app && app.Package ? String(app.Package) : "";
+    if (!appId || !isOpenAiDesktopCandidate(name, appId)) continue;
+    if (report) report.appx.push({ package: name, family: app.Family || "", appId, manifest: true });
+    addCandidate(out, seen, "ChatGPT/Codex 桌面程序（MSIX AppID）", appId, {
+      launchType: "appId",
+      appId,
+      name,
+      packaged: true,
+    });
+  }
+  for (const row of arr) {
+    const p = row && row.Path ? String(row.Path) : "";
+    if (report && row) report.appx.push({ package: row.Package || "", path: p });
+    addChecked(report, p);
+    // Program Files\WindowsApps 里的包内 exe 通常不能被普通进程直接启动；
+    // 只记录诊断，不当作启动候选，避免弹系统错误框。
+    if (p && !isWindowsPackagedPath(p)) {
+      addCandidate(out, seen, "ChatGPT/Codex 桌面程序（Microsoft Store/MSIX）", p);
+    }
+  }
+}
+
+function desktopExecutableCandidates() {
+  const home = os.homedir();
+  const out = [];
+  const seen = new Set();
+  const report = {
+    platform: process.platform,
+    checkedPaths: [],
+    scannedRoots: [],
+    shortcuts: [],
+    shortcutTargets: [],
+    appx: [],
+    candidates: [],
+  };
+
+  if (process.platform === "darwin") {
+    [
+      path.join(home, "Applications/ChatGPT.app/Contents/MacOS/ChatGPT"),
+      "/Applications/ChatGPT.app/Contents/MacOS/ChatGPT",
+      path.join(home, "Applications/Codex.app/Contents/MacOS/Codex"),
+      "/Applications/Codex.app/Contents/MacOS/Codex",
+    ].forEach((p) => {
+      addChecked(report, p);
+      addCandidate(out, seen, "ChatGPT/Codex 桌面程序", p);
+    });
+    const sorted = sortCandidates(out);
+    lastDiscovery = { ...report, candidates: sorted };
+    return sorted;
+  }
+
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+    const appdata = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    const programData = process.env.ProgramData || "C:\\ProgramData";
+    const pf = process.env.ProgramFiles || "C:\\Program Files";
+    const pf86 = process.env["ProgramFiles(x86)"] || "";
+    const windowsApps = path.join(local, "Microsoft", "WindowsApps");
+    const userStartMenu = path.join(appdata, "Microsoft", "Windows", "Start Menu", "Programs");
+    const systemStartMenu = path.join(programData, "Microsoft", "Windows", "Start Menu", "Programs");
+    const known = [
+      [local, "Programs", "ChatGPT", "ChatGPT.exe"],
+      [local, "Programs", "OpenAI", "ChatGPT", "ChatGPT.exe"],
+      [local, "Programs", "OpenAI ChatGPT", "ChatGPT.exe"],
+      [local, "Programs", "ChatGPT Desktop", "ChatGPT.exe"],
+      [local, "ChatGPT", "ChatGPT.exe"],
+      [local, "OpenAI", "ChatGPT", "ChatGPT.exe"],
+      [local, "OpenAI", "ChatGPT", "bin", "ChatGPT.exe"],
+      [pf, "ChatGPT", "ChatGPT.exe"],
+      [pf, "OpenAI", "ChatGPT", "ChatGPT.exe"],
+      [pf, "OpenAI ChatGPT", "ChatGPT.exe"],
+      pf86 && [pf86, "ChatGPT", "ChatGPT.exe"],
+      pf86 && [pf86, "OpenAI", "ChatGPT", "ChatGPT.exe"],
+      [local, "OpenAI", "Codex", "bin", "Codex.exe"],
+      [local, "Programs", "Codex", "Codex.exe"],
+      [local, "Programs", "codex", "Codex.exe"],
+      [local, "Programs", "OpenAI Codex", "Codex.exe"],
+      [local, "Programs", "Codex Desktop", "Codex.exe"],
+      [local, "Codex", "Codex.exe"],
+      [pf, "Codex", "Codex.exe"],
+      [pf, "OpenAI Codex", "Codex.exe"],
+      pf86 && [pf86, "Codex", "Codex.exe"],
+    ].filter(Boolean);
+    for (const parts of known) {
+      const p = path.join(...parts);
+      addChecked(report, p);
+      addCandidate(out, seen, "ChatGPT/Codex 桌面程序", p);
+    }
+    for (const p of [path.join(windowsApps, "ChatGPT.exe"), path.join(windowsApps, "Codex.exe")]) {
+      addChecked(report, p);
+      if (existsFile(p)) {
+        report.appx.push({ package: "WindowsApps alias", path: path.resolve(p) });
+        addCandidate(out, seen, "ChatGPT/Codex 桌面程序（WindowsApps 别名）", p, {
+          launchType: "alias",
+          packaged: true,
+        });
+      }
+    }
+    addWindowsShortcutCandidates(out, seen, report, [userStartMenu, systemStartMenu]);
+    addWindowsAppxCandidates(out, seen, report);
+    for (const base of [path.join(local, "Programs"), local, pf, pf86, windowsApps].filter(Boolean)) {
+      scanDirForExecutables(base, out, seen, { maxDepth: 5, maxEntries: 1600, maxHits: 24, report });
+    }
+    const sorted = sortCandidates(out);
+    lastDiscovery = { ...report, candidates: sorted };
+    return sorted;
+  }
+
+  lastDiscovery = { ...report, candidates: out };
+  return out;
+}
+
+function sortCandidates(items) {
+  return [...items].sort((a, b) => scoreCandidate(b.path) - scoreCandidate(a.path));
+}
+
+function scoreCandidate(p) {
+  let score = 0;
+  if (/chatgpt/i.test(path.basename(p))) score += 100;
+  if (/codex/i.test(path.basename(p))) score += 50;
+  if (isWindowsPackagedPath(p)) score -= 1000;
+  if (/localappdata|AppData[\\/]Local|Applications/i.test(p)) score += 10;
+  if (/programs/i.test(p)) score += 5;
+  return score;
+}
+
+function codexExecutable() {
+  const first = desktopExecutableCandidates().find((item) => !item.packaged);
+  return first ? first.path : "";
+}
+
+function discoveryReport() {
+  return lastDiscovery || {
+    platform: process.platform,
+    checkedPaths: [],
+    scannedRoots: [],
+    shortcuts: [],
+    shortcutTargets: [],
+    appx: [],
+    candidates: [],
+  };
+}
+
+function discoverySummary() {
+  const r = discoveryReport();
+  const parts = [];
+  if (r.checkedPaths && r.checkedPaths.length) parts.push(`固定路径 ${r.checkedPaths.length} 个`);
+  if (r.scannedRoots && r.scannedRoots.length) parts.push(`目录扫描 ${r.scannedRoots.length} 处`);
+  if (r.shortcuts && r.shortcuts.length) parts.push(`快捷方式 ${r.shortcuts.length} 个`);
+  if (r.appx && r.appx.length) parts.push(`Store/MSIX 线索 ${r.appx.length} 个`);
+  if (r.candidates && r.candidates.length) parts.push(`命中 ${r.candidates.length} 个`);
+  return parts.join("，");
+}
+
+function codexRunning() {
+  try {
+    if (process.platform === "darwin") {
+      return execFileSync("pgrep", ["-f", "(Codex.app/Contents/MacOS/Codex|ChatGPT.app/Contents/MacOS/ChatGPT)"], { encoding: "utf-8" }).trim().length > 0;
+    }
+    if (process.platform === "win32") {
+      return windowsProcessRows().length > 0;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+function windowsProcessRows() {
+  if (process.platform !== "win32") return [];
+  const escapedNames = WIN_PROCESS_NAMES.map((name) => "'" + name.replace(/'/g, "''") + "'").join(",");
+  const script = [
+    `$names=@(${escapedNames})`,
+    "$pkg='WindowsApps\\\\OpenAI\\.(Codex|CodexBeta|ChatGPT-Desktop)_'",
+    "$rows=Get-CimInstance Win32_Process | Where-Object { $names -contains $_.Name -or ($_.ExecutablePath -match $pkg) -or ($_.CommandLine -match $pkg) } | ForEach-Object {",
+    "  [pscustomobject]@{Name=$_.Name;ProcessId=$_.ProcessId;ExecutablePath=$_.ExecutablePath;CommandLine=$_.CommandLine}",
+    "}",
+    "$rows|ConvertTo-Json -Depth 4 -Compress",
+  ].join(";");
+  const data = psJson(script, 4500);
+  if (!data) return [];
+  return Array.isArray(data) ? data : [data];
+}
+
+function windowsProcessDiagnostics(port) {
+  const rows = windowsProcessRows();
+  const portRe = new RegExp("--remote-debugging-port(?:=|\\s+)" + String(port || ""), "i");
+  const hasDebugArg = rows.some((row) => portRe.test(String((row && row.CommandLine) || "")));
+  const summary = rows.map((row) => {
+    const cmd = String((row && row.CommandLine) || "").replace(/\s+/g, " ").slice(0, 260);
+    const name = (row && row.Name) || "process";
+    const pid = (row && row.ProcessId) || "?";
+    return `${name}#${pid}${cmd ? " " + cmd : ""}`;
+  }).join(" | ");
+  return { rows, hasDebugArg, summary };
+}
+
+function waitForCodexExit(maxMs = 9000) {
+  return new Promise((resolve) => {
+    const t0 = Date.now();
+    const tick = () => {
+      if (!codexRunning()) {
+        resolve(true);
+        return;
+      }
+      if (Date.now() - t0 >= maxMs) {
+        resolve(false);
+        return;
+      }
+      setTimeout(tick, 300);
+    };
+    tick();
+  });
+}
+
+function killCodex() {
+  return new Promise((resolve) => {
+    if (process.platform === "darwin") {
+      execFile("osascript", ["-e", 'tell application "Codex" to quit', "-e", 'tell application "ChatGPT" to quit'], () => {
+        execFile("pkill", ["-f", "(Codex.app/Contents/MacOS/Codex|ChatGPT.app/Contents/MacOS/ChatGPT)"], () => {
+          waitForCodexExit(12000).then((exited) => resolve({ exited }));
+        });
+      });
+      return;
+    }
+    if (process.platform === "win32") {
+      let pending = WIN_PROCESS_NAMES.length;
+      const done = () => {
+        pending -= 1;
+        if (pending <= 0) {
+          waitForCodexExit(9000).then((ok) => {
+            if (!ok) {
+              try {
+                execFileSync("powershell.exe", [
+                  "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command",
+                  "$pkg='WindowsApps\\\\OpenAI\\.(Codex|CodexBeta|ChatGPT-Desktop)_'; Get-CimInstance Win32_Process | Where-Object { @('ChatGPT.exe','Codex.exe','OpenAI ChatGPT.exe','ChatGPT Desktop.exe','Codex Desktop.exe') -contains $_.Name -or ($_.ExecutablePath -match $pkg) -or ($_.CommandLine -match $pkg) } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }",
+                ], { windowsHide: true, timeout: 3500 });
+              } catch {}
+            }
+            waitForCodexExit(5000).then((exited) => resolve({ exited }));
+          });
+        }
+      };
+      for (const name of WIN_PROCESS_NAMES) execFile("taskkill", ["/IM", name, "/T", "/F"], done);
+      return;
+    }
+    resolve({ exited: true });
+  });
+}
+
+module.exports = {
+  desktopExecutableCandidates,
+  codexExecutable,
+  isWindowsPackagedPath,
+  discoveryReport,
+  discoverySummary,
+  codexRunning,
+  windowsProcessDiagnostics,
+  killCodex,
+};
diff --git a/electron/lib/media-understanding.js b/electron/lib/media-understanding.js
new file mode 100644
index 0000000..7bf17c4
--- /dev/null
+++ b/electron/lib/media-understanding.js
@@ -0,0 +1,364 @@
+// 上传附件的本地预处理层：MiniMax 负责感知，DeepSeek 只消费结构化证据。
+const crypto = require("crypto");
+const { gatewayConfig } = require("./multimodal-config");
+
+const cache = new Map();
+const CACHE_TTL_MS = 10 * 60 * 1000;
+const MAX_IMAGES_PER_REQUEST = 8;
+const MAX_IMAGE_VALUE_LENGTH = 12 * 1024 * 1024;
+const MAX_BINARY_BYTES = 25 * 1024 * 1024;
+const MAX_PDF_PAGES = 20;
+const MAX_PDF_TEXT_LENGTH = 32000;
+
+const SYSTEM_PROMPT = [
+  "你是附件理解服务。只根据附件可见内容回答，不要猜测。",
+  "返回严格 JSON，不要 Markdown：",
+  '{"summary":"简短概括","items":[{"kind":"ocr|scene|ui|chart","text":"证据","confidence":0.0}]}',
+  "OCR 保留原文；图表需给出数据、单位与趋势；无法确认时降低 confidence。",
+].join("\n");
+
+function sha256(value) {
+  return crypto.createHash("sha256").update(String(value || "")).digest("hex");
+}
+
+function textFromPart(part) {
+  if (!part || typeof part !== "object") return "";
+  return String(part.text || part.content || "").trim();
+}
+
+function urlFromPart(part) {
+  if (!part || typeof part !== "object") return "";
+  const inputImage = part.input_image && typeof part.input_image === "object" ? part.input_image : {};
+  const inputFile = part.input_file && typeof part.input_file === "object" ? part.input_file : {};
+  const inputAudio = part.input_audio && typeof part.input_audio === "object" ? part.input_audio : {};
+  const candidate =
+    (part.image_url && (part.image_url.url || part.image_url)) ||
+    (part.file_url && (part.file_url.url || part.file_url)) ||
+    (part.audio_url && (part.audio_url.url || part.audio_url)) ||
+    inputImage.image_url ||
+    inputImage.url ||
+    inputImage.data ||
+    inputFile.file_url ||
+    inputFile.file_data ||
+    inputFile.url ||
+    inputFile.data ||
+    inputAudio.audio_url ||
+    inputAudio.url ||
+    inputAudio.data ||
+    part.url ||
+    part.data ||
+    part.file_data ||
+    "";
+  return typeof candidate === "string" ? candidate.trim() : "";
+}
+
+function kindFromPart(part, value) {
+  const type = String((part && part.type) || "").toLowerCase();
+  const name = String((part && (part.filename || part.name)) || "").toLowerCase();
+  const mime = String((part && (part.mime_type || part.mimeType)) || "").toLowerCase();
+  if (type.includes("image") || /^data:image\//i.test(value) || /\.(png|jpe?g|gif|webp|bmp)$/i.test(name)) return "image";
+  if (type.includes("audio") || /^data:audio\//i.test(value) || /\.(mp3|wav|m4a|aac|ogg|webm)$/i.test(name)) return "audio";
+  if (type.includes("file") || type.includes("pdf") || mime.includes("pdf") || /\.pdf$/i.test(name)) return "document";
+  return "";
+}
+
+function collectAttachments(request) {
+  const attachments = [];
+  const input = request && request.input;
+  if (!Array.isArray(input)) return attachments;
+  for (const message of input) {
+    if (!message || !Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      const value = urlFromPart(part);
+      const kind = kindFromPart(part, value);
+      if (!kind) continue;
+      const nestedFile = part.input_file && typeof part.input_file === "object" ? part.input_file : {};
+      const nestedAudio = part.input_audio && typeof part.input_audio === "object" ? part.input_audio : {};
+      const format = String(nestedAudio.format || "").trim().toLowerCase();
+      const name = String(
+        part.filename ||
+        part.name ||
+        nestedFile.filename ||
+        nestedFile.name ||
+        (kind === "audio" && format ? `audio.${format}` : "")
+      );
+      attachments.push({
+        id: `${kind}:${sha256(value || `${name}:${textFromPart(part)}`)}`,
+        kind,
+        value,
+        name,
+        mimeType: String(part.mime_type || part.mimeType || nestedFile.mime_type || nestedFile.mimeType || ""),
+      });
+    }
+  }
+  return attachments;
+}
+
+function extractContentText(payload) {
+  const message = payload && payload.choices && payload.choices[0] && payload.choices[0].message;
+  const content = message && message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => (typeof part === "string" ? part : (part && (part.text || part.content)) || "")).join("");
+  }
+  return "";
+}
+
+function parseEvidence(text) {
+  const raw = String(text || "").trim();
+  const fenced = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "");
+  try {
+    const parsed = JSON.parse(fenced);
+    return {
+      summary: String(parsed.summary || "").trim(),
+      items: Array.isArray(parsed.items)
+        ? parsed.items.slice(0, 40).map((item) => ({
+          kind: String((item && item.kind) || "scene"),
+          text: String((item && item.text) || "").trim(),
+          confidence: Number.isFinite(Number(item && item.confidence)) ? Number(item.confidence) : null,
+        })).filter((item) => item.text)
+        : [],
+    };
+  } catch {
+    return { summary: raw.slice(0, 6000), items: [] };
+  }
+}
+
+function chatEndpoint(baseUrl) {
+  const base = String(baseUrl || "").replace(/\/+$/, "");
+  if (/\/chat\/completions$/i.test(base)) return base;
+  if (/\/v\d+$/i.test(base)) return `${base}/chat/completions`;
+  return `${base}/v1/chat/completions`;
+}
+
+function transcriptionEndpoint(baseUrl) {
+  const base = String(baseUrl || "").replace(/\/+$/, "");
+  if (/\/v\d+$/i.test(base)) return `${base}/audio/transcriptions`;
+  return `${base}/v1/audio/transcriptions`;
+}
+
+async function binaryFromAsset(asset, requestFetch) {
+  const value = String(asset.value || "").trim();
+  if (!value) throw new Error("附件没有可读取的数据或 URL");
+  if (/^data:/i.test(value)) {
+    const comma = value.indexOf(",");
+    if (comma < 0) throw new Error("附件 data URL 格式无效");
+    const meta = value.slice(0, comma);
+    const body = value.slice(comma + 1);
+    const buffer = /;base64/i.test(meta)
+      ? Buffer.from(body, "base64")
+      : Buffer.from(decodeURIComponent(body), "utf-8");
+    if (buffer.length > MAX_BINARY_BYTES) throw new Error("附件超过 25MB 限制");
+    return buffer;
+  }
+  if (/^https?:\/\//i.test(value)) {
+    const response = await requestFetch(value, { headers: { "user-agent": "codex-market" } });
+    if (!response.ok) throw new Error(`读取附件失败（HTTP ${response.status}）`);
+    const size = Number(response.headers && response.headers.get && response.headers.get("content-length"));
+    if (Number.isFinite(size) && size > MAX_BINARY_BYTES) throw new Error("附件超过 25MB 限制");
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length > MAX_BINARY_BYTES) throw new Error("附件超过 25MB 限制");
+    return buffer;
+  }
+  const buffer = Buffer.from(value, "base64");
+  if (!buffer.length || buffer.length > MAX_BINARY_BYTES) throw new Error("附件内容无效或超过 25MB 限制");
+  return buffer;
+}
+
+async function understandPdf(asset, requestFetch) {
+  const data = await binaryFromAsset(asset, requestFetch);
+  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const task = pdfjs.getDocument({ data: new Uint8Array(data), isEvalSupported: false });
+  const document = await task.promise;
+  const items = [];
+  for (let pageNumber = 1; pageNumber <= Math.min(document.numPages, MAX_PDF_PAGES); pageNumber += 1) {
+    const page = await document.getPage(pageNumber);
+    const content = await page.getTextContent();
+    const text = content.items.map((item) => String(item.str || "")).join(" ").replace(/\s+/g, " ").trim();
+    if (text) items.push({ kind: "document", text: text.slice(0, MAX_PDF_TEXT_LENGTH), page: pageNumber, confidence: 1 });
+  }
+  if (!items.length) {
+    return {
+      summary: "PDF 未提取到可复制文本，可能是扫描件；需要后续 OCR/页面视觉解析。",
+      items: [],
+    };
+  }
+  return {
+    summary: `PDF 共 ${document.numPages} 页，已提取 ${items.length} 页文本。`,
+    items,
+  };
+}
+
+function audioMimeType(asset) {
+  if (asset.mimeType) return asset.mimeType;
+  const name = String(asset.name || "").toLowerCase();
+  if (name.endsWith(".wav")) return "audio/wav";
+  if (name.endsWith(".mp3")) return "audio/mpeg";
+  if (name.endsWith(".m4a")) return "audio/mp4";
+  if (name.endsWith(".aac")) return "audio/aac";
+  if (name.endsWith(".ogg")) return "audio/ogg";
+  return "audio/webm";
+}
+
+async function understandAudio(asset, config, requestFetch) {
+  const data = await binaryFromAsset(asset, requestFetch);
+  const mimeType = audioMimeType(asset);
+  const filename = asset.name || "audio.webm";
+  const form = new FormData();
+  form.append("model", config.sttModel);
+  form.append("file", new Blob([data], { type: mimeType }), filename);
+  const response = await requestFetch(transcriptionEndpoint(config.baseUrl), {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${config.key}`,
+      "user-agent": "codex-market",
+    },
+    body: form,
+  });
+  if (!response.ok) {
+    const detail = (await response.text().catch(() => "")).slice(0, 300);
+    throw new Error(`音频转写失败（HTTP ${response.status}${detail ? `：${detail}` : ""}）`);
+  }
+  const result = await response.json();
+  const segments = Array.isArray(result.segments) ? result.segments : [];
+  const items = segments.map((segment) => ({
+    kind: "transcript",
+    text: String(segment.text || "").trim(),
+    start_ms: Number.isFinite(Number(segment.start)) ? Math.round(Number(segment.start) * 1000) : null,
+    end_ms: Number.isFinite(Number(segment.end)) ? Math.round(Number(segment.end) * 1000) : null,
+    confidence: null,
+  })).filter((item) => item.text);
+  return {
+    summary: String(result.text || items.map((item) => item.text).join(" ")).slice(0, MAX_PDF_TEXT_LENGTH),
+    items,
+  };
+}
+
+async function understandImages(images, instruction, config, requestFetch) {
+  const content = [
+    { type: "text", text: `用户问题：${String(instruction || "请识别附件内容").slice(0, 4000)}` },
+    ...images.map((asset) => ({ type: "image_url", image_url: { url: asset.value } })),
+  ];
+  const response = await requestFetch(chatEndpoint(config.baseUrl), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${config.key}`,
+      "user-agent": "codex-market",
+    },
+    body: JSON.stringify({
+      model: config.model,
+      temperature: 0.1,
+      max_tokens: 1800,
+      stream: false,
+      messages: [
+        { role: "system", content: SYSTEM_PROMPT },
+        { role: "user", content },
+      ],
+    }),
+  });
+  if (!response.ok) {
+    const detail = (await response.text().catch(() => "")).slice(0, 300);
+    throw new Error(`MiniMax 识别失败（HTTP ${response.status}${detail ? `：${detail}` : ""}）`);
+  }
+  return parseEvidence(extractContentText(await response.json()));
+}
+
+function evidenceText(evidence) {
+  return `[TD 多模态识别证据]\n${JSON.stringify(evidence)}`;
+}
+
+function appendEvidence(request, evidence) {
+  if (!Array.isArray(request.input)) return;
+  let target = null;
+  for (let i = request.input.length - 1; i >= 0; i -= 1) {
+    const item = request.input[i];
+    if (item && item.type === "message" && item.role === "user" && Array.isArray(item.content)) {
+      target = item;
+      break;
+    }
+  }
+  if (!target) {
+    target = { type: "message", role: "user", content: [] };
+    request.input.push(target);
+  }
+  target.content.push({ type: "input_text", text: evidenceText(evidence) });
+}
+
+function cleanupCache(now) {
+  for (const [key, value] of cache) if (now - value.at > CACHE_TTL_MS) cache.delete(key);
+}
+
+async function enrichResponsesRequest(request, { instruction = "", fetchImpl = global.fetch } = {}) {
+  const config = gatewayConfig();
+  const attachments = collectAttachments(request);
+  if (!attachments.length) return { processed: false, attachments: [] };
+  const imageAssets = attachments
+    .filter((asset) => asset.kind === "image" && asset.value && asset.value.length <= MAX_IMAGE_VALUE_LENGTH)
+    .slice(0, MAX_IMAGES_PER_REQUEST);
+  const evidence = {
+    version: 1,
+    provider: "minimax",
+    modality: attachments.length > 1 ? "mixed" : attachments[0].kind,
+    summary: "",
+    items: [],
+    unsupported: [],
+  };
+  const summaries = [];
+
+  if (imageAssets.length) {
+    if (!config.key) {
+      summaries.push("已检测到图片附件，但免费多模态网关尚未注入访问密钥，不能识别图片内容。不要声称已查看或识别该图片。");
+    } else {
+      cleanupCache(Date.now());
+      const cacheKey = sha256(`${config.model}:${instruction}:${imageAssets.map((asset) => asset.id).join(",")}`);
+      const cached = cache.get(cacheKey);
+      if (cached) {
+        summaries.push(cached.value.summary);
+        evidence.items.push(...cached.value.items);
+      } else {
+        try {
+          const understood = await understandImages(imageAssets, instruction, config, fetchImpl);
+          summaries.push(understood.summary);
+          evidence.items.push(...understood.items);
+          cache.set(cacheKey, { at: Date.now(), value: understood });
+        } catch (error) {
+          summaries.push(String((error && error.message) || "MiniMax 图片识别失败"));
+        }
+      }
+    }
+  }
+  for (const asset of attachments.filter((item) => item.kind === "document")) {
+    try {
+      const understood = await understandPdf(asset, fetchImpl);
+      summaries.push(understood.summary);
+      evidence.items.push(...understood.items);
+    } catch (error) {
+      evidence.unsupported.push({ kind: "document", name: asset.name || "未命名附件" });
+      summaries.push(String((error && error.message) || "PDF 解析失败"));
+    }
+  }
+  for (const asset of attachments.filter((item) => item.kind === "audio")) {
+    if (!config.key || !config.sttModel) {
+      evidence.unsupported.push({ kind: "audio", name: asset.name || "未命名附件" });
+      summaries.push("音频已检测到，但免费多模态网关尚未配置音频转写模型。");
+      continue;
+    }
+    try {
+      const understood = await understandAudio(asset, config, fetchImpl);
+      summaries.push(understood.summary);
+      evidence.items.push(...understood.items);
+    } catch (error) {
+      summaries.push(String((error && error.message) || "音频转写失败"));
+    }
+  }
+  evidence.summary = summaries.filter(Boolean).join("\n").slice(0, MAX_PDF_TEXT_LENGTH);
+  appendEvidence(request, evidence);
+  return { processed: true, attachments, evidence };
+}
+
+module.exports = {
+  collectAttachments,
+  enrichResponsesRequest,
+  parseEvidence,
+};
diff --git a/electron/lib/memory.js b/electron/lib/memory.js
index 4a4843e..f31d3b9 100644
--- a/electron/lib/memory.js
+++ b/electron/lib/memory.js
@@ -32,6 +32,7 @@ const seenRollouts = new Set(); // 已见过的 rollout 文件（判定「新会
 const queue = [];
 let working = false;
 let cfg = null;
+const deletedSessionIds = new Set();
 
 // ---------------------------------------------------------------------------
 // 配置（userData/memory.json）
@@ -123,6 +124,33 @@ function flushDb() {
     log("会话记忆：记忆库写盘失败 " + (e.message || e));
   }
 }
+function flushDbStrict() {
+  clearTimeout(persistTimer);
+  if (!db) return;
+  const file = dbFile();
+  const tmp = file + ".td-delete-" + process.pid + ".tmp";
+  const old = file + ".td-delete-" + process.pid + ".old";
+  fs.rmSync(old, { force: true });
+  const fd = fs.openSync(tmp, "w");
+  try {
+    fs.writeFileSync(fd, Buffer.from(db.export()));
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try {
+    if (fs.existsSync(file)) fs.renameSync(file, old);
+    try {
+      fs.renameSync(tmp, file);
+    } catch (e) {
+      if (fs.existsSync(old)) fs.renameSync(old, file);
+      throw e;
+    }
+    try { fs.rmSync(old, { force: true }); } catch {}
+  } finally {
+    fs.rmSync(tmp, { force: true });
+  }
+}
 function all(sql, params = []) {
   const rows = [];
   const st = db.prepare(sql);
@@ -270,6 +298,7 @@ async function summarizeFile(file) {
   const items = sessions.listConversations({ includeSubagent: false });
   const item = items.find((i) => i.path === file);
   if (!item || !item.id) return; // 子 agent 线程或读不到元信息 → 跳过
+  if (deletedSessionIds.has(item.id)) return;
   const conv = sessions.readConversation(file);
   if (!conv.messages.some((m) => m.role === "user")) return; // 空会话不摘要
   let r;
@@ -280,6 +309,7 @@ async function summarizeFile(file) {
     r = localSummarize(item, conv);
   }
   await ensureDb();
+  if (deletedSessionIds.has(item.id)) return;
   db.run(
     `INSERT INTO sessions (id, ts, project, cwd, topic, summary, decisions, next_steps, files,
                            rollout_path, rollout_size, engine, updated_at)
@@ -618,6 +648,65 @@ function writeProjectCore(cwd) {
   if (nt !== text) writeFileAtomic(f, nt);
 }
 
+function removeProjectCore(cwd) {
+  const f = path.join(cwd, "AGENTS.md");
+  let text = "";
+  try { text = fs.readFileSync(f, "utf-8"); } catch { return; }
+  const si = text.indexOf(AGENTS_START);
+  const ei = text.indexOf(AGENTS_END);
+  if (si < 0 || ei <= si) return;
+  const next = text.slice(0, si) + text.slice(ei + AGENTS_END.length);
+  writeFileAtomic(f, next);
+}
+
+function removeArchiveSession(cwd, id) {
+  if (!cwd || !id) return;
+  const f = archivePath(cwd);
+  let text = "";
+  try { text = fs.readFileSync(f, "utf-8"); } catch { return; }
+  const lines = text.split("\n");
+  const kept = [];
+  let dropping = false;
+  for (const line of lines) {
+    const header = line.match(/^## .*  \[([0-9a-f-]{36})\]\s*$/i);
+    if (header) dropping = header[1] === id;
+    if (!dropping) kept.push(line);
+  }
+  const next = kept.join("\n");
+  if (next.trim()) writeFileAtomic(f, next);
+  else fs.rmSync(f, { force: true });
+}
+
+function refreshScopeAfterDelete(cwd, id) {
+  db.run("DELETE FROM core_decisions WHERE scope = ? AND session_id = ?", [cwd, id]);
+  const latest = all("SELECT * FROM sessions WHERE cwd = ? ORDER BY ts DESC LIMIT 1", [cwd])[0];
+  if (!latest) {
+    db.run("DELETE FROM core WHERE scope = ?", [cwd]);
+    return 0;
+  }
+  db.run(
+    `INSERT INTO core (scope,state,next_steps,files,updated_at) VALUES (?,?,?,?,?)
+     ON CONFLICT(scope) DO UPDATE SET state=excluded.state,next_steps=excluded.next_steps,files=excluded.files,updated_at=excluded.updated_at`,
+    [cwd, clip(latest.summary, 300), JSON.stringify(parseArr(latest.next_steps).slice(0, 6)), JSON.stringify(parseArr(latest.files).slice(0, 8)), new Date().toISOString()]
+  );
+  return 1;
+}
+
+function removeGeneratedHandoff(cwd) {
+  const file = handoffPath(cwd);
+  let text = "";
+  try { text = fs.readFileSync(file, "utf-8"); } catch { return; }
+  if (text.startsWith("<!-- 本文件由「Codex 插件市场 · 会话记忆」自动生成与覆盖，请勿手动编辑 -->")) {
+    fs.rmSync(file, { force: true });
+  }
+}
+
+function canWriteGeneratedHandoff(cwd) {
+  let text = "";
+  try { text = fs.readFileSync(handoffPath(cwd), "utf-8"); } catch { return true; }
+  return text.startsWith("<!-- 本文件由「Codex 插件市场 · 会话记忆」自动生成与覆盖，请勿手动编辑 -->");
+}
+
 // 新版首启：先把已有 sessions 迁移进结构化 core，再把所有已知项目 AGENTS.md 升级为核心块格式
 function refreshAllCores() {
   try {
@@ -738,16 +827,19 @@ function start(opts = {}) {
   if (opts.log) log = opts.log;
   if (opts.notify) notify = opts.notify;
   loadCfg();
-  // 先把已存在的会话标记为「已见」，这样只有启动后【新开】的会话才触发「即刻结算上一个」
-  try {
-    for (const it of sessions.listConversations({ includeSubagent: true })) seenRollouts.add(it.path);
-  } catch {}
+  const markSeen = () => {
+    // 标记已存在会话需要递归扫描 ~/.codex/sessions，启动时可延后，避免阻塞主进程响应点击。
+    try {
+      for (const it of sessions.listConversations({ includeSubagent: true })) seenRollouts.add(it.path);
+    } catch {}
+  };
   // 监视器常开（总开关只控制是否处理），这样开关切换无需重启
   try {
-    fs.mkdirSync(sessions.SESSIONS_DIR, { recursive: true });
-    watcher = fs.watch(sessions.SESSIONS_DIR, { recursive: true }, (_ev, name) => {
+    const sessionsDir = sessions.getSessionsDir();
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    watcher = fs.watch(sessionsDir, { recursive: true }, (_ev, name) => {
       if (!name || !/rollout-.*\.jsonl$/.test(String(name))) return;
-      const full = path.join(sessions.SESSIONS_DIR, String(name));
+      const full = path.join(sessionsDir, String(name));
       // 「开新会话即刻结算上一个」：首次见到某 rollout 文件 = 新会话开始 → 立刻把其它待处理的（多半是刚关掉的那个）先存好
       if (!seenRollouts.has(full)) {
         seenRollouts.add(full);
@@ -759,7 +851,15 @@ function start(opts = {}) {
     log("会话记忆：无法监视 sessions 目录 " + (e.message || e));
   }
   sweepTimer = setInterval(sweep, 5000);
-  backfill().catch((e) => log("会话记忆：启动扫描失败 " + (e.message || e)));
+  if (opts.startupScan === false) return;
+  const startupScan = () => {
+    if (!loadCfg().enabled) return;
+    markSeen();
+    backfill().catch((e) => log("会话记忆：启动扫描失败 " + (e.message || e)));
+  };
+  const delay = Number(opts.startupDelayMs) || 0;
+  if (delay > 0) setTimeout(startupScan, delay);
+  else startupScan();
 }
 
 function stop() {
@@ -771,6 +871,14 @@ function stop() {
   flushDb(); // 退出前把内存库落盘
 }
 
+function restartWatching() {
+  stop();
+  dirty.clear();
+  seenRollouts.clear();
+  queue.length = 0;
+  start();
+}
+
 // ---------------------------------------------------------------------------
 // 给 UI 的接口
 // ---------------------------------------------------------------------------
@@ -856,15 +964,61 @@ async function deleteRow(id) {
   notify();
 }
 
+async function deleteSession(id, cwd) {
+  deletedSessionIds.add(String(id || ""));
+  await ensureDb();
+  const rows = all("SELECT cwd, rollout_path FROM sessions WHERE id = ?", [id]);
+  for (const row of rows) {
+    if (row.rollout_path) {
+      dirty.delete(row.rollout_path);
+      seenRollouts.delete(row.rollout_path);
+      for (let i = queue.length - 1; i >= 0; i--) if (queue[i] === row.rollout_path) queue.splice(i, 1);
+    }
+  }
+  const storedScopes = Array.from(new Set(rows.map((row) => row.cwd).filter(Boolean)));
+  const scopes = storedScopes.length ? storedScopes : (cwd ? [cwd] : []);
+  const snapshot = Buffer.from(db.export());
+  try {
+    db.run("BEGIN");
+    db.run("DELETE FROM sessions WHERE id = ?", [id]);
+    for (const scope of scopes) refreshScopeAfterDelete(scope, id);
+    db.run("COMMIT");
+    flushDbStrict();
+  } catch (e) {
+    try { db.run("ROLLBACK"); } catch {}
+    try { db.close(); } catch {}
+    db = new SQLmod.Database(snapshot);
+    throw e;
+  }
+  for (const scope of scopes) removeArchiveSession(scope, id);
+  for (const scope of scopes) {
+    if (!scope) continue;
+    try { if (!fs.statSync(scope).isDirectory()) continue; } catch { continue; }
+    try {
+      if (all("SELECT 1 FROM sessions WHERE cwd = ? LIMIT 1", [scope]).length) {
+        writeProjectCore(scope);
+        if (canWriteGeneratedHandoff(scope)) writeHandoff(scope);
+      } else {
+        removeProjectCore(scope);
+        removeGeneratedHandoff(scope);
+      }
+    } catch (e) { log("会话记忆派生文件清理失败：" + (e.message || e)); }
+  }
+  notify();
+  return { id, scopes };
+}
+
 module.exports = {
   start,
   stop,
+  restartWatching,
   statusInfo,
   list,
   setEnabled,
   toggleProject,
   resummarize,
   deleteRow,
+  deleteSession,
   handoffPath,
   renderProjectCore,
   writeProjectCore,
diff --git a/electron/lib/multimodal-config.js b/electron/lib/multimodal-config.js
new file mode 100644
index 0000000..f5de9ad
--- /dev/null
+++ b/electron/lib/multimodal-config.js
@@ -0,0 +1,38 @@
+// 多模态网关凭据只允许在打包时注入，不写进仓库或路由分组配置。
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_BASE_URL = "https://api.tokendun.com";
+const DEFAULT_MODEL = "MiniMax-M3";
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function configFiles() {
+  const files = [];
+  if (process.env.TD_MULTIMODAL_GATEWAY_CONFIG) files.push(process.env.TD_MULTIMODAL_GATEWAY_CONFIG);
+  // 热更新目录不随完整安装包携带 resources；将凭据放在 userData 后可被热更新代码稳定读取。
+  try {
+    const { app } = require("electron");
+    if (app && app.getPath) files.push(path.join(app.getPath("userData"), "multimodal-gateway.json"));
+  } catch {}
+  if (process.resourcesPath) files.push(path.join(process.resourcesPath, "multimodal-gateway.json"));
+  files.push(path.join(__dirname, "..", "..", "resources", "multimodal-gateway.json"));
+  return Array.from(new Set(files));
+}
+
+function gatewayConfig() {
+  const fileConfig = configFiles().map(readJson).find(Boolean) || {};
+  const baseUrl = String(process.env.TD_MULTIMODAL_GATEWAY_URL || fileConfig.baseUrl || DEFAULT_BASE_URL).trim();
+  const key = String(process.env.TD_MULTIMODAL_GATEWAY_KEY || fileConfig.key || "").trim();
+  const model = String(process.env.TD_MULTIMODAL_MODEL || fileConfig.model || DEFAULT_MODEL).trim();
+  const sttModel = String(process.env.TD_MULTIMODAL_STT_MODEL || fileConfig.sttModel || "").trim();
+  return { baseUrl, key, model, sttModel };
+}
+
+module.exports = { gatewayConfig };
diff --git a/electron/lib/provider_sync.js b/electron/lib/provider_sync.js
index 04700a3..404b2c7 100644
--- a/electron/lib/provider_sync.js
+++ b/electron/lib/provider_sync.js
@@ -4,26 +4,29 @@
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
-const { execFileSync, spawnSync } = require("child_process");
+const { spawnSync } = require("child_process");
 const initSqlJs = require("sql.js");
+const { cleanThreadTitle, cleanUserVisibleText } = require("./title_clean");
+const codexDesktop = require("./codex_desktop");
 
-const CODEX_HOME = path.join(os.homedir(), ".codex");
-const SESSION_INDEX = path.join(CODEX_HOME, "session_index.jsonl");
-const GLOBAL_STATE = path.join(CODEX_HOME, ".codex-global-state.json");
+let CODEX_HOME = path.join(os.homedir(), ".codex");
+let SESSION_INDEX = path.join(CODEX_HOME, "session_index.jsonl");
+let GLOBAL_STATE = path.join(CODEX_HOME, ".codex-global-state.json");
+// Codex 桌面端侧栏现在优先读这个本地目录库，而不是直接扫 state_*.sqlite。
+// 只改 threads / rollout / session_index 而不同步这里，重启后侧栏仍会空。
+let LOCAL_CATALOG_DB = path.join(CODEX_HOME, "sqlite", "codex-dev.db");
+
+function setCodexDataDir(dir) {
+  if (typeof dir !== "string" || !path.isAbsolute(dir)) throw new Error("Codex 数据目录必须是绝对路径");
+  CODEX_HOME = path.resolve(dir);
+  SESSION_INDEX = path.join(CODEX_HOME, "session_index.jsonl");
+  GLOBAL_STATE = path.join(CODEX_HOME, ".codex-global-state.json");
+  LOCAL_CATALOG_DB = path.join(CODEX_HOME, "sqlite", "codex-dev.db");
+}
 
 // 检测 Codex 是否在运行（尽力而为，跨平台）
 function codexRunning() {
-  try {
-    if (process.platform === "darwin") {
-      return execFileSync("pgrep", ["-f", "Codex.app/Contents/MacOS/Codex"], { encoding: "utf-8" }).trim().length > 0;
-    }
-    if (process.platform === "win32") {
-      return /Codex\.exe/i.test(execFileSync("tasklist", [], { encoding: "utf-8" }));
-    }
-  } catch {
-    /* pgrep 无匹配时退出码非 0，视为未运行 */
-  }
-  return false;
+  return codexDesktop.codexRunning();
 }
 
 // 目标 provider = config.toml 根级 model_provider，缺省 openai
@@ -68,7 +71,7 @@ function loadIndexTitles() {
       if (!line.trim()) continue;
       try {
         const d = JSON.parse(line);
-        if (d.id && d.thread_name) map[d.id] = d.thread_name;
+        if (d.id && d.thread_name) map[d.id] = cleanThreadTitle(d.thread_name, "", 80);
       } catch {}
     }
   } catch {}
@@ -91,12 +94,277 @@ function firstText(value) {
   return "";
 }
 
+// rollout payload 里的字段不一定是字符串：subagent 会话的 source 就是对象
+// {subagent:{thread_spawn:{...}}}。Codex 自身在 state 库里存的是 JSON 字符串；
+// 直接把对象绑给 sql.js 会抛 "unknown type" 并让整批 upsert 回滚（Windows 无
+// sqlite3 CLI 时走 sql.js 路径，正是这个原因导致恢复后 state 库 0 线程）。
+function payloadText(value, fallback) {
+  if (typeof value === "string") return value;
+  if (value === null || value === undefined) return fallback;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    const text = JSON.stringify(value);
+    if (typeof text === "string") return text;
+  } catch {}
+  return fallback;
+}
+
 function sql(v) {
   if (v === null || v === undefined) return "NULL";
   if (typeof v === "number") return Number.isFinite(v) ? String(v) : "NULL";
+  if (typeof v !== "string") {
+    // 对象（如 subagent 的 source）序列化成 JSON 文本，与 Codex 自身存储一致，
+    // 避免落入 String(v) 产生无意义的 '[object Object]' 脏行。
+    try { v = JSON.stringify(v); } catch { v = String(v); }
+  }
   return "'" + String(v).replace(/'/g, "''") + "'";
 }
 
+const THREAD_COLUMNS = [
+  "id", "rollout_path", "created_at", "updated_at", "source", "model_provider", "cwd", "title",
+  "sandbox_policy", "approval_mode", "tokens_used", "has_user_event", "archived", "archived_at",
+  "git_sha", "git_branch", "git_origin_url", "cli_version", "first_user_message", "memory_mode",
+  "model", "reasoning_effort", "created_at_ms", "updated_at_ms", "thread_source", "preview",
+  "recency_at", "recency_at_ms", "history_mode",
+];
+
+// Codex 当前 state_5.sqlite 的完整基础 schema。首次安装工具箱且目标目录还没有任何
+// state_*.sqlite 时，不能只创建一个 threads 简表：Codex 启动时还会依赖这些索引、触发器
+// 和关联表。migration 记录使用当前 Codex 版本的基线，后续版本可继续追加自己的迁移。
+const STATE_DB_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS _sqlx_migrations (
+  version BIGINT PRIMARY KEY,
+  description TEXT NOT NULL,
+  installed_on TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  success BOOLEAN NOT NULL,
+  checksum BLOB NOT NULL,
+  execution_time BIGINT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS thread_sections (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS backfill_state (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  status TEXT NOT NULL,
+  last_watermark TEXT,
+  last_success_at INTEGER,
+  updated_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS external_agent_config_imports (
+  import_id TEXT PRIMARY KEY,
+  completed_at_ms INTEGER NOT NULL,
+  successes TEXT NOT NULL,
+  failures TEXT NOT NULL,
+  provider_id TEXT
+);
+CREATE TABLE IF NOT EXISTS remote_control_enrollments (
+  websocket_url TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  app_server_client_name TEXT NOT NULL,
+  server_id TEXT NOT NULL,
+  environment_id TEXT NOT NULL,
+  server_name TEXT NOT NULL,
+  updated_at INTEGER NOT NULL,
+  remote_control_enabled INTEGER,
+  PRIMARY KEY (websocket_url, account_id, app_server_client_name)
+);
+CREATE TABLE IF NOT EXISTS threads (
+  id TEXT PRIMARY KEY,
+  rollout_path TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  source TEXT NOT NULL,
+  model_provider TEXT NOT NULL,
+  cwd TEXT NOT NULL,
+  title TEXT NOT NULL,
+  sandbox_policy TEXT NOT NULL,
+  approval_mode TEXT NOT NULL,
+  tokens_used INTEGER NOT NULL DEFAULT 0,
+  has_user_event INTEGER NOT NULL DEFAULT 0,
+  archived INTEGER NOT NULL DEFAULT 0,
+  archived_at INTEGER,
+  git_sha TEXT,
+  git_branch TEXT,
+  git_origin_url TEXT,
+  cli_version TEXT NOT NULL DEFAULT '',
+  first_user_message TEXT NOT NULL DEFAULT '',
+  agent_nickname TEXT,
+  agent_role TEXT,
+  memory_mode TEXT NOT NULL DEFAULT 'enabled',
+  model TEXT,
+  reasoning_effort TEXT,
+  agent_path TEXT,
+  created_at_ms INTEGER,
+  updated_at_ms INTEGER,
+  thread_source TEXT,
+  preview TEXT NOT NULL DEFAULT '',
+  recency_at INTEGER NOT NULL DEFAULT 0,
+  recency_at_ms INTEGER NOT NULL DEFAULT 0,
+  history_mode TEXT NOT NULL DEFAULT 'legacy',
+  name TEXT,
+  is_pinned INTEGER NOT NULL DEFAULT 0,
+  thread_section_id TEXT REFERENCES thread_sections(id) ON DELETE SET NULL
+);
+CREATE TABLE IF NOT EXISTS thread_dynamic_tools (
+  thread_id TEXT NOT NULL,
+  position INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  input_schema TEXT NOT NULL,
+  defer_loading INTEGER NOT NULL DEFAULT 0,
+  namespace TEXT,
+  PRIMARY KEY(thread_id, position),
+  FOREIGN KEY(thread_id) REFERENCES threads(id) ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS thread_spawn_edges (
+  parent_thread_id TEXT NOT NULL,
+  child_thread_id TEXT NOT NULL PRIMARY KEY,
+  status TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_thread_dynamic_tools_thread ON thread_dynamic_tools(thread_id);
+CREATE INDEX IF NOT EXISTS idx_thread_spawn_edges_parent_status ON thread_spawn_edges(parent_thread_id, status);
+CREATE INDEX IF NOT EXISTS idx_threads_archived ON threads(archived);
+CREATE INDEX IF NOT EXISTS idx_threads_archived_cwd_created_at_ms ON threads(archived, cwd, created_at_ms DESC, id DESC);
+CREATE INDEX IF NOT EXISTS idx_threads_archived_cwd_recency_at_ms ON threads(archived, cwd, recency_at_ms DESC, id DESC);
+CREATE INDEX IF NOT EXISTS idx_threads_archived_cwd_updated_at_ms ON threads(archived, cwd, updated_at_ms DESC, id DESC);
+CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at DESC, id DESC);
+CREATE INDEX IF NOT EXISTS idx_threads_created_at_ms ON threads(created_at_ms DESC, id DESC);
+CREATE INDEX IF NOT EXISTS idx_threads_pinned_recency_at_ms ON threads(archived, recency_at_ms DESC, id DESC) WHERE is_pinned = 1 AND preview <> '';
+CREATE INDEX IF NOT EXISTS idx_threads_provider ON threads(model_provider);
+CREATE INDEX IF NOT EXISTS idx_threads_recency_at_ms ON threads(recency_at_ms DESC, id DESC);
+CREATE INDEX IF NOT EXISTS idx_threads_section_recency_at_ms ON threads(archived, thread_section_id, recency_at_ms DESC, id DESC) WHERE thread_section_id IS NOT NULL AND preview <> '';
+CREATE INDEX IF NOT EXISTS idx_threads_source ON threads(source);
+CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at DESC, id DESC);
+CREATE INDEX IF NOT EXISTS idx_threads_updated_at_ms ON threads(updated_at_ms DESC, id DESC);
+CREATE INDEX IF NOT EXISTS idx_threads_visible_created_at_ms ON threads(archived, created_at_ms DESC) WHERE preview <> '';
+CREATE INDEX IF NOT EXISTS idx_threads_visible_recency_at_ms ON threads(archived, recency_at_ms DESC, id DESC) WHERE preview <> '';
+CREATE INDEX IF NOT EXISTS idx_threads_visible_updated_at_ms ON threads(archived, updated_at_ms DESC) WHERE preview <> '';
+CREATE TRIGGER IF NOT EXISTS threads_created_at_ms_after_insert
+AFTER INSERT ON threads WHEN NEW.created_at_ms IS NULL
+BEGIN UPDATE threads SET created_at_ms = NEW.created_at * 1000 WHERE id = NEW.id; END;
+CREATE TRIGGER IF NOT EXISTS threads_created_at_ms_after_update
+AFTER UPDATE OF created_at ON threads
+WHEN NEW.created_at != OLD.created_at AND NEW.created_at_ms IS OLD.created_at_ms
+BEGIN UPDATE threads SET created_at_ms = NEW.created_at * 1000 WHERE id = NEW.id; END;
+CREATE TRIGGER IF NOT EXISTS threads_recency_at_after_insert
+AFTER INSERT ON threads WHEN NEW.recency_at_ms = 0
+BEGIN UPDATE threads SET recency_at = NEW.updated_at, recency_at_ms = COALESCE(NEW.updated_at_ms, NEW.updated_at * 1000) WHERE id = NEW.id; END;
+CREATE TRIGGER IF NOT EXISTS threads_updated_at_ms_after_insert
+AFTER INSERT ON threads WHEN NEW.updated_at_ms IS NULL
+BEGIN UPDATE threads SET updated_at_ms = NEW.updated_at * 1000 WHERE id = NEW.id; END;
+CREATE TRIGGER IF NOT EXISTS threads_updated_at_ms_after_update
+AFTER UPDATE OF updated_at ON threads
+WHEN NEW.updated_at != OLD.updated_at AND NEW.updated_at_ms IS OLD.updated_at_ms
+BEGIN UPDATE threads SET updated_at_ms = NEW.updated_at * 1000 WHERE id = NEW.id; END;
+`;
+
+const STATE_DB_MIGRATIONS = [
+  [1, "threads", "627EF19164C9BB298A0CD99945981C9B7BDA3D9E6CF12EB35145E3B1D3BF7CF8740F0DBAA0B475185FC2993397078049"],
+  [2, "logs", "521B72CBC04C7D03B1E4AEF8DC0FDEE672F1F7F5881385A55A0E937E4EBE87A3F67BCA4D3F6B59AFBC9A7CA723C82856"],
+  [3, "logs thread id", "E58A2862BDB66D3274E60144A26DC9D68BBEFFF834CD29B82B740F38FCF95862934F412665D985715167839E8F0EB377"],
+  [4, "thread dynamic tools", "8ADC251366E4C7E5EA78B620AC71F4C4BDFB8F048BF9F2FD7204226CFBA54C8E83FC9D83FC1EC334BC683BB7F6D0D8A8"],
+  [5, "threads cli version", "1AC64F85E083E5B49B974BF498FC39C630F0032057FB4BF4CB31708619FAC5A80189F261CF3E38DAFD92DC406E73C220"],
+  [6, "memories", "A203FC4B597E1420BFFDC4E00E214798B21CF7FC921D8BD6F089C75248FB6A4B4942C97A1F8E0271ECA8CF3B3E5E7A80"],
+  [7, "threads first user message", "7E35A464DF6D4C82694DE50865BA3FE9104F9E1385A33BE7D633AB4B8D6CF60B7F369FE083D31251FD77B75FA2D61F82"],
+  [8, "backfill state", "AA3F287F7A448554E7AF01F259F0871CE90ACE1A7D4B8EBBD74C87AE57C3E21119F7EEC8B9C2E9F4A9E76E63A0F0B60A"],
+  [9, "stage1 outputs rollout slug", "8B469360777E6DD6C21D3F0EB93481251846B0A50E0A44EB0DBEE4A0A32B7206768A5D83A5FCEC30C6FD2E43D755FF1B"],
+  [10, "logs process id", "8ADAF1365F8E5DEEBA68BDEEE9FD83B094A87BDAB364D95AB5C714F7B8BD95DC3B38576871470312154C9D41E8F10F93"],
+  [11, "logs partition prune indexes", "31ECECBD07F04452D0DC5127D824ED183056B9900A31AA739387A4AEF232016D975110829814841FB6BF3FD23634B799"],
+  [12, "logs estimated bytes", "0012A213ED25F2CF806C2530C487EBB00B4F102F5960D1A852154A0F77D25C9E9F7DF29550FAEB30EBAFF15A26C7D604"],
+  [13, "threads agent nickname", "05526A0900A8430523A9A05932EA61302FCE20782B245498565C1B9A2DFD10CF5C49932089B496AE23AF44F6C5F76AF4"],
+  [14, "agent jobs", "4D2FBB2442C5C5C7C47B4254B5B8DC2C52129F65C4A952A79F1EC5C40FB07483326429CE5ACDBD372BC9262352CB6277"],
+  [15, "agent jobs max runtime seconds", "0EECE6DB59C948FAA6608526AF440A9F53F5A982D27F3E866CD9F1401C2E59BC61F8381B5A1C9744ACB232F50DB493E5"],
+  [16, "memory usage", "4768F743E981293735C6E07B0282EC8ACE98AF720059D68555B17979D28C94B0C893A97A950D5E32758BC6D92D8FE6FF"],
+  [17, "phase2 selection flag", "4CBDB2EDFEBF6040858FFC193CFFA36E6B3FBF508F8418AD073081BBFCF59D53D423B6EB4C0DED206AB4D4C1A0EFED94"],
+  [18, "phase2 selection snapshot", "A4363003BC44F0A4AE1EED53B536B7175F97863EA6881A059DC6642E70E2921576204697CEC2345F560E65FF7FBF4455"],
+  [19, "thread dynamic tools defer loading", "3884C02F080F0184E92B620F870DFBB840A8EC5DFCE2FE6455DD8197FCD27D7DD86E63AD6EC7C4091A1161D9ED199F8D"],
+  [20, "threads model reasoning effort", "07673F4859F740134569AB9606760D8173ED6DF92DA47C86FBD0CEEB333E18AB7AC91D525AB8C11503C42164FD4167AE"],
+  [21, "thread spawn edges", "EA1AEBE4F5A1D56C8EFFCC15F705C272275DD8ADFEB01BC97D3F7B283474A3B8C2B0C8C69DE55786E8BDA17CAE6F4DE7"],
+  [22, "threads agent path", "160FE01B757DD06F9573B9030952D021F2B148732BEA5FC5F5AE09E9227F3F83CA676695EDAF8502669FCB546119DC94"],
+  [23, "drop logs", "E6C748A9A18286E4C773FFE0DAD659F16FB7E5B7B032235815991C405F2D32C068F3EDDE920D0FCF589B687BFFCFEE2E"],
+  [24, "remote control enrollments", "E92AA526B1F36E26F6221C04A671F07B27DE2E7A5112D93A8C3AF816A87846E7804D5FBAD689E61CF4EC91FD79D3BD8A"],
+  [25, "thread timestamps millis", "D6FB51D79941B93C3278FE2A8A0C6FA882407B7B716E32D72329F0B7B60C181A42F49E56CD552315EFB0402A111EDE12"],
+  [26, "thread dynamic tools namespace", "6C62A325D3B9CA8E424EACB9E3890D8D9DE57C3725E2D1FA30C3743AE779FCA2969387174359DFB26E4920791AE7E831"],
+  [27, "threads cwd sort indexes", "D84DCA6A039E004C0C7D06C5A16C2CCC363137537F3DD9898F50BB013CE9067140761B87D58CA742D769D35976863FC3"],
+  [28, "device key bindings", "EF44ADAA291E40DFE6B74E3CD259711ADAE13F01C5594B177D08E2D2041A67ED3813FEECF049662AAED0F636BD3F4AC3"],
+  [29, "thread goals", "E9EC76F97DBF41CE4949DE324A2A26538C2025C0AC4F272B77A852970FB14B7EC970D6978A765F91AE171DCE9C0E4149"],
+  [30, "threads thread source", "80C1CDACD4520B42B18B960164912685591A7EE041645F35609A2EE2792EB474B7B0B758366556982D8CDE2ACB583672"],
+  [31, "drop device key bindings", "943675A9B3DC92D0B2731AE7D2FE324FF1A40B6366B9D5D8B4CB47CA885C08BEB6EBB1D776A5A47C878B4094DDE70EA0"],
+  [32, "threads preview", "3C01D615C5E3ABA0FD858B7168E73881598D7D33A0ECC41527BDF6595A199D1AEC2FF9F3B3000A57241C500D81B34259"],
+  [33, "thread goal stopped statuses", "4904AAE354E3D8CE32AC21D2AE579FD708446AE1DFB2649FC9DD22DC9279B91A2BBB02E6F01B3E0ABD1088177BF2F030"],
+  [34, "drop thread goals", "D6FEA739C76EBDEF35A23F06E54EFB5904D7987FB6B663DB1EBC98EB9B192305F454932BFBAA2231AEDCA6209903A5F3"],
+  [35, "drop memory tables", "D7B56ACB07C96858BDC7CA4C53DB51EB71C6A19EF2C524FF68C2660A6FE0D23211A6D39CB905F01C42FFB7C8EE913BBC"],
+  [36, "threads visible sort indexes", "6381F7BB4C36BE41C6106B8523EA6C68F5A00273A5522155B7B84BAD26D152436F3375DF7097CE3ABF2421AEC32641ED"],
+  [37, "remote control enrollments enabled", "F6A5AB0DB36BB9E45AB5285B56090FB453DF0A4D4D8D62EACE234F0B557F4203C6C455FC67BD7D6E72623C3979EC9405"],
+  [38, "external agent config imports", "E7778522CBE529F5E2BA179B502AEE8E5C21272AD820E672AB0A565F7EDC9BD0F29171CCF9815C0ACC0F89EAE0A2B1FC"],
+  [39, "threads recency at", "C217B3D14C08C23603F485AF11452EE2B68F65FA8DBAF215F33F53B608C092BE8738DE3F63D6A38F120EDEA5AF247C17"],
+  [40, "threads history mode", "A7A99674F90A43184E43D66595C4F1DA50AE8715A5BFCB1579A2B7B10668335D7F7AB6B6F2D7A7A379272773D803A914"],
+  [41, "threads name", "0DC734DBE4CBCC5AD5A8BBC2FDC1CF770DDEA3CB53EB36C55A4DA6FA2E8BE4CC8E68672F43AC953E727E415E45C50A78"],
+  [42, "drop agent jobs", "CFDC4FD47328D1B67C0C7555125DE4FB4ADD5B3B57FD31AC1987E4D8B0C99B1F5418DB9EE7EC2158AED8A2E3DFCFD636"],
+  [43, "threads is pinned", "605128E722BD2521C7E979E9961C16706435E442B3E3A8EFA36F6B16C42E3833090906D9A62FDE097A109B78E29DA830"],
+  [44, "external agent config imports provider id", "5D29223BD1CAFE456A4AF992A545E8EC420B71331EB12A7427E26512B8A44117D9445B83562F095B3A5A0F11C4F091D2"],
+  [45, "threads section", "A7FADC8CAEA8B6ABEB108F588A91B8E5D1C9E2645CE990F2251B9F0234E6E53D78FC854F1C88C7217CC143016539D691"],
+];
+
+function threadColumns(cols) {
+  return THREAD_COLUMNS.filter((c) => cols.has(c));
+}
+
+function threadValue(record, target, column) {
+  const created = Math.floor(record.created_at_ms / 1000);
+  const updated = Math.floor(record.updated_at_ms / 1000);
+  const values = {
+    id: record.id,
+    rollout_path: record.rollout_path,
+    created_at: created,
+    updated_at: updated,
+    source: record.source,
+    model_provider: target,
+    cwd: record.cwd,
+    title: record.title,
+    sandbox_policy: record.sandbox_policy,
+    approval_mode: record.approval_mode,
+    tokens_used: record.tokens_used,
+    has_user_event: record.has_user_event,
+    archived: record.archived,
+    archived_at: record.archived ? updated : null,
+    git_sha: record.git_sha,
+    git_branch: record.git_branch,
+    git_origin_url: record.git_origin_url,
+    cli_version: record.cli_version,
+    first_user_message: record.first_user_message,
+    memory_mode: "enabled",
+    model: record.model,
+    reasoning_effort: record.reasoning_effort,
+    created_at_ms: Math.round(record.created_at_ms),
+    updated_at_ms: Math.round(record.updated_at_ms),
+    thread_source: record.thread_source,
+    preview: record.preview,
+    recency_at: updated,
+    recency_at_ms: Math.round(record.updated_at_ms),
+    history_mode: record.history_mode,
+  };
+  return values[column];
+}
+
+function threadUpdateSet(columns, target, parameterized = false) {
+  return columns.filter((c) => c !== "id").map((c) => {
+    if (c === "model_provider") return `${c}=${parameterized ? "?" : sql(target)}`;
+    if (c === "has_user_event") return `${c}=CASE WHEN excluded.${c}=1 THEN 1 ELSE threads.${c} END`;
+    if (["cwd", "first_user_message", "preview", "thread_source"].includes(c)) {
+      return `${c}=CASE WHEN COALESCE(excluded.${c},'')<>'' THEN excluded.${c} ELSE threads.${c} END`;
+    }
+    if (c === "title") {
+      return `${c}=CASE WHEN COALESCE(threads.${c},'')='' OR threads.${c}='(无标题对话)' THEN excluded.${c} ELSE threads.${c} END`;
+    }
+    if (["updated_at", "updated_at_ms", "recency_at", "recency_at_ms"].includes(c)) {
+      return `${c}=MAX(threads.${c}, excluded.${c})`;
+    }
+    return `${c}=excluded.${c}`;
+  });
+}
+
 function sqlite3Available() {
   const r = spawnSync("sqlite3", ["--version"], { encoding: "utf-8" });
   return !r.error && r.status === 0;
@@ -164,12 +432,12 @@ function readRolloutRecord(file, titles) {
     const p = d.payload || {};
     if (d.type === "session_meta" && !rec.id) {
       rec.id = p.id || p.session_id || rec.id;
-      rec.cwd = p.cwd || rec.cwd;
-      rec.source = p.source || rec.source;
-      rec.model_provider = p.model_provider || rec.model_provider;
-      rec.thread_source = p.thread_source || rec.thread_source;
-      rec.cli_version = p.cli_version || rec.cli_version;
-      rec.history_mode = p.history_mode || rec.history_mode;
+      rec.cwd = payloadText(p.cwd, rec.cwd);
+      rec.source = payloadText(p.source, rec.source);
+      rec.model_provider = payloadText(p.model_provider, rec.model_provider);
+      rec.thread_source = payloadText(p.thread_source, rec.thread_source);
+      rec.cli_version = payloadText(p.cli_version, rec.cli_version);
+      rec.history_mode = payloadText(p.history_mode, rec.history_mode);
       rec.created_at_ms = parseTimeMs(p.timestamp || d.timestamp, rec.created_at_ms);
       if (p.git && typeof p.git === "object") {
         rec.git_sha = p.git.commit_hash || null;
@@ -182,77 +450,18 @@ function readRolloutRecord(file, titles) {
     }
   }
   rec.updated_at_ms = Math.max(rec.updated_at_ms, rec.created_at_ms);
-  rec.title = titles[rec.id] || rec.first_user_message.replace(/\s+/g, " ").slice(0, 80) || "(无标题对话)";
-  rec.preview = rec.first_user_message.replace(/\s+/g, " ").slice(0, 200);
+  rec.title = cleanThreadTitle(titles[rec.id] || "", rec.first_user_message, 80) || "(无标题对话)";
+  rec.preview = cleanUserVisibleText(rec.first_user_message).replace(/\s+/g, " ").trim().slice(0, 200);
   return rec.id ? rec : null;
 }
 
 function buildThreadUpsertSql(records, target, cols) {
-  const desired = [
-    "id", "rollout_path", "created_at", "updated_at", "source", "model_provider", "cwd", "title",
-    "sandbox_policy", "approval_mode", "tokens_used", "has_user_event", "archived", "archived_at",
-    "git_sha", "git_branch", "git_origin_url", "cli_version", "first_user_message", "memory_mode",
-    "model", "reasoning_effort", "created_at_ms", "updated_at_ms", "thread_source", "preview",
-    "recency_at", "recency_at_ms", "history_mode",
-  ].filter((c) => cols.has(c));
-  const valueFor = (r, c) => {
-    const created = Math.floor(r.created_at_ms / 1000);
-    const updated = Math.floor(r.updated_at_ms / 1000);
-    const values = {
-      id: r.id,
-      rollout_path: r.rollout_path,
-      created_at: created,
-      updated_at: updated,
-      source: r.source,
-      model_provider: target,
-      cwd: r.cwd,
-      title: r.title,
-      sandbox_policy: r.sandbox_policy,
-      approval_mode: r.approval_mode,
-      tokens_used: r.tokens_used,
-      has_user_event: r.has_user_event,
-      archived: r.archived,
-      archived_at: r.archived ? updated : null,
-      git_sha: r.git_sha,
-      git_branch: r.git_branch,
-      git_origin_url: r.git_origin_url,
-      cli_version: r.cli_version,
-      first_user_message: r.first_user_message,
-      memory_mode: "enabled",
-      model: r.model,
-      reasoning_effort: r.reasoning_effort,
-      created_at_ms: Math.round(r.created_at_ms),
-      updated_at_ms: Math.round(r.updated_at_ms),
-      thread_source: r.thread_source,
-      preview: r.preview,
-      recency_at: updated,
-      recency_at_ms: Math.round(r.updated_at_ms),
-      history_mode: r.history_mode,
-    };
-    return values[c];
-  };
-  const updateSet = [];
-  for (const c of desired) {
-    if (c === "id") continue;
-    // 【增强】model_provider 强制更新为目标 provider（切账号核心逻辑）
-    if (c === "model_provider") {
-      updateSet.push(`${c}=${sql(target)}`);
-    } else if (c === "has_user_event") {
-      updateSet.push(`${c}=CASE WHEN excluded.${c}=1 THEN 1 ELSE threads.${c} END`);
-    } else if (["cwd", "first_user_message", "preview", "thread_source"].includes(c)) {
-      updateSet.push(`${c}=CASE WHEN COALESCE(excluded.${c},'')<>'' THEN excluded.${c} ELSE threads.${c} END`);
-    } else if (c === "title") {
-      updateSet.push(`${c}=CASE WHEN COALESCE(threads.${c},'')='' OR threads.${c}='(无标题对话)' THEN excluded.${c} ELSE threads.${c} END`);
-    } else if (["updated_at", "updated_at_ms", "recency_at", "recency_at_ms"].includes(c)) {
-      updateSet.push(`${c}=MAX(threads.${c}, excluded.${c})`);
-    } else {
-      updateSet.push(`${c}=excluded.${c}`);
-    }
-  }
+  const desired = threadColumns(cols);
+  const updateSet = threadUpdateSet(desired, target);
   const lines = ["BEGIN;"];
   for (const r of records) {
     lines.push(
-      `INSERT INTO threads (${desired.join(",")}) VALUES (${desired.map((c) => sql(valueFor(r, c))).join(",")}) ` +
+      `INSERT INTO threads (${desired.join(",")}) VALUES (${desired.map((c) => sql(threadValue(r, target, c))).join(",")}) ` +
       `ON CONFLICT(id) DO UPDATE SET ${updateSet.join(",")};`
     );
   }
@@ -327,7 +536,7 @@ function rebuildSessionIndex(records, log = () => {}) {
     if (!r.id) continue;
     const indexEntry = {
       id: r.id,
-      thread_name: existingTitles[r.id] || r.title || "(无标题对话)",
+      thread_name: cleanThreadTitle(existingTitles[r.id] || "", r.first_user_message || r.title, 80) || r.title || "(无标题对话)",
       project_path: r.cwd || null,
       created_at: new Date(r.created_at_ms).toISOString(),
       source: r.source || "vscode",
@@ -346,6 +555,394 @@ function rebuildSessionIndex(records, log = () => {}) {
   }
 }
 
+function secTs(ms) {
+  const n = Number(ms);
+  if (!Number.isFinite(n) || n <= 0) return Date.now() / 1000;
+  // 兼容秒 / 毫秒两种时间戳
+  return n > 1e12 ? n / 1000 : n;
+}
+
+// 重建 Codex 桌面端侧栏目录（~/.codex/sqlite/codex-dev.db 的 local_thread_catalog）。
+// 新版 ChatGPT/Codex 启动后侧栏主要读这里；只同步 state_5.sqlite 不会让历史会话重新出现。
+function rebuildLocalThreadCatalog(records, target, log = () => {}) {
+  if (!records || !records.length) {
+    log("侧栏目录重建：无会话记录，跳过");
+    return { rebuilt: 0, skipped: true };
+  }
+  if (!fs.existsSync(LOCAL_CATALOG_DB)) {
+    log(`侧栏目录重建跳过：未找到 ${LOCAL_CATALOG_DB}`);
+    return { rebuilt: 0, skipped: true, missing: true };
+  }
+
+  // 只回填未归档、有标题/预览/用户消息的主会话。
+  // 注意：新版 Codex 从某版本起大量线程 has_user_event 默认写成 0，不能再只靠这个字段过滤。
+  const visible = [];
+  const seen = new Set();
+  for (const r of records) {
+    if (!r || !r.id || seen.has(r.id) || r.archived) continue;
+    const hasText = !!(r.first_user_message || r.preview || (r.title && r.title !== "(无标题对话)"));
+    const hasUser = !!r.has_user_event || hasText;
+    if (!hasUser) continue;
+    seen.add(r.id);
+    visible.push(r);
+  }
+  if (!visible.length) {
+    log("侧栏目录重建：没有可展示会话，跳过");
+    return { rebuilt: 0, skipped: true };
+  }
+
+  // 备份目录库
+  try {
+    const bak = LOCAL_CATALOG_DB + ".bak-" + ts();
+    fs.copyFileSync(LOCAL_CATALOG_DB, bak);
+    log(`已备份侧栏目录库 → ${path.basename(bak)}`);
+  } catch (e) {
+    log(`侧栏目录库备份失败：${e.message || e}`);
+  }
+
+  const nowSec = Date.now() / 1000;
+  let maxUpdated = 0;
+  const valuesSql = [];
+  visible.forEach((r, idx) => {
+    const created = secTs(r.created_at_ms);
+    const updated = Math.max(secTs(r.updated_at_ms), created);
+    if (updated > maxUpdated) maxUpdated = updated;
+    const title = cleanThreadTitle(r.title || "", r.first_user_message || r.preview || "", 80) || "(无标题对话)";
+    const sourceKind = String(r.source || "vscode").slice(0, 64) || "vscode";
+    const provider = target || r.model_provider || "";
+    const cwd = r.cwd || "";
+    const gitBranch = r.git_branch || null;
+    // observation_sequence 用递增序号，避免全 0 被后续 reconcile 误判
+    const obs = idx + 1;
+    valuesSql.push(
+      `(${sql("local")},${sql(r.id)},${sql(title)},${sql(created)},${sql(updated)},${sql(cwd)},` +
+        `${sql(sourceKind)},NULL,${sql(provider)},${sql(gitBranch)},${sql(obs)},0)`
+    );
+  });
+
+  const sqlText = [
+    "BEGIN;",
+    "DELETE FROM local_thread_catalog WHERE host_id='local';",
+    "INSERT INTO local_thread_catalog (" +
+      "host_id, thread_id, display_title, source_created_at, source_updated_at, cwd, " +
+      "source_kind, source_detail, model_provider, git_branch, observation_sequence, missing_candidate" +
+      ") VALUES " +
+      valuesSql.join(",\n") +
+      ";",
+    // 标记冷构建完成，避免启动后又被半残状态卡住
+    "INSERT OR IGNORE INTO local_thread_catalog_sync_state (host_id) VALUES ('local');",
+    "UPDATE local_thread_catalog_sync_state SET " +
+      `watermark_updated_at=${sql(maxUpdated || nowSec)}, ` +
+      "initial_build_complete=1, " +
+      `observation_sequence=${sql(visible.length)}, ` +
+      `last_full_reconciled_at=${sql(Math.floor(nowSec))} ` +
+      "WHERE host_id='local';",
+    "INSERT OR IGNORE INTO local_thread_catalog_hosts (host_id, host_kind) VALUES ('local','local');",
+    "INSERT OR IGNORE INTO local_thread_catalog_metadata (id, catalog_revision) VALUES (1, 0);",
+    "UPDATE local_thread_catalog_metadata SET catalog_revision=COALESCE(catalog_revision,0)+1 WHERE id=1;",
+    "COMMIT;",
+    "PRAGMA wal_checkpoint(TRUNCATE);",
+  ].join("\n") + "\n";
+
+  try {
+    if (sqlite3Available()) {
+      runSqlite3(LOCAL_CATALOG_DB, sqlText);
+    } else {
+      // 无 sqlite3 CLI 时走 sql.js（同步路径里已有依赖）
+      throw new Error("sqlite3 CLI 不可用，改走 sql.js");
+    }
+    log(`侧栏目录重建完成：${visible.length} 条（provider=${target}）`);
+    return { rebuilt: visible.length };
+  } catch (e) {
+    // sql.js 兜底
+    try {
+      // 这里用同步 require 的 initSqlJs 需要 await，调用方是 async，所以抛回给上层处理
+      return { rebuilt: 0, error: e.message || String(e), needSqlJs: true, sqlText, visibleCount: visible.length };
+    } catch (e2) {
+      log(`侧栏目录重建失败：${e.message || e}`);
+      return { rebuilt: 0, error: e.message || String(e) };
+    }
+  }
+}
+
+// Codex 桌面端对 codex-dev.db 有一套版本化迁移（PRAGMA user_version，当前迁移链到 v30，
+// 依据 ChatGPT.app 0.147.x 的 app.asar 反编译核对）。工具箱自建该库时必须把 user_version
+// 对齐到链尾：否则 Codex 会从 v0 重跑全部迁移，其中 v27/v28/v29 会把
+// local_thread_catalog_sync_state.last_full_reconciled_at 置 NULL，首次启动即触发
+// full reconcile——若 state 库线程没写成功，侧栏会话会"闪现后全部消失"。
+// Codex 升级新增 v31+ 迁移时会自然在此基础上继续，不受影响。
+const CATALOG_DB_USER_VERSION = 30;
+
+function createLocalCatalogSchema(db) {
+  db.run(`CREATE TABLE IF NOT EXISTS local_thread_catalog (
+    host_id TEXT NOT NULL,
+    thread_id TEXT NOT NULL,
+    display_title TEXT NOT NULL,
+    source_created_at REAL NOT NULL,
+    source_updated_at REAL NOT NULL,
+    cwd TEXT NOT NULL,
+    source_kind TEXT NOT NULL,
+    source_detail TEXT,
+    model_provider TEXT NOT NULL,
+    git_branch TEXT,
+    observation_sequence INTEGER NOT NULL,
+    missing_candidate INTEGER NOT NULL DEFAULT 0 CHECK (missing_candidate IN (0, 1)),
+    thread_source TEXT,
+    source_recency_at REAL NOT NULL DEFAULT 0,
+    PRIMARY KEY (host_id, thread_id)
+  )`);
+  db.run("CREATE INDEX IF NOT EXISTS local_thread_catalog_created_idx ON local_thread_catalog (host_id, source_created_at DESC, source_updated_at DESC, thread_id) WHERE missing_candidate=0");
+  db.run("CREATE INDEX IF NOT EXISTS local_thread_catalog_cwd_created_idx ON local_thread_catalog (host_id, cwd, source_created_at DESC, source_updated_at DESC, thread_id) WHERE missing_candidate=0");
+  db.run("CREATE INDEX IF NOT EXISTS local_thread_catalog_updated_idx ON local_thread_catalog (host_id, source_recency_at DESC, source_created_at DESC, thread_id) WHERE missing_candidate=0");
+  db.run("CREATE INDEX IF NOT EXISTS local_thread_catalog_cwd_updated_idx ON local_thread_catalog (host_id, cwd, source_recency_at DESC, source_created_at DESC, thread_id) WHERE missing_candidate=0");
+  db.run(`CREATE TABLE IF NOT EXISTS local_thread_catalog_sync_state (
+    host_id TEXT PRIMARY KEY,
+    watermark_updated_at REAL,
+    initial_build_complete INTEGER NOT NULL DEFAULT 0,
+    observation_sequence INTEGER NOT NULL DEFAULT 0,
+    last_full_reconciled_at INTEGER
+  )`);
+  db.run("CREATE TABLE IF NOT EXISTS local_thread_catalog_hosts (host_id TEXT PRIMARY KEY, host_kind TEXT NOT NULL CHECK (host_kind IN ('local','ssh','wsl','remote-control')))");
+  db.run("CREATE TABLE IF NOT EXISTS local_thread_catalog_metadata (id INTEGER PRIMARY KEY CHECK (id=1), catalog_revision INTEGER NOT NULL DEFAULT 0)");
+}
+
+async function rebuildLocalThreadCatalogAsync(records, target, log = () => {}) {
+  if (!records || !records.length) {
+    log("侧栏目录重建：无会话记录，跳过");
+    return { rebuilt: 0, skipped: true };
+  }
+  const visible = [];
+  const seen = new Set();
+  for (const r of records) {
+    if (!r || !r.id || seen.has(r.id) || r.archived) continue;
+    const hasText = !!(r.first_user_message || r.preview || (r.title && r.title !== "(无标题对话)"));
+    if (!(r.has_user_event || hasText)) continue;
+    seen.add(r.id);
+    visible.push(r);
+  }
+  if (!visible.length) {
+    log("侧栏目录重建：没有可展示会话，跳过");
+    return { rebuilt: 0, skipped: true };
+  }
+
+  let db;
+  const existed = fs.existsSync(LOCAL_CATALOG_DB);
+  try {
+    const SQL = await initSqlJs({
+      locateFile: (f) =>
+        path.join(global.__BUNDLE_ROOT__ || path.join(__dirname, "..", ".."), "node_modules", "sql.js", "dist", f),
+    });
+    fs.mkdirSync(path.dirname(LOCAL_CATALOG_DB), { recursive: true });
+    db = existed ? new SQL.Database(fs.readFileSync(LOCAL_CATALOG_DB)) : new SQL.Database();
+    createLocalCatalogSchema(db);
+    if (!existed) db.run(`PRAGMA user_version = ${CATALOG_DB_USER_VERSION}`);
+
+    if (existed) {
+      try {
+        const bak = LOCAL_CATALOG_DB + ".bak-" + ts();
+        fs.copyFileSync(LOCAL_CATALOG_DB, bak);
+        log(`已备份侧栏目录库 → ${path.basename(bak)}`);
+      } catch (e) {
+        log(`侧栏目录库备份失败：${e.message || e}`);
+      }
+    }
+
+    const cols = sqlJsTableColumns(db, "local_thread_catalog");
+    const insertCols = [
+      "host_id", "thread_id", "display_title", "source_created_at", "source_updated_at", "cwd",
+      "source_kind", "source_detail", "model_provider", "git_branch", "observation_sequence",
+      "missing_candidate", "thread_source", "source_recency_at",
+    ].filter((c) => cols.has(c));
+    const nowSec = Date.now() / 1000;
+    let maxUpdated = 0;
+    const valuesFor = (r, idx) => {
+      const created = secTs(r.created_at_ms);
+      const updated = Math.max(secTs(r.updated_at_ms), created);
+      maxUpdated = Math.max(maxUpdated, updated);
+      const title = cleanThreadTitle(r.title || "", r.first_user_message || r.preview || "", 80) || "(无标题对话)";
+      const values = {
+        host_id: "local",
+        thread_id: r.id,
+        display_title: title,
+        source_created_at: created,
+        source_updated_at: updated,
+        cwd: r.cwd || "",
+        source_kind: String(r.source || "vscode").slice(0, 64) || "vscode",
+        source_detail: null,
+        model_provider: target || r.model_provider || "",
+        git_branch: r.git_branch || null,
+        observation_sequence: idx + 1,
+        missing_candidate: 0,
+        thread_source: r.thread_source || "user",
+        source_recency_at: updated,
+      };
+      return insertCols.map((c) => values[c]);
+    };
+    const insert = db.prepare(
+      `INSERT INTO local_thread_catalog (${insertCols.join(",")}) VALUES (${insertCols.map(() => "?").join(",")})`
+    );
+    db.run("BEGIN");
+    db.run("DELETE FROM local_thread_catalog WHERE host_id='local'");
+    visible.forEach((r, idx) => insert.run(valuesFor(r, idx)));
+    insert.free();
+    db.run("INSERT OR IGNORE INTO local_thread_catalog_sync_state (host_id) VALUES ('local')");
+    db.run(
+      "UPDATE local_thread_catalog_sync_state SET watermark_updated_at=?, initial_build_complete=1, observation_sequence=?, last_full_reconciled_at=? WHERE host_id='local'",
+      [maxUpdated || nowSec, visible.length, Math.floor(nowSec)]
+    );
+    db.run("INSERT OR IGNORE INTO local_thread_catalog_hosts (host_id, host_kind) VALUES ('local','local')");
+    db.run("INSERT OR IGNORE INTO local_thread_catalog_metadata (id, catalog_revision) VALUES (1,0)");
+    db.run("UPDATE local_thread_catalog_metadata SET catalog_revision=COALESCE(catalog_revision,0)+1 WHERE id=1");
+    db.run("COMMIT");
+    const exported = Buffer.from(db.export());
+    db.close();
+    db = null;
+    fs.writeFileSync(LOCAL_CATALOG_DB, exported);
+    try { fs.rmSync(LOCAL_CATALOG_DB + "-wal", { force: true }); } catch {}
+    try { fs.rmSync(LOCAL_CATALOG_DB + "-shm", { force: true }); } catch {}
+    log(`侧栏目录重建完成（sql.js）：${visible.length} 条（provider=${target}）`);
+    return { rebuilt: visible.length, created: !existed };
+  } catch (e) {
+    if (db) try { db.run("ROLLBACK"); } catch {}
+    if (db) try { db.close(); } catch {}
+    log(`侧栏目录重建失败：${e.message || e}`);
+    return { rebuilt: 0, error: e.message || String(e) };
+  }
+}
+
+// 兜底：把 rollout 已确认有用户消息、但 state DB 仍为 0 的 has_user_event 强制拉起来。
+// 新版 Codex 从 7/17 起大量线程默认写成 0，仅靠 upsert 的 CASE 也可能被后续状态覆盖。
+function forceHasUserEventSql(userEventIds) {
+  if (!userEventIds || !userEventIds.size) return "";
+  const ids = [...userEventIds].map((id) => sql(id));
+  // 分批，避免单条 SQL 过长
+  const chunks = [];
+  for (let i = 0; i < ids.length; i += 200) chunks.push(ids.slice(i, i + 200));
+  return chunks
+    .map((part) => `UPDATE threads SET has_user_event=1 WHERE id IN (${part.join(",")}) AND COALESCE(has_user_event,0)<>1;`)
+    .join("\n");
+}
+
+function sqlJsTableColumns(db, table) {
+  const result = db.exec(`PRAGMA table_info("${String(table).replace(/"/g, '""')}")`);
+  if (!result.length) return new Set();
+  return new Set(result[0].values.map((row) => String(row[1] || "")).filter(Boolean));
+}
+
+function sqlJsCount(db, table) {
+  const result = db.exec(`SELECT COUNT(*) FROM "${String(table).replace(/"/g, '""')}"`);
+  return result.length && result[0].values.length ? Number(result[0].values[0][0] || 0) : 0;
+}
+
+function sqlJsLocateFile(file) {
+  return path.join(
+    global.__BUNDLE_ROOT__ || path.join(__dirname, "..", ".."),
+    "node_modules", "sql.js", "dist", file
+  );
+}
+
+async function loadSqlJs() {
+  return initSqlJs({ locateFile: sqlJsLocateFile });
+}
+
+// 创建一个可被当前 Codex 直接打开的完整 state_5.sqlite，而不是只造 threads 表。
+// 通过临时文件安装，避免 Windows 下进程中断时留下半个数据库。
+function createStateDbSqlJs(SQL, dbPath) {
+  const db = new SQL.Database();
+  try {
+    db.exec(STATE_DB_SCHEMA_SQL);
+    for (const [version, description, checksum] of STATE_DB_MIGRATIONS) {
+      db.run(
+        `INSERT INTO _sqlx_migrations (version, description, success, checksum, execution_time) ` +
+        `VALUES (${version}, ${sql(description)}, 1, X'${checksum}', 0)`
+      );
+    }
+    const tmp = `${dbPath}.td-create-${process.pid}-${Date.now()}.tmp`;
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    try {
+      fs.writeFileSync(tmp, Buffer.from(db.export()));
+      fs.renameSync(tmp, dbPath);
+    } finally {
+      try { fs.rmSync(tmp, { force: true }); } catch {}
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// sql.js 只接受 null/string/number/bigint 绑定值，其余类型直接抛错。
+function bindValue(v) {
+  if (v === null || v === undefined) return null;
+  if (typeof v === "string" || typeof v === "number") return v;
+  try {
+    const text = JSON.stringify(v);
+    if (typeof text === "string") return text;
+  } catch {}
+  return String(v);
+}
+
+// Windows 通常没有 sqlite3.exe。这里必须和 sqlite3 分支一样做 UPSERT，不能只 UPDATE 已有行，
+// 否则新机器上的 state_*.sqlite 没有 threads 时，rollout 虽然存在，Codex 仍然看不到会话。
+// 单条记录失败只跳过该条（记日志），不能让一条异常记录回滚整批——否则 state 库一条都进不去，
+// 侧栏 catalog 却重建成功，Codex 启动 full reconcile 后会话会"闪现后全部消失"。
+function upsertStateDbSqlJs(db, records, target, userEventIds, cwdById, log = () => {}) {
+  const tables = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='threads'");
+  if (!tables.length) return { insertedRows: 0, provRows: 0, ueRows: 0, cwdRows: 0, failedRows: 0, skipped: true };
+  const cols = sqlJsTableColumns(db, "threads");
+  if (!cols.has("id") || !cols.has("model_provider")) {
+    return { insertedRows: 0, provRows: 0, ueRows: 0, cwdRows: 0, failedRows: 0, skipped: true };
+  }
+  const desired = threadColumns(cols);
+  const updateSet = threadUpdateSet(desired, target, true);
+  const statement = db.prepare(
+    `INSERT INTO threads (${desired.join(",")}) VALUES (${desired.map(() => "?").join(",")}) ` +
+    `ON CONFLICT(id) DO UPDATE SET ${updateSet.join(",")}`
+  );
+  const before = sqlJsCount(db, "threads");
+  let provRows = 0;
+  let ueRows = 0;
+  let cwdRows = 0;
+  let failedRows = 0;
+  try {
+    db.run("BEGIN");
+    for (const record of records) {
+      try {
+        statement.run(desired.map((column) => bindValue(threadValue(record, target, column))).concat([target]));
+      } catch (e) {
+        failedRows++;
+        if (failedRows <= 3) log(`  线程回填跳过 ${record.id || "(无id)"}：${e.message || e}`);
+      }
+    }
+    statement.free();
+    db.run(`UPDATE threads SET model_provider=? WHERE COALESCE(model_provider,'')<>?`, [target, target]);
+    provRows = db.getRowsModified();
+    if (cols.has("has_user_event")) {
+      for (const id of userEventIds || []) {
+        db.run("UPDATE threads SET has_user_event=1 WHERE id=? AND COALESCE(has_user_event,0)<>1", [id]);
+        ueRows += db.getRowsModified();
+      }
+    }
+    if (cols.has("cwd")) {
+      for (const [id, cwd] of Object.entries(cwdById || {})) {
+        db.run("UPDATE threads SET cwd=? WHERE id=? AND COALESCE(cwd,'')<>?", [cwd, id, cwd]);
+        cwdRows += db.getRowsModified();
+      }
+    }
+    db.run("COMMIT");
+  } catch (e) {
+    try { statement.free(); } catch {}
+    try { db.run("ROLLBACK"); } catch {}
+    throw e;
+  }
+  return {
+    insertedRows: Math.max(0, sqlJsCount(db, "threads") - before),
+    provRows,
+    ueRows,
+    cwdRows,
+    failedRows,
+  };
+}
+
 async function syncProviderToCurrent(log = () => {}, onProgress = () => {}) {
   if (codexRunning()) throw new Error("检测到 Codex 正在运行，请先完全退出 Codex 再同步。");
   const target = targetProvider();
@@ -362,6 +959,12 @@ async function syncProviderToCurrent(log = () => {}, onProgress = () => {}) {
   for (const db of fs.readdirSync(CODEX_HOME).filter((f) => /^state_.*\.sqlite(?:-(?:wal|shm))?$/.test(f))) {
     fs.copyFileSync(path.join(CODEX_HOME, db), path.join(backup, db));
   }
+  // 同时备份侧栏目录库
+  if (fs.existsSync(LOCAL_CATALOG_DB)) {
+    try {
+      fs.copyFileSync(LOCAL_CATALOG_DB, path.join(backup, "codex-dev.db"));
+    } catch {}
+  }
   log(`已备份到 ${backup}`);
 
   // 2) 遍历 rollout：改首行 provider，收集完整线程元信息
@@ -424,14 +1027,35 @@ async function syncProviderToCurrent(log = () => {}, onProgress = () => {}) {
   // 2.5) Codex 项目分组来自全局 state，历史 cwd 需要合并到 project-order。
   const projectState = updateProjectState(records, log);
 
-  // 3) 更新所有 state_*.sqlite
+  // 3) 首次安装场景：目标目录可能连 state_*.sqlite 都没有。先创建完整的
+  // state_5.sqlite，再走下面统一的 sqlite3 / sql.js UPSERT 流程。
+  let SQL = null;
+  let stateDbCreated = 0;
+  let stateDbCreateError = "";
+  let stateDbNames = fs.readdirSync(CODEX_HOME).filter((f) => /^state_.*\.sqlite$/.test(f));
+  if (!stateDbNames.length) {
+    const stateDbName = "state_5.sqlite";
+    try {
+      SQL = await loadSqlJs();
+      createStateDbSqlJs(SQL, path.join(CODEX_HOME, stateDbName));
+      stateDbNames = [stateDbName];
+      stateDbCreated = 1;
+      log(`未找到 state_*.sqlite，已创建完整状态库：${stateDbName}`);
+    } catch (e) {
+      stateDbCreateError = e.message || String(e);
+      log(`创建 state_5.sqlite 失败：${stateDbCreateError}`);
+    }
+  }
+
+  // 4) 更新所有 state_*.sqlite
   onProgress({ phase: "更新数据库", done: 0, total: 0 });
   if (sqlite3Available()) {
     let provRows = 0;
     let ueRows = 0;
     let cwdRows = 0;
     let insertedRows = 0;
-    for (const name of fs.readdirSync(CODEX_HOME).filter((f) => /^state_.*\.sqlite$/.test(f))) {
+    const forceUeSql = forceHasUserEventSql(userEventIds);
+    for (const name of stateDbNames) {
       const dbPath = path.join(CODEX_HOME, name);
       try {
         const cols = sqliteCols(dbPath);
@@ -440,6 +1064,8 @@ async function syncProviderToCurrent(log = () => {}, onProgress = () => {}) {
         const beforeUserEvent = Number(runSqlite3(dbPath, "SELECT COUNT(*) FROM threads WHERE COALESCE(has_user_event,0)<>1;\n").trim() || 0);
         const beforeRows = Number(runSqlite3(dbPath, "SELECT COUNT(*) FROM threads;\n").trim() || 0);
         runSqlite3(dbPath, buildThreadUpsertSql(records, target, cols));
+        // 兜底：强制把 rollout 已确认有用户消息的线程 has_user_event 拉起来
+        if (forceUeSql) runSqlite3(dbPath, "BEGIN;\n" + forceUeSql + "\nCOMMIT;\n");
         runSqlite3(dbPath, "PRAGMA wal_checkpoint(TRUNCATE);\n");
         const afterUserEvent = Number(runSqlite3(dbPath, "SELECT COUNT(*) FROM threads WHERE COALESCE(has_user_event,0)<>1;\n").trim() || 0);
         const afterRows = Number(runSqlite3(dbPath, "SELECT COUNT(*) FROM threads;\n").trim() || 0);
@@ -457,6 +1083,11 @@ async function syncProviderToCurrent(log = () => {}, onProgress = () => {}) {
     onProgress({ phase: "重建索引", done: 0, total: 0 });
     const indexResult = rebuildSessionIndex(records, log);
 
+    // 【关键修复】5) 重建 Codex 桌面侧栏 local_thread_catalog
+    // 新版 ChatGPT/Codex 侧栏读的是 ~/.codex/sqlite/codex-dev.db，不是 state_5.sqlite。
+    onProgress({ phase: "重建侧栏目录", done: 0, total: 0 });
+    const catalogResult = await rebuildLocalThreadCatalogAsync(records, target, log);
+
     onProgress({ phase: "完成", done: 0, total: 0 });
 
     return {
@@ -471,61 +1102,55 @@ async function syncProviderToCurrent(log = () => {}, onProgress = () => {}) {
       projectRows: projectState.addedProjects,
       projectlessRemoved: projectState.removedProjectless,
       indexRebuilt: indexResult.rebuilt || 0,
+      catalogRebuilt: catalogResult.rebuilt || 0,
+      stateDbCreated,
+      stateDbCreateError,
       backup,
     };
   }
 
-  const SQL = await initSqlJs({
-    // wasm 恒在【包内】node_modules（热更包不含 node_modules），故用 BUNDLE_ROOT 而非 __dirname
-    locateFile: (f) =>
-      path.join(global.__BUNDLE_ROOT__ || path.join(__dirname, "..", ".."),
-        "node_modules", "sql.js", "dist", f),
-  });
+  if (!SQL) SQL = await loadSqlJs();
   let provRows = 0;
   let ueRows = 0;
   let cwdRows = 0;
-  for (const name of fs.readdirSync(CODEX_HOME).filter((f) => /^state_.*\.sqlite$/.test(f))) {
+  let insertedRows = 0;
+  let failedRows = 0;
+  for (const name of stateDbNames) {
     const dbPath = path.join(CODEX_HOME, name);
     let db;
     try {
       db = new SQL.Database(fs.readFileSync(dbPath));
-      const tbl = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='threads'");
-      if (!tbl.length) {
+      const result = upsertStateDbSqlJs(db, records, target, userEventIds, cwdById, log);
+      if (result.skipped) {
         db.close();
+        db = null;
         continue;
       }
-      const cols = new Set(db.exec("PRAGMA table_info(threads)")[0].values.map((r) => r[1]));
-      if (!cols.has("model_provider")) {
-        db.close();
-        continue;
-      }
-      db.run("UPDATE threads SET model_provider=? WHERE COALESCE(model_provider,'')<>?", [target, target]);
-      provRows += db.getRowsModified();
-      if (cols.has("has_user_event")) {
-        for (const tid of userEventIds) {
-          db.run("UPDATE threads SET has_user_event=1 WHERE id=? AND COALESCE(has_user_event,0)<>1", [tid]);
-          ueRows += db.getRowsModified();
-        }
-      }
-      if (cols.has("cwd")) {
-        for (const tid of Object.keys(cwdById)) {
-          db.run("UPDATE threads SET cwd=? WHERE id=? AND COALESCE(cwd,'')<>?", [cwdById[tid], tid, cwdById[tid]]);
-          cwdRows += db.getRowsModified();
-        }
-      }
+      provRows += result.provRows;
+      ueRows += result.ueRows;
+      cwdRows += result.cwdRows;
+      insertedRows += result.insertedRows;
+      failedRows += result.failedRows || 0;
       fs.writeFileSync(dbPath, Buffer.from(db.export()));
       db.close();
+      db = null;
+      try { fs.rmSync(dbPath + "-wal", { force: true }); } catch {}
+      try { fs.rmSync(dbPath + "-shm", { force: true }); } catch {}
     } catch (e) {
       if (db) try { db.close(); } catch {}
       log(`  数据库跳过 ${name}：${e.message || e}`);
     }
   }
-  log(`数据库更新：provider ${provRows} 行、has_user_event ${ueRows} 行、cwd ${cwdRows} 行`);
+  log(`数据库更新：provider ${provRows} 行、has_user_event ${ueRows} 行、cwd ${cwdRows} 行、新增线程 ${insertedRows} 行${failedRows ? `、失败跳过 ${failedRows} 行` : ""}`);
 
   // 【增强】4) 重建 session_index.jsonl，确保所有会话都在索引中
   onProgress({ phase: "重建索引", done: 0, total: 0 });
   const indexResult = rebuildSessionIndex(records, log);
 
+  // 【关键修复】5) 重建 Codex 桌面侧栏 local_thread_catalog
+  onProgress({ phase: "重建侧栏目录", done: 0, total: 0 });
+  const catalogResult = await rebuildLocalThreadCatalogAsync(records, target, log);
+
   onProgress({ phase: "完成", done: 0, total: 0 });
 
   return {
@@ -536,12 +1161,15 @@ async function syncProviderToCurrent(log = () => {}, onProgress = () => {}) {
     provRows,
     ueRows,
     cwdRows,
-    insertedRows: 0,
+    insertedRows,
     projectRows: projectState.addedProjects,
     projectlessRemoved: projectState.removedProjectless,
     indexRebuilt: indexResult.rebuilt || 0,
+    catalogRebuilt: catalogResult.rebuilt || 0,
+    stateDbCreated,
+    stateDbCreateError,
     backup,
   };
 }
 
-module.exports = { syncProviderToCurrent, codexRunning, targetProvider };
+module.exports = { syncProviderToCurrent, codexRunning, targetProvider, setCodexDataDir };
diff --git a/electron/lib/purge.js b/electron/lib/purge.js
index e6d5449..b1fce46 100644
--- a/electron/lib/purge.js
+++ b/electron/lib/purge.js
@@ -7,6 +7,7 @@ const os = require("os");
 const { exec } = require("child_process");
 
 const codex = require("./codex");
+const codexDesktop = require("./codex_desktop");
 
 const IS_WIN = process.platform === "win32";
 
@@ -85,6 +86,11 @@ async function detectInstalls() {
   add("Codex 数据目录（配置 · 登录 · 会话 · 插件）", "data", path.join(home, ".codex"));
 
   // 2) PATH 里的可执行文件（which / where 可能返回多行）
+  for (const item of codexDesktop.desktopExecutableCandidates()) {
+    add(item.label || "ChatGPT/Codex 桌面程序", "bin", item.path);
+  }
+
+  // 3) PATH 里的可执行文件（which / where 可能返回多行）
   const whichOut = IS_WIN ? await run("where codex") : await run("which -a codex");
   if (whichOut) {
     for (const line of whichOut.split(/\r?\n/)) {
@@ -103,7 +109,7 @@ async function detectInstalls() {
     }
   }
 
-  // 3) npm 全局包与 npm 全局 bin
+  // 4) npm 全局包与 npm 全局 bin
   const npmRoot = await run(IS_WIN ? "npm.cmd root -g" : "npm root -g");
   if (npmRoot) add("@openai/codex 安装包（npm 全局）", "npm-package", path.join(npmRoot, "@openai", "codex"));
 
@@ -116,7 +122,7 @@ async function detectInstalls() {
     add("@openai/codex 安装包（npm 全局）", "npm-package", path.join(npmPrefix, IS_WIN ? "node_modules" : "lib/node_modules", "@openai", "codex"));
   }
 
-  // 4) 各平台常见固定位置兜底
+  // 5) 各平台常见固定位置兜底
   if (IS_WIN) {
     const appdata = process.env.APPDATA || path.join(home, "AppData", "Roaming");
     for (const n of ["codex", "codex.cmd", "codex.ps1"]) {
diff --git a/electron/lib/router.js b/electron/lib/router.js
index 2d971a1..1f851ff 100644
--- a/electron/lib/router.js
+++ b/electron/lib/router.js
@@ -1,5 +1,5 @@
-// router.js —— 本地路由/中转代理：Codex 直连本地，指令经此转发到"当前分组"的中转 API。
-// 切分组只改内存里的 activeId，Codex 那头地址不变 → 秒切、无需重启 Codex。
+// router.js —— 本地路由/中转代理：Codex 直连本地，默认指令经 activeId 转发；
+// 若请求显式携带已登记的 model，则按 model 路由到对应分组，支持总控/子 Agent 分组并行。
 const http = require("http");
 const https = require("https");
 const fs = require("fs");
@@ -9,16 +9,145 @@ const crypto = require("crypto");
 const { URL } = require("url");
 const { app, safeStorage } = require("electron");
 const translate = require("./translate");
+const mediaUnderstanding = require("./media-understanding");
 
-const CODEX_HOME = path.join(os.homedir(), ".codex");
+let CODEX_HOME = path.join(os.homedir(), ".codex");
 const CLAUDE_HOME = path.join(os.homedir(), ".claude");
 const PROVIDER_ID = "local-router"; // config.toml 里的 provider 名（走本地路由进程时用）
 const DIRECT_PROVIDER_ID = "td-direct"; // config.toml 里的 provider 名（直连中转、不经路由时用）
 
+function setCodexDataDir(dir) {
+  if (typeof dir !== "string" || !dir.trim()) return;
+  CODEX_HOME = path.resolve(dir);
+}
+
 function cfgPath() {
   return path.join(app.getPath("userData"), "router.json");
 }
 
+const RETRYABLE_WRITE_CODES = new Set(["EACCES", "EBUSY", "EEXIST", "ENOTEMPTY", "EPERM"]);
+
+function sleepSync(ms) {
+  if (!ms) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function retryWriteOperation(fn) {
+  const delays = [0, 10, 25, 50, 100, 200];
+  let lastError;
+  for (const delay of delays) {
+    if (delay) sleepSync(delay);
+    try {
+      return fn();
+    } catch (e) {
+      lastError = e;
+      if (!RETRYABLE_WRITE_CODES.has(e && e.code)) throw e;
+    }
+  }
+  throw lastError;
+}
+
+// Windows 上 Codex/安全软件可能短暂占用配置文件。先同目录原子替换，失败时重试，
+// 再退化为带重试的直接覆盖；最终回读校验，绝不把写入失败伪装成切换成功。
+function safeWriteFileSync(file, content, encoding) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const data = Buffer.isBuffer(content) ? content : Buffer.from(String(content), encoding || "utf-8");
+  const tmp = `${file}.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+  const before = readFileState(file);
+  let targetMayHaveChanged = false;
+  try {
+    retryWriteOperation(() => fs.writeFileSync(tmp, data));
+    try {
+      retryWriteOperation(() => fs.renameSync(tmp, file));
+      targetMayHaveChanged = true;
+    } catch (renameError) {
+      if (!RETRYABLE_WRITE_CODES.has(renameError && renameError.code)) throw renameError;
+      targetMayHaveChanged = true;
+      retryWriteOperation(() => fs.writeFileSync(file, data));
+    }
+    const actual = retryWriteOperation(() => fs.readFileSync(file));
+    if (!actual.equals(data)) {
+      const error = new Error(`写入后校验失败：${file}`);
+      error.code = "EVERIFY";
+      throw error;
+    }
+  } catch (e) {
+    let rollbackError = null;
+    if (targetMayHaveChanged) {
+      try {
+        if (before.exists) retryWriteOperation(() => fs.writeFileSync(file, before.data));
+        else retryWriteOperation(() => fs.rmSync(file, { force: true }));
+      } catch (restoreError) {
+        rollbackError = restoreError;
+      }
+    }
+    const detail = e && e.code ? `${e.code}: ${e.message}` : String((e && e.message) || e);
+    const rollbackDetail = rollbackError
+      ? `；原内容恢复失败：${rollbackError.code || "ERROR"}: ${rollbackError.message}`
+      : "";
+    throw new Error(`无法写入配置文件 ${file}（${detail}）${rollbackDetail}`);
+  } finally {
+    try { fs.rmSync(tmp, { force: true }); } catch {}
+  }
+}
+
+function readFileState(file) {
+  try {
+    return { exists: true, data: retryWriteOperation(() => fs.readFileSync(file)) };
+  } catch (e) {
+    if (e && e.code === "ENOENT") return { exists: false, data: null };
+    throw e;
+  }
+}
+
+function restoreFileState(file, state) {
+  if (state.exists) {
+    safeWriteFileSync(file, state.data);
+    return;
+  }
+  retryWriteOperation(() => fs.rmSync(file, { force: true }));
+}
+
+function writeCodexConfigPair(configText, authText) {
+  const configFile = path.join(CODEX_HOME, "config.toml");
+  const authFile = path.join(CODEX_HOME, "auth.json");
+  const beforeConfig = readFileState(configFile);
+  const beforeAuth = readFileState(authFile);
+  try {
+    safeWriteFileSync(configFile, configText, "utf-8");
+    safeWriteFileSync(authFile, authText, "utf-8");
+    try { fs.chmodSync(authFile, 0o600); } catch {}
+  } catch (writeError) {
+    const rollbackErrors = [];
+    try { restoreFileState(configFile, beforeConfig); } catch (e) { rollbackErrors.push(`config.toml: ${(e && e.message) || e}`); }
+    try { restoreFileState(authFile, beforeAuth); } catch (e) { rollbackErrors.push(`auth.json: ${(e && e.message) || e}`); }
+    if (rollbackErrors.length) {
+      throw new Error(`${writeError.message}；回滚失败：${rollbackErrors.join("；")}`);
+    }
+    throw writeError;
+  }
+}
+
+function readJsonForUpdate(file) {
+  const text = readTextForUpdate(file);
+  if (!text.trim()) return {};
+  try {
+    const value = JSON.parse(text);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch (e) {
+    throw new Error(`配置文件 JSON 解析失败 ${file}：${e.message}`);
+  }
+}
+
+function readTextForUpdate(file) {
+  try {
+    return retryWriteOperation(() => fs.readFileSync(file, "utf-8"));
+  } catch (e) {
+    if (e && e.code === "ENOENT") return "";
+    throw e;
+  }
+}
+
 // —— 加解密（复用 safeStorage）——
 function enc(s) {
   if (!s) return "";
@@ -48,6 +177,8 @@ function defaultConfig() {
 
 // 分组所属协议族：claude 模式 = Anthropic 族，其余（responses/chat/默认）= OpenAI 族
 function isClaudeGroup(g) { return !!g && g.mode === "claude"; }
+// 工具/插件专用分组：只给画布、技能或插件显式调用，不参与 Codex/GPT 默认分组选择。
+function isToolOnlyGroup(g) { return !!g && !g.isDefault && (g.codexImage || g.codexVideo || g.stt); }
 function load() {
   if (config) return config;
   try {
@@ -78,10 +209,23 @@ function migrateActiveSlots() {
   if (act && isClaudeGroup(act)) {
     if (!config.activeClaudeId) config.activeClaudeId = act.id;
     // 优先选真正的中转分组（非默认、非 claude）；没有再退到默认分组
-    const proxy = config.groups.find((g) => !isClaudeGroup(g) && !g.isDefault);
+    const proxy = config.groups.find((g) => !isClaudeGroup(g) && !g.isDefault && !isToolOnlyGroup(g));
     const fallback = config.groups.find((g) => !isClaudeGroup(g));
     config.activeId = (proxy || fallback || {}).id || null;
   }
+  const activeOpenAI = config.groups.find((g) => g.id === config.activeId);
+  if (isToolOnlyGroup(activeOpenAI)) {
+    const proxy = config.groups.find((g) => !isClaudeGroup(g) && !g.isDefault && !isToolOnlyGroup(g));
+    const fallback = config.groups.find((g) => !isClaudeGroup(g) && !isToolOnlyGroup(g));
+    config.activeId = (proxy || fallback || {}).id || null;
+    save();
+  }
+  const activeClaude = config.groups.find((g) => g.id === config.activeClaudeId);
+  if (isToolOnlyGroup(activeClaude)) {
+    const cg = config.groups.find((g) => isClaudeGroup(g) && !isToolOnlyGroup(g));
+    config.activeClaudeId = cg ? cg.id : null;
+    save();
+  }
   // 补齐 claude 槽：若从未设过，且存在 claude 分组，默认选第一个
   if (!config.activeClaudeId) {
     const cg = config.groups.find((g) => isClaudeGroup(g));
@@ -101,8 +245,7 @@ function save() {
     }),
   };
   const p = cfgPath();
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  fs.writeFileSync(p, JSON.stringify(out, null, 2));
+  safeWriteFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   try {
     fs.chmodSync(p, 0o600);
   } catch {}
@@ -115,6 +258,88 @@ function activeGroup(wantClaude) {
   return config.groups.find((g) => g.id === id) || null;
 }
 
+function requestModel(body) {
+  try {
+    const parsed = JSON.parse(Buffer.isBuffer(body) ? body.toString("utf-8") : String(body || ""));
+    return String(parsed && parsed.model || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+function requestRouteHintModel(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.isBuffer(body) ? body.toString("utf-8") : String(body || ""));
+  } catch {
+    return "";
+  }
+  const seen = new Set();
+  const texts = [];
+  const walk = (value) => {
+    if (value == null) return;
+    if (typeof value === "string") {
+      texts.push(value);
+      return;
+    }
+    if (typeof value !== "object" || seen.has(value)) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      value.forEach(walk);
+      return;
+    }
+    for (const key of ["instructions", "text", "content", "input", "output", "arguments", "prompt"]) {
+      walk(value[key]);
+    }
+  };
+  walk(parsed);
+  const text = texts.join("\n");
+  const m = text.match(/TD_MODEL_ROUTE\s+model=["']?([^"'\]\s;]+)/i);
+  return m ? String(m[1] || "").trim() : "";
+}
+
+function rewriteRequestModel(body, model) {
+  const target = String(model || "").trim();
+  if (!target || !body.length) return body;
+  let j;
+  try {
+    j = JSON.parse(body.toString("utf-8"));
+  } catch {
+    return body;
+  }
+  if (!j || typeof j !== "object" || Array.isArray(j) || j.model === target) return body;
+  j.model = target;
+  return Buffer.from(JSON.stringify(j), "utf-8");
+}
+
+// 返回 { group, byModel }：显式模型命中 routeModels 时不受 activeId 影响。
+// routeModels 由员工团队生成时登记，避免用户切换激活分组后子 Agent 跑错上游。
+function requestGroup(wantClaude, body) {
+  const active = activeGroup(wantClaude);
+  if (wantClaude) return { group: active, byModel: false };
+  load();
+  const candidates = config.groups.filter((g) =>
+    !g.isDefault && !isClaudeGroup(g) && !isToolOnlyGroup(g) && g.baseUrl && g.key
+  );
+
+  // 只有带明确路由提示的团队/子 Agent 请求才按模型覆盖 activeId。
+  // 普通 Codex 请求如果仍然带着旧的模型名（例如顶部选择器未刷新，还停留在
+  // kimi-k3），绝不能因为 exact/routeModels 命中而把用户刚选的 activeId 拽回去。
+  const hintModel = requestRouteHintModel(body);
+  if (hintModel) {
+    const explicit = candidates.find((g) => Array.isArray(g.routeModels) && g.routeModels.includes(hintModel));
+    if (explicit) return { group: explicit, byModel: true, routeModel: hintModel };
+    const exact = candidates.find((g) => g.model && String(g.model) === hintModel);
+    if (exact) return { group: exact, byModel: true, routeModel: hintModel };
+  }
+
+  const model = requestModel(body);
+  if (!model) return { group: active, byModel: false };
+  const explicit = candidates.find((g) => Array.isArray(g.routeModels) && g.routeModels.includes(model));
+  if (explicit) return { group: explicit, byModel: true, routeModel: model };
+  return { group: active, byModel: false };
+}
+
 // 判断一个进来的请求是否是 Anthropic 协议（Claude Code）：走 /v1/messages，或带 anthropic 头。
 function reqIsAnthropic(req) {
   const h = req.headers || {};
@@ -134,6 +359,11 @@ function currentModelProvider() {
   const m = head.match(/^\s*model_provider\s*=\s*["']([^"']+)/m);
   return m ? m[1] : "";
 }
+function modelProviderFromText(text) {
+  const head = String(text || "").split("\n[")[0];
+  const m = head.match(/^\s*model_provider\s*=\s*["']([^"']+)/m);
+  return m ? m[1] : "";
+}
 // 读根级 model（新版桌面 Codex 登录态通常没有；用于复原时精确还原/清除中转写入的 model）
 function currentRootModel() {
   const head = readConfigToml().split("\n[")[0];
@@ -153,6 +383,36 @@ function readAuthKey() {
     return "";
   }
 }
+function maskSecret(s) {
+  if (!s) return "";
+  if (s.length <= 10) return "****";
+  return s.slice(0, 6) + "..." + s.slice(-4);
+}
+function authSummaryFromText(text) {
+  if (!text) return { exists: false, loginMode: "未检测到凭证", hasOpenAIKey: false, keyPreview: "", hasTokens: false };
+  try {
+    const a = JSON.parse(text);
+    const key = a.OPENAI_API_KEY || "";
+    const tokens = a.tokens || {};
+    const hasTokens = !!(tokens.access_token || tokens.id_token || tokens.refresh_token);
+    return {
+      exists: true,
+      loginMode: hasTokens ? "ChatGPT OAuth 登录" : (key ? "API Key" : "未检测到凭证"),
+      hasOpenAIKey: !!key,
+      keyPreview: maskSecret(key),
+      hasTokens,
+    };
+  } catch {
+    return { exists: true, loginMode: "auth.json 解析失败", hasOpenAIKey: false, keyPreview: "", hasTokens: false };
+  }
+}
+function readAuthSummary() {
+  try {
+    return authSummaryFromText(fs.readFileSync(path.join(CODEX_HOME, "auth.json"), "utf-8"));
+  } catch {
+    return authSummaryFromText("");
+  }
+}
 // 是否已用自己账号登录 Codex（ChatGPT OAuth）——凭证是 auth.json 的 tokens，而非 API key。
 // 这是「我的账号 · 直连」的真实判据：只要 tokens 在，切中转只是覆盖 OPENAI_API_KEY，登录不会丢。
 function isLoggedIn() {
@@ -179,6 +439,93 @@ function removeTomlSection(text, header) {
   }
   return out.join("\n").replace(/\n{3,}/g, "\n\n");
 }
+function isManagedProviderId(id) {
+  return id === PROVIDER_ID || id === DIRECT_PROVIDER_ID;
+}
+function configLooksManaged(text) {
+  const s = String(text || "");
+  if (!s.trim()) return false;
+  if (isManagedProviderId(modelProviderFromText(s))) return true;
+  return s.includes(`[model_providers.${PROVIDER_ID}]`) || s.includes(`[model_providers.${DIRECT_PROVIDER_ID}]`);
+}
+
+// 当前 Codex 是否仍保留“本地路由”接管痕迹。这个状态只用于页面显示和取消按钮，
+// 不把直连中转（td-direct）误显示成已启用本地路由。
+function codexRouteApplied() {
+  const text = readConfigToml();
+  if (modelProviderFromText(text) === PROVIDER_ID) return true;
+  if (extractProviderBlock(text, PROVIDER_ID)) return true;
+  try {
+    const auth = JSON.parse(readTextIfExists(path.join(CODEX_HOME, "auth.json")) || "{}");
+    return auth.OPENAI_API_KEY === config.routerKey;
+  } catch {
+    return false;
+  }
+}
+function cleanOfficialConfigToml(text) {
+  let out = String(text || "");
+  out = removeTomlSection(out, `model_providers.${PROVIDER_ID}`);
+  out = removeTomlSection(out, `model_providers.${DIRECT_PROVIDER_ID}`);
+  out = out.replace(/^\s*model_provider\s*=.*$\n?/m, "");
+  out = out.replace(/^\s*model\s*=.*$\n?/m, "");
+  return out.replace(/\n{3,}/g, "\n\n").trimEnd() + (out.trim() ? "\n" : "");
+}
+function authLooksManaged(text) {
+  try {
+    const auth = JSON.parse(text || "{}");
+    const key = auth.OPENAI_API_KEY || "";
+    return !!(key && (key === config.routerKey || /^rk-[a-z0-9-]+/i.test(key) || config.groups.some((g) => !g.isDefault && g.key === key)));
+  } catch {
+    return false;
+  }
+}
+function cleanOfficialAuthJson(text) {
+  let auth = {};
+  try { auth = JSON.parse(text || "{}"); } catch {}
+  const tokens = auth.tokens || {};
+  const hasTokens = !!(tokens.access_token || tokens.id_token || tokens.refresh_token);
+  if (hasTokens || authLooksManaged(text)) delete auth.OPENAI_API_KEY;
+  return JSON.stringify(auth, null, 2);
+}
+function readTextIfExists(file) {
+  try { return fs.readFileSync(file, "utf-8"); } catch { return ""; }
+}
+function routerConfigBackups() {
+  const dir = path.join(CODEX_HOME, "backups_state", "router");
+  let names = [];
+  try { names = fs.readdirSync(dir); } catch { return []; }
+  return names
+    .filter((n) => /^config\.toml\.\d+\.bak$/.test(n))
+    .sort((a, b) => {
+      const ta = Number((a.match(/\.(\d+)\.bak$/) || [])[1] || 0);
+      const tb = Number((b.match(/\.(\d+)\.bak$/) || [])[1] || 0);
+      return ta - tb;
+    })
+    .map((n) => readTextIfExists(path.join(dir, n)))
+    .filter(Boolean);
+}
+function bestOfficialConfigToml(...preferred) {
+  const officialDir = path.join(CODEX_HOME, "backups_state", "router", "official-login");
+  const candidates = [
+    readTextIfExists(path.join(officialDir, "config.toml.clean")),
+    readTextIfExists(path.join(officialDir, "config.toml.orig")),
+    ...routerConfigBackups(),
+    ...preferred,
+  ].filter((s) => s && s.trim());
+  const clean = candidates.find((s) => !configLooksManaged(s));
+  if (clean) return clean.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+  return cleanOfficialConfigToml(candidates[0] || "");
+}
+function bestOfficialAuthJson(...preferred) {
+  const officialDir = path.join(CODEX_HOME, "backups_state", "router", "official-login");
+  const candidates = [
+    readTextIfExists(path.join(officialDir, "auth.json.clean")),
+    readTextIfExists(path.join(officialDir, "auth.json.orig")),
+    ...preferred,
+  ].filter((s) => s && s.trim());
+  const clean = candidates.find((s) => !authLooksManaged(s));
+  return cleanOfficialAuthJson(clean || candidates[0] || "{}");
+}
 
 function backupConfig(text) {
   try {
@@ -191,12 +538,50 @@ function backupConfig(text) {
 // 完整快照进默认分组 def.officialBackup，并落一份磁盘副本。幂等：只在第一次真正执行。
 // 保证任何时候「切回默认」都能 100% 还原回官方登录态。
 function snapshotOfficialLogin(def) {
-  if (!def) return;
-  if (def.officialBackup && def.officialBackup.done) return; // 幂等守卫
+  if (!def) return false;
   let configToml = "";
   let authJson = "";
   try { configToml = fs.readFileSync(path.join(CODEX_HOME, "config.toml"), "utf-8"); } catch {}
   try { authJson = fs.readFileSync(path.join(CODEX_HOME, "auth.json"), "utf-8"); } catch {}
+  const backup = def.officialBackup || {};
+  const backupAuth = backup.authJson || "";
+  const hasTokens = isLoggedIn() || !!authSummaryFromText(backupAuth).hasTokens || !!authSummaryFromText(authJson).hasTokens;
+  const polluted = configLooksManaged(backup.configToml || "") || authLooksManaged(backup.authJson || "")
+    || isManagedProviderId(def.modelProvider);
+  if (backup.done && !hasTokens && !polluted) return false; // 纯 API key 老用户且快照干净：沿用原始快照。
+  if (hasTokens || polluted) {
+    const cleanConfigToml = bestOfficialConfigToml(backup.configToml || "", configToml);
+    const cleanAuthJson = bestOfficialAuthJson(backup.authJson || "", authJson);
+    const changed = !backup.done
+      || backup.configToml !== cleanConfigToml
+      || backup.authJson !== cleanAuthJson
+      || def.modelProvider
+      || def.providerBlock
+      || def.authKey
+      || def.origModel;
+    const cleanProvider = modelProviderFromText(cleanConfigToml);
+    def.modelProvider = cleanProvider && !isManagedProviderId(cleanProvider) ? cleanProvider : "";
+    def.providerBlock = def.modelProvider ? extractProviderBlock(cleanConfigToml, def.modelProvider) : "";
+    def.authKey = "";
+    def.origModel = "";
+    def.officialBackup = {
+      done: true,
+      ts: backup.ts || Date.now(),
+      repairedTs: changed ? Date.now() : backup.repairedTs,
+      configToml: cleanConfigToml,
+      authJson: cleanAuthJson,
+      hadTokens: hasTokens,
+    };
+    try {
+      const dir = path.join(CODEX_HOME, "backups_state", "router", "official-login");
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, "config.toml.clean"), cleanConfigToml, "utf-8");
+      fs.writeFileSync(path.join(dir, "auth.json.clean"), cleanAuthJson, "utf-8");
+      try { fs.chmodSync(path.join(dir, "auth.json.clean"), 0o600); } catch {}
+    } catch {}
+    return !!changed;
+  }
+  if (backup.done) return false; // 幂等守卫
   // 磁盘副本（灾备）：仅当不存在时写，避免二次接管覆盖原始官方备份
   try {
     const dir = path.join(CODEX_HOME, "backups_state", "router", "official-login");
@@ -216,6 +601,7 @@ function snapshotOfficialLogin(def) {
     authJson,
     hadTokens: isLoggedIn(),
   };
+  return true;
 }
 // 首次使用时，把当前(原始)Codex 配置快照为不可删除的「默认」分组。
 // 铁律：默认分组必须代表「我的账号 · 直连」的登录态，绝不能是接入中转的状态，
@@ -225,15 +611,17 @@ function ensureDefault() {
   const loggedIn = isLoggedIn();
   const existing = config.groups.find((g) => g.isDefault);
   if (existing) {
-    snapshotOfficialLogin(existing); // 幂等：确保已装用户也补上官方登录完整备份
+    let changed = snapshotOfficialLogin(existing); // 幂等：确保已装用户也补上官方登录完整备份，并修复历史污染快照
     // 自愈：已用自己账号登录，但历史版本把默认分组错误地快照成了中转 provider →
     // 纠正为「纯登录态」，保证「切回默认」永远能干净复原自己账号。
     if (loggedIn && (existing.modelProvider || existing.providerBlock || existing.authKey)) {
       existing.modelProvider = "";
       existing.providerBlock = "";
       existing.authKey = "";
-      save();
+      existing.origModel = "";
+      changed = true;
     }
+    if (changed) save();
     return;
   }
   if (loggedIn) {
@@ -255,7 +643,7 @@ function ensureDefault() {
   }
   // 未用 OAuth 登录（纯 API key 用户，无 tokens 可保护）：沿用原逻辑，快照当前直连 provider。
   const prov = currentModelProvider();
-  if (!prov || prov === PROVIDER_ID) return; // 已是本地路由 / 无配置 → 不快照
+  if (!prov || isManagedProviderId(prov)) return; // 已是本软件接管 / 无配置 → 不快照
   const text = readConfigToml();
   config.groups.unshift({
     id: "default",
@@ -276,6 +664,53 @@ function catalogPath() {
   const name = m ? m[1] : "cc-switch-model-catalog.json";
   return path.isAbsolute(name) ? name : path.join(CODEX_HOME, name);
 }
+
+// 国产模型的实际可用窗口通常小于 Codex 模板模型。分组未填写时给出保守值，
+// 让 Codex 在上游拒绝请求前预留足够空间完成自动压缩。用户填写的值始终优先
+// （≥1024 即生效；过小的值多半也是有意为之，比如想强制尽早压缩）。
+function effectiveContextWindow(group, fallback = 0) {
+  const configured = parseInt(group && group.contextWindow, 10);
+  if (configured >= 1024) return configured;
+  const hint = `${group && group.model || ""} ${group && group.name || ""}`.toLowerCase();
+  if (/deepseek/.test(hint)) return 65536;
+  if (/kimi/.test(hint)) return 131072;
+  return fallback;
+}
+
+function setCompactionHeadroom(model, window) {
+  // Desktop starts its own compaction from this ratio.  The 95% inherited from
+  // GPT templates leaves too little room for the compaction prompt on 64K/128K
+  // third-party models, so the request can hit the provider limit first.
+  if (!model || !window) return;
+  model.effective_context_window_percent = Math.min(
+    Number(model.effective_context_window_percent) || 95,
+    80
+  );
+}
+// Codex 只有在 config.toml 显式写了 model_catalog_json 时才会读本地模型目录；不写这行，
+// 本工具登记的 context_window / 压缩阈值全部无效，Codex 会把未知模型按默认 GPT 模板
+// （272000×95%≈258K）处理 → 深度求索/Kimi 真实窗口远小于此 → 永远等不到自动压缩。
+// 另外该路径按进程 CWD 解析（桌面端 CWD 不固定），必须写绝对路径。
+// 已指向其它目录文件时尊重用户配置不动；目录文件不存在/为空时跳过，避免 Codex 启动报错。
+function ensureCatalogLinked(text) {
+  const abs = catalogPath();
+  try {
+    const cat = JSON.parse(fs.readFileSync(abs, "utf-8"));
+    if (!cat || !Array.isArray(cat.models) || !cat.models.length) return text;
+  } catch {
+    return text;
+  }
+  const m = String(text || "").match(/^\s*model_catalog_json\s*=\s*["']([^"']+)["']/m);
+  if (m) {
+    const existing = m[1];
+    const resolved = path.isAbsolute(existing) ? existing : path.join(CODEX_HOME, existing);
+    if (resolved !== abs) return text; // 用户指向了自己的目录文件，尊重
+    if (path.isAbsolute(existing)) return text; // 已是绝对路径且指向同一文件
+    return text.replace(/^\s*model_catalog_json\s*=.*$/m, `model_catalog_json = "${abs}"`);
+  }
+  return `model_catalog_json = "${abs}"\n${text}`;
+}
+
 // 把分组的模型 + 上下文窗口写进 Codex 模型目录，让 Codex 按真实窗口自动压缩
 // 铁律：只要分组指定了 model，就必须保证它在目录里存在（visibility=list）。
 // 否则 config.toml 的根级 model 指向一个「目录里没有的模型」，Codex 会以未知模型启动、
@@ -291,12 +726,13 @@ function applyModelCatalog(group) {
     return; // 无目录文件就不动
   }
   if (!cat.models || !cat.models.length) return;
-  const win = parseInt(group.contextWindow, 10); // 未填 → NaN（假值），此时保留/沿用既有窗口
+  const win = effectiveContextWindow(group); // 未填时为 DeepSeek/Kimi 使用保守窗口
   const existing = cat.models.find((m) => m.slug === group.model);
   if (existing) {
     if (win) {
       existing.context_window = win;
       existing.max_context_window = win;
+      setCompactionHeadroom(existing, win);
     }
     existing.visibility = "list"; // 已在目录：无论有无窗口，都确保可见
   } else {
@@ -308,6 +744,7 @@ function applyModelCatalog(group) {
     tpl.description = group.model;
     tpl.context_window = w;
     tpl.max_context_window = w;
+    setCompactionHeadroom(tpl, w);
     tpl.priority = 900;
     tpl.visibility = "list";
     cat.models.push(tpl);
@@ -315,7 +752,7 @@ function applyModelCatalog(group) {
   try {
     fs.writeFileSync(p + ".bak-router", fs.readFileSync(p));
   } catch {}
-  fs.writeFileSync(p, JSON.stringify(cat, null, 2), "utf-8");
+  safeWriteFileSync(p, JSON.stringify(cat, null, 2), "utf-8");
 }
 // 【根治「切模型丢会话」】把分组中转站 /models 返回的全部文本模型，先登记进 Codex 模型目录。
 // 关键：用户是在 Codex 本体的模型选择器里切模型的，那条路径不经过本 App，App 的 applyModelCatalog
@@ -345,30 +782,41 @@ async function syncCatalogFromProvider(group) {
     if (!cat.models || !cat.models.length) return { ok: false, error: "模型目录为空" };
     const tpl0 = cat.models[0];
     const w0 = parseInt(tpl0.context_window, 10) || 128000;
+    // 回填窗口用分组的真实窗口（用户填写 > 国产模型保守值 > 模板窗口），并统一压缩阈值；
+    // 否则回填模型继承 GPT 模板的 272000×95%≈258K，Codex 永远等不到自动压缩。
+    const win = effectiveContextWindow(group, w0);
     let added = 0;
     let revealed = 0;
+    let refreshed = 0;
     for (const slug of textIds) {
       const ex = cat.models.find((m) => m.slug === slug);
       if (ex) {
         if (ex.visibility !== "list") { ex.visibility = "list"; revealed++; }
+        if (win && (ex.context_window !== win || ex.max_context_window !== win)) {
+          ex.context_window = win;
+          ex.max_context_window = win;
+          refreshed++;
+        }
+        setCompactionHeadroom(ex, win);
         continue;
       }
       const t = JSON.parse(JSON.stringify(tpl0)); // 克隆模板(含 base_instructions 等必需字段)
       t.slug = slug;
       t.display_name = slug;
       t.description = slug;
-      t.context_window = w0;
-      t.max_context_window = w0;
+      t.context_window = win;
+      t.max_context_window = win;
+      setCompactionHeadroom(t, win);
       t.priority = 900;
       t.visibility = "list";
       cat.models.push(t);
       added++;
     }
-    if (added || revealed) {
+    if (added || revealed || refreshed) {
       try { fs.writeFileSync(p + ".bak-router", fs.readFileSync(p)); } catch {}
-      fs.writeFileSync(p, JSON.stringify(cat, null, 2), "utf-8");
+      safeWriteFileSync(p, JSON.stringify(cat, null, 2), "utf-8");
     }
-    return { ok: true, added, revealed, total: textIds.length };
+    return { ok: true, added, revealed, refreshed, total: textIds.length };
   } catch (e) {
     return { ok: false, error: (e && e.message) || String(e) };
   }
@@ -390,7 +838,7 @@ function ensureModelInCatalog(model) {
     if (existing.visibility !== "list") {
       existing.visibility = "list";
       try { fs.writeFileSync(p + ".bak-router", fs.readFileSync(p)); } catch {}
-      fs.writeFileSync(p, JSON.stringify(cat, null, 2), "utf-8");
+      safeWriteFileSync(p, JSON.stringify(cat, null, 2), "utf-8");
     }
     return;
   }
@@ -405,26 +853,51 @@ function ensureModelInCatalog(model) {
   tpl.visibility = "list";
   cat.models.push(tpl);
   try { fs.writeFileSync(p + ".bak-router", fs.readFileSync(p)); } catch {}
-  fs.writeFileSync(p, JSON.stringify(cat, null, 2), "utf-8");
+  safeWriteFileSync(p, JSON.stringify(cat, null, 2), "utf-8");
 }
 // 把 config.toml 根级 model 设成指定值（写入前先确保该模型已在目录里，避免 Codex 以未知模型启动）
 function setConfigModel(model) {
   if (!model) return;
   ensureModelInCatalog(model);
   const cfgFile = path.join(CODEX_HOME, "config.toml");
-  let text = readConfigToml();
-  if (/^\s*model\s*=/m.test(text)) text = text.replace(/^\s*model\s*=.*$/m, `model = "${model}"`);
-  else text = text.replace(/^(\s*model_provider\s*=.*)$/m, `$1\nmodel = "${model}"`);
-  fs.writeFileSync(cfgFile, text, "utf-8");
+  let text = readTextForUpdate(cfgFile);
+  text = setRootModelInText(text, model);
+  text = ensureCatalogLinked(text);
+  safeWriteFileSync(cfgFile, text, "utf-8");
+}
+
+function setRootModelInText(text, model) {
+  if (!model) return text;
+  if (/^\s*model\s*=/m.test(text)) return text.replace(/^\s*model\s*=.*$/m, `model = "${model}"`);
+  if (/^\s*model_provider\s*=/m.test(text)) {
+    return text.replace(/^(\s*model_provider\s*=.*)$/m, `$1\nmodel = "${model}"`);
+  }
+  return `model = "${model}"\n${text}`;
 }
 
 // 恢复到默认（把 config.toml/auth.json 还原成客户原始配置，Codex 直连自己账号）
 function restoreDirect() {
   const def = config.groups.find((g) => g.isDefault);
-  if (!def) return;
+  if (!def) {
+    // 没有默认分组时也必须清理本工具的接管痕迹，不能让“取消路由”变成空操作。
+    const cfgFile = path.join(CODEX_HOME, "config.toml");
+    const before = readTextForUpdate(cfgFile);
+    backupConfig(before);
+    const text = cleanOfficialConfigToml(before);
+    const authFile = path.join(CODEX_HOME, "auth.json");
+    const authText = cleanOfficialAuthJson(readTextForUpdate(authFile));
+    writeCodexConfigPair(text, authText);
+    return;
+  }
+  if (snapshotOfficialLogin(def)) save();
   const cfgFile = path.join(CODEX_HOME, "config.toml");
-  let text = readConfigToml();
+  let text = readTextForUpdate(cfgFile);
   backupConfig(text);
+  if (def.officialBackup && def.officialBackup.done && def.officialBackup.configToml && !configLooksManaged(def.officialBackup.configToml)) {
+    const authText = def.officialBackup.authJson || JSON.stringify(readJsonForUpdate(path.join(CODEX_HOME, "auth.json")), null, 2);
+    writeCodexConfigPair(def.officialBackup.configToml, authText);
+    return;
+  }
   // 先移除本地路由段 + 直连中转段（无论哪种复原都要清掉，避免残留污染）
   text = removeTomlSection(text, `model_providers.${PROVIDER_ID}`);
   text = removeTomlSection(text, `model_providers.${DIRECT_PROVIDER_ID}`);
@@ -445,23 +918,18 @@ function restoreDirect() {
     if (def.origModel) text = `model = "${def.origModel}"\n` + text;
   }
   text = text.replace(/\n{3,}/g, "\n\n");
-  fs.writeFileSync(cfgFile, text, "utf-8");
   const af = path.join(CODEX_HOME, "auth.json");
+  let authText;
   // 优先用官方登录完整备份整体还原（含 OAuth tokens）→ 100% 复原官方登录态
   if (def.officialBackup && def.officialBackup.done && def.officialBackup.hadTokens && def.officialBackup.authJson) {
-    try {
-      fs.writeFileSync(af, def.officialBackup.authJson, "utf-8");
-      fs.chmodSync(af, 0o600);
-      return;
-    } catch {}
-  }
-  try {
-    const a = JSON.parse(fs.readFileSync(af, "utf-8"));
+    authText = def.officialBackup.authJson;
+  } else {
+    const a = readJsonForUpdate(af);
     // 登录态：清空 OPENAI_API_KEY、保留 tokens → Codex 用 OAuth 直连；纯 key 用户则还原原始 key
     a.OPENAI_API_KEY = def.authKey || null;
-    fs.writeFileSync(af, JSON.stringify(a, null, 2), "utf-8");
-    fs.chmodSync(af, 0o600);
-  } catch {}
+    authText = JSON.stringify(a, null, 2);
+  }
+  writeCodexConfigPair(text, authText);
 }
 
 function getGroupKey(id) {
@@ -476,6 +944,32 @@ function groupById(id) {
   return config.groups.find((x) => x.id === id) || null;
 }
 
+// 登记一个模型属于哪个 OpenAI 兼容分组。生成团队时调用，运行时按请求 model 分流。
+// 只保存模型名和分组归属，不改变当前激活分组，也不触碰 Codex 配置文件。
+function registerModelRoute(groupId, model) {
+  load();
+  const name = String(model || "").trim();
+  const group = config.groups.find((g) => g.id === groupId);
+  if (!name || !group || group.isDefault || isClaudeGroup(group) || !group.baseUrl || !group.key) {
+    return { ok: false, skipped: true };
+  }
+  let changed = false;
+  config.groups.forEach((g) => {
+    if (g.id === group.id) return;
+    if (Array.isArray(g.routeModels) && g.routeModels.includes(name)) {
+      g.routeModels = g.routeModels.filter((x) => x !== name);
+      changed = true;
+    }
+  });
+  group.routeModels = Array.isArray(group.routeModels) ? group.routeModels : [];
+  if (!group.routeModels.includes(name)) {
+    group.routeModels.push(name);
+    changed = true;
+  }
+  if (changed) save();
+  return { ok: true, groupId: group.id, model: name, changed };
+}
+
 // 可供画布等内部功能"按需选用"的中转分组列表：排除默认直连分组，需配齐 baseUrl+key。只读。
 function usableGroups() {
   load();
@@ -486,7 +980,7 @@ function usableGroups() {
 // 不可用则取第一个配置齐全的中转分组；默认分组（直连账号）不参与。
 function llmGroup() {
   load();
-  const usable = (g) => g && !g.isDefault && g.baseUrl && g.key && g.model;
+  const usable = (g) => g && !g.isDefault && !isToolOnlyGroup(g) && g.baseUrl && g.key && g.model;
   const act = config.groups.find((g) => g.id === config.activeId);
   if (usable(act)) return act;
   return config.groups.find(usable) || null;
@@ -502,28 +996,54 @@ function sttGroup() {
   return config.groups.find(ok) || null;
 }
 
+function modelFetchBases(baseUrl) {
+  const base = String(baseUrl || "").replace(/\/$/, "");
+  const bases = [base];
+  try {
+    const u = new URL(base);
+    if (/\/anthropic$/i.test(u.pathname)) {
+      u.pathname = u.pathname.replace(/\/anthropic$/i, "") || "/";
+      bases.push(u.href.replace(/\/$/, ""));
+    }
+  } catch {}
+  return Array.from(new Set(bases.filter(Boolean)));
+}
+
+function knownModelsForBase(baseUrl) {
+  try {
+    const u = new URL(String(baseUrl || ""));
+    if (u.hostname === "api.deepseek.com" && /\/anthropic\/?$/i.test(u.pathname)) {
+      return ["deepseek-v4-pro[1m]", "deepseek-v4-flash"];
+    }
+  } catch {}
+  return [];
+}
+
 // 拉取某个中转 API 的模型列表（试 /v1/models 再 /models）
 async function fetchModels(baseUrl, key) {
   if (!baseUrl) throw new Error("请先填 API 地址");
-  const base = baseUrl.replace(/\/$/, "");
   let lastErr = null;
-  for (const p of ["/v1/models", "/models"]) {
-    try {
-      const res = await fetch(base + p, {
-        headers: { Authorization: "Bearer " + (key || ""), "User-Agent": "codex-market" },
-      });
-      if (!res.ok) {
-        lastErr = new Error("HTTP " + res.status);
-        continue;
+  for (const base of modelFetchBases(baseUrl)) {
+    for (const p of ["/v1/models", "/models"]) {
+      try {
+        const res = await fetch(base + p, {
+          headers: { Authorization: "Bearer " + (key || ""), "User-Agent": "codex-market" },
+        });
+        if (!res.ok) {
+          lastErr = new Error("HTTP " + res.status);
+          continue;
+        }
+        const j = await res.json();
+        const arr = Array.isArray(j) ? j : j.data || j.models || [];
+        const list = arr.map((m) => (typeof m === "string" ? m : m.id || m.name)).filter(Boolean);
+        if (list.length) return Array.from(new Set(list));
+      } catch (e) {
+        lastErr = e;
       }
-      const j = await res.json();
-      const arr = Array.isArray(j) ? j : j.data || j.models || [];
-      const list = arr.map((m) => (typeof m === "string" ? m : m.id || m.name)).filter(Boolean);
-      if (list.length) return Array.from(new Set(list));
-    } catch (e) {
-      lastErr = e;
     }
   }
+  const known = knownModelsForBase(baseUrl);
+  if (known.length) return known;
   throw lastErr || new Error("未获取到模型列表（接口可能不支持 /v1/models）");
 }
 
@@ -541,6 +1061,30 @@ function writeCapture(name, data) {
   } catch {}
 }
 
+function upstreamHeaders(incoming, host, bodyLength) {
+  const headers = { ...(incoming || {}) };
+  const connectionHeaders = String(headers.connection || "")
+    .split(",")
+    .map((name) => name.trim().toLowerCase())
+    .filter(Boolean);
+  for (const name of connectionHeaders) delete headers[name];
+  for (const name of [
+    "connection",
+    "proxy-connection",
+    "keep-alive",
+    "transfer-encoding",
+    "te",
+    "trailer",
+    "upgrade",
+    "content-length",
+  ]) {
+    delete headers[name];
+  }
+  headers.host = host;
+  headers["content-length"] = bodyLength;
+  return headers;
+}
+
 function requestTextForIntent(req) {
   const parts = [];
   const walk = (v) => {
@@ -573,7 +1117,7 @@ function stripGenImageSkill(instructions) {
     .join("\n");
 }
 
-function rewriteResponsesBody(body, group) {
+function rewriteResponsesBody(body, group, { preserveModel = false } = {}) {
   if (!body.length) return body;
   let j;
   try {
@@ -583,7 +1127,7 @@ function rewriteResponsesBody(body, group) {
   }
   if (!j || typeof j !== "object") return body;
   let changed = false;
-  if (group.model && "model" in j && j.model !== group.model) {
+  if (!preserveModel && group.model && "model" in j && j.model !== group.model) {
     j.model = group.model;
     changed = true;
   }
@@ -599,16 +1143,23 @@ function rewriteResponsesBody(body, group) {
   return changed ? Buffer.from(JSON.stringify(j), "utf-8") : body;
 }
 
-function handle(req, res) {
-  // 按请求协议派发：Claude Code(Anthropic) → activeClaudeId；Codex/GPT(OpenAI) → activeId。
-  // 这样两族各转发到各自激活的分组，可同时使用、互不顶替。
-  const wantClaude = reqIsAnthropic(req);
-  const g = activeGroup(wantClaude);
-  if (!g) {
-    res.writeHead(503, { "content-type": "text/plain; charset=utf-8" });
-    res.end(wantClaude ? "本地路由：未选择 Claude Code 分组" : "本地路由：未选择中转分组");
-    return;
+function rewriteAnthropicBody(body, group) {
+  const model = group && group.model ? String(group.model).trim() : "";
+  if (!body.length || !model) return body;
+  let j;
+  try {
+    j = JSON.parse(body.toString("utf-8"));
+  } catch {
+    return body;
   }
+  if (!j || typeof j !== "object" || Array.isArray(j)) return body;
+  if (j.model === model) return body;
+  j.model = model;
+  return Buffer.from(JSON.stringify(j), "utf-8");
+}
+
+function handle(req, res) {
+  const wantClaude = reqIsAnthropic(req);
   // 校验路由 key（Codex 用 auth.json 里的 routerKey 作 Bearer 发来）
   const auth = req.headers["authorization"] || "";
   if (config.routerKey && auth !== "Bearer " + config.routerKey) {
@@ -616,17 +1167,38 @@ function handle(req, res) {
   }
   const chunks = [];
   req.on("data", (c) => chunks.push(c));
-  req.on("end", () => {
-    let body = Buffer.concat(chunks);
+  req.on("end", async () => {
+    const rawBody = Buffer.concat(chunks);
+    const routed = requestGroup(wantClaude, rawBody);
+    const g = routed.group;
+    if (!g) {
+      res.writeHead(503, { "content-type": "text/plain; charset=utf-8" });
+      res.end(wantClaude ? "本地路由：未选择 Claude Code 分组" : "本地路由：未选择中转分组");
+      return;
+    }
+    let body = rawBody;
     const doCapture = /responses/.test(req.url || "");
-    if (doCapture) body = rewriteResponsesBody(body, g);
+    if (routed.routeModel) body = rewriteRequestModel(body, routed.routeModel);
+    if (doCapture) body = rewriteResponsesBody(body, g, { preserveModel: routed.byModel });
+    if (wantClaude) body = rewriteAnthropicBody(body, g);
     // —— chat 模式：Responses ⇄ Chat Completions 协议转换（DeepSeek/GLM/Kimi 等）——
     if (g.mode === "chat" && /responses/.test(req.url || "")) {
       let responsesReq = {};
       try {
         responsesReq = JSON.parse(body.toString("utf-8"));
       } catch {}
-      const chatReq = translate.responsesToChat(responsesReq, g.model || responsesReq.model);
+      if (g.multimodal) {
+        try {
+          await mediaUnderstanding.enrichResponsesRequest(responsesReq, {
+            instruction: requestTextForIntent(responsesReq),
+          });
+        } catch {}
+      }
+      const chatReq = translate.responsesToChat(responsesReq, routed.byModel ? responsesReq.model : (g.model || responsesReq.model), {
+        // 图片已由 MiniMax 预处理为证据，故只移除会读取原图的 view_image；
+        // shell/文件等编码工具仍必须保留，否则模型只能回复一句文字而无法执行任务。
+        omitVisualTools: !!g.multimodal,
+      });
       const chatBody = Buffer.from(JSON.stringify(chatReq), "utf-8");
       // 拼 chat 端点：多数网关/厂商(DeepSeek/GLM/Kimi/one-api)是 /v1/chat/completions
       const cbase = g.baseUrl.replace(/\/$/, "");
@@ -730,8 +1302,7 @@ function handle(req, res) {
     }
     const isHttps = target.protocol === "https:";
     const mod = isHttps ? https : http;
-    const headers = { ...req.headers };
-    headers["host"] = target.host;
+    const headers = upstreamHeaders(req.headers, target.host, body.length);
     // Anthropic 风格请求（Claude Code 走 /v1/messages）：保持客户端原本的认证方式，只把密钥换成分组的真实密钥。
     // 关键：不要同时塞 Bearer + x-api-key —— 有的中转会据此判定为"直连 API 模式"而落到空账号池，返回 "No available accounts"。
     const isAnthropic = /\/v1\/messages/.test(req.url || "") || "anthropic-version" in headers || "x-api-key" in headers;
@@ -758,8 +1329,6 @@ function handle(req, res) {
         headers["anthropic-beta"] = existing ? (existing.includes(beta) ? existing : existing + "," + beta) : beta;
       }
     }
-    delete headers["content-length"];
-    if (body.length) headers["content-length"] = Buffer.byteLength(body);
     if (doCapture) {
       writeCapture("last-request.json", `URL ${req.method} ${req.url}\nUPSTREAM ${target.href}\n\n` + body.toString("utf-8"));
     }
@@ -815,6 +1384,62 @@ function stop() {
   }
   return { running: false };
 }
+
+// 只解除本工具对 Codex 的接管，不把用户后来手写的 provider 覆盖成官方直连。
+// 关键边界：如果根级 model_provider 已经不是 local-router/td-direct，说明用户已经
+// 自己写了中转 provider，此时只清理本工具残留的段和路由 Key，保留用户配置。
+function releaseCodexTakeover() {
+  load();
+  const cfgFile = path.join(CODEX_HOME, "config.toml");
+  const before = readTextForUpdate(cfgFile);
+  backupConfig(before);
+
+  const managedProvider = isManagedProviderId(modelProviderFromText(before));
+  let text = before;
+  // 无论根级当前指向谁，都先移除本工具可能残留的两个段，避免污染用户配置。
+  text = removeTomlSection(text, `model_providers.${PROVIDER_ID}`);
+  text = removeTomlSection(text, `model_providers.${DIRECT_PROVIDER_ID}`);
+  if (managedProvider) {
+    // 根级还指向本工具，才删根级 model_provider 和根级 model；否则不碰用户配置。
+    text = text.replace(/^\s*model_provider\s*=.*$\n?/m, "");
+    text = text.replace(/^\s*model\s*=.*$\n?/m, "");
+  }
+  text = text.replace(/\n{3,}/g, "\n\n").trimEnd() + (text.trim() ? "\n" : "");
+
+  const authFile = path.join(CODEX_HOME, "auth.json");
+  const authRaw = readTextForUpdate(authFile);
+  const auth = readJsonForUpdate(authFile);
+  const authManaged = authLooksManaged(authRaw);
+  if (authManaged) delete auth.OPENAI_API_KEY;
+  writeCodexConfigPair(text, JSON.stringify(auth, null, 2));
+  return {
+    removedManagedProvider: managedProvider,
+    keptUserProvider: !managedProvider && !!modelProviderFromText(text),
+    authCleared: authManaged,
+  };
+}
+
+// 路由页面的“停止”：关闭本地服务；只要 Codex 仍有本软件接管痕迹，就释放接管。
+// 保留 stop() 的纯停止语义，避免改端口、退出应用等流程产生配置写入副作用。
+function stopAndRestoreDirect() {
+  return disableCodex();
+}
+
+// “取消本地路由”必须是幂等操作：无论路由进程当前是否运行，只要 Codex 配置仍由本工具接管，
+// 都立即清除 local-router / td-direct / 路由 Key，同时保留用户自己写的 provider。
+function disableCodex() {
+  load();
+  const shouldRelease = configLooksManaged(readConfigToml())
+    || authLooksManaged(readTextIfExists(path.join(CODEX_HOME, "auth.json")));
+  const stopped = stop();
+  if (!shouldRelease) return { ...stopped, released: false, skippedRelease: true };
+  try {
+    const detail = releaseCodexTakeover();
+    return { ...stopped, released: true, ...detail };
+  } catch (e) {
+    return { ...stopped, released: false, releaseError: String((e && e.message) || e) };
+  }
+}
 function isRunning() {
   return !!server;
 }
@@ -829,6 +1454,7 @@ function status() {
     activeId: config.activeId,
     activeClaudeId: config.activeClaudeId,
     claudeApplied: claudeApplied(),
+    codexApplied: codexRouteApplied(),
     groups: config.groups.map((g) => ({
       id: g.id,
       name: g.name,
@@ -839,13 +1465,47 @@ function status() {
       hasKey: g.isDefault ? true : !!g.key,
       isDefault: !!g.isDefault,
       codexImage: !!g.codexImage,
+      codexVideo: !!g.codexVideo,
       stt: !!g.stt,
       sttModel: g.sttModel || "",
+      multimodal: !!g.multimodal,
       oneMillionModels: Array.isArray(g.oneMillionModels) ? g.oneMillionModels : [],
     })),
   };
 }
 
+function defaultConfigInfo() {
+  load();
+  const def = config.groups.find((g) => g.isDefault) || null;
+  if (def && snapshotOfficialLogin(def)) save();
+  const currentConfigToml = readConfigToml();
+  const snapshotConfigToml = (def && def.officialBackup && def.officialBackup.configToml) || "";
+  const snapshotAuthJson = (def && def.officialBackup && def.officialBackup.authJson) || "";
+  return {
+    ok: true,
+    codexHome: CODEX_HOME,
+    configPath: path.join(CODEX_HOME, "config.toml"),
+    authPath: path.join(CODEX_HOME, "auth.json"),
+    currentConfigToml,
+    snapshotConfigToml,
+    current: {
+      modelProvider: currentModelProvider() || "Codex 原生登录态",
+      model: currentRootModel() || "",
+      managed: configLooksManaged(currentConfigToml) || authLooksManaged(readTextIfExists(path.join(CODEX_HOME, "auth.json"))),
+      auth: readAuthSummary(),
+    },
+    snapshot: {
+      savedAt: def && def.officialBackup && def.officialBackup.ts ? def.officialBackup.ts : 0,
+      repairedAt: def && def.officialBackup && def.officialBackup.repairedTs ? def.officialBackup.repairedTs : 0,
+      modelProvider: (def && def.modelProvider) || "Codex 原生登录态",
+      model: (def && def.origModel) || "",
+      hasProviderBlock: !!(def && def.providerBlock),
+      managed: configLooksManaged(snapshotConfigToml) || authLooksManaged(snapshotAuthJson),
+      auth: authSummaryFromText(snapshotAuthJson),
+    },
+  };
+}
+
 // ——————————————————————————————————————————————————————————————
 // gen-image 生图技能：把「用于 Codex 生图」的中转分组凭证写进技能的 .env
 // ——————————————————————————————————————————————————————————————
@@ -912,6 +1572,8 @@ function syncGenImage() {
 // —— 分组增删改 / 切换 ——
 function upsertGroup(g) {
   load();
+  // 附件理解仅在 Responses -> Chat 的转译路径生效，避免错误保存到其它协议分组。
+  g.multimodal = g.mode === "chat" && !!g.multimodal;
   let id;
   let prevMode = null; // 编辑前的接口类型（用于判断是否从 claude 改成别的）
   if (g.id) {
@@ -924,62 +1586,43 @@ function upsertGroup(g) {
     config.groups.push(g);
     id = g.id;
   }
-  // 首个分组自动激活到所属协议族的槽：claude→activeClaudeId，其余→activeId
-  const curG = config.groups.find((x) => x.id === id);
-  if (isClaudeGroup(curG)) { if (!config.activeClaudeId) config.activeClaudeId = id; }
-  else { if (!config.activeId) config.activeId = id; }
   // 生图来源唯一：勾选的分组独占，清掉其它分组的标记
   const cur = config.groups.find((x) => x.id === id);
   if (cur && cur.codexImage) {
     for (const grp of config.groups) if (grp.id !== id) grp.codexImage = false;
   }
+  // 视频来源唯一：勾选的分组独占，清掉其它分组的标记
+  if (cur && cur.codexVideo) {
+    for (const grp of config.groups) if (grp.id !== id) grp.codexVideo = false;
+  }
+  if (isToolOnlyGroup(cur) && config.activeId === id) {
+    const next = config.groups.find((x) => !isClaudeGroup(x) && !x.isDefault && !isToolOnlyGroup(x))
+      || config.groups.find((x) => !isClaudeGroup(x) && !isToolOnlyGroup(x));
+    config.activeId = next ? next.id : null;
+  }
+  if (isToolOnlyGroup(cur) && config.activeClaudeId === id) {
+    const next = config.groups.find((x) => isClaudeGroup(x) && !isToolOnlyGroup(x));
+    config.activeClaudeId = next ? next.id : null;
+  }
   save();
   try { syncGenImage(); } catch {}
-  // 保存分组后按接口类型分流：
-  //  - claude 模式：把分组直连配置写进 ~/.claude/settings.json（接入 Claude Code CLI），不碰 Codex
-  //  - responses/chat 模式：把直连中转配置写进 Codex config.toml（不经路由、不起进程）
+  // 保存只保存配置，不自动接入 Codex/Claude，也不改 activeId。
+  // 真正启用由用户点击列表单选触发 setActive，避免插件专用分组被误设为默认对话分组。
   const st = status();
   if (cur && !cur.isDefault) {
-    if (cur.mode === "claude") {
-      // 接入 Claude Code
-      if (!cur.baseUrl || !cur.key) {
-        st._claudeSkipped = true;
-        st._claudeReason = "该分组缺少 API 地址或密钥，未写入 Claude Code 配置";
-      } else {
-        try {
-          const rc = applyDirectToClaude(cur.id);
-          if (rc.ok) st._claudeApplied = true;
-          else { st._claudeSkipped = true; st._claudeReason = rc.error || "写入失败"; }
-        } catch (e) {
-          st._claudeError = String((e && e.message) || e);
-        }
-      }
-    } else {
-      // 接入 Codex（responses 直连 / chat 协议转换）
-      // 仅当【本分组】之前是 claude 模式、现改回 Codex 模式 → 还原它写过的 Claude Code 配置
-      if (prevMode === "claude" && config.claudePrev && claudeDirectApplied()) {
-        try { restoreClaudeCode(); st._claudeRestored = true; } catch {}
-      }
-      if (isRunning()) {
-        st._directSkipped = true;
-        st._directReason = "本地路由运行中，保存的分组走路由生效（切分组无需重启）";
-      } else if (!cur.baseUrl || !cur.key) {
-        st._directSkipped = true;
-        st._directReason = "该分组缺少 API 地址或密钥，未写入 Codex 配置";
-      } else if (cur.mode === "chat") {
-        st._directSkipped = true;
-        st._directNeedRouter = true;
-        st._directReason = "该分组为 Chat 协议转换模式，需启用本地路由才能接入 Codex";
-      } else {
-        try {
-          const r = applyDirectToCodex(cur.id);
-          if (r.ok) { st._directApplied = true; st.activeId = config.activeId; }
-          else { st._directSkipped = true; st._directReason = r.error || "写入失败"; }
-        } catch (e) {
-          st._directError = String((e && e.message) || e);
-        }
+    if (cur.id === config.activeClaudeId && cur.mode === "claude") {
+      try {
+        const r = claudeApplied() ? applyToClaudeCode() : (claudeDirectApplied() ? applyDirectToClaude(cur.id) : null);
+        if (r && r.ok) st._claudeApplied = true;
+        else if (r && !r.ok) { st._claudeSkipped = r.skipped; st._claudeReason = r.error; }
+      } catch (e) {
+        st._claudeError = (e && e.message) || String(e);
       }
     }
+    // 仅当【本分组】之前是 claude 模式、现改回 Codex 模式 → 还原它写过的 Claude Code 配置
+    if (prevMode === "claude" && cur.mode !== "claude" && config.claudePrev && claudeDirectApplied()) {
+      try { restoreClaudeCode(); st._claudeRestored = true; } catch {}
+    }
   }
   return st;
 }
@@ -992,12 +1635,13 @@ function deleteGroup(id) {
   // 删的是哪族分组，就补选同族的另一个（找不到则清空该族激活槽），不影响另一族。
   if (wasClaude) {
     if (config.activeClaudeId === id) {
-      const next = config.groups.find((x) => isClaudeGroup(x));
+      const next = config.groups.find((x) => isClaudeGroup(x) && !isToolOnlyGroup(x));
       config.activeClaudeId = next ? next.id : null;
     }
   } else {
     if (config.activeId === id) {
-      const next = config.groups.find((x) => !isClaudeGroup(x));
+      const next = config.groups.find((x) => !isClaudeGroup(x) && !x.isDefault && !isToolOnlyGroup(x))
+        || config.groups.find((x) => !isClaudeGroup(x) && !isToolOnlyGroup(x));
       config.activeId = next ? next.id : null;
     }
   }
@@ -1009,58 +1653,87 @@ function setActive(id) {
   load();
   const target = config.groups.find((g) => g.id === id);
   if (!target) return status();
+  if (isToolOnlyGroup(target)) {
+    return {
+      ...status(),
+      _activeSkipped: true,
+      _activeReason: "该分组是插件/画布专用分组，不参与 Codex/GPT 默认分组选择",
+    };
+  }
   // Claude Code（Anthropic 族）：落 activeClaudeId，写 ~/.claude/settings.json，绝不碰 Codex 配置。
   // 与 OpenAI 族互不顶替 —— 两族可同时激活。
   if (isClaudeGroup(target)) {
+    const previousActiveClaudeId = config.activeClaudeId;
+    const hadClaudePrev = Object.prototype.hasOwnProperty.call(config, "claudePrev");
+    const previousClaudePrev = hadClaudePrev ? JSON.parse(JSON.stringify(config.claudePrev)) : undefined;
     config.activeClaudeId = id;
-    let claudeMode = "proxy";
-    let claudeSkipped, claudeReason;
-    if (isRunning()) {
-      // 路由在跑：settings.json 指向本地路由即可，路由按 activeClaudeId 动态转发，无需改文件、无需重启
-      claudeMode = "proxy";
-      if (!claudeApplied()) applyToClaudeCode();
-    } else {
-      // 默认模式：直连中转，把分组地址写进 settings.json（新开 claude 会话生效）
-      claudeMode = "direct";
-      const r = applyDirectToClaude(id);
-      if (!r.ok) { claudeSkipped = r.skipped; claudeReason = r.error; }
+    try {
+      let claudeMode = "proxy";
+      let claudeSkipped, claudeReason;
+      if (isRunning()) {
+        // 路由在跑：settings.json 指向本地路由，并同步 ANTHROPIC_MODEL 让新开 CLI 立即显示当前分组模型。
+        claudeMode = "proxy";
+        const r = applyToClaudeCode();
+        if (!r.ok) { claudeSkipped = r.skipped; claudeReason = r.error; }
+      } else {
+        // 默认模式：直连中转，把分组地址写进 settings.json（新开 claude 会话生效）
+        claudeMode = "direct";
+        const r = applyDirectToClaude(id);
+        if (!r.ok) { claudeSkipped = r.skipped; claudeReason = r.error; }
+      }
+      save();
+      return { ...status(), _mode: claudeMode, _claudeSkipped: claudeSkipped, _claudeReason: claudeReason };
+    } catch (e) {
+      config.activeClaudeId = previousActiveClaudeId;
+      if (hadClaudePrev) config.claudePrev = previousClaudePrev;
+      else delete config.claudePrev;
+      save();
+      throw e;
     }
-    save();
-    return { ...status(), _mode: claudeMode, _claudeSkipped: claudeSkipped, _claudeReason: claudeReason };
   }
   const before = currentModelProvider();
   const wasTakenOver = before === PROVIDER_ID || before === DIRECT_PROVIDER_ID;
+  const previousActiveId = config.activeId;
   let needsRestart = false;
+  let needsCodexRefresh = false;
   let mode = "proxy";
-  if (target.isDefault) {
-    // 切回默认 = 还原原始配置，Codex 直连自己账号（需重启 Codex）
-    restoreDirect();
-    mode = "direct";
-    needsRestart = wasTakenOver; // 之前在走路由或直连中转 → 需重启
-  } else if (isRunning()) {
-    // 路由进程在跑（高级模式）：确保 config.toml 指向本地路由，秒切无需重启
-    mode = "proxy";
-    if (before !== PROVIDER_ID) {
-      applyToCodex();
-      needsRestart = true; // 从直连/默认切到路由 → 需重启一次
-    }
-    if (target.model) {
-      applyModelCatalog(target);
-      setConfigModel(target.model);
-    }
-  } else {
-    // 默认模式：直连中转，改 config.toml 指向该分组地址（必然需重启 Codex）
-    mode = "direct";
-    const r = applyDirectToCodex(id);
-    // applyDirectToCodex 内部已 setActive + save；chat/缺 key 则不写配置
-    needsRestart = !!r.ok && !r.restored;
-    config.activeId = id;
-    save();
-    return { ...status(), _needsRestart: needsRestart, _mode: mode, _directSkipped: r.skipped, _directReason: r.error };
-  }
   config.activeId = id;
-  save();
-  return { ...status(), _needsRestart: needsRestart, _mode: mode };
+  try {
+    if (target.isDefault) {
+      // 切回默认 = 还原原始配置，Codex 直连自己账号（需重启 Codex）
+      restoreDirect();
+      mode = "direct";
+      needsRestart = wasTakenOver; // 之前在走路由或直连中转 → 需重启
+    } else if (isRunning()) {
+      // 路由进程在跑（高级模式）：先更新 activeId，再同步本地路由和目标模型。
+      mode = "proxy";
+      if (before !== PROVIDER_ID) {
+        applyToCodex();
+        needsRestart = true; // 从直连/默认切到路由 → 需重启一次
+      } else if (target.model) {
+        // 路由进程已经接管 Codex：上游请求会即时切到新模型，但 Codex 客户端的
+        // 顶部模型选择器只在启动时读取 config.toml 的根级 model，不会热刷新。
+        const beforeModel = currentRootModel();
+        applyModelCatalog(target);
+        setConfigModel(target.model);
+        needsCodexRefresh = beforeModel !== target.model;
+      }
+    } else {
+      // 默认模式：直连中转，改 config.toml 指向该分组地址（必然需重启 Codex）
+      mode = "direct";
+      const r = applyDirectToCodex(id);
+      // applyDirectToCodex 内部已保存；chat/缺 key 则不写配置，但保留用户选中的分组。
+      needsRestart = !!r.ok && !r.restored;
+      save();
+      return { ...status(), _needsRestart: needsRestart, _mode: mode, _directSkipped: r.skipped, _directReason: r.error };
+    }
+    save();
+    return { ...status(), _needsRestart: needsRestart, _needsCodexRefresh: needsCodexRefresh, _mode: mode };
+  } catch (e) {
+    config.activeId = previousActiveId;
+    save();
+    throw e;
+  }
 }
 function setPort(port) {
   load();
@@ -1079,15 +1752,12 @@ function applyToCodex() {
   load();
   // 本地路由需要一个中转分组做上游；若当前是默认/空，自动选第一个中转分组（排除 claude 模式）
   const cur = config.groups.find((g) => g.id === config.activeId);
-  if (!cur || cur.isDefault || cur.mode === "claude") {
-    const proxy = config.groups.find((g) => !g.isDefault && g.mode !== "claude");
+  if (!cur || cur.isDefault || cur.mode === "claude" || isToolOnlyGroup(cur)) {
+    const proxy = config.groups.find((g) => !g.isDefault && g.mode !== "claude" && !isToolOnlyGroup(g));
     if (proxy) config.activeId = proxy.id;
   }
   const cfgFile = path.join(CODEX_HOME, "config.toml");
-  let text = "";
-  try {
-    text = fs.readFileSync(cfgFile, "utf-8");
-  } catch {}
+  let text = readTextForUpdate(cfgFile);
   // 备份
   try {
     fs.mkdirSync(path.join(CODEX_HOME, "backups_state", "router"), { recursive: true });
@@ -1109,25 +1779,20 @@ function applyToCodex() {
   const block = `[model_providers.${PROVIDER_ID}]\nname = "本地路由"\nbase_url = "http://127.0.0.1:${config.port}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
   text = removeTomlSection(text, `model_providers.${PROVIDER_ID}`);
   text = text.trimEnd() + "\n\n" + block;
-  fs.writeFileSync(cfgFile, text, "utf-8");
 
   // auth.json 写 routerKey（保留其它字段），Codex 会把它当 Bearer 发到本地路由
   const authFile = path.join(CODEX_HOME, "auth.json");
-  let auth = {};
-  try {
-    auth = JSON.parse(fs.readFileSync(authFile, "utf-8"));
-  } catch {}
+  const auth = readJsonForUpdate(authFile);
   auth.OPENAI_API_KEY = config.routerKey;
-  try {
-    fs.writeFileSync(authFile, JSON.stringify(auth, null, 2), "utf-8");
-    fs.chmodSync(authFile, 0o600);
-  } catch {}
   // 当前分组若指定了模型 → 写模型目录窗口 + 设 config 模型
   const cur2 = config.groups.find((g) => g.id === config.activeId);
   if (cur2 && !cur2.isDefault && cur2.model) {
     applyModelCatalog(cur2);
-    setConfigModel(cur2.model);
+    ensureModelInCatalog(cur2.model);
+    text = setRootModelInText(text, cur2.model);
   }
+  text = ensureCatalogLinked(text);
+  writeCodexConfigPair(text, JSON.stringify(auth, null, 2));
   // 先回填该中转站的全部文本模型进目录（异步、不阻塞、失败不动目录），
   // 保证用户之后在 Codex 本体里切到任何模型都不会因"模型不在目录"而丢会话。
   if (cur2 && !cur2.isDefault) syncCatalogFromProvider(cur2).catch(() => {});
@@ -1137,11 +1802,14 @@ function applyToCodex() {
 
 // —— 直连中转写配置（不经本地路由，不起进程）——
 // 把指定分组的中转 base_url/key 直接写进 config.toml + auth.json，Codex 直连中转站。
-// 用户保存分组即调用；重启 Codex 生效。chat 模式分组需协议转换、无法直连 → 拒绝。
+// 仅在用户明确选择/接入分组时调用；重启 Codex 生效。chat 模式分组需协议转换、无法直连 → 拒绝。
 function applyDirectToCodex(groupId) {
   load();
   const g = config.groups.find((x) => x.id === (groupId || config.activeId));
   if (!g) return { ok: false, error: "分组不存在" };
+  if (isToolOnlyGroup(g)) {
+    return { ok: false, skipped: true, error: "该分组是插件/画布专用分组，不写入 Codex 默认配置" };
+  }
   if (g.isDefault) {
     restoreDirect(); // 默认分组语义 = 回到官方登录直连
     config.activeId = g.id;
@@ -1163,8 +1831,7 @@ function applyDirectToCodex(groupId) {
   if (def) snapshotOfficialLogin(def);
 
   const cfgFile = path.join(CODEX_HOME, "config.toml");
-  let text = "";
-  try { text = fs.readFileSync(cfgFile, "utf-8"); } catch {}
+  let text = readTextForUpdate(cfgFile);
   backupConfig(text);
 
   // 清理其他接管痕迹：本地路由段、上次直连段、默认分组原始 provider 段
@@ -1184,23 +1851,20 @@ function applyDirectToCodex(groupId) {
   const block = `[model_providers.${DIRECT_PROVIDER_ID}]\nname = "${(g.name || "中转直连").replace(/"/g, "")}"\nbase_url = "${base}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
   text = text.trimEnd() + "\n\n" + block;
   text = text.replace(/\n{3,}/g, "\n\n");
-  fs.writeFileSync(cfgFile, text, "utf-8");
 
   // auth.json 写分组真实 key（Codex 直连中转站时用它作 Bearer）
   const authFile = path.join(CODEX_HOME, "auth.json");
-  let auth = {};
-  try { auth = JSON.parse(fs.readFileSync(authFile, "utf-8")); } catch {}
+  const auth = readJsonForUpdate(authFile);
   auth.OPENAI_API_KEY = g.key;
-  try {
-    fs.writeFileSync(authFile, JSON.stringify(auth, null, 2), "utf-8");
-    fs.chmodSync(authFile, 0o600);
-  } catch {}
 
   // 分组指定模型 → 写模型目录窗口 + 设根级 model
   if (g.model) {
     applyModelCatalog(g);
-    setConfigModel(g.model);
+    ensureModelInCatalog(g.model);
+    text = setRootModelInText(text, g.model);
   }
+  text = ensureCatalogLinked(text);
+  writeCodexConfigPair(text, JSON.stringify(auth, null, 2));
   // 先回填：把该中转站能用的全部文本模型登记进 Codex 模型目录（异步、不阻塞保存、失败不动目录）。
   // 这样即便用户之后在 Codex 本体的模型选择器里切到别的模型（那条路径不经过本 App），
   // 目标模型也已在目录里 → Codex 能正常启动、侧栏历史不再"消失"。
@@ -1219,12 +1883,8 @@ function applyToClaudeCode() {
   // 不再动 activeId（OpenAI/Codex 槽）—— 两族独立，接入 Claude Code 不该顶掉 Codex 的选择。
   fs.mkdirSync(CLAUDE_HOME, { recursive: true });
   const p = claudeSettingsPath();
-  let settings = {};
-  let existed = false;
-  try {
-    settings = JSON.parse(fs.readFileSync(p, "utf-8"));
-    existed = true;
-  } catch {}
+  const existed = fs.existsSync(p);
+  const settings = readJsonForUpdate(p);
   // 备份原文件
   if (existed) {
     try {
@@ -1234,16 +1894,23 @@ function applyToClaudeCode() {
     } catch {}
   }
   settings.env = settings.env || {};
-  // 首次接入时记住用户原有的两项，便于「取消接入」还原
+  // 首次接入时记住用户原有值，便于「取消接入」还原。
+  // 老版本只记录了 base/token；这里补记 model，避免覆盖后无法还原。
   if (!config.claudePrev) {
     config.claudePrev = {
       base: Object.prototype.hasOwnProperty.call(settings.env, "ANTHROPIC_BASE_URL") ? settings.env.ANTHROPIC_BASE_URL : null,
       token: Object.prototype.hasOwnProperty.call(settings.env, "ANTHROPIC_AUTH_TOKEN") ? settings.env.ANTHROPIC_AUTH_TOKEN : null,
+      model: Object.prototype.hasOwnProperty.call(settings.env, "ANTHROPIC_MODEL") ? settings.env.ANTHROPIC_MODEL : null,
     };
+  } else if (!Object.prototype.hasOwnProperty.call(config.claudePrev, "model")) {
+    config.claudePrev.model = Object.prototype.hasOwnProperty.call(settings.env, "ANTHROPIC_MODEL") ? settings.env.ANTHROPIC_MODEL : null;
   }
   settings.env.ANTHROPIC_BASE_URL = `http://127.0.0.1:${config.port}`;
   settings.env.ANTHROPIC_AUTH_TOKEN = config.routerKey;
-  fs.writeFileSync(p, JSON.stringify(settings, null, 2), "utf-8");
+  const g = activeGroup(true);
+  if (g && g.model && g.model.trim()) settings.env.ANTHROPIC_MODEL = g.model.trim();
+  else delete settings.env.ANTHROPIC_MODEL;
+  safeWriteFileSync(p, JSON.stringify(settings, null, 2), "utf-8");
   try {
     fs.chmodSync(p, 0o600);
   } catch {}
@@ -1255,12 +1922,8 @@ function applyToClaudeCode() {
 function restoreClaudeCode() {
   load();
   const p = claudeSettingsPath();
-  let settings = {};
-  try {
-    settings = JSON.parse(fs.readFileSync(p, "utf-8"));
-  } catch {
-    return { ok: true }; // 没有文件就无需还原
-  }
+  if (!fs.existsSync(p)) return { ok: true }; // 没有文件就无需还原
+  const settings = readJsonForUpdate(p);
   settings.env = settings.env || {};
   const prev = config.claudePrev || { base: null, token: null, model: null };
   for (const [k, v] of [["ANTHROPIC_BASE_URL", prev.base], ["ANTHROPIC_AUTH_TOKEN", prev.token], ["ANTHROPIC_MODEL", prev.model]]) {
@@ -1268,7 +1931,7 @@ function restoreClaudeCode() {
     else settings.env[k] = v;
   }
   if (settings.env && Object.keys(settings.env).length === 0) delete settings.env;
-  fs.writeFileSync(p, JSON.stringify(settings, null, 2), "utf-8");
+  safeWriteFileSync(p, JSON.stringify(settings, null, 2), "utf-8");
   delete config.claudePrev;
   save();
   return { ok: true };
@@ -1292,6 +1955,7 @@ function applyDirectToClaude(groupId) {
   const g = config.groups.find((x) => x.id === (groupId || config.activeId));
   if (!g) return { ok: false, error: "分组不存在" };
   if (g.isDefault) return { ok: false, error: "默认分组不接入 Claude Code" };
+  if (isToolOnlyGroup(g)) return { ok: false, skipped: true, error: "该分组是插件/画布专用分组，不写入 Claude Code 配置" };
   // Claude Code 直连用分组主字段：API 地址 baseUrl、API 密钥 key、默认模型 model
   if (!g.baseUrl || !g.key) {
     return { ok: false, skipped: true, error: "该分组缺少 API 地址或密钥，未写入 Claude Code 配置" };
@@ -1300,12 +1964,8 @@ function applyDirectToClaude(groupId) {
 
   fs.mkdirSync(CLAUDE_HOME, { recursive: true });
   const p = claudeSettingsPath();
-  let settings = {};
-  let existed = false;
-  try {
-    settings = JSON.parse(fs.readFileSync(p, "utf-8"));
-    existed = true;
-  } catch {}
+  const existed = fs.existsSync(p);
+  const settings = readJsonForUpdate(p);
   // 备份原文件
   if (existed) {
     try {
@@ -1327,7 +1987,7 @@ function applyDirectToClaude(groupId) {
   settings.env.ANTHROPIC_AUTH_TOKEN = g.key;
   if (g.model && g.model.trim()) settings.env.ANTHROPIC_MODEL = g.model.trim();
   else delete settings.env.ANTHROPIC_MODEL;
-  fs.writeFileSync(p, JSON.stringify(settings, null, 2), "utf-8");
+  safeWriteFileSync(p, JSON.stringify(settings, null, 2), "utf-8");
   try { fs.chmodSync(p, 0o600); } catch {}
   save();
   return { ok: true, direct: true, path: p, group: g.name };
@@ -1346,10 +2006,14 @@ function claudeDirectApplied() {
 
 module.exports = {
   load,
+  setCodexDataDir,
   start,
   stop,
+  stopAndRestoreDirect,
+  disableCodex,
   isRunning,
   status,
+  defaultConfigInfo,
   upsertGroup,
   deleteGroup,
   setActive,
@@ -1365,6 +2029,7 @@ module.exports = {
   getGroupKey,
   syncGenImage,
   groupById,
+  registerModelRoute,
   usableGroups,
   llmGroup,
   sttGroup,
diff --git a/electron/lib/sessions.js b/electron/lib/sessions.js
index 3a23eec..73458a4 100644
--- a/electron/lib/sessions.js
+++ b/electron/lib/sessions.js
@@ -2,12 +2,38 @@
 // 直接读 ~/.codex/sessions / archived_sessions 下的 rollout-*.jsonl，不依赖数据库，跨平台。
 const fs = require("fs");
 const path = require("path");
-const os = require("os");
+const { spawnSync } = require("child_process");
+const initSqlJs = require("sql.js");
+const { cleanThreadTitle, cleanUserVisibleText, stripInternalThoughtBlocks, looksLikeSkillMentionTitle } = require("./title_clean");
+const codexDataDir = require("./codex_data_dir");
 
-const CODEX_HOME = path.join(os.homedir(), ".codex");
-const SESSIONS_DIR = path.join(CODEX_HOME, "sessions");
-const ARCHIVED_SESSIONS_DIR = path.join(CODEX_HOME, "archived_sessions");
-const SESSION_INDEX = path.join(CODEX_HOME, "session_index.jsonl");
+let permanentDeleteBusy = false;
+
+function paths() {
+  const codexHome = codexDataDir.get();
+  return {
+    codexHome,
+    sessionsDir: path.join(codexHome, "sessions"),
+    archivedSessionsDir: path.join(codexHome, "archived_sessions"),
+    sessionIndex: path.join(codexHome, "session_index.jsonl"),
+    titleCleanMarker: path.join(codexHome, ".td-title-clean-v1.json"),
+  };
+}
+
+function isInside(base, file) {
+  const rel = path.relative(path.resolve(base), path.resolve(file));
+  return rel && !rel.startsWith(".." + path.sep) && rel !== ".." && !path.isAbsolute(rel);
+}
+
+function sessionRoots() {
+  const { sessionsDir, archivedSessionsDir } = paths();
+  return [sessionsDir, archivedSessionsDir];
+}
+
+function sessionFileAllowed(file) {
+  return sessionRoots().some((root) => isInside(root, file)) &&
+    path.basename(file).startsWith("rollout-") && path.extname(file) === ".jsonl";
+}
 
 // 递归找出所有 rollout-*.jsonl
 function findRolloutFiles(base) {
@@ -33,12 +59,12 @@ function findRolloutFiles(base) {
 function loadIndexTitles() {
   const map = {};
   try {
-    const txt = fs.readFileSync(SESSION_INDEX, "utf-8");
+    const txt = fs.readFileSync(paths().sessionIndex, "utf-8");
     for (const line of txt.split("\n")) {
       if (!line.trim()) continue;
       try {
         const d = JSON.parse(line);
-        if (d.id && d.thread_name) map[d.id] = d.thread_name;
+        if (d.id && d.thread_name) map[d.id] = cleanThreadTitle(d.thread_name, "", 80);
       } catch {}
     }
   } catch {}
@@ -76,13 +102,372 @@ function peekMeta(file) {
       meta.threadSource = p.thread_source || "";
       meta.provider = p.model_provider || "";
     } else if (d.type === "event_msg" && p.type === "user_message" && !meta.title) {
-      meta.title = String(p.message || "").replace(/\s+/g, " ").trim().slice(0, 60);
+      meta.title = cleanThreadTitle(p.message || "", "", 200);
     }
     if (meta.id && meta.title) break;
   }
   return meta;
 }
 
+function sqlite3Available() {
+  const r = spawnSync("sqlite3", ["--version"], { encoding: "utf-8" });
+  return !r.error && r.status === 0;
+}
+
+function runSqlite3(dbPath, sql) {
+  const r = spawnSync("sqlite3", ["-json", dbPath, sql], {
+    encoding: "utf-8",
+    maxBuffer: 20 * 1024 * 1024,
+  });
+  if (r.error || r.status !== 0) {
+    throw new Error((r.stderr || (r.error && r.error.message) || "sqlite3 执行失败").trim());
+  }
+  return r.stdout || "";
+}
+
+function quoteIdent(value) {
+  return "\"" + String(value || "").replace(/"/g, "\"\"") + "\"";
+}
+
+function sqliteTables(dbPath) {
+  try {
+    return JSON.parse(runSqlite3(dbPath, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';") || "[]");
+  } catch {
+    return [];
+  }
+}
+
+function sqliteTableInfo(dbPath, table) {
+  try {
+    return JSON.parse(runSqlite3(dbPath, "PRAGMA table_info(" + quoteIdent(table) + ");") || "[]");
+  } catch {
+    return [];
+  }
+}
+
+function sqliteForeignKeys(dbPath, table) {
+  try {
+    return JSON.parse(runSqlite3(dbPath, "PRAGMA foreign_key_list(" + quoteIdent(table) + ");") || "[]");
+  } catch {
+    return [];
+  }
+}
+
+function sqlJsRows(db, statement) {
+  const result = db.exec(statement);
+  if (!result.length) return [];
+  const columns = result[0].columns;
+  return result[0].values.map((values) => Object.fromEntries(columns.map((name, index) => [name, values[index]])));
+}
+
+function sqliteBufferWithCommittedWal(dbPath) {
+  let main = fs.readFileSync(dbPath);
+  const walPath = dbPath + "-wal";
+  if (!fs.existsSync(walPath)) return main;
+  const wal = fs.readFileSync(walPath);
+  if (wal.length < 32) return main;
+  const magic = wal.readUInt32BE(0);
+  if (magic !== 0x377f0682 && magic !== 0x377f0683) throw new Error("SQLite WAL 头无效，已停止删除");
+  let pageSize = wal.readUInt32BE(8);
+  if (pageSize === 1) pageSize = 65536;
+  if (!pageSize || (pageSize & (pageSize - 1)) !== 0) throw new Error("SQLite WAL 页大小无效，已停止删除");
+  const frameSize = 24 + pageSize;
+  const salt1 = wal.readUInt32BE(16);
+  const salt2 = wal.readUInt32BE(20);
+  const littleEndianChecksum = magic === 0x377f0682;
+  const checksum = (buffer, start, end, sums) => {
+    let [s1, s2] = sums;
+    for (let offset = start; offset < end; offset += 8) {
+      const a = littleEndianChecksum ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
+      const b = littleEndianChecksum ? buffer.readUInt32LE(offset + 4) : buffer.readUInt32BE(offset + 4);
+      s1 = (s1 + a + s2) >>> 0;
+      s2 = (s2 + b + s1) >>> 0;
+    }
+    return [s1, s2];
+  };
+  let sums = checksum(wal, 0, 24, [0, 0]);
+  if (sums[0] !== wal.readUInt32BE(24) || sums[1] !== wal.readUInt32BE(28)) {
+    throw new Error("SQLite WAL 校验失败，已停止删除");
+  }
+  let lastCommitOffset = -1;
+  let committedPages = 0;
+  for (let offset = 32; offset + frameSize <= wal.length; offset += frameSize) {
+    if (wal.readUInt32BE(offset + 8) !== salt1 || wal.readUInt32BE(offset + 12) !== salt2) break;
+    sums = checksum(wal, offset, offset + 8, sums);
+    sums = checksum(wal, offset + 24, offset + 24 + pageSize, sums);
+    if (sums[0] !== wal.readUInt32BE(offset + 16) || sums[1] !== wal.readUInt32BE(offset + 20)) break;
+    const dbSize = wal.readUInt32BE(offset + 4);
+    if (dbSize > 0) {
+      lastCommitOffset = offset;
+      committedPages = dbSize;
+    }
+  }
+  if (lastCommitOffset < 0) return main;
+  const merged = Buffer.alloc(committedPages * pageSize);
+  main.copy(merged, 0, 0, Math.min(main.length, merged.length));
+  for (let offset = 32; offset <= lastCommitOffset; offset += frameSize) {
+    const pageNo = wal.readUInt32BE(offset);
+    if (!pageNo || pageNo > committedPages) continue;
+    wal.copy(merged, (pageNo - 1) * pageSize, offset + 24, offset + 24 + pageSize);
+  }
+  return merged;
+}
+
+function replaceStateDb(dbPath, data) {
+  const tmp = dbPath + ".td-delete-" + process.pid + ".tmp";
+  const old = dbPath + ".td-delete-" + process.pid + ".old";
+  const oldWal = old + "-wal";
+  const oldShm = old + "-shm";
+  fs.rmSync(old, { force: true });
+  fs.rmSync(oldWal, { force: true });
+  fs.rmSync(oldShm, { force: true });
+  const fd = fs.openSync(tmp, "w");
+  try {
+    fs.writeFileSync(fd, data);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  let movedMain = false;
+  let movedWal = false;
+  let movedShm = false;
+  let installed = false;
+  try {
+    fs.renameSync(dbPath, old);
+    movedMain = true;
+    if (fs.existsSync(dbPath + "-wal")) { fs.renameSync(dbPath + "-wal", oldWal); movedWal = true; }
+    if (fs.existsSync(dbPath + "-shm")) { fs.renameSync(dbPath + "-shm", oldShm); movedShm = true; }
+    fs.renameSync(tmp, dbPath);
+    installed = true;
+  } catch (e) {
+    if (installed) { try { fs.rmSync(dbPath, { force: true }); } catch {} }
+    if (movedMain && fs.existsSync(old) && !fs.existsSync(dbPath)) fs.renameSync(old, dbPath);
+    if (movedWal && fs.existsSync(oldWal) && !fs.existsSync(dbPath + "-wal")) fs.renameSync(oldWal, dbPath + "-wal");
+    if (movedShm && fs.existsSync(oldShm) && !fs.existsSync(dbPath + "-shm")) fs.renameSync(oldShm, dbPath + "-shm");
+    throw e;
+  } finally {
+    fs.rmSync(tmp, { force: true });
+  }
+  try { fs.rmSync(old, { force: true }); } catch {}
+  try { fs.rmSync(oldWal, { force: true }); } catch {}
+  try { fs.rmSync(oldShm, { force: true }); } catch {}
+}
+
+async function deleteSessionFromStateDb(SQL, dbPath, id) {
+  let db;
+  try {
+    db = new SQL.Database(sqliteBufferWithCommittedWal(dbPath));
+    const tables = sqlJsRows(db, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").map((row) => row.name).filter(Boolean);
+    if (!tables.includes("threads")) return false;
+    db.run("PRAGMA foreign_keys=ON");
+    db.run("PRAGMA secure_delete=ON");
+    db.run("BEGIN");
+    let changed = false;
+    for (const table of tables) {
+      if (table === "threads") continue;
+      const columns = sqlJsRows(db, "PRAGMA table_info(" + quoteIdent(table) + ")").map((row) => String(row.name || ""));
+      const fks = sqlJsRows(db, "PRAGMA foreign_key_list(" + quoteIdent(table) + ")");
+      const direct = columns.filter((name) => /(^|_)thread_id$/i.test(name));
+      const referencesThread = fks.filter((fk) => String(fk.table || "").toLowerCase() === "threads").map((fk) => fk.from).filter(Boolean);
+      for (const column of Array.from(new Set(direct.concat(referencesThread)))) {
+        db.run("DELETE FROM " + quoteIdent(table) + " WHERE " + quoteIdent(column) + "=?", [id]);
+        changed = db.getRowsModified() > 0 || changed;
+      }
+    }
+    db.run("DELETE FROM " + quoteIdent("threads") + " WHERE " + quoteIdent("id") + "=?", [id]);
+    changed = db.getRowsModified() > 0 || changed;
+    db.run("COMMIT");
+    if (changed) {
+      db.run("VACUUM");
+      const fkErrors = sqlJsRows(db, "PRAGMA foreign_key_check");
+      const integrity = sqlJsRows(db, "PRAGMA integrity_check");
+      if (fkErrors.length || !integrity.length || integrity.some((row) => String(Object.values(row)[0] || "").toLowerCase() !== "ok")) {
+        throw new Error("SQLite 删除后完整性校验失败，已停止替换");
+      }
+      for (const table of tables) {
+        const columns = sqlJsRows(db, "PRAGMA table_info(" + quoteIdent(table) + ")").map((row) => String(row.name || ""));
+        for (const column of columns.filter((name) => /(^|_)thread_id$/i.test(name))) {
+          const hit = sqlJsRows(db, "SELECT 1 AS hit FROM " + quoteIdent(table) + " WHERE " + quoteIdent(column) + "=" + sql(id) + " LIMIT 1");
+          if (hit.length) throw new Error("SQLite 仍有会话关联记录，已停止替换");
+        }
+      }
+      replaceStateDb(dbPath, Buffer.from(db.export()));
+    }
+    return changed;
+  } catch (e) {
+    if (db) try { db.run("ROLLBACK"); } catch {}
+    throw e;
+  } finally {
+    if (db) try { db.close(); } catch {}
+  }
+}
+
+function removeSessionIndexEntry(id) {
+  const { sessionIndex } = paths();
+  if (!fs.existsSync(sessionIndex)) return false;
+  const lines = fs.readFileSync(sessionIndex, "utf-8").split("\n");
+  const kept = lines.filter((line) => {
+    if (!line.trim()) return true;
+    try { return JSON.parse(line).id !== id; } catch { return true; }
+  });
+  if (kept.length === lines.length) return false;
+  const tmp = sessionIndex + ".td-delete-" + process.pid + ".tmp";
+  const old = sessionIndex + ".td-delete-" + process.pid + ".old";
+  fs.rmSync(old, { force: true });
+  const fd = fs.openSync(tmp, "w");
+  try {
+    fs.writeFileSync(fd, kept.join("\n"), "utf-8");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try {
+    fs.renameSync(sessionIndex, old);
+    try { fs.renameSync(tmp, sessionIndex); } catch (e) { fs.renameSync(old, sessionIndex); throw e; }
+    try { fs.rmSync(old, { force: true }); } catch {}
+  } finally { fs.rmSync(tmp, { force: true }); }
+  return true;
+}
+
+// 永久删除一个会话：正文、归档正文、Codex 标题/状态索引一起清理。
+// 只接受本机 sessions/archived_sessions 下的 rollout 文件，禁止借此 IPC 删除任意路径。
+async function deleteConversation(filePath) {
+  if (permanentDeleteBusy) throw new Error("已有永久删除任务正在执行，请稍后重试");
+  permanentDeleteBusy = true;
+  try {
+  const requested = path.resolve(String(filePath || ""));
+  if (!sessionFileAllowed(requested) || !fs.existsSync(requested)) throw new Error("无效的会话文件");
+  const meta = peekMeta(requested);
+  if (!meta || !meta.id) throw new Error("无法识别会话 ID，已停止删除");
+  const files = [];
+  for (const root of sessionRoots()) {
+    for (const file of findRolloutFiles(root)) {
+      const m = peekMeta(file);
+      if (m && m.id === meta.id) files.push(file);
+    }
+  }
+  const { codexHome } = paths();
+  const stateDbs = fs.readdirSync(codexHome).filter((name) => /^state_.*\.sqlite$/.test(name));
+  const SQL = await initSqlJs({
+    locateFile: (file) => path.join(global.__BUNDLE_ROOT__ || path.join(__dirname, "..", ".."), "node_modules", "sql.js", "dist", file),
+  });
+  let stateRowsRemoved = 0;
+  for (const name of stateDbs) {
+    if (await deleteSessionFromStateDb(SQL, path.join(codexHome, name), meta.id)) stateRowsRemoved++;
+  }
+  const indexRemoved = removeSessionIndexEntry(meta.id);
+  for (const file of files) fs.rmSync(file, { force: true });
+  return { id: meta.id, cwd: meta.cwd || "", filesRemoved: files.length, indexRemoved, stateDbs: stateDbs.length, stateRowsRemoved };
+  } finally {
+    permanentDeleteBusy = false;
+  }
+}
+
+function findConversationById(id) {
+  const target = String(id || "").trim();
+  if (!target || target.length > 160) return null;
+  for (const root of sessionRoots()) {
+    for (const file of findRolloutFiles(root)) {
+      const meta = peekMeta(file);
+      if (meta && meta.id === target) return { ...meta, path: file };
+    }
+  }
+  return null;
+}
+
+function sql(v) {
+  return "'" + String(v == null ? "" : v).replace(/'/g, "''") + "'";
+}
+
+function findFallbackTitlesById() {
+  const map = {};
+  for (const root of sessionRoots()) {
+    for (const file of findRolloutFiles(root)) {
+      const m = peekMeta(file);
+      if (m && m.id && m.title) map[m.id] = m.title;
+    }
+  }
+  return map;
+}
+
+function repairStateDbTitles(fallbackTitles, log = () => {}) {
+  if (!sqlite3Available()) return 0;
+  let fixed = 0;
+  let files = [];
+  const { codexHome } = paths();
+  try {
+    files = fs.readdirSync(codexHome).filter((f) => /^state_.*\.sqlite$/.test(f));
+  } catch {
+    return 0;
+  }
+  for (const name of files) {
+    const dbPath = path.join(codexHome, name);
+    try {
+      const out = runSqlite3(dbPath, "SELECT id,title,first_user_message FROM threads WHERE title LIKE '[$%' OR title LIKE '$%';");
+      const rows = JSON.parse(out || "[]");
+      const updates = [];
+      for (const row of rows) {
+        const next = cleanThreadTitle(row.title, row.first_user_message || fallbackTitles[row.id] || "", 80);
+        if (next && next !== row.title) updates.push({ id: row.id, title: next });
+      }
+      if (!updates.length) continue;
+      const statements = ["BEGIN;"].concat(
+        updates.map((u) => `UPDATE threads SET title=${sql(u.title)} WHERE id=${sql(u.id)};`),
+        ["COMMIT;"]
+      ).join("\n");
+      runSqlite3(dbPath, statements);
+      fixed += updates.length;
+    } catch (e) {
+      log(`标题清洗跳过 ${name}：${e.message || e}`);
+    }
+  }
+  return fixed;
+}
+
+function repairSkillMentionTitles(log = () => {}) {
+  let raw = "";
+  let indexMtimeMs = 0;
+  const { sessionIndex, titleCleanMarker } = paths();
+  try {
+    indexMtimeMs = fs.statSync(sessionIndex).mtimeMs;
+    const marker = JSON.parse(fs.readFileSync(titleCleanMarker, "utf-8"));
+    if (marker && Number(marker.indexMtimeMs) >= indexMtimeMs) return { indexFixed: 0, dbFixed: 0, skipped: true };
+  } catch {}
+  try {
+    raw = fs.readFileSync(sessionIndex, "utf-8");
+  } catch {
+    return { indexFixed: 0, dbFixed: 0 };
+  }
+  const fallbackTitles = findFallbackTitlesById();
+  let indexFixed = 0;
+  const lines = raw.split("\n").map((line) => {
+    if (!line.trim()) return line;
+    try {
+      const d = JSON.parse(line);
+      if (!d || !d.id || !d.thread_name || !looksLikeSkillMentionTitle(d.thread_name)) return line;
+      const next = cleanThreadTitle(d.thread_name, fallbackTitles[d.id] || "", 80);
+      if (!next || next === d.thread_name) return line;
+      d.thread_name = next;
+      indexFixed++;
+      return JSON.stringify(d);
+    } catch {
+      return line;
+    }
+  });
+  if (indexFixed) {
+    const backup = sessionIndex + ".bak-title-clean-" + new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+    try {
+      fs.copyFileSync(sessionIndex, backup);
+    } catch {}
+    fs.writeFileSync(sessionIndex, lines.join("\n"), "utf-8");
+  }
+  const dbFixed = repairStateDbTitles(fallbackTitles, log);
+  try {
+    fs.writeFileSync(titleCleanMarker, JSON.stringify({ indexMtimeMs, checkedAt: new Date().toISOString() }, null, 2), "utf-8");
+  } catch {}
+  return { indexFixed, dbFixed };
+}
+
 function normalizeListOptions(opts) {
   if (typeof opts === "boolean") return { includeSubagent: opts, includeArchived: false };
   return {
@@ -94,8 +479,9 @@ function normalizeListOptions(opts) {
 // 列出会话（默认只列当前 sessions，并排除子 agent 派生线程；全量模式会带 archived_sessions）
 function listConversations(opts = {}) {
   const { includeSubagent, includeArchived } = normalizeListOptions(opts);
-  const roots = [{ dir: SESSIONS_DIR, archived: false }];
-  if (includeArchived) roots.push({ dir: ARCHIVED_SESSIONS_DIR, archived: true });
+  const { sessionsDir, archivedSessionsDir } = paths();
+  const roots = [{ dir: sessionsDir, archived: false }];
+  if (includeArchived) roots.push({ dir: archivedSessionsDir, archived: true });
   const titles = loadIndexTitles();
   const items = [];
   for (const root of roots) {
@@ -110,7 +496,7 @@ function listConversations(opts = {}) {
       } catch {}
       items.push({
         id: m.id,
-        title: titles[m.id] || m.title || "(无标题对话)",
+        title: cleanThreadTitle(titles[m.id] || "", m.title, 80) || "(无标题对话)",
         project: m.cwd ? path.basename(m.cwd) : "",
         cwd: m.cwd,
         ts: m.ts,
@@ -150,9 +536,9 @@ function readConversation(file) {
     if (d.type === "session_meta") {
       meta = { id: p.session_id || p.id || "", cwd: p.cwd || "", ts: p.timestamp || ts, provider: p.model_provider || "" };
     } else if (d.type === "event_msg" && p.type === "user_message") {
-      messages.push({ role: "user", text: String(p.message || ""), ts });
+      messages.push({ role: "user", text: cleanUserVisibleText(String(p.message || "")), ts });
     } else if (d.type === "event_msg" && p.type === "agent_message") {
-      messages.push({ role: "assistant", text: String(p.message || ""), ts });
+      messages.push({ role: "assistant", text: stripInternalThoughtBlocks(String(p.message || "")), ts });
     } else if (d.type === "response_item" && p.type === "function_call") {
       const name = p.name || "tool";
       messages.push({ role: "tool", text: `调用工具：${name}`, ts, collapsed: true });
@@ -186,7 +572,8 @@ function backupAll(destDir, log = () => {}) {
   const out = path.join(destDir, "codex-sessions-backup");
   fs.mkdirSync(out, { recursive: true });
   let n = 0;
-  for (const [name, dir] of [["sessions", SESSIONS_DIR], ["archived_sessions", ARCHIVED_SESSIONS_DIR]]) {
+  const { sessionsDir, archivedSessionsDir, sessionIndex } = paths();
+  for (const [name, dir] of [["sessions", sessionsDir], ["archived_sessions", archivedSessionsDir]]) {
     const files = findRolloutFiles(dir);
     for (const f of files) {
       const rel = path.relative(dir, f);
@@ -196,22 +583,71 @@ function backupAll(destDir, log = () => {}) {
       n++;
     }
   }
-  if (fs.existsSync(SESSION_INDEX)) fs.copyFileSync(SESSION_INDEX, path.join(out, "session_index.jsonl"));
+  if (fs.existsSync(sessionIndex)) fs.copyFileSync(sessionIndex, path.join(out, "session_index.jsonl"));
   log(`已备份 ${n} 个会话文件到 ${out}`);
   return { path: out, count: n };
 }
 
+function resolveImportRoot(srcDir) {
+  const root = path.resolve(String(srcDir || ""));
+  if (fs.existsSync(path.join(root, "sessions"))) return root;
+  const nested = path.join(root, "codex-sessions-backup");
+  if (fs.existsSync(path.join(nested, "sessions"))) return nested;
+  return root;
+}
+
+function mergeSessionIndex(srcIndex, dstIndex) {
+  if (!fs.existsSync(srcIndex)) return 0;
+  const entries = new Map();
+  const read = (file) => {
+    try {
+      for (const line of fs.readFileSync(file, "utf-8").split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const value = JSON.parse(line);
+          if (value && value.id) entries.set(String(value.id), value);
+        } catch {}
+      }
+    } catch {}
+  };
+  // 目标机器已有的重命名优先，备份只补缺失条目。
+  read(srcIndex);
+  const imported = new Map(entries);
+  entries.clear();
+  read(dstIndex);
+  const existing = new Map(entries);
+  for (const [id, value] of imported) if (!existing.has(id)) existing.set(id, value);
+  if (!existing.size) return 0;
+  fs.mkdirSync(path.dirname(dstIndex), { recursive: true });
+  const backup = dstIndex + ".bak-import-" + Date.now();
+  try { if (fs.existsSync(dstIndex)) fs.copyFileSync(dstIndex, backup); } catch {}
+  const tmp = dstIndex + ".tmp-import-" + process.pid;
+  try {
+    fs.writeFileSync(tmp, [...existing.values()].map((value) => JSON.stringify(value)).join("\n") + "\n", "utf-8");
+    try { fs.renameSync(tmp, dstIndex); }
+    catch {
+      fs.rmSync(dstIndex, { force: true });
+      fs.renameSync(tmp, dstIndex);
+    }
+  } finally {
+    try { fs.rmSync(tmp, { force: true }); } catch {}
+  }
+  return imported.size;
+}
+
 // 导入：把外部备份目录里的 rollout-*.jsonl 合并进本机 sessions/ 与 archived_sessions/（已存在则跳过）
 function importSessions(srcDir, log = () => {}) {
   // 支持传入 backup 根目录或其中的 sessions/ 子目录
   let added = 0;
   let skipped = 0;
-  const roots = fs.existsSync(path.join(srcDir, "sessions"))
+  const sourceRoot = resolveImportRoot(srcDir);
+  const { sessionsDir, archivedSessionsDir } = paths();
+  const roots = fs.existsSync(path.join(sourceRoot, "sessions"))
     ? [
-        { base: path.join(srcDir, "sessions"), dest: SESSIONS_DIR },
-        { base: path.join(srcDir, "archived_sessions"), dest: ARCHIVED_SESSIONS_DIR },
+        { base: path.join(sourceRoot, "sessions"), dest: sessionsDir },
+        { base: path.join(sourceRoot, "archived_sessions"), dest: archivedSessionsDir },
       ]
-    : [{ base: srcDir, dest: SESSIONS_DIR }];
+    : [{ base: sourceRoot, dest: sessionsDir }];
   for (const root of roots) {
     const files = findRolloutFiles(root.base);
     for (const f of files) {
@@ -226,17 +662,21 @@ function importSessions(srcDir, log = () => {}) {
       added++;
     }
   }
-  log(`导入完成：新增 ${added} 个，跳过 ${skipped} 个（已存在）`);
-  return { added, skipped };
+  const indexMerged = mergeSessionIndex(path.join(sourceRoot, "session_index.jsonl"), paths().sessionIndex);
+  log(`导入完成：新增 ${added} 个，跳过 ${skipped} 个（已存在），合并索引 ${indexMerged} 条`);
+  return { added, skipped, indexMerged };
 }
 
 module.exports = {
-  CODEX_HOME,
-  SESSIONS_DIR,
-  ARCHIVED_SESSIONS_DIR,
+  getCodexHome: () => paths().codexHome,
+  getSessionsDir: () => paths().sessionsDir,
+  getArchivedSessionsDir: () => paths().archivedSessionsDir,
   listConversations,
   readConversation,
   toMarkdown,
   backupAll,
   importSessions,
+  deleteConversation,
+  findConversationById,
+  repairSkillMentionTitles,
 };
diff --git a/electron/lib/team-prompt.js b/electron/lib/team-prompt.js
index 5678242..06fe3ac 100644
--- a/electron/lib/team-prompt.js
+++ b/electron/lib/team-prompt.js
@@ -93,11 +93,20 @@ const TEAM_CONVENTIONS = {
     '数据库变更交接必须附：变更说明、迁移脚本、回滚脚本、受影响表',
     '接收方动工前先确认契约；有异议退回来源角色或总控，不擅自改契约',
   ],
+  model_routing: [
+    '团队生成模型只用于把需求转换成角色与协作配置，不等于生成后总控或执行角色的运行模型',
+    '总控使用 orchestrator.model：负责需求拆解、架构设计、契约收敛、代码审计、安全审核、视觉验收与最终集成验收；总控不直接写业务代码',
+    '执行角色使用各自的 model：负责实现、测试、文档和明确授权范围内的修复；默认优先使用成本更低的执行模型',
+    '能力分流：需要识图、截图对比、视频理解、音频语义分析或视觉验收时，任务必须留在总控，或交给明确声明支持对应能力的模型',
+    '多模态任务完成后，总控只把结构化视觉证据、明确约束和验收标准交给执行角色，不把无法处理的原始图片/视频直接派给不支持多模态的模型',
+    '执行角色遇到视觉、视频、复杂架构、安全或跨职责问题，立即暂停并交总控裁决，不得假装已理解媒体内容',
+  ],
 };
 
 // 总控调度状态机
 const ORCHESTRATOR_WORKFLOW = [
   '需求分析：澄清目标、边界与验收标准',
+  '能力分流：识别视觉 / 视频 / 音频 / 复杂审计任务，确认由总控处理，不派给不具备对应能力的执行模型',
   '任务拆分：拆成可独立交付的小任务，标注负责角色与依赖关系',
   '契约收敛：先让契约 owner 定稿接口契约（OpenAPI / DTO / 错误码 / 分页 / 权限码），各方确认',
   '任务立契：分派前为每个任务产出《任务契约》（套 templates/task-charter.md），必须写明目标、可判定的验收标准、以及至少 2 条「明确不做（out of scope）」；写不出 out of scope 说明任务没想清楚，不得分派',
diff --git a/electron/lib/team.js b/electron/lib/team.js
index 6671b7a..993bb84 100644
--- a/electron/lib/team.js
+++ b/electron/lib/team.js
@@ -475,12 +475,18 @@ function reconcileTeam(team) {
   return team;
 }
 
-function normalizeTeam(team, model, requirement) {
+function normalizeTeam(team, modelOrOptions, requirement) {
+  const options = modelOrOptions && typeof modelOrOptions === 'object'
+    ? modelOrOptions
+    : { analysisModel: modelOrOptions, orchestratorModel: modelOrOptions, agentModel: modelOrOptions };
+  const analysisModel = String(options.analysisModel || '').trim();
+  const orchestratorModel = String(options.orchestratorModel || analysisModel).trim();
+  const agentModel = String(options.agentModel || analysisModel).trim();
   team.stack = asArr(team.stack);
   team.employees = asArr(team.employees);
 
   team.employees.forEach((e) => {
-    e.model = model; // 员工统一用运行模型，避免模型名不一致
+    e.model = agentModel; // 执行角色统一使用成本模型；总控单独使用 orchestratorModel
     e.constraints = ensureConstraints(e);
     e.responsibilities = asArr(e.responsibilities);
     e.handoff_in = e.handoff_in || '';
@@ -488,12 +494,20 @@ function normalizeTeam(team, model, requirement) {
   });
 
   if (team.orchestrator) {
-    team.orchestrator.model = model;
+    team.orchestrator.model = orchestratorModel;
     team.orchestrator.constraints = ensureConstraints(team.orchestrator);
     team.orchestrator.responsibilities = asArr(team.orchestrator.responsibilities);
     team.orchestrator.workflow = ORCHESTRATOR_WORKFLOW; // 注入调度状态机
   }
 
+  team.model_routing = {
+    generation_model: analysisModel,
+    orchestrator_model: orchestratorModel,
+    worker_model: agentModel,
+    analysis_model: analysisModel,
+    capability_policy: '需要识图、截图对比、视频理解、音频语义分析、复杂架构或最终审计的任务由总控处理；执行角色只接收结构化证据和明确验收标准',
+  };
+
   // 结构性归一（id / 路径互斥 / 引用收敛 / 总控只读）——与 /api/pack 共用同一套
   reconcileTeam(team);
 
@@ -550,26 +564,28 @@ function sharedProtocol(team, isLead) {
   (asArr(team.git_rules).length ? team.git_rules : TEAM_CONVENTIONS.git_rules).forEach((x) => L.push(`- ${x}`));
   L.push('\n### 四、任务交接协议');
   TEAM_CONVENTIONS.handoff_protocol.forEach((x) => L.push(`- ${x}`));
-  L.push(`\n### 五、接口契约`);
+  L.push('\n### 五、模型与能力路由');
+  TEAM_CONVENTIONS.model_routing.forEach((x) => L.push(`- ${x}`));
+  L.push(`\n### 六、接口契约`);
   L.push(`- 契约 owner：${ownerName(team)}，只有 owner 能定稿 / 变更契约。`);
   L.push(`- 契约约定：${team.contract_spec}`);
   L.push(`- 其他角色需遵循契约，有异议先与 owner 或总控确认，不擅自改动。`);
   if (team.security_checklist.length) {
-    L.push('\n### 六、安全 / 权限审核清单（相关改动必须自检）');
+    L.push('\n### 七、安全 / 权限审核清单（相关改动必须自检）');
     team.security_checklist.forEach((x) => L.push(`- ${x}`));
   }
   if (isLead) {
-    L.push('\n### 七、调度流程（总控按此状态机推进）');
+    L.push('\n### 八、调度流程（总控按此状态机推进）');
     ((team.orchestrator && team.orchestrator.workflow) || ORCHESTRATOR_WORKFLOW).forEach((x, i) => L.push(`${i + 1}. ${x}`));
     L.push('\n遇到跨角色冲突、职责归属不清、契约争议，由你（总控）裁决并驱动返工闭环。你是只读角色，不写任何文件。');
-    L.push('\n### 八、范围纪律（防跑飞——总控是第一道闸）');
+    L.push('\n### 九、范围纪律（防跑飞——总控是第一道闸）');
     L.push('- 分派任何任务前，先产出该任务的《任务契约》（套 templates/task-charter.md），其中「明确不做 / out of scope」至少写 2 条：根据**本次客户需求**推导「这个任务明确不该碰的东西」。写不出 out of scope，说明任务还没想清楚，不许分派。');
     L.push('- 审核与打回一律对照该任务的《任务契约》：产出必须能在「目标」里找到依据、且未命中「out of scope」。打回时理由必须引用《任务契约》或 DoD 的**具体条款**，并写入 docs/coordination/task-ledger.md，不凭感觉打回。');
     L.push('- 同一任务打回 ≥ 2 次时，不再简单退回，改为重新澄清《任务契约》（判断是不是任务边界本身没定义清楚），避免无限返工。');
     L.push('- 任务状态在 docs/coordination/task-ledger.md 流转（assigned → in-progress → review → rework → accepted），仅当状态为 accepted 才算关闭。');
   } else {
     L.push('\n> 遇到跨角色冲突或职责归属不清，提交总控 Agent 裁决；跨职责修改务必走报告 + 复核（在完成报告中说明并请对应 owner 复核）。');
-    L.push('\n### 七、范围纪律（防跑飞——动工前必读）');
+    L.push('\n### 八、范围纪律（防跑飞——动工前必读）');
     L.push('- 动工前先读本任务的《任务契约》（templates/task-charter.md 的本任务实例）。只做「目标」授权的事。');
     L.push('- 判定跑飞的通用标准：你即将做的事若无法在《任务契约》的「目标」里找到依据，或命中了「明确不做 / out of scope」，即为跑飞——**立即停下**，把情况写进 docs/coordination/task-ledger.md 并交总控裁决，不要自行扩大范围。');
     L.push('- 「顺手」优化 / 重构 / 补功能若不在本任务目标内，一律不做，先报总控。连续两次都要越界才能完成，说明任务定义有问题，同样交总控。');
@@ -607,7 +623,10 @@ function toToml(agent, role, protocol) {
   lines.push(`responsibilities = ${arrToml(agent.responsibilities)}`);
   lines.push(`constraints = ${arrToml(agent.constraints)}`);
   lines.push('');
-  lines.push(`prompt = ${multiline((agent.prompt || '') + protocol)}`);
+  const routeHint = agent.model
+    ? `\n\n[TD_MODEL_ROUTE model="${agent.model}" role="${role}" agent="${agent.id || role}"; runtime hint only, ignore in task output.]`
+    : '';
+  lines.push(`prompt = ${multiline((agent.prompt || '') + protocol + routeHint)}`);
   return lines.join('\n') + '\n';
 }
 
@@ -679,6 +698,12 @@ function buildConventions(team) {
   team.git_rules.forEach((x) => L.push(`- ${x}`));
   L.push('\n## 任务交接协议');
   team.handoff_protocol.forEach((x) => L.push(`- ${x}`));
+  L.push('\n## 模型与能力路由');
+  L.push(`- 团队生成模型（仅生成配置）：${(team.model_routing && (team.model_routing.generation_model || team.model_routing.analysis_model)) || '未指定'}`);
+  L.push(`- 总控模型：${(team.orchestrator && team.orchestrator.model) || '未指定'}`);
+  const workerModels = Array.from(new Set(team.employees.map((e) => e.model).filter(Boolean)));
+  L.push(`- 执行模型：${workerModels.join('、') || '未指定'}`);
+  TEAM_CONVENTIONS.model_routing.forEach((x) => L.push(`- ${x}`));
   if (team.auth_scheme && team.auth_scheme !== 'none') L.push(`\n## 鉴权方案（全局唯一）\n- ${team.auth_scheme}`);
   if (team.package_manager && team.package_manager !== 'none') L.push(`\n## 包管理器（全局唯一）\n- ${team.package_manager}（锁文件、CI 命令、.gitignore 均以此为准）`);
   L.push('\n## 接口契约');
@@ -807,7 +832,11 @@ function buildReadme(team, tool) {
   if (isClaude) {
     L.push('Claude Code 的 `model` 字段只认 claude 系（`sonnet` / `opus` / `haiku` / `claude-*`）。生成时若未指定 claude 系模型，agent 文件已**省略 model 字段 = 自动继承会话模型**（推荐）。需要固定某档时在 frontmatter 加一行如 `model: sonnet`。');
   } else {
-    L.push(`各文件里的 \`model = "${team.employees[0] ? team.employees[0].model : ''}"\` 请改成你本地 Codex 运行器实际支持的模型名，否则可能调用失败。`);
+    const generationModel = (team.model_routing && (team.model_routing.generation_model || team.model_routing.analysis_model)) || '';
+    const leadModel = team.orchestrator && team.orchestrator.model ? team.orchestrator.model : '';
+    const workerModel = team.employees[0] && team.employees[0].model ? team.employees[0].model : '';
+    L.push(`本次团队配置由 \`${generationModel || '未指定'}\` 生成；生成后总控文件使用 \`model = "${leadModel}"\`，执行角色使用 \`model = "${workerModel}"\`。请确保运行模型已在本地路由分组中配置；本包会按模型名自动选择对应分组。`);
+    L.push('涉及识图、截图对比、视频理解、音频语义分析或最终视觉验收时，必须由总控处理，再把结构化证据交给执行角色。');
   }
   L.push('\n> 定位：这是一份**多 Agent 协作配置包**（规范 + 角色 + 模板 + 工具化约束），不是可直接运行的项目骨架。`package.json` 等由 **devops-engineer 作为第一个 bootstrap 任务**初始化后，CI 才会真正跑起来（未初始化时 CI 不会硬失败）。');
   L.push('\n## ⚠️ 解压须知（先看这个）');
@@ -1442,6 +1471,13 @@ function packDefaults(result) {
   result.auth_scheme = result.auth_scheme || '';
   result.package_manager = result.package_manager || '';
   if (result.orchestrator) result.orchestrator.workflow = fill(result.orchestrator.workflow, ORCHESTRATOR_WORKFLOW);
+  const workerModel = result.employees.find((e) => e && e.model) || {};
+  result.model_routing = {
+    ...(result.model_routing || {}),
+    generation_model: (result.model_routing && (result.model_routing.generation_model || result.model_routing.analysis_model)) || '',
+    orchestrator_model: (result.orchestrator && result.orchestrator.model) || '',
+    worker_model: workerModel.model || '',
+  };
   // pack 复用完整结构性归一（id 清洗/路径互斥/引用收敛/总控只读，含 orchestrator.id 对齐；不覆写模型）+ 口径强制
   reconcileTeam(result);
   enforceConsistency(result);
@@ -1473,21 +1509,36 @@ function resolveGroup(groupId) {
 }
 
 // 生成员工团队：需求 → 结构化团队
-async function generate({ requirement, tool, groupId, model, agentModel } = {}) {
+async function generate({ requirement, tool, groupId, orchestratorGroupId, agentGroupId, model, agentModel, orchestratorModel } = {}) {
   if (!requirement || !String(requirement).trim()) throw new Error("请先输入项目需求");
-  const g = resolveGroup(groupId);
-  const useModel = (model && String(model).trim()) || g.model;
+  if (tool !== "claude" && (!String(orchestratorModel || "").trim() || !String(agentModel || "").trim())) {
+    throw new Error("Codex 团队必须分别选择总控执行模型和子 Agent 执行模型；团队生成模型只用于生成配置");
+  }
+  const analysisGroup = resolveGroup(groupId);
+  const orchestratorGroup = resolveGroup(orchestratorGroupId || groupId);
+  const workerGroup = resolveGroup(agentGroupId || groupId);
+  const useModel = (model && String(model).trim()) || analysisGroup.model;
   if (!useModel) throw new Error("未选择模型");
-  const gwBase = chatBase(g.baseUrl);
+  const gwBase = chatBase(analysisGroup.baseUrl);
 
-  const content = await callChat(gwBase, g.key, useModel, [
+  const content = await callChat(gwBase, analysisGroup.key, useModel, [
     { role: "system", content: EMPLOYEE_SYSTEM_PROMPT },
     { role: "user", content: buildEmployeeInstruction(requirement, tool) },
   ], 5000);
 
-  // 员工运行模型：用户可指定，否则用分析模型
-  const runModel = (agentModel && String(agentModel).trim()) || useModel;
-  const result = normalizeTeam(extractJson(content), runModel, requirement);
+  // 生成模型只负责本次生成；总控/执行模型是生成后的运行时配置，三者彼此独立。
+  const runModel = (agentModel && String(agentModel).trim()) || workerGroup.model || useModel;
+  const leadModel = (orchestratorModel && String(orchestratorModel).trim()) || orchestratorGroup.model || useModel;
+  if (!runModel) throw new Error("未选择子 Agent 模型");
+  if (typeof router.registerModelRoute === "function") {
+    router.registerModelRoute(orchestratorGroupId || groupId || orchestratorGroup.id, leadModel);
+    router.registerModelRoute(agentGroupId || groupId || workerGroup.id, runModel);
+  }
+  const result = normalizeTeam(extractJson(content), {
+    analysisModel: useModel,
+    orchestratorModel: leadModel,
+    agentModel: runModel,
+  }, requirement);
   return result;
 }
 
@@ -1566,6 +1617,12 @@ function packFiles(result, tool) {
     package_manager: result.package_manager || "",
     auth_scheme: result.auth_scheme || "",
     interface_kind: result.interface_kind || "",
+    model_routing: {
+      generation: (result.model_routing && (result.model_routing.generation_model || result.model_routing.analysis_model)) || "",
+      orchestrator: (result.model_routing && result.model_routing.orchestrator_model) || (result.orchestrator && result.orchestrator.model) || "",
+      workers: Array.from(new Set(result.employees.map((e) => e && e.model).filter(Boolean))),
+      capability_policy: (result.model_routing && result.model_routing.capability_policy) || "",
+    },
     required_env: asArr(result.env_vars).map((v) => v && v.name).filter(Boolean),
     roles: result.employees.map((e) => e.id).concat(["orchestrator"]),
     files: [],
diff --git a/electron/lib/title_clean.js b/electron/lib/title_clean.js
new file mode 100644
index 0000000..1f446c6
--- /dev/null
+++ b/electron/lib/title_clean.js
@@ -0,0 +1,90 @@
+"use strict";
+
+const SKILL_LINK_RE = /\[\$([^\]\n]+)\]\(([^)\n]*)\)/g;
+const LEADING_SKILL_LINK_RE = /^\s*\[\$([^\]\n]+)\]\(([^)\n]*)\)\s*/;
+const TRUNCATED_LEADING_SKILL_LINK_RE = /^\s*\[\$([^\]\n]+)\]\([^)\n]*$/;
+const LEADING_SKILL_TOKEN_RE = /^\s*\$[A-Za-z][\w:.-]*(?:\s+|$)/;
+
+function normalizeInlineText(text) {
+  return String(text || "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function cleanSkillLinks(text) {
+  return String(text || "").replace(SKILL_LINK_RE, (_m, name) => `$${String(name || "").trim()}`);
+}
+
+function stripLeadingSkillMentions(text) {
+  let out = cleanSkillLinks(text);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const before = out;
+    out = out.replace(LEADING_SKILL_LINK_RE, "");
+    out = out.replace(TRUNCATED_LEADING_SKILL_LINK_RE, "");
+    out = out.replace(LEADING_SKILL_TOKEN_RE, "");
+    out = out.replace(/^\s*[:：,，;；|｜\-–—]+\s*/, "");
+    changed = out !== before;
+  }
+  return out;
+}
+
+function cleanUserVisibleText(text) {
+  return cleanSkillLinks(text);
+}
+
+// 某些中转模型会把内部思考误当成普通正文，用 XML 风格标签直接输出。
+// 只清理明确的内部块，不改动普通文本中的尖括号内容。
+function stripInternalThoughtBlocks(text) {
+  let out = String(text || "");
+  for (const name of ["thinking", "analysis", "reasoning"]) {
+    const re = new RegExp("<" + name + "\\b[^>]*>[\\s\\S]*?</" + name + "\\s*>", "gi");
+    out = out.replace(re, "");
+  }
+  return out.replace(/<\/?(?:thinking|analysis|reasoning)\b[^>]*>/gi, "");
+}
+
+// 流式内容可能把标签拆在多个 chunk 中：未闭合的内部块整体暂不输出。
+function stripInternalThoughtStreaming(text) {
+  const source = String(text || "");
+  let out = "";
+  let cursor = 0;
+  const openRe = /<(thinking|analysis|reasoning)\b[^>]*>/gi;
+  while (true) {
+    openRe.lastIndex = cursor;
+    const open = openRe.exec(source);
+    if (!open) {
+      out += source.slice(cursor);
+      break;
+    }
+    out += source.slice(cursor, open.index);
+    const closeRe = new RegExp("</" + open[1] + "\\s*>", "i");
+    const tail = source.slice(openRe.lastIndex);
+    const close = closeRe.exec(tail);
+    if (!close) break;
+    cursor = openRe.lastIndex + close.index + close[0].length;
+  }
+  return stripInternalThoughtBlocks(out);
+}
+
+function cleanThreadTitle(title, fallback = "", maxLen = 80) {
+  const primary = normalizeInlineText(stripLeadingSkillMentions(title));
+  const secondary = normalizeInlineText(stripLeadingSkillMentions(fallback));
+  const cleaned = primary || secondary || normalizeInlineText(cleanSkillLinks(title)) || normalizeInlineText(cleanSkillLinks(fallback));
+  return cleaned ? cleaned.slice(0, maxLen) : "";
+}
+
+function looksLikeSkillMentionTitle(title) {
+  const text = normalizeInlineText(title);
+  return /^\[\$[^\]]+\]\(/.test(text) || /^\$[A-Za-z][\w:.-]*(?:\s|$)/.test(text);
+}
+
+module.exports = {
+  cleanSkillLinks,
+  cleanThreadTitle,
+  cleanUserVisibleText,
+  stripInternalThoughtBlocks,
+  stripInternalThoughtStreaming,
+  looksLikeSkillMentionTitle,
+};
diff --git a/electron/lib/token_inject.js b/electron/lib/token_inject.js
index d9f3a1d..c6e301b 100644
--- a/electron/lib/token_inject.js
+++ b/electron/lib/token_inject.js
@@ -15,14 +15,14 @@
 
 const TOKEN_INJECT_SCRIPT = `
 (() => {
-  const VER = "td-token-v17";
+  const VER = "td-token-v18";
   if (window.__tdTokenInstalled === VER) return;
   if (window.__tdTokenObserver) { try { window.__tdTokenObserver.disconnect(); } catch {} }
   const oldBar = document.getElementById("td-token-bar");
   if (oldBar) oldBar.remove();
   const oldRow = document.getElementById("td-token-center-row");
   if (oldRow) oldRow.remove();
-  ["td-token-style-v4", "td-token-style-v5", "td-token-style-v6", "td-token-style-v7", "td-token-style-v8", "td-token-style-v9", "td-token-style-v10", "td-token-style-v11", "td-token-style-v12", "td-token-style-v13", "td-token-style-v14", "td-token-style-v15", "td-token-style-v16", "td-token-style-v17"].forEach((id) => {
+  ["td-token-style-v4", "td-token-style-v5", "td-token-style-v6", "td-token-style-v7", "td-token-style-v8", "td-token-style-v9", "td-token-style-v10", "td-token-style-v11", "td-token-style-v12", "td-token-style-v13", "td-token-style-v14", "td-token-style-v15", "td-token-style-v16", "td-token-style-v17", "td-token-style-v18"].forEach((id) => {
     const el = document.getElementById(id);
     if (el) el.remove();
   });
@@ -78,7 +78,7 @@ const TOKEN_INJECT_SCRIPT = `
   //  2. 创建 UI
   // ============================================================================
   const BAR_ID = "td-token-bar";
-  const STYLE_ID = "td-token-style-v17";
+  const STYLE_ID = "td-token-style-v18";
   const TOKEN_CAP = 5000000000;
 
   if (!document.getElementById(STYLE_ID)) {
@@ -537,18 +537,57 @@ const TOKEN_INJECT_SCRIPT = `
     }, 700);
   }
 
-  function findToolbar() {
-    const rich = document.querySelector("DIV.ProseMirror, [contenteditable], textarea");
-    if (!rich) return null;
-    let p = rich;
-    for (let i = 0; i < 7 && p; i++) {
-      const foot = p.querySelector("[class*='_footer_'], [class*='composer-footer'], footer.composer, [class*='footer'][class*='composer']");
-      if (foot && foot.querySelectorAll("button, [role='button']").length >= 2) return foot;
-      p = p.parentElement;
+  const EDITOR_SELECTOR = "DIV.ProseMirror, [contenteditable='true'], [contenteditable=''], textarea";
+  const TOOLBAR_SELECTOR = "[class*='_footer_'], [class*='composer-footer'], footer.composer, [class*='footer'][class*='composer']";
+
+  function isVisible(el) {
+    if (!el || !el.isConnected) return false;
+    const rect = el.getBoundingClientRect();
+    if (!rect.width || !rect.height) return false;
+    const style = window.getComputedStyle(el);
+    return style.display !== "none" && style.visibility !== "hidden" && Number(style.opacity || 1) > 0;
+  }
+
+  function toolbarForEditor(editor) {
+    let parent = editor;
+    for (let i = 0; i < 8 && parent && parent !== document.body && parent !== document.documentElement; i++) {
+      const toolbars = Array.from(parent.querySelectorAll(TOOLBAR_SELECTOR)).filter((toolbar) => (
+        isVisible(toolbar) && toolbar.querySelectorAll("button, [role='button']").length >= 2
+      ));
+      if (toolbars.length) {
+        const editorRect = editor.getBoundingClientRect();
+        toolbars.sort((a, b) => {
+          const aRect = a.getBoundingClientRect();
+          const bRect = b.getBoundingClientRect();
+          return Math.abs(aRect.top - editorRect.bottom) - Math.abs(bRect.top - editorRect.bottom);
+        });
+        return toolbars[0];
+      }
+      parent = parent.parentElement;
     }
     return null;
   }
 
+  function toolbarScore(editor, toolbar) {
+    const editorRect = editor.getBoundingClientRect();
+    const toolbarRect = toolbar.getBoundingClientRect();
+    const model = findModelControl(toolbar);
+    // 主会话 composer 通常位于可视区更靠下的位置，并且具备模型选择控件。
+    return (model ? 1000000 : 0) + Math.round(toolbarRect.bottom * 1000) + Math.round(editorRect.bottom);
+  }
+
+  function findToolbar() {
+    const candidates = [];
+    for (const editor of document.querySelectorAll(EDITOR_SELECTOR)) {
+      if (!isVisible(editor)) continue;
+      const toolbar = toolbarForEditor(editor);
+      if (toolbar) candidates.push({ editor, toolbar });
+    }
+    if (!candidates.length) return null;
+    candidates.sort((a, b) => toolbarScore(b.editor, b.toolbar) - toolbarScore(a.editor, a.toolbar));
+    return candidates[0].toolbar;
+  }
+
   function visibleText(el) {
     return String((el && (el.getAttribute("aria-label") || el.title || el.textContent)) || "").trim();
   }
@@ -561,25 +600,8 @@ const TOKEN_INJECT_SCRIPT = `
     return buttons.length > 1 ? buttons[buttons.length - 2] : buttons[0] || null;
   }
 
-  function centerUnderEditor(bar) {
-    const rich = document.querySelector("DIV.ProseMirror, [contenteditable], textarea");
-    if (!rich || !rich.parentElement) return false;
-    const row = document.createElement("div");
-    row.id = "td-token-center-row";
-    row.style.cssText = "display:flex;justify-content:center;align-items:center;width:100%;padding:2px 0 0;pointer-events:none;";
-    row.appendChild(bar);
-    const anchor = rich.parentElement;
-    anchor.insertAdjacentElement("afterend", row);
-    return true;
-  }
-
-  function cleanupCenterRow() {
-    const row = document.getElementById("td-token-center-row");
-    if (row && !row.querySelector("#" + BAR_ID)) row.remove();
-  }
-
-  function placeInToolbar(bar) {
-    const toolbar = findToolbar();
+  function placeInToolbar(bar, toolbar) {
+    toolbar = toolbar || findToolbar();
     if (!toolbar) return false;
     const model = findModelControl(toolbar);
     if (model && model.parentElement && toolbar.contains(model.parentElement)) {
@@ -589,44 +611,53 @@ const TOKEN_INJECT_SCRIPT = `
     } else {
       toolbar.appendChild(bar);
     }
-    cleanupCenterRow();
     return true;
   }
 
   function mountBar() {
-    const existing = document.getElementById(BAR_ID);
-    if (existing) return;
-    const bar = buildBar();
-    if (!placeInToolbar(bar) && !centerUnderEditor(bar)) {
-      (document.body || document.documentElement).appendChild(bar);
-    }
+    const toolbar = findToolbar();
+    if (!toolbar) return false;
+    const bar = document.getElementById(BAR_ID) || buildBar();
+    placeInToolbar(bar, toolbar);
     render();
+    return true;
   }
 
   function maybeRelocate() {
     const bar = document.getElementById(BAR_ID);
-    if (!bar) return false;
-    const row = document.getElementById("td-token-center-row");
-    if (row && row.contains(bar)) return placeInToolbar(bar);
-    if (bar.parentElement === document.body || bar.parentElement === document.documentElement) return placeInToolbar(bar);
-    return false;
+    const toolbar = findToolbar();
+    if (!toolbar) return false;
+    if (!bar) return mountBar();
+    if (!toolbar.contains(bar)) return placeInToolbar(bar, toolbar);
+    const model = findModelControl(toolbar);
+    const expectedParent = model && model.parentElement && toolbar.contains(model.parentElement) ? model.parentElement : toolbar;
+    if (bar.parentElement !== expectedParent || (model && bar.nextElementSibling !== model)) {
+      return placeInToolbar(bar, toolbar);
+    }
+    return true;
   }
 
   // ============================================================================
   //  5. MutationObserver：页面重绘后补回悬浮条
   // ============================================================================
   function tryMount() {
-    if (document.getElementById(BAR_ID)) return;
-    mountBar();
+    maybeRelocate();
   }
 
   let mo = null;
+  let relocateTimer = null;
+  function scheduleRelocate() {
+    if (relocateTimer) return;
+    relocateTimer = setTimeout(() => {
+      relocateTimer = null;
+      tryMount();
+    }, 40);
+  }
   function startObserver() {
     if (mo) return;
     installNetworkFallback();
     mo = new MutationObserver((mutations) => {
-      maybeRelocate();
-      if (!document.getElementById(BAR_ID)) tryMount();
+      scheduleRelocate();
       scheduleDomScan();
     });
     window.__tdTokenObserver = mo;
diff --git a/electron/lib/token_usage.js b/electron/lib/token_usage.js
index d31be33..51e34a1 100644
--- a/electron/lib/token_usage.js
+++ b/electron/lib/token_usage.js
@@ -9,6 +9,10 @@ const CODEX_HOME = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
 const SESSIONS_ROOT = path.join(CODEX_HOME, "sessions");
 const RESET_PATH = path.join(CODEX_HOME, ".tokendun-token-reset.json");
 const fileCache = new Map();
+const fsp = fs.promises;
+// 正在增长（流式生成中）的会话文件每次变化都会导致全量重读，阻塞主进程事件循环。
+// 给同一文件加最小重读间隔：5 秒内即使变了也复用上次结果，token 统计允许秒级延迟。
+const MIN_REREAD_MS = 5000;
 
 function clean(n) {
   n = Number(n);
@@ -61,19 +65,24 @@ function snapshotAt(line) {
   return usage.total > 0 ? { timestamp, usage } : null;
 }
 
-function parseSessionFile(file) {
+async function parseSessionFile(file) {
   try {
-    const stat = fs.statSync(file);
+    const stat = await fsp.stat(file);
     const cached = fileCache.get(file);
-    if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.value;
+    if (cached) {
+      // 未变化 → 直接用缓存
+      if (cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.value;
+      // 变化了但距上次读太近 → 复用缓存，避免流式生成期间反复全量读盘阻塞主进程
+      if (Date.now() - cached.readAt < MIN_REREAD_MS) return cached.value;
+    }
+    const text = await fsp.readFile(file, "utf8");
     const snapshots = [];
-    const text = fs.readFileSync(file, "utf8");
     for (const line of text.split("\n")) {
       const snapshot = snapshotAt(line);
       if (snapshot) snapshots.push(snapshot);
     }
     const value = { snapshots };
-    fileCache.set(file, { size: stat.size, mtimeMs: stat.mtimeMs, value });
+    fileCache.set(file, { size: stat.size, mtimeMs: stat.mtimeMs, value, readAt: Date.now() });
     return value;
   } catch {
     return { snapshots: [] };
@@ -132,7 +141,7 @@ function applyReset(value) {
   };
 }
 
-function readDailyRaw(now = new Date()) {
+async function readDailyRaw(now = new Date()) {
   const date = dayKey(now);
   const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
   const end = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
@@ -140,7 +149,7 @@ function readDailyRaw(now = new Date()) {
   result.available = fs.existsSync(SESSIONS_ROOT);
 
   for (const file of sessionFilesForDay(start, end)) {
-    const snapshots = parseSessionFile(file).snapshots;
+    const snapshots = (await parseSessionFile(file)).snapshots;
     let before = null;
     let current = null;
     for (const snapshot of snapshots) {
@@ -159,12 +168,12 @@ function readDailyRaw(now = new Date()) {
   return result;
 }
 
-function readDaily(now = new Date()) {
-  return applyReset(readDailyRaw(now));
+async function readDaily(now = new Date()) {
+  return applyReset(await readDailyRaw(now));
 }
 
-function reset(now = new Date()) {
-  const value = readDailyRaw(now);
+async function reset(now = new Date()) {
+  const value = await readDailyRaw(now);
   fs.mkdirSync(path.dirname(RESET_PATH), { recursive: true });
   fs.writeFileSync(RESET_PATH, JSON.stringify({ ...value, date: dayKey(now) }), "utf8");
   return blank(dayKey(now));
diff --git a/electron/lib/token_watch.js b/electron/lib/token_watch.js
index d67283c..f660ab1 100644
--- a/electron/lib/token_watch.js
+++ b/electron/lib/token_watch.js
@@ -18,7 +18,7 @@ async function tokenStatus() {
   try {
     const snap = voice.status();
     const page = await voice.tokenStatus();
-    const local = tokenUsage.readDaily();
+    const local = await tokenUsage.readDaily();
     if (local && local.available) {
       await voice.tokenSet(local);
       return { ok: true, phase: snap.phase, connected: snap.phase === "connected", ...local, network: page.network };
@@ -31,7 +31,7 @@ async function tokenStatus() {
 
 async function tokenReset() {
   try {
-    const local = tokenUsage.reset();
+    const local = await tokenUsage.reset();
     const ok = await voice.tokenSet(local);
     await voice.tokenReset();
     return { ok: ok || true };
diff --git a/electron/lib/translate.js b/electron/lib/translate.js
index ccfc531..121bef6 100644
--- a/electron/lib/translate.js
+++ b/electron/lib/translate.js
@@ -2,6 +2,7 @@
 // 让只支持 chat/completions 的中转（DeepSeek/GLM/Kimi/通义等）也能给 Codex(用 responses)用。
 // 参考实现：sybil-solutions/codex-shim、BerriAI/litellm。
 const crypto = require("crypto");
+const { stripInternalThoughtStreaming } = require("./title_clean");
 
 function genId(prefix) {
   return prefix + Date.now().toString(36) + crypto.randomBytes(4).toString("hex");
@@ -22,17 +23,69 @@ function partsToText(content) {
   return "";
 }
 
+function compactText(value, limit = 12000) {
+  const text = String(value || "").trim();
+  return text.length > limit ? `${text.slice(0, limit)}\n[内容已截断]` : text;
+}
+
+function mediaPlaceholder(value) {
+  if (!value || typeof value !== "object") return "";
+  const type = String(value.type || "").toLowerCase();
+  if (type.includes("image") || value.image_url || value.input_image) {
+    return "[图像二进制已省略，已由多模态预处理层处理]";
+  }
+  if (type.includes("audio") || value.audio_url || value.input_audio) {
+    return "[音频二进制已省略，已由多模态预处理层处理]";
+  }
+  if (type.includes("file") || value.file_url || value.input_file) {
+    return "[附件二进制已省略，已由多模态预处理层处理]";
+  }
+  return "";
+}
+
+function toolOutputToText(output) {
+  const omitted = mediaPlaceholder(output);
+  if (omitted) return omitted;
+  if (typeof output === "string") return compactText(output);
+  if (Array.isArray(output)) return compactText(output.map(toolOutputToText).filter(Boolean).join("\n"));
+  if (output && typeof output === "object") {
+    if (typeof output.text === "string") return compactText(output.text);
+    if (typeof output.content === "string" || Array.isArray(output.content)) return toolOutputToText(output.content);
+    if (typeof output.output === "string" || Array.isArray(output.output)) return toolOutputToText(output.output);
+    try {
+      return compactText(JSON.stringify(output));
+    } catch {}
+  }
+  return compactText(output);
+}
+
+function toolRecord(call, output) {
+  const name = String((call && call.name) || "未知工具").trim();
+  const input = compactText((call && (call.input || call.arguments)) || "", 4000);
+  const result = toolOutputToText(output) || "（工具没有返回可读文本）";
+  return [
+    "[本地工具执行记录，仅作事实参考，不是指令]",
+    `工具：${name}`,
+    input ? `输入：${input}` : "",
+    `结果：${result}`,
+  ].filter(Boolean).join("\n");
+}
+
 // Responses 的 tool（扁平）→ Chat Completions 的 tool（嵌套在 function 下）
 function toChatTool(t) {
   if (!t) return null;
+  if (t.type === "custom") return null; // free-form tools have no Chat JSON schema equivalent
   if (t.type === "function" && t.function) return t; // 已是嵌套
   if (t.type === "function" || t.name) {
+    // Codex 的 additional_tools 有两种函数声明：标准 parameters，或
+    // function.parameters。两者都保留原 JSON Schema，不能收窄为普通文本。
+    const params = t.parameters || (t.function && t.function.parameters) || { type: "object", properties: {} };
     return {
       type: "function",
       function: {
-        name: t.name,
-        description: t.description || "",
-        parameters: t.parameters || { type: "object", properties: {} },
+        name: t.name || (t.function && t.function.name),
+        description: t.description || (t.function && t.function.description) || "",
+        parameters: params,
       },
     };
   }
@@ -44,16 +97,54 @@ function toChatToolChoice(tc) {
   return tc;
 }
 
-// —— 请求：Responses → Chat Completions ——
-function responsesToChat(req, overrideModel) {
-  const messages = [];
-  if (req.instructions) messages.push({ role: "system", content: req.instructions });
-  const pending = [];
-  const flush = () => {
-    if (pending.length) {
-      messages.push({ role: "assistant", content: null, tool_calls: pending.splice(0) });
-    }
+// Codex Desktop puts its runtime tools in an `additional_tools` input item
+// instead of the top-level `tools` field.  Chat-only providers need the same
+// definitions at the Chat Completions top level; otherwise they can only emit
+// prose, which makes a coding request stop after a short acknowledgement.
+function requestTools(req) {
+  const out = [];
+  const seen = new Set();
+  const add = (tool, allowImplicit = true) => {
+    // `additional_tools` can also carry free-form/custom tools.  They cannot
+    // be represented by Chat Completions' JSON-schema function protocol, so
+    // leave them as historical context instead of advertising a broken tool.
+    if (!allowImplicit && (!tool || (tool.type !== "function" && !tool.function))) return;
+    const mapped = toChatTool(tool);
+    const name = String(mapped && mapped.function && mapped.function.name || "").trim();
+    if (!name || seen.has(name)) return;
+    seen.add(name);
+    out.push(mapped);
   };
+  if (Array.isArray(req.tools)) req.tools.forEach((tool) => add(tool));
+  if (Array.isArray(req.input)) {
+    for (const item of req.input) {
+      if (item && item.type === "additional_tools" && Array.isArray(item.tools)) {
+        item.tools.forEach((tool) => add(tool, false));
+      }
+    }
+  }
+  return out;
+}
+
+// —— 请求：Responses → Chat Completions ——
+function responsesToChat(req, overrideModel, options = {}) {
+  // Codex 的 custom tool 不能由 OpenAI Chat 协议安全复现。将历史动作投影为
+  // 只读结果，避免模型在没有工具契约时输出 DSML 等伪调用标记。
+  const mappedTools = requestTools(req)
+    .filter((tool) => {
+      const name = String(tool && tool.function && tool.function.name || "").toLowerCase();
+      return !(options.omitVisualTools && name === "view_image");
+    });
+  const tools = options.omitTools ? [] : mappedTools;
+  const messages = [];
+  if (!tools.length) {
+    messages.push({
+      role: "system",
+      content: "兼容模式：当前模型只能读取文本上下文，不能调用本地工具。工具执行记录仅代表已完成的事实；不得请求、模拟或输出任何工具调用标记。请直接根据用户问题、附件识别证据和已完成记录回答。",
+    });
+  }
+  if (req.instructions) messages.push({ role: "system", content: req.instructions });
+  const calls = new Map();
   const input = req.input;
   if (typeof input === "string") {
     messages.push({ role: "user", content: input });
@@ -61,28 +152,27 @@ function responsesToChat(req, overrideModel) {
     for (const item of input) {
       const t = item.type;
       if (t === "message" || (item.role && !t)) {
-        flush();
         const role = item.role === "developer" ? "system" : item.role;
-        messages.push({ role, content: partsToText(item.content) });
-      } else if (t === "function_call") {
-        const callId = item.call_id || item.id || "call_0";
-        pending.push({ id: callId, type: "function", function: { name: item.name || "", arguments: item.arguments || "" } });
-      } else if (t === "function_call_output") {
-        flush();
-        const out = typeof item.output === "string" ? item.output : JSON.stringify(item.output);
-        messages.push({ role: "tool", tool_call_id: item.call_id, content: out });
+        if (role === "tool" || role === "function") {
+          // Codex 有时把 view_image 的原图作为 role=tool 消息塞入历史；不能转发 Base64。
+          const result = toolOutputToText(item.content);
+          if (result) messages.push({ role: "user", content: `[已完成的本地工具结果]\n${result}` });
+        } else {
+          messages.push({ role, content: partsToText(item.content) });
+        }
+      } else if (t === "function_call" || t === "custom_tool_call") {
+        calls.set(item.call_id || item.id || `call_${calls.size}`, item);
+      } else if (t === "function_call_output" || t === "custom_tool_call_output") {
+        const call = calls.get(item.call_id) || null;
+        messages.push({ role: "user", content: toolRecord(call, item.output) });
       }
       // reasoning item → 丢弃(chat 上游用不到)
     }
   }
-  flush();
 
   const out = { model: overrideModel || req.model, messages, stream: req.stream !== false };
-  if (Array.isArray(req.tools)) {
-    const tools = req.tools.map(toChatTool).filter(Boolean);
-    if (tools.length) out.tools = tools;
-  }
-  if (req.tool_choice) out.tool_choice = toChatToolChoice(req.tool_choice);
+  if (tools.length) out.tools = tools;
+  if (tools.length && req.tool_choice) out.tool_choice = toChatToolChoice(req.tool_choice);
   if (req.max_output_tokens) out.max_tokens = req.max_output_tokens;
   if (req.temperature != null) out.temperature = req.temperature;
   if (req.top_p != null) out.top_p = req.top_p;
@@ -114,6 +204,7 @@ class ChatToResponses {
     this.outIndex = 0;
     this.msgOpen = false;
     this.msgClosed = false;
+    this.msgRawText = "";
     this.msgText = "";
     this.msgOutputIndex = null;
     this.tools = {}; // index → {id,name,arguments,outputIndex,closed}
@@ -307,16 +398,21 @@ class ChatToResponses {
       });
     }
     if (delta.content) {
-      out += this.closeReason(); // 有正文了，先收尾推理
-      out += this.openMsg();
-      this.msgText += delta.content;
-      out += this.ev("response.output_text.delta", {
-        item_id: this.msgId,
-        output_index: this.msgOutputIndex,
-        content_index: 0,
-        delta: delta.content,
-        logprobs: [],
-      });
+      this.msgRawText += String(delta.content);
+      const visible = stripInternalThoughtStreaming(this.msgRawText);
+      const visibleDelta = visible.slice(this.msgText.length);
+      if (visibleDelta) {
+        out += this.closeReason(); // 有正文了，先收尾推理
+        out += this.openMsg();
+        this.msgText = visible;
+        out += this.ev("response.output_text.delta", {
+          item_id: this.msgId,
+          output_index: this.msgOutputIndex,
+          content_index: 0,
+          delta: visibleDelta,
+          logprobs: [],
+        });
+      }
     }
     if (Array.isArray(delta.tool_calls)) {
       for (const tc of delta.tool_calls) out += this.onToolDelta(tc);
diff --git a/electron/lib/voice_cdp.js b/electron/lib/voice_cdp.js
index dc83040..0e03291 100644
--- a/electron/lib/voice_cdp.js
+++ b/electron/lib/voice_cdp.js
@@ -1,20 +1,21 @@
-// voice_cdp.js —— Codex 语音输入注入：主进程侧。
-// 用 CDP（Chrome DevTools Protocol）连接带 --remote-debugging-port 的 Codex 桌面版，
+// voice_cdp.js —— ChatGPT/Codex 语音输入注入：主进程侧。
+// 用 CDP（Chrome DevTools Protocol）连接带 --remote-debugging-port 的 ChatGPT/Codex 桌面版，
 // 往其页面注入麦克风按钮脚本，录音经 binding 回传 → 调中转站 Whisper 转写 → 文字回填 composer。
 // 不改 Codex 源码、不写补丁文件。无第三方依赖：CDP over WebSocket 用 Node 内置 net 手写最小 WS 客户端
 // （Electron 34 主进程的 Node 无全局 WebSocket）；HTTP 用全局 fetch；multipart 用全局 FormData/Blob。
 //
 // 机制参考 CodexPlusPlus 的 bridge.rs：Runtime.evaluate / Page.addScriptToEvaluateOnNewDocument /
 // Runtime.addBinding + Runtime.bindingCalled。
-const { spawn, execFile } = require("child_process");
-const os = require("os");
-const path = require("path");
+const { execFile, spawn } = require("child_process");
+const fs = require("fs");
 const net = require("net");
 const crypto = require("crypto");
+const os = require("os");
+const path = require("path");
 
 function dlog(...a) { try { console.log("[voice]", ...a); } catch {} }
 const router = require("./router");
-const providerSync = require("./provider_sync");
+const codexDesktop = require("./codex_desktop");
 const { INJECT_SCRIPT } = require("./voice_inject");
 const { TOKEN_INJECT_SCRIPT } = require("./token_inject");
 const tokenUsage = require("./token_usage");
@@ -25,28 +26,39 @@ const CDP_HTTP_TIMEOUT = 3000; // GET /json 超时
 const CDP_WS_TIMEOUT = 5000; // WebSocket 握手超时
 const CDP_CMD_TIMEOUT = 5000; // 单条 CDP 命令超时
 const READY_POLL_INTERVAL = 500; // 轮询就绪间隔
-const READY_POLL_MAX_MS = 20000; // 轮询就绪最长等待
+const READY_POLL_MAX_MS = 180000; // 轮询就绪最长等待：Windows 冷启动可能要 2～3 分钟
+const PACKAGED_READY_POLL_MAX_MS = 180000; // Store/MSIX 版 AppID 启动后也要给足白屏加载时间
+const WINDOWS_LAUNCH_TIMEOUT_MS = 4500;
+const WINDOWS_APPID_ACTIVATE_TIMEOUT_MS = 10000;
 const RECORD_MAX_MS = 60000; // 单次录音上限（注入脚本侧也限）
 
 // —— 状态机 ——
-// unknown / checking / not_running / running_no_port / restarting / connecting /
-// injecting / connected / disconnected / error
+// unknown / checking / not_running / running_no_port / restarting / waiting_debug_port /
+// unsupported_packaged / connecting / injecting / connected / disconnected / error
 let state = {
   phase: "unknown",
   port: DEFAULT_PORT,
   codexPath: "",
+  codexPackaged: false,
+  codexLaunchType: "exe",
+  codexAppId: "",
+  launchWarning: "",
+  portDiagnostic: "",
   lastError: "",
+  discovery: null,
   target: null, // { id, url, title }
 };
 let session = null; // 当前 CdpSession
+let voiceScriptIdentifier = ""; // 用于断开时撤销后续页面的语音自动注入
 let networkSessions = []; // worker 等附加 target 的 Network 监听 session
 let networkAttachGeneration = 0;
 let onStatusCb = null;
+let onSessionDeleteCb = null;
 let tokenSyncTimer = null;
 
 function snapshot() {
-  const { phase, port, codexPath, lastError, model, target } = state;
-  return { phase, port, codexPath, lastError, model, target };
+  const { phase, port, codexPath, codexPackaged, codexLaunchType, codexAppId, launchWarning, portDiagnostic, lastError, model, target, discovery } = state;
+  return { phase, port, codexPath, codexPackaged, codexLaunchType, codexAppId, launchWarning, portDiagnostic, lastError, model, target, discovery };
 }
 function setPhase(phase, extra = {}) {
   state = { ...state, phase, ...extra };
@@ -59,7 +71,7 @@ function setPhase(phase, extra = {}) {
 
 async function syncTokenUsage() {
   if (!session) return;
-  const usage = tokenUsage.readDaily();
+  const usage = await tokenUsage.readDaily();
   if (!usage || !usage.available) return;
   try {
     await session.send("Runtime.evaluate", {
@@ -81,36 +93,290 @@ function stopTokenSync() {
 }
 
 // —— 探测 Codex 可执行路径 ——
-function codexExecutable() {
-  const home = os.homedir();
-  if (process.platform === "darwin") {
-    const cands = [
-      path.join(home, "Applications/ChatGPT.app/Contents/MacOS/ChatGPT"),
-      "/Applications/ChatGPT.app/Contents/MacOS/ChatGPT",
-      "/Applications/Codex.app/Contents/MacOS/Codex",
-    ];
-    for (const p of cands) {
-      try {
-        if (require("fs").existsSync(p)) return p;
-      } catch {}
-    }
-    return "";
-  }
+function scanCodexExecutable() {
+  const candidates = codexDesktop.desktopExecutableCandidates();
+  const candidate = candidates.find((item) => item && item.path && !item.packaged) ||
+    candidates.find((item) => item && item.path && item.packaged);
+  const exe = candidate && candidate.path ? candidate.path : "";
+  state.codexPath = exe;
+  state.codexPackaged = !!(candidate && candidate.packaged);
+  state.codexLaunchType = (candidate && candidate.launchType) || "exe";
+  state.codexAppId = (candidate && candidate.appId) || "";
+  state.discovery = codexDesktop.discoveryReport ? codexDesktop.discoveryReport() : null;
+  return exe;
+}
+
+function desktopNotFoundError() {
+  const summary = codexDesktop.discoverySummary ? codexDesktop.discoverySummary() : "";
+  const discovery = state.discovery || {};
+  const hasPackaged = Array.isArray(discovery.candidates) && discovery.candidates.some((item) => item && item.packaged);
   if (process.platform === "win32") {
-    const local = process.env.LOCALAPPDATA || "";
-    const pf = process.env["ProgramFiles"] || "C:\\Program Files";
-    const cands = [
-      local && path.join(local, "Programs\\ChatGPT\\ChatGPT.exe"),
-      path.join(pf, "ChatGPT\\ChatGPT.exe"),
-    ].filter(Boolean);
-    for (const p of cands) {
-      try {
-        if (require("fs").existsSync(p)) return p;
-      } catch {}
-    }
-    return "";
+    return "未找到可直接启动的 ChatGPT/Codex 桌面程序。" +
+      (summary ? "扫描结果：" + summary + "。" : "") +
+      (hasPackaged ? "检测到 WindowsApps/Store 受保护入口，但它不能直接附加调试端口。" : "") +
+      "请安装官网下载的桌面版后重试。";
   }
-  return "";
+  return "未找到 ChatGPT/Codex 桌面程序。" + (summary ? "扫描结果：" + summary + "。" : "");
+}
+
+function desktopLaunchError(exePath, err) {
+  const msg = String((err && err.message) || err || "");
+  if (process.platform === "win32" && /eperm/i.test(msg)) {
+    return "Windows 拒绝启动 ChatGPT/Codex 调试模式（EPERM）。路径：" + exePath +
+      "。如果这是 Microsoft Store/WindowsApps 版本，请改装官网下载的桌面版；如果是普通 exe，请用管理员权限启动工具箱后再试。";
+  }
+  return "启动 ChatGPT/Codex 失败：" + msg + (exePath ? "。路径：" + exePath : "");
+}
+
+function compactError(err, fallback = "未知错误") {
+  const parts = [
+    err && err.stderr,
+    err && err.stdout,
+    err && err.message,
+    err,
+  ].filter(Boolean).map((v) => String(v));
+  const raw = parts.find((v) => v.trim()) || fallback;
+  return raw
+    .replace(/Command failed:[\s\S]*?(?=(\r?\n|$))/i, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 220) || fallback;
+}
+
+function compactCommandLine(cmd) {
+  const text = String(cmd || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  const hasWindowsApps = /WindowsApps/i.test(text);
+  const hasDebugArg = /--remote-debugging-port/i.test(text);
+  const exe = (text.match(/(?:^|[ "])([A-Z]:\\[^"]*?(?:ChatGPT|Codex)[^"\\]*\.exe)/i) || [])[1] || "";
+  const pidPart = exe ? exe.replace(/^.*[\\/]/, "") : "";
+  const tags = [];
+  if (hasWindowsApps) tags.push("WindowsApps");
+  tags.push(hasDebugArg ? "含调试参数" : "无调试参数");
+  return [pidPart, tags.join("/")].filter(Boolean).join(" ");
+}
+
+function updateWindowsProcessDiagnostic(port) {
+  if (process.platform !== "win32" || !codexDesktop.windowsProcessDiagnostics) return null;
+  try {
+    const d = codexDesktop.windowsProcessDiagnostics(port);
+    if (!d || !Array.isArray(d.rows) || !d.rows.length) {
+      state.portDiagnostic = "未检测到 ChatGPT/Codex 进程";
+      return d;
+    }
+    state.portDiagnostic = d.hasDebugArg
+      ? "进程命令行已包含调试端口参数"
+      : "进程命令行未包含 --remote-debugging-port=" + port + "，调试端口不会打开";
+    const rowsSummary = d.rows.map((row) => {
+      const name = (row && row.Name) || "process";
+      const pid = (row && row.ProcessId) || "?";
+      const cmd = compactCommandLine((row && row.CommandLine) || "");
+      return `${name}#${pid}${cmd ? " " + cmd : ""}`;
+    }).join(" | ");
+    if (rowsSummary) state.portDiagnostic += "；" + rowsSummary;
+    state.portDiagnostic = state.portDiagnostic.slice(0, 260);
+    return d;
+  } catch (e) {
+    state.portDiagnostic = "读取进程命令行失败：" + compactError(e);
+    return null;
+  }
+}
+
+function debugPortFailureMessage(action, port) {
+  const diag = updateWindowsProcessDiagnostic(port);
+  if (state.codexPackaged) {
+    const reason = diag && diag.rows && diag.rows.length && !diag.hasDebugArg
+      ? "当前 Store/MSIX 启动参数没有进入 Codex 进程，无法打开调试端口。"
+      : "当前 Store/MSIX 启动方式未开放调试端口。";
+    return "已尝试通过 Windows AppID " + action + " ChatGPT/Codex，但未检测到调试端口。" +
+      reason + "建议改装官网下载桌面版。";
+  }
+  return action === "重启" ? "重启 ChatGPT 后未开放调试端口" : "Codex 启动后未开放调试端口，请重试";
+}
+
+function isPackagedDebugArgMissing(port) {
+  if (!state.codexPackaged || process.platform !== "win32") return false;
+  const d = updateWindowsProcessDiagnostic(port);
+  return !!(d && Array.isArray(d.rows) && d.rows.length && !d.hasDebugArg);
+}
+
+function setDebugPortFailure(action, port) {
+  const unsupported = isPackagedDebugArgMissing(port);
+  setPhase(unsupported ? "unsupported_packaged" : "error", {
+    lastError: debugPortFailureMessage(action, port) + (state.launchWarning ? "（" + state.launchWarning + "）" : ""),
+    portDiagnostic: state.portDiagnostic,
+  });
+}
+
+function windowsLaunchArgs(port) {
+  return [
+    `--remote-debugging-port=${port}`,
+    `--remote-allow-origins=http://127.0.0.1:${port}`,
+  ];
+}
+
+function quoteWindowsArgument(arg) {
+  const text = String(arg || "");
+  if (text && !/[ \t"]/.test(text)) return text;
+  let out = "\"";
+  let backslashes = 0;
+  for (const ch of text) {
+    if (ch === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (ch === "\"") {
+      out += "\\".repeat(backslashes * 2 + 1) + "\"";
+      backslashes = 0;
+      continue;
+    }
+    out += "\\".repeat(backslashes) + ch;
+    backslashes = 0;
+  }
+  out += "\\".repeat(backslashes * 2) + "\"";
+  return out;
+}
+
+function windowsCommandLineArguments(args) {
+  return args.map(quoteWindowsArgument).join(" ");
+}
+
+function windowsActivateAppId(appId, port) {
+  return new Promise((resolve, reject) => {
+    if (process.platform !== "win32") {
+      reject(new Error("AppID activation only supports Windows"));
+      return;
+    }
+    const script = [
+      "$ErrorActionPreference='Stop'",
+      "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8",
+      "$OutputEncoding=[System.Text.Encoding]::UTF8",
+      "$code = @'",
+      "using System;",
+      "using System.Runtime.InteropServices;",
+      "namespace TdCodexAppActivation {",
+      "[ComImport, Guid(\"45BA127D-10A8-46EA-8AB7-56EA9078943C\")]",
+      "public class ApplicationActivationManager {}",
+      "[ComImport, Guid(\"2e941141-7f97-4756-ba1d-9decde894a3d\"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]",
+      "public interface IApplicationActivationManager {",
+      "  [PreserveSig]",
+      "  int ActivateApplication([MarshalAs(UnmanagedType.LPWStr)] string appUserModelId, [MarshalAs(UnmanagedType.LPWStr)] string arguments, int options, out uint processId);",
+      "  [PreserveSig]",
+      "  int ActivateForFile([MarshalAs(UnmanagedType.LPWStr)] string appUserModelId, IntPtr itemArray, [MarshalAs(UnmanagedType.LPWStr)] string verb, out uint processId);",
+      "  [PreserveSig]",
+      "  int ActivateForProtocol([MarshalAs(UnmanagedType.LPWStr)] string appUserModelId, IntPtr itemArray, out uint processId);",
+      "}",
+      "public static class Launcher {",
+      "  const int COINIT_APARTMENTTHREADED = 0x2;",
+      "  const int RPC_E_CHANGED_MODE = unchecked((int)0x80010106);",
+      "  [DllImport(\"ole32.dll\")] static extern int CoInitializeEx(IntPtr pvReserved, int dwCoInit);",
+      "  [DllImport(\"ole32.dll\")] static extern void CoUninitialize();",
+      "  public static uint Activate(string appUserModelId, string arguments) {",
+      "    int coinit = CoInitializeEx(IntPtr.Zero, COINIT_APARTMENTTHREADED);",
+      "    bool shouldUninitialize = coinit >= 0;",
+      "    if (coinit < 0 && coinit != RPC_E_CHANGED_MODE) Marshal.ThrowExceptionForHR(coinit);",
+      "    try {",
+      "      var manager = (IApplicationActivationManager)new ApplicationActivationManager();",
+      "      uint processId = 0;",
+      "      int hr = manager.ActivateApplication(appUserModelId, arguments, 0, out processId);",
+      "      if (hr != 0) throw new COMException(\"ActivateApplication failed\", hr);",
+      "      return processId;",
+      "    } finally {",
+      "      if (shouldUninitialize) CoUninitialize();",
+      "    }",
+      "  }",
+      "}",
+      "}",
+      "'@",
+      "Add-Type -TypeDefinition $code -ErrorAction Stop",
+      "$activatedProcessId=[TdCodexAppActivation.Launcher]::Activate($env:TD_CODEX_APPID, $env:TD_CODEX_LAUNCH_ARGS)",
+      "[pscustomobject]@{ok=$true;pid=$activatedProcessId;args=$env:TD_CODEX_LAUNCH_ARGS}|ConvertTo-Json -Compress",
+    ].join("\n");
+    const scriptPath = path.join(os.tmpdir(), "td-codex-appid-activate-" + process.pid + "-" + Date.now() + ".ps1");
+    try {
+      fs.writeFileSync(scriptPath, script, "utf8");
+    } catch (e) {
+      reject(e);
+      return;
+    }
+    execFile("powershell.exe", ["-NoProfile", "-Sta", "-ExecutionPolicy", "Bypass", "-File", scriptPath], {
+      env: {
+        ...process.env,
+        TD_CODEX_APPID: String(appId || ""),
+        TD_CODEX_LAUNCH_PORT: String(port),
+        TD_CODEX_LAUNCH_ARGS: windowsCommandLineArguments(windowsLaunchArgs(port)),
+      },
+      windowsHide: true,
+      timeout: WINDOWS_APPID_ACTIVATE_TIMEOUT_MS,
+    }, (err, stdout) => {
+      try { fs.rmSync(scriptPath, { force: true }); } catch {}
+      if (err) {
+        reject(err);
+        return;
+      }
+      let data = null;
+      try {
+        data = JSON.parse(String(stdout || "").trim());
+      } catch {}
+      resolve(data || { ok: true });
+    });
+  });
+}
+
+function windowsShellStart(exePath, port) {
+  return new Promise((resolve, reject) => {
+    if (process.platform !== "win32") {
+      reject(new Error("shell start only supports Windows"));
+      return;
+    }
+    const launchType = state.codexLaunchType || "exe";
+    const target = launchType === "appId"
+      ? "shell:AppsFolder\\" + String(state.codexAppId || exePath || "").trim()
+      : String(exePath || "").replace(/^\\\\\?\\/, "");
+    if (launchType === "appId") {
+      windowsActivateAppId(state.codexAppId || exePath, port).then((data) => {
+        const pid = data && data.pid ? `，PID ${data.pid}` : "";
+        state.launchWarning = "已通过 Windows AppID 激活 Store/MSIX 版 Codex" + pid;
+        resolve(true);
+      }).catch((activateErr) => {
+        execFile("explorer.exe", [target], { windowsHide: true, timeout: WINDOWS_LAUNCH_TIMEOUT_MS }, (err) => {
+          const first = "COM 激活提示：" + compactError(activateErr, "AppID 激活失败");
+          if (err) {
+            // explorer.exe often returns a failure code for shell:AppsFolder
+            // even after Windows has already handed off and launched the app.
+            const second = "explorer 提示：" + compactError(err, "explorer 启动失败");
+            state.launchWarning = (first + "；" + second).slice(0, 220);
+            resolve(false);
+            return;
+          }
+          state.launchWarning = (first + "；已通过 explorer 兜底拉起 Store/MSIX 版 Codex").slice(0, 220);
+          resolve(true);
+        });
+      });
+      return;
+    }
+    const script = [
+      "$target=$env:TD_CODEX_LAUNCH_TARGET",
+      "$args=@('--remote-debugging-port=' + $env:TD_CODEX_LAUNCH_PORT, '--remote-allow-origins=http://127.0.0.1:' + $env:TD_CODEX_LAUNCH_PORT)",
+      "Start-Process -FilePath $target -ArgumentList $args",
+    ].join(";");
+    execFile("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
+      env: {
+        ...process.env,
+        TD_CODEX_LAUNCH_TARGET: target,
+        TD_CODEX_LAUNCH_PORT: String(port),
+      },
+      windowsHide: true,
+      timeout: WINDOWS_LAUNCH_TIMEOUT_MS,
+    }, (err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      state.launchWarning = "";
+      resolve(true);
+    });
+  });
 }
 
 // —— HTTP：GET /json 取 targets ——
@@ -427,7 +693,22 @@ async function handleBinding(params) {
   } catch {
     return;
   }
-  if (!payload || payload.kind !== "transcribe") return;
+  if (!payload) return;
+  if (
+    payload.kind === "delete-session" ||
+    payload.kind === "delete-session-clipboard-prepare" ||
+    payload.kind === "delete-session-clipboard-read"
+  ) {
+    if (onSessionDeleteCb) {
+      try { await onSessionDeleteCb(payload); } catch (e) { dlog("永久删除会话请求失败:", e && e.message); }
+    }
+    return;
+  }
+  if (payload.kind === "debug-sidebar-dump") {
+    dlog("侧边栏诊断:", JSON.stringify(payload.info || {}));
+    return;
+  }
+  if (payload.kind !== "transcribe") return;
   const { id, audioB64, mime } = payload;
   dlog("binding 收到转写请求 id=" + id, "mime=" + mime, "audioB64长度=" + (audioB64?audioB64.length:0));
   setPhase("transcribing");
@@ -456,6 +737,11 @@ function connectedPhase() {
 
 // —— 注入：addBinding + addScriptToEvaluateOnNewDocument + 立即 evaluate + Network 监听 ——
 async function inject(sessionObj) {
+  // 清除 require 缓存，使 voice_inject.js 的修改能在重连时生效，无需重启整个应用
+  delete require.cache[require.resolve("./voice_inject")];
+  delete require.cache[require.resolve("./token_inject")];
+  const { INJECT_SCRIPT: FRESH_INJECT } = require("./voice_inject");
+  const { TOKEN_INJECT_SCRIPT: FRESH_TOKEN } = require("./token_inject");
   await sessionObj.send("Runtime.enable");
   try {
     await sessionObj.send("Runtime.removeBinding", { name: BINDING_NAME });
@@ -463,11 +749,12 @@ async function inject(sessionObj) {
   await sessionObj.send("Runtime.addBinding", { name: BINDING_NAME });
   await sessionObj.send("Page.enable");
   // 语音注入脚本
-  await sessionObj.send("Page.addScriptToEvaluateOnNewDocument", { source: INJECT_SCRIPT });
-  await sessionObj.send("Runtime.evaluate", { expression: INJECT_SCRIPT, awaitPromise: false });
+  const voiceScript = await sessionObj.send("Page.addScriptToEvaluateOnNewDocument", { source: FRESH_INJECT });
+  voiceScriptIdentifier = (voiceScript && voiceScript.identifier) || "";
+  await sessionObj.send("Runtime.evaluate", { expression: FRESH_INJECT, awaitPromise: false });
   // Token 用量 UI 注入脚本（只负责 UI + localStorage，不管网络抓取）
-  await sessionObj.send("Page.addScriptToEvaluateOnNewDocument", { source: TOKEN_INJECT_SCRIPT });
-  await sessionObj.send("Runtime.evaluate", { expression: TOKEN_INJECT_SCRIPT, awaitPromise: false });
+  await sessionObj.send("Page.addScriptToEvaluateOnNewDocument", { source: FRESH_TOKEN });
+  await sessionObj.send("Runtime.evaluate", { expression: FRESH_TOKEN, awaitPromise: false });
   // 启用 Network 域，在 CDP 层面拦截 LLM 响应抓 token 用量
   await sessionObj.send("Network.enable");
 }
@@ -732,18 +1019,19 @@ async function connectToTarget(port) {
   closeNetworkSessions();
   state.target = { id: tgt.id, url: tgt.url, title: tgt.title };
   setPhase("connecting");
-  session = await openSession(tgt.webSocketDebuggerUrl, handleBinding);
-  session.on("Runtime.bindingCalled", handleBinding);
+  const ownedSession = await openSession(tgt.webSocketDebuggerUrl, handleBinding);
+  session = ownedSession;
   // Token 用量：Network 层拦截 LLM 响应
-  bindNetworkHandlers(session);
-  session.ws.on("close", () => {
+  bindNetworkHandlers(ownedSession);
+  ownedSession.ws.on("close", () => {
+    if (session !== ownedSession) return;
     stopTokenSync();
     closeNetworkSessions();
     session = null;
     setPhase("disconnected");
   });
   setPhase("injecting");
-  await inject(session);
+  await inject(ownedSession);
   startTokenSync();
   setPhase("connected", { target: state.target });
   attachWorkerNetworkTargets(port, tgt.id).catch((e) => {
@@ -755,44 +1043,66 @@ async function connectToTarget(port) {
 // —— 轮询直到出现 page target（重启后用）——
 async function waitForReady(port) {
   const t0 = Date.now();
-  while (Date.now() - t0 < READY_POLL_MAX_MS) {
+  const maxMs = state.codexPackaged ? PACKAGED_READY_POLL_MAX_MS : READY_POLL_MAX_MS;
+  let diagnosed = false;
+  while (Date.now() - t0 < maxMs) {
     const targets = await listTargets(port);
     const tgt = pickTarget(targets);
     if (tgt) return tgt;
+    if (!diagnosed && process.platform === "win32" && Date.now() - t0 >= 5000) {
+      diagnosed = true;
+      const d = updateWindowsProcessDiagnostic(port);
+      setPhase("waiting_debug_port", { portDiagnostic: state.portDiagnostic });
+      if (state.codexPackaged && d && Array.isArray(d.rows) && d.rows.length && !d.hasDebugArg) {
+        return null;
+      }
+    }
     await new Promise((r) => setTimeout(r, READY_POLL_INTERVAL));
   }
+  updateWindowsProcessDiagnostic(port);
   return null;
 }
 
-// —— 启动接管：杀当前 Codex → 带端口重启 ——
-function killCodex() {
-  return new Promise((resolve) => {
-    if (process.platform === "darwin") {
-      execFile("osascript", ["-e", 'tell application "ChatGPT" to quit'], () => {
-        // 兜底：osascript 没杀掉就 pkill
-        execFile("pgrep", ["-f", "ChatGPT.app/Contents/MacOS/ChatGPT"], (_e, out) => {
-          if (out && out.trim()) {
-            execFile("pkill", ["-f", "ChatGPT.app/Contents/MacOS/ChatGPT"], () =>
-              setTimeout(resolve, 800)
-            );
-          } else resolve();
-        });
-      });
-    } else if (process.platform === "win32") {
-      execFile("taskkill", ["/IM", "ChatGPT.exe", "/F"], () =>
-        setTimeout(resolve, 800)
-      );
-    } else resolve();
-  });
-}
 function spawnCodex(exePath, port) {
-  const child = spawn(exePath, [`--remote-debugging-port=${port}`], {
-    detached: true,
-    stdio: "ignore",
+  if (state.codexPackaged && process.platform === "win32") {
+    return windowsShellStart(exePath, port);
+  }
+  return new Promise((resolve, reject) => {
+    let child = null;
+    try {
+      const args = process.platform === "win32" ? windowsLaunchArgs(port) : [`--remote-debugging-port=${port}`];
+      child = spawn(exePath, args, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: false,
+      });
+    } catch (e) {
+      reject(e);
+      return;
+    }
+    state.launchWarning = "";
+    let settled = false;
+    const finish = (err) => {
+      if (settled) return;
+      settled = true;
+      if (err) {
+        reject(err);
+        return;
+      }
+      try {
+        child.unref();
+      } catch {}
+      resolve(true);
+    };
+    child.once("error", (err) => {
+      if (process.platform === "win32" && /eperm/i.test(String((err && err.message) || err || ""))) {
+        windowsShellStart(exePath, port).then(() => finish(null)).catch(finish);
+        return;
+      }
+      finish(err);
+    });
+    child.once("spawn", () => finish(null));
   });
-  try {
-    child.unref();
-  } catch {}
 }
 
 // —— 对外：status / connect / disconnect ——
@@ -802,31 +1112,39 @@ function status() {
 function onStatus(cb) {
   onStatusCb = cb;
 }
+function onSessionDelete(cb) {
+  onSessionDeleteCb = cb;
+}
 
 // connect(onStatusCb)：流程见计划。forceRestart=true 时直接重启（前端已确认）。
 async function connect(cb, opts = {}) {
   if (cb) onStatusCb = cb;
   const port = opts.port || DEFAULT_PORT;
   state.port = port;
-  setPhase("checking");
+  setPhase("checking", { lastError: "", launchWarning: "", portDiagnostic: "" });
+  const exe = scanCodexExecutable();
   // 1. 端口已开？
   const ok = await connectToTarget(port);
   if (ok) return snapshot();
   // 2. 判断 Codex 是否在跑
-  const running = providerSync.codexRunning ? providerSync.codexRunning() : false;
+  const running = codexDesktop.codexRunning();
   if (!running && !opts.forceRestart) {
     // 没在跑也没开端口：直接尝试拉起带端口的实例（无需杀进程）
-    const exe = codexExecutable();
     if (!exe) {
-      setPhase("error", { lastError: "未找到 Codex 可执行文件" });
+      setPhase("error", { lastError: desktopNotFoundError(), discovery: state.discovery });
       return snapshot();
     }
-    state.codexPath = exe;
     setPhase("restarting", { codexPath: exe });
-    spawnCodex(exe, port);
+    try {
+      await spawnCodex(exe, port);
+    } catch (e) {
+      setPhase("error", { lastError: desktopLaunchError(exe, e), discovery: state.discovery });
+      return snapshot();
+    }
+    setPhase("waiting_debug_port", { codexPath: exe, lastError: "" });
     const tgt = await waitForReady(port);
     if (!tgt) {
-      setPhase("error", { lastError: "Codex 启动后未开放调试端口，请重试" });
+      setDebugPortFailure("启动", port);
       return snapshot();
     }
     const ok2 = await connectToTarget(port);
@@ -835,23 +1153,27 @@ async function connect(cb, opts = {}) {
   }
   // 3. 在跑但没端口：需用户在前端确认后 forceRestart 重启
   if (running && !opts.forceRestart) {
-    state.codexPath = codexExecutable();
     setPhase("running_no_port", { codexPath: state.codexPath });
     return snapshot(); // 前端据此弹"重启确认"
   }
   // 4. forceRestart：杀进程 → 重启
-  const exe = codexExecutable();
   if (!exe) {
-    setPhase("error", { lastError: "未找到 Codex 可执行文件" });
+    setPhase("error", { lastError: desktopNotFoundError(), discovery: state.discovery });
     return snapshot();
   }
   state.codexPath = exe;
   setPhase("restarting");
-  await killCodex();
-  spawnCodex(exe, port);
+  await codexDesktop.killCodex();
+  try {
+    await spawnCodex(exe, port);
+  } catch (e) {
+    setPhase("error", { lastError: desktopLaunchError(exe, e), discovery: state.discovery });
+    return snapshot();
+  }
+  setPhase("waiting_debug_port", { codexPath: exe, lastError: "" });
   const tgt = await waitForReady(port);
   if (!tgt) {
-    setPhase("error", { lastError: "重启 Codex 后未开放调试端口" });
+    setDebugPortFailure("重启", port);
     return snapshot();
   }
   const ok3 = await connectToTarget(port);
@@ -859,14 +1181,28 @@ async function connect(cb, opts = {}) {
   return snapshot();
 }
 
-function disconnect() {
+async function disconnect() {
   stopTokenSync();
   closeNetworkSessions();
   if (session) {
+    const ownedSession = session;
+    // 先让页面停止录音并删除已挂载按钮，再关闭 CDP；关闭后无法清理前台 DOM。
     try {
-      session.close();
+      await ownedSession.send("Runtime.evaluate", {
+        expression: "window.__voiceInjectDispose && window.__voiceInjectDispose()",
+        awaitPromise: false,
+      });
     } catch {}
+    if (voiceScriptIdentifier) {
+      try {
+        await ownedSession.send("Page.removeScriptToEvaluateOnNewDocument", { identifier: voiceScriptIdentifier });
+      } catch {}
+      voiceScriptIdentifier = "";
+    }
     session = null;
+    try {
+      ownedSession.close();
+    } catch {}
   }
   setPhase("disconnected");
   return snapshot();
@@ -973,6 +1309,7 @@ module.exports = {
   connect,
   disconnect,
   onStatus,
+  onSessionDelete,
   sttInfo,
   probeStt,
   tokenStatus,
diff --git a/electron/lib/voice_inject.js b/electron/lib/voice_inject.js
index f042b4b..e2da91a 100644
--- a/electron/lib/voice_inject.js
+++ b/electron/lib/voice_inject.js
@@ -7,17 +7,23 @@
 // 注意：脚本体用普通模板字符串包裹；内部避免出现 ${（已无）与裸反引号（内部的模板字符串反引号需转义为 \`)。
 const INJECT_SCRIPT = `
 (() => {
-  const VER = "voice-inject-v6";
+  const VER = "voice-inject-v13";
   if (window.__voiceInjectInstalled === VER) return;
-  // 版本变了或首次：清理旧按钮/旧 observer，重新安装
-  if (window.__voiceInjectObserver) { try { window.__voiceInjectObserver.disconnect(); } catch {} }
+  // 版本变了或首次：完整卸载旧实例，避免旧 observer 在新会话继续挂回按钮。
+  if (typeof window.__voiceInjectDispose === "function") {
+    try { window.__voiceInjectDispose(); } catch {}
+  } else if (window.__voiceInjectObserver) {
+    try { window.__voiceInjectObserver.disconnect(); } catch {}
+  }
   const oldBtn = document.getElementById("codex-voice-input-btn");
   if (oldBtn) oldBtn.remove();
+  document.querySelectorAll("[data-td-sidebar-delete]").forEach((el) => el.remove());
   window.__voiceInjectInstalled = VER;
 
   const TAG = "[VoiceInput]";
   const BTN_ID = "codex-voice-input-btn";
-  const STYLE_ID = "codex-voice-input-style-v6";
+  const STYLE_ID = "codex-voice-input-style-v13";
+  let disposed = false;
 
   // —— 样式 ——
   if (!document.getElementById(STYLE_ID)) {
@@ -58,11 +64,18 @@ const INJECT_SCRIPT = `
         font:13px system-ui,sans-serif;z-index:999999;box-shadow:0 8px 30px rgba(0,0,0,.5);
         max-width:80vw;
       }
+      .td-sidebar-delete-btn{color:rgba(113,113,122,.72)!important;}
+      .td-sidebar-delete-btn:hover,.td-sidebar-delete-btn:focus-visible{color:#dc2626!important;}
+      @media (prefers-color-scheme:dark){
+        .td-sidebar-delete-btn{color:rgba(161,161,170,.72)!important;}
+        .td-sidebar-delete-btn:hover,.td-sidebar-delete-btn:focus-visible{color:#f87171!important;}
+      }
     \`;
     (document.head || document.documentElement).appendChild(st);
   }
 
   function toast(msg, ms = 2400) {
+    if (disposed) return;
     const t = document.createElement("div");
     t.className = "codex-voice-toast";
     t.textContent = msg;
@@ -70,6 +83,410 @@ const INJECT_SCRIPT = `
     setTimeout(() => t.remove(), ms);
   }
 
+  // 某些中转会把内部思考块作为普通正文推给页面。只处理已明确成对的
+  // 内部标签，保留用户输入框、代码编辑器和工具箱自己注入的节点。
+  function stripVisibleThoughtText(text) {
+    let out = String(text || "");
+    for (const name of ["thinking", "analysis", "reasoning"]) {
+      out = out.replace(new RegExp("<" + name + "\\b[^>]*>[\\s\\S]*?</" + name + "\\s*>", "gi"), "");
+    }
+    return out.replace(/<\\/?(?:thinking|analysis|reasoning)\\b[^>]*>/gi, "");
+  }
+  function sanitizeVisibleThoughts(root) {
+    if (!root || !document.createTreeWalker) return;
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    let node;
+    while ((node = walker.nextNode())) nodes.push(node);
+    for (const textNode of nodes) {
+      const parent = textNode.parentElement;
+      if (!parent || parent.closest("#codex-voice-input-btn, textarea, input, [contenteditable='true'], script, style")) continue;
+      const next = stripVisibleThoughtText(textNode.nodeValue);
+      if (next !== textNode.nodeValue) textNode.nodeValue = next;
+    }
+  }
+
+  // 在 Codex 任务右键菜单中增加真正删除入口。只从当前菜单关联的
+  // DOM 数据/链接提取 thread id，拿不到 id 时不显示，避免误删。
+  let currentMenuThreadId = "";
+  const THREAD_ID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+  function readReactThreadId(node) {
+    for (const key of Object.keys(node || {})) {
+      if (!key.startsWith("__reactProps$") && !key.startsWith("__reactFiber$")) continue;
+      const seen = new Set();
+      const walk = (value, depth, field) => {
+        if (depth > 4 || value == null) return "";
+        if (typeof value === "string") {
+          const hit = value.match(THREAD_ID_RE);
+          return hit && /thread|conversation|session|href|id/i.test(field || "") ? hit[0] : "";
+        }
+        if (typeof value !== "object" || seen.has(value) || value instanceof Node) return "";
+        seen.add(value);
+        for (const [name, child] of Object.entries(value)) {
+          if (/^(children|return|sibling|child|stateNode|alternate|_owner)$/i.test(name)) continue;
+          const hit = walk(child, depth + 1, name);
+          if (hit) return hit;
+        }
+        return "";
+      };
+      const hit = walk(node[key], 0, key);
+      if (hit) return hit;
+    }
+    return "";
+  }
+  function readThreadId(node) {
+    let cur = node;
+    for (let depth = 0; cur && depth < 8; depth++, cur = cur.parentElement) {
+      for (const key of ["threadId", "conversationId", "sessionId", "id"]) {
+        const value = cur.dataset && cur.dataset[key];
+        if (value && THREAD_ID_RE.test(value)) return value.match(THREAD_ID_RE)[0];
+      }
+      const href = cur.getAttribute && cur.getAttribute("href");
+      const hit = href && href.match(THREAD_ID_RE);
+      if (hit) return hit[0];
+      const text = cur.getAttribute && (cur.getAttribute("data-state") || cur.getAttribute("aria-controls") || "");
+      const textHit = text.match(THREAD_ID_RE);
+      if (textHit) return textHit[0];
+      const nested = cur.querySelector && cur.querySelector("a[href],[data-thread-id],[data-conversation-id],[data-session-id]");
+      if (nested && nested !== cur) {
+        const nestedValue = (nested.getAttribute("href") || "") + " " +
+          (nested.dataset && (nested.dataset.threadId || nested.dataset.conversationId || nested.dataset.sessionId) || "");
+        const nestedHit = nestedValue.match(THREAD_ID_RE);
+        if (nestedHit) return nestedHit[0];
+      }
+      const reactHit = readReactThreadId(cur);
+      if (reactHit) return reactHit;
+    }
+    return "";
+  }
+  function sidebarThreadId(row) {
+    const raw = row && row.getAttribute && row.getAttribute("data-app-action-sidebar-thread-id");
+    const hit = String(raw || "").match(THREAD_ID_RE);
+    return hit ? hit[0] : readThreadId(row);
+  }
+  function copySessionIdItem(menu) {
+    if (!menu) return null;
+    const candidates = menu.querySelectorAll("button,[role='menuitem'],[role='button'],li,div");
+    for (const item of candidates) {
+      if (item.dataset && item.dataset.tdPermanentDelete) continue;
+      if (String(item.textContent || "").trim() === "复制会话 ID") return item;
+    }
+    return null;
+  }
+  function menuLooksLikeSession(menu) {
+    const text = String(menu && menu.textContent || "");
+    return !!copySessionIdItem(menu) && /归档任务|复制深度链接|重命名任务/.test(text);
+  }
+  function findMenuThreadId(menu) {
+    const direct = readThreadId(menu);
+    if (direct) return direct;
+    const links = menu ? menu.querySelectorAll("a,button,[role='menuitem'],[data-thread-id],[data-conversation-id]") : [];
+    for (const el of links) {
+      const hit = readThreadId(el);
+      if (hit) return hit;
+    }
+    return currentMenuThreadId;
+  }
+  function sendDeleteRequest(threadId, menu) {
+    if (!threadId || typeof window.__voiceBridge !== "function") {
+      const nativeCopy = copySessionIdItem(menu);
+      if (!nativeCopy || typeof window.__voiceBridge !== "function") {
+        toast("未找到会话 ID，请从工具箱会话记录页删除");
+        return;
+      }
+      const requestId = "td-del-" + Date.now() + "-" + Math.random().toString(16).slice(2);
+      try {
+        // 先让主进程保存剪贴板，随后复用 Codex 原生“复制会话 ID”菜单动作。
+        window.__voiceBridge(JSON.stringify({ kind: "delete-session-clipboard-prepare", requestId }));
+        setTimeout(() => {
+          try { nativeCopy.click(); } catch {}
+          setTimeout(() => {
+            try { window.__voiceBridge(JSON.stringify({ kind: "delete-session-clipboard-read", requestId })); } catch {}
+          }, 90);
+        }, 110);
+        toast("正在读取会话 ID…", 2200);
+      } catch (e) {
+        toast("删除请求发送失败");
+      }
+      return true;
+    }
+    try {
+      window.__voiceBridge(JSON.stringify({ kind: "delete-session", threadId }));
+      toast("正在执行永久删除，请稍候…", 3200);
+      return false;
+    } catch (e) {
+      toast("删除请求发送失败");
+      return false;
+    }
+  }
+  function addDeleteMenuItem(menu) {
+    if (!menu || menu.querySelector("[data-td-permanent-delete]")) return;
+    if (!menuLooksLikeSession(menu)) return;
+    const threadId = findMenuThreadId(menu);
+    const nativeCopy = copySessionIdItem(menu);
+    if (!nativeCopy) return;
+    const item = document.createElement("button");
+    item.type = "button";
+    item.dataset.tdPermanentDelete = "1";
+    item.textContent = "彻底删除本地会话";
+    item.title = "退出 Codex 后删除本地会话、SQLite 索引和工具箱记忆";
+    item.style.cssText = "display:block;width:100%;margin-top:6px;padding:8px 12px;border:0;border-top:1px solid rgba(127,127,127,.2);background:transparent;color:#dc2626;text-align:left;font:inherit;cursor:pointer;";
+    item.addEventListener("mouseenter", () => { item.style.background = "rgba(220,38,38,.10)"; });
+    item.addEventListener("mouseleave", () => { item.style.background = "transparent"; });
+    item.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const needsNativeCopy = sendDeleteRequest(threadId, menu);
+      const root = item.closest("[role='menu'],[data-radix-menu-content]") || item.parentElement;
+      if (root) setTimeout(() => root.remove(), needsNativeCopy ? 280 : 0);
+    });
+    (nativeCopy.parentElement || menu).appendChild(item);
+  }
+  function scanSessionMenus() {
+    document.querySelectorAll("[role='menu'],[data-radix-menu-content],div[class*='menu'],div[class*='popover']").forEach((el) => addDeleteMenuItem(el));
+  }
+  function captureMenuTarget(event) {
+    currentMenuThreadId = readThreadId(event.target);
+    setTimeout(scanSessionMenus, 30);
+    setTimeout(scanSessionMenus, 180);
+  }
+  if (window.__tdPermanentDeleteContextHandler) {
+    document.removeEventListener("contextmenu", window.__tdPermanentDeleteContextHandler, true);
+    document.removeEventListener("pointerdown", window.__tdPermanentDeleteContextHandler, true);
+  }
+  // 原生菜单不经过网页 DOM，不再对全局 pointerdown 做昂贵扫描。保留手动
+  // scanner 仅用于未来 Codex 切回网页菜单时诊断。
+  window.__tdPermanentDeleteContextHandler = null;
+  window.__tdScanPermanentDeleteMenu = scanSessionMenus;
+
+  // Codex 的右键菜单是 Electron 原生 Menu，网页脚本无法向其中追加 DOM。
+  // 因此把彻底删除入口挂到任务行已有的“置顶/归档”操作组，macOS/Windows 共用。
+  function makeSidebarDeleteButton(row, actionBox) {
+    const archive = actionBox.querySelector("button[aria-label='归档任务'],button[aria-label='Archive task']");
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.dataset.tdSidebarDelete = "1";
+    btn.className = ((archive && archive.className) || "") + " td-sidebar-delete-btn";
+    btn.setAttribute("aria-label", "彻底删除本地会话");
+    btn.title = "彻底删除本地会话";
+    btn.innerHTML = '<svg width="20" height="20" viewBox="0 0 20 20" fill="none" aria-hidden="true"><path d="M6.25 5.75h7.5m-6.5 0 .45 9h4.6l.45-9M8.1 5.75V4.5h3.8v1.25M8.65 8v4.6M11.35 8v4.6" stroke="currentColor" stroke-width="1.35" stroke-linecap="round" stroke-linejoin="round"/></svg>';
+    btn.addEventListener("pointerdown", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+    });
+    btn.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const threadId = sidebarThreadId(row);
+      if (!threadId) {
+        toast("未找到会话 ID，请从工具箱会话记录页删除");
+        return;
+      }
+      sendDeleteRequest(threadId, null);
+    });
+    return btn;
+  }
+  // —— 侧栏行/归档按钮/操作容器 查找：多策略 + 调试日志 ——
+  // 行查找：优先 Codex 内部属性，退化到 aria-label/href/testid 关键字匹配。
+  function findSidebarRows(root) {
+    const scope = root || document;
+    const out = [];
+    const seen = new Set();
+    const push = (el) => { if (el && !seen.has(el)) { seen.add(el); out.push(el); } };
+    // 1) Codex 内部属性（最准）
+    try {
+      if (scope.nodeType === 1 && scope.matches && scope.matches("[data-app-action-sidebar-thread-row]")) push(scope);
+      if (scope.querySelectorAll) scope.querySelectorAll("[data-app-action-sidebar-thread-row]").forEach(push);
+    } catch (e) { console.log("[TD] findSidebarRows: attr strategy failed", e && e.message); }
+    if (out.length) { console.log("[TD] findSidebarRows: attr strategy hit", out.length); return out; }
+    // 2) aria-label 含 thread/conversation/任务/会话 的按钮或链接
+    try {
+      const ariaEls = scope.querySelectorAll("button[aria-label],a[aria-label],[role='button'][aria-label]");
+      const kwRe = /(thread|conversation|任务|会话)/i;
+      for (const el of ariaEls) {
+        const label = el.getAttribute("aria-label") || "";
+        if (kwRe.test(label)) push(el.closest("li,[data-app-action-sidebar-thread-row],div,section") || el.parentElement || el);
+      }
+    } catch (e) { console.log("[TD] findSidebarRows: aria strategy failed", e && e.message); }
+    if (out.length) { console.log("[TD] findSidebarRows: aria strategy hit", out.length); return out; }
+    // 3) href 含 UUID 的链接
+    try {
+      const hrefEls = scope.querySelectorAll("a[href]");
+      for (const el of hrefEls) {
+        const href = el.getAttribute("href") || "";
+        if (THREAD_ID_RE.test(href)) push(el.closest("li,[data-app-action-sidebar-thread-row],div,section") || el.parentElement || el);
+      }
+    } catch (e) { console.log("[TD] findSidebarRows: href strategy failed", e && e.message); }
+    if (out.length) { console.log("[TD] findSidebarRows: href strategy hit", out.length); return out; }
+    // 4) data-testid 含 thread/conversation
+    try {
+      const testEls = scope.querySelectorAll("[data-testid]");
+      const testRe = /(thread|conversation)/i;
+      for (const el of testEls) {
+        const tid = el.getAttribute("data-testid") || "";
+        if (testRe.test(tid)) push(el.closest("li,[data-app-action-sidebar-thread-row],div,section") || el.parentElement || el);
+      }
+    } catch (e) { console.log("[TD] findSidebarRows: testid strategy failed", e && e.message); }
+    if (out.length) console.log("[TD] findSidebarRows: testid strategy hit", out.length);
+    else console.log("[TD] findSidebarRows: no rows found via any strategy");
+    return out;
+  }
+  // 归档按钮查找：aria-label/title/textContent/SVG 多策略，大小写不敏感、部分匹配。
+  function findArchiveButton(row) {
+    if (!row) return null;
+    const kwRe = /(归档|archive)/i;
+    // 1) aria-label（大小写不敏感 + 部分匹配）
+    try {
+      const byAria = row.querySelector("button[aria-label],a[aria-label],[role='button'][aria-label]");
+      const list = byAria ? [byAria, ...row.querySelectorAll("button[aria-label],a[aria-label],[role='button'][aria-label]")] : row.querySelectorAll("button[aria-label],a[aria-label],[role='button'][aria-label]");
+      for (const el of list) {
+        const label = (el.getAttribute && el.getAttribute("aria-label")) || "";
+        if (kwRe.test(label)) { console.log("[TD] findArchiveButton: aria-label hit", label); return el; }
+      }
+    } catch (e) { console.log("[TD] findArchiveButton: aria strategy failed", e && e.message); }
+    // 2) title 属性
+    try {
+      for (const el of row.querySelectorAll("button[title],a[title],[role='button'][title]")) {
+        const title = (el.getAttribute && el.getAttribute("title")) || "";
+        if (kwRe.test(title)) { console.log("[TD] findArchiveButton: title hit", title); return el; }
+      }
+    } catch (e) { console.log("[TD] findArchiveButton: title strategy failed", e && e.message); }
+    // 3) textContent 匹配
+    try {
+      for (const el of row.querySelectorAll("button,a,[role='button']")) {
+        const text = String(el.textContent || "").trim();
+        if (text && kwRe.test(text)) { console.log("[TD] findArchiveButton: textContent hit", text); return el; }
+      }
+    } catch (e) { console.log("[TD] findArchiveButton: text strategy failed", e && e.message); }
+    // 4) SVG 图标启发：含 archive/pin 风格 path 的按钮
+    try {
+      const svgBtns = row.querySelectorAll("button:has(svg),a:has(svg),[role='button']:has(svg)");
+      for (const el of svgBtns) {
+        const svg = el.querySelector("svg");
+        if (!svg) continue;
+        const d = (svg.querySelector("path") && svg.querySelector("path").getAttribute("d")) || "";
+        // 归档盒常见：横向顶条 + 下方矩形
+        if (/m.*h.*v.*h.*z/i.test(d) && d.length > 30) {
+          console.log("[TD] findArchiveButton: svg heuristics hit");
+          return el;
+        }
+      }
+    } catch (e) { console.log("[TD] findArchiveButton: svg strategy failed", e && e.message); }
+    console.log("[TD] findArchiveButton: no archive button found");
+    return null;
+  }
+  // 操作容器查找：从归档按钮向上试多种深度，或直接定位行内操作组。
+  function findSidebarActionBox(row) {
+    const archive = findArchiveButton(row);
+    if (archive) {
+      // 试 parent.depth 1..4，找到含多个按钮的容器即视为 actionBox
+      let cur = archive.parentElement;
+      for (let depth = 1; cur && depth <= 4; depth++, cur = cur.parentElement) {
+        const btns = cur.querySelectorAll("button,[role='button']");
+        if (btns.length >= 2) {
+          console.log("[TD] findSidebarActionBox: via archive, depth", depth, "btns", btns.length);
+          return { actionBox: cur, anchor: archive.parentElement || archive };
+        }
+      }
+      // 退而求其次：归档按钮的直接父级
+      console.log("[TD] findSidebarActionBox: fallback to archive.parentElement");
+      return { actionBox: archive.parentElement, anchor: archive };
+    }
+    // 不经归档按钮：直接找行内按钮组
+    try {
+      const groups = row.querySelectorAll("div:has(> button),span:has(> button)");
+      for (const g of groups) {
+        if (g.querySelectorAll("button,[role='button']").length >= 2) {
+          console.log("[TD] findSidebarActionBox: direct group hit");
+          return { actionBox: g, anchor: null };
+        }
+      }
+    } catch (e) { console.log("[TD] findSidebarActionBox: direct group strategy failed", e && e.message); }
+    console.log("[TD] findSidebarActionBox: not found");
+    return null;
+  }
+  function mountSidebarDeleteButtons(root = document) {
+    const rows = findSidebarRows(root);
+    console.log("[TD] mountSidebarDeleteButtons: rows", rows.length);
+    let mounted = 0, skipped = 0, failed = 0;
+    for (const row of rows) {
+      if (row.querySelector("[data-td-sidebar-delete]")) { skipped++; continue; }
+      const found = findSidebarActionBox(row);
+      if (!found || !found.actionBox) { console.log("[TD] mountSidebarDeleteButtons: no actionBox for row", row); failed++; continue; }
+      const { actionBox, anchor } = found;
+      try {
+        actionBox.style.width = "76px";
+        actionBox.insertBefore(makeSidebarDeleteButton(row, actionBox), anchor || actionBox.firstChild);
+        mounted++;
+        console.log("[TD] mountSidebarDeleteButtons: mounted on row", row);
+      } catch (e) {
+        console.log("[TD] mountSidebarDeleteButtons: insert failed", e && e.message);
+        failed++;
+      }
+    }
+    console.log(\`[TD] mountSidebarDeleteButtons: done mounted=\${mounted} skipped=\${skipped} failed=\${failed}\`);
+  }
+  // —— 诊断：把侧边栏 DOM 结构通过 binding 回传主进程（无需 DevTools）——
+  function dumpSidebarInfo() {
+    if (typeof window.__voiceBridge !== "function") return;
+    const info = { sidebar: null, rows: [], archive: null, actionBox: null };
+    // 1) 侧边栏容器
+    const sidebarCandidates = document.querySelectorAll("[class*='sidebar'],[class*='thread-list'],[class*='conversation-list'],[class*='nav-list'],[class*='task-list']");
+    info.sidebar = sidebarCandidates.length;
+    // 2) 每行采样：取前 3 行看 HTML 结构
+    const allRows = document.querySelectorAll("a[href*='thread'],a[href*='conversation'],a[href*='/c/'],a[href*='/chat/'],[data-app-action-sidebar-thread-row],[class*='thread-row'],[class*='conversation-row'],[class*='session-row']");
+    if (allRows.length) {
+      for (let i = 0; i < Math.min(3, allRows.length); i++) {
+        const el = allRows[i];
+        info.rows.push({
+          tag: el.tagName,
+          id: el.id,
+          classes: (el.className || "").slice(0, 120),
+          attrs: [].map.call(el.attributes || [], function(a) { return a.name + '=\\"' + a.value.slice(0, 60) + '\\"'; }).join(" ").slice(0, 300),
+          inner: el.innerHTML.replace(/\\s+/g, " ").slice(0, 400),
+        });
+      }
+    }
+    // 3) 归档按钮
+    const archiveBtn = document.querySelector("button[aria-label*='归档'],button[aria-label*='Archive'],button[aria-label*='archive'],button[aria-label*='archiv'],button[title*='归档'],button[title*='Archive'],button[title*='archive']");
+    if (archiveBtn) {
+      info.archive = {
+        tag: archiveBtn.tagName,
+        id: archiveBtn.id,
+        ariaLabel: archiveBtn.getAttribute("aria-label") || "",
+        title: archiveBtn.title,
+        classes: (archiveBtn.className || "").slice(0, 120),
+        outer: archiveBtn.outerHTML.slice(0, 300),
+      };
+    }
+    // 4) 侧边栏内所有按钮
+    info.allButtons = [].map.call(document.querySelectorAll("[class*='sidebar'] button,[class*='thread-list'] button"), function(b) {
+      return { ariaLabel: b.getAttribute("aria-label") || "", title: b.title, classes: (b.className || "").slice(0, 60) };
+    });
+    try {
+      window.__voiceBridge(JSON.stringify({ kind: "debug-sidebar-dump", info: info }));
+    } catch {}
+  }
+  window.__tdDumpSidebarInfo = dumpSidebarInfo;
+  // 周期性重试：侧边栏可能是懒加载的，首次注入时 DOM 可能还没渲染出来
+  let retryCount = 0;
+  const MAX_RETRIES = 10;
+  function retryMountSidebar() {
+    if (retryCount >= MAX_RETRIES) return;
+    retryCount++;
+    setTimeout(function() {
+      const rows = findSidebarRows(document);
+      if (rows.length > 0) {
+        mountSidebarDeleteButtons(document);
+        dumpSidebarInfo();
+      } else {
+        console.log("[TD] retryMountSidebar: attempt " + retryCount + " still no rows, retrying...");
+        retryMountSidebar();
+      }
+    }, 1500);
+  }
+  setTimeout(retryMountSidebar, 2000);
+
   // —— binding 通道（window.__voiceBridge 由主进程 CDP addBinding 注入）——
   const pending = new Map();
   let seq = 0;
@@ -126,6 +543,7 @@ const INJECT_SCRIPT = `
 
   // —— 录音 ——
   let mediaRecorder = null;
+  let activeStream = null;
   let chunks = [];
   let curBtn = null;
   let stopTimer = null;
@@ -150,6 +568,7 @@ const INJECT_SCRIPT = `
   }
 
   async function startRecording(btn) {
+    if (disposed) return;
     if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
       toast("此环境不支持麦克风");
       setBtnState(btn, "error");
@@ -169,6 +588,7 @@ const INJECT_SCRIPT = `
       return;
     }
     curBtn = btn;
+    activeStream = stream;
     chunks = [];
     const mime = MediaRecorder.isTypeSupported("audio/webm")
       ? "audio/webm"
@@ -188,6 +608,8 @@ const INJECT_SCRIPT = `
     };
     mediaRecorder.onstop = () => {
       stream.getTracks().forEach((t) => t.stop());
+      activeStream = null;
+      if (disposed) return;
       const blob = new Blob(chunks, { type: mime || "audio/webm" });
       if (blob.size < 800) {
         toast("未录到声音");
@@ -197,6 +619,7 @@ const INJECT_SCRIPT = `
       setBtnState(btn, "transcribing");
       const reader = new FileReader();
       reader.onload = async () => {
+        if (disposed) return;
         const dataUrl = String(reader.result || "");
         const comma = dataUrl.indexOf(",");
         const b64 = comma >= 0 ? dataUrl.slice(comma + 1) : dataUrl;
@@ -212,6 +635,7 @@ const INJECT_SCRIPT = `
         setBtnState(btn, "");
       };
       reader.onerror = () => {
+        if (disposed) return;
         toast("音频读取失败");
         setBtnState(btn, "error");
       };
@@ -270,6 +694,7 @@ const INJECT_SCRIPT = `
   }
 
   function onBtnClick(btn) {
+    if (disposed) return;
     if (mediaRecorder && mediaRecorder.state === "recording") {
       stopRecording();
       return;
@@ -307,6 +732,7 @@ const INJECT_SCRIPT = `
 
   let firstMount = true;
   function tryMount() {
+    if (disposed) return;
     if (!firstMount && document.getElementById(BTN_ID)) return; // 已在，避免频繁重建丢焦点
     firstMount = false;
     const existing = document.getElementById(BTN_ID);
@@ -326,23 +752,66 @@ const INJECT_SCRIPT = `
   // —— MutationObserver：composer/页面重建后重挂 ——
   let mo = null;
   function startObserver() {
-    if (mo) return;
-    mo = new MutationObserver(() => {
+    if (disposed || mo) return;
+    mo = new MutationObserver((records) => {
+      if (disposed) return;
       if (!document.getElementById(BTN_ID)) { firstMount = true; tryMount(); }
+      for (const record of records) {
+        if (record.target && record.target.nodeType === 1) sanitizeVisibleThoughts(record.target);
+        for (const added of record.addedNodes || []) {
+          if (added.nodeType !== 1) continue;
+          sanitizeVisibleThoughts(added);
+          mountSidebarDeleteButtons(added);
+        }
+      }
     });
     window.__voiceInjectObserver = mo; // 供重新安装时 disconnect
     const root = document.body || document.documentElement;
     if (root) mo.observe(root, { childList: true, subtree: true });
     // 首次尝试
     tryMount();
+    mountSidebarDeleteButtons(root);
+    sanitizeVisibleThoughts(root);
   }
   function ensureStarted() {
+    if (disposed) return;
     if (document.readyState === "loading") {
       document.addEventListener("DOMContentLoaded", startObserver, { once: true });
     } else {
       startObserver();
     }
   }
+  // 由主进程在“关闭语音输入”时调用。必须在断开 CDP 前执行，
+  // 否则页面里的 observer 仍会在输入框重建时重新挂出麦克风按钮。
+  window.__voiceInjectDispose = () => {
+    if (disposed) return;
+    disposed = true;
+    if (stopTimer) {
+      clearTimeout(stopTimer);
+      stopTimer = null;
+    }
+    if (mediaRecorder && mediaRecorder.state !== "inactive") {
+      try { mediaRecorder.stop(); } catch {}
+    }
+    if (activeStream) {
+      try { activeStream.getTracks().forEach((track) => track.stop()); } catch {}
+      activeStream = null;
+    }
+    for (const entry of pending.values()) {
+      try { entry.reject(new Error("语音输入已关闭")); } catch {}
+    }
+    pending.clear();
+    if (mo) {
+      try { mo.disconnect(); } catch {}
+      mo = null;
+    }
+    if (window.__voiceInjectObserver) delete window.__voiceInjectObserver;
+    document.getElementById(BTN_ID)?.remove();
+    document.getElementById(STYLE_ID)?.remove();
+    document.querySelectorAll(".codex-voice-toast").forEach((el) => el.remove());
+    if (window.__voiceInjectHandle) delete window.__voiceInjectHandle;
+    if (window.__voiceInjectInstalled) delete window.__voiceInjectInstalled;
+  };
   ensureStarted();
 })();
 `;
diff --git a/electron/main.js b/electron/main.js
index 997b125..f3b7989 100644
--- a/electron/main.js
+++ b/electron/main.js
@@ -5,6 +5,8 @@ const { autoUpdater } = require("electron-updater");
 const path = require("path");
 const os = require("os");
 const fs = require("fs");
+const crypto = require("crypto");
+const { execFile } = require("child_process");
 const git = require("isomorphic-git");
 const gitHttp = require("isomorphic-git/http/node");
 
@@ -12,13 +14,16 @@ const codex = require("./lib/codex");
 const purge = require("./lib/purge");
 const secrets = require("./lib/secrets");
 const sessions = require("./lib/sessions");
+const codexDataDir = require("./lib/codex_data_dir");
 const providerSync = require("./lib/provider_sync");
 const router = require("./lib/router");
 const canvas = require("./lib/canvas");
+const canvasStore = require("./lib/canvas_store");
 const team = require("./lib/team");
 const promptAnalysis = require("./lib/prompt-analysis");
 const claudedesk = require("./lib/claudedesk");
 const voice = require("./lib/voice_cdp");
+const codexDesktop = require("./lib/codex_desktop");
 const tokenWatch = require("./lib/token_watch");
 const proxy = require("./lib/proxy");
 const memory = require("./lib/memory");
@@ -87,6 +92,15 @@ let tray = null;
 let isQuitting = false;
 let trayHinted = false; // Windows：首次最小化到托盘时弹一次气泡提示
 let lastPull = null; // { base, items } —— gh-restore 用上次 pull 的结果
+let voiceSessionDeleteBusy = false;
+let stateWriteOperation = "";
+const sessionDeleteClipboard = new Map();
+
+async function withStateWriteLock(label, fn) {
+  if (stateWriteOperation) throw new Error(`正在${stateWriteOperation}，请完成后再${label}`);
+  stateWriteOperation = label;
+  try { return await fn(); } finally { stateWriteOperation = ""; }
+}
 
 // —— 日志：主进程 → 前端 api.onLog ——
 function log(msg) {
@@ -95,6 +109,24 @@ function log(msg) {
   }
 }
 
+function deferStartupWork(label, delayMs, fn) {
+  setTimeout(() => {
+    const t0 = Date.now();
+    try {
+      const r = fn();
+      const done = (out) => {
+        const ms = Date.now() - t0;
+        if (ms > 300) log(`${label}完成：${ms}ms`);
+        return out;
+      };
+      if (r && typeof r.then === "function") r.then(done).catch((e) => log(`${label}失败：${e.message || e}`));
+      else done(r);
+    } catch (e) {
+      log(`${label}异常：${e.message || e}`);
+    }
+  }, delayMs);
+}
+
 // ---------------------------------------------------------------------------
 // 窗口
 // ---------------------------------------------------------------------------
@@ -149,14 +181,19 @@ function showWindow() {
 function rebuildTrayMenu() {
   if (!tray) return;
   const st = router.status();
-  const groupItems = st.groups.map((g) => ({
-    label: (g.id === st.activeId ? "● " : "○ ") + g.name,
-    click: () => {
-      router.setActive(g.id);
-      rebuildTrayMenu();
-      if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send("router-changed", router.status());
-    },
-  }));
+  const groupItems = st.groups.map((g) => {
+    const toolOnly = !g.isDefault && (g.codexImage || g.codexVideo || g.stt);
+    return {
+      label: (g.id === st.activeId ? "● " : "○ ") + g.name + (toolOnly ? "（插件专用）" : ""),
+      enabled: !toolOnly,
+      click: () => {
+        if (toolOnly) return;
+        router.setActive(g.id);
+        rebuildTrayMenu();
+        if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send("router-changed", router.status());
+      },
+    };
+  });
   const px = proxy.status();
   const pxLabel =
     px.mode === "global" ? "全局代理：运行中(整机 TUN)" : px.mode === "system" ? "系统代理：运行中" : "代理：未开启";
@@ -200,6 +237,8 @@ if (!app.requestSingleInstanceLock()) {
 }
 
 app.whenReady().then(async () => {
+  providerSync.setCodexDataDir(codexDataDir.get());
+  router.setCodexDataDir(codexDataDir.get());
   createWindow();
   setupTray();
   app.on("activate", () => showWindow());
@@ -209,13 +248,14 @@ app.whenReady().then(async () => {
     if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send("proxy-changed", st);
     rebuildTrayMenu();
   });
-  proxy.cleanupStale().catch(() => {});
+  deferStartupWork("启动清理代理残留", 15000, () => proxy.cleanupStale());
   // 会话记忆：后台监视 ~/.codex/sessions，会话静默后自动摘要入库 + 写 HANDOFF.md
   memory.start({
     log,
     notify: () => {
       if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send("memory-changed");
     },
+    startupScan: false,
   });
   // 启动时不再自动接管/启动本地路由：用户可能只想用其它功能。
   // 保存分组已直接写 Codex 直连配置；只有用户显式「启用本地路由」才 start() 路由进程。
@@ -225,34 +265,26 @@ app.whenReady().then(async () => {
   } catch (e) {
     log(`刷新托盘失败：${e.message || e}`);
   }
-  try {
+  deferStartupWork("启动迁移 skill", 60000, () => {
     const r = migrateLegacySkills();
     if (r.migrated.length) log(`启动迁移 skill: ${r.migrated.length} 个转为软链`);
     if (r.errors.length) log(`启动迁移 skill 错误: ${JSON.stringify(r.errors)}`);
-  } catch (e) {
-    log(`启动迁移 skill 异常: ${e.message || e}`);
-  }
-  try {
+  });
+  deferStartupWork("启动迁移 plugin", 75000, () => {
     const r = migrateLegacyPlugins();
     if (r.migrated.length) log(`启动迁移 plugin: ${r.migrated.length} 个转为软链`);
     if (r.errors.length) log(`启动迁移 plugin 错误: ${JSON.stringify(r.errors)}`);
-  } catch (e) {
-    log(`启动迁移 plugin 异常: ${e.message || e}`);
-  }
+  });
   // 启动自愈：把当前激活分组的全部文本模型先回填进 Codex 模型目录。
   // 目的——用户在 Codex 本体的模型选择器里切模型（不经本 App）时，若目标模型不在目录里，
   // Codex 会以未知模型启动、侧栏历史还原失败 = "切模型后会话记录消失"。先回填即根治，
   // 且既有安装无需重新保存分组即可自动修复。异步、失败不动目录（离线安全）。
-  try {
+  deferStartupWork("启动同步模型目录", 30000, async () => {
     const active = router.llmGroup(); // 当前激活且配齐 baseUrl+key+model 的中转分组（排除默认直连）
-    if (active) {
-      router.syncCatalogFromProvider(active)
-        .then((r) => { if (r && r.ok && (r.added || r.revealed)) log(`启动同步模型目录：新增 ${r.added} · 显示 ${r.revealed} · 共 ${r.total}`); })
-        .catch((e) => log(`启动同步模型目录失败：${e.message || e}`));
-    }
-  } catch (e) {
-    log(`启动同步模型目录异常：${e.message || e}`);
-  }
+    if (!active) return;
+    const r = await router.syncCatalogFromProvider(active);
+    if (r && r.ok && (r.added || r.revealed)) log(`启动同步模型目录：新增 ${r.added} · 显示 ${r.revealed} · 共 ${r.total}`);
+  });
 });
 
 // 统一退出：清理代理(杀 sing-box + 还原网络) → 停本地路由 → 销毁托盘 → 退出。
@@ -303,6 +335,274 @@ const UPDATE_REPO = "codex-market-app";
 // up 域名给 API/直连，update 域名给用户浏览下载页（管理登录会话在此）。
 const GITEA_RELEASES_API = `https://update.tokendun.cc/api/v1/repos/${UPDATE_OWNER}/${UPDATE_REPO}/releases/latest`;
 const GITEA_RELEASES_PAGE = `https://update.tokendun.cc/${UPDATE_OWNER}/${UPDATE_REPO}/releases`;
+const CODEX_INSTALLER_RELEASE_TAG = "codex-installers";
+const CODEX_WINDOWS_MSIX_NAME = "Codex-Windows-x64.msix";
+const CODEX_MAC_DMG_NAME = "ChatGPT.dmg";
+const CODEX_WINDOWS_MSIX_URL =
+  `https://update.tokendun.cc/${UPDATE_OWNER}/${UPDATE_REPO}/releases/download/${CODEX_INSTALLER_RELEASE_TAG}/${CODEX_WINDOWS_MSIX_NAME}`;
+const CODEX_WINDOWS_MSIX_SHA256_URL = `${CODEX_WINDOWS_MSIX_URL}.sha256`;
+const CODEX_MAC_DMG_URL =
+  `https://update.tokendun.cc/${UPDATE_OWNER}/${UPDATE_REPO}/releases/download/${CODEX_INSTALLER_RELEASE_TAG}/${CODEX_MAC_DMG_NAME}`;
+const CODEX_MAC_DMG_SHA256_URL = `${CODEX_MAC_DMG_URL}.sha256`;
+const codexInstallerDownloadControllers = new Map();
+
+function codexInstallerTarget(platform) {
+  if (platform === "windows") {
+    return {
+      platform,
+      fileName: CODEX_WINDOWS_MSIX_NAME,
+      url: CODEX_WINDOWS_MSIX_URL,
+      sha256Url: CODEX_WINDOWS_MSIX_SHA256_URL,
+      label: "Codex Windows 版",
+    };
+  }
+  if (platform === "mac") {
+    return {
+      platform,
+      fileName: CODEX_MAC_DMG_NAME,
+      url: CODEX_MAC_DMG_URL,
+      sha256Url: CODEX_MAC_DMG_SHA256_URL,
+      label: "Codex Mac 版",
+    };
+  }
+  throw new Error("未知安装平台");
+}
+
+function sendCodexInstallerProgress(data) {
+  if (mainWindow && !mainWindow.isDestroyed()) {
+    mainWindow.webContents.send("codex-installer-progress", data);
+  }
+}
+
+function codexInstallerCachePath(fileName) {
+  return path.join(app.getPath("userData"), "installers", fileName);
+}
+
+function isAbortError(e) {
+  return (e && e.name === "AbortError") || /aborted|abort/i.test(String(e && e.message ? e.message : e));
+}
+
+function assertCodexInstallerNotCanceled(signal) {
+  if (signal && signal.aborted) {
+    const err = new Error("已取消下载");
+    err.name = "AbortError";
+    throw err;
+  }
+}
+
+function parseSha256(text) {
+  const m = String(text || "").match(/\b[a-fA-F0-9]{64}\b/);
+  return m ? m[0].toLowerCase() : "";
+}
+
+function hashFile(file) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash("sha256");
+    fs.createReadStream(file)
+      .on("data", (chunk) => h.update(chunk))
+      .on("error", reject)
+      .on("end", () => resolve(h.digest("hex")));
+  });
+}
+
+async function fetchInstallerSha256(sha256Url, signal) {
+  const res = await fetch(sha256Url, {
+    headers: { "User-Agent": "codex-market", "Cache-Control": "no-cache" },
+    signal,
+  });
+  if (!res.ok) throw new Error(`安装包校验文件未发布或不可访问：HTTP ${res.status}`);
+  const sha256 = parseSha256(await res.text());
+  if (!sha256) throw new Error("安装包校验文件格式不正确");
+  return sha256;
+}
+
+async function downloadCodexInstaller({ fileName, url, expectedSha256, platform, signal }) {
+  const installerPath = codexInstallerCachePath(fileName);
+  const tmpPath = `${installerPath}.download`;
+  fs.mkdirSync(path.dirname(installerPath), { recursive: true });
+  assertCodexInstallerNotCanceled(signal);
+
+  if (fs.existsSync(installerPath)) {
+    sendCodexInstallerProgress({ platform, phase: "verify", message: "校验本地缓存…", percent: 60 });
+    assertCodexInstallerNotCanceled(signal);
+    const cachedSha256 = await hashFile(installerPath);
+    assertCodexInstallerNotCanceled(signal);
+    if (cachedSha256 === expectedSha256) {
+      sendCodexInstallerProgress({ platform, phase: "cached", message: "已使用本地缓存", percent: 62 });
+      return installerPath;
+    }
+    try { fs.rmSync(installerPath, { force: true }); } catch {}
+  }
+
+  sendCodexInstallerProgress({ platform, phase: "download", message: "开始下载安装包…", downloaded: 0, total: 0, percent: 0 });
+  const res = await fetch(url, { headers: { "User-Agent": "codex-market" }, signal });
+  if (!res.ok) throw new Error(`安装包下载失败：HTTP ${res.status}`);
+  if (!res.body || typeof res.body.getReader !== "function") throw new Error("当前运行环境不支持流式下载");
+
+  const total = Number(res.headers.get("content-length") || 0);
+  const reader = res.body.getReader();
+  const out = fs.createWriteStream(tmpPath);
+  const streamError = new Promise((_, reject) => out.once("error", reject));
+  let downloaded = 0;
+  let lastEmit = 0;
+  try {
+    for (;;) {
+      assertCodexInstallerNotCanceled(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = Buffer.from(value);
+      downloaded += chunk.length;
+      if (!out.write(chunk)) await Promise.race([streamError, new Promise((resolve) => out.once("drain", resolve))]);
+      const now = Date.now();
+      if (now - lastEmit > 300) {
+        lastEmit = now;
+        sendCodexInstallerProgress({
+          platform,
+          phase: "download",
+          downloaded,
+          total,
+          percent: total ? Math.round((downloaded / total) * 100) : 0,
+        });
+      }
+    }
+    await Promise.race([streamError, new Promise((resolve) => out.end(resolve))]);
+  } catch (e) {
+    try { out.destroy(); } catch {}
+    try { fs.rmSync(tmpPath, { force: true }); } catch {}
+    throw e;
+  }
+
+  sendCodexInstallerProgress({ platform, phase: "verify", message: "校验安装包…", percent: 60 });
+  assertCodexInstallerNotCanceled(signal);
+  const sha256 = await hashFile(tmpPath);
+  assertCodexInstallerNotCanceled(signal);
+  if (sha256 !== expectedSha256) {
+    try { fs.rmSync(tmpPath, { force: true }); } catch {}
+    throw new Error("安装包 SHA256 校验失败，已停止安装");
+  }
+  fs.renameSync(tmpPath, installerPath);
+  return installerPath;
+}
+
+async function downloadCodexInstallerForPlatform(platform) {
+  const target = codexInstallerTarget(platform);
+  if (codexInstallerDownloadControllers.has(platform)) throw new Error(`${target.label}安装包正在下载中`);
+  const controller = new AbortController();
+  codexInstallerDownloadControllers.set(platform, controller);
+  try {
+    sendCodexInstallerProgress({ platform, phase: "checking", message: "读取安装包校验信息…", percent: 2 });
+    const expectedSha256 = await fetchInstallerSha256(target.sha256Url, controller.signal);
+    const installerPath = await downloadCodexInstaller({
+      fileName: target.fileName,
+      url: target.url,
+      expectedSha256,
+      platform,
+      signal: controller.signal,
+    });
+    sendCodexInstallerProgress({ platform, phase: "downloaded", message: `${target.label}安装包已下载并校验完成`, percent: 100 });
+    return { ok: true, platform, path: installerPath };
+  } catch (e) {
+    if (isAbortError(e)) {
+      try { fs.rmSync(`${codexInstallerCachePath(target.fileName)}.download`, { force: true }); } catch {}
+      sendCodexInstallerProgress({ platform, phase: "canceled", message: `${target.label}安装包下载已取消`, percent: 0 });
+      throw new Error("已取消下载");
+    }
+    throw e;
+  } finally {
+    if (codexInstallerDownloadControllers.get(platform) === controller) {
+      codexInstallerDownloadControllers.delete(platform);
+    }
+  }
+}
+
+function cancelCodexInstallerDownload(platform) {
+  const target = codexInstallerTarget(platform);
+  const controller = codexInstallerDownloadControllers.get(platform);
+  if (!controller) return { ok: true, canceled: false };
+  controller.abort();
+  sendCodexInstallerProgress({ platform, phase: "canceling", message: `正在取消${target.label}安装包下载…`, percent: 0 });
+  return { ok: true, canceled: true };
+}
+
+function execFileAsync(file, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(file, args, opts, (err, stdout, stderr) => {
+      if (!err) return resolve({ stdout, stderr });
+      const msg = String(stderr || stdout || err.message || err).trim();
+      reject(new Error(msg || `${path.basename(file)} 执行失败`));
+    });
+  });
+}
+
+function runCodexWindowsMsix(installerPath) {
+  const systemRoot = process.env.SystemRoot || "C:\\Windows";
+  const bundledPowerShell = path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  const powerShell = fs.existsSync(bundledPowerShell) ? bundledPowerShell : "powershell.exe";
+  const args = [
+    "-NoProfile",
+    "-ExecutionPolicy", "Bypass",
+    "-Command",
+    "& { param([string]$pkg) Add-AppxPackage -Path $pkg }",
+    installerPath,
+  ];
+  return execFileAsync(powerShell, args, { windowsHide: false, timeout: 15 * 60 * 1000 });
+}
+
+async function installCodexWindows() {
+  if (process.platform !== "win32") {
+    throw new Error("Windows 一键安装只能在 Windows 上运行；可先在软件内下载 MSIX，再发给 Windows 用户安装。");
+  }
+  const { path: installerPath } = await downloadCodexInstallerForPlatform("windows");
+  sendCodexInstallerProgress({ platform: "windows", phase: "install", message: "正在调用 PowerShell 安装…", percent: 85 });
+  await runCodexWindowsMsix(installerPath);
+  sendCodexInstallerProgress({ platform: "windows", phase: "done", message: "Codex Windows 版安装完成", percent: 100 });
+  return { ok: true, path: installerPath };
+}
+
+function findMountedAppBundle(mountDir) {
+  const items = fs.readdirSync(mountDir, { withFileTypes: true });
+  const appItem = items.find((ent) => ent.isDirectory() && ent.name.endsWith(".app"));
+  if (!appItem) throw new Error("DMG 中没有找到 .app 应用");
+  return path.join(mountDir, appItem.name);
+}
+
+async function runCodexMacDmg(dmgPath) {
+  const mountDir = path.join(app.getPath("temp"), `codex-installer-${Date.now()}`);
+  fs.rmSync(mountDir, { recursive: true, force: true });
+  fs.mkdirSync(mountDir, { recursive: true });
+  let mounted = false;
+  try {
+    sendCodexInstallerProgress({ platform: "mac", phase: "install", message: "正在挂载 DMG…", percent: 68 });
+    await execFileAsync("/usr/bin/hdiutil", ["attach", dmgPath, "-nobrowse", "-readonly", "-mountpoint", mountDir], { timeout: 5 * 60 * 1000 });
+    mounted = true;
+
+    const appPath = findMountedAppBundle(mountDir);
+    const targetPath = path.join("/Applications", path.basename(appPath));
+    sendCodexInstallerProgress({ platform: "mac", phase: "install", message: `正在复制到 /Applications/${path.basename(appPath)}…`, percent: 82 });
+    fs.rmSync(targetPath, { recursive: true, force: true });
+    await execFileAsync("/usr/bin/ditto", [appPath, targetPath], { timeout: 15 * 60 * 1000 });
+
+    sendCodexInstallerProgress({ platform: "mac", phase: "install", message: "正在卸载 DMG…", percent: 94 });
+    await execFileAsync("/usr/bin/hdiutil", ["detach", mountDir], { timeout: 2 * 60 * 1000 });
+    mounted = false;
+    return { appPath: targetPath };
+  } finally {
+    if (mounted) {
+      try { await execFileAsync("/usr/bin/hdiutil", ["detach", mountDir], { timeout: 2 * 60 * 1000 }); } catch {}
+    }
+    try { fs.rmSync(mountDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+async function installCodexMac() {
+  if (process.platform !== "darwin") {
+    throw new Error("Mac 一键安装只能在 macOS 上运行；可先在软件内下载 DMG，再发给 Mac 用户安装。");
+  }
+  const { path: installerPath } = await downloadCodexInstallerForPlatform("mac");
+  const result = await runCodexMacDmg(installerPath);
+  sendCodexInstallerProgress({ platform: "mac", phase: "done", message: "Codex Mac 版安装完成", percent: 100 });
+  return { ok: true, path: installerPath, appPath: result.appPath };
+}
 
 // 比较版本号：a>b 返回 1，a<b 返回 -1，相等 0
 function cmpVersion(a, b) {
@@ -874,19 +1174,23 @@ function safeSkillDir(name) {
 }
 
 // 列出已安装技能：扫描 ~/.codex/skills/<name>/
-function skillInstalledList() {
+function skillInstalledList(opts = {}) {
   const base = path.join(codex.CODEX_HOME, "skills");
   if (!fs.existsSync(base)) return [];
+  const includeSize = !!opts.includeSize;
+  const includeMeta = opts.includeMeta !== false;
   // 建索引：磁盘目录名 -> catalog 条目（中文名/中文简介）。读不到 catalog 就空索引，回退 SKILL.md。
   let byDir = null;
-  try {
-    const list = (skillCatalog() || []);
-    const items = Array.isArray(list) ? list : (list.skills || list.items || list.data || []);
-    byDir = new Map();
-    for (const s of items) {
-      if (s && s.name) byDir.set(safeSkillDir(s.name), s);
-    }
-  } catch {}
+  if (includeMeta) {
+    try {
+      const list = (skillCatalog() || []);
+      const items = Array.isArray(list) ? list : (list.skills || list.items || list.data || []);
+      byDir = new Map();
+      for (const s of items) {
+        if (s && s.name) byDir.set(safeSkillDir(s.name), s);
+      }
+    } catch {}
+  }
   const out = [];
   for (const ent of fs.readdirSync(base, { withFileTypes: true })) {
     const isDir = ent.isDirectory();
@@ -895,7 +1199,7 @@ function skillInstalledList() {
     const dir = path.join(base, ent.name);
     let mtime = 0;
     try { mtime = fs.statSync(dir).mtimeMs; } catch {}
-    const meta = readSkillMeta(dir, ent.name);
+    const meta = includeMeta ? readSkillMeta(dir, ent.name) : { name: ent.name, description: "" };
     // 优先用 catalog 的中文名/中文简介覆盖显示（SKILL.md 的 name 多为英文 slug，中文展示名在 catalog）
     const info = byDir && byDir.get(ent.name);
     out.push({
@@ -903,7 +1207,7 @@ function skillInstalledList() {
       name: (info && info.name) || meta.name,
       subtitle: (info && info.subtitle) || "",
       description: (info && (info.brief || info.subtitle)) || meta.description,
-      size: dirSize(dir),
+      size: includeSize ? dirSize(dir) : 0,
       mtime,
       symlink: isLink,
     });
@@ -921,9 +1225,11 @@ function builtinPluginInfo(name) {
 }
 
 // 列出已安装插件：扫描 ~/.codex/plugins/cache/<source>/<name>/
-function pluginInstalledList() {
+function pluginInstalledList(opts = {}) {
   const base = path.join(codex.CODEX_HOME, "plugins", "cache");
   if (!fs.existsSync(base)) return [];
+  const includeSize = !!opts.includeSize;
+  const includeMeta = opts.includeMeta !== false;
   const out = [];
   for (const src of fs.readdirSync(base, { withFileTypes: true })) {
     const isSrcDir = src.isDirectory();
@@ -938,14 +1244,14 @@ function pluginInstalledList() {
       let mtime = 0;
       try { mtime = fs.statSync(dir).mtimeMs; } catch {}
       // 中文标题/中文介绍优先取内置 plugins.json；磁盘 plugin.json 作兜底
-      const info = builtinPluginInfo(ent.name);
+      const info = includeMeta ? builtinPluginInfo(ent.name) : null;
       out.push({
         source: src.name,
         name: ent.name,
         displayName: (info && info.displayName) || ent.name, // 中文名，匹配不到回退英文 slug
-        description: (info && info.description) || readPluginDescription(dir),
+        description: includeMeta ? ((info && info.description) || readPluginDescription(dir)) : "",
         rel: `plugins/cache/${src.name}/${ent.name}`,
-        size: dirSize(dir),
+        size: includeSize ? dirSize(dir) : 0,
         mtime,
         symlink: isLink,
         protected: src.name.startsWith("openai-") && !isLink,
@@ -1087,14 +1393,29 @@ function migrateLegacyPlugins() {
 // ---------------------------------------------------------------------------
 ipcMain.handle("skill-catalog", async () => skillCatalog());
 ipcMain.handle("skill-install", async (_e, { skill }) => skillInstall(skill));
-ipcMain.handle("skill-installed", async () => skillInstalledList());
+ipcMain.handle("skill-installed", async (_e, opts = {}) => skillInstalledList(opts || {}));
 ipcMain.handle("skill-uninstall", async (_e, { dir }) => skillUninstall(dir));
 ipcMain.handle("skill-migrate", async () => migrateLegacySkills());
 ipcMain.handle("plugin-catalog", async () => pluginCatalog());
 ipcMain.handle("plugin-install", async (_e, { plugin }) => pluginInstall(plugin));
-ipcMain.handle("plugin-installed", async () => pluginInstalledList());
+ipcMain.handle("plugin-installed", async (_e, opts = {}) => pluginInstalledList(opts || {}));
 ipcMain.handle("plugin-uninstall", async (_e, { rel }) => pluginUninstall(rel));
 ipcMain.handle("plugin-migrate", async () => migrateLegacyPlugins());
+ipcMain.handle("codex-installer-info", async () => ({
+  platform: process.platform,
+  isWindows: process.platform === "win32",
+  isMac: process.platform === "darwin",
+  windowsUrl: CODEX_WINDOWS_MSIX_URL,
+  windowsSha256Url: CODEX_WINDOWS_MSIX_SHA256_URL,
+  macUrl: CODEX_MAC_DMG_URL,
+  macSha256Url: CODEX_MAC_DMG_SHA256_URL,
+  windowsCachePath: codexInstallerCachePath(CODEX_WINDOWS_MSIX_NAME),
+  macCachePath: codexInstallerCachePath(CODEX_MAC_DMG_NAME),
+}));
+ipcMain.handle("codex-download-installer", async (_e, { platform }) => downloadCodexInstallerForPlatform(platform));
+ipcMain.handle("codex-cancel-installer-download", async (_e, { platform }) => cancelCodexInstallerDownload(platform));
+ipcMain.handle("codex-install-windows", async () => installCodexWindows());
+ipcMain.handle("codex-install-mac", async () => installCodexMac());
 
 ipcMain.handle("scan-local", async () => {
   return codex.scanBase(codex.CODEX_HOME);
@@ -1201,6 +1522,30 @@ ipcMain.handle("set-secret", async (_e, { name, value }) => {
 });
 
 // —— 会话记录：浏览 / 读取 / 导出 / 备份 / 导入 ——
+ipcMain.handle("sessions-data-dir-info", async () => codexDataDir.info());
+ipcMain.handle("sessions-data-dir-select", async () => {
+  const current = codexDataDir.info();
+  const picked = await dialog.showOpenDialog(mainWindow, {
+    title: "选择 Codex 会话数据目录",
+    defaultPath: current.path,
+    properties: ["openDirectory"],
+  });
+  if (picked.canceled || !picked.filePaths.length) return { canceled: true, ...current };
+  const next = codexDataDir.set(picked.filePaths[0]);
+  providerSync.setCodexDataDir(next.path);
+  router.setCodexDataDir(next.path);
+  memory.restartWatching();
+  log(`会话数据目录已切换：${next.path}`);
+  return next;
+});
+ipcMain.handle("sessions-data-dir-reset", async () => {
+  const next = codexDataDir.reset();
+  providerSync.setCodexDataDir(next.path);
+  router.setCodexDataDir(next.path);
+  memory.restartWatching();
+  log(`会话数据目录已恢复默认：${next.path}`);
+  return next;
+});
 ipcMain.handle("sessions-list", async (_e, opts = {}) => {
   return sessions.listConversations(opts || {});
 });
@@ -1209,6 +1554,20 @@ ipcMain.handle("session-read", async (_e, { path: filePath }) => {
   return sessions.readConversation(filePath);
 });
 
+ipcMain.handle("session-delete-permanently", async (_e, { path: filePath } = {}) => {
+  return withStateWriteLock("永久删除会话", async () => {
+    if (providerSync.codexRunning()) throw new Error("请先完全退出 Codex，再永久删除会话");
+    const result = await sessions.deleteConversation(filePath);
+    try {
+      await memory.deleteSession(result.id, result.cwd);
+      return { ok: true, ...result };
+    } catch (e) {
+      log("会话主体已删除，但工具箱记忆清理失败：" + (e.message || e));
+      return { ok: true, cleanupWarning: String(e.message || e), ...result };
+    }
+  });
+});
+
 ipcMain.handle("session-export", async (_e, { item }) => {
   const conv = sessions.readConversation(item.path);
   const md = sessions.toMarkdown(item, conv);
@@ -1239,7 +1598,15 @@ ipcMain.handle("sessions-import", async () => {
     title: "选择要导入的备份目录（含 sessions 的文件夹）",
   });
   if (r.canceled || !r.filePaths.length) return { canceled: true };
-  return sessions.importSessions(r.filePaths[0], log);
+  return withStateWriteLock("导入并恢复会话", async () => {
+    if (providerSync.codexRunning()) throw new Error("请先完全退出 Codex，再导入并恢复会话");
+    const imported = sessions.importSessions(r.filePaths[0], log);
+    const onProgress = (p) => {
+      if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send("provider-sync-progress", p);
+    };
+    const synced = await providerSync.syncProviderToCurrent(log, onProgress);
+    return { ...imported, ...synced, restored: true };
+  });
 });
 
 // —— 会话记忆：状态 / 检索 / 开关 / 手动摘要 ——
@@ -1275,11 +1642,12 @@ ipcMain.handle("provider-sync", async () => {
   const onProgress = (p) => {
     if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send("provider-sync-progress", p);
   };
-  return providerSync.syncProviderToCurrent(log, onProgress);
+  return withStateWriteLock("同步会话账号", () => providerSync.syncProviderToCurrent(log, onProgress));
 });
 
 // —— 本地路由 ——
 ipcMain.handle("router-status", async () => router.status());
+ipcMain.handle("router-default-config", async () => router.defaultConfigInfo());
 ipcMain.handle("router-upsert-group", async (_e, { group }) => {
   const s = router.upsertGroup(group);
   rebuildTrayMenu();
@@ -1309,9 +1677,14 @@ ipcMain.handle("router-start", async () => {
   return router.status();
 });
 ipcMain.handle("router-stop", async () => {
-  router.stop();
+  const r = router.stopAndRestoreDirect();
   rebuildTrayMenu();
-  return router.status();
+  return { ...r, status: router.status() };
+});
+ipcMain.handle("router-disable-codex", async () => {
+  const r = router.disableCodex();
+  rebuildTrayMenu();
+  return { ...r, status: router.status() };
 });
 ipcMain.handle("router-apply-codex", async () => {
   const r = router.applyToCodex();
@@ -1374,6 +1747,34 @@ ipcMain.handle("canvas-run", (e, { kind, params }) =>
 );
 ipcMain.handle("canvas-groups", () => canvas.groups());
 ipcMain.handle("canvas-models", (_e, { groupId }) => canvas.listModels(groupId));
+ipcMain.handle("canvas-workspaces", () => ({ ok: true, workspaces: canvasStore.list() }));
+ipcMain.handle("canvas-workspace-create", (_e, { name } = {}) => {
+  try { return { ok: true, workspace: canvasStore.create(name) }; }
+  catch (err) { return { ok: false, error: String((err && err.message) || err) }; }
+});
+ipcMain.handle("canvas-workspace-load", (_e, { id } = {}) => {
+  try { return { ok: true, workspace: canvasStore.load(id) }; }
+  catch (err) { return { ok: false, error: String((err && err.message) || err) }; }
+});
+ipcMain.handle("canvas-workspace-rename", (_e, { id, name } = {}) => {
+  try { return { ok: true, workspace: canvasStore.rename(id, name) }; }
+  catch (err) { return { ok: false, error: String((err && err.message) || err) }; }
+});
+ipcMain.handle("canvas-workspace-save", (_e, { workspace } = {}) => {
+  try { return { ok: true, workspace: canvasStore.save(workspace) }; }
+  catch (err) { return { ok: false, error: String((err && err.message) || err) }; }
+});
+ipcMain.on("canvas-workspace-save-now", (_e, workspace) => {
+  try { canvasStore.save(workspace); } catch {}
+});
+ipcMain.handle("canvas-media-cache", async (_e, payload = {}) => {
+  try { return { ok: true, ...(await canvasStore.cacheMedia(payload)) }; }
+  catch (err) { return { ok: false, error: String((err && err.message) || err) }; }
+});
+ipcMain.handle("canvas-media-read", async (_e, payload = {}) => {
+  try { return { ok: true, ...(await canvasStore.readMedia(payload)) }; }
+  catch (err) { return { ok: false, error: String((err && err.message) || err) }; }
+});
 
 // —— 多 Agent 员工团队生成（需求 → 团队 → 打包 zip）——
 ipcMain.handle("team-generate", async (_e, params) => {
@@ -1442,8 +1843,87 @@ ipcMain.handle("voice-connect", (e, opts) =>
   }, opts || {})
 );
 ipcMain.handle("voice-disconnect", () => voice.disconnect());
+ipcMain.handle("voice-restart-codex", async () => {
+  try {
+    await voice.disconnect();
+  } catch (e) {
+    log("重启 Codex：断开注入失败：" + (e && e.message ? e.message : e));
+  }
+  try {
+    const stopped = await codexDesktop.killCodex();
+    if (!stopped || !stopped.exited) {
+      return { ok: false, error: "Codex 未完全退出，已停止重启以保护运行中会话" };
+    }
+  } catch (e) {
+    return { ok: false, error: "退出 Codex 失败：" + (e && e.message ? e.message : e) };
+  }
+  try {
+    const restarted = await voice.connect(null, {});
+    return { ok: true, phase: restarted.phase, lastError: restarted.lastError };
+  } catch (e) {
+    return { ok: false, error: "重新启动 Codex 失败：" + (e && e.message ? e.message : e) };
+  }
+});
 ipcMain.handle("voice-stt-info", () => voice.sttInfo());
 ipcMain.handle("voice-probe-stt", async () => voice.probeStt());
+voice.onSessionDelete(async (request) => {
+  const payload = typeof request === "string" ? { kind: "delete-session", threadId: request } : (request || {});
+  const requestId = String(payload.requestId || "");
+  if (payload.kind === "delete-session-clipboard-prepare") {
+    if (requestId) {
+      sessionDeleteClipboard.set(requestId, { text: clipboard.readText(), expires: Date.now() + 5000 });
+      setTimeout(() => sessionDeleteClipboard.delete(requestId), 6000);
+    }
+    return;
+  }
+  let threadId = String(payload.threadId || "");
+  if (payload.kind === "delete-session-clipboard-read") {
+    const saved = sessionDeleteClipboard.get(requestId);
+    sessionDeleteClipboard.delete(requestId);
+    const copied = clipboard.readText();
+    if (saved && saved.expires > Date.now()) {
+      try { clipboard.writeText(saved.text); } catch {}
+    }
+    const hit = copied.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i);
+    if (!hit) throw new Error("未能从 Codex 原生菜单读取会话 ID，已停止删除");
+    threadId = hit[0];
+  }
+  if (voiceSessionDeleteBusy) return;
+  voiceSessionDeleteBusy = true;
+  const item = sessions.findConversationById(threadId);
+  if (!item) { voiceSessionDeleteBusy = false; throw new Error("未找到对应的本地会话，已停止删除"); }
+  try {
+  await withStateWriteLock("永久删除会话", async () => {
+    const answer = await dialog.showMessageBox(mainWindow, {
+    type: "warning",
+    title: "彻底删除本地会话",
+    message: "永久删除“" + (item.title || "未命名会话") + "”？",
+    detail: "将退出 Codex，然后删除会话正文、归档副本、state SQLite 线程索引、标题索引和工具箱会话记忆。此操作不可恢复。",
+    buttons: ["取消", "彻底删除"],
+    defaultId: 0,
+    cancelId: 0,
+  });
+    if (answer.response !== 1) return;
+  voice.disconnect();
+  try {
+    const stopped = await codexDesktop.killCodex();
+    if (!stopped || !stopped.exited) throw new Error("Codex 未完全退出，已停止删除以保护 SQLite");
+    const result = await sessions.deleteConversation(item.path);
+    try { await memory.deleteSession(result.id, result.cwd); } catch (e) { log("会话主体已删除，但工具箱记忆清理失败：" + (e.message || e)); }
+    log("已彻底删除会话 " + result.id + "：正文 " + result.filesRemoved + "，SQLite 命中 " + result.stateRowsRemoved + " 个");
+  } finally {
+    try {
+      const restarted = await voice.connect(null, {});
+      if (!restarted || restarted.phase !== "connected") log("删除后重新启动 Codex 未连接：" + ((restarted && restarted.lastError) || "未知原因"));
+    } catch (e) {
+      log("删除后重新启动 Codex 失败：" + (e.message || e));
+    }
+  }
+  });
+  } finally {
+    voiceSessionDeleteBusy = false;
+  }
+});
 
 // —— Token 用量监控（注入 Codex 页面，复用 CDP 连接）——
 ipcMain.handle("token-status", async () => tokenWatch.tokenStatus());
diff --git a/electron/preload.js b/electron/preload.js
index e1aec52..ada1a5d 100644
--- a/electron/preload.js
+++ b/electron/preload.js
@@ -12,15 +12,26 @@ contextBridge.exposeInMainWorld("api", {
   // —— 技能商店（cocoloop 镜像）——
   skillCatalog: () => ipcRenderer.invoke("skill-catalog"),
   skillInstall: (skill) => ipcRenderer.invoke("skill-install", { skill }),
-  skillInstalled: () => ipcRenderer.invoke("skill-installed"),
+  skillInstalled: (opts) => ipcRenderer.invoke("skill-installed", opts || {}),
   skillUninstall: (dir) => ipcRenderer.invoke("skill-uninstall", { dir }),
   skillMigrate: () => ipcRenderer.invoke("skill-migrate"),
   // —— 插件市场（tokendun 官方插件，自建 gitea）——
   pluginCatalog: () => ipcRenderer.invoke("plugin-catalog"),
   pluginInstall: (plugin) => ipcRenderer.invoke("plugin-install", { plugin }),
-  pluginInstalled: () => ipcRenderer.invoke("plugin-installed"),
+  pluginInstalled: (opts) => ipcRenderer.invoke("plugin-installed", opts || {}),
   pluginUninstall: (rel) => ipcRenderer.invoke("plugin-uninstall", { rel }),
   pluginMigrate: () => ipcRenderer.invoke("plugin-migrate"),
+  // —— Codex 安装器 ——
+  codexInstallerInfo: () => ipcRenderer.invoke("codex-installer-info"),
+  codexDownloadInstaller: (platform) => ipcRenderer.invoke("codex-download-installer", { platform }),
+  codexCancelInstallerDownload: (platform) => ipcRenderer.invoke("codex-cancel-installer-download", { platform }),
+  codexInstallWindows: () => ipcRenderer.invoke("codex-install-windows"),
+  codexInstallMac: () => ipcRenderer.invoke("codex-install-mac"),
+  onCodexInstallerProgress: (cb) => {
+    const handler = (_e, p) => cb(p);
+    ipcRenderer.on("codex-installer-progress", handler);
+    return () => ipcRenderer.removeListener("codex-installer-progress", handler);
+  },
   // —— 热更新 ——
   hotCheck: () => ipcRenderer.invoke("hot-check"),
   hotApply: () => ipcRenderer.invoke("hot-apply"),
@@ -39,7 +50,11 @@ contextBridge.exposeInMainWorld("api", {
   quitApp: () => ipcRenderer.invoke("app-quit"),
   sessionsList: (opts) =>
     ipcRenderer.invoke("sessions-list", typeof opts === "object" && opts !== null ? opts : { includeSubagent: !!opts }),
+  sessionsDataDirInfo: () => ipcRenderer.invoke("sessions-data-dir-info"),
+  sessionsDataDirSelect: () => ipcRenderer.invoke("sessions-data-dir-select"),
+  sessionsDataDirReset: () => ipcRenderer.invoke("sessions-data-dir-reset"),
   sessionRead: (path) => ipcRenderer.invoke("session-read", { path }),
+  sessionDeletePermanently: (path) => ipcRenderer.invoke("session-delete-permanently", { path }),
   sessionExport: (item) => ipcRenderer.invoke("session-export", { item }),
   sessionsBackup: () => ipcRenderer.invoke("sessions-backup"),
   sessionsImport: () => ipcRenderer.invoke("sessions-import"),
@@ -64,12 +79,14 @@ contextBridge.exposeInMainWorld("api", {
     return () => ipcRenderer.removeListener("provider-sync-progress", handler);
   },
   routerStatus: () => ipcRenderer.invoke("router-status"),
+  routerDefaultConfig: () => ipcRenderer.invoke("router-default-config"),
   routerUpsertGroup: (group) => ipcRenderer.invoke("router-upsert-group", { group }),
   routerDeleteGroup: (id) => ipcRenderer.invoke("router-delete-group", { id }),
   routerSetActive: (id) => ipcRenderer.invoke("router-set-active", { id }),
   routerSetPort: (port) => ipcRenderer.invoke("router-set-port", { port }),
   routerStart: () => ipcRenderer.invoke("router-start"),
   routerStop: () => ipcRenderer.invoke("router-stop"),
+  routerDisableCodex: () => ipcRenderer.invoke("router-disable-codex"),
   routerApplyCodex: () => ipcRenderer.invoke("router-apply-codex"),
   routerApplyDirect: (id) => ipcRenderer.invoke("router-apply-direct", { id }),
   routerApplyClaude: () => ipcRenderer.invoke("router-apply-claude"),
@@ -92,6 +109,14 @@ contextBridge.exposeInMainWorld("api", {
   canvasRun: (kind, params) => ipcRenderer.invoke("canvas-run", { kind, params }),
   canvasGroups: () => ipcRenderer.invoke("canvas-groups"),
   canvasModels: (groupId) => ipcRenderer.invoke("canvas-models", { groupId }),
+  canvasWorkspaces: () => ipcRenderer.invoke("canvas-workspaces"),
+  canvasWorkspaceCreate: (name) => ipcRenderer.invoke("canvas-workspace-create", { name }),
+  canvasWorkspaceLoad: (id) => ipcRenderer.invoke("canvas-workspace-load", { id }),
+  canvasWorkspaceRename: (id, name) => ipcRenderer.invoke("canvas-workspace-rename", { id, name }),
+  canvasWorkspaceSave: (workspace) => ipcRenderer.invoke("canvas-workspace-save", { workspace }),
+  canvasWorkspaceSaveNow: (workspace) => ipcRenderer.send("canvas-workspace-save-now", workspace),
+  canvasMediaCache: (payload) => ipcRenderer.invoke("canvas-media-cache", payload || {}),
+  canvasMediaRead: (payload) => ipcRenderer.invoke("canvas-media-read", payload || {}),
   // —— 多 Agent 员工团队生成 ——
   teamGenerate: (params) => ipcRenderer.invoke("team-generate", params || {}),
   teamPreview: (params) => ipcRenderer.invoke("team-preview", params || {}),
@@ -109,6 +134,7 @@ contextBridge.exposeInMainWorld("api", {
   voiceStatus: () => ipcRenderer.invoke("voice-status"),
   voiceConnect: (opts) => ipcRenderer.invoke("voice-connect", opts || {}),
   voiceDisconnect: () => ipcRenderer.invoke("voice-disconnect"),
+  voiceRestartCodex: () => ipcRenderer.invoke("voice-restart-codex"),
   voiceSttInfo: () => ipcRenderer.invoke("voice-stt-info"),
   voiceProbeStt: () => ipcRenderer.invoke("voice-probe-stt"),
   onVoiceStatus: (cb) => {
diff --git a/package-lock.json b/package-lock.json
index bf3f7f2..71436b1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,16 +1,17 @@
 {
   "name": "codex-market",
-  "version": "1.5.16",
+  "version": "1.5.21",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "codex-market",
-      "version": "1.5.16",
+      "version": "1.5.21",
       "license": "MIT",
       "dependencies": {
         "electron-updater": "^6.8.9",
         "isomorphic-git": "^1.29.0",
+        "pdfjs-dist": "^4.10.38",
         "sql.js": "^1.14.1"
       },
       "devDependencies": {
@@ -490,6 +491,271 @@
         "node": ">= 10.0.0"
       }
     },
+    "node_modules/@napi-rs/canvas": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas/-/canvas-0.1.100.tgz",
+      "integrity": "sha512-xglYA6q3XO5P3BNJYxVZ1IV7DLVjp1Py6nwag88YntrS+3vKHyYcMqXVS4ZztJmwz2uGvz1FWhI/4LgbR5uQDA==",
+      "license": "MIT",
+      "optional": true,
+      "workspaces": [
+        "e2e/*"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas-android-arm64": "0.1.100",
+        "@napi-rs/canvas-darwin-arm64": "0.1.100",
+        "@napi-rs/canvas-darwin-x64": "0.1.100",
+        "@napi-rs/canvas-linux-arm-gnueabihf": "0.1.100",
+        "@napi-rs/canvas-linux-arm64-gnu": "0.1.100",
+        "@napi-rs/canvas-linux-arm64-musl": "0.1.100",
+        "@napi-rs/canvas-linux-riscv64-gnu": "0.1.100",
+        "@napi-rs/canvas-linux-x64-gnu": "0.1.100",
+        "@napi-rs/canvas-linux-x64-musl": "0.1.100",
+        "@napi-rs/canvas-win32-arm64-msvc": "0.1.100",
+        "@napi-rs/canvas-win32-x64-msvc": "0.1.100"
+      }
+    },
+    "node_modules/@napi-rs/canvas-android-arm64": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-android-arm64/-/canvas-android-arm64-0.1.100.tgz",
+      "integrity": "sha512-hjhCKhntPv9+t4ckHymdx0phYNcVW+GKQR6Lzw2zE+pOVjOplSmtx9nNNknTjbEDLcuLZqA1y8ufKg1XfgftzQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-arm64": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-darwin-arm64/-/canvas-darwin-arm64-0.1.100.tgz",
+      "integrity": "sha512-2PcswRaC7Ly645DGt88///zuFDhJxJYdKAs1uU3mfk1atYkXufgcgLfBpk6Tm12nCQBaNt1wpybuPZ4qOhTo8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-x64": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-darwin-x64/-/canvas-darwin-x64-0.1.100.tgz",
+      "integrity": "sha512-ePNZtj7pNIva/siZMg+HmbeozkIjqUIYdoymH8HaA3qK7LfzFN4WMBM8G6HQ9ZC+H3+Dnn5pqtiXpgLykaPOhw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm-gnueabihf": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-linux-arm-gnueabihf/-/canvas-linux-arm-gnueabihf-0.1.100.tgz",
+      "integrity": "sha512-d5cDB48oWFGU8/XPhUOFAlySgb/VAu7D+s8fi55K1Pcfg8aPplHWqMgibhVLU8ky7Pyg/fuiVLz4Nf3JrSTuUA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-gnu": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-linux-arm64-gnu/-/canvas-linux-arm64-gnu-0.1.100.tgz",
+      "integrity": "sha512-rDxgxRu69RvDlX/bh9o22DxLsGr8EqsNgotL9+RwQE1S0b0cqeatqsw6aW45mukm0B42DIAaAacKaYQ8cqS1nw==",
+      "cpu": [
+        "arm64"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-musl": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-linux-arm64-musl/-/canvas-linux-arm64-musl-0.1.100.tgz",
+      "integrity": "sha512-K3mDW66N+xT2/V439u1alFANiBUjdEx2gLiNYnCmUsva5jZMxWTjafBYwTzYK+EMFMHrUoabuU+T1BIP5CgbYQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-riscv64-gnu": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-linux-riscv64-gnu/-/canvas-linux-riscv64-gnu-0.1.100.tgz",
+      "integrity": "sha512-mooqUBTIsccZpnoQC4NgrC1v6C1vof39etLNMnBwCY+p0gajWJvAHLGQ6g/gGyS5YrpDW+GefSN4+Cvcr08UWw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-gnu": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-linux-x64-gnu/-/canvas-linux-x64-gnu-0.1.100.tgz",
+      "integrity": "sha512-1eCvkDCazm7FFhsT7DfGOdSaHgZVK3bt/dSBl5EWHOWmnz+I7j8tPseJqqD81NF+MH21jKUK4wQSDjN0mdhnTg==",
+      "cpu": [
+        "x64"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-musl": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-linux-x64-musl/-/canvas-linux-x64-musl-0.1.100.tgz",
+      "integrity": "sha512-20arT6lnI19S68qNlii73TSEDbECNgzMz2EpldC1V3mZFuRkeujXkcebRk0LRJe9SEUAooYiLokfMViY8IX7yA==",
+      "cpu": [
+        "x64"
+      ],
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-arm64-msvc": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-win32-arm64-msvc/-/canvas-win32-arm64-msvc-0.1.100.tgz",
+      "integrity": "sha512-DZFFT1wIAg37LJw37yhMRFfjATd3vTQzjZ1Yki8u2vhO6Hi5VE6BVaGQ1aaDu7xb4iMErz+9EOwjpS7xcxFeBw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-x64-msvc": {
+      "version": "0.1.100",
+      "resolved": "https://registry.npmmirror.com/@napi-rs/canvas-win32-x64-msvc/-/canvas-win32-x64-msvc-0.1.100.tgz",
+      "integrity": "sha512-MyT1j3mHC2+Lu4pBi9mKyMJhtP6U7k7EldY7sj/uS5gJA65gTXt8MefJQXLJo5d/vZbuWmfxzkEUNc/urV3pHA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
     "node_modules/@pkgjs/parseargs": {
       "version": "0.11.0",
       "resolved": "https://registry.npmmirror.com/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
@@ -3537,6 +3803,18 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/pdfjs-dist": {
+      "version": "4.10.38",
+      "resolved": "https://registry.npmmirror.com/pdfjs-dist/-/pdfjs-dist-4.10.38.tgz",
+      "integrity": "sha512-/Y3fcFrXEAsMjJXeL9J8+ZG9U01LbuWaYypvDW2ycW1jL269L3js3DVBjDJ0Up9Np1uqDXsDrRihHANhZOlwdQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=20"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas": "^0.1.65"
+      }
+    },
     "node_modules/pend": {
       "version": "1.2.0",
       "resolved": "https://registry.npmmirror.com/pend/-/pend-1.2.0.tgz",
diff --git a/package.json b/package.json
index 3e6fde7..27d4034 100644
--- a/package.json
+++ b/package.json
@@ -5,10 +5,13 @@
   "author": "Codex Market",
   "license": "MIT",
   "main": "electron/bootstrap.js",
-  "hotContentVersion": "1.5.24",
+  "hotContentVersion": "1.5.83",
   "hotMinAppVersion": "1.5.0",
   "scripts": {
     "start": "electron .",
+    "test": "node --test",
+    "smoke:multimodal": "node scripts/smoke-multimodal.js",
+    "prepare:multimodal": "node scripts/prepare-multimodal-gateway.js",
     "dist": "electron-builder",
     "dist:mac": "electron-builder --mac",
     "dist:win": "electron-builder --win",
@@ -21,6 +24,7 @@
   "dependencies": {
     "electron-updater": "^6.8.9",
     "isomorphic-git": "^1.29.0",
+    "pdfjs-dist": "^4.10.38",
     "sql.js": "^1.14.1"
   }
 }
diff --git a/renderer/app.js b/renderer/app.js
index 2000b49..52cb02b 100644
--- a/renderer/app.js
+++ b/renderer/app.js
@@ -43,6 +43,19 @@ function busy(btn, on, textWhenBusy) {
     btn.disabled = false;
   }
 }
+function deferUI(fn, delay = 0) {
+  const run = () => {
+    try {
+      const r = fn();
+      if (r && typeof r.catch === "function") r.catch((e) => console.warn(e));
+    } catch (e) {
+      console.warn(e);
+    }
+  };
+  if (delay > 0) return setTimeout(run, delay);
+  if ("requestIdleCallback" in window) return window.requestIdleCallback(run, { timeout: 1200 });
+  return setTimeout(run, 0);
+}
 
 // —— 顶部广告：点击用系统浏览器打开官方推荐中转 ——
 const promoEl = document.querySelector(".promo");
@@ -60,6 +73,10 @@ function activatePanel(name) {
     clearInterval(tkPollTimer);
     tkPollTimer = null;
   }
+  if (name !== "canvas") {
+    const canvasPanel = document.getElementById("tab-canvas");
+    if (canvasPanel && canvasPanel.classList.contains("cv-fullscreen")) cvToggleFull(false);
+  }
   $$(".tab").forEach((t) => t.classList.remove("active"));
   $$(".panel").forEach((p) => p.classList.remove("active"));
   const panel = $(`#tab-${name}`);
@@ -75,7 +92,10 @@ $$("[data-open-panel]").forEach((btn) => {
   btn.addEventListener("click", () => {
     const name = btn.dataset.openPanel;
     activatePanel(name);
-    if (name === "sessions" && !sessLoaded) sessLoad();
+    if (name === "sessions") {
+      loadSessionDataDir();
+      if (!sessLoaded) sessLoad();
+    }
     if (name === "memory" && !memLoaded) memLoad();
     if (name === "voice" && !voiceLoaded) voiceLoad();
     if (name === "team") tmEnter();
@@ -87,6 +107,249 @@ $$("[data-open-panel]").forEach((btn) => {
 $$("[data-back-plugins]").forEach((btn) => {
   btn.addEventListener("click", () => activatePanel("plugins"));
 });
+
+// Codex 安装器：渲染层只触发固定主进程能力，不拼命令/路径。
+let codexInstallerInfo = null;
+const codexWinInstallBtn = $("#codex-win-install-btn");
+const codexWinOpenUrlBtn = $("#codex-win-open-url-btn");
+const codexMacInstallBtn = $("#codex-mac-install-btn");
+const codexMacOpenUrlBtn = $("#codex-mac-open-url-btn");
+const codexInstallerStatus = $("#codex-installer-status");
+const codexInstallerProgressWrap = $("#codex-installer-progress-wrap");
+const codexInstallerProgressBar = $("#codex-installer-progress-bar");
+const codexInstallerCancelRow = $("#codex-installer-cancel-row");
+const codexInstallerCancelBtn = $("#codex-installer-cancel-btn");
+let codexInstallerActivePlatform = "";
+
+function setCodexInstallerStatus(text) {
+  if (codexInstallerStatus) codexInstallerStatus.textContent = text;
+}
+
+function setCodexInstallerProgress(percent, active = true) {
+  if (!codexInstallerProgressWrap || !codexInstallerProgressBar) return;
+  codexInstallerProgressWrap.classList.toggle("hidden", !active);
+  const value = Math.max(0, Math.min(100, Number(percent) || 0));
+  codexInstallerProgressBar.style.width = `${value}%`;
+}
+
+function setCodexInstallerCancelVisible(visible, disabled = false) {
+  if (!codexInstallerCancelRow || !codexInstallerCancelBtn) return;
+  codexInstallerCancelRow.classList.toggle("hidden", !visible);
+  codexInstallerCancelBtn.disabled = !!disabled;
+}
+
+function setCodexInstallerControlsLocked(locked, activeBtn) {
+  [codexWinInstallBtn, codexMacInstallBtn, codexWinOpenUrlBtn, codexMacOpenUrlBtn].forEach((btn) => {
+    if (btn && btn !== activeBtn) btn.disabled = !!locked;
+  });
+}
+
+function isCodexInstallerCanceled(e) {
+  return /取消下载|已取消/.test(String(e && e.message ? e.message : e));
+}
+
+function handleCodexInstallerError(e) {
+  if (isCodexInstallerCanceled(e)) {
+    setCodexInstallerStatus("下载已取消");
+    setCodexInstallerProgress(0, false);
+    toast("下载已取消", "ok");
+    return;
+  }
+  const msg = e.message || e;
+  setCodexInstallerStatus(`安装失败：${msg}`);
+  toast(`安装失败：${msg}`, "err");
+}
+
+function codexInstallerProgressText(p) {
+  if (!p) return "";
+  const label = p.platform === "mac" ? "Mac" : "Windows";
+  if (p.phase === "download") {
+    const total = p.total ? ` / ${humanSize(p.total)}` : "";
+    const got = p.downloaded ? humanSize(p.downloaded) : "0B";
+    const percent = p.percent ? ` ${p.percent}%` : "";
+    return `${label} 下载中${percent}（${got}${total}）`;
+  }
+  if (p.message) return p.message;
+  const map = {
+    checking: "读取安装包校验信息…",
+    cached: "已使用本地缓存",
+    verify: "校验安装包…",
+    downloaded: `${label} 安装包已下载并校验完成`,
+    install: p.platform === "mac" ? "正在安装 Mac 版…" : "正在调用 PowerShell 安装…",
+    done: p.platform === "mac" ? "Codex Mac 版安装完成" : "Codex Windows 版安装完成",
+  };
+  return map[p.phase] || "处理中…";
+}
+
+function updateCodexInstallerButton(p) {
+  const btn = p && p.platform === "mac" ? codexMacInstallBtn : codexWinInstallBtn;
+  if (!btn || btn.dataset.busyActive !== "1") return;
+  if (p.phase === "download" && p.percent) btn.textContent = `下载 ${p.percent}%`;
+  else if (p.phase === "verify") btn.textContent = "校验中…";
+  else if (p.phase === "downloaded") btn.textContent = "下载完成";
+  else if (p.phase === "install") btn.textContent = p.platform === "mac" ? "安装中…" : "安装中…";
+}
+
+if (apic.onCodexInstallerProgress) {
+  apic.onCodexInstallerProgress((p) => {
+    const text = codexInstallerProgressText(p);
+    if (text) setCodexInstallerStatus(text);
+    const active = p && !["done", "downloaded", "canceled"].includes(p.phase);
+    setCodexInstallerProgress(p && p.percent, active);
+    const cancelable = p && ["checking", "download", "verify"].includes(p.phase);
+    if (cancelable) {
+      codexInstallerActivePlatform = p.platform || codexInstallerActivePlatform;
+      setCodexInstallerCancelVisible(true, false);
+    } else if (p && p.phase === "canceling") {
+      setCodexInstallerCancelVisible(true, true);
+    } else if (p && ["install", "done", "downloaded", "canceled"].includes(p.phase)) {
+      setCodexInstallerCancelVisible(false);
+    }
+    updateCodexInstallerButton(p);
+  });
+}
+
+async function loadCodexInstallerInfo() {
+  if (!apic.codexInstallerInfo) return null;
+  codexInstallerInfo = await apic.codexInstallerInfo();
+  const platformLabel = { win32: "Windows", darwin: "macOS", linux: "Linux" }[codexInstallerInfo.platform] || codexInstallerInfo.platform;
+  if (codexInstallerInfo.isWindows) {
+    setCodexInstallerStatus("当前是 Windows：可远程下载、校验 SHA256 后安装。");
+  } else if (codexInstallerInfo.isMac) {
+    setCodexInstallerStatus("当前是 macOS：可远程下载 DMG、校验 SHA256 后安装到 /Applications。");
+  } else {
+    setCodexInstallerStatus(`当前是 ${platformLabel}，可在软件内下载安装包后发给对应系统用户。`);
+  }
+  if (!codexInstallerInfo.isWindows && codexWinInstallBtn) {
+    if (codexWinInstallBtn) codexWinInstallBtn.textContent = "下载 Windows 包";
+  }
+  if (!codexInstallerInfo.isMac && codexMacInstallBtn) codexMacInstallBtn.textContent = "下载 Mac 包";
+  return codexInstallerInfo;
+}
+
+async function downloadCodexInstallerInApp(platform, btn) {
+  if (!apic.codexDownloadInstaller) throw new Error("当前版本缺少安装包下载能力，请先更新工具箱。");
+  const label = platform === "mac" ? "Mac" : "Windows";
+  codexInstallerActivePlatform = platform;
+  setCodexInstallerProgress(0, true);
+  setCodexInstallerCancelVisible(true, false);
+  setCodexInstallerControlsLocked(true, btn);
+  busy(btn, true, "准备下载…");
+  try {
+    const result = await apic.codexDownloadInstaller(platform);
+    setCodexInstallerStatus(`${label} 安装包已下载并校验完成：${result.path}`);
+    setCodexInstallerProgress(100, true);
+    toast(`${label} 安装包下载完成`, "ok");
+    return result;
+  } finally {
+    busy(btn, false);
+    setCodexInstallerControlsLocked(false);
+    setCodexInstallerCancelVisible(false);
+  }
+}
+
+if (codexInstallerCancelBtn) {
+  codexInstallerCancelBtn.addEventListener("click", async () => {
+    try {
+      if (!codexInstallerActivePlatform) return;
+      codexInstallerCancelBtn.disabled = true;
+      setCodexInstallerStatus("正在取消下载…");
+      await apic.codexCancelInstallerDownload(codexInstallerActivePlatform);
+    } catch (e) {
+      toast(`取消失败：${e.message || e}`, "err");
+      setCodexInstallerCancelVisible(true, false);
+    }
+  });
+}
+
+if (codexWinOpenUrlBtn) {
+  codexWinOpenUrlBtn.addEventListener("click", async () => {
+    try {
+      const info = codexInstallerInfo || await loadCodexInstallerInfo();
+      if (info && info.windowsUrl) {
+        await apic.openExternal(info.windowsUrl);
+        toast("已打开 Codex Windows 下载地址", "ok");
+      }
+    } catch (e) {
+      toast(`打开失败：${e.message || e}`, "err");
+    }
+  });
+}
+
+if (codexMacOpenUrlBtn) {
+  codexMacOpenUrlBtn.addEventListener("click", async () => {
+    try {
+      const info = codexInstallerInfo || await loadCodexInstallerInfo();
+      if (info && info.macUrl) {
+        await apic.openExternal(info.macUrl);
+        toast("已打开 Codex Mac 下载地址", "ok");
+      }
+    } catch (e) {
+      toast(`打开失败：${e.message || e}`, "err");
+    }
+  });
+}
+
+if (codexWinInstallBtn) {
+  codexWinInstallBtn.addEventListener("click", async () => {
+    try {
+      const info = codexInstallerInfo || await loadCodexInstallerInfo();
+      if (!info) throw new Error("安装器信息不可用");
+      if (!info.isWindows) {
+        await downloadCodexInstallerInApp("windows", codexWinInstallBtn);
+        return;
+      }
+      codexInstallerActivePlatform = "windows";
+      setCodexInstallerProgress(0, true);
+      setCodexInstallerCancelVisible(true, false);
+      setCodexInstallerControlsLocked(true, codexWinInstallBtn);
+      busy(codexWinInstallBtn, true, "准备中…");
+      await apic.codexInstallWindows();
+      setCodexInstallerStatus("Codex Windows 版安装完成");
+      setCodexInstallerProgress(100, true);
+      toast("Codex Windows 版安装完成", "ok");
+    } catch (e) {
+      handleCodexInstallerError(e);
+    } finally {
+      busy(codexWinInstallBtn, false);
+      setCodexInstallerControlsLocked(false);
+      setCodexInstallerCancelVisible(false);
+    }
+  });
+}
+
+if (codexMacInstallBtn) {
+  codexMacInstallBtn.addEventListener("click", async () => {
+    try {
+      const info = codexInstallerInfo || await loadCodexInstallerInfo();
+      if (!info) throw new Error("安装器信息不可用");
+      if (!info.isMac) {
+        await downloadCodexInstallerInApp("mac", codexMacInstallBtn);
+        return;
+      }
+      codexInstallerActivePlatform = "mac";
+      setCodexInstallerProgress(0, true);
+      setCodexInstallerCancelVisible(true, false);
+      setCodexInstallerControlsLocked(true, codexMacInstallBtn);
+      busy(codexMacInstallBtn, true, "准备中…");
+      await apic.codexInstallMac();
+      setCodexInstallerStatus("Codex Mac 版安装完成");
+      setCodexInstallerProgress(100, true);
+      toast("Codex Mac 版安装完成", "ok");
+    } catch (e) {
+      handleCodexInstallerError(e);
+    } finally {
+      busy(codexMacInstallBtn, false);
+      setCodexInstallerControlsLocked(false);
+      setCodexInstallerCancelVisible(false);
+    }
+  });
+}
+
+deferUI(() => loadCodexInstallerInfo().catch((e) => {
+  setCodexInstallerStatus(`安装器信息读取失败：${e.message || e}`);
+}));
+
 $$(".subtab").forEach((st) => {
   st.addEventListener("click", () => {
     $$(".subtab").forEach((s) => s.classList.remove("active"));
@@ -102,10 +365,23 @@ $("#log-toggle").addEventListener("click", () => {
   p.classList.toggle("hidden");
   $("#log-caret").textContent = p.classList.contains("hidden") ? "▲" : "▼";
 });
-apic.onLog((msg) => {
+let logBuffer = [];
+let logFlushTimer = 0;
+let logLines = [];
+function flushLogs() {
+  logFlushTimer = 0;
+  if (!logBuffer.length) return;
+  logLines.push(...logBuffer);
+  logBuffer = [];
+  if (logLines.length > 500) logLines = logLines.slice(-500);
   const out = $("#log-out");
-  out.textContent += msg + "\n";
-  $("#log-panel").scrollTop = $("#log-panel").scrollHeight;
+  const panel = $("#log-panel");
+  out.textContent = logLines.join("\n") + "\n";
+  if (!panel.classList.contains("hidden")) panel.scrollTop = panel.scrollHeight;
+}
+apic.onLog((msg) => {
+  logBuffer.push(String(msg));
+  if (!logFlushTimer) logFlushTimer = setTimeout(flushLogs, 120);
 });
 
 // ===========================================================================
@@ -115,15 +391,17 @@ let voiceLoaded = false;
 let voiceControlsWired = false;
 let latestVoiceStatus = null;
 const PHASE_TEXT = {
-  unknown: "未连接",
+  unknown: "未注入",
   checking: "检测中…",
   not_running: "Codex 未运行",
-  running_no_port: "需重启 Codex",
-  restarting: "正在重启 Codex…",
+  running_no_port: "需重启注入",
+  restarting: "正在重启 ChatGPT…",
+  waiting_debug_port: "等待调试端口…",
+  unsupported_packaged: "需官网版",
   connecting: "正在连接…",
   injecting: "正在注入…",
-  connected: "已连接",
-  disconnected: "已断开",
+  connected: "已注入",
+  disconnected: "未注入",
   transcribing: "转写中…",
   recording: "录音中",
   error: "出错",
@@ -145,6 +423,7 @@ function renderVoiceStatus(s) {
   const connected = isVoiceConnected(phase);
   $$("[data-voice-link-connect]").forEach((btn) => btn.classList.toggle("hidden", connected));
   $$("[data-voice-link-disconnect]").forEach((btn) => btn.classList.toggle("hidden", !connected));
+  $$("[data-voice-disable]").forEach((btn) => btn.classList.toggle("hidden", !connected));
   $$("[data-voice-enable]").forEach((btn) => {
     btn.disabled = connected;
     if (!btn.dataset.busyActive) {
@@ -155,6 +434,8 @@ function renderVoiceStatus(s) {
   });
   let detailText = txt;
   if (s && s.lastError) detailText += "　" + s.lastError;
+  if (s && s.launchWarning) detailText += "　" + s.launchWarning;
+  if (s && s.portDiagnostic) detailText += "　" + s.portDiagnostic;
   if (s && s.codexPath) detailText += "　路径：" + s.codexPath;
   if (s && s.target && s.target.title) detailText += "　目标：" + s.target.title;
   if (detail) detail.textContent = detailText;
@@ -165,7 +446,7 @@ async function handleVoiceConnect(triggerBtn) {
   // 若 Codex 在跑但没端口，需用户确认重启
   if (cur.phase === "running_no_port") {
     const ok = confirm(
-      "需要重启 Codex 以启用语音输入调试通道。\n\n当前 Codex 窗口会关闭一次后重新打开，登录态与历史会话保留。\n是否继续？"
+      "需要重启 Codex 以启用注入通道。\n\n语音输入、Token 用量和左侧任务行的彻底删除按钮都依赖此连接。当前 Codex 窗口会关闭一次后重新打开，登录态与历史会话保留。\n是否继续？"
     );
     if (!ok) return;
     busy(triggerBtn, true, "重启中…");
@@ -173,6 +454,7 @@ async function handleVoiceConnect(triggerBtn) {
       const s = await apic.voiceConnect({ forceRestart: true });
       renderVoiceStatus(s);
       if (s.phase === "error") toast(s.lastError || "连接失败", "err");
+      else if (s.phase === "unsupported_packaged") toast(s.lastError || "当前 Store/MSIX 版不支持直接注入，请安装官网普通桌面版", "warn");
     } catch (e) {
       toast("连接失败：" + (e && e.message ? e.message : e), "err");
     } finally {
@@ -186,11 +468,13 @@ async function handleVoiceConnect(triggerBtn) {
     const s = await apic.voiceConnect({});
     renderVoiceStatus(s);
     if (s.phase === "running_no_port") {
-      toast(isEnable ? "Codex 在运行，需重启以启用调试端口，请再次点击启用" : "Codex 在运行，需重启以启用调试端口，请再次点击连接", "");
+      toast(isEnable ? "ChatGPT 在运行，需重启以启用调试端口，请再次点击启用" : "ChatGPT 在运行，需重启以启用调试端口，请再次点击连接", "");
+    } else if (s.phase === "unsupported_packaged") {
+      toast(s.lastError || "当前 Store/MSIX 版不支持直接注入，请安装官网普通桌面版", "warn");
     } else if (s.phase === "error") {
       toast(s.lastError || "连接失败", "err");
     } else if (s.phase === "connected") {
-      toast(isEnable ? "语音输入已启用，Codex 输入框旁应出现 🎤 按钮" : "已连接 Codex");
+      toast(isEnable ? "语音输入和左侧任务删除按钮已注入" : "已注入 Codex：语音、Token 与左侧任务删除按钮已启用");
     }
   } catch (e) {
     toast("连接失败：" + (e && e.message ? e.message : e), "err");
@@ -218,7 +502,7 @@ function wireVoiceControls() {
       await handleVoiceConnect(connectBtn);
       return;
     }
-    const disconnectBtn = e.target.closest("[data-voice-link-disconnect]");
+    const disconnectBtn = e.target.closest("[data-voice-link-disconnect], [data-voice-disable]");
     if (disconnectBtn) await handleVoiceDisconnect(disconnectBtn);
   });
   apic.voiceStatus().then(renderVoiceStatus).catch(() => {});
@@ -248,7 +532,7 @@ async function voiceLoad() {
       }
     } catch {}
   }
-  loadSttInfo();
+  deferUI(loadSttInfo, 1200);
 
   if (refreshSttBtn) {
     refreshSttBtn.addEventListener("click", () => loadSttInfo());
@@ -289,8 +573,8 @@ function safeSkillDir(name) {
     .toLowerCase()
     .replace(/[^\w一-龥.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80)) || "skill";
 }
-async function loadInstalledSkills() {
-  try { installedSkills = await apic.skillInstalled(); }
+async function loadInstalledSkills(opts = {}) {
+  try { installedSkills = await apic.skillInstalled(opts); }
   catch { installedSkills = []; }
   installedDirs = new Set(installedSkills.map((x) => x.dir));
 }
@@ -484,7 +768,7 @@ async function uninstallSkill(dir, btn) {
   try {
     await apic.skillUninstall(dir);
     // 清掉旧的 localStorage 标记（按 id 存的，尽力匹配）
-    await loadInstalledSkills();
+    await loadInstalledSkills({ includeSize: storeCat === "__installed__", includeMeta: true });
     toast(`已卸载 ${label} ✅`, "ok");
     renderInstalledSkills();
     renderStoreNav();
@@ -513,11 +797,12 @@ function renderStoreNav() {
   for (const c of skillCat.categories) html += item(c.name, c.name, c.count);
   nav.innerHTML = html;
   nav.querySelectorAll(".nav-item").forEach((el) =>
-    el.addEventListener("click", () => {
+    el.addEventListener("click", async () => {
       storeCat = el.dataset.cat;
       nav.querySelectorAll(".nav-item").forEach((x) => x.classList.remove("active"));
       el.classList.add("active");
       $("#market-grid").scrollTop = 0;
+      if (storeCat === "__installed__") await loadInstalledSkills({ includeSize: true, includeMeta: true });
       renderStore(true);
     })
   );
@@ -532,7 +817,7 @@ async function installSkill(id, btn) {
     const r = await apic.skillInstall(s);
     installed.add(String(s.id));
     localStorage.setItem("installedSkills", JSON.stringify([...installed]));
-    await loadInstalledSkills();
+    await loadInstalledSkills({ includeSize: storeCat === "__installed__", includeMeta: true });
     renderStoreNav();
     toast(`已安装 ${s.name} ✅（${r.files} 个文件）重启 Codex 生效`, "ok");
     btn.textContent = "已安装 ✓";
@@ -587,9 +872,12 @@ async function loadMarket() {
   grid.innerHTML = '<div class="empty"><div class="spinner"></div>正在加载技能商店…</div>';
   try {
     skillCat = await apic.skillCatalog();
-    await loadInstalledSkills();
     renderStoreNav();
     renderStore(true);
+    deferUI(async () => {
+      await loadInstalledSkills({ includeSize: false, includeMeta: false });
+      renderStore(true);
+    }, 900);
   } catch (e) {
     grid.innerHTML = "";
     empty.classList.remove("hidden");
@@ -885,6 +1173,45 @@ let sessCurrent = null;
 let sessLoaded = false;
 let sessAllMode = false;
 
+function renderSessionDataDir(info) {
+  if (!info || !info.path) return;
+  $("#session-data-dir-path").textContent = info.path;
+  $("#session-data-dir-path").title = info.path;
+  $("#mem-data-dir-path").textContent = info.path;
+  $("#mem-data-dir-path").title = info.path;
+  $("#session-data-dir-reset").classList.toggle("hidden", !!info.isDefault);
+}
+
+async function loadSessionDataDir() {
+  try {
+    renderSessionDataDir(await apic.sessionsDataDirInfo());
+  } catch {
+    $("#session-data-dir-path").textContent = "读取失败";
+    $("#mem-data-dir-path").textContent = "读取失败";
+  }
+}
+
+async function changeSessionDataDir(reset, btn) {
+  busy(btn, true, reset ? "恢复中…" : "切换中…");
+  try {
+    const info = reset ? await apic.sessionsDataDirReset() : await apic.sessionsDataDirSelect();
+    if (info.canceled) return;
+    renderSessionDataDir(info);
+    sessData = [];
+    sessCurrent = null;
+    sessLoaded = false;
+    $("#sess-conv").classList.add("hidden");
+    $("#sess-empty").classList.remove("hidden");
+    await sessLoad();
+    if (memLoaded) await memLoad();
+    toast(reset ? "已恢复默认 Codex 会话目录" : "已切换 Codex 会话目录，记忆监视已重启", "ok");
+  } catch (e) {
+    toast("切换目录失败：" + (e.message || e), "err");
+  } finally {
+    busy(btn, false);
+  }
+}
+
 function sessUpdateScope() {
   const el = $("#sess-scope");
   if (!el) return;
@@ -978,8 +1305,33 @@ async function sessLoad(opts = {}) {
   }
 }
 
+$("#sess-delete").addEventListener("click", async (ev) => {
+  if (!sessCurrent) return;
+  const item = sessCurrent;
+  const confirmed = confirm("永久删除这条会话？\\n\\n将同时删除：会话正文、归档副本、Codex 本地索引、工具箱会话记忆。\\n此操作不可恢复，且需要先完全退出 Codex。");
+  if (!confirmed) return;
+  const btn = ev.currentTarget;
+  busy(btn, true, "删除中…");
+  try {
+    const r = await apic.sessionDeletePermanently(item.path);
+    if (!r || !r.ok) throw new Error((r && r.error) || "永久删除失败");
+    sessCurrent = null;
+    $("#sess-empty").classList.remove("hidden");
+    $("#sess-conv").classList.add("hidden");
+    await sessLoad();
+    if (r.cleanupWarning) toast("会话主体已删除，但工具箱记忆清理失败：" + r.cleanupWarning, "err");
+    else toast("会话及本地缓存已永久删除", "ok");
+  } catch (e) {
+    toast("永久删除失败：" + (e.message || e), "err");
+  } finally {
+    busy(btn, false);
+  }
+});
+
 $("#sess-search").addEventListener("input", sessRender);
 $("#sess-refresh").addEventListener("click", sessLoad);
+$("#session-data-dir-select").addEventListener("click", (ev) => changeSessionDataDir(false, ev.currentTarget));
+$("#session-data-dir-reset").addEventListener("click", (ev) => changeSessionDataDir(true, ev.currentTarget));
 $("#sess-fetch-all").addEventListener("click", async (ev) => {
   const btn = ev.currentTarget;
   busy(btn, true, "读取中…");
@@ -1063,12 +1415,13 @@ $("#sync-btn").addEventListener("click", async (ev) => {
     const r = await apic.providerSync();
     $("#sync-progress-fill").style.width = "100%";
     const dbChanged = (r.ueRows || 0) + (r.provRows || 0) + (r.insertedRows || 0) + (r.projectRows || 0) + (r.projectlessRemoved || 0);
-    const changedMsg = r.changedFiles > 0 || dbChanged > 0
-      ? `文件 ${r.changedFiles || 0} 条，数据库/项目索引 ${dbChanged} 项`
+    const catalogN = r.catalogRebuilt || 0;
+    const changedMsg = r.changedFiles > 0 || dbChanged > 0 || catalogN > 0
+      ? `文件 ${r.changedFiles || 0} 条，数据库/项目索引 ${dbChanged} 项，侧栏目录 ${catalogN} 条`
       : `全部已是最新，无需改动`;
     $("#sync-progress-label").textContent = `完成 ✅ 共 ${r.totalConversations} 条会话，${changedMsg}`;
-    const tip = r.changedFiles > 0 || dbChanged > 0
-      ? `同步完成 ✅ ${changedMsg}。重新打开 Codex 即可看到`
+    const tip = r.changedFiles > 0 || dbChanged > 0 || catalogN > 0
+      ? `同步完成 ✅ ${changedMsg}。请完全退出并重新打开 Codex 查看侧栏`
       : `全部 ${r.totalConversations} 条会话之前已同步过，本次无需改动 ✅`;
     toast(tip, "ok");
     setTimeout(() => $("#sync-progress").classList.add("hidden"), 4000);
@@ -1225,6 +1578,7 @@ async function memRenderList() {
 async function memLoad() {
   memLoaded = true;
   try {
+    await loadSessionDataDir();
     memRenderStatus(await apic.memoryStatus());
     await memRenderList();
   } catch (e) {
@@ -1377,23 +1731,26 @@ function renderRouter(st) {
   const itemHtml = (g, radioName, activeId) => {
     // chat 模式（国产：DeepSeek/GLM/Kimi/通义）需协议转换，无法直连 Codex，必须开本地路由才能用
     const needsRouter = !g.isDefault && g.mode === "chat";
+    const toolOnly = !g.isDefault && (g.codexImage || g.codexVideo || g.stt);
     const badges =
-      (g.id === activeId ? '<span class="pc-badge skill">当前</span>' : "") +
+      (!toolOnly && g.id === activeId ? '<span class="pc-badge skill">当前</span>' : "") +
       (g.isDefault ? ' <span class="pc-badge">默认·不可删</span>' : "") +
-      (needsRouter ? ' <span class="pc-badge warn">需路由</span>' : "");
+      (needsRouter ? ' <span class="pc-badge warn">需路由</span>' : "") +
+      (toolOnly ? ' <span class="pc-badge plugin">插件专用</span>' : "");
     const actions = g.isDefault
-      ? '<span class="muted small">切回这里 = 直连你的账号</span>'
+      ? '<span class="muted small">切回这里 = 直连你的账号</span><button class="btn small ghost" data-default-config="1">编辑</button>'
       : `<button class="btn small ghost" data-edit="${g.id}">编辑</button><button class="btn small ghost" data-del="${g.id}">删除</button>`;
     // chat 分组被选中但路由没在跑 → 醒目提示去启动
     const routerHint = needsRouter && g.id === activeId && !st.running
       ? '<div class="cl-warn">⚠️ 该分组需协议转换，请先在上方「启动」本地路由，否则 Codex 无法使用</div>'
       : "";
     return `
-    <div class="cl-item">
-      <input type="radio" name="${radioName}" ${g.id === activeId ? "checked" : ""} data-active="${g.id}" />
+    <div class="cl-item${toolOnly ? " is-disabled" : ""}">
+      <input type="radio" name="${radioName}" ${!toolOnly && g.id === activeId ? "checked" : ""} ${toolOnly ? "disabled" : ""} data-active="${g.id}" />
       <div>
-        <div class="cl-name">${esc(g.name)} ${badges}${g.codexImage ? ' <span class="agent-badge mm">🎨 生图</span>' : ""}${g.stt ? ' <span class="agent-badge mm">🎤 转文字' + (g.sttModel ? " " + esc(g.sttModel) : "") + '</span>' : ""}</div>
+        <div class="cl-name">${esc(g.name)} ${badges}${g.codexImage ? ' <span class="agent-badge mm">🎨 生图</span>' : ""}${g.codexVideo ? ' <span class="agent-badge mm">🎬 视频</span>' : ""}${g.stt ? ' <span class="agent-badge mm">🎤 语音' + (g.sttModel ? " " + esc(g.sttModel) : "") + '</span>' : ""}${g.multimodal ? ' <span class="agent-badge mm">多模态</span>' : ""}</div>
         <div class="cl-src">${esc(g.baseUrl)}${g.model ? " · 模型 " + esc(g.model) : ""}${needsRouter ? " · 🔄转换" : ""}${g.hasKey ? "" : " · ⚠️无密钥"}</div>
+        ${toolOnly ? '<div class="cl-tool-hint">画布/插件按需调用，不作为 Codex/GPT 默认对话分组</div>' : ""}
         ${routerHint}
       </div>
       <div class="btn-group" style="margin-left:auto">${actions}</div>
@@ -1409,21 +1766,33 @@ function renderRouter(st) {
     colHtml("Claude Code", "Anthropic 协议 · /v1/messages", claude, "active-grp-claude", st.activeClaudeId);
   box.querySelectorAll("[data-active]").forEach((el) =>
     el.addEventListener("change", async () => {
+      if (el.disabled) return;
       const r = await apic.routerSetActive(el.dataset.active);
+      if (r && r._activeSkipped) {
+        renderRouter(r);
+        toast(r._activeReason || "该分组不能作为默认对话分组", "warn");
+        return;
+      }
       const g = (r.groups || []).find((x) => x.id === el.dataset.active);
       renderRouter(r);
       if (g && g.mode === "claude") {
         if (r._claudeSkipped) toast("已选 Claude 分组，但未写入：" + (r._claudeReason || "缺地址或密钥"), "warn");
         else if (r._mode === "direct") toast("已切 Claude Code 分组 ✅ 新开 claude 会话生效", "ok");
         else toast("已秒切 Claude Code 分组 ✅ 无需重启", "ok");
-      } else if (r._needsRestart) toast("已切换，重启 Codex 后生效（配置有变）", "ok");
-      else if (r._mode === "direct") toast("已切回默认（直连你的账号）✅", "ok");
+      } else if (r._needsRestart) {
+        toast("已切换，重启 Codex 后生效（配置有变）", "ok");
+      } else if (r._needsCodexRefresh) {
+        toast("已秒切分组 ✅ 下一次 Codex 请求即用新模型；顶部模型选择器将在 Codex 下次启动时刷新", "ok");
+      } else if (r._mode === "direct") toast("已切回默认（直连你的账号）✅", "ok");
       else toast("已秒切分组 ✅ 无需重启 Codex", "ok");
     })
   );
   box.querySelectorAll("[data-edit]").forEach((el) =>
     el.addEventListener("click", () => openGrpModal(st.groups.find((g) => g.id === el.dataset.edit)))
   );
+  box.querySelectorAll("[data-default-config]").forEach((el) =>
+    el.addEventListener("click", openDefaultConfigModal)
+  );
   box.querySelectorAll("[data-del]").forEach((el) =>
     el.addEventListener("click", async () => {
       if (confirm("删除这个分组？")) renderRouter(await apic.routerDeleteGroup(el.dataset.del));
@@ -1449,8 +1818,11 @@ function openGrpModal(g) {
   $("#grp-key").placeholder = g && g.hasKey ? "（已保存，留空则不修改）" : "sk-…";
   $("#grp-model").value = g ? g.model || "" : "";
   $("#grp-codex-image").checked = !!(g && g.codexImage);
+  $("#grp-codex-video").checked = !!(g && g.codexVideo);
   $("#grp-stt").checked = !!(g && g.stt);
+  $("#grp-multimodal").checked = !!(g && g.multimodal);
   $("#grp-stt-model").value = g && g.sttModel ? g.sttModel : "whisper-1";
+  grpUpdateSttModelField();
   $("#grp-ctx").value = g && g.contextWindow ? g.contextWindow : "";
   const sel = $("#grp-model-list");
   sel.classList.add("hidden");
@@ -1460,6 +1832,7 @@ function openGrpModal(g) {
   grp1mMarks = new Set((g && Array.isArray(g.oneMillionModels)) ? g.oneMillionModels : []);
   if (grp1mMarks.size) grpRender1mList([...grp1mMarks]);
   else { $("#grp-1m-field").style.display = "none"; $("#grp-1m-list").innerHTML = ""; }
+  grpUpdateMultimodalField();
   grpUpdateClaudeDesk();
   $("#grp-modal").classList.remove("hidden");
 }
@@ -1467,11 +1840,67 @@ function closeGrpModal() {
   $("#grp-modal").classList.add("hidden");
 }
 
+function grpUpdateSttModelField() {
+  const field = $("#grp-stt-model-field");
+  if (!field) return;
+  field.classList.toggle("hidden", !$("#grp-stt").checked);
+}
+
+function grpUpdateMultimodalField() {
+  const toggle = $("#grp-multimodal");
+  if (!toggle) return;
+  const enabled = $("#grp-mode").value === "chat";
+  if (!enabled) toggle.checked = false;
+  toggle.disabled = !enabled;
+}
+
+function fmtTime(ts) {
+  if (!ts) return "无快照时间";
+  try { return new Date(ts).toLocaleString(); } catch { return String(ts); }
+}
+function authLine(a) {
+  if (!a) return "凭证：未知";
+  const parts = [a.loginMode || "凭证：未知"];
+  if (a.hasOpenAIKey) parts.push("API Key " + (a.keyPreview || "已保存"));
+  if (a.hasTokens) parts.push("OAuth tokens 已保存");
+  return parts.join(" · ");
+}
+async function openDefaultConfigModal() {
+  const modal = $("#default-config-modal");
+  const summary = $("#default-config-summary");
+  const current = $("#default-config-current");
+  const snapshot = $("#default-config-snapshot");
+  modal.classList.remove("hidden");
+  summary.innerHTML = '<div><b>读取中</b>正在读取 ~/.codex/config.toml...</div>';
+  current.value = "";
+  snapshot.value = "";
+  try {
+    const info = await apic.routerDefaultConfig();
+    if (!info || !info.ok) throw new Error((info && info.error) || "读取失败");
+    const cur = info.current || {};
+    const snap = info.snapshot || {};
+    summary.innerHTML = [
+      `<div><b>当前配置</b>Provider：${esc(cur.modelProvider || "Codex 原生登录态")}<br>Model：${esc(cur.model || "未设置")}<br>状态：${cur.managed ? "当前被中转/路由接管" : "官方直连"}<br>${esc(authLine(cur.auth))}</div>`,
+      `<div><b>默认快照</b>Provider：${esc(snap.modelProvider || "Codex 原生登录态")}<br>Model：${esc(snap.model || "未设置")}<br>状态：${snap.managed ? "异常：仍含接管配置" : "干净官方配置"}<br>修复时间：${esc(fmtTime(snap.repairedAt || snap.savedAt))}</div>`,
+      `<div><b>config.toml</b>${esc(info.configPath || "~/.codex/config.toml")}</div>`,
+      `<div><b>auth.json</b>${esc(authLine(snap.auth))}<br>${esc(info.authPath || "~/.codex/auth.json")}</div>`,
+    ].join("");
+    current.value = info.currentConfigToml || "（未读取到当前 config.toml）";
+    snapshot.value = info.snapshotConfigToml || "（没有默认快照内容：可能是旧版本创建的默认项，或首次记录时 config.toml 为空）";
+  } catch (e) {
+    summary.innerHTML = `<div><b>读取失败</b>${esc(e.message || e)}</div>`;
+  }
+}
+function closeDefaultConfigModal() {
+  $("#default-config-modal").classList.add("hidden");
+}
+
 // 刷新「接入 Claude 桌面 App」区：按分组协议启用/禁用 + 显示接入/备份状态
 async function grpUpdateClaudeDesk() {
   const block = $("#grp-claudedesk");
   if (!block) return;
   const isClaude = $("#grp-mode").value === "claude";
+  block.classList.toggle("hidden", !isClaude);
   const hint = $("#grp-cd-hint");
   const applyBtn = $("#grp-cd-apply");
   const exportBtn = $("#grp-cd-export");
@@ -1506,9 +1935,19 @@ document.querySelectorAll("[data-ctx]").forEach((b) =>
 );
 $("#grp-add").addEventListener("click", () => openGrpModal(null));
 $("#grp-modal-close").addEventListener("click", closeGrpModal);
+$("#default-config-close").addEventListener("click", closeDefaultConfigModal);
+$("#default-config-refresh").addEventListener("click", openDefaultConfigModal);
+$("#default-config-copy").addEventListener("click", () => {
+  const text = $("#default-config-current").value;
+  if (text) navigator.clipboard.writeText(text).then(() => toast("已复制当前 config.toml", "ok"));
+});
 
 // 接口类型改变时，实时刷新「接入 Claude 桌面」区的可用性
-$("#grp-mode").addEventListener("change", grpUpdateClaudeDesk);
+$("#grp-mode").addEventListener("change", () => {
+  grpUpdateMultimodalField();
+  grpUpdateClaudeDesk();
+});
+$("#grp-stt").addEventListener("change", grpUpdateSttModelField);
 
 // —— 接入 Claude 桌面 App 按钮 ——
 $("#grp-cd-apply").addEventListener("click", async (ev) => {
@@ -1557,6 +1996,9 @@ $("#grp-cd-restore").addEventListener("click", async (ev) => {
 $("#grp-modal").addEventListener("click", (e) => {
   if (e.target === $("#grp-modal")) closeGrpModal();
 });
+$("#default-config-modal").addEventListener("click", (e) => {
+  if (e.target === $("#default-config-modal")) closeDefaultConfigModal();
+});
 $("#grp-save").addEventListener("click", async () => {
   const name = $("#grp-name").value.trim();
   const baseUrl = $("#grp-url").value.trim();
@@ -1571,8 +2013,10 @@ $("#grp-save").addEventListener("click", async () => {
     mode: $("#grp-mode").value,
     contextWindow: $("#grp-ctx").value.trim(),
     codexImage: $("#grp-codex-image").checked,
+    codexVideo: $("#grp-codex-video").checked,
     stt: $("#grp-stt").checked,
     sttModel: $("#grp-stt").checked ? ($("#grp-stt-model").value.trim() || "whisper-1") : "",
+    multimodal: $("#grp-mode").value === "chat" && $("#grp-multimodal").checked,
     oneMillionModels: [...grp1mMarks],
   };
   if (grpEditing) group.id = grpEditing.id;
@@ -1644,13 +2088,39 @@ $("#router-toggle").addEventListener("click", async (ev) => {
   const btn = ev.currentTarget;
   busy(btn, true, "处理中…");
   try {
-    renderRouter(routerState.running ? await apic.routerStop() : await apic.routerStart());
+    if (routerState.running) {
+      const r = await apic.routerStop();
+      renderRouter(r.status || r);
+      if (r.releaseError) toast("本地路由已停止，但清理 Codex 接管配置失败：" + r.releaseError, "err");
+      else if (r.released && r.keptUserProvider) toast("本地路由已停止，已清理本工具配置并保留你手写的 provider", "ok");
+      else if (r.released) toast("本地路由已停止，已清理本工具配置", "ok");
+      else if (r.skippedRelease) toast("本地路由已停止，当前 Codex 配置未由本地路由接管", "warn");
+    } else {
+      renderRouter(await apic.routerStart());
+    }
   } catch (e) {
     toast("操作失败：" + (e.message || e), "err");
   } finally {
     busy(btn, false);
   }
 });
+$("#router-refresh-codex").addEventListener("click", async (ev) => {
+  if (!confirm("将重启 Codex 以同步顶部模型选择器。\n\n登录态与历史会话保留，未保存的输入内容请先自行确认。是否继续？")) return;
+  const btn = ev.currentTarget;
+  busy(btn, true, "刷新中…");
+  try {
+    const s = await apic.voiceRestartCodex();
+    renderVoiceStatus(s);
+    if (s && s.ok && s.phase === "connected") toast("Codex 已重启，顶部模型选择器已刷新", "ok");
+    else toast((s && (s.error || s.lastError)) || "Codex 刷新失败", "warn");
+  } catch (e) {
+    toast("Codex 刷新失败：" + (e && e.message ? e.message : e), "err");
+  } finally {
+    busy(btn, false);
+    renderVoiceStatus(latestVoiceStatus || {});
+  }
+});
+
 $("#router-save-port").addEventListener("click", async () => {
   try {
     renderRouter(await apic.routerSetPort($("#router-port").value));
@@ -1835,113 +2305,6 @@ apic.onUpdateStatus((s) => {
   else if (s.state === "error") info.textContent = "更新检查失败：" + (s.message || "");
 });
 
-// ===========================================================================
-// 全局 / 系统代理
-// ===========================================================================
-function renderProxy(st) {
-  const badge = $("#proxy-state");
-  if (!badge) return;
-  const detail = $("#proxy-state-detail");
-  const stopBtn = $("#proxy-stop");
-  const gBtn = $("#proxy-start-global");
-  const sBtn = $("#proxy-start-system");
-  if (st.mode === "global") {
-    badge.textContent = "全局代理运行中";
-    badge.className = "pc-badge on";
-    detail.textContent = "整机 TUN · 所有程序流量走代理";
-  } else if (st.mode === "system") {
-    badge.textContent = "系统代理运行中";
-    badge.className = "pc-badge on";
-    detail.textContent = `本地中转 127.0.0.1:${st.localPort}`;
-  } else {
-    badge.textContent = "未开启";
-    badge.className = "pc-badge";
-    detail.textContent = st.proxy
-      ? `已配置 ${st.proxy.host}:${st.proxy.port}${st.proxy.hasAuth ? " · 需密码" : ""}`
-      : "未配置代理";
-  }
-  const running = st.mode !== "off";
-  stopBtn.classList.toggle("hidden", !running);
-  const disabled = !st.hasConfig || !st.binOk;
-  gBtn.disabled = disabled;
-  sBtn.disabled = disabled;
-  gBtn.classList.toggle("active", st.mode === "global");
-  sBtn.classList.toggle("active", st.mode === "system");
-  if (!st.binOk) detail.textContent = "⚠️ 缺少 sing-box 引擎文件，请重装软件";
-}
-
-async function loadProxy() {
-  try {
-    const cfg = await apic.proxyGetConfig();
-    if (cfg && cfg.proxyStr && !$("#proxy-str").value) $("#proxy-str").value = cfg.proxyStr;
-    renderProxy(await apic.proxyStatus());
-  } catch (e) {
-    toast("代理状态读取失败：" + (e.message || e), "err");
-  }
-}
-
-$("#proxy-save").addEventListener("click", async (ev) => {
-  const btn = ev.currentTarget;
-  busy(btn, true, "保存中…");
-  try {
-    await apic.proxySetConfig({ proxyStr: $("#proxy-str").value.trim() });
-    renderProxy(await apic.proxyStatus());
-    toast("已保存 ✅", "ok");
-  } catch (e) {
-    toast("保存失败：" + (e.message || e), "err");
-  } finally {
-    busy(btn, false);
-  }
-});
-
-$("#proxy-test").addEventListener("click", async (ev) => {
-  const btn = ev.currentTarget;
-  const out = $("#proxy-test-out");
-  busy(btn, true, "测试中…");
-  out.textContent = "正在通过代理请求出口 IP…";
-  try {
-    await apic.proxySetConfig({ proxyStr: $("#proxy-str").value.trim() });
-    const r = await apic.proxyTest();
-    out.innerHTML = `✅ 代理可用 · 出口 IP：<b>${esc(r.ip)}</b>`;
-  } catch (e) {
-    out.textContent = "❌ 测试失败：" + (e.message || e);
-  } finally {
-    busy(btn, false);
-  }
-});
-
-async function startProxy(mode, btn) {
-  busy(btn, true, mode === "global" ? "启动全局中…" : "启动系统代理中…");
-  try {
-    await apic.proxySetConfig({ proxyStr: $("#proxy-str").value.trim() });
-    renderProxy(await apic.proxyStart(mode));
-    toast(mode === "global" ? "全局代理已开启（整机）✅" : "系统代理已开启 ✅", "ok");
-  } catch (e) {
-    toast("启动失败：" + (e.message || e), "err");
-    try {
-      renderProxy(await apic.proxyStatus());
-    } catch {}
-  } finally {
-    busy(btn, false);
-  }
-}
-$("#proxy-start-global").addEventListener("click", (ev) => startProxy("global", ev.currentTarget));
-$("#proxy-start-system").addEventListener("click", (ev) => startProxy("system", ev.currentTarget));
-$("#proxy-stop").addEventListener("click", async (ev) => {
-  const btn = ev.currentTarget;
-  busy(btn, true, "关闭中…");
-  try {
-    renderProxy(await apic.proxyStop());
-    toast("代理已关闭，网络已还原", "ok");
-  } catch (e) {
-    toast("关闭失败：" + (e.message || e), "err");
-  } finally {
-    busy(btn, false);
-  }
-});
-document.querySelector('.tab[data-tab="proxy"]').addEventListener("click", loadProxy);
-apic.onProxyChanged((st) => renderProxy(st));
-
 // ============================================================
 // 创意画布（Drawflow 节点画布）
 // 懒初始化：首次进入 canvas 标签才 new Drawflow + start()，避免容器无尺寸时初始化。
@@ -1959,26 +2322,621 @@ const CANVAS = {
   runMap: {}, // runId → nodeId 映射（流式渐进预览用）
   refImages: {}, // 图片节点参考图缓存：{ [nodeId]: dataURL }（图生图，运行时传图床换外链）
   videoMaterials: {}, // 视频节点素材缓存：{ [nodeId]: { first?, last?, refs:[] } }（dataURL，运行时传图床）
+  quickAddPos: null, // 双击空白处弹出菜单时记录的画布坐标
   progressBound: false, // onCanvasProgress 是否已订阅（幂等）
+  portResizeObserver: null, // 预览框尺寸变化时同步端口位置
+  openConfigEl: null, // 当前展开参数配置的紧凑节点
+  openPopEl: null, // 当前展开的 details 参数弹层
+  portRefreshRAF: 0, // 全量端口刷新 rAF 合并锁
+  portRefreshNodeRAFs: {}, // 单节点端口刷新 rAF 合并锁
+  portResizeQueue: new Set(), // ResizeObserver 收集后统一刷新
+  portResizeRAF: 0,
+  portResizeTimer: 0,
+  dragStart: null, // 节点拖动阈值判断，避免拖动结束误触发配置展开
+  dragSuppressClick: false,
+  dragEndTimer: 0,
+  workspaceId: "",
+  workspaceName: "未命名画布",
+  workspaceReady: false,
+  workspaceRestoring: false,
+  workspaceSaveTimer: 0,
+  workspaceSaving: false,
+  workspaceResave: false,
+  workspaceSavePromise: null,
+  workspaceLoading: false,
+  workspaceList: [],
+  workspaceRenamingId: "",
+  outputRefs: {}, // { [nodeId]: { kind, assetId, sourceUrl?, meta? } }，本地媒体引用
+  materialRefs: {}, // 上传的参考图 / 首尾帧 / 多参考素材引用
+  mediaCacheQueue: Promise.resolve(), // 多参考图批量上传时串行修改同一项目存档
 };
 
+function cvQueueMediaCache(payload) {
+  const run = () => apic.canvasMediaCache(payload);
+  CANVAS.mediaCacheQueue = CANVAS.mediaCacheQueue.then(run, run);
+  return CANVAS.mediaCacheQueue;
+}
+
+function cvWorkspaceTitle() {
+  const el = document.getElementById("cv-projects-btn");
+  if (el) el.textContent = CANVAS.workspaceName || "未命名画布";
+}
+
+function cvControlKey(el, index) {
+  const classes = Array.from(el.classList || []).filter((name) => name.startsWith("cv-")).sort().join(".");
+  return `${el.tagName}:${classes}:${el.dataset.slot || ""}:${index}`;
+}
+
+function cvCaptureNodeState() {
+  const out = {};
+  document.querySelectorAll("#drawflow .drawflow-node").forEach((nodeEl) => {
+    const id = nodeEl.id.replace("node-", "");
+    if (!id) return;
+    const fields = {};
+    Array.from(nodeEl.querySelectorAll("input, textarea, select")).forEach((el, index) => {
+      if (el.type === "file") return;
+      fields[cvControlKey(el, index)] = el.value;
+    });
+    out[id] = { fields };
+  });
+  return out;
+}
+
+function cvApplyNodeState(nodeEl, state) {
+  if (!nodeEl || !state || !state.fields) return;
+  Array.from(nodeEl.querySelectorAll("input, textarea, select")).forEach((el, index) => {
+    if (el.type === "file") return;
+    const value = state.fields[cvControlKey(el, index)];
+    if (value === undefined) return;
+    if (el.tagName === "SELECT" && value && !Array.from(el.options).some((option) => option.value === value)) {
+      const option = document.createElement("option");
+      option.value = value;
+      option.textContent = value + "（上次使用）";
+      el.appendChild(option);
+    }
+    el.value = value;
+  });
+  cvSyncVideoMode(nodeEl);
+  cvUpdateParamSummary(nodeEl);
+}
+
+function cvWorkspaceSnapshot() {
+  const ed = CANVAS.editor;
+  if (!ed || !CANVAS.workspaceId) return null;
+  let drawflow;
+  try { drawflow = ed.export(); } catch { return null; }
+  return {
+    id: CANVAS.workspaceId,
+    name: CANVAS.workspaceName,
+    canvas: {
+      drawflow,
+      module: ed.module || "Home",
+      zoom: ed.zoom || 1,
+      canvasX: ed.canvas_x || 0,
+      canvasY: ed.canvas_y || 0,
+      addCount: CANVAS.addCount || 0,
+    },
+    nodeState: cvCaptureNodeState(),
+    outputs: CANVAS.outputRefs,
+    materials: CANVAS.materialRefs,
+  };
+}
+
+function cvScheduleAutosave() {
+  if (!CANVAS.workspaceReady || CANVAS.workspaceRestoring || !CANVAS.workspaceId) return;
+  clearTimeout(CANVAS.workspaceSaveTimer);
+  CANVAS.workspaceSaveTimer = setTimeout(() => cvSaveWorkspace(), 700);
+}
+
+async function cvSaveWorkspace() {
+  clearTimeout(CANVAS.workspaceSaveTimer);
+  CANVAS.workspaceSaveTimer = 0;
+  if (!apic.canvasWorkspaceSave) return;
+  if (CANVAS.workspaceSaving) {
+    CANVAS.workspaceResave = true;
+    return CANVAS.workspaceSavePromise;
+  }
+  CANVAS.workspaceSaving = true;
+  CANVAS.workspaceSavePromise = (async () => {
+    try {
+      do {
+        CANVAS.workspaceResave = false;
+        await CANVAS.mediaCacheQueue;
+        const snapshot = cvWorkspaceSnapshot();
+        if (!snapshot) return;
+        const r = await apic.canvasWorkspaceSave(snapshot);
+        if (!r || !r.ok) throw new Error((r && r.error) || "本地画布保存失败");
+        CANVAS.workspaceName = r.workspace.name || CANVAS.workspaceName;
+        cvWorkspaceTitle();
+      } while (CANVAS.workspaceResave);
+    } catch (e) {
+      console.warn("canvas autosave failed", e);
+    } finally {
+      CANVAS.workspaceSaving = false;
+      CANVAS.workspaceSavePromise = null;
+    }
+  })();
+  return CANVAS.workspaceSavePromise;
+}
+
+function cvWorkspaceNameForNow() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `画布 ${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+async function cvRestoreOutputs() {
+  const entries = Object.entries(CANVAS.outputRefs || {});
+  await Promise.all(entries.map(async ([nodeId, ref]) => {
+    if (!ref || !ref.assetId || !apic.canvasMediaRead) return;
+    try {
+      const r = await apic.canvasMediaRead({ workspaceId: CANVAS.workspaceId, assetId: ref.assetId });
+      if (!r || !r.ok || !r.dataUrl) return;
+      const nodeEl = document.getElementById(`node-${nodeId}`);
+      if (!nodeEl) return;
+      const host = cvResultHost(nodeEl, ref.kind);
+      cvRenderResult(ref.kind, host, { dataUrl: r.dataUrl, url: ref.sourceUrl || "", meta: ref.meta || {} });
+      if (ref.kind === "image") CANVAS.outputs[nodeId] = { image: r.dataUrl };
+    } catch (e) {
+      console.warn("canvas media restore failed", e);
+    }
+  }));
+}
+
+async function cvReadAsset(assetId) {
+  if (!assetId || !apic.canvasMediaRead) return "";
+  const r = await apic.canvasMediaRead({ workspaceId: CANVAS.workspaceId, assetId });
+  return r && r.ok ? r.dataUrl || "" : "";
+}
+
+async function cvRestoreMaterials() {
+  const entries = Object.entries(CANVAS.materialRefs || {});
+  await Promise.all(entries.map(async ([nodeId, refs]) => {
+    const nodeEl = document.getElementById(`node-${nodeId}`);
+    if (!nodeEl || !refs) return;
+    try {
+      if (refs.image && refs.image.assetId) {
+        const dataUrl = await cvReadAsset(refs.image.assetId);
+        if (dataUrl) {
+          CANVAS.refImages[nodeId] = dataUrl;
+          const thumb = nodeEl.querySelector(".cv-refimg-thumb");
+          if (thumb) { thumb.src = dataUrl; thumb.classList.remove("hidden"); }
+          nodeEl.querySelector(".cv-refimg-clear")?.classList.remove("hidden");
+          const frame = nodeEl.querySelector(".cv-image-frame .cv-video-frame-inner");
+          if (frame && !CANVAS.outputRefs[nodeId]) frame.innerHTML = cvPreviewChrome("image", dataUrl, "", '<div class="cv-meta">参考图 · 本地缓存</div>');
+        }
+      }
+      const mats = (CANVAS.videoMaterials[nodeId] = { refs: [] });
+      for (const slot of ["first", "last"]) {
+        if (!refs[slot] || !refs[slot].assetId) continue;
+        const dataUrl = await cvReadAsset(refs[slot].assetId);
+        if (!dataUrl) continue;
+        mats[slot] = dataUrl;
+        const thumb = nodeEl.querySelector(`.cv-vmat-thumb[data-slot="${slot}"]`);
+        if (thumb) { thumb.src = dataUrl; thumb.classList.remove("hidden"); }
+        nodeEl.querySelector(`.cv-vmat-clear[data-slot="${slot}"]`)?.classList.remove("hidden");
+      }
+      if (Array.isArray(refs.refs)) {
+        const list = await Promise.all(refs.refs.map((item) => cvReadAsset(item.assetId)));
+        mats.refs = list.filter(Boolean);
+        const box = nodeEl.querySelector(".cv-vmat-refs-thumbs");
+        if (box) {
+          box.innerHTML = mats.refs.map((src) => `<img src="${src}" alt="参考图" style="max-width:40px;max-height:40px;border-radius:4px;object-fit:cover;margin:2px">`).join("");
+        }
+        if (mats.refs.length) nodeEl.querySelector('.cv-vmat-clear[data-slot="refs"]')?.classList.remove("hidden");
+      }
+    } catch (e) {
+      console.warn("canvas material restore failed", e);
+    }
+  }));
+}
+
+async function cvApplyWorkspace(workspace) {
+  const ed = CANVAS.editor;
+  if (!ed || !workspace) return;
+  CANVAS.workspaceRestoring = true;
+  try {
+    CANVAS.workspaceId = workspace.id;
+    CANVAS.workspaceName = workspace.name || "未命名画布";
+    CANVAS.outputs = {};
+    CANVAS.outputRefs = workspace.outputs && typeof workspace.outputs === "object" ? workspace.outputs : {};
+    CANVAS.materialRefs = workspace.materials && typeof workspace.materials === "object" ? workspace.materials : {};
+    CANVAS.refImages = {};
+    CANVAS.videoMaterials = {};
+    const canvas = workspace.canvas || {};
+    const drawflow = canvas.drawflow && canvas.drawflow.drawflow ? canvas.drawflow : { drawflow: { Home: { data: {} } } };
+    // 存档只继承拓扑/位置/数据；节点 HTML 使用当前版本模板，避免热更新后旧画布卡在旧 UI。
+    Object.values(drawflow.drawflow || {}).forEach((moduleData) => {
+      Object.values((moduleData && moduleData.data) || {}).forEach((node) => {
+        if (node && CV_NODES[node.name]) {
+          node.html = cvNodeHTML(node.name);
+          node.class = `cv-df-${node.name}`;
+        }
+      });
+    });
+    ed.import(drawflow);
+    ed.module = canvas.module && drawflow.drawflow[canvas.module] ? canvas.module : "Home";
+    CANVAS.addCount = Number(canvas.addCount) || 0;
+    ed.zoom = Number(canvas.zoom) || 1;
+    ed.canvas_x = Number(canvas.canvasX) || 0;
+    ed.canvas_y = Number(canvas.canvasY) || 0;
+    ed.zoom_last_value = ed.zoom;
+    ed.precanvas.style.transform = `translate(${ed.canvas_x}px, ${ed.canvas_y}px) scale(${ed.zoom})`;
+    Object.keys(cvAllNodes()).forEach((id) => {
+      cvSetupNode(id);
+      cvApplyNodeState(document.getElementById(`node-${id}`), (workspace.nodeState || {})[id]);
+    });
+    cvWorkspaceTitle();
+    cvSyncZoomControls(true);
+    cvUpdateEmptyHint();
+    cvRefreshAllNodePorts();
+    await cvRestoreMaterials();
+    await cvRestoreOutputs();
+  } finally {
+    CANVAS.workspaceRestoring = false;
+    CANVAS.workspaceReady = true;
+  }
+}
+
+async function cvCreateWorkspace() {
+  if (!apic.canvasWorkspaceCreate) throw new Error("画布本地存储能力未就绪，请先热更新");
+  await cvSaveWorkspace();
+  const r = await apic.canvasWorkspaceCreate(cvWorkspaceNameForNow());
+  if (!r || !r.ok) throw new Error((r && r.error) || "新建画布失败");
+  await cvApplyWorkspace(r.workspace);
+  cvCloseWorkspacePicker();
+  toast("已新建画布，编辑内容会自动保存到本机", "ok");
+}
+
+function cvWorkspaceTime(value) {
+  const date = new Date(value || 0);
+  return Number.isNaN(date.getTime()) ? "刚刚保存" : date.toLocaleString();
+}
+
+function cvRenderWorkspaceList() {
+  const list = document.getElementById("cv-project-list");
+  if (!list) return;
+  const items = CANVAS.workspaceList || [];
+  if (!items.length) {
+    list.innerHTML = '<div class="cv-project-empty">还没有画布记录，新建一个开始创作。</div>';
+    return;
+  }
+  document.getElementById("cv-project-close")?.classList.toggle("hidden", !CANVAS.workspaceReady);
+  list.innerHTML = items.map((item) => {
+    const renaming = item.id === CANVAS.workspaceRenamingId;
+    return `
+    <div class="cv-project-item ${item.id === CANVAS.workspaceId ? "active" : ""}">
+      <div class="cv-project-info">${renaming
+        ? `<input class="cv-project-title-input" type="text" maxlength="60" value="${esc(item.name || "未命名画布")}" data-cv-rename-input="${esc(item.id)}" aria-label="画布名称" />`
+        : `<div class="cv-project-title">${esc(item.name || "未命名画布")}</div>`}
+      <div class="cv-project-meta">${esc(cvWorkspaceTime(item.updatedAt))} · ${Number(item.nodeCount) || 0} 个节点 · ${Number(item.mediaCount) || 0} 个本地素材</div></div>
+      <div class="cv-project-item-actions">
+        ${renaming
+          ? `<button class="cv-project-icon ok" type="button" data-cv-rename-save="${esc(item.id)}" title="保存名称" aria-label="保存名称">✓</button>
+             <button class="cv-project-icon" type="button" data-cv-rename-cancel title="取消改名" aria-label="取消改名">×</button>`
+          : `<button class="cv-project-icon" type="button" data-cv-rename-start="${esc(item.id)}" title="修改画布名称" aria-label="修改画布名称">✎</button>
+             <button class="btn small ghost cv-project-open" type="button" data-cv-workspace-id="${esc(item.id)}">${item.id === CANVAS.workspaceId ? "当前画布" : "继续"}</button>`}
+      </div>
+    </div>`;
+  }).join("");
+  const input = list.querySelector("[data-cv-rename-input]");
+  if (input) { input.focus(); input.select(); }
+}
+
+async function cvRenameWorkspace(id) {
+  const input = document.querySelector(`[data-cv-rename-input="${id}"]`);
+  const name = input ? input.value.trim() : "";
+  if (!name) {
+    toast("画布名称不能为空", "err");
+    input?.focus();
+    return;
+  }
+  const r = await apic.canvasWorkspaceRename(id, name);
+  if (!r || !r.ok) throw new Error((r && r.error) || "画布改名失败");
+  const item = CANVAS.workspaceList.find((entry) => entry.id === id);
+  if (item) Object.assign(item, r.workspace);
+  if (CANVAS.workspaceId === id) {
+    CANVAS.workspaceName = r.workspace.name;
+    cvWorkspaceTitle();
+  }
+  CANVAS.workspaceRenamingId = "";
+  cvRenderWorkspaceList();
+  toast("画布名称已修改", "ok");
+}
+
+async function cvOpenWorkspacePicker() {
+  const picker = document.getElementById("cv-project-picker");
+  if (!picker) return;
+  try {
+    const r = await apic.canvasWorkspaces();
+    CANVAS.workspaceList = r && r.ok && Array.isArray(r.workspaces) ? r.workspaces : [];
+  } catch (e) {
+    CANVAS.workspaceList = [];
+  }
+  cvRenderWorkspaceList();
+  picker.classList.remove("hidden");
+}
+
+function cvCloseWorkspacePicker() {
+  if (!CANVAS.workspaceReady) return;
+  document.getElementById("cv-project-picker")?.classList.add("hidden");
+}
+
+async function cvLoadWorkspace(id) {
+  if (!id || id === CANVAS.workspaceId) return cvCloseWorkspacePicker();
+  await cvSaveWorkspace();
+  const r = await apic.canvasWorkspaceLoad(id);
+  if (!r || !r.ok) throw new Error((r && r.error) || "读取画布记录失败");
+  await cvApplyWorkspace(r.workspace);
+  cvCloseWorkspacePicker();
+  toast("已恢复画布记录和本地生成素材", "ok");
+}
+
+async function cvCacheOutput(nodeId, kind, result, context) {
+  const workspaceId = (context && context.workspaceId) || CANVAS.workspaceId;
+  if (!workspaceId || !result || !result.dataUrl || !apic.canvasMediaCache) return;
+  const r = await cvQueueMediaCache({
+    workspaceId, nodeId, kind, dataUrl: result.dataUrl, role: "output",
+    sourceUrl: result.url || "", meta: result.meta || {},
+    workspaceState: CANVAS.workspaceId === workspaceId ? cvWorkspaceSnapshot() : null,
+  });
+  if (!r || !r.ok) throw new Error((r && r.error) || "生成结果本地缓存失败");
+  if (CANVAS.workspaceId !== workspaceId) return;
+  const previous = CANVAS.outputRefs[nodeId];
+  const history = previous && Array.isArray(previous.history) ? previous.history.slice() : [];
+  if (previous && previous.assetId && previous.assetId !== r.assetId) {
+    history.push({ ...previous, history: undefined });
+  }
+  CANVAS.outputRefs[nodeId] = {
+    kind, assetId: r.assetId, sourceUrl: result.url || "", meta: result.meta || {},
+    cachedAt: new Date().toISOString(), history,
+  };
+  await cvSaveWorkspace();
+}
+
+async function cvCacheMaterial(nodeId, slot, dataUrl, context) {
+  const workspaceId = (context && context.workspaceId) || CANVAS.workspaceId;
+  if (!workspaceId || !dataUrl || !apic.canvasMediaCache) return;
+  try {
+    const r = await cvQueueMediaCache({
+      workspaceId, nodeId, kind: "image", dataUrl, role: "material", slot,
+      workspaceState: (context && context.workspaceState) || cvWorkspaceSnapshot(),
+    });
+    if (!r || !r.ok) throw new Error((r && r.error) || "素材缓存失败");
+    if (CANVAS.workspaceId !== workspaceId) return;
+    const refs = (CANVAS.materialRefs[nodeId] = CANVAS.materialRefs[nodeId] || { refs: [] });
+    const value = { assetId: r.assetId };
+    if (slot === "refs") refs.refs = (refs.refs || []).concat(value);
+    else refs[slot] = value;
+    cvScheduleAutosave();
+  } catch (e) {
+    toast("参考素材本地缓存失败：" + (e.message || e), "err");
+  }
+}
+
 // 4 类节点的元信息：标题 / 图标 / 输入端口数 / 输出端口数 / 角标
 const CV_NODES = {
   text: { title: "文本 / 提示词", icon: "📝", inputs: 0, outputs: 1, tag: "" },
   image: { title: "文生图", icon: "🖼️", inputs: 1, outputs: 1, tag: "" },
-  video: { title: "Seedance 2.0", icon: "🎬", inputs: 1, outputs: 0, tag: "2.0" },
+  video: { title: "Seedance 视频", icon: "🎬", inputs: 1, outputs: 0, tag: "V1/V2" },
   grokVideo: { title: "Grok 视频", icon: "🎞️", inputs: 1, outputs: 0, tag: "Grok" },
   tts: { title: "TTS 配音", icon: "🔊", inputs: 1, outputs: 0, tag: "" },
 };
 
+function cvCompactVideoBody(kind) {
+  const isGrok = kind === "grokVideo";
+  const title = isGrok ? "Grok 视频" : "视频";
+  const modelHint = isGrok ? "Grok 模型" : "Seedance / V2 模型";
+  const resolutionOptions = isGrok
+    ? `<option value="720p">720p</option><option value="1080p">1080p</option><option value="480p">480p</option>`
+    : `<option value="720p">720p</option><option value="1080p">1080p</option><option value="2k">2K（需上游支持）</option><option value="4k">4K（需上游支持）</option><option value="480p">480p</option>`;
+  const ratioOptions = isGrok
+    ? `<option value="16:9">16:9</option><option value="9:16">9:16</option><option value="4:3">4:3</option><option value="3:4">3:4</option><option value="2:3">2:3</option><option value="3:2">3:2</option><option value="1:1">1:1</option>`
+    : `<option value="16:9">16:9</option><option value="9:16">9:16</option><option value="1:1">1:1</option><option value="4:3">4:3</option>`;
+  return `
+    <div class="cv-video-compact">
+      <div class="cv-video-label"><span>▦</span>${title}</div>
+      <div class="cv-video-frame" data-port-anchor>
+        <div class="cv-video-frame-inner">▣</div>
+      </div>
+      <div class="cv-video-foot">
+        <span>参考图 0 张(连线 / @ 同步)</span>
+        <b>待定</b>
+      </div>
+      <div class="cv-video-composer">
+        <div class="cv-video-compose-tools">
+          <span>↖</span>
+          <span>＋</span>
+          <span class="cv-video-expand">⛶</span>
+        </div>
+        <textarea class="cv-field cv-field-prompt cv-video-prompt" rows="2" placeholder="描述任何你想要生成的内容"></textarea>
+        <div class="cv-video-chip-row">
+          <select class="cv-field cv-field-group cv-chip-select" title="中转分组"></select>
+          <select class="cv-field cv-field-model cv-chip-select" title="${modelHint}"><option value="">${modelHint}</option></select>
+          <button class="cv-fetch-models cv-chip-action" title="拉取该分组的模型">拉取</button>
+          <details class="cv-video-pop">
+            <summary>文生 · 16:9 · 720p · 5s</summary>
+            <div class="cv-video-pop-body">
+              <label>生成方式<select class="cv-field cv-field-vmode" title="模式">
+                <option value="text">文生视频</option>
+                <option value="first">首帧图生视频</option>
+                <option value="reference">多参考图</option>
+                ${isGrok ? "" : '<option value="firstlast">双图参考</option>'}
+              </select></label>
+              <label>比例<select class="cv-field cv-field-ratio" title="比例">${ratioOptions}</select></label>
+              <label>清晰度<select class="cv-field cv-field-vsize" title="分辨率">
+                ${resolutionOptions}
+              </select></label>
+              <label>时长<select class="cv-field cv-field-duration" title="时长">
+                <option value="5">5s</option><option value="6">6s</option><option value="8">8s</option>
+                <option value="10">10s</option><option value="15">15s</option>
+              </select></label>
+              <label>运镜<select class="cv-field cv-field-vquality" title="画质">
+                <option value="auto">自动</option><option value="hd">高清</option>
+              </select></label>
+              <label class="cv-pop-wide">高级<input class="cv-field cv-field-endpoint" placeholder="/v1/videos" /></label>
+              <select class="cv-field cv-field-refsource hidden" title="多参考图字段">
+                <option value="images">images</option>
+                <option value="ref_assets">ref_assets</option>
+              </select>
+              <button type="button" class="cv-pop-close">收起</button>
+            </div>
+          </details>
+          <button class="cv-run cv-send-run" title="生成">↑</button>
+        </div>
+        <div class="cv-video-materials">
+          <div class="cv-vmat cv-vmat-first hidden">
+            <label class="cv-refimg-pick" title="上传首帧图">首帧<input type="file" class="cv-vmat-file" data-slot="first" accept="image/*" hidden /></label>
+            <img class="cv-vmat-thumb hidden" data-slot="first" alt="首帧" />
+            <button type="button" class="cv-vmat-clear hidden" data-slot="first" title="移除">✕</button>
+            <input class="cv-field cv-vmat-url" data-slot="first" placeholder="公网首帧 URL；留空用上游图" />
+          </div>
+          <div class="cv-vmat cv-vmat-last hidden">
+            <label class="cv-refimg-pick" title="上传尾帧图">尾帧<input type="file" class="cv-vmat-file" data-slot="last" accept="image/*" hidden /></label>
+            <img class="cv-vmat-thumb hidden" data-slot="last" alt="尾帧" />
+            <button type="button" class="cv-vmat-clear hidden" data-slot="last" title="移除">✕</button>
+            <input class="cv-field cv-vmat-url" data-slot="last" placeholder="公网尾帧 URL" />
+          </div>
+          <div class="cv-vmat cv-vmat-refs hidden">
+            <label class="cv-refimg-pick" title="上传多张参考图">参考图<input type="file" class="cv-vmat-file" data-slot="refs" accept="image/*" multiple hidden /></label>
+            <button type="button" class="cv-vmat-clear hidden" data-slot="refs" title="清空">✕</button>
+            <div class="cv-vmat-refs-thumbs"></div>
+            <textarea class="cv-field cv-vmat-urls" data-slot="refs" rows="2" placeholder="可选：每行一个公网图片URL"></textarea>
+          </div>
+        </div>
+        <div class="cv-node-err hidden"></div>
+        <div class="cv-node-preview hidden"></div>
+      </div>
+    </div>`;
+}
+
+function cvCompactImageBody() {
+  return `
+    <div class="cv-video-compact cv-image-compact">
+      <div class="cv-video-label"><span>▧</span>图片</div>
+      <div class="cv-video-frame cv-image-frame" data-port-anchor>
+        <div class="cv-video-frame-inner">▧</div>
+      </div>
+      <div class="cv-video-foot">
+        <span>参考图 0 张(连线 / @ 同步)</span>
+        <b>待定</b>
+      </div>
+      <div class="cv-video-composer">
+        <div class="cv-video-compose-tools">
+          <span>↖</span>
+          <span>＋</span>
+          <span class="cv-video-expand">⛶</span>
+        </div>
+        <textarea class="cv-field cv-field-prompt cv-video-prompt" rows="2" placeholder="描述任何你想要生成的画面"></textarea>
+        <div class="cv-video-chip-row">
+          <select class="cv-field cv-field-group cv-chip-select" title="中转分组"></select>
+          <input class="cv-field cv-field-model cv-chip-select" placeholder="图片模型" />
+          <button class="cv-fetch-models cv-chip-action" title="拉取该分组的模型">拉取</button>
+          <datalist class="cv-node-datalist"></datalist>
+          <details class="cv-video-pop">
+            <summary>1:1 · 1K</summary>
+            <div class="cv-video-pop-body">
+              <label>比例<select class="cv-field cv-field-ratio" title="比例">
+                <option value="1:1">1:1</option><option value="16:9">16:9</option><option value="9:16">9:16</option>
+                <option value="4:3">4:3</option><option value="3:4">3:4</option><option value="3:2">3:2</option>
+              </select></label>
+              <label>清晰度<select class="cv-field cv-field-quality" title="清晰度">
+                <option value="1K">1K</option><option value="2K">2K</option><option value="4K">4K</option>
+              </select></label>
+              <label class="cv-pop-wide">接口<input class="cv-field cv-field-endpoint" placeholder="/v1/images/generations" /></label>
+              <label class="cv-pop-wide">参考字段<input class="cv-field cv-field-reffield" placeholder="image" /></label>
+              <div class="cv-refimg-row">
+                <label class="cv-refimg-pick" title="上传参考图">参考图<input type="file" class="cv-field-refimg" accept="image/*" hidden /></label>
+                <img class="cv-refimg-thumb hidden" alt="参考图" />
+                <button type="button" class="cv-refimg-clear hidden" title="移除参考图">✕</button>
+              </div>
+              <button type="button" class="cv-pop-close">收起</button>
+            </div>
+          </details>
+          <button class="cv-run cv-send-run" title="生成">↑</button>
+        </div>
+        <div class="cv-node-err hidden"></div>
+        <div class="cv-node-preview hidden"></div>
+      </div>
+    </div>`;
+}
+
+function cvCompactTtsBody() {
+  return `
+    <div class="cv-video-compact cv-tts-compact">
+      <div class="cv-video-label"><span>♪</span>音频</div>
+      <div class="cv-video-frame cv-audio-frame" data-port-anchor>
+        <div class="cv-video-frame-inner">♪</div>
+      </div>
+      <div class="cv-video-foot">
+        <span>连接文本 / 手动输入</span>
+        <b>待定</b>
+      </div>
+      <div class="cv-video-composer">
+        <div class="cv-video-compose-tools">
+          <span>↖</span>
+          <span>＋</span>
+          <span class="cv-video-expand">⛶</span>
+        </div>
+        <textarea class="cv-field cv-field-prompt cv-video-prompt" rows="2" placeholder="输入要配音的文本，或连接上游文本节点"></textarea>
+        <div class="cv-video-chip-row">
+          <select class="cv-field cv-field-group cv-chip-select" title="中转分组"></select>
+          <input class="cv-field cv-field-model cv-chip-select" placeholder="TTS 模型" />
+          <button class="cv-fetch-models cv-chip-action" title="拉取该分组的模型">拉取</button>
+          <datalist class="cv-node-datalist"></datalist>
+          <details class="cv-video-pop">
+            <summary>alloy · mp3</summary>
+            <div class="cv-video-pop-body">
+              <label>音色<select class="cv-field cv-field-voice" title="音色">
+                <option value="alloy">alloy</option><option value="nova">nova</option><option value="shimmer">shimmer</option>
+                <option value="echo">echo</option><option value="fable">fable</option><option value="onyx">onyx</option>
+              </select></label>
+              <label>格式<select class="cv-field cv-field-format" title="格式">
+                <option value="mp3">mp3</option><option value="wav">wav</option><option value="opus">opus</option>
+              </select></label>
+              <button type="button" class="cv-pop-close">收起</button>
+            </div>
+          </details>
+          <button class="cv-run cv-send-run" title="生成">↑</button>
+        </div>
+        <div class="cv-node-err hidden"></div>
+        <div class="cv-node-preview hidden"></div>
+      </div>
+    </div>`;
+}
+
+function cvCompactTextBody() {
+  return `
+    <div class="cv-video-compact cv-text-compact">
+      <div class="cv-video-label"><span>T</span>文本</div>
+      <div class="cv-video-frame cv-text-frame" data-port-anchor>
+        <div class="cv-video-frame-inner">T</div>
+      </div>
+      <div class="cv-video-foot">
+        <span>作为输入源输出文本</span>
+        <b>文本</b>
+      </div>
+      <div class="cv-video-composer">
+        <div class="cv-video-compose-tools">
+          <span>↖</span>
+          <span>＋</span>
+        </div>
+        <textarea class="cv-field cv-field-prompt cv-video-prompt" rows="3" placeholder="输入文本 / 提示词，连线到下游节点作为输入"></textarea>
+        <div class="cv-node-hint">作为输入源，实时输出上面的文本</div>
+      </div>
+    </div>`;
+}
+
 // 各类节点的表单主体（Drawflow 以 HTML 字符串注入到 .drawflow_content_node）
 function cvNodeBody(kind) {
   if (kind === "text") {
+    return cvCompactTextBody();
     return `
       <textarea class="cv-field cv-field-prompt" rows="4" placeholder="输入文本 / 提示词，连线到下游节点作为输入…"></textarea>
       <div class="cv-node-hint">作为输入源，实时输出上面的文本</div>`;
   }
   if (kind === "image") {
+    return cvCompactImageBody();
     return `
       <textarea class="cv-field cv-field-prompt" rows="3" placeholder="提示词（可留空，将取上游文本节点）"></textarea>
       <div class="cv-refimg-row">
@@ -2019,6 +2977,7 @@ function cvNodeBody(kind) {
       <div class="cv-node-preview hidden"></div>`;
   }
   if (kind === "video") {
+    return cvCompactVideoBody("video");
     return `
       <select class="cv-field cv-field-vmode" title="模式">
         <option value="first">图生视频 · 首帧图</option>
@@ -2076,7 +3035,7 @@ function cvNodeBody(kind) {
           <option value="15">15s</option>
         </select>
       </div>
-      <div class="cv-node-hint">CLMM 文档接口：模型名、时长和参考图按上游能力校验</div>
+      <div class="cv-node-hint">支持 Seedance / Seedance V2：切换分组后自动匹配接口</div>
       <details class="cv-adv"><summary>⚙️ 高级</summary>
         <input class="cv-field cv-field-endpoint" placeholder="/v1/videos" />
         <select class="cv-field cv-field-refsource" title="多参考图字段">
@@ -2089,6 +3048,7 @@ function cvNodeBody(kind) {
       <div class="cv-node-preview hidden"></div>`;
   }
   if (kind === "grokVideo") {
+    return cvCompactVideoBody("grokVideo");
     return `
       <select class="cv-field cv-field-vmode" title="模式">
         <option value="text">文生视频</option>
@@ -2151,6 +3111,7 @@ function cvNodeBody(kind) {
       <div class="cv-node-preview hidden"></div>`;
   }
   if (kind === "tts") {
+    return cvCompactTtsBody();
     return `
       <textarea class="cv-field cv-field-prompt" rows="3" placeholder="要配音的文本（可留空，取上游文本节点）"></textarea>
       <select class="cv-field cv-field-group" title="中转分组"></select>
@@ -2195,6 +3156,35 @@ function cvNodeHTML(kind) {
     </div>`;
 }
 
+function cvCloseConfig(compact) {
+  const box = compact || CANVAS.openConfigEl;
+  if (!box) return;
+  box.classList.remove("cv-config-open");
+  box.closest(".drawflow-node")?.classList.remove("cv-node-config-open");
+  if (CANVAS.openConfigEl === box) CANVAS.openConfigEl = null;
+}
+
+function cvOpenConfig(compact) {
+  if (!compact) return;
+  if (CANVAS.openConfigEl && CANVAS.openConfigEl !== compact) cvCloseConfig(CANVAS.openConfigEl);
+  compact.classList.add("cv-config-open");
+  compact.closest(".drawflow-node")?.classList.add("cv-node-config-open");
+  CANVAS.openConfigEl = compact;
+}
+
+function cvCloseOpenPop(except) {
+  const pop = CANVAS.openPopEl;
+  if (!pop || pop === except) return;
+  pop.open = false;
+  if (CANVAS.openPopEl === pop) CANVAS.openPopEl = null;
+}
+
+function cvMarkCanvasDragging(on) {
+  const el = document.getElementById("drawflow");
+  if (!el) return;
+  el.classList.toggle("cv-dragging", !!on);
+}
+
 // 懒初始化 Drawflow（幂等）
 function cvInit() {
   if (CANVAS.inited) return;
@@ -2212,6 +3202,14 @@ function cvInit() {
   let selConn = null;
   editor.on("connectionSelected", (c) => { selConn = c; });
   editor.on("connectionUnselected", () => { selConn = null; });
+  editor.on("connectionStart", () => el.classList.add("cv-linking"));
+  editor.on("connectionCancel", () => el.classList.remove("cv-linking"));
+  editor.on("connectionCreated", () => { el.classList.remove("cv-linking"); cvScheduleAutosave(); });
+  editor.on("connectionRemoved", () => cvScheduleAutosave());
+  editor.on("nodeCreated", () => cvScheduleAutosave());
+  editor.on("nodeMoved", () => cvScheduleAutosave());
+  editor.on("translate", () => cvScheduleAutosave());
+  editor.on("mouseUp", () => el.classList.remove("cv-linking"));
   el.addEventListener("dblclick", (e) => {
     if (!e.target.closest(".connection")) return;
     if (selConn && CANVAS.editor) {
@@ -2231,14 +3229,131 @@ function cvInit() {
 
   // 节点删除时清理产物缓存 + 流式映射
   editor.on("nodeRemoved", (id) => {
+    if (CANVAS.openConfigEl?.closest(".drawflow-node")?.id === `node-${id}`) CANVAS.openConfigEl = null;
+    if (CANVAS.openPopEl?.closest(".drawflow-node")?.id === `node-${id}`) CANVAS.openPopEl = null;
     delete CANVAS.outputs[id];
     delete CANVAS.refImages[id];
     delete CANVAS.videoMaterials[id];
+    delete CANVAS.outputRefs[id];
     cvClearRunMapForNode(id);
+    cvUpdateEmptyHint();
+    cvScheduleAutosave();
   });
 
+  // 点击空白画布直接进入沉浸式全屏；点节点、连线、工具条则不触发
+  const panel = document.getElementById("tab-canvas");
+  const stage = panel ? panel.querySelector(".cv-stage") : null;
+  if (stage && !stage.dataset.fullscreenBound) {
+    stage.dataset.fullscreenBound = "1";
+    let blankDown = null;
+    stage.addEventListener("pointerdown", (e) => {
+      blankDown = { x: e.clientX, y: e.clientY };
+    });
+    stage.addEventListener("click", (e) => {
+      if (panel && panel.classList.contains("cv-fullscreen")) return;
+      if (!cvIsBlankCanvasClick(e)) return;
+      if (blankDown) {
+        const dx = e.clientX - blankDown.x;
+        const dy = e.clientY - blankDown.y;
+        if ((dx * dx + dy * dy) > 36) return;
+      }
+      cvToggleFull(true);
+    });
+    stage.addEventListener("dblclick", (e) => {
+      if (!cvIsBlankCanvasClick(e)) return;
+      e.preventDefault();
+      e.stopPropagation();
+      cvOpenQuickMenu(e.clientX, e.clientY);
+    });
+    const quickMenu = document.getElementById("cv-quick-menu");
+    if (quickMenu && !quickMenu.dataset.bound) {
+      quickMenu.dataset.bound = "1";
+      quickMenu.addEventListener("click", (e) => {
+        const btn = e.target.closest("[data-cv-quick-add]");
+        if (!btn) return;
+        cvAddNode(btn.dataset.cvQuickAdd, CANVAS.quickAddPos || undefined);
+        cvCloseQuickMenu();
+      });
+    }
+    el.addEventListener("pointerdown", (e) => {
+      const nodeEl = e.target.closest(".drawflow-node");
+      if (!nodeEl || e.button !== 0) {
+        CANVAS.dragStart = null;
+        return;
+      }
+      clearTimeout(CANVAS.dragEndTimer);
+      CANVAS.dragStart = { x: e.clientX, y: e.clientY, moved: false };
+      CANVAS.dragSuppressClick = false;
+    }, true);
+    el.addEventListener("pointermove", (e) => {
+      const start = CANVAS.dragStart;
+      if (!start) return;
+      const dx = e.clientX - start.x;
+      const dy = e.clientY - start.y;
+      if (!start.moved && (dx * dx + dy * dy) > 16) {
+        start.moved = true;
+        CANVAS.dragSuppressClick = true;
+        cvMarkCanvasDragging(true);
+      }
+    }, true);
+    document.addEventListener("pointerup", () => {
+      if (!CANVAS.dragStart) return;
+      CANVAS.dragStart = null;
+      clearTimeout(CANVAS.dragEndTimer);
+      CANVAS.dragEndTimer = setTimeout(() => {
+        CANVAS.dragSuppressClick = false;
+        cvMarkCanvasDragging(false);
+      }, 80);
+    }, true);
+    panel.addEventListener("click", (e) => {
+      if (!CANVAS.editor || !panel.classList.contains("active")) return;
+      const menu = document.getElementById("cv-quick-menu");
+      if (menu && !menu.classList.contains("hidden") && !e.target.closest("#cv-quick-menu")) cvCloseQuickMenu();
+
+      const compact = e.target.closest("#drawflow .cv-video-compact");
+      if (!e.target.closest(".cv-video-pop")) cvCloseOpenPop();
+      if (!compact) {
+        if (!e.target.closest("#cv-quick-menu, .cv-toolbar, .cv-zoom, .cv-tool-rail")) cvCloseConfig();
+        return;
+      }
+      if (CANVAS.openConfigEl && CANVAS.openConfigEl !== compact) cvCloseConfig(CANVAS.openConfigEl);
+      if (CANVAS.dragSuppressClick) return;
+      if (e.target.closest(".cv-video-composer, .cv-video-pop, .cv-preview-actions, button, input, textarea, select, label")) return;
+      cvOpenConfig(compact);
+    });
+    panel.addEventListener("toggle", (e) => {
+      const pop = e.target;
+      if (!pop || !pop.classList || !pop.classList.contains("cv-video-pop")) return;
+      if (pop.open) {
+        cvCloseOpenPop(pop);
+        CANVAS.openPopEl = pop;
+      } else if (CANVAS.openPopEl === pop) {
+        CANVAS.openPopEl = null;
+      }
+      const compact = pop.closest(".cv-video-compact");
+      if (compact) compact.classList.toggle("cv-pop-open", !!pop.open);
+    }, true);
+    panel.addEventListener("input", (e) => {
+      if (e.target.closest("#drawflow .cv-field")) cvScheduleAutosave();
+    });
+    panel.addEventListener("change", (e) => {
+      if (e.target.closest("#drawflow .cv-field")) cvScheduleAutosave();
+    });
+  }
+
   // 事件委托：点击节点内「运行」/「拉取模型」按钮
   el.addEventListener("click", (e) => {
+    const popClose = e.target.closest(".cv-pop-close");
+    if (popClose) {
+      const box = popClose.closest("details");
+      if (box) box.open = false;
+      const compact = popClose.closest(".cv-video-compact");
+      if (compact) {
+        compact.classList.remove("cv-pop-open");
+        cvCloseConfig(compact);
+      }
+      return;
+    }
     const runBtn = e.target.closest(".cv-run");
     if (runBtn) {
       const nodeEl = runBtn.closest(".drawflow-node");
@@ -2247,12 +3362,12 @@ function cvInit() {
     }
     const openPreviewBtn = e.target.closest(".cv-preview-open");
     if (openPreviewBtn) {
-      cvOpenPreview(openPreviewBtn.closest(".cv-node-preview"));
+      cvOpenPreview(openPreviewBtn.closest(".cv-node-preview, .cv-video-frame-inner"));
       return;
     }
     const downloadPreviewBtn = e.target.closest(".cv-preview-download");
     if (downloadPreviewBtn) {
-      cvDownloadPreview(downloadPreviewBtn.closest(".cv-node-preview"));
+      cvDownloadPreview(downloadPreviewBtn.closest(".cv-node-preview, .cv-video-frame-inner"));
       return;
     }
     const fetchBtn = e.target.closest(".cv-fetch-models");
@@ -2300,49 +3415,63 @@ function cvInit() {
       if (nodeEl) cvOnVideoMatPicked(nodeEl, vmatFile.dataset.slot, vmatFile.files);
     }
   });
+  el.addEventListener("change", (e) => {
+    const nodeEl = e.target.closest(".drawflow-node");
+    if (nodeEl && e.target.closest(".cv-video-pop")) cvUpdateParamSummary(nodeEl);
+  });
 
   // 缩放变化（按钮 / Ctrl+滚轮）→ 同步右下角百分比
   editor.on("zoom", cvUpdateZoomLabel);
+  window.addEventListener("resize", cvRefreshAllNodePorts);
+  requestAnimationFrame(cvRefreshAllNodePorts);
 
-  // 普通鼠标滚轮直接缩放（无需 Ctrl）；Ctrl+滚轮仍走 Drawflow 原生。
+  // 普通鼠标滚轮直接缩放（无需 Ctrl）；Ctrl+滚轮也统一走这里，避免原生步进越界。
   // 用 rAF 把「一次滚动的多次事件」合并成每帧一次，避免一帧内多写 transform / 多次 dispatch。
   let wheelAccum = 0;
   let wheelRAF = 0;
   el.addEventListener(
     "wheel",
     (e) => {
-      if (e.ctrlKey) return; // 交给 Drawflow 原生（含 Mac 触控板捏合）
       e.preventDefault();
+      e.stopImmediatePropagation();
       if (!CANVAS.editor) return;
       wheelAccum += e.deltaY;
       if (wheelRAF) return; // 一帧内只处理一次
       wheelRAF = requestAnimationFrame(() => {
         wheelRAF = 0;
         const STEP = 100;
-        let steps = Math.trunc(wheelAccum / STEP);
+        const steps = Math.trunc(wheelAccum / STEP);
         wheelAccum -= steps * STEP;
-        while (steps < 0) { CANVAS.editor.zoom_in(); steps++; }
-        while (steps > 0) { CANVAS.editor.zoom_out(); steps--; }
-        // label 由 editor.on("zoom") 自动同步，无需手动调用
+        if (steps) cvSetZoomPercent(cvZoomPercent() - steps * 5);
       });
     },
-    { passive: false }
+    { passive: false, capture: true }
   );
 
-  // 首次进入即预置一条「连好线、可直接运行」的示例工作流
-  cvSeedSample();
+  cvUpdateEmptyHint();
 }
 
 // 刷新右下角缩放百分比显示
 function cvUpdateZoomLabel() {
-  const el = document.getElementById("cv-zoom-reset");
-  if (el && CANVAS.editor) el.textContent = Math.round((CANVAS.editor.zoom || 1) * 100) + "%";
+  cvSyncZoomControls();
+}
+
+function cvIsBlankCanvasClick(e) {
+  const t = e.target;
+  if (!t || !t.closest) return false;
+  if (
+    t.closest(
+      ".drawflow-node, .parent-node, .input, .output, .cv-zoom, .cv-mask, .cv-toolbar, .cv-tool-rail, .cv-quick-menu, .cv-empty-hint, .modal, .connection, .point, .cv-field, .cv-preview-shell, .cv-node-preview, .cv-adv, .cv-refimg-pick, .cv-vmat, .drawflow-delete"
+    )
+  ) return false;
+  return !!t.closest(".cv-stage");
 }
 
 // 图片节点选了参考图（图生图）：读成 dataURL 存缓存 + 显示缩略图
 function cvOnRefImagePicked(nodeEl, file) {
   if (!file) return;
   const id = nodeEl.id.replace("node-", "");
+  const workspaceContext = { workspaceId: CANVAS.workspaceId, workspaceState: cvWorkspaceSnapshot() };
   const reader = new FileReader();
   reader.onload = () => {
     CANVAS.refImages[id] = reader.result; // dataURL
@@ -2353,14 +3482,30 @@ function cvOnRefImagePicked(nodeEl, file) {
     }
     const clr = nodeEl.querySelector(".cv-refimg-clear");
     if (clr) clr.classList.remove("hidden");
+    const frame = nodeEl.querySelector(".cv-image-frame .cv-video-frame-inner");
+    if (frame) {
+      const foot = '<div class="cv-meta">参考图 · 上传</div>';
+      frame.innerHTML = cvPreviewChrome("image", reader.result, "", foot);
+    }
+    cvCacheMaterial(id, "image", reader.result, workspaceContext);
+    cvScheduleAutosave();
   };
   reader.readAsDataURL(file);
 }
 
+function cvResetFramePlaceholder(nodeEl, kind, text) {
+  if (!nodeEl) return;
+  const frame = nodeEl.querySelector(".cv-video-frame-inner");
+  if (!frame) return;
+  const symbol = text || (kind === "image" ? "▧" : kind === "tts" ? "♪" : "▣");
+  frame.innerHTML = symbol;
+}
+
 // 清除图片节点参考图
 function cvClearRefImage(nodeEl) {
   const id = nodeEl.id.replace("node-", "");
   delete CANVAS.refImages[id];
+  if (CANVAS.materialRefs[id]) delete CANVAS.materialRefs[id].image;
   const thumb = nodeEl.querySelector(".cv-refimg-thumb");
   if (thumb) {
     thumb.src = "";
@@ -2370,6 +3515,8 @@ function cvClearRefImage(nodeEl) {
   if (clr) clr.classList.add("hidden");
   const inp = nodeEl.querySelector(".cv-field-refimg");
   if (inp) inp.value = "";
+  cvResetFramePlaceholder(nodeEl, "image");
+  cvScheduleAutosave();
 }
 
 // 视频节点选了素材（首帧/尾帧/多参考图）：读成 dataURL 存缓存 + 显示缩略图
@@ -2377,6 +3524,7 @@ function cvOnVideoMatPicked(nodeEl, slot, fileList) {
   const files = Array.from(fileList || []);
   if (!files.length) return;
   const id = nodeEl.id.replace("node-", "");
+  const workspaceContext = { workspaceId: CANVAS.workspaceId, workspaceState: cvWorkspaceSnapshot() };
   const store = (CANVAS.videoMaterials[id] = CANVAS.videoMaterials[id] || { refs: [] });
   if (slot === "refs") {
     store.refs = store.refs || [];
@@ -2394,6 +3542,8 @@ function cvOnVideoMatPicked(nodeEl, slot, fileList) {
         }
         const clr = nodeEl.querySelector('.cv-vmat-clear[data-slot="refs"]');
         if (clr) clr.classList.remove("hidden");
+        cvCacheMaterial(id, "refs", reader.result, workspaceContext);
+        cvScheduleAutosave();
       };
       reader.readAsDataURL(f);
     });
@@ -2410,6 +3560,13 @@ function cvOnVideoMatPicked(nodeEl, slot, fileList) {
     }
     const clr = nodeEl.querySelector(`.cv-vmat-clear[data-slot="${slot}"]`);
     if (clr) clr.classList.remove("hidden");
+    if (slot === "first" && nodeEl.querySelector(".cv-video-frame-inner")) {
+      const frame = nodeEl.querySelector(".cv-video-frame-inner");
+      const foot = '<div class="cv-meta">首帧 · 上传</div>';
+      frame.innerHTML = cvPreviewChrome("image", reader.result, "", foot);
+    }
+    cvCacheMaterial(id, slot, reader.result, workspaceContext);
+    cvScheduleAutosave();
   };
   reader.readAsDataURL(files[0]);
 }
@@ -2418,10 +3575,15 @@ function cvOnVideoMatPicked(nodeEl, slot, fileList) {
 function cvClearVideoMat(nodeEl, slot) {
   const id = nodeEl.id.replace("node-", "");
   const store = CANVAS.videoMaterials[id];
+  const refs = CANVAS.materialRefs[id];
   if (store) {
     if (slot === "refs") store.refs = [];
     else delete store[slot];
   }
+  if (refs) {
+    if (slot === "refs") refs.refs = [];
+    else delete refs[slot];
+  }
   if (slot === "refs") {
     const box = nodeEl.querySelector(".cv-vmat-refs-thumbs");
     if (box) box.innerHTML = "";
@@ -2438,9 +3600,64 @@ function cvClearVideoMat(nodeEl, slot) {
   if (clr) clr.classList.add("hidden");
   const inp = nodeEl.querySelector(`.cv-vmat-file[data-slot="${slot}"]`);
   if (inp) inp.value = "";
+  if (slot === "first") cvResetFramePlaceholder(nodeEl, "video");
+  cvScheduleAutosave();
+}
+
+function cvIsSeedanceV2Group(g) {
+  if (!g) return false;
+  if (g.seedanceV2) return true;
+  const text = `${g.name || ""} ${g.model || ""}`.toLowerCase();
+  return /seedance[\s_-]*v\s*2|seedancev2|seedance_v2/.test(text) || cvIsSeedanceV2Model(g.model);
+}
+
+function cvIsSeedanceV2Model(model) {
+  return /^(?:bh2\.0-|sd2\.0-|sdvip|gz-sd)/i.test(String(model || "").trim());
+}
+
+function cvIsSeedanceGroup(g) {
+  if (!g) return false;
+  if (g.seedance) return true;
+  return /seedance/i.test(`${g.name || ""} ${g.model || ""}`);
+}
+
+function cvIsGrokGroup(g) {
+  if (!g) return false;
+  if (g.grok) return true;
+  return /grok/i.test(`${g.name || ""} ${g.model || ""}`) || /grok-imagine-video/i.test(g.model || "");
+}
+
+function cvGroupChannelTag(g, nodeKind) {
+  if (!g) return "";
+  if (cvIsSeedanceV2Group(g)) return "Seedance V2";
+  if (cvIsGrokGroup(g)) return "Grok";
+  if (cvIsSeedanceGroup(g)) return "Seedance";
+  if (g.codexVideo && nodeKind === "video") return "视频";
+  if (g.codexImage && nodeKind === "image") return "生图";
+  return "";
+}
+
+function cvSortGroupsForNode(groups, nodeKind) {
+  const score = (g) => {
+    let s = 0;
+    if (nodeKind === "video") {
+      if (g.codexVideo) s += 100;
+      if (cvIsSeedanceV2Group(g)) s += 90;
+      if (cvIsSeedanceGroup(g)) s += 70;
+      if (cvIsGrokGroup(g)) s += 40;
+    } else if (nodeKind === "grokVideo") {
+      if (cvIsGrokGroup(g)) s += 100;
+      if (g.codexVideo) s += 50;
+    } else if (nodeKind === "image") {
+      if (g.codexImage) s += 100;
+    }
+    return s;
+  };
+  return groups.slice().sort((a, b) => score(b) - score(a));
 }
 
 // 用 CANVAS.groups 填充一个分组下拉，默认选中 activeGroupId（保留已有选择）
+// Seedance 视频节点会优先展示 / 默认选中 Seedance V2 分组，方便直接生成。
 function cvFillGroupSelect(sel) {
   if (!sel) return;
   const prev = sel.value;
@@ -2449,20 +3666,40 @@ function cvFillGroupSelect(sel) {
     sel.innerHTML = `<option value="">请先在『路由中转』添加分组</option>`;
     return;
   }
-  sel.innerHTML = groups
+  const nodeEl = sel.closest(".drawflow-node");
+  const isImage = !!(nodeEl && nodeEl.querySelector(".cv-node-image"));
+  const isGrokVideo = !!(nodeEl && nodeEl.querySelector(".cv-node-grokVideo"));
+  const isSeedanceVideo = !!(nodeEl && nodeEl.querySelector(".cv-node-video") && !isGrokVideo);
+  const isVideo = isSeedanceVideo || isGrokVideo;
+  const nodeKind = isGrokVideo ? "grokVideo" : isSeedanceVideo ? "video" : isImage ? "image" : "";
+  const ordered = cvSortGroupsForNode(groups, nodeKind);
+  sel.innerHTML = ordered
     .map((g) => {
-      const label = esc(g.name) + (g.host ? " · " + esc(g.host) : "");
+      const tag = cvGroupChannelTag(g, nodeKind);
+      const label = esc(g.name)
+        + (tag ? ` · ${esc(tag)}` : "");
       return `<option value="${esc(g.id)}">${label}</option>`;
     })
     .join("");
   const keep = prev && groups.some((g) => String(g.id) === prev);
-  const nodeEl = sel.closest(".drawflow-node");
-  const isGrokVideo = !!(nodeEl && nodeEl.querySelector(".cv-node-grokVideo"));
-  const grokGroup = isGrokVideo
-    ? groups.find((g) => /grok/i.test(g.name || "") || /grok-imagine-video/i.test(g.model || ""))
+  const imageGroup = isImage ? groups.find((g) => g.codexImage) : null;
+  const videoDefault = isSeedanceVideo
+    ? (
+        groups.find((g) => g.codexVideo && cvIsSeedanceV2Group(g))
+        || groups.find((g) => cvIsSeedanceV2Group(g))
+        || groups.find((g) => g.codexVideo && cvIsSeedanceGroup(g))
+        || groups.find((g) => g.codexVideo)
+        || groups.find((g) => cvIsSeedanceGroup(g))
+      )
     : null;
-  const want = keep ? prev : String((grokGroup && grokGroup.id) || CANVAS.activeGroupId || "");
+  const grokGroup = isGrokVideo
+    ? (groups.find((g) => cvIsGrokGroup(g)) || groups.find((g) => g.codexVideo))
+    : null;
+  const want = keep
+    ? prev
+    : String((videoDefault && videoDefault.id) || (imageGroup && imageGroup.id) || (grokGroup && grokGroup.id) || CANVAS.activeGroupId || "");
   if (want) sel.value = want;
+  cvApplyGroupChannelHints(nodeEl, want);
 }
 
 function cvSetNodeModelOptions(nodeEl, models) {
@@ -2510,14 +3747,85 @@ function cvSetupNode(id) {
   cvFillGroupSelect(nodeEl.querySelector(".cv-field-group"));
   // 视频节点：按当前模式初始化素材控件显隐
   if (nodeEl.querySelector(".cv-field-vmode")) cvSyncVideoMode(nodeEl);
+  cvUpdateParamSummary(nodeEl);
+  cvObserveNodePortFrame(nodeEl);
+  requestAnimationFrame(() => cvAlignNodePorts(nodeEl));
 }
 
-// 分组下拉变化：清空旧模型候选，不自动锁定第一个模型，保留手动选择。
+function cvSyncImagePreviewRatio(nodeEl) {
+  const frame = nodeEl && nodeEl.querySelector(".cv-image-frame");
+  if (!frame) return;
+  const ratio = (nodeEl.querySelector(".cv-field-ratio")?.value || "1:1").trim();
+  const parts = ratio.split(":").map((n) => parseFloat(n));
+  const w = Number.isFinite(parts[0]) && parts[0] > 0 ? parts[0] : 1;
+  const h = Number.isFinite(parts[1]) && parts[1] > 0 ? parts[1] : 1;
+  frame.dataset.ratio = ratio;
+  frame.style.setProperty("--cv-image-preview-aspect", `${w} / ${h}`);
+  cvRefreshNodePorts(nodeEl);
+}
+
+function cvUpdateParamSummary(nodeEl) {
+  if (!nodeEl) return;
+  const sum = nodeEl.querySelector(".cv-video-pop > summary");
+  if (!sum) return;
+  const val = (sel) => {
+    const el = nodeEl.querySelector(sel);
+    return el ? el.value.trim() : "";
+  };
+  if (nodeEl.querySelector(".cv-image-compact")) {
+    cvSyncImagePreviewRatio(nodeEl);
+    sum.textContent = [val(".cv-field-ratio") || "1:1", val(".cv-field-quality") || "1K"].join(" · ");
+    return;
+  }
+  if (nodeEl.querySelector(".cv-tts-compact")) {
+    sum.textContent = [val(".cv-field-voice") || "alloy", val(".cv-field-format") || "mp3"].join(" · ");
+    return;
+  }
+  const modeMap = { text: "文生", first: "首帧", firstlast: "双图", reference: "参考" };
+  const mode = modeMap[val(".cv-field-vmode")] || "文生";
+  const resolutionMap = { "2k": "2K", "4k": "4K" };
+  const resolution = val(".cv-field-vsize") || "720p";
+  sum.textContent = [mode, val(".cv-field-ratio") || "16:9", resolutionMap[resolution.toLowerCase()] || resolution, val(".cv-field-duration") || "5s"].join(" · ");
+}
+
+// 按所选分组切换 Seedance / Seedance V2 的默认接口与提示。
+function cvApplyGroupChannelHints(nodeEl, groupId) {
+  if (!nodeEl) return;
+  const isSeedanceVideo = !!(nodeEl.querySelector(".cv-node-video") && !nodeEl.querySelector(".cv-node-grokVideo"));
+  if (!isSeedanceVideo) return;
+  const g = (CANVAS.groups || []).find((item) => String(item.id) === String(groupId || ""));
+  const endpoint = nodeEl.querySelector(".cv-field-endpoint");
+  const hint = nodeEl.querySelector(".cv-node-hint");
+  const title = nodeEl.querySelector(".cv-video-label");
+  const isV2 = cvIsSeedanceV2Group(g);
+  if (endpoint) {
+    const cur = String(endpoint.value || "").trim();
+    const v1Path = "/v1/videos";
+    const v2Path = "/v1/video/generations";
+    // 仅在空或旧默认路径时自动切换，避免覆盖用户自定义
+    if (!cur || cur === v1Path || cur === v2Path || /\/v1\/videos(?:\/generations)?$/i.test(cur) || /\/v1\/video\/generations$/i.test(cur)) {
+      endpoint.value = isV2 ? v2Path : "";
+    }
+    endpoint.placeholder = isV2 ? v2Path : v1Path;
+    endpoint.title = isV2 ? "Seedance V2 原生接口" : "CLMM / 旧 Seedance 接口";
+  }
+  if (hint) {
+    hint.textContent = isV2
+      ? "Seedance V2（Binghuo）：模型请拉取 V2 分组完整名称，默认 /v1/video/generations"
+      : "Seedance / CLMM：模型名、时长和参考图按上游能力校验，默认 /v1/videos";
+  }
+  if (title) {
+    title.innerHTML = isV2 ? "<span>▦</span>Seedance V2" : "<span>▦</span>视频";
+  }
+}
+
+// 分组下拉变化：清空旧模型候选，并按 Seedance V1/V2 切换默认接口。
 function cvOnGroupChange(nodeEl, groupId) {
   const dl = nodeEl.querySelector(".cv-node-datalist");
   if (dl) dl.innerHTML = "";
   const model = nodeEl.querySelector(".cv-field-model");
   if (model && model.tagName === "SELECT") model.innerHTML = '<option value="">请点击“拉取”选择模型</option>';
+  cvApplyGroupChannelHints(nodeEl, groupId);
 }
 
 // 拉取某节点所选分组的模型 → 填充完整模型下拉/候选列表
@@ -2601,10 +3909,13 @@ function cvSeedSample() {
     cvSetField(t2, "大家好，这是TD工具箱创意画布");
     // 能力节点：唯一化 datalist + 回填分组下拉（默认选中 activeId）
     [img, vid, tts].forEach(cvSetupNode);
+    cvRefreshAllNodePorts();
     // 连线：output_1 → input_1
     ed.addConnection(t1, img, "output_1", "input_1");
     ed.addConnection(img, vid, "output_1", "input_1");
     ed.addConnection(t2, tts, "output_1", "input_1");
+    cvRefreshAllNodePorts();
+    cvUpdateEmptyHint();
   } catch (e) {
     // 预置失败不影响画布可用
   }
@@ -2616,9 +3927,52 @@ function cvReflow() {
     if (CANVAS.editor && typeof CANVAS.editor.zoom_refresh === "function") {
       CANVAS.editor.zoom_refresh();
     }
+    cvRefreshAllNodePorts();
   } catch (e) {}
 }
 
+function cvZoomPercent() {
+  return Math.round((CANVAS.editor && CANVAS.editor.zoom ? CANVAS.editor.zoom : 1) * 100);
+}
+
+function cvSyncZoomControls(forceRange) {
+  const ed = CANVAS.editor;
+  const pct = cvZoomPercent();
+  const label = document.getElementById("cv-zoom-reset");
+  const range = document.getElementById("cv-zoom-range");
+  if (label) label.textContent = pct + "%";
+  if (range && ed) {
+    range.min = String(Math.round((ed.zoom_min || 0.5) * 100));
+    range.max = String(Math.round((ed.zoom_max || 1.6) * 100));
+    if (forceRange || document.activeElement !== range) range.value = String(pct);
+  }
+}
+
+function cvSetZoomPercent(pct) {
+  const ed = CANVAS.editor;
+  if (!ed) return;
+  const minPct = Math.round((ed.zoom_min || 0.5) * 100);
+  const maxPct = Math.round((ed.zoom_max || 1.6) * 100);
+  const next = Math.min(maxPct, Math.max(minPct, Math.round(Number(pct) || 100)));
+  ed.zoom = next / 100;
+  if (typeof ed.zoom_refresh === "function") ed.zoom_refresh();
+  cvSyncZoomControls(true);
+  cvRefreshAllNodePorts();
+  cvScheduleAutosave();
+}
+
+function cvRequestAutoFull() {
+  const panel = document.getElementById("tab-canvas");
+  if (!panel || panel.classList.contains("cv-fullscreen")) return;
+  requestAnimationFrame(() => {
+    requestAnimationFrame(() => {
+      if (panel.classList.contains("active") && !panel.classList.contains("cv-fullscreen")) {
+        cvToggleFull(true);
+      }
+    });
+  });
+}
+
 // 切换沉浸式全屏（fixed 覆盖整个应用窗口，不新开窗口）
 function cvToggleFull(force) {
   const panel = document.getElementById("tab-canvas");
@@ -2630,7 +3984,7 @@ function cvToggleFull(force) {
   document.body.classList.toggle("cv-noscroll", on);
   const btn = document.getElementById("cv-full-btn");
   if (btn) btn.textContent = on ? "✕ 退出全屏" : "⛶ 全屏";
-  cvReflow();
+  requestAnimationFrame(() => requestAnimationFrame(cvReflow));
 }
 
 // 计算画布中心坐标（考虑当前缩放/平移），并错位摆放避免重叠
@@ -2645,16 +3999,146 @@ function cvCenterPos() {
   return { x: Math.max(20, x), y: Math.max(20, y) };
 }
 
+function cvCanvasPosFromPoint(clientX, clientY) {
+  const c = document.getElementById("drawflow");
+  const ed = CANVAS.editor;
+  if (!c || !ed) return cvCenterPos();
+  const rect = c.getBoundingClientRect();
+  const zoom = ed.zoom || 1;
+  const x = (clientX - rect.left - (ed.canvas_x || 0)) / zoom - 125;
+  const y = (clientY - rect.top - (ed.canvas_y || 0)) / zoom - 70;
+  return { x: Math.max(20, x), y: Math.max(20, y) };
+}
+
+function cvUpdateEmptyHint() {
+  const hint = document.getElementById("cv-empty-hint");
+  if (!hint) return;
+  hint.classList.toggle("hidden", Object.keys(cvAllNodes()).length > 0);
+}
+
+function cvOpenQuickMenu(clientX, clientY) {
+  const menu = document.getElementById("cv-quick-menu");
+  const stage = document.querySelector("#tab-canvas .cv-stage");
+  if (!menu || !stage) return;
+  CANVAS.quickAddPos = cvCanvasPosFromPoint(clientX, clientY);
+  const rect = stage.getBoundingClientRect();
+  const width = 240;
+  const height = 310;
+  const left = Math.min(Math.max(14, clientX - rect.left + 12), Math.max(14, rect.width - width - 14));
+  const top = Math.min(Math.max(14, clientY - rect.top + 12), Math.max(14, rect.height - height - 14));
+  menu.style.left = left + "px";
+  menu.style.top = top + "px";
+  menu.classList.remove("hidden");
+}
+
+function cvCloseQuickMenu() {
+  const menu = document.getElementById("cv-quick-menu");
+  if (menu) menu.classList.add("hidden");
+}
+
 // 在画布中心添加一个指定类型的节点
-function cvAddNode(kind) {
+function cvAddNode(kind, customPos) {
   const m = CV_NODES[kind];
   if (!CANVAS.editor || !m) return;
-  const pos = cvCenterPos();
+  const pos = customPos || cvCenterPos();
   const id = CANVAS.editor.addNode(
     kind, m.inputs, m.outputs, pos.x, pos.y,
     `cv-df-${kind}`, {}, cvNodeHTML(kind), false
   );
   cvSetupNode(id); // 唯一化 datalist + 回填分组下拉
+  cvRefreshNodePorts(document.getElementById(`node-${id}`));
+  cvUpdateEmptyHint();
+  cvScheduleAutosave();
+}
+
+function cvPortAnchor(nodeEl) {
+  if (!nodeEl) return null;
+  return nodeEl.querySelector("[data-port-anchor]") || nodeEl.querySelector(".cv-video-frame") || nodeEl.querySelector(".cv-video-composer");
+}
+
+function cvAlignNodePorts(nodeEl) {
+  if (!nodeEl) return false;
+  const frame = cvPortAnchor(nodeEl);
+  if (!frame) return false;
+  const nodeRect = nodeEl.getBoundingClientRect();
+  const frameRect = frame.getBoundingClientRect();
+  if (!nodeRect.width || !frameRect.width) return false;
+  const zoom = (CANVAS.editor && CANVAS.editor.zoom) || 1;
+  const midY = (frameRect.top - nodeRect.top + frameRect.height / 2) / zoom;
+  const leftX = (frameRect.left - nodeRect.left) / zoom;
+  const rightX = (frameRect.right - nodeRect.left) / zoom;
+  const next = `${Math.round(midY)}:${Math.round(leftX)}:${Math.round(rightX)}`;
+  if (nodeEl.dataset.cvPortPos === next) return false;
+  nodeEl.dataset.cvPortPos = next;
+  nodeEl.style.setProperty("--cv-port-y", `${midY}px`);
+  nodeEl.style.setProperty("--cv-port-left", `${leftX}px`);
+  nodeEl.style.setProperty("--cv-port-right", `${rightX}px`);
+  return true;
+}
+
+function cvAlignAllNodePorts() {
+  document.querySelectorAll("#drawflow .drawflow-node").forEach(cvAlignNodePorts);
+}
+
+function cvRefreshNodePorts(nodeEl) {
+  if (!nodeEl || !nodeEl.id) return;
+  const id = nodeEl.id;
+  if (CANVAS.portRefreshNodeRAFs[id]) return;
+  CANVAS.portRefreshNodeRAFs[id] = requestAnimationFrame(() => {
+    delete CANVAS.portRefreshNodeRAFs[id];
+    if (!nodeEl.isConnected) return;
+    const changed = cvAlignNodePorts(nodeEl);
+    if (changed && CANVAS.editor && typeof CANVAS.editor.updateConnectionNodes === "function") {
+      CANVAS.editor.updateConnectionNodes(nodeEl.id);
+    }
+  });
+}
+
+function cvRefreshAllNodePorts() {
+  if (CANVAS.portRefreshRAF) return;
+  CANVAS.portRefreshRAF = requestAnimationFrame(() => {
+    CANVAS.portRefreshRAF = 0;
+    if (document.getElementById("drawflow")?.classList.contains("cv-dragging")) {
+      setTimeout(cvRefreshAllNodePorts, 90);
+      return;
+    }
+    document.querySelectorAll("#drawflow .drawflow-node").forEach((nodeEl) => {
+      const changed = cvAlignNodePorts(nodeEl);
+      if (changed && CANVAS.editor && typeof CANVAS.editor.updateConnectionNodes === "function") {
+        CANVAS.editor.updateConnectionNodes(nodeEl.id);
+      }
+    });
+  });
+}
+
+function cvObserveNodePortFrame(nodeEl) {
+  if (!nodeEl) return;
+  const frame = cvPortAnchor(nodeEl);
+  if (!frame || frame.dataset.cvPortObserved) return;
+  frame.dataset.cvPortObserved = "1";
+  if (!CANVAS.portResizeObserver && typeof ResizeObserver !== "undefined") {
+    CANVAS.portResizeObserver = new ResizeObserver((entries) => {
+      entries.forEach((entry) => {
+        const next = `${Math.round(entry.contentRect.width)}:${Math.round(entry.contentRect.height)}`;
+        if (entry.target.dataset.cvResizeSize === next) return;
+        entry.target.dataset.cvResizeSize = next;
+        const node = entry.target.closest(".drawflow-node");
+        if (node) CANVAS.portResizeQueue.add(node);
+      });
+      if (CANVAS.portResizeTimer) return;
+      CANVAS.portResizeTimer = setTimeout(() => {
+        CANVAS.portResizeTimer = 0;
+        if (CANVAS.portResizeRAF) return;
+        CANVAS.portResizeRAF = requestAnimationFrame(() => {
+        CANVAS.portResizeRAF = 0;
+        const nodes = Array.from(CANVAS.portResizeQueue);
+        CANVAS.portResizeQueue.clear();
+        nodes.forEach(cvRefreshNodePorts);
+      });
+      }, 120);
+    });
+  }
+  if (CANVAS.portResizeObserver) CANVAS.portResizeObserver.observe(frame);
 }
 
 // 切换视频模式：按 mode 显隐首帧、尾帧和多参考图素材控件
@@ -2687,22 +4171,13 @@ function cvNodeOutput(id) {
   return res;
 }
 
-// 汇总某节点所有上游连线的产物（取第一个非空文本 / 图片）
+// 汇总某节点所有上游连线的产物：文本保留首个，图片保留全部并提供首图兼容字段。
 function cvCollectUpstream(nodeId) {
-  const out = { text: "", image: "" };
   try {
     const node = CANVAS.editor.getNodeFromId(nodeId);
-    if (!node || !node.inputs) return out;
-    for (const key of Object.keys(node.inputs)) {
-      const conns = (node.inputs[key] && node.inputs[key].connections) || [];
-      for (const c of conns) {
-        const src = cvNodeOutput(c.node);
-        if (src.text && !out.text) out.text = src.text;
-        if (src.image && !out.image) out.image = src.image;
-      }
-    }
+    if (window.CanvasInputs) return window.CanvasInputs.collectUpstreamOutputs(node, cvNodeOutput);
   } catch (e) {}
-  return out;
+  return { text: "", image: "", images: [] };
 }
 
 // 节点内错误红字
@@ -2738,7 +4213,10 @@ function cvMediaExt(mime, kind) {
   if (/jpe?g/i.test(mime)) return "jpg";
   if (/webp/i.test(mime)) return "webp";
   if (/mp4/i.test(mime) || kind === "video" || kind === "grokVideo") return "mp4";
-  return kind === "image" ? "png" : "bin";
+  if (/wav/i.test(mime)) return "wav";
+  if (/mpeg/i.test(mime) || /mp3/i.test(mime)) return "mp3";
+  if (/ogg/i.test(mime) || /opus/i.test(mime)) return "opus";
+  return kind === "image" ? "png" : kind === "audio" ? "mp3" : "bin";
 }
 
 function cvPreviewChrome(kind, dataUrl, sourceUrl, foot) {
@@ -2748,7 +4226,7 @@ function cvPreviewChrome(kind, dataUrl, sourceUrl, foot) {
     ? `<video class="cv-media" controls src="${dataUrl}"${sourceAttr}></video>`
     : `<img class="cv-media" src="${dataUrl}"${sourceAttr} alt="生成图片" />`;
   return `
-    <div class="cv-preview-shell">
+    <div class="cv-preview-shell ${isVideo ? "cv-preview-video" : "cv-preview-image"}">
       <div class="cv-preview-actions">
         <button type="button" class="cv-preview-open" title="放大预览">⛶</button>
         <button type="button" class="cv-preview-download" title="下载">⇩</button>
@@ -2757,20 +4235,32 @@ function cvPreviewChrome(kind, dataUrl, sourceUrl, foot) {
     </div>${foot}`;
 }
 
+function cvAudioPreviewChrome(dataUrl, foot) {
+  return `
+    <div class="cv-preview-shell cv-preview-audio">
+      <div class="cv-preview-actions">
+        <button type="button" class="cv-preview-open" title="放大预览">⛶</button>
+        <button type="button" class="cv-preview-download" title="下载">⇩</button>
+      </div>
+      <audio class="cv-media-audio" controls src="${dataUrl}"></audio>
+    </div>${foot}`;
+}
+
 function cvOpenPreview(previewEl) {
   if (!previewEl) return;
-  const media = previewEl.querySelector("img.cv-media, video.cv-media");
+  const media = previewEl.querySelector("img.cv-media, video.cv-media, audio.cv-media-audio");
   if (!media || !media.src) return;
   const isVideo = media.tagName === "VIDEO";
+  const isAudio = media.tagName === "AUDIO";
   const src = media.src || media.dataset.sourceUrl;
   const modal = modalOverlay.querySelector(".modal");
   const body = $("#modal-body");
-  $("#modal-title").textContent = isVideo ? "视频预览" : "图片预览";
+  $("#modal-title").textContent = isVideo ? "视频预览" : isAudio ? "音频预览" : "图片预览";
   body.innerHTML = "";
-  const m = document.createElement(isVideo ? "video" : "img");
+  const m = document.createElement(isVideo ? "video" : isAudio ? "audio" : "img");
   m.className = "cv-modal-media";
   m.src = src;
-  if (isVideo) m.controls = true;
+  if (isVideo || isAudio) m.controls = true;
   body.appendChild(m);
   if (modal) modal.classList.add("cv-media-modal");
   modalOverlay.classList.remove("hidden");
@@ -2794,9 +4284,10 @@ function cvDataUrlToBlob(dataUrl) {
 
 async function cvDownloadPreview(previewEl) {
   if (!previewEl) return;
-  const media = previewEl.querySelector("img.cv-media, video.cv-media");
+  const media = previewEl.querySelector("img.cv-media, video.cv-media, audio.cv-media-audio");
   if (!media || !media.src) return;
   const isVideo = media.tagName === "VIDEO";
+  const isAudio = media.tagName === "AUDIO";
   const src = media.src || media.dataset.sourceUrl;
   try {
     let blob;
@@ -2809,7 +4300,7 @@ async function cvDownloadPreview(previewEl) {
       if (!res.ok) throw new Error("HTTP " + res.status);
       blob = await res.blob();
     }
-    const ext = cvMediaExt(blob.type, isVideo ? "video" : "image");
+    const ext = cvMediaExt(blob.type, isVideo ? "video" : isAudio ? "audio" : "image");
     const url = URL.createObjectURL(blob);
     const a = document.createElement("a");
     a.href = url;
@@ -2839,10 +4330,28 @@ function cvRenderResult(kind, el, r) {
   } else if (kind === "video" || kind === "grokVideo") {
     el.innerHTML = cvPreviewChrome(kind, r.dataUrl, r.url || "", foot);
   } else if (kind === "tts") {
-    el.innerHTML = `<audio class="cv-media-audio" controls src="${r.dataUrl}"></audio>${foot}`;
+    el.innerHTML = cvAudioPreviewChrome(r.dataUrl, foot);
   }
 }
 
+function cvResultHost(nodeEl, kind) {
+  if (!nodeEl) return null;
+  if (kind === "image" || kind === "video" || kind === "grokVideo" || kind === "tts") {
+    return nodeEl.querySelector(".cv-video-frame-inner") || nodeEl.querySelector(".cv-node-preview");
+  }
+  return nodeEl.querySelector(".cv-node-preview");
+}
+
+function cvResetResultHost(el, kind) {
+  if (!el) return;
+  if (el.classList.contains("cv-video-frame-inner")) {
+    el.innerHTML = kind === "image" ? "▧" : kind === "tts" ? "♪" : "▣";
+    return;
+  }
+  el.classList.add("hidden");
+  el.innerHTML = "";
+}
+
 // 据 比例×清晰度 算出图像尺寸 "WxH"（长边 1K=1024/2K=2048/4K=4096，短边按比例取整）
 function cvRatioToSize(ratio, quality) {
   const longEdge = quality === "4K" ? 4096 : quality === "2K" ? 2048 : 1024;
@@ -2867,12 +4376,14 @@ function cvClearRunMapForNode(nodeId) {
 function cvSetPreviewImage(prevEl, dataUrl) {
   if (!prevEl || !dataUrl) return;
   prevEl.classList.remove("hidden");
-  const img = prevEl.querySelector("img.cv-media");
-  if (img) {
-    img.src = dataUrl;
-  } else {
-    prevEl.innerHTML = `<img class="cv-media" src="${dataUrl}" alt="生成中…" />`;
+  if (prevEl.classList.contains("cv-video-frame-inner")) {
+    const foot = '<div class="cv-meta">生成中…</div>';
+    prevEl.innerHTML = cvPreviewChrome("image", dataUrl, "", foot);
+    return;
   }
+  const img = prevEl.querySelector("img.cv-media");
+  if (img) img.src = dataUrl;
+  else prevEl.innerHTML = `<img class="cv-media" src="${dataUrl}" alt="生成中…" />`;
 }
 
 // 订阅后端流式进度（幂等，页面生命周期内保留一次）
@@ -2887,7 +4398,7 @@ function cvBindProgress() {
       if (!nodeId) return; // 无映射（已结束/已清理）→ 丢弃，避免串图
       const nodeEl = document.getElementById(`node-${nodeId}`);
       if (!nodeEl) return;
-      cvSetPreviewImage(nodeEl.querySelector(".cv-node-preview"), p.dataUrl);
+      cvSetPreviewImage(cvResultHost(nodeEl, "image"), p.dataUrl);
     } catch (e) {}
   });
 }
@@ -2898,7 +4409,8 @@ async function cvRunNode(nodeId, btn) {
   if (!nodeEl) return;
   const node = CANVAS.editor.getNodeFromId(nodeId);
   const kind = node && node.name;
-  const prevEl = nodeEl.querySelector(".cv-node-preview");
+  const workspaceContext = { workspaceId: CANVAS.workspaceId, workspaceState: cvWorkspaceSnapshot() };
+  const prevEl = cvResultHost(nodeEl, kind);
   cvSetErr(nodeEl, "");
 
   // 组装每类节点的入参（优先自身填写，其次上游连线）
@@ -2922,8 +4434,8 @@ async function cvRunNode(nodeId, btn) {
     runKind = "image";
     params = { prompt, model, size };
     if (endpointPath) params.endpointPath = endpointPath;
-    // 图生图：本节点上传的参考图 → 主进程传图床换外链；字段名可在高级里改（默认 image）
-    const refImg = CANVAS.refImages[nodeId];
+    // 图生图：本节点上传的参考图优先，其次使用连接上游的首张图片。
+    const refImg = CANVAS.refImages[nodeId] || up.image;
     if (refImg) params.image = refImg;
     const refField = val(".cv-field-reffield");
     if (refField) params.refField = refField;
@@ -2943,12 +4455,17 @@ async function cvRunNode(nodeId, btn) {
       const el = nodeEl.querySelector(`.cv-vmat-url[data-slot="${slot}"]`);
       return el ? el.value.trim() : "";
     };
+    const matUrls = (slot) => {
+      const el = nodeEl.querySelector(`.cv-vmat-urls[data-slot="${slot}"]`);
+      return el ? el.value.split(/\s+/).map((s) => s.trim()).filter(Boolean) : [];
+    };
     runKind = "video";
     params = {
       mode,
       prompt: ownText || up.text,
       ratio: val(".cv-field-ratio"),
       quality: val(".cv-field-vquality"),
+      resolution: val(".cv-field-vsize") || "720p",
       referenceField: val(".cv-field-refsource") || "images",
     };
     if (model) params.model = model;
@@ -2967,12 +4484,18 @@ async function cvRunNode(nodeId, btn) {
       params.lastFrameImage = last;
     }
     if (mode === "reference") {
-      const refs = (mats.refs || []).slice();
-      if (!refs.length) return cvSetErr(nodeEl, "多参考图模式请至少上传 1 张参考图");
+      const refs = CanvasInputs.uniqueNonEmpty([].concat(up.images, mats.refs || [], matUrls("refs")));
+      if (!refs.length) return cvSetErr(nodeEl, "多参考图模式请连接上游图片、上传参考图，或填写公网图片URL");
       params.referenceImages = refs;
     }
     if (duration) params.seconds = duration;
     if (endpointPath) params.endpointPath = endpointPath;
+    else {
+      // 未填高级接口时：Seedance V2 分组自动走原生 /v1/video/generations
+      const gid = val(".cv-field-group");
+      const gg = (CANVAS.groups || []).find((item) => String(item.id) === String(gid || ""));
+      if (cvIsSeedanceV2Group(gg) || cvIsSeedanceV2Model(model)) params.endpointPath = "/v1/video/generations";
+    }
   } else if (kind === "grokVideo") {
     const mode = val(".cv-field-vmode") || "text";
     const model = val(".cv-field-model");
@@ -3002,7 +4525,7 @@ async function cvRunNode(nodeId, btn) {
       params.image = first;
     }
     if (mode === "reference") {
-      const refs = [up.image].concat(mats.refs || [], matUrls("refs")).filter(Boolean);
+      const refs = CanvasInputs.uniqueNonEmpty([].concat(up.images, mats.refs || [], matUrls("refs")));
       if (!refs.length) return cvSetErr(nodeEl, "多参考图模式请连接上游图片、上传参考图，或填写公网图片URL");
       params.referenceImages = refs;
       params.aspectRatio = params.aspectRatio || "16:9";
@@ -3034,17 +4557,22 @@ async function cvRunNode(nodeId, btn) {
     prevEl.innerHTML = `<div class="cv-skeleton"><span class="cv-spin"></span>生成中…</div>`;
   }
   try {
+    await cvSaveWorkspace();
     if (!apic.canvasRun) throw new Error("画布运行能力尚未就绪（后端未接入）");
     const r = await apic.canvasRun(runKind, params);
     if (!r || !r.ok) throw new Error((r && r.error) || "生成失败");
-    cvRenderResult(runKind, prevEl, r);
-    // 缓存产物供下游取用（图片可连到图生视频）
-    if (runKind === "image") CANVAS.outputs[nodeId] = { image: r.dataUrl };
-  } catch (e) {
-    if (prevEl) {
-      prevEl.classList.add("hidden");
-      prevEl.innerHTML = "";
+    if (CANVAS.workspaceId === workspaceContext.workspaceId) {
+      cvRenderResult(runKind, prevEl, r);
+      // 缓存产物供下游取用（图片可连到图生视频）
+      if (runKind === "image") CANVAS.outputs[nodeId] = { image: r.dataUrl };
     }
+    try {
+      await cvCacheOutput(nodeId, runKind, r, workspaceContext);
+    } catch (cacheErr) {
+      toast("生成成功，但本地缓存失败：" + (cacheErr.message || cacheErr), "err");
+    }
+  } catch (e) {
+    cvResetResultHost(prevEl, runKind || kind);
     cvSetErr(nodeEl, e.message || String(e));
   } finally {
     cvBusy(btn, false);
@@ -3086,17 +4614,78 @@ async function cvRefreshStatus() {
 }
 
 // 进入画布：懒初始化 + 加载分组 + 刷新状态
-function cvEnter() {
+async function cvEnter() {
   cvInit();
   cvBindProgress(); // 幂等；若启动时后端未就绪，进入时再尝试订阅
   cvLoadGroups();
   cvRefreshStatus();
+  cvRequestAutoFull();
+  if (!CANVAS.workspaceReady && !CANVAS.workspaceLoading) {
+    CANVAS.workspaceLoading = true;
+    try {
+      const r = await apic.canvasWorkspaces();
+      CANVAS.workspaceList = r && r.ok && Array.isArray(r.workspaces) ? r.workspaces : [];
+      if (!CANVAS.workspaceList.length) {
+        await cvCreateWorkspace();
+      } else {
+        await cvOpenWorkspacePicker();
+      }
+    } catch (e) {
+      toast("画布记录加载失败：" + (e.message || e), "err");
+    } finally {
+      CANVAS.workspaceLoading = false;
+    }
+  }
 }
 const cvTabBtn = document.querySelector('.tab[data-tab="canvas"]');
 if (cvTabBtn) cvTabBtn.addEventListener("click", cvEnter);
 // 启动时订阅一次流式进度（幂等）
 cvBindProgress();
 
+document.getElementById("cv-projects-btn")?.addEventListener("click", cvOpenWorkspacePicker);
+document.getElementById("cv-project-close")?.addEventListener("click", cvCloseWorkspacePicker);
+document.getElementById("cv-project-create")?.addEventListener("click", () => {
+  cvCreateWorkspace().catch((e) => toast("新建画布失败：" + (e.message || e), "err"));
+});
+document.getElementById("cv-new-btn")?.addEventListener("click", () => {
+  cvCreateWorkspace().catch((e) => toast("新建画布失败：" + (e.message || e), "err"));
+});
+document.getElementById("cv-project-list")?.addEventListener("click", (e) => {
+  const renameStart = e.target.closest("[data-cv-rename-start]");
+  if (renameStart) {
+    CANVAS.workspaceRenamingId = renameStart.dataset.cvRenameStart;
+    cvRenderWorkspaceList();
+    return;
+  }
+  if (e.target.closest("[data-cv-rename-cancel]")) {
+    CANVAS.workspaceRenamingId = "";
+    cvRenderWorkspaceList();
+    return;
+  }
+  const renameSave = e.target.closest("[data-cv-rename-save]");
+  if (renameSave) {
+    cvRenameWorkspace(renameSave.dataset.cvRenameSave).catch((err) => toast("改名失败：" + (err.message || err), "err"));
+    return;
+  }
+  const btn = e.target.closest("[data-cv-workspace-id]");
+  if (!btn) return;
+  busy(btn, true, "载入中…");
+  cvLoadWorkspace(btn.dataset.cvWorkspaceId)
+    .catch((err) => toast("恢复画布失败：" + (err.message || err), "err"))
+    .finally(() => busy(btn, false));
+});
+document.getElementById("cv-project-list")?.addEventListener("keydown", (e) => {
+  const input = e.target.closest("[data-cv-rename-input]");
+  if (!input) return;
+  if (e.key === "Enter") {
+    e.preventDefault();
+    cvRenameWorkspace(input.dataset.cvRenameInput).catch((err) => toast("改名失败：" + (err.message || err), "err"));
+  } else if (e.key === "Escape") {
+    CANVAS.workspaceRenamingId = "";
+    cvRenderWorkspaceList();
+  }
+});
+
 // 顶部「添加节点」按钮
 $$("[data-cv-add]").forEach((b) =>
   b.addEventListener("click", () => {
@@ -3149,17 +4738,21 @@ if (cvFullBtn)
     cvToggleFull();
   });
 
-// 悬浮缩放控件（＋ / 100% 重置 / －）→ Drawflow zoom_in/out/reset
-const cvZoom = (fn) => () => {
+// 悬浮缩放控件（＋ / 100% 重置 / －）统一走 cvSetZoomPercent，避免越过 Drawflow min/max
+const cvZoomStep = (delta) => () => {
   cvInit();
-  if (CANVAS.editor && typeof CANVAS.editor[fn] === "function") {
-    CANVAS.editor[fn]();
-    cvUpdateZoomLabel();
-  }
+  cvSetZoomPercent(cvZoomPercent() + delta);
 };
-document.getElementById("cv-zoom-in")?.addEventListener("click", cvZoom("zoom_in"));
-document.getElementById("cv-zoom-out")?.addEventListener("click", cvZoom("zoom_out"));
-document.getElementById("cv-zoom-reset")?.addEventListener("click", cvZoom("zoom_reset"));
+document.getElementById("cv-zoom-in")?.addEventListener("click", cvZoomStep(5));
+document.getElementById("cv-zoom-out")?.addEventListener("click", cvZoomStep(-5));
+document.getElementById("cv-zoom-reset")?.addEventListener("click", () => {
+  cvInit();
+  cvSetZoomPercent(100);
+});
+const cvZoomRange = document.getElementById("cv-zoom-range");
+if (cvZoomRange) {
+  cvZoomRange.addEventListener("input", () => cvSetZoomPercent(cvZoomRange.value));
+}
 
 // Esc 退出全屏
 document.addEventListener("keydown", (e) => {
@@ -3172,7 +4765,16 @@ document.addEventListener("keydown", (e) => {
 // ============================================================================
 //  员工团队：需求 → AI 员工团队 → 打包 zip
 // ============================================================================
-const TEAM = { tool: "codex", team: null, groups: [], activeGroupId: "", loaded: false };
+const TEAM = {
+  tool: "codex",
+  team: null,
+  groups: [],
+  activeGroupId: "",
+  orchestratorGroupId: "",
+  agentGroupId: "",
+  agentModels: [],
+  loaded: false,
+};
 
 async function tmEnter() {
   if (!TEAM.loaded) {
@@ -3190,43 +4792,125 @@ async function tmLoadGroups() {
     if (r && r.ok) {
       TEAM.groups = Array.isArray(r.groups) ? r.groups : [];
       TEAM.activeGroupId = r.activeId || (TEAM.groups[0] && TEAM.groups[0].id) || "";
+      TEAM.orchestratorGroupId = TEAM.orchestratorGroupId || TEAM.activeGroupId;
+      const preferredWorker = TEAM.groups.find((g) => /deepseek/i.test(
+        `${g.id || ""} ${g.name || ""} ${g.model || ""} ${(g.models || []).join(" ")}`
+      ));
+      const fallbackWorker = TEAM.groups.find((g) => g.id !== TEAM.activeGroupId && !g.codexImage && !g.codexVideo && !g.stt)
+        || TEAM.groups[0];
+      TEAM.agentGroupId = TEAM.agentGroupId || (preferredWorker && preferredWorker.id) || (fallbackWorker && fallbackWorker.id) || "";
     } else {
       TEAM.groups = [];
       TEAM.activeGroupId = "";
+      TEAM.orchestratorGroupId = "";
+      TEAM.agentGroupId = "";
     }
   } catch (e) {
     TEAM.groups = [];
     TEAM.activeGroupId = "";
+    TEAM.orchestratorGroupId = "";
+    TEAM.agentGroupId = "";
   }
-  const sel = document.getElementById("tm-group");
-  if (sel) {
-    sel.innerHTML = TEAM.groups.length
-      ? TEAM.groups.map((g) => `<option value="${esc(g.id)}">${esc(g.name || g.id)}${g.host ? " · " + esc(g.host) : ""}</option>`).join("")
-      : `<option value="">未配置可用分组（去『路由中转』添加）</option>`;
-    sel.value = TEAM.activeGroupId || "";
-    sel.onchange = () => { TEAM.activeGroupId = sel.value; };
-  }
+  tmRenderGroupSelect("tm-group", TEAM.activeGroupId, (id) => {
+    TEAM.activeGroupId = id;
+    const group = TEAM.groups.find((g) => g.id === id);
+    tmSetSelectModels("tm-model", TEAM.activeGroupId, group && (group.model || (group.models || [])[0]));
+    tmUpdateGenBtn();
+  });
+  tmRenderGroupSelect("tm-orch-group", TEAM.orchestratorGroupId, (id) => {
+    TEAM.orchestratorGroupId = id;
+    const group = TEAM.groups.find((g) => g.id === id);
+    tmSetSelectModels("tm-orch-model", TEAM.orchestratorGroupId, group && (group.model || (group.models || [])[0]));
+    tmUpdateGenBtn();
+  });
+  tmRenderGroupSelect("tm-agent-group", TEAM.agentGroupId, (id) => {
+    TEAM.agentGroupId = id;
+    const group = TEAM.groups.find((g) => g.id === id);
+    tmSetWorkerModels(group, group && (group.model || (group.models || [])[0]), true);
+    tmUpdateGenBtn();
+  });
+  const leadGroup = TEAM.groups.find((g) => g.id === TEAM.activeGroupId);
+  const orchestratorGroup = TEAM.groups.find((g) => g.id === TEAM.orchestratorGroupId);
+  const workerGroup = TEAM.groups.find((g) => g.id === TEAM.agentGroupId);
+  tmSetSelectModels("tm-model", TEAM.activeGroupId, leadGroup && (leadGroup.model || (leadGroup.models || [])[0]));
+  tmSetSelectModels("tm-orch-model", TEAM.orchestratorGroupId, orchestratorGroup && (orchestratorGroup.model || (orchestratorGroup.models || [])[0]));
+  tmSetWorkerModels(workerGroup, workerGroup && (workerGroup.model || (workerGroup.models || [])[0]));
   tmUpdateGenBtn();
 }
 
-// 拉取所选分组的模型列表，填充模型下拉
-async function tmFetchModels() {
-  const btn = document.getElementById("tm-fetch");
-  const sel = document.getElementById("tm-model");
-  const groupId = TEAM.activeGroupId || undefined;
+function tmRenderGroupSelect(id, selectedId, onChange) {
+  const sel = document.getElementById(id);
+  if (!sel) return;
+  sel.innerHTML = TEAM.groups.length
+    ? TEAM.groups.map((g) => `<option value="${esc(g.id)}">${esc(g.name || g.id)}</option>`).join("")
+    : `<option value="">未配置可用分组（去『路由中转』添加）</option>`;
+  sel.value = selectedId || "";
+  sel.onchange = () => onChange(sel.value);
+}
+
+function tmSetSelectModels(id, groupId, preferred) {
+  const sel = document.getElementById(id);
+  if (!sel) return;
+  const group = TEAM.groups.find((g) => g.id === groupId);
+  const models = Array.from(new Set([
+    preferred,
+    group && group.model,
+    ...((group && group.models) || []),
+  ].map((m) => String(m || "").trim()).filter(Boolean)));
+  sel.innerHTML = models.length
+    ? models.map((m) => `<option value="${esc(m)}">${esc(m)}</option>`).join("")
+    : `<option value="">先拉取模型</option>`;
+  if (preferred && models.includes(preferred)) sel.value = preferred;
+  sel.onchange = tmUpdateGenBtn;
+}
+
+function tmSetWorkerModels(group, preferred, force = false) {
+  const input = document.getElementById("tm-agent-model");
+  const list = document.getElementById("tm-agent-model-list");
+  if (!input || !list) return;
+  TEAM.agentModels = Array.from(new Set([
+    preferred,
+    group && group.model,
+    ...((group && group.models) || []),
+  ].map((m) => String(m || "").trim()).filter(Boolean)));
+  list.innerHTML = TEAM.agentModels.map((m) => `<option value="${esc(m)}"></option>`).join("");
+  if (preferred && (force || !input.value.trim())) input.value = preferred;
+  input.oninput = tmUpdateGenBtn;
+}
+
+// 拉取所选分组的模型列表，填充总控下拉或执行模型 datalist。
+async function tmFetchModelsFor(kind) {
+  const isWorker = kind === "worker";
+  const isOrchestrator = kind === "orchestrator";
+  const btn = document.getElementById(isWorker ? "tm-agent-fetch" : (isOrchestrator ? "tm-orch-fetch" : "tm-fetch"));
+  const groupId = (isWorker ? TEAM.agentGroupId : (isOrchestrator ? TEAM.orchestratorGroupId : TEAM.activeGroupId)) || undefined;
   busy(btn, true, "…");
   try {
     if (!apic.canvasModels) throw new Error("拉取模型能力尚未就绪（后端未接入）");
     const r = await apic.canvasModels(groupId);
     if (!r || !r.ok) throw new Error((r && r.error) || "拉取失败");
     const models = Array.isArray(r.models) ? r.models : [];
-    if (sel) {
-      sel.innerHTML = models.length
-        ? models.map((m) => `<option value="${esc(m)}">${esc(m)}</option>`).join("")
-        : `<option value="">该分组没有可用模型</option>`;
-      sel.onchange = tmUpdateGenBtn;
+    if (isWorker) {
+      TEAM.agentModels = models;
+      const input = document.getElementById("tm-agent-model");
+      const list = document.getElementById("tm-agent-model-list");
+      if (list) list.innerHTML = models.map((m) => `<option value="${esc(m)}"></option>`).join("");
+      if (input && !input.value.trim()) input.value = models[0] || "";
+    } else {
+      const sel = document.getElementById(isOrchestrator ? "tm-orch-model" : "tm-model");
+      if (sel) {
+        sel.innerHTML = models.length
+          ? models.map((m) => `<option value="${esc(m)}">${esc(m)}</option>`).join("")
+          : `<option value="">该分组没有可用模型</option>`;
+        sel.onchange = tmUpdateGenBtn;
+      }
     }
-    document.getElementById("tm-model-hint").textContent = `已拉取 ${models.length} 个模型，选一个用于分析需求`;
+    const hint = document.getElementById(isWorker ? "tm-agent-hint" : (isOrchestrator ? "tm-orch-hint" : "tm-model-hint"));
+    if (hint) hint.textContent = isWorker
+      ? `已拉取 ${models.length} 个模型，选择一个作为子 Agent 执行模型`
+      : isOrchestrator
+        ? `已拉取 ${models.length} 个模型，选择一个作为总控实际执行模型`
+        : `已拉取 ${models.length} 个模型，选择一个用于生成团队配置`;
     tmUpdateGenBtn();
     toast(`已拉取 ${models.length} 个模型`, "ok");
   } catch (e) {
@@ -3236,12 +4920,18 @@ async function tmFetchModels() {
   }
 }
 
+function tmFetchModels() { return tmFetchModelsFor("lead"); }
+function tmFetchOrchestratorModels() { return tmFetchModelsFor("orchestrator"); }
+function tmFetchWorkerModels() { return tmFetchModelsFor("worker"); }
+
 function tmUpdateGenBtn() {
   const btn = document.getElementById("tm-gen");
   if (btn.dataset.busy === "1") return; // 生成中不改动禁用态（由 tmGenerate 收尾复位）
   const req = document.getElementById("tm-req").value.trim();
   const model = document.getElementById("tm-model").value;
-  btn.disabled = !(req && model);
+  const orchestratorModel = document.getElementById("tm-orch-model").value;
+  const workerModel = document.getElementById("tm-agent-model").value.trim();
+  btn.disabled = !(req && model && (TEAM.tool === "claude" || (orchestratorModel && workerModel)));
 }
 
 function tmSetView(w) {
@@ -3259,7 +4949,9 @@ function tmSetView(w) {
 async function tmGenerate() {
   const requirement = document.getElementById("tm-req").value.trim();
   const model = document.getElementById("tm-model").value;
-  if (!requirement || !model) return;
+  const orchestratorModel = document.getElementById("tm-orch-model").value;
+  const workerModel = document.getElementById("tm-agent-model").value.trim();
+  if (!requirement || !model || (TEAM.tool === "codex" && (!orchestratorModel || !workerModel))) return;
   const genBtn = document.getElementById("tm-gen");
   document.getElementById("tm-download").hidden = true;
   // 生成期间禁用按钮并改文案，防止误触重复提交
@@ -3273,7 +4965,10 @@ async function tmGenerate() {
       tool: TEAM.tool,
       groupId: TEAM.activeGroupId || undefined,
       model,
-      agentModel: document.getElementById("tm-agent-model").value.trim(),
+      orchestratorGroupId: TEAM.orchestratorGroupId || undefined,
+      agentGroupId: TEAM.agentGroupId || undefined,
+      agentModel: workerModel || undefined,
+      orchestratorModel: orchestratorModel || undefined,
     });
     if (!r || !r.ok) throw new Error((r && r.error) || "生成失败");
     TEAM.team = r.result;
@@ -3296,7 +4991,8 @@ function tmRenderTeam(team) {
   head.innerHTML =
     `<div class="tm-team-name">${esc(team.project_name || "AI 员工团队")}</div>` +
     (team.summary ? `<div class="tm-team-summary">${esc(team.summary)}</div>` : "") +
-    (stack ? `<div class="tm-team-stack">${stack}</div>` : "");
+    (stack ? `<div class="tm-team-stack">${stack}</div>` : "") +
+    (team.model_routing ? `<div class="tm-team-models">生成：<code>${esc(team.model_routing.generation_model || team.model_routing.analysis_model || "—")}</code>　总控执行：<code>${esc(team.model_routing.orchestrator_model || "继承")}</code>　子 Agent 执行：<code>${esc(team.model_routing.worker_model || "继承")}</code></div>` : "");
   const list = document.getElementById("tm-team-list");
   list.innerHTML = "";
   list.appendChild(tmConvCard(team));
@@ -3345,6 +5041,7 @@ function tmAgentCard(a, isLead) {
        ${isLead ? '<span class="tm-emp-badge">总控</span>' : ""}
        <span class="tm-emp-id">${esc(a.id || "")}</span>
      </div>
+     ${a.model ? `<div class="tm-emp-model">模型：<code>${esc(a.model)}</code></div>` : ""}
      <div class="tm-emp-duty">${esc(a.duty || "")}</div>
      ${resp ? `<div class="tm-sec-label">职责</div><ul class="tm-resp">${resp}</ul>` : ""}
      ${extra}
@@ -3424,10 +5121,10 @@ async function tmDownload() {
           : "生成 .toml 员工 + 总控（调度 / 审核）+ AGENTS.md";
         const hint = document.getElementById("tm-agent-hint");
         const inp = document.getElementById("tm-agent-model");
-        inp.placeholder = isClaude ? "留空＝继承会话模型（推荐），或填 sonnet / opus / haiku" : "留空＝用上面的分析模型，如 gpt-4o";
+        inp.placeholder = isClaude ? "留空＝继承会话模型（推荐），或填 sonnet / opus / haiku" : "必须选择子 Agent 执行模型，如 deepseek-v4-flash";
         hint.textContent = isClaude
           ? "Claude 只认 sonnet / opus / haiku / claude-*；留空则省略 model 字段＝自动继承"
-          : "写进每个员工的 model 字段，改成你运行器支持的模型名";
+          : "生成 Codex 团队时必须明确选择执行模型；总控和员工会分别按模型路由";
         // 已生成的团队：切工具后重新渲染（预览扩展名随之变）
         if (TEAM.team) tmRenderTeam(TEAM.team);
       });
@@ -3435,6 +5132,10 @@ async function tmDownload() {
   }
   const fetchBtn = document.getElementById("tm-fetch");
   if (fetchBtn) fetchBtn.addEventListener("click", tmFetchModels);
+  const orchFetchBtn = document.getElementById("tm-orch-fetch");
+  if (orchFetchBtn) orchFetchBtn.addEventListener("click", tmFetchOrchestratorModels);
+  const agentFetchBtn = document.getElementById("tm-agent-fetch");
+  if (agentFetchBtn) agentFetchBtn.addEventListener("click", tmFetchWorkerModels);
   const genBtn = document.getElementById("tm-gen");
   if (genBtn) genBtn.addEventListener("click", tmGenerate);
   const dlBtn = document.getElementById("tm-download");
@@ -3470,7 +5171,7 @@ async function pmEnter() {
   const sel = document.getElementById("pm-group");
   if (sel) {
     sel.innerHTML = PM.groups.length
-      ? PM.groups.map((g) => `<option value="${esc(g.id)}">${esc(g.name || g.id)}${g.host ? " · " + esc(g.host) : ""}</option>`).join("")
+      ? PM.groups.map((g) => `<option value="${esc(g.id)}">${esc(g.name || g.id)}</option>`).join("")
       : `<option value="">未配置可用分组（去『路由中转』添加）</option>`;
     sel.value = PM.activeGroupId || "";
     sel.onchange = () => { PM.activeGroupId = sel.value; };
@@ -3758,7 +5459,7 @@ function tkRenderStatus(s) {
   const phaseText = document.getElementById("tk-phase-text");
   if (dot) dot.dataset.state = (s && s.phase) || "unknown";
   if (phaseText) {
-    const map = { connected: "已连接", disconnected: "未连接", transcribing: "已连接", recording: "已连接" };
+    const map = { connected: "已连接", disconnected: "未连接", waiting_debug_port: "等待调试端口…", unsupported_packaged: "需官网版", transcribing: "已连接", recording: "已连接" };
     phaseText.textContent = map[(s && s.phase)] || (s && s.phase) || "—";
   }
 }
@@ -3857,6 +5558,9 @@ async function tkEnter() {
 // —— 启动 ——
 wireVoiceControls();
 loadMarket();
-loadSecrets();
-loadVersion();
-loadProxy();
+deferUI(loadSecrets, 800);
+deferUI(loadVersion, 1400);
+window.addEventListener("beforeunload", () => {
+  const snapshot = cvWorkspaceSnapshot();
+  if (snapshot && apic.canvasWorkspaceSaveNow) apic.canvasWorkspaceSaveNow(snapshot);
+});
diff --git a/renderer/canvas-inputs.js b/renderer/canvas-inputs.js
new file mode 100644
index 0000000..2fa100e
--- /dev/null
+++ b/renderer/canvas-inputs.js
@@ -0,0 +1,33 @@
+(function initCanvasInputs(root) {
+  function uniqueNonEmpty(values) {
+    const seen = new Set();
+    return (Array.isArray(values) ? values : []).filter((value) => {
+      const normalized = typeof value === "string" ? value.trim() : "";
+      if (!normalized || seen.has(normalized)) return false;
+      seen.add(normalized);
+      return true;
+    });
+  }
+
+  function collectUpstreamOutputs(node, readNodeOutput) {
+    const out = { text: "", image: "", images: [] };
+    if (!node || !node.inputs || typeof readNodeOutput !== "function") return out;
+
+    for (const key of Object.keys(node.inputs)) {
+      const connections = (node.inputs[key] && node.inputs[key].connections) || [];
+      for (const connection of connections) {
+        const source = readNodeOutput(connection.node) || {};
+        if (source.text && !out.text) out.text = String(source.text).trim();
+        if (source.image) out.images.push(source.image);
+      }
+    }
+
+    out.images = uniqueNonEmpty(out.images);
+    out.image = out.images[0] || "";
+    return out;
+  }
+
+  const api = { uniqueNonEmpty, collectUpstreamOutputs };
+  if (typeof module !== "undefined" && module.exports) module.exports = api;
+  root.CanvasInputs = api;
+})(typeof window !== "undefined" ? window : globalThis);
diff --git a/renderer/index.html b/renderer/index.html
index 59b1574..8cbd26d 100644
--- a/renderer/index.html
+++ b/renderer/index.html
@@ -18,7 +18,7 @@
       </div>
       <div class="brand-text">
         <div class="brand-name">TD工具箱</div>
-        <div class="brand-sub">tokendun 工具箱 · 技能 / 插件 · 路由 · 代理</div>
+        <div class="brand-sub">tokendun 工具箱 · 技能 / 插件 · 路由</div>
       </div>
     </div>
 
@@ -33,7 +33,6 @@
       <button class="tab" data-tab="plugins" role="tab">插件市场</button>
       <button class="tab" data-tab="canvas" role="tab">创意画布</button>
       <button class="tab" data-tab="router" role="tab">路由中转</button>
-      <button class="tab" data-tab="proxy" role="tab">全局代理</button>
       <button class="tab" data-tab="settings" role="tab">设置</button>
     </nav>
   </header>
@@ -84,11 +83,11 @@
           <p class="muted">tokendun 官方自研插件与内置工具</p>
         </div>
         <div class="head-actions">
-          <div class="codex-link-status" title="Codex 桌面连接状态；语音输入与 Token 用量共用此连接">
+          <div class="codex-link-status" title="Codex 注入状态：语音输入、Token 用量和左侧任务行的彻底删除按钮都依赖此连接">
             <span id="codex-link-dot" class="voice-dot" data-state="unknown"></span>
             <span class="codex-link-label">Codex</span>
             <span id="codex-link-phase-text" class="muted small">未连接</span>
-            <button class="btn ghost small" id="codex-link-connect-btn" data-voice-link-connect>连接</button>
+            <button class="btn ghost small" id="codex-link-connect-btn" data-voice-link-connect>连接并注入</button>
             <button class="btn ghost small hidden" id="codex-link-disconnect-btn" data-voice-link-disconnect>断开</button>
           </div>
           <input id="plugin-search" class="search" type="search" placeholder="搜索插件 / 作者…" />
@@ -111,11 +110,11 @@
         </div>
         <div class="tool-card">
           <div class="tool-top"><span class="tool-ico">🎤</span><div class="tool-name">语音输入</div></div>
-          <div class="tool-desc">给 Codex 输入框注入麦克风按钮，说话即转文字填入。需由工具箱重启 Codex 一次以启用调试通道（登录态保留）。</div>
+          <div class="tool-desc">给 ChatGPT/Codex 输入框注入麦克风按钮，说话即转文字填入。需由工具箱重启 ChatGPT 一次以启用调试通道（登录态保留）。</div>
           <div class="tool-foot"><button class="btn primary small" id="voice-enable-card-btn" data-voice-enable data-enable-label="启用" data-enabled-label="已启用">启用</button></div>
         </div>
         <div class="tool-card">
-          <div class="tool-top"><span class="tool-ico">🧑‍💼</span><div class="tool-name">员工团队</div></div>
+          <div class="tool-top"><span class="tool-ico">👥</span><div class="tool-name">员工团队</div></div>
           <div class="tool-desc">用一段话描述项目需求，自动拆解出一支带约束、能协作的 AI 员工团队（含总控 + 契约 + 文件边界 + 协同规范），打包成 Codex / Claude Code 可直接用的配置 zip。</div>
           <div class="tool-foot"><button class="btn primary small" data-open-panel="team">打开</button></div>
         </div>
@@ -129,6 +128,23 @@
           <div class="tool-desc">在 Codex 输入框下方、模型选择左侧显示每日 Token 累计消耗量。复用语音 CDP 连接自动注入，无需额外配置。每天 24 点自动清零。</div>
           <div class="tool-foot"><button class="btn primary small" data-open-panel="token">打开</button></div>
         </div>
+        <div class="tool-card" id="codex-installer-card">
+          <div class="tool-top"><span class="tool-ico">⬇</span><div class="tool-name">安装 Codex</div></div>
+          <div class="tool-desc">Windows / Mac 版远程下载并自动校验安装包，不把大体积安装文件塞进工具箱。下载和安装过程会显示进度。</div>
+          <div class="tool-status muted small" id="codex-installer-status">正在读取安装器信息…</div>
+          <div class="installer-progress hidden" id="codex-installer-progress-wrap">
+            <div class="installer-progress-bar" id="codex-installer-progress-bar"></div>
+          </div>
+          <div class="installer-cancel-row hidden" id="codex-installer-cancel-row">
+            <button class="btn ghost small" id="codex-installer-cancel-btn">取消下载</button>
+          </div>
+          <div class="tool-foot multi">
+            <button class="btn ghost small" id="codex-win-open-url-btn">浏览器打开 Windows</button>
+            <button class="btn primary small" id="codex-win-install-btn">Windows 一键安装</button>
+            <button class="btn ghost small" id="codex-mac-open-url-btn">浏览器打开 Mac</button>
+            <button class="btn primary small" id="codex-mac-install-btn">Mac 一键安装</button>
+          </div>
+        </div>
       </div>
 
       <!-- 已安装插件 -->
@@ -147,18 +163,19 @@
       <div class="panel-head">
         <div>
           <h2><button class="btn ghost small back-btn" data-back-plugins>← 插件市场</button> 语音输入</h2>
-          <p class="muted">由工具箱用 CDP 连接 Codex 桌面版，往输入框注入麦克风按钮；录音经中转站 Whisper 转文字并自动填入。</p>
+          <p class="muted">由工具箱用 CDP 连接 ChatGPT/Codex 桌面版，往输入框注入麦克风按钮；录音经中转站 Whisper 转文字并自动填入。</p>
         </div>
         <div class="head-actions">
           <span id="voice-dot" class="voice-dot" data-state="unknown"></span>
           <span id="voice-phase-text" class="muted small">未连接</span>
           <button id="voice-enable-btn" class="btn primary" data-voice-enable data-enable-label="启用语音输入" data-enabled-label="已启用">启用语音输入</button>
+          <button id="voice-disable-btn" class="btn ghost hidden" data-voice-disable>关闭语音输入</button>
         </div>
       </div>
       <div class="voice-body">
         <div class="voice-card">
           <div class="voice-card-title">状态</div>
-          <div id="voice-detail" class="muted small">点击「启用语音输入」开始。若 Codex 正在运行，会提示你确认重启 Codex 以启用调试端口。</div>
+          <div id="voice-detail" class="muted small">点击「启用语音输入」开始。若 ChatGPT 正在运行，会提示你确认重启 ChatGPT 以启用调试端口。</div>
         </div>
         <div class="voice-card">
           <div class="voice-card-title">转写分组 / 模型</div>
@@ -176,7 +193,7 @@
         <div class="voice-card">
           <div class="voice-card-title">使用说明</div>
           <ol class="voice-ol">
-            <li>点击「启用语音输入」。若 Codex 在运行且未带调试端口，会弹窗提示重启（当前窗口会关闭一次，登录态保留）。</li>
+            <li>点击「启用语音输入」。若 ChatGPT 在运行且未带调试端口，会弹窗提示重启（当前窗口会关闭一次，登录态保留）。</li>
             <li>连接成功后，Codex 输入框旁出现 🎤 按钮。点击 → 授权麦克风权限 → 说话 → 再次点击停止。</li>
             <li>转写完成后文字自动填入输入框。首次需在「系统设置 → 隐私 → 麦克风」允许 ChatGPT。</li>
             <li>macOS 误杀进程风险已规避：仅在确认后重启。Codex 升级后若按钮消失，可能需等待工具箱适配。</li>
@@ -189,27 +206,57 @@
     <section class="panel" id="tab-canvas">
       <div class="cv-toolbar">
         <div class="cv-toolbar-left">
-          <h2 class="cv-title">🎨 创意画布</h2>
+          <button class="cv-nav-dot" type="button" title="画布"></button>
+          <h2 class="cv-title">创意画布</h2>
+          <button class="cv-project-name" id="cv-projects-btn" type="button" title="打开画布记录">未命名画布</button>
           <span class="pc-badge cv-status" id="cv-status">检测中…</span>
         </div>
         <div class="cv-toolbar-right">
-          <span class="cv-add-label">添加节点</span>
-          <button class="btn small" data-cv-add="text">📝 文本</button>
-          <button class="btn small" data-cv-add="image">🖼️ 文生图</button>
-          <button class="btn small" data-cv-add="video">🎬 图生视频</button>
-          <button class="btn small" data-cv-add="grokVideo">🎞️ Grok视频</button>
-          <button class="btn small" data-cv-add="tts">🔊 TTS配音</button>
+          <button class="btn small ghost" id="cv-new-btn">＋ 新建画布</button>
           <button class="btn small ghost" id="cv-models-btn">🔄 拉取模型</button>
           <button class="btn small ghost" id="cv-seed-btn">✨ 载入示例</button>
           <button class="btn small primary" id="cv-full-btn">⛶ 全屏</button>
         </div>
       </div>
+      <div class="cv-tool-rail" aria-label="添加节点">
+        <button class="cv-rail-btn" type="button" data-cv-add="text" title="文本">T</button>
+        <button class="cv-rail-btn" type="button" data-cv-add="image" title="文生图">▧</button>
+        <button class="cv-rail-btn" type="button" data-cv-add="video" title="图生视频">▣</button>
+        <button class="cv-rail-btn" type="button" data-cv-add="grokVideo" title="Grok视频">◆</button>
+        <button class="cv-rail-btn" type="button" data-cv-add="tts" title="TTS配音">♪</button>
+      </div>
       <div class="cv-stage">
+        <div class="cv-project-picker hidden" id="cv-project-picker" role="dialog" aria-label="画布记录">
+          <div class="cv-project-picker-head">
+            <div><b>画布记录</b><span>自动保存到本机，生成素材也会缓存</span></div>
+            <button class="cv-project-close" id="cv-project-close" type="button" title="关闭">×</button>
+          </div>
+          <div class="cv-project-actions">
+            <button class="btn small primary" id="cv-project-create" type="button">＋ 新建画布</button>
+          </div>
+          <div class="cv-project-list" id="cv-project-list"></div>
+        </div>
         <div id="drawflow"></div>
+        <div class="cv-empty-hint" id="cv-empty-hint">
+          <span>✳ 双击</span>
+          <b>画布任意空白处，自由生成</b>
+        </div>
+        <div class="cv-quick-menu hidden" id="cv-quick-menu">
+          <div class="cv-quick-title">新建节点</div>
+          <button type="button" data-cv-quick-add="text"><span>T</span>文本生成</button>
+          <button type="button" data-cv-quick-add="image"><span>▧</span>图片生成</button>
+          <button type="button" data-cv-quick-add="video"><span>▣</span>视频生成</button>
+          <button type="button" data-cv-quick-add="grokVideo"><span>◆</span>Grok 视频</button>
+          <button type="button" data-cv-quick-add="tts"><span>♪</span>音频 / TTS</button>
+        </div>
         <div class="cv-zoom">
-          <button class="cv-zoom-btn" id="cv-zoom-in" title="放大 (Ctrl+滚轮)">＋</button>
+          <button class="cv-zoom-btn" id="cv-zoom-out" title="缩小">－</button>
+          <input id="cv-zoom-range" class="cv-zoom-range" type="range" min="50" max="160" step="5" value="100" aria-label="画布缩放" />
           <button class="cv-zoom-btn cv-zoom-level" id="cv-zoom-reset" title="点击重置为 100%">100%</button>
-          <button class="cv-zoom-btn" id="cv-zoom-out" title="缩小 (Ctrl+滚轮)">－</button>
+          <button class="cv-zoom-btn" id="cv-zoom-in" title="放大">＋</button>
+        </div>
+        <div class="cv-minimap" aria-hidden="true">
+          <div class="cv-minimap-view"><span></span></div>
         </div>
         <div class="cv-mask hidden" id="cv-mask">
           <div class="cv-mask-box">
@@ -241,19 +288,34 @@
           </div>
 
           <div class="tm-field">
-            <label class="tm-label">分析模型（中转分组）</label>
+            <label class="tm-label">团队生成模型（仅用于生成配置）</label>
             <div class="tm-row">
               <select class="tm-select" id="tm-group"></select>
               <button class="btn small ghost" id="tm-fetch">🔄 拉取模型</button>
             </div>
             <select class="tm-select" id="tm-model" style="margin-top:8px"></select>
-            <div class="tm-hint" id="tm-model-hint">先在『路由中转』配置好分组，再选具体模型</div>
+            <div class="tm-hint" id="tm-model-hint">只负责把需求转换成团队配置；它不会决定生成后 Agent 执行任务使用的模型</div>
           </div>
 
           <div class="tm-field">
-            <label class="tm-label">员工运行模型（可选）</label>
-            <input id="tm-agent-model" class="tm-text" placeholder="留空＝用上面的分析模型，如 gpt-4o" />
-            <div class="tm-hint" id="tm-agent-hint">写进每个员工的 model 字段，改成你运行器支持的模型名</div>
+            <label class="tm-label">总控执行模型（生成后实际运行）</label>
+            <div class="tm-row">
+              <select class="tm-select" id="tm-orch-group"></select>
+              <button class="btn small ghost" id="tm-orch-fetch">🔄 拉取模型</button>
+            </div>
+            <select class="tm-select" id="tm-orch-model" style="margin-top:8px"></select>
+            <div class="tm-hint" id="tm-orch-hint">总控负责调度、设计、审计、验收和多模态任务；可以和团队生成模型不同</div>
+          </div>
+
+          <div class="tm-field">
+            <label class="tm-label">子 Agent 执行模型</label>
+            <div class="tm-row">
+              <select class="tm-select" id="tm-agent-group"></select>
+              <button class="btn small ghost" id="tm-agent-fetch">🔄 拉取模型</button>
+            </div>
+            <input id="tm-agent-model" class="tm-text" list="tm-agent-model-list" style="margin-top:2px" placeholder="选择或填写 DeepSeek 模型，如 deepseek-v4-flash" />
+            <datalist id="tm-agent-model-list"></datalist>
+            <div class="tm-hint" id="tm-agent-hint">子 Agent 负责编码、测试和文档；模型名会写入员工配置，并自动登记到对应路由分组</div>
           </div>
 
           <button id="tm-gen" class="btn primary tm-gen" disabled>生成员工团队</button>
@@ -267,7 +329,7 @@
           </div>
           <div class="tm-result-body">
             <div class="tm-empty" id="tm-empty">
-              <div class="tm-empty-ico">🧑‍💼→👥</div>
+              <div class="tm-empty-ico">👤→👥</div>
               <p class="tm-empty-title">描述需求，自动组建 AI 员工团队</p>
               <p class="tm-empty-sub">拆解职责 · 定义契约 · 划分文件边界 · 生成协同规范</p>
             </div>
@@ -413,7 +475,7 @@
       <div class="panel-head">
         <div>
           <h2><button class="btn ghost small back-btn" data-back-plugins>← 插件市场</button> 会话记录</h2>
-          <p class="muted">直接读取本机 <code>~/.codex/sessions</code>，全量模式会同时读取 <code>archived_sessions</code> 和子任务会话</p>
+          <p class="muted">直接读取所选 Codex 数据目录的 <code>sessions</code>；全量模式会同时读取 <code>archived_sessions</code> 和子任务会话</p>
         </div>
         <div class="head-actions">
           <input id="sess-search" class="search" type="search" placeholder="搜索标题 / 项目…" />
@@ -424,6 +486,12 @@
           <button id="sess-backup" class="btn">备份全部…</button>
         </div>
       </div>
+      <div class="session-data-dir" id="session-data-dir">
+        <span class="muted small">Codex 会话数据目录</span>
+        <code id="session-data-dir-path">读取中…</code>
+        <button id="session-data-dir-select" class="btn ghost small">选择目录…</button>
+        <button id="session-data-dir-reset" class="btn ghost small hidden">恢复默认</button>
+      </div>
       <div class="sync-banner">
         <div class="sync-text">
           <strong>🔄 同步会话到当前账号</strong>
@@ -442,7 +510,10 @@
           <div class="sess-conv hidden" id="sess-conv">
             <div class="sess-conv-head">
               <div class="sess-conv-title" id="sess-conv-title"></div>
-              <button id="sess-export" class="btn small">导出为 Markdown</button>
+              <div class="sess-conv-actions">
+                <button id="sess-delete" class="btn small danger">永久删除</button>
+                <button id="sess-export" class="btn small">导出为 Markdown</button>
+              </div>
             </div>
             <div class="sess-messages" id="sess-messages"></div>
           </div>
@@ -476,6 +547,7 @@
           工作方式：会话静默几分钟后自动摘要（优先走「路由中转」当前分组的 LLM，失败退化为本地提取）。
           项目根目录会生成 <code>HANDOFF.md</code>（状态快照），并在 <code>AGENTS.md</code> 里加一段「先读 HANDOFF」引导（带标记，可随时删）。
         </p>
+        <p class="muted small" style="margin:6px 0 0">正在监视：<code id="mem-data-dir-path">读取中…</code></p>
       </div>
 
       <div class="panel-head" style="margin-top:14px">
@@ -510,6 +582,7 @@
             <button id="router-apply" class="btn primary">启用本地路由（高级）</button>
             <button id="router-apply-claude" class="btn">接入 Claude Code</button>
             <button id="router-toggle" class="btn">启动</button>
+            <button id="router-refresh-codex" class="btn ghost" title="仅当需要同步 Codex 顶部模型选择器时重启 Codex">刷新 Codex 显示</button>
           </div>
         </div>
         <div class="row">
@@ -533,6 +606,31 @@
       </div>
       <div id="router-groups" class="checklist"></div>
 
+      <!-- 默认账号配置详情 -->
+      <div id="default-config-modal" class="modal-overlay hidden">
+        <div class="modal default-config-modal">
+          <div class="modal-head"><h3>默认账号配置（只读）</h3><button class="modal-close" id="default-config-close">✕</button></div>
+          <div class="modal-body">
+            <div id="default-config-summary" class="default-config-summary"></div>
+            <label class="field grow" style="margin-top:12px">
+              <span>当前 ~/.codex/config.toml</span>
+              <textarea id="default-config-current" class="config-textarea" readonly></textarea>
+            </label>
+            <label class="field grow" style="margin-top:12px">
+              <span>默认分组保存的原始快照（切回默认时参考）</span>
+              <textarea id="default-config-snapshot" class="config-textarea" readonly></textarea>
+            </label>
+            <div class="row between" style="margin-top:12px">
+              <span class="muted small">auth.json 仅展示脱敏摘要，不回显密钥或登录 token。</span>
+              <div class="btn-group">
+                <button type="button" class="btn ghost small" id="default-config-refresh">刷新</button>
+                <button type="button" class="btn small" id="default-config-copy">复制当前 config</button>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+
       <!-- 分组编辑弹窗 -->
       <div id="grp-modal" class="modal-overlay hidden">
         <div class="modal">
@@ -549,16 +647,26 @@
             </label>
             <label class="field grow" style="margin-top:10px"><span>API 地址（base_url）</span><input id="grp-url" placeholder="https://api.xxx.com" /></label>
             <label class="field grow" style="margin-top:10px"><span>API 密钥</span><input id="grp-key" type="password" placeholder="sk-…" /></label>
-            <label class="field grow" style="margin-top:10px;flex-direction:row;align-items:center;gap:8px;cursor:pointer">
-              <input id="grp-codex-image" type="checkbox" style="width:auto;margin:0" />
-              <span style="margin:0">在 Codex 中用于生图（写入 gen-image 技能，需支持 OpenAI 图片接口）</span>
-            </label>
-            <label class="field grow" style="margin-top:10px;flex-direction:row;align-items:center;gap:8px;cursor:pointer">
-              <input id="grp-stt" type="checkbox" style="width:auto;margin:0" />
-              <span style="margin:0">支持语音转文字（语音输入插件用此分组转写）</span>
-            </label>
-            <label class="field grow" style="margin-top:8px">
-              <span>语音转写模型（勾选 STT 后填，如 whisper-1 / speech-01）</span>
+            <div class="grp-purpose">
+              <label class="grp-purpose-pill">
+                <input id="grp-codex-image" type="checkbox" />
+                <span>生图专用</span>
+              </label>
+              <label class="grp-purpose-pill">
+                <input id="grp-codex-video" type="checkbox" />
+                <span>视频专用</span>
+              </label>
+              <label class="grp-purpose-pill">
+                <input id="grp-stt" type="checkbox" />
+                <span>语音专用</span>
+              </label>
+              <label class="grp-purpose-pill" title="只用于当前 DeepSeek 分组的附件识别，不会替换对话模型">
+                <input id="grp-multimodal" type="checkbox" />
+                <span>启用 MiniMax 多模态</span>
+              </label>
+            </div>
+            <label class="field grow hidden" id="grp-stt-model-field" style="margin-top:8px">
+              <span>语音专用模型（如 whisper-1 / speech-01）</span>
               <input id="grp-stt-model" placeholder="whisper-1" />
             </label>
             <div class="field grow" style="margin-top:10px">
@@ -607,61 +715,6 @@
       </div>
     </section>
 
-    <!-- ⑤ 全局代理 -->
-    <section class="panel" id="tab-proxy">
-      <div class="panel-head">
-        <div>
-          <h2>全局代理</h2>
-          <p class="muted">填入 SOCKS5 代理，一键把<b>整台电脑</b>(全局 TUN)或<b>系统</b>的网络切到代理上。支持要密码的 SOCKS5。</p>
-        </div>
-      </div>
-
-      <div class="card action-card">
-        <label class="field grow">
-          <span>SOCKS5 代理地址</span>
-          <input id="proxy-str" type="text" placeholder="host:port:user:pass  例如 1.2.3.4:1080:用户名:密码" />
-        </label>
-        <div class="row between">
-          <span class="muted small" id="proxy-parsed">支持格式：<code>host:port:user:pass</code> / <code>host:port</code> / <code>socks5://user:pass@host:port</code></span>
-          <div class="btn-group">
-            <button id="proxy-save" class="btn ghost">保存</button>
-            <button id="proxy-test" class="btn">测试连接</button>
-          </div>
-        </div>
-        <div id="proxy-test-out" class="muted small" style="margin-top:6px"></div>
-      </div>
-
-      <div class="card action-card">
-        <div class="row between">
-          <div class="field">
-            <span>当前状态</span>
-            <div><span class="pc-badge" id="proxy-state">未开启</span> <span class="muted small" id="proxy-state-detail"></span></div>
-          </div>
-          <div class="btn-group">
-            <button id="proxy-start-global" class="btn primary">启动全局代理（整机）</button>
-            <button id="proxy-start-system" class="btn">启动系统代理</button>
-            <button id="proxy-stop" class="btn ghost hidden">关闭代理</button>
-          </div>
-        </div>
-        <div class="proxy-modes">
-          <div class="pm-item">
-            <b>🌐 全局代理（整机 TUN）</b>
-            <span class="muted small">创建虚拟网卡接管<b>所有</b>程序的流量(含命令行、各类 App)。macOS/Windows 启动时会弹一次<b>系统管理员密码</b>——创建网卡必需，和 Clash 一样。</span>
-          </div>
-          <div class="pm-item">
-            <b>⚙️ 系统代理</b>
-            <span class="muted small">只设操作系统代理，<b>不需要管理员密码</b>。浏览器和多数 App 生效；不认系统代理的程序(部分命令行)不走。</span>
-          </div>
-        </div>
-      </div>
-
-      <div class="card action-card">
-        <p class="muted small" style="margin:0">
-          <b>说明</b>：本功能内置 sing-box 引擎在本地做中转，因此即使 SOCKS5 需要账号密码也能正常用于系统代理(操作系统本身不发密码，靠本地中转补上)。关闭软件会自动还原网络设置。
-        </p>
-      </div>
-    </section>
-
     <!-- 设置 -->
     <section class="panel" id="tab-settings">
       <div class="panel-head"><div><h2>设置</h2><p class="muted">密钥用系统安全存储加密后保存在本机</p></div></div>
@@ -764,6 +817,7 @@
   </div>
 
   <script src="vendor/drawflow.min.js"></script>
+  <script src="canvas-inputs.js"></script>
   <script src="app.js"></script>
 </body>
 </html>
diff --git a/renderer/styles.css b/renderer/styles.css
index cf15c55..8cc8182 100644
--- a/renderer/styles.css
+++ b/renderer/styles.css
@@ -141,12 +141,6 @@ h3 { margin: 0; font-size: 16px; }
 .cl-warn { margin-top: 6px; font-size: 12px; color: #f59e0b;
   background: rgba(245,158,11,.1); border-radius: 8px; padding: 6px 9px; }
 .pc-badge.on { background: rgba(74,222,128,.18); color: var(--ok); }
-/* 全局代理：两种模式说明块 */
-.proxy-modes { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin-top: 14px; }
-.pm-item { display: flex; flex-direction: column; gap: 5px; padding: 12px 14px;
-  border: 1px solid var(--border); border-radius: 10px; background: rgba(255,255,255,.02); }
-.pm-item b { font-size: 14px; }
-@media (max-width: 760px) { .proxy-modes { grid-template-columns: 1fr; } }
 .pc-name { font-weight: 700; font-size: 15px; word-break: break-all; }
 .pc-meta { color: var(--muted); font-size: 12px; display: flex; gap: 10px;
   flex-wrap: wrap; }
@@ -166,8 +160,12 @@ h3 { margin: 0; font-size: 16px; }
   cursor: pointer; transition: .12s; }
 .cl-item:hover { border-color: var(--accent); }
 .cl-item input { width: 17px; height: 17px; accent-color: var(--accent); }
+.cl-item.is-disabled { cursor: default; opacity: .82; }
+.cl-item.is-disabled:hover { border-color: var(--border); }
+.cl-item input:disabled { cursor: not-allowed; opacity: .45; }
 .cl-item .cl-name { font-weight: 600; }
 .cl-item .cl-src { color: var(--muted); font-size: 12px; }
+.cl-tool-hint { color: var(--muted); font-size: 12px; margin-top: 4px; }
 .cl-item .cl-size { margin-left: auto; color: var(--muted); font-size: 12px; }
 
 /* 路由分组：按协议族分两栏，各一个单选，可同时激活 */
@@ -222,7 +220,7 @@ h3 { margin: 0; font-size: 16px; }
 /* Toast */
 .toast { position: fixed; bottom: 60px; left: 50%; transform: translateX(-50%);
   background: var(--card); border: 1px solid var(--border); color: var(--text);
-  padding: 12px 20px; border-radius: 12px; box-shadow: var(--shadow); z-index: 50;
+  padding: 12px 20px; border-radius: 12px; box-shadow: var(--shadow); z-index: 10060;
   max-width: 80%; font-size: 13px; }
 .toast.ok { border-color: var(--ok); }
 .toast.err { border-color: var(--danger); }
@@ -232,6 +230,11 @@ h3 { margin: 0; font-size: 16px; }
 .installing { pointer-events: none; opacity: .7; }
 
 /* 会话记录：同步横幅 */
+.session-data-dir { display: flex; align-items: center; gap: 8px; flex-wrap: wrap;
+  margin-bottom: 12px; padding: 9px 12px; border: 1px solid var(--border); border-radius: var(--radius);
+  background: var(--card-2); }
+.session-data-dir code { min-width: 0; max-width: min(620px, 55vw); overflow: hidden;
+  text-overflow: ellipsis; white-space: nowrap; color: var(--text); }
 .sync-banner { display: flex; align-items: center; justify-content: space-between;
   gap: 14px; background: linear-gradient(135deg, rgba(124,133,255,.12), rgba(168,85,247,.10));
   border: 1px solid var(--border); border-radius: var(--radius); padding: 12px 16px;
@@ -266,6 +269,9 @@ h3 { margin: 0; font-size: 16px; }
 .sess-conv { display: flex; flex-direction: column; height: 100%; }
 .sess-conv-head { display: flex; align-items: center; justify-content: space-between;
   gap: 10px; padding: 12px 16px; border-bottom: 1px solid var(--border); }
+.sess-conv-actions { display: flex; align-items: center; gap: 7px; }
+.sess-conv-actions .btn.danger { color: var(--danger); border-color: rgba(255,107,107,.38); }
+.sess-conv-actions .btn.danger:hover { background: rgba(255,107,107,.12); border-color: var(--danger); }
 .sess-conv-title { font-weight: 700; font-size: 14px; white-space: nowrap;
   overflow: hidden; text-overflow: ellipsis; }
 .sess-messages { overflow-y: auto; padding: 16px; display: flex;
@@ -294,7 +300,7 @@ h3 { margin: 0; font-size: 16px; }
 
 /* 说明弹窗 */
 .modal-overlay { position: fixed; inset: 0; background: rgba(0, 0, 0, .5);
-  display: flex; align-items: center; justify-content: center; z-index: 100;
+  display: flex; align-items: center; justify-content: center; z-index: 10050;
   padding: 24px; animation: fade .15s ease; }
 .modal { background: var(--card); border: 1px solid var(--border);
   border-radius: var(--radius); box-shadow: var(--shadow); max-width: 640px;
@@ -325,9 +331,31 @@ h3 { margin: 0; font-size: 16px; }
   border: 1px solid var(--border); color: var(--text); border-radius: 10px;
   padding: 9px 12px; outline: none; font-size: 13px; }
 .grp-select:focus { border-color: var(--accent); }
+.grp-purpose { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; margin-top: 12px; }
+.grp-purpose-pill {
+  min-height: 36px; display: inline-flex; align-items: center; gap: 8px; flex: 1 1 0;
+  min-width: 112px; padding: 8px 12px; border: 1px solid var(--border);
+  border-radius: 10px; background: var(--bg-2); color: var(--text);
+  font-size: 13px; font-weight: 600; cursor: pointer; user-select: none;
+}
+.grp-purpose-pill:hover { border-color: var(--accent); background: var(--card-2); }
+.grp-purpose-pill input {
+  flex: none; width: 15px; height: 15px; margin: 0; accent-color: var(--accent); cursor: pointer;
+}
+.grp-purpose-pill span { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.default-config-modal { max-width: 820px; }
+.default-config-summary { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 8px; }
+.default-config-summary div { min-width: 0; border: 1px solid var(--border); border-radius: 10px;
+  background: var(--bg-2); padding: 9px 11px; color: var(--muted); font-size: 12px; line-height: 1.45; }
+.default-config-summary b { display: block; color: var(--text); font-size: 13px; margin-bottom: 2px; }
+.config-textarea { width: 100%; min-height: 180px; resize: vertical; border: 1px solid var(--border);
+  border-radius: 10px; background: var(--bg-2); color: var(--text); padding: 10px 12px;
+  font: 12px/1.55 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; outline: none; }
+.config-textarea:focus { border-color: var(--accent); }
 .grp-1m-list { margin-top: 8px; display: flex; flex-direction: column; gap: 2px;
   max-height: 180px; overflow-y: auto; border: 1px solid var(--border);
   border-radius: 10px; padding: 6px; background: var(--bg-2); }
+@media (max-width: 720px) { .default-config-summary { grid-template-columns: 1fr; } }
 .grp-1m-item { display: flex; align-items: center; gap: 8px; padding: 5px 7px;
   border-radius: 7px; cursor: pointer; font-size: 13px; }
 .grp-1m-item:hover { background: var(--card); }
@@ -335,6 +363,7 @@ h3 { margin: 0; font-size: 16px; }
 .grp-1m-item span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .claudedesk-block > span:first-child { font-weight: 600; font-size: 13px; }
 .claudedesk-block .btn:disabled { opacity: .45; cursor: not-allowed; }
+.claudedesk-block.hidden { display: none !important; }
 
 /* —— 会话记忆 —— */
 .mem-item { background: var(--card); border: 1px solid var(--border);
@@ -499,52 +528,194 @@ h3 { margin: 0; font-size: 16px; }
 .tool-name { font-weight: 700; font-size: 15px; }
 .tool-desc { color: var(--muted); font-size: 13px; line-height: 1.6; flex: 1; }
 .tool-foot { display: flex; justify-content: flex-end; }
+.tool-foot.multi { justify-content: space-between; align-items: center; gap: 8px; flex-wrap: wrap; }
+.tool-status { min-height: 18px; line-height: 1.5; }
+.installer-progress { width: 100%; height: 8px; overflow: hidden; border-radius: 999px;
+  background: var(--card-2); border: 1px solid var(--border); }
+.installer-progress-bar { width: 0%; height: 100%; border-radius: inherit;
+  background: var(--accent); transition: width .18s ease; }
+.installer-cancel-row { display: flex; justify-content: flex-end; margin-top: -2px; }
 .back-btn { margin-right: 8px; vertical-align: middle; padding: 4px 10px; }
 
 /* ============================================================
    创意画布（Drawflow 节点画布）
    复用 :root 设计变量，覆写 Drawflow 默认外观，明/暗色协调。
    ============================================================ */
+#tab-canvas {
+  color-scheme: dark;
+  --text: #f6f6f6;
+  --muted: #999999;
+  --border: rgba(255,255,255,.08);
+  --bg: #0a0a0a;
+  --card: #161616;
+  --card-2: #1d1d1d;
+  --cv-accent: #ff6a2c;
+  --cv-accent-strong: #ff7f42;
+  --cv-accent-soft: rgba(255, 106, 44, .14);
+  --cv-blue: #3b82f6;
+  --cv-warn: #f59e0b;
+  --cv-shell: #0a0a0a;
+  --cv-surface: #161616;
+  --cv-surface-2: #1d1d1d;
+  --cv-panel-glass: rgba(35,35,41,.82);
+  --cv-field: #1d1d1d;
+  --cv-canvas: #0a0a0a;
+  --cv-grid-major: rgba(255,255,255,.055);
+  --cv-grid-minor: rgba(255,255,255,.032);
+  --cv-shadow-soft: 0 25px 50px -12px rgba(0,0,0,.25);
+  --cv-shadow-card: 0 8px 28px rgba(0,0,0,.42);
+}
+
+@media (prefers-color-scheme: light) {
+  #tab-canvas {
+    color-scheme: light;
+  }
+}
+
 /* 画布面板占满内容区高度：工具条固定 + 画布撑满剩余空间 */
 /* 画布面板占满内容区高度：抵消 .content 的 22px padding，铺满更大气 */
 #tab-canvas.active { display: flex; flex-direction: column; min-height: 0;
-  margin: -22px; height: calc(100% + 44px); padding: 22px; }
-.cv-toolbar { display: flex; align-items: center; justify-content: space-between;
-  gap: 12px; flex-wrap: wrap; margin-bottom: 12px; }
-.cv-toolbar-left { display: flex; align-items: center; gap: 12px; }
-.cv-title { font-size: 18px; }
-.cv-status { border: 1px solid var(--border); background: var(--card-2); color: var(--muted); }
-.cv-status.on { background: rgba(74,222,128,.18); color: var(--ok); border-color: transparent; }
-.cv-status.off { background: rgba(255,107,107,.16); color: var(--danger); border-color: transparent; }
-.cv-toolbar-right { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
-.cv-add-label { color: var(--muted); font-size: 12px; font-weight: 600; margin-right: 2px; }
+  position: relative; margin: -22px; height: calc(100% + 44px); padding: 0; gap: 0;
+  overflow: hidden; background: var(--cv-canvas); }
+.cv-toolbar { position: absolute; top: 12px; left: 12px; right: 12px; z-index: 30;
+  display: flex; align-items: center; justify-content: space-between;
+  gap: 12px; flex-wrap: nowrap; margin-bottom: 0; padding: 0; pointer-events: none; }
+.cv-toolbar-left,
+.cv-toolbar-right { display: flex; align-items: center; gap: 7px; min-height: 34px;
+  pointer-events: auto; padding: 4px 6px; border-radius: 999px;
+  border: 1px solid var(--border); background: rgba(22,22,22,.96);
+  box-shadow: 0 4px 12px rgba(0,0,0,.28); }
+.cv-toolbar-left { min-width: 0; }
+.cv-nav-dot { width: 24px; height: 24px; border: 0; border-radius: 999px; cursor: default;
+  background: radial-gradient(circle at 38% 36%, #ffb077, var(--cv-accent));
+  box-shadow: 0 0 0 4px rgba(255,138,77,.12); }
+.cv-title { position: relative; display: inline-flex; align-items: center; gap: 8px;
+  font-size: 14px; letter-spacing: 0; font-weight: 760; white-space: nowrap; }
+.cv-title::before { content: none; }
+.cv-status { border: 1px solid color-mix(in srgb, var(--border) 74%, transparent);
+  background: rgba(29,29,29,.9); color: var(--muted); box-shadow: none; }
+.cv-status.on { background: rgba(16,185,129,.10); color: #059669; border-color: rgba(16,185,129,.22); }
+.cv-status.off { background: rgba(255,107,107,.13); color: var(--danger); border-color: rgba(255,107,107,.28); }
+#tab-canvas .cv-toolbar .btn { min-height: 30px; padding: 6px 10px; border-radius: 8px;
+  background: rgba(29,29,29,.9); color: var(--text);
+  border-color: var(--border); box-shadow: none; }
+#tab-canvas .cv-toolbar .btn:hover { border-color: rgba(255,138,77,.42);
+  background: color-mix(in srgb, var(--cv-accent-soft) 46%, var(--cv-surface-2)); }
+#tab-canvas .cv-toolbar .btn.primary { background: var(--cv-blue); border-color: transparent;
+  color: #fff; box-shadow: 0 9px 18px rgba(59,130,246,.22); }
+#tab-canvas .cv-toolbar .btn.primary:hover { background: #2563eb; filter: none; }
+.cv-project-name { max-width: 220px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  border: 0; background: transparent; color: var(--text); font: inherit; font-size: 12px; font-weight: 680;
+  padding: 5px 7px; border-radius: 6px; cursor: pointer; }
+.cv-project-name:hover { background: var(--cv-surface-2); }
+
+.cv-tool-rail { position: absolute; left: 18px; top: 50%; transform: translateY(-50%);
+  z-index: 28; display: flex; flex-direction: column; align-items: center; gap: 4px;
+  width: 50px; padding: 7px; box-sizing: border-box;
+  border: 1px solid var(--border); border-radius: 26px;
+  background: rgba(22,22,22,.96); box-shadow: 0 8px 18px rgba(0,0,0,.24); }
+.cv-rail-btn { width: 36px; height: 36px; border: 0; border-radius: 999px;
+  display: grid; place-items: center; color: #8b96a8; background: transparent;
+  font-weight: 760; font-size: 13px; cursor: pointer;
+  transition: background-color .14s, color .14s; }
+.cv-rail-btn:hover { color: var(--text); background: var(--cv-surface-2); box-shadow: none; }
 
 /* 画布舞台：明确高度（Drawflow 容器需要），点阵底纹 */
 .cv-stage { position: relative; flex: 1; min-height: 560px;
-  border: 1px solid var(--border); border-radius: var(--radius); overflow: hidden;
-  box-shadow: var(--shadow); }
+  border: 0; border-radius: 0; overflow: hidden; box-shadow: none; background: var(--cv-canvas); }
+.cv-stage::before { content: ""; position: absolute; inset: 0; z-index: 1; pointer-events: none;
+  background: radial-gradient(circle at 50% 42%, rgba(255,255,255,.025), transparent 44%);
+  box-shadow: inset 0 0 0 1px rgba(255,255,255,.04); }
+.cv-project-picker { position: absolute; z-index: 40; top: 14px; left: 50%; transform: translateX(-50%);
+  width: min(520px, calc(100% - 28px)); max-height: min(620px, calc(100% - 28px)); overflow: auto;
+  border: 1px solid rgba(255,255,255,.12); border-radius: 10px; background: #171717;
+  box-shadow: 0 20px 55px rgba(0,0,0,.48); padding: 14px; box-sizing: border-box; }
+.cv-project-picker.hidden { display: none; }
+.cv-project-picker-head { display: flex; justify-content: space-between; align-items: flex-start; gap: 14px; }
+.cv-project-picker-head b { display: block; color: var(--text); font-size: 15px; }
+.cv-project-picker-head span { display: block; margin-top: 4px; color: var(--muted); font-size: 12px; }
+.cv-project-close { width: 28px; height: 28px; border: 0; border-radius: 6px; color: var(--muted); background: transparent; font-size: 22px; line-height: 1; cursor: pointer; }
+.cv-project-close:hover { color: var(--text); background: var(--cv-surface-2); }
+.cv-project-actions { display: flex; justify-content: flex-end; margin: 12px 0 10px; }
+.cv-project-list { display: grid; gap: 6px; }
+.cv-project-item { display: grid; grid-template-columns: minmax(0,1fr) auto; gap: 12px; align-items: center; padding: 11px;
+  border: 1px solid rgba(255,255,255,.08); border-radius: 8px; background: #1c1c1c; }
+.cv-project-item.active { border-color: rgba(59,130,246,.58); background: rgba(59,130,246,.08); }
+.cv-project-info { min-width: 0; }
+.cv-project-title { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--text); font-size: 13px; font-weight: 680; }
+.cv-project-title-input { width: 100%; height: 30px; box-sizing: border-box; border: 1px solid rgba(59,130,246,.7);
+  border-radius: 6px; outline: none; background: #111; color: var(--text); padding: 5px 8px; font: inherit; font-size: 13px; }
+.cv-project-meta { margin-top: 4px; color: var(--muted); font-size: 11px; }
+.cv-project-item-actions { display: flex; align-items: center; gap: 6px; }
+.cv-project-icon { width: 30px; height: 30px; display: grid; place-items: center; padding: 0; border: 0; border-radius: 6px;
+  background: transparent; color: var(--muted); font-size: 16px; line-height: 1; cursor: pointer; }
+.cv-project-icon:hover { background: var(--cv-surface-2); color: var(--text); }
+.cv-project-icon.ok { color: #6ee7a0; }
+.cv-project-open { min-height: 30px; }
+.cv-project-empty { padding: 24px 8px; text-align: center; color: var(--muted); font-size: 13px; }
 #drawflow { position: absolute; inset: 0; width: 100%; height: 100%;
-  background-color: var(--bg-2);
-  background-image: radial-gradient(var(--border) 1px, transparent 1px);
-  background-size: 22px 22px; }
+  z-index: 2; background-color: var(--cv-canvas);
+  background-image:
+    linear-gradient(var(--cv-grid-major) 1px, transparent 1px),
+    linear-gradient(90deg, var(--cv-grid-major) 1px, transparent 1px),
+    radial-gradient(var(--cv-grid-minor) 1px, transparent 1px);
+  background-size: 112px 112px, 112px 112px, 22px 22px;
+  background-position: -1px -1px, -1px -1px, 0 0; }
 
 /* 悬浮缩放控件（右下角，覆盖在画布上） */
 .cv-zoom { position: absolute; right: 14px; bottom: 14px; z-index: 15;
-  display: flex; flex-direction: column; gap: 1px; border-radius: 10px; overflow: hidden;
-  border: 1px solid var(--border); box-shadow: var(--shadow); }
-.cv-zoom-btn { border: 0; background: var(--card); color: var(--text);
-  width: 38px; height: 34px; cursor: pointer; font-size: 17px; font-weight: 700;
+  left: 50%; right: auto; transform: translateX(-50%);
+  display: flex; align-items: center; justify-content: center; gap: 4px;
+  width: min(436px, calc(100vw - 72px)); min-height: 46px; border-radius: 999px; overflow: hidden;
+  border: 1px solid var(--border);
+  background: rgba(22,22,22,.96);
+  box-shadow: 0 4px 12px rgba(0,0,0,.28); padding: 5px; }
+.cv-zoom-btn { border: 0; background: transparent; color: var(--text);
+  width: 30px; height: 30px; border-radius: 8px; cursor: pointer; font-size: 15px; font-weight: 750;
   line-height: 1; display: flex; align-items: center; justify-content: center;
-  transition: .12s; user-select: none; }
-.cv-zoom-btn:hover { background: var(--accent); color: #fff; }
+  transition: background-color .12s, color .12s, transform .12s; user-select: none; }
+.cv-zoom-btn:hover { background: var(--cv-accent); color: #fff; }
 .cv-zoom-btn:active { transform: scale(.94); }
-.cv-zoom-level { font-size: 11px; font-weight: 600; color: var(--muted);
-  border-top: 1px solid var(--border); border-bottom: 1px solid var(--border); }
+.cv-zoom-level { font-size: 11px; font-weight: 750; color: var(--text);
+  min-width: 56px; padding: 0 8px; background: var(--cv-surface-2);
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--border) 62%, transparent); }
+.cv-zoom-range { width: 128px; height: 18px; accent-color: var(--cv-accent); cursor: pointer; }
+.cv-zoom-range::-webkit-slider-runnable-track { height: 4px; border-radius: 999px;
+  background: color-mix(in srgb, var(--border) 64%, var(--cv-accent-soft)); }
+.cv-zoom-range::-webkit-slider-thumb { margin-top: -5px; width: 14px; height: 14px;
+  border-radius: 50%; background: var(--cv-accent); border: 2px solid #fff;
+  box-shadow: 0 2px 8px rgba(0,0,0,.22); }
+.cv-minimap { position: absolute; left: 18px; bottom: 18px; z-index: 15;
+  width: 202px; height: 152px; padding: 9px; border-radius: 12px;
+  border: 1px solid var(--border); background: rgba(22,22,22,.92);
+  box-shadow: 0 6px 16px rgba(15,23,42,.16); }
+.cv-minimap-view { position: relative; width: 100%; height: 100%; border-radius: 6px;
+  background: #101010; box-shadow: inset 0 0 0 1px rgba(255,255,255,.08); }
+.cv-minimap-view span { position: absolute; left: 50%; top: 50%; width: 34px; height: 9px;
+  transform: translate(-50%,-50%); border-radius: 2px; background: var(--cv-accent); }
+.cv-empty-hint { position: absolute; left: 50%; top: 37%; z-index: 16;
+  display: flex; align-items: center; gap: 12px; transform: translate(-50%, -50%);
+  color: var(--muted); font-size: 14px; pointer-events: none; }
+.cv-empty-hint span { display: inline-flex; align-items: center; gap: 5px; height: 34px;
+  padding: 0 15px; border-radius: 10px; color: var(--cv-accent-strong); background: var(--cv-surface);
+  border: 1px solid var(--border); box-shadow: 0 12px 30px rgba(0,0,0,.28); }
+.cv-empty-hint b { font-size: 15px; color: var(--muted); font-weight: 660; }
+.cv-quick-menu { position: absolute; z-index: 32; width: 240px; padding: 12px;
+  border-radius: 18px; border: 1px solid var(--border);
+  background: rgba(22,22,22,.98); box-shadow: 0 12px 32px rgba(0,0,0,.34); }
+.cv-quick-title { color: var(--muted); font-size: 12px; padding: 2px 6px 8px; }
+.cv-quick-menu button { width: 100%; border: 0; background: transparent; color: var(--text);
+  display: flex; align-items: center; gap: 14px; padding: 10px 8px; border-radius: 12px;
+  font: inherit; font-size: 14px; font-weight: 670; cursor: pointer; text-align: left;
+  transition: background-color .14s, color .14s, transform .14s; }
+.cv-quick-menu button span { width: 32px; height: 32px; display: grid; place-items: center;
+  border-radius: 10px; color: var(--muted); background: var(--cv-surface-2); font-weight: 780; }
+.cv-quick-menu button:hover { background: var(--cv-surface-2); transform: translateX(2px); }
+.cv-quick-menu button:hover span { color: var(--cv-accent-strong); background: var(--cv-accent-soft); }
 
 /* 未就绪遮罩 */
 .cv-mask { position: absolute; inset: 0; z-index: 20; display: grid; place-items: center;
-  background: color-mix(in srgb, var(--bg) 78%, transparent);
-  backdrop-filter: blur(2px); }
+  background: color-mix(in srgb, var(--bg) 86%, transparent); }
 .cv-mask-box { text-align: center; background: var(--card); border: 1px solid var(--border);
   border-radius: var(--radius); padding: 28px 32px; box-shadow: var(--shadow); max-width: 380px; }
 .cv-mask-ico { font-size: 34px; }
@@ -552,30 +723,155 @@ h3 { margin: 0; font-size: 16px; }
 .cv-mask-text { color: var(--muted); font-size: 13px; margin: 0 0 14px; line-height: 1.6; }
 
 /* —— 覆写 Drawflow 节点为卡片风 —— */
-.drawflow .drawflow-node { background: transparent; border: 0; padding: 0;
-  border-radius: 16px; box-shadow: none; width: 250px; }
-.drawflow .drawflow-node.selected { box-shadow: none; }
+.drawflow .drawflow-node { background: transparent !important; border: 0; padding: 0;
+  border-radius: 12px; box-shadow: none; width: 250px; }
+.drawflow .drawflow-node.cv-df-video,
+.drawflow .drawflow-node.cv-df-grokVideo { width: 420px; }
+.drawflow .drawflow-node.cv-df-image { width: 420px; }
+.drawflow .drawflow-node.cv-df-tts,
+.drawflow .drawflow-node.cv-df-text { width: 430px; }
+.drawflow .drawflow-node.selected { background: transparent !important; box-shadow: none; }
 .drawflow .drawflow-node .drawflow_content_node { width: 100%; }
-.cv-node { background: var(--card); border: 1px solid var(--border);
-  border-radius: 16px; overflow: hidden; box-shadow: var(--shadow);
-  transition: border-color .15s; }
-.drawflow-node:hover .cv-node { border-color: var(--accent); }
-.drawflow-node.selected .cv-node { border-color: transparent;
-  box-shadow: 0 0 0 2px var(--accent), var(--shadow); }
+.cv-node { background: var(--cv-surface); border: 1px solid color-mix(in srgb, var(--border) 72%, transparent);
+  border-radius: 12px; overflow: hidden; box-shadow: 0 2px 8px rgba(0,0,0,.22);
+  transition: border-color .12s; }
+.drawflow-node:hover .cv-node { border-color: rgba(255,255,255,.14);
+  box-shadow: 0 2px 8px rgba(0,0,0,.22); }
+.drawflow-node.selected .cv-node { border-color: rgba(255,106,44,.42);
+  background: var(--cv-surface) !important;
+  box-shadow: 0 0 0 2px rgba(255,106,44,.16), 0 2px 8px rgba(0,0,0,.22); }
+.drawflow .drawflow-node.cv-node-config-open { z-index: 30; }
+.drawflow-node.selected .cv-node-body { background: transparent !important; }
 .cv-node-head { display: flex; align-items: center; gap: 8px;
-  padding: 9px 12px; background: var(--card-2); border-bottom: 1px solid var(--border); }
-.cv-node-ico { font-size: 15px; }
-.cv-node-name { font-weight: 700; font-size: 13px; color: var(--text); }
-.cv-node-tag { margin-left: auto; font-size: 10px; font-weight: 700; color: #f59e0b;
-  background: rgba(245,158,11,.16); padding: 2px 7px; border-radius: 999px; }
-.cv-node-body { display: flex; flex-direction: column; gap: 8px; padding: 11px 12px; }
+  padding: 9px 11px; background: linear-gradient(180deg, var(--cv-surface-2), color-mix(in srgb, var(--cv-surface-2) 70%, transparent));
+  border-bottom: 1px solid color-mix(in srgb, var(--border) 72%, transparent); }
+.cv-node-ico { display: grid; place-items: center; width: 22px; height: 22px;
+  border-radius: 7px; font-size: 13px; background: var(--cv-accent-soft); }
+.cv-node-name { font-weight: 750; font-size: 13px; color: var(--text); }
+.cv-node-tag { margin-left: auto; font-size: 10px; font-weight: 750; color: var(--cv-warn);
+  background: rgba(217,119,6,.14); padding: 2px 7px; border-radius: 999px;
+  border: 1px solid rgba(217,119,6,.18); }
+.cv-node-body { display: flex; flex-direction: column; gap: 8px; padding: 10px 11px 11px; }
 .cv-node-hint { color: var(--muted); font-size: 11px; line-height: 1.5; }
+.cv-df-video .cv-node,
+.cv-df-grokVideo .cv-node,
+.cv-df-image .cv-node,
+.cv-df-tts .cv-node,
+.cv-df-text .cv-node { background: transparent !important; border: 0; box-shadow: none;
+  overflow: visible; backdrop-filter: none; }
+.cv-df-video .cv-node-head,
+.cv-df-grokVideo .cv-node-head,
+.cv-df-image .cv-node-head,
+.cv-df-tts .cv-node-head,
+.cv-df-text .cv-node-head { display: none; }
+.cv-df-video .cv-node-body,
+.cv-df-grokVideo .cv-node-body,
+.cv-df-image .cv-node-body,
+.cv-df-tts .cv-node-body,
+.cv-df-text .cv-node-body { padding: 0; background: transparent !important; }
+.cv-df-video.drawflow-node.selected .cv-node,
+.cv-df-grokVideo.drawflow-node.selected .cv-node,
+.cv-df-image.drawflow-node.selected .cv-node,
+.cv-df-tts.drawflow-node.selected .cv-node,
+.cv-df-text.drawflow-node.selected .cv-node { background: transparent !important; box-shadow: none !important; }
+.cv-video-compact { position: relative; display: flex; flex-direction: column; align-items: center; gap: 12px;
+  padding-top: 14px; }
+.cv-video-label { align-self: center; display: inline-flex; align-items: center; gap: 7px;
+  max-width: calc(100% - 44px); padding: 0 8px; color: var(--muted);
+  font-size: 13px; font-weight: 650; background: var(--cv-canvas);
+  border-radius: 999px; line-height: 1.2; white-space: nowrap; overflow: hidden;
+  text-overflow: ellipsis; }
+.cv-video-label span { color: #777; flex: none; }
+.cv-video-frame { width: 276px; max-width: calc(100% - 44px); min-height: 0; border: 1px solid var(--border);
+  border-radius: 16px; padding: 8px; background: var(--cv-surface);
+  box-shadow: 0 2px 8px rgba(0,0,0,.24); }
+.drawflow-node.selected .cv-video-frame { border-color: rgba(255,106,44,.42);
+  box-shadow: 0 0 0 2px rgba(255,106,44,.14), 0 2px 8px rgba(0,0,0,.24); }
+.cv-video-frame-inner { height: auto; aspect-ratio: var(--cv-video-preview-aspect, 16 / 9);
+  border-radius: 10px; border: 1px dashed rgba(255,255,255,.12);
+  display: grid; place-items: center; color: var(--muted); font-size: 34px; background: #101010;
+  overflow: hidden; }
+.cv-video-frame-inner .cv-skeleton { width: 100%; height: 100%; border-radius: inherit; }
+.cv-video-frame-inner .cv-preview-shell { width: 100%; height: 100%; border-radius: inherit; overflow: hidden; }
+.cv-video-frame-inner .cv-preview-shell.cv-preview-video { background: #05070b; }
+.cv-video-frame-inner .cv-preview-shell.cv-preview-image { background: #111; }
+.cv-video-frame-inner .cv-preview-video .cv-media { width: 100%; height: 100%; max-height: none; object-fit: contain; background: #05070b; }
+.cv-video-frame-inner .cv-preview-image .cv-media { width: 100%; height: 100%; max-height: none; object-fit: contain; background: #111; }
+.cv-video-frame-inner .cv-meta { display: none; }
+.cv-image-frame { width: 276px; max-width: calc(100% - 44px); min-height: 0; align-self: center; }
+.cv-image-frame[data-ratio="16:9"],
+.cv-image-frame[data-ratio="4:3"],
+.cv-image-frame[data-ratio="3:2"] { width: 276px; max-width: calc(100% - 44px); }
+.cv-image-frame[data-ratio="9:16"],
+.cv-image-frame[data-ratio="3:4"] { width: 276px; max-width: calc(100% - 44px); }
+.cv-image-frame .cv-video-frame-inner { height: auto; aspect-ratio: var(--cv-image-preview-aspect, 1 / 1);
+  min-height: 0; border-style: solid; border-color: rgba(255,255,255,.08); background: #111; font-size: 30px; }
+.cv-image-compact .cv-video-foot { width: min(420px, calc(100% - 60px)); margin-top: -6px; }
+.cv-audio-frame .cv-video-frame-inner,
+.cv-text-frame .cv-video-frame-inner { aspect-ratio: 16 / 5; border-style: solid;
+  border-color: rgba(255,255,255,.08); font-size: 28px; }
+.cv-video-foot { width: min(420px, 100%); display: flex; align-items: center;
+  justify-content: space-between; color: var(--muted); font-size: 12px; pointer-events: none; }
+.cv-video-foot b { padding: 4px 8px; border-radius: 999px; background: var(--cv-accent-soft);
+  border: 1px solid rgba(255,106,44,.38); color: var(--cv-accent); font-size: 10px; font-weight: 500; }
+.cv-video-composer { width: min(420px, 100%); min-height: 188px; margin-top: 0; padding: 12px;
+  border-radius: 16px; border: 1px solid var(--border);
+  background: var(--cv-surface); box-shadow: 0 2px 8px rgba(0,0,0,.24);
+  contain: layout paint style; display: none; flex-direction: column; gap: 8px; }
+.cv-video-compact.cv-config-open .cv-video-composer { display: flex; }
+.cv-video-compact.cv-config-open .cv-video-foot { display: none; }
+.cv-tts-compact .cv-video-composer,
+.cv-text-compact .cv-video-composer { min-height: 0; }
+.cv-video-compose-tools { display: flex; align-items: center; gap: 4px; color: var(--muted);
+  font-size: 16px; height: 28px; }
+.cv-video-compose-tools .cv-video-expand { margin-left: auto; font-size: 13px; }
+.cv-video-prompt { min-height: 58px; border: 0; box-shadow: none; padding: 6px 0;
+  background: transparent; resize: none; color: var(--text); }
+.cv-video-prompt:focus { box-shadow: none; border-color: transparent; }
+.cv-video-chip-row { display: flex; align-items: flex-start; gap: 7px; flex-wrap: wrap; }
+.cv-chip-select, .cv-chip-action, .cv-video-pop > summary { width: auto; min-width: 0; height: 27px;
+  border-radius: 999px !important; border: 1px solid var(--border) !important;
+  background: var(--cv-surface-2) !important; color: var(--muted) !important; font-size: 11px !important;
+  font-weight: 500; padding: 0 10px !important; resize: none; }
+.cv-chip-select.cv-field-group { max-width: 132px; }
+.cv-chip-select.cv-field-model { max-width: 150px; }
+.cv-chip-action { cursor: pointer; }
+.cv-video-pop { position: relative; flex: 0 0 auto; }
+.cv-video-pop > summary { display: inline-flex; align-items: center; cursor: pointer; list-style: none; }
+.cv-video-pop > summary::-webkit-details-marker { display: none; }
+.cv-video-pop[open] { flex-basis: 100%; width: 100%; }
+.cv-video-pop-body { position: static; left: auto; top: auto; transform: none;
+  z-index: 42; width: 100%; margin-top: 8px; padding: 12px; border-radius: 14px;
+  border: 1px solid var(--border); background: #141414;
+  box-shadow: none; contain: layout paint style; display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 10px; }
+.cv-video-pop[open] > summary { color: var(--cv-accent-strong) !important; background: var(--cv-accent-soft) !important; }
+.cv-video-pop-body label { display: grid; gap: 5px; min-width: 0; color: #7f8da1; font-size: 11px; font-weight: 650; }
+.cv-video-pop-body .cv-pop-wide,
+.cv-video-pop-body .cv-refimg-row,
+.cv-video-pop-body .cv-field-refsource,
+.cv-video-pop-body .cv-pop-close { grid-column: 1 / -1; }
+.cv-video-pop-body .cv-field { height: 34px; border-radius: 10px; background: var(--cv-surface-2); color: var(--text); border-color: var(--border); }
+.cv-video-pop-body .cv-field,
+.cv-video-pop-body select,
+.cv-video-pop-body input,
+.cv-video-pop-body textarea { min-width: 0; width: 100%; box-sizing: border-box; }
+.cv-pop-close { height: 32px; border: 0; border-radius: 10px; background: var(--cv-surface-2);
+  color: var(--muted); font-size: 12px; font-weight: 700; cursor: pointer; }
+.cv-pop-close:hover { background: #242424; color: var(--text); }
+.cv-video-compact.cv-pop-open .cv-video-foot { display: none !important; }
+.cv-send-run { margin-left: auto; width: 34px; height: 34px; border-radius: 999px;
+  padding: 0; display: grid; place-items: center; background: #ffc7b8; color: #f26b2d; }
+.cv-video-materials { margin-top: 8px; }
+.cv-df-video .cv-node-preview,
+.cv-df-grokVideo .cv-node-preview,
+.cv-df-image .cv-node-preview,
+.cv-df-tts .cv-node-preview { margin-top: 10px; }
 
 /* 节点内表单控件 */
-.cv-field { width: 100%; background: var(--bg-2); border: 1px solid var(--border);
-  color: var(--text); border-radius: 9px; padding: 8px 10px; font-size: 12px;
+.cv-field { width: 100%; background: var(--cv-field); border: 1px solid color-mix(in srgb, var(--border) 76%, transparent);
+  color: var(--text); border-radius: 8px; padding: 8px 10px; font-size: 12px;
   font-family: inherit; outline: none; resize: vertical; }
-.cv-field:focus { border-color: var(--accent); }
+.cv-field:focus { border-color: var(--cv-accent); box-shadow: 0 0 0 3px var(--cv-accent-soft); }
 select.cv-field { resize: none; cursor: pointer; }
 
 /* 并排两个下拉（比例 + 清晰度 / 音色 + 格式 等） */
@@ -585,34 +881,39 @@ select.cv-field { resize: none; cursor: pointer; }
 /* 模型输入框 + 每节点「拉取」小按钮 */
 .cv-model-row { display: flex; gap: 6px; align-items: stretch; }
 .cv-model-row .cv-field { flex: 1; min-width: 0; }
-.cv-fetch-models { flex: none; border: 1px solid var(--border); background: var(--card-2);
-  color: var(--muted); border-radius: 9px; padding: 0 10px; cursor: pointer;
+.cv-fetch-models { flex: none; border: 1px solid color-mix(in srgb, var(--border) 76%, transparent); background: var(--cv-surface-2);
+  color: var(--muted); border-radius: 8px; padding: 0 10px; cursor: pointer;
   font-size: 11px; font-weight: 700; transition: .15s; }
-.cv-fetch-models:hover { border-color: var(--accent); color: var(--accent); }
+.cv-fetch-models:hover { border-color: var(--cv-accent); color: var(--cv-accent); }
 .cv-fetch-models:disabled { opacity: .5; cursor: not-allowed; }
 
 /* 素材上传控件（图片节点参考图 / 视频节点首帧·尾帧·多参考图）——走自建图床 */
 .cv-refimg-row, .cv-vmat { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; }
 .cv-refimg-pick { display: inline-flex; align-items: center; gap: 5px; cursor: pointer;
-  border: 1px dashed var(--accent); color: var(--accent); background: var(--card-2);
-  border-radius: 9px; padding: 7px 12px; font-size: 11px; font-weight: 700;
+  border: 1px dashed rgba(255,106,44,.52); color: var(--cv-accent); background: var(--cv-accent-soft);
+  border-radius: 8px; padding: 7px 12px; font-size: 11px; font-weight: 700;
   transition: .15s; white-space: nowrap; user-select: none; }
-.cv-refimg-pick:hover { background: var(--accent); color: #fff; }
-.cv-refimg-thumb, .cv-vmat-thumb { border: 1px solid var(--border); }
-.cv-refimg-clear, .cv-vmat-clear { flex: none; border: 1px solid var(--border);
-  background: var(--card-2); color: var(--muted); border-radius: 7px; cursor: pointer;
+.cv-refimg-pick:hover { background: var(--cv-accent); color: #fff; }
+.cv-refimg-thumb, .cv-vmat-thumb { flex: none; display: block; width: 42px; height: 42px;
+  max-width: 42px; max-height: 42px; object-fit: cover;
+  border: 1px solid color-mix(in srgb, var(--border) 76%, transparent); border-radius: 8px; }
+.cv-refimg-clear, .cv-vmat-clear { flex: none; border: 1px solid color-mix(in srgb, var(--border) 76%, transparent);
+  background: var(--cv-surface-2); color: var(--muted); border-radius: 7px; cursor: pointer;
   width: 24px; height: 24px; font-size: 12px; line-height: 1; padding: 0; transition: .15s; }
 .cv-refimg-clear:hover, .cv-vmat-clear:hover { border-color: var(--danger); color: var(--danger); }
 /* URL 输入 / 提示 / 多图缩略图 各自独占一行 */
 .cv-vmat-url, .cv-vmat-urls { flex: 1 1 100%; }
 .cv-refimg-row .cv-node-hint, .cv-vmat .cv-node-hint { flex: 1 1 100%; }
 .cv-vmat-refs-thumbs { display: flex; flex-wrap: wrap; gap: 2px; flex: 1 1 100%; }
+.cv-vmat-refs-thumbs img { width: 34px !important; height: 34px !important;
+  max-width: 34px !important; max-height: 34px !important; object-fit: cover;
+  border-radius: 7px; border: 1px solid color-mix(in srgb, var(--border) 76%, transparent); }
 /* 复选标签（生成音频 / 水印 / 固定镜头）对齐 */
 .cv-check { display: inline-flex; align-items: center; gap: 5px; font-size: 11px;
   color: var(--muted); cursor: pointer; user-select: none; }
 
 /* 折叠「高级」区（接口地址覆盖），别把节点撑太高 */
-.cv-adv { border-top: 1px dashed var(--border); padding-top: 6px; }
+.cv-adv { border-top: 1px dashed color-mix(in srgb, var(--border) 78%, transparent); padding-top: 6px; }
 .cv-adv > summary { cursor: pointer; color: var(--muted); font-size: 11px;
   font-weight: 600; list-style: none; user-select: none; }
 .cv-adv > summary::-webkit-details-marker { display: none; }
@@ -621,29 +922,39 @@ select.cv-field { resize: none; cursor: pointer; }
 .cv-adv[open] > summary { margin-bottom: 6px; }
 
 /* 运行按钮（沿用主色渐变观感） */
-.cv-run { align-self: stretch; border: 0; background: var(--grad); color: #fff;
-  padding: 8px 14px; border-radius: 9px; cursor: pointer; font-size: 12px;
+.cv-run { align-self: stretch; border: 0; background: var(--cv-accent); color: #fff;
+  padding: 8px 14px; border-radius: 8px; cursor: pointer; font-size: 12px;
   font-weight: 700; transition: .15s; }
-.cv-run:hover { filter: brightness(1.08); }
+.cv-run:hover { background: var(--cv-accent-strong); filter: none; }
 .cv-run:disabled { opacity: .6; cursor: not-allowed; }
+.cv-video-chip-row .cv-send-run { align-self: auto; flex: none; margin-left: auto;
+  width: 34px; height: 34px; border-radius: 999px; padding: 0; display: grid; place-items: center;
+  background: var(--cv-accent); color: #0a0a0a; box-shadow: none; overflow: hidden; white-space: nowrap; }
+.cv-video-chip-row .cv-send-run:hover { background: var(--cv-accent-strong); color: #0a0a0a; }
+.cv-video-chip-row .cv-send-run.loading { color: transparent; position: relative; }
+.cv-video-chip-row .cv-send-run.loading::after { content: ""; position: absolute; width: 14px; height: 14px;
+  border-radius: 999px; border: 2px solid rgba(242,107,45,.24); border-top-color: #f26b2d;
+  animation: cv-rot .7s linear infinite; }
 
 /* 错误红字 */
 .cv-node-err { color: var(--danger); font-size: 11px; line-height: 1.5;
   background: rgba(255,107,107,.1); border-radius: 8px; padding: 6px 9px; }
 
 /* 预览区（img/video/audio）圆角、限高、加载骨架 */
-.cv-node-preview { border-radius: 10px; overflow: hidden; background: var(--bg-2);
-  border: 1px solid var(--border); }
+.cv-node-preview { border-radius: 9px; overflow: hidden; background: var(--cv-field);
+  border: 1px solid color-mix(in srgb, var(--border) 76%, transparent); }
 .cv-preview-shell { position: relative; background: #000; }
+.cv-preview-shell.cv-preview-audio { display: grid; place-items: center; min-height: 92px; background: #111; }
 .cv-preview-actions { position: absolute; top: 6px; right: 6px; display: flex; gap: 5px;
   z-index: 2; opacity: .92; }
 .cv-preview-actions button { width: 26px; height: 26px; display: grid; place-items: center;
   border: 1px solid rgba(255,255,255,.22); border-radius: 7px; background: rgba(15,17,23,.78);
   color: #fff; cursor: pointer; font-size: 13px; line-height: 1; padding: 0; }
-.cv-preview-actions button:hover { background: rgba(90,103,216,.92); border-color: rgba(255,255,255,.4); }
+.cv-preview-actions button:hover { background: rgba(255,106,44,.92); border-color: rgba(255,255,255,.4); }
 .cv-media { display: block; width: 100%; max-height: 220px; object-fit: contain;
   background: #000; }
 .cv-media-audio { display: block; width: 100%; }
+.cv-preview-audio .cv-media-audio { width: calc(100% - 16px); margin: 34px 8px 8px; }
 .cv-meta { font-size: 10px; color: var(--muted); padding: 5px 8px;
   border-top: 1px solid var(--border); }
 .cv-skeleton { display: flex; align-items: center; justify-content: center; gap: 8px;
@@ -652,25 +963,59 @@ select.cv-field { resize: none; cursor: pointer; }
   background-size: 200% 100%; animation: cv-shimmer 1.2s linear infinite; }
 @keyframes cv-shimmer { from { background-position: 200% 0; } to { background-position: -200% 0; } }
 .cv-spin { width: 13px; height: 13px; border-radius: 50%;
-  border: 2px solid var(--border); border-top-color: var(--accent);
+  border: 2px solid var(--border); border-top-color: var(--cv-accent);
   animation: cv-rot .7s linear infinite; }
 @keyframes cv-rot { to { transform: rotate(360deg); } }
 
 /* —— 端口与连线用主题色 —— */
 .drawflow .drawflow-node .input,
-.drawflow .drawflow-node .output { background: var(--card);
-  border: 2px solid var(--accent); width: 13px; height: 13px; }
-.drawflow .drawflow-node .output:hover,
-.drawflow .drawflow-node .input:hover { background: var(--accent); }
-.drawflow .connection .main-path { stroke: var(--accent); stroke-width: 2.4px; }
+.drawflow .drawflow-node .output { width: 28px; height: 28px; border: 0;
+  background: transparent; box-shadow: none; opacity: 1; z-index: 8;
+  position: absolute !important; top: var(--cv-port-y, 50%) !important; margin-bottom: 0 !important; }
+.drawflow .drawflow-node .input { pointer-events: none; }
+.drawflow .drawflow-node .output { pointer-events: auto; }
+.drawflow .drawflow-node .input { left: var(--cv-port-left, 0) !important; transform: translate(-50%, -50%) !important; }
+.drawflow .drawflow-node .output { left: var(--cv-port-right, 100%) !important; right: auto !important; transform: translate(-50%, -50%) !important; }
+.drawflow .drawflow-node .input::after,
+.drawflow .drawflow-node .output::after { content: "+"; position: absolute; left: 50%; top: 50%;
+  display: grid; place-items: center; color: var(--text); font-size: 16px; font-weight: 720; line-height: 1;
+  width: 22px; height: 22px; border-radius: 999px; transform: translate(-50%, -50%) scale(.86);
+  background: var(--cv-surface-2); border: 1px solid rgba(255,255,255,.16);
+  box-shadow: none;
+  opacity: 0; pointer-events: none; transition: opacity .10s ease, color .10s ease, border-color .10s ease; }
+.drawflow .drawflow-node.selected .output::after,
+.drawflow .drawflow-node.cv-node-config-open .output::after,
+#drawflow.cv-linking .drawflow-node .input::after,
+#drawflow.cv-linking .drawflow-node .output::after {
+  opacity: 1;
+  transform: translate(-50%, -50%) scale(1);
+}
+#drawflow.cv-linking .drawflow-node .input::after { opacity: 1; }
+#drawflow.cv-dragging .cv-node,
+#drawflow.cv-dragging .cv-video-frame,
+#drawflow.cv-dragging .cv-video-composer,
+#drawflow.cv-dragging .cv-skeleton,
+#drawflow.cv-dragging .cv-spin,
+#drawflow.cv-dragging .drawflow-node .input::after,
+#drawflow.cv-dragging .drawflow-node .output::after {
+  box-shadow: none !important;
+  transition: none !important;
+  animation-play-state: paused !important;
+}
+#drawflow.cv-dragging .drawflow-node.selected { will-change: transform; }
+#drawflow.cv-linking .drawflow-node .input { pointer-events: auto; }
+#drawflow.cv-linking .drawflow-node .output:hover::after,
+#drawflow.cv-linking .drawflow-node .input:hover::after { color: var(--cv-accent-strong); border-color: var(--cv-accent-strong); }
+.drawflow .connection .main-path { stroke: var(--cv-accent); stroke-width: 2.3px; }
 .drawflow .connection .main-path:hover { stroke: var(--text); }
-.drawflow .connection .point { stroke: var(--accent); fill: var(--card); }
+.drawflow .connection .point { stroke: var(--cv-accent); fill: var(--cv-surface); }
 
 /* —— 沉浸式全屏：fixed 覆盖整个应用窗口（含顶部导航） —— */
 body.cv-noscroll { overflow: hidden; }
 #tab-canvas.cv-fullscreen { position: fixed; inset: 0; z-index: 9999; margin: 0;
-  height: auto; padding: 14px 16px; background: var(--bg); }
-#tab-canvas.cv-fullscreen .cv-stage { min-height: 0; border-radius: 12px; }
+  height: auto; padding: 0; background: var(--cv-canvas); }
+#tab-canvas.cv-fullscreen .cv-stage { min-height: 0; border-radius: 11px; }
+#tab-canvas.cv-fullscreen .cv-toolbar { padding: 8px 10px; }
 
 /* —— 语音输入面板 —— */
 .voice-body { display: grid; gap: 14px; max-width: 760px; }
@@ -682,9 +1027,9 @@ body.cv-noscroll { overflow: hidden; }
 .voice-dot { width: 10px; height: 10px; border-radius: 999px; display: inline-block; background: #6b7280; flex: none; }
 .voice-dot[data-state="connected"] { background: #34d399; box-shadow: 0 0 8px rgba(52,211,153,.7); }
 .voice-dot[data-state="transcribing"], .voice-dot[data-state="recording"] { background: #fbbf24; box-shadow: 0 0 8px rgba(251,191,36,.7); }
-.voice-dot[data-state="restarting"], .voice-dot[data-state="connecting"], .voice-dot[data-state="injecting"], .voice-dot[data-state="checking"] { background: #60a5fa; }
+.voice-dot[data-state="restarting"], .voice-dot[data-state="waiting_debug_port"], .voice-dot[data-state="connecting"], .voice-dot[data-state="injecting"], .voice-dot[data-state="checking"] { background: #60a5fa; }
 .voice-dot[data-state="error"] { background: #ef4444; box-shadow: 0 0 8px rgba(239,68,68,.7); }
-.voice-dot[data-state="running_no_port"] { background: #f59e0b; }
+.voice-dot[data-state="running_no_port"], .voice-dot[data-state="unsupported_packaged"] { background: #f59e0b; }
 .codex-link-status {
   display: flex;
   align-items: center;
@@ -712,6 +1057,7 @@ body.cv-noscroll { overflow: hidden; }
 .tm-field { display: flex; flex-direction: column; gap: 6px; }
 .tm-label { font-size: 12.5px; font-weight: 600; color: var(--text); }
 .tm-hint { font-size: 11.5px; color: var(--muted); line-height: 1.4; }
+.tm-hint strong { color: var(--text); }
 .tm-row { display: flex; gap: 8px; align-items: center; }
 .tm-select, .tm-text { background: var(--card); border: 1px solid var(--border); color: var(--text);
   border-radius: 9px; padding: 8px 10px; font-size: 13px; font-family: inherit; flex: 1; min-width: 0; }
@@ -742,6 +1088,8 @@ body.cv-noscroll { overflow: hidden; }
 .tm-team-name { font-size: 18px; font-weight: 700; }
 .tm-team-summary { color: var(--muted); font-size: 13px; margin-top: 4px; line-height: 1.5; }
 .tm-team-stack { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 8px; }
+.tm-team-models { margin-top: 8px; color: var(--muted); font-size: 12px; }
+.tm-team-models code, .tm-emp-model code { color: var(--text); font-family: ui-monospace, monospace; }
 .tm-stack-chip { background: var(--card-2); border: 1px solid var(--border); color: var(--text);
   padding: 3px 10px; border-radius: 20px; font-size: 11.5px; }
 .tm-conv-card, .tm-emp-card { background: var(--card); border: 1px solid var(--border);
@@ -758,6 +1106,7 @@ body.cv-noscroll { overflow: hidden; }
 .tm-emp-id { font-family: ui-monospace, monospace; font-size: 11.5px; color: var(--muted);
   background: var(--card-2); padding: 1px 6px; border-radius: 5px; }
 .tm-emp-duty { font-size: 13px; color: var(--text); margin-top: 5px; line-height: 1.5; }
+.tm-emp-model { margin-top: 5px; color: var(--muted); font-size: 11.5px; }
 .tm-sec-label { font-size: 11.5px; font-weight: 600; color: var(--accent); margin: 10px 0 4px; }
 .tm-resp, .tm-flow { margin: 0; padding-left: 16px; font-size: 12.5px; color: var(--muted); line-height: 1.55; }
 .tm-collab { display: flex; flex-direction: column; gap: 3px; margin-top: 8px; }
diff --git a/resources/multimodal-gateway.example.json b/resources/multimodal-gateway.example.json
new file mode 100644
index 0000000..6999238
--- /dev/null
+++ b/resources/multimodal-gateway.example.json
@@ -0,0 +1,6 @@
+{
+  "baseUrl": "https://api.tokendun.com",
+  "key": "replace-at-release-time",
+  "model": "MiniMax-M3",
+  "sttModel": ""
+}
diff --git a/scripts/prepare-multimodal-gateway.js b/scripts/prepare-multimodal-gateway.js
new file mode 100644
index 0000000..4e223a2
--- /dev/null
+++ b/scripts/prepare-multimodal-gateway.js
@@ -0,0 +1,26 @@
+// 在发布机执行：把免费多模态网关凭据写进未跟踪的打包资源。
+const fs = require("fs");
+const path = require("path");
+
+const key = String(process.env.TD_MULTIMODAL_GATEWAY_KEY || "").trim();
+if (!key) {
+  console.error("缺少 TD_MULTIMODAL_GATEWAY_KEY，未生成多模态网关配置。");
+  process.exit(1);
+}
+
+const projectTarget = path.join(__dirname, "..", "resources", "multimodal-gateway.json");
+const userDataTarget = path.join(
+  process.env.TD_MULTIMODAL_USER_DATA_DIR || path.join(process.env.HOME || process.cwd(), "Library", "Application Support", "codex-market"),
+  "multimodal-gateway.json"
+);
+const config = {
+  baseUrl: String(process.env.TD_MULTIMODAL_GATEWAY_URL || "https://api.tokendun.com").trim(),
+  key,
+  model: String(process.env.TD_MULTIMODAL_MODEL || "MiniMax-M3").trim(),
+  sttModel: String(process.env.TD_MULTIMODAL_STT_MODEL || "").trim(),
+};
+for (const target of Array.from(new Set([projectTarget, userDataTarget]))) {
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+  console.log(`已生成 ${path.relative(process.cwd(), target)}`);
+}
diff --git a/scripts/publish-codex-installer.js b/scripts/publish-codex-installer.js
new file mode 100644
index 0000000..a0dcd07
--- /dev/null
+++ b/scripts/publish-codex-installer.js
@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+// publish-codex-installer.js —— 发布 Codex 安装器资源到自建 gitea。
+//
+// 用法：
+//   node scripts/publish-codex-installer.js /Users/mac/Downloads/Codex-Windows-x64.msix
+//   node scripts/publish-codex-installer.js /Users/mac/Downloads/ChatGPT.dmg
+//   token 可设置 GIT_TOKEN，或写入 ~/.tokendun-git-token。
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const crypto = require("crypto");
+const { execFileSync, spawnSync } = require("child_process");
+
+const OWNER = "mhgmh";
+const REPO = "codex-market-app";
+const TAG = "codex-installers";
+const MSIX_NAME = "Codex-Windows-x64.msix";
+const DMG_NAME = "ChatGPT.dmg";
+const ALLOWED_NAMES = new Set([MSIX_NAME, DMG_NAME]);
+const API = `https://up.tokendun.cc/api/v1/repos/${OWNER}/${REPO}`;
+const DL = `https://update.tokendun.cc/${OWNER}/${REPO}/releases/download/${TAG}`;
+
+const installerPath = path.resolve(process.argv[2] || "/Users/mac/Downloads/Codex-Windows-x64.msix");
+const installerName = path.basename(installerPath);
+if (!ALLOWED_NAMES.has(installerName)) {
+  console.error(`安装包文件名必须是 ${Array.from(ALLOWED_NAMES).join(" 或 ")}，当前是 ${installerName}`);
+  process.exit(1);
+}
+if (!fs.existsSync(installerPath)) {
+  console.error(`安装包不存在：${installerPath}`);
+  process.exit(1);
+}
+
+let token = process.env.GIT_TOKEN || "";
+if (!token) {
+  try { token = fs.readFileSync(path.join(os.homedir(), ".tokendun-git-token"), "utf8").trim(); } catch {}
+}
+if (!token) {
+  console.error("缺少 gitea token：设置 GIT_TOKEN 或写入 ~/.tokendun-git-token");
+  process.exit(1);
+}
+
+function hashFile(file) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash("sha256");
+    fs.createReadStream(file)
+      .on("data", (chunk) => h.update(chunk))
+      .on("error", reject)
+      .on("end", () => resolve(h.digest("hex")));
+  });
+}
+
+function api(method, urlPath, body) {
+  const args = ["-s", "-X", method, "-H", `Authorization: token ${token}`, `${API}${urlPath}`];
+  if (body !== undefined) {
+    args.push("-H", "Content-Type: application/json", "-d", JSON.stringify(body));
+  }
+  return execFileSync("curl", args, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+}
+
+function apiJson(method, urlPath, body) {
+  const out = api(method, urlPath, body);
+  try { return JSON.parse(out); } catch { return null; }
+}
+
+function upload(rel, file, name) {
+  const result = spawnSync("curl", [
+    "--progress-bar",
+    "-o", "/dev/null",
+    "-w", "%{http_code}",
+    "-X", "POST",
+    "-H", `Authorization: token ${token}`,
+    "-F", `attachment=@${file};type=application/octet-stream`,
+    `${API}/releases/${rel.id}/assets?name=${encodeURIComponent(name)}`,
+  ], { encoding: "utf8", stdio: ["ignore", "pipe", "inherit"], maxBuffer: 64 * 1024 * 1024 });
+  if (result.error) throw result.error;
+  const code = String(result.stdout || "").trim();
+  console.log(`上传 ${name} → HTTP ${code}`);
+  if (code !== "201") {
+    console.error(`上传失败：${name}`);
+    process.exit(1);
+  }
+}
+
+(async () => {
+  const stat = fs.statSync(installerPath);
+  console.log(`准备发布 ${installerName}：${(stat.size / 1048576).toFixed(2)}MB`);
+  const sha256 = await hashFile(installerPath);
+  const shaPath = path.join(os.tmpdir(), `${installerName}.sha256`);
+  fs.writeFileSync(shaPath, `${sha256}  ${installerName}\n`);
+  console.log(`sha256=${sha256}`);
+
+  let rel = apiJson("GET", `/releases/tags/${encodeURIComponent(TAG)}`);
+  if (!rel || !rel.id) {
+    console.log(`创建 release ${TAG} …`);
+    rel = apiJson("POST", "/releases", {
+      tag_name: TAG,
+      target_commitish: "main",
+      name: "Codex 安装器资源",
+      body: "TD工具箱内置安装器使用的远程安装包资源。",
+      draft: false,
+      prerelease: false,
+    });
+  }
+  if (!rel || !rel.id) {
+    console.error(`无法创建/获取 release ${TAG}`);
+    process.exit(1);
+  }
+
+  const existing = new Map((rel.assets || []).map((a) => [a.name, a.id]));
+  for (const name of [installerName, `${installerName}.sha256`]) {
+    if (existing.has(name)) {
+      api("DELETE", `/releases/${rel.id}/assets/${existing.get(name)}`);
+      console.log(`删除旧 asset: ${name}`);
+    }
+  }
+
+  upload(rel, installerPath, installerName);
+  upload(rel, shaPath, `${installerName}.sha256`);
+
+  console.log("\n发布完成：");
+  console.log(`  ${DL}/${installerName}`);
+  console.log(`  ${DL}/${installerName}.sha256`);
+})();
diff --git a/scripts/smoke-multimodal.js b/scripts/smoke-multimodal.js
new file mode 100644
index 0000000..1f05ba7
--- /dev/null
+++ b/scripts/smoke-multimodal.js
@@ -0,0 +1,46 @@
+const fs = require("fs");
+const path = require("path");
+const media = require("../electron/lib/media-understanding");
+const { gatewayConfig } = require("../electron/lib/multimodal-config");
+
+const imagePath = process.argv[2] || path.join(__dirname, "..", "renderer", "logo.png");
+const config = gatewayConfig();
+
+if (!config.key) {
+  console.error("缺少多模态网关 Key：请先生成 resources/multimodal-gateway.json，或设置 TD_MULTIMODAL_GATEWAY_KEY。");
+  process.exit(2);
+}
+
+const ext = path.extname(imagePath).toLowerCase();
+const mime =
+  ext === ".jpg" || ext === ".jpeg" ? "image/jpeg" :
+    ext === ".webp" ? "image/webp" :
+      "image/png";
+const data = fs.readFileSync(imagePath).toString("base64");
+const request = {
+  input: [{
+    type: "message",
+    role: "user",
+    content: [
+      { type: "input_text", text: "请识别这张图片里的主要内容和可见文字。" },
+      { type: "input_image", image_url: `data:${mime};base64,${data}` },
+    ],
+  }],
+};
+
+media.enrichResponsesRequest(request, { instruction: "请识别这张图片里的主要内容和可见文字。" })
+  .then((result) => {
+    if (!result.processed) throw new Error("没有检测到可处理的图片附件");
+    const evidence = result.evidence || {};
+    console.log(JSON.stringify({
+      provider: evidence.provider,
+      modality: evidence.modality,
+      summary: evidence.summary,
+      items: evidence.items,
+      unsupported: evidence.unsupported,
+    }, null, 2));
+  })
+  .catch((error) => {
+    console.error(String((error && error.message) || error));
+    process.exit(1);
+  });
diff --git a/test/canvas-inputs.test.js b/test/canvas-inputs.test.js
new file mode 100644
index 0000000..5f1b837
--- /dev/null
+++ b/test/canvas-inputs.test.js
@@ -0,0 +1,47 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { collectUpstreamOutputs } = require("../renderer/canvas-inputs.js");
+
+function nodeWithConnections(connections) {
+  return { inputs: { input_1: { connections } } };
+}
+
+test("collects text from a connected text node for image prompts", () => {
+  const result = collectUpstreamOutputs(
+    nodeWithConnections([{ node: 1 }]),
+    () => ({ text: "a cinematic desk lamp", image: "" })
+  );
+
+  assert.equal(result.text, "a cinematic desk lamp");
+  assert.deepEqual(result.images, []);
+});
+
+test("exposes the first connected image for first-frame video", () => {
+  const result = collectUpstreamOutputs(
+    nodeWithConnections([{ node: 1 }]),
+    () => ({ image: "data:image/png;base64,first" })
+  );
+
+  assert.equal(result.image, "data:image/png;base64,first");
+  assert.deepEqual(result.images, ["data:image/png;base64,first"]);
+});
+
+test("keeps every connected image in connection order and removes duplicates", () => {
+  const outputs = {
+    1: { image: "data:image/png;base64,one" },
+    2: { image: "data:image/png;base64,two" },
+    3: { image: "data:image/png;base64,one" },
+    4: { image: "   " },
+  };
+  const result = collectUpstreamOutputs(
+    nodeWithConnections([{ node: 1 }, { node: 2 }, { node: 3 }, { node: 4 }]),
+    (id) => outputs[id]
+  );
+
+  assert.equal(result.image, "data:image/png;base64,one");
+  assert.deepEqual(result.images, [
+    "data:image/png;base64,one",
+    "data:image/png;base64,two",
+  ]);
+});
diff --git a/test/canvas-resolution.test.js b/test/canvas-resolution.test.js
new file mode 100644
index 0000000..6e0bf81
--- /dev/null
+++ b/test/canvas-resolution.test.js
@@ -0,0 +1,28 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const {
+  clmmResolutionFromParamsV2,
+  clmmSizeFromParamsV2,
+} = require("../electron/lib/canvas.js");
+
+test("keeps Seedance 2K and 4K resolutions for upstream capability negotiation", () => {
+  assert.equal(clmmResolutionFromParamsV2({ resolution: "2K" }), "2k");
+  assert.equal(clmmResolutionFromParamsV2({ resolution: "4k" }), "4k");
+  assert.equal(clmmResolutionFromParamsV2({ resolution: "unsupported" }), "720p");
+});
+
+test("derives standard 2K and 4K video sizes from aspect ratio", () => {
+  assert.equal(clmmSizeFromParamsV2({ ratio: "16:9" }, "2k"), "2560x1440");
+  assert.equal(clmmSizeFromParamsV2({ ratio: "9:16" }, "2k"), "1440x2560");
+  assert.equal(clmmSizeFromParamsV2({ ratio: "1:1" }, "4k"), "2160x2160");
+});
+
+test("exposes 2K and 4K only on the Seedance video control", () => {
+  const source = fs.readFileSync(path.resolve(__dirname, "../renderer/app.js"), "utf8");
+  assert.match(source, /value="2k">2K（需上游支持）/);
+  assert.match(source, /value="4k">4K（需上游支持）/);
+  assert.match(source, /const resolutionOptions = isGrok/);
+});
diff --git a/test/codex-data-dir.test.js b/test/codex-data-dir.test.js
new file mode 100644
index 0000000..06c8ae9
--- /dev/null
+++ b/test/codex-data-dir.test.js
@@ -0,0 +1,61 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const Module = require("node:module");
+
+const DATA_DIR_MODULE = path.resolve(__dirname, "../electron/lib/codex_data_dir.js");
+const SESSIONS_MODULE = path.resolve(__dirname, "../electron/lib/sessions.js");
+
+function loadModules(userData) {
+  const originalLoad = Module._load;
+  Module._load = function (request, parent, isMain) {
+    if (request === "electron") return { app: { getPath: () => userData } };
+    return originalLoad.call(this, request, parent, isMain);
+  };
+  delete require.cache[DATA_DIR_MODULE];
+  delete require.cache[SESSIONS_MODULE];
+  try {
+    return { dataDir: require(DATA_DIR_MODULE), sessions: require(SESSIONS_MODULE) };
+  } finally {
+    Module._load = originalLoad;
+  }
+}
+
+function writeRollout(root, id, title) {
+  const dir = path.join(root, "sessions", "2026", "08", "06");
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, "rollout-test.jsonl"), [
+    JSON.stringify({ type: "session_meta", payload: { session_id: id, cwd: "/work/demo", timestamp: "2026-08-06T10:00:00.000Z" } }),
+    JSON.stringify({ type: "event_msg", payload: { type: "user_message", message: title } }),
+  ].join("\n") + "\n");
+}
+
+test("会话数据目录切换后列表读取新目录，配置可持久化", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-market-data-dir-"));
+  const userData = path.join(root, "user-data");
+  const first = path.join(root, "first-codex");
+  const second = path.join(root, "second-codex");
+  fs.mkdirSync(userData, { recursive: true });
+  writeRollout(first, "11111111-1111-4111-8111-111111111111", "第一份记录");
+  writeRollout(second, "22222222-2222-4222-8222-222222222222", "第二份记录");
+
+  try {
+    let { dataDir, sessions } = loadModules(userData);
+    assert.throws(() => dataDir.set(path.join(root, "not-codex")), /Codex 数据/);
+    assert.equal(dataDir.set(first).path, first);
+    assert.equal(sessions.getCodexHome(), first);
+    assert.deepEqual(sessions.listConversations().map((row) => row.title), ["第一份记录"]);
+
+    assert.equal(dataDir.set(second).path, second);
+    assert.equal(sessions.getCodexHome(), second);
+    assert.deepEqual(sessions.listConversations().map((row) => row.title), ["第二份记录"]);
+
+    ({ dataDir, sessions } = loadModules(userData));
+    assert.equal(dataDir.info().path, second);
+    assert.deepEqual(sessions.listConversations().map((row) => row.title), ["第二份记录"]);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/test/media-understanding.test.js b/test/media-understanding.test.js
new file mode 100644
index 0000000..27cd18c
--- /dev/null
+++ b/test/media-understanding.test.js
@@ -0,0 +1,88 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const media = require("../electron/lib/media-understanding");
+
+test("collectAttachments finds a Responses image part", () => {
+  const attachments = media.collectAttachments({
+    input: [{
+      type: "message",
+      role: "user",
+      content: [{ type: "input_image", image_url: "data:image/png;base64,abc" }],
+    }],
+  });
+  assert.equal(attachments.length, 1);
+  assert.equal(attachments[0].kind, "image");
+});
+
+test("collectAttachments finds standard Responses input_audio data", () => {
+  const attachments = media.collectAttachments({
+    input: [{
+      type: "message",
+      role: "user",
+      content: [{
+        type: "input_audio",
+        input_audio: { data: "YXVkaW8=", format: "wav" },
+      }],
+    }],
+  });
+  assert.equal(attachments.length, 1);
+  assert.equal(attachments[0].kind, "audio");
+  assert.equal(attachments[0].name, "audio.wav");
+  assert.equal(attachments[0].value, "YXVkaW8=");
+});
+
+test("enrichResponsesRequest injects MiniMax evidence without exposing credentials", async () => {
+  const previousKey = process.env.TD_MULTIMODAL_GATEWAY_KEY;
+  process.env.TD_MULTIMODAL_GATEWAY_KEY = "test-key";
+  const request = {
+    input: [{
+      type: "message",
+      role: "user",
+      content: [{ type: "input_image", image_url: "data:image/png;base64,abc" }],
+    }],
+  };
+  try {
+    const result = await media.enrichResponsesRequest(request, {
+      instruction: "图片里写了什么？",
+      fetchImpl: async () => ({
+        ok: true,
+        json: async () => ({
+          choices: [{
+            message: {
+              content: '{"summary":"界面截图","items":[{"kind":"ocr","text":"设置","confidence":0.99}]}',
+            },
+          }],
+        }),
+      }),
+    });
+    assert.equal(result.processed, true);
+    const last = request.input[0].content.at(-1);
+    assert.equal(last.type, "input_text");
+    assert.match(last.text, /界面截图/);
+    assert.doesNotMatch(last.text, /test-key/);
+  } finally {
+    if (previousKey == null) delete process.env.TD_MULTIMODAL_GATEWAY_KEY;
+    else process.env.TD_MULTIMODAL_GATEWAY_KEY = previousKey;
+  }
+});
+
+test("enrichResponsesRequest reports an unavailable gateway instead of empty image evidence", async () => {
+  const previousKey = process.env.TD_MULTIMODAL_GATEWAY_KEY;
+  delete process.env.TD_MULTIMODAL_GATEWAY_KEY;
+  const request = {
+    input: [{
+      type: "message",
+      role: "user",
+      content: [{ type: "input_image", image_url: "data:image/png;base64,abc" }],
+    }],
+  };
+  try {
+    const result = await media.enrichResponsesRequest(request);
+    assert.match(result.evidence.summary, /尚未注入访问密钥/);
+    assert.match(request.input[0].content.at(-1).text, /不能识别图片内容/);
+  } finally {
+    if (previousKey == null) delete process.env.TD_MULTIMODAL_GATEWAY_KEY;
+    else process.env.TD_MULTIMODAL_GATEWAY_KEY = previousKey;
+  }
+});
diff --git a/test/router.test.js b/test/router.test.js
new file mode 100644
index 0000000..c257dd7
--- /dev/null
+++ b/test/router.test.js
@@ -0,0 +1,1238 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const http = require("node:http");
+const os = require("node:os");
+const path = require("node:path");
+const Module = require("node:module");
+
+const ROUTER_MODULE = path.resolve(__dirname, "../electron/lib/router.js");
+
+function b64(value) {
+  return "b64:" + Buffer.from(String(value || ""), "utf-8").toString("base64");
+}
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.removeListener("error", reject);
+      resolve(server.address().port);
+    });
+  });
+}
+
+function close(server) {
+  return new Promise((resolve) => server.close(resolve));
+}
+
+function fixture(options = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-market-router-"));
+  const home = path.join(root, "home");
+  const userData = path.join(root, "user-data");
+  const codexHome = path.join(home, ".codex");
+  const claudeHome = path.join(home, ".claude");
+  fs.mkdirSync(codexHome, { recursive: true });
+  fs.mkdirSync(claudeHome, { recursive: true });
+  fs.mkdirSync(userData, { recursive: true });
+
+  const officialConfig = options.officialConfig || 'model_catalog_json = "cc-switch-model-catalog.json"\n';
+  const officialAuthObject = options.officialAuth || {
+    auth_mode: "chatgpt",
+    tokens: {
+      access_token: "official-access-token",
+      refresh_token: "official-refresh-token",
+    },
+  };
+  const officialAuth = JSON.stringify(officialAuthObject, null, 2);
+  const routerKey = options.routerKey || "rk-test-router-key";
+  const groups = [
+    {
+      id: "default",
+      name: "我的账号",
+      isDefault: true,
+      key: "",
+      modelProvider: "",
+      providerBlock: "",
+      authKey: "",
+      origModel: "",
+      officialBackup: {
+        done: true,
+        ts: 1,
+        configToml: officialConfig,
+        authJson: officialAuth,
+        hadTokens: true,
+      },
+    },
+    ...(options.groups || []),
+  ];
+  const persistedGroups = groups.map((group) => {
+    const out = { ...group, key: b64(group.key) };
+    if (out.officialBackup && out.officialBackup.authJson) {
+      out.officialBackup = {
+        ...out.officialBackup,
+        authJson: b64(out.officialBackup.authJson),
+      };
+    }
+    return out;
+  });
+
+  fs.writeFileSync(path.join(codexHome, "config.toml"), options.configToml || officialConfig);
+  fs.writeFileSync(
+    path.join(codexHome, "auth.json"),
+    JSON.stringify(options.auth || officialAuthObject, null, 2)
+  );
+  fs.writeFileSync(
+    path.join(userData, "router.json"),
+    JSON.stringify({
+      port: options.port || 8787,
+      routerKey: b64(routerKey),
+      activeId: options.activeId || "default",
+      activeClaudeId: options.activeClaudeId || null,
+      groups: persistedGroups,
+    }, null, 2)
+  );
+
+  if (options.claudeSettings) {
+    fs.writeFileSync(path.join(claudeHome, "settings.json"), JSON.stringify(options.claudeSettings, null, 2));
+  }
+
+  return { root, home, userData, codexHome, claudeHome, officialConfig, officialAuth, routerKey };
+}
+
+function loadRouter(fx) {
+  const previousHome = process.env.HOME;
+  process.env.HOME = fx.home;
+  delete require.cache[ROUTER_MODULE];
+  const originalLoad = Module._load;
+  Module._load = function load(request, parent, isMain) {
+    if (request === "electron") {
+      return {
+        app: {
+          getPath(name) {
+            assert.equal(name, "userData");
+            return fx.userData;
+          },
+        },
+        safeStorage: {
+          isEncryptionAvailable: () => false,
+        },
+      };
+    }
+    return originalLoad.call(this, request, parent, isMain);
+  };
+  try {
+    return require(ROUTER_MODULE);
+  } finally {
+    Module._load = originalLoad;
+    if (previousHome == null) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+  }
+}
+
+test("DeepSeek and Kimi get conservative context windows when none is configured", { concurrency: false }, () => {
+  const fx = fixture({
+    activeId: "deepseek",
+    groups: [{
+      id: "deepseek",
+      name: "DeepSeek",
+      baseUrl: "https://proxy.example.test",
+      key: "deepseek-key",
+      model: "deepseek-chat",
+      mode: "responses",
+    }],
+  });
+  const catalogFile = path.join(fx.codexHome, "cc-switch-model-catalog.json");
+  fs.writeFileSync(catalogFile, JSON.stringify({
+    models: [{
+      slug: "template",
+      display_name: "Template",
+      context_window: 128000,
+      max_context_window: 128000,
+      effective_context_window_percent: 95,
+      visibility: "list",
+    }],
+  }));
+  const router = loadRouter(fx);
+  try {
+    router.applyToCodex();
+    const catalog = JSON.parse(fs.readFileSync(catalogFile, "utf-8"));
+    const deepseek = catalog.models.find((model) => model.slug === "deepseek-chat");
+    assert.equal(deepseek.context_window, 65536);
+    assert.equal(deepseek.max_context_window, 65536);
+    assert.equal(deepseek.effective_context_window_percent, 80);
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("takeover links the model catalog into config.toml with an absolute path", { concurrency: false }, () => {
+  const fx = fixture({
+    activeId: "deepseek",
+    groups: [{
+      id: "deepseek",
+      name: "DeepSeek",
+      baseUrl: "https://proxy.example.test",
+      key: "deepseek-key",
+      model: "deepseek-chat",
+      mode: "chat",
+    }],
+    configToml: 'model_reasoning_effort = "high"\n', // 无 model_catalog_json：Codex 会忽略目录
+  });
+  const catalogFile = path.join(fx.codexHome, "cc-switch-model-catalog.json");
+  fs.writeFileSync(catalogFile, JSON.stringify({
+    models: [{
+      slug: "template",
+      display_name: "Template",
+      context_window: 128000,
+      max_context_window: 128000,
+      effective_context_window_percent: 95,
+      visibility: "list",
+    }],
+  }));
+  const router = loadRouter(fx);
+  try {
+    router.applyToCodex();
+    const configToml = fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8");
+    assert.match(configToml, new RegExp(`^model_catalog_json = "${catalogFile.replace(/\./g, "\\.")}"$`, "m"));
+    // 再次接管：已是绝对路径时不重复注入
+    router.applyToCodex();
+    const again = fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8");
+    assert.equal(again.match(/^model_catalog_json = /gm).length, 1);
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("relative model_catalog_json is upgraded to an absolute path and user catalogs are preserved", { concurrency: false }, () => {
+  const fx = fixture({
+    activeId: "deepseek",
+    groups: [{
+      id: "deepseek",
+      name: "DeepSeek",
+      baseUrl: "https://proxy.example.test",
+      key: "deepseek-key",
+      model: "deepseek-chat",
+      mode: "responses",
+    }],
+    configToml: 'model_catalog_json = "cc-switch-model-catalog.json"\n',
+  });
+  const catalogFile = path.join(fx.codexHome, "cc-switch-model-catalog.json");
+  fs.writeFileSync(catalogFile, JSON.stringify({ models: [{ slug: "template", context_window: 128000, visibility: "list" }] }));
+  const router = loadRouter(fx);
+  try {
+    router.applyToCodex();
+    let configToml = fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8");
+    assert.match(configToml, new RegExp(`^model_catalog_json = "${catalogFile.replace(/\./g, "\\.")}"$`, "m"));
+    assert.doesNotMatch(configToml, /model_catalog_json = "cc-switch/);
+    // 指向用户自建目录时不被改写
+    fs.writeFileSync(path.join(fx.codexHome, "config.toml"), 'model_catalog_json = "my-own-catalog.json"\n');
+    router.applyDirectToCodex("deepseek");
+    configToml = fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8");
+    assert.match(configToml, /^model_catalog_json = "my-own-catalog.json"$/m);
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("small explicit context windows are honored instead of silently ignored", { concurrency: false }, () => {
+  const fx = fixture({
+    activeId: "deepseek",
+    groups: [{
+      id: "deepseek",
+      name: "DeepSeek",
+      baseUrl: "https://proxy.example.test",
+      key: "deepseek-key",
+      model: "deepseek-chat",
+      mode: "responses",
+      contextWindow: "2048",
+    }],
+  });
+  const catalogFile = path.join(fx.codexHome, "cc-switch-model-catalog.json");
+  fs.writeFileSync(catalogFile, JSON.stringify({
+    models: [{ slug: "template", context_window: 128000, max_context_window: 128000, visibility: "list" }],
+  }));
+  const router = loadRouter(fx);
+  try {
+    router.applyToCodex();
+    const catalog = JSON.parse(fs.readFileSync(catalogFile, "utf-8"));
+    const deepseek = catalog.models.find((model) => model.slug === "deepseek-chat");
+    assert.equal(deepseek.context_window, 2048);
+    assert.equal(deepseek.effective_context_window_percent, 80);
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("running router writes the newly selected model immediately", { concurrency: false }, async () => {
+  const probe = http.createServer();
+  const port = await listen(probe);
+  await close(probe);
+  const fx = fixture({
+    port,
+    activeId: "model-a",
+    configToml: [
+      'model_provider = "td-direct"',
+      'model = "gpt-model-a"',
+      "",
+      "[model_providers.td-direct]",
+      'name = "Old direct route"',
+      'base_url = "https://old.example.test"',
+      'wire_api = "responses"',
+      "requires_openai_auth = true",
+      "",
+    ].join("\n"),
+    auth: {
+      auth_mode: "chatgpt",
+      OPENAI_API_KEY: "key-a",
+      tokens: { access_token: "official-access-token" },
+    },
+    groups: [
+      {
+        id: "model-a",
+        name: "Model A",
+        baseUrl: "http://127.0.0.1:1",
+        key: "key-a",
+        model: "gpt-model-a",
+        mode: "responses",
+      },
+      {
+        id: "model-b",
+        name: "Model B",
+        baseUrl: "http://127.0.0.1:1",
+        key: "key-b",
+        model: "gpt-model-b",
+        mode: "responses",
+      },
+    ],
+  });
+  const previousFetch = global.fetch;
+  global.fetch = async () => {
+    throw new Error("offline test");
+  };
+  const router = loadRouter(fx);
+  try {
+    await router.start();
+    router.applyToCodex();
+    const result = router.setActive("model-b");
+    assert.equal(result.activeId, "model-b");
+    assert.equal(result._needsCodexRefresh, true);
+    assert.equal(result._needsRestart, false);
+    const configToml = fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8");
+    assert.match(configToml, /^model_provider = "local-router"$/m);
+    assert.match(configToml, /^model = "gpt-model-b"$/m);
+    assert.doesNotMatch(configToml, /^model = "gpt-model-a"$/m);
+    const saved = JSON.parse(fs.readFileSync(path.join(fx.userData, "router.json"), "utf-8"));
+    assert.equal(saved.activeId, "model-b");
+    await new Promise((resolve) => setImmediate(resolve));
+  } finally {
+    router.stop();
+    global.fetch = previousFetch;
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("stopped router writes the selected group directly to Codex immediately", { concurrency: false }, () => {
+  const fx = fixture({
+    activeId: "default",
+    groups: [
+      {
+        id: "model-b",
+        name: "Model B",
+        baseUrl: "https://proxy.example.test/v1",
+        key: "key-b",
+        model: "gpt-model-b",
+        mode: "responses",
+      },
+    ],
+  });
+  const previousFetch = global.fetch;
+  global.fetch = async () => {
+    throw new Error("offline test");
+  };
+  const router = loadRouter(fx);
+  try {
+    assert.equal(router.isRunning(), false);
+    const result = router.setActive("model-b");
+    assert.equal(result.activeId, "model-b");
+    assert.equal(result._mode, "direct");
+    assert.equal(result._needsRestart, true);
+
+    const configToml = fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8");
+    assert.match(configToml, /^model_provider = "td-direct"$/m);
+    assert.match(configToml, /^model = "gpt-model-b"$/m);
+    assert.match(configToml, /^\[model_providers\.td-direct\]$/m);
+    assert.match(configToml, /^base_url = "https:\/\/proxy\.example\.test\/v1"$/m);
+    assert.doesNotMatch(configToml, /^\[model_providers\.local-router\]$/m);
+
+    const auth = JSON.parse(fs.readFileSync(path.join(fx.codexHome, "auth.json"), "utf-8"));
+    assert.equal(auth.OPENAI_API_KEY, "key-b");
+    assert.equal(auth.tokens.access_token, "official-access-token");
+
+    const saved = JSON.parse(fs.readFileSync(path.join(fx.userData, "router.json"), "utf-8"));
+    assert.equal(saved.activeId, "model-b");
+  } finally {
+    global.fetch = previousFetch;
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("direct switch retries a transient Windows-style auth.json lock", { concurrency: false }, () => {
+  const fx = fixture({
+    activeId: "default",
+    groups: [
+      {
+        id: "model-b",
+        name: "Model B",
+        baseUrl: "https://proxy.example.test/v1",
+        key: "key-b",
+        model: "gpt-model-b",
+        mode: "responses",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  const authFile = path.join(fx.codexHome, "auth.json");
+  const originalRenameSync = fs.renameSync;
+  let authRenameAttempts = 0;
+  fs.renameSync = function renameSyncWithTransientLock(from, to) {
+    if (to === authFile && authRenameAttempts++ === 0) {
+      const error = new Error("file is temporarily locked");
+      error.code = "EPERM";
+      throw error;
+    }
+    return originalRenameSync.call(this, from, to);
+  };
+  try {
+    const result = router.setActive("model-b");
+    assert.equal(result.activeId, "model-b");
+    assert.ok(authRenameAttempts >= 2);
+    assert.equal(
+      JSON.parse(fs.readFileSync(authFile, "utf-8")).OPENAI_API_KEY,
+      "key-b"
+    );
+    assert.match(
+      fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8"),
+      /^model_provider = "td-direct"$/m
+    );
+  } finally {
+    fs.renameSync = originalRenameSync;
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("direct switch rolls back config and active group when auth.json stays locked", { concurrency: false }, () => {
+  const fx = fixture({
+    activeId: "default",
+    groups: [
+      {
+        id: "model-b",
+        name: "Model B",
+        baseUrl: "https://proxy.example.test/v1",
+        key: "key-b",
+        model: "gpt-model-b",
+        mode: "responses",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  const configFile = path.join(fx.codexHome, "config.toml");
+  const authFile = path.join(fx.codexHome, "auth.json");
+  const beforeConfig = fs.readFileSync(configFile);
+  const beforeAuth = fs.readFileSync(authFile);
+  const originalRenameSync = fs.renameSync;
+  const originalWriteFileSync = fs.writeFileSync;
+  fs.renameSync = function renameSyncWithPersistentLock(from, to) {
+    if (to === authFile) {
+      const error = new Error("file remains locked");
+      error.code = "EPERM";
+      throw error;
+    }
+    return originalRenameSync.call(this, from, to);
+  };
+  fs.writeFileSync = function writeFileSyncWithPersistentLock(file, ...args) {
+    if (file === authFile) {
+      const error = new Error("file remains locked");
+      error.code = "EPERM";
+      throw error;
+    }
+    return originalWriteFileSync.call(this, file, ...args);
+  };
+  try {
+    assert.throws(
+      () => router.setActive("model-b"),
+      /无法写入配置文件 .*auth\.json/
+    );
+    assert.deepEqual(fs.readFileSync(configFile), beforeConfig);
+    assert.deepEqual(fs.readFileSync(authFile), beforeAuth);
+    assert.equal(router.status().activeId, "default");
+    assert.equal(
+      JSON.parse(fs.readFileSync(path.join(fx.userData, "router.json"), "utf-8")).activeId,
+      "default"
+    );
+  } finally {
+    fs.renameSync = originalRenameSync;
+    fs.writeFileSync = originalWriteFileSync;
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("claude proxy writes active model to settings and forwards that model upstream", { concurrency: false }, async () => {
+  let observed;
+  const upstream = http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      observed = {
+        headers: req.headers,
+        body: Buffer.concat(chunks).toString("utf-8"),
+      };
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end('{"type":"message","content":[]}');
+    });
+  });
+  const upstreamPort = await listen(upstream);
+  const probe = http.createServer();
+  const routerPort = await listen(probe);
+  await close(probe);
+  const fx = fixture({
+    port: routerPort,
+    activeClaudeId: "claude-glm",
+    claudeSettings: {
+      env: {
+        ANTHROPIC_BASE_URL: "https://original.example.test",
+        ANTHROPIC_AUTH_TOKEN: "original-token",
+        ANTHROPIC_MODEL: "original-model",
+      },
+    },
+    groups: [
+      {
+        id: "claude-glm",
+        name: "国模",
+        baseUrl: `http://127.0.0.1:${upstreamPort}`,
+        key: "glm-key",
+        model: "glm-5.2",
+        mode: "claude",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  const payload = JSON.stringify({
+    model: "claude-opus-4-8",
+    max_tokens: 128,
+    messages: [{ role: "user", content: "hi" }],
+  });
+  try {
+    await router.start();
+    const applied = router.applyToClaudeCode();
+    assert.equal(applied.ok, true);
+    const settings = JSON.parse(fs.readFileSync(path.join(fx.claudeHome, "settings.json"), "utf-8"));
+    assert.equal(settings.env.ANTHROPIC_BASE_URL, `http://127.0.0.1:${routerPort}`);
+    assert.equal(settings.env.ANTHROPIC_AUTH_TOKEN, fx.routerKey);
+    assert.equal(settings.env.ANTHROPIC_MODEL, "glm-5.2");
+
+    const response = await new Promise((resolve, reject) => {
+      const req = http.request({
+        method: "POST",
+        host: "127.0.0.1",
+        port: routerPort,
+        path: "/v1/messages",
+        headers: {
+          authorization: "Bearer " + fx.routerKey,
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(payload),
+          "anthropic-version": "2023-06-01",
+        },
+      }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve({
+          statusCode: res.statusCode,
+          body: Buffer.concat(chunks).toString("utf-8"),
+        }));
+      });
+      req.on("error", reject);
+      req.end(payload);
+    });
+
+    assert.equal(response.statusCode, 200);
+    assert.equal(response.body, '{"type":"message","content":[]}');
+    assert.ok(observed);
+    assert.equal(JSON.parse(observed.body).model, "glm-5.2");
+    assert.equal(observed.headers.authorization, "Bearer glm-key");
+    assert.equal(observed.headers["x-api-key"], undefined);
+    assert.equal(observed.headers["content-length"], String(Buffer.byteLength(observed.body)));
+
+    const restored = router.restoreClaudeCode();
+    assert.equal(restored.ok, true);
+    const restoredSettings = JSON.parse(fs.readFileSync(path.join(fx.claudeHome, "settings.json"), "utf-8"));
+    assert.equal(restoredSettings.env.ANTHROPIC_MODEL, "original-model");
+  } finally {
+    router.stop();
+    await close(upstream);
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("switching active claude group refreshes the cli model setting while router is running", { concurrency: false }, async () => {
+  const probe = http.createServer();
+  const routerPort = await listen(probe);
+  await close(probe);
+  const fx = fixture({
+    port: routerPort,
+    activeClaudeId: "claude-opus",
+    groups: [
+      {
+        id: "claude-opus",
+        name: "Claude",
+        baseUrl: "https://claude.example.test",
+        key: "opus-key",
+        model: "claude-opus-4-8",
+        mode: "claude",
+      },
+      {
+        id: "claude-glm",
+        name: "国模",
+        baseUrl: "https://glm.example.test",
+        key: "glm-key",
+        model: "glm-5.2",
+        mode: "claude",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  try {
+    await router.start();
+    assert.equal(router.applyToClaudeCode().ok, true);
+    assert.equal(
+      JSON.parse(fs.readFileSync(path.join(fx.claudeHome, "settings.json"), "utf-8")).env.ANTHROPIC_MODEL,
+      "claude-opus-4-8"
+    );
+
+    const result = router.setActive("claude-glm");
+    assert.equal(result.activeClaudeId, "claude-glm");
+    assert.equal(result._mode, "proxy");
+    assert.equal(
+      JSON.parse(fs.readFileSync(path.join(fx.claudeHome, "settings.json"), "utf-8")).env.ANTHROPIC_MODEL,
+      "glm-5.2"
+    );
+  } finally {
+    router.stop();
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("claude switch rolls back active group when settings.json stays locked", { concurrency: false }, () => {
+  const fx = fixture({
+    activeClaudeId: "claude-opus",
+    claudeSettings: {
+      env: {
+        ANTHROPIC_BASE_URL: "https://opus.example.test",
+        ANTHROPIC_AUTH_TOKEN: "opus-key",
+        ANTHROPIC_MODEL: "claude-opus-4-8",
+      },
+    },
+    groups: [
+      {
+        id: "claude-opus",
+        name: "Claude",
+        baseUrl: "https://opus.example.test",
+        key: "opus-key",
+        model: "claude-opus-4-8",
+        mode: "claude",
+      },
+      {
+        id: "claude-glm",
+        name: "国模",
+        baseUrl: "https://glm.example.test",
+        key: "glm-key",
+        model: "glm-5.2",
+        mode: "claude",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  const settingsFile = path.join(fx.claudeHome, "settings.json");
+  const beforeSettings = fs.readFileSync(settingsFile);
+  const originalRenameSync = fs.renameSync;
+  const originalWriteFileSync = fs.writeFileSync;
+  fs.renameSync = function renameSyncWithPersistentLock(from, to) {
+    if (to === settingsFile) {
+      const error = new Error("file remains locked");
+      error.code = "EPERM";
+      throw error;
+    }
+    return originalRenameSync.call(this, from, to);
+  };
+  fs.writeFileSync = function writeFileSyncWithPersistentLock(file, ...args) {
+    if (file === settingsFile) {
+      const error = new Error("file remains locked");
+      error.code = "EPERM";
+      throw error;
+    }
+    return originalWriteFileSync.call(this, file, ...args);
+  };
+  try {
+    assert.throws(
+      () => router.setActive("claude-glm"),
+      /无法写入配置文件 .*settings\.json/
+    );
+    assert.deepEqual(fs.readFileSync(settingsFile), beforeSettings);
+    assert.equal(router.status().activeClaudeId, "claude-opus");
+    assert.equal(
+      JSON.parse(fs.readFileSync(path.join(fx.userData, "router.json"), "utf-8")).activeClaudeId,
+      "claude-opus"
+    );
+  } finally {
+    fs.renameSync = originalRenameSync;
+    fs.writeFileSync = originalWriteFileSync;
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("stopping restores official config when managed sections or keys remain", { concurrency: false }, () => {
+  const fx = fixture({
+    activeId: "model-a",
+    configToml: [
+      'model_provider = "custom-user-provider"',
+      'model = "gpt-model-a"',
+      "",
+      "[model_providers.custom-user-provider]",
+      'name = "User provider"',
+      'base_url = "https://user.example.test"',
+      'wire_api = "responses"',
+      "",
+      "[model_providers.local-router]",
+      'name = "Stale local route"',
+      'base_url = "http://127.0.0.1:8787"',
+      'wire_api = "responses"',
+      "",
+      "[model_providers.td-direct]",
+      'name = "Stale direct route"',
+      'base_url = "https://stale.example.test"',
+      'wire_api = "responses"',
+      "",
+    ].join("\n"),
+    auth: {
+      auth_mode: "chatgpt",
+      OPENAI_API_KEY: "rk-test-router-key",
+      tokens: { access_token: "official-access-token" },
+    },
+    groups: [
+      {
+        id: "model-a",
+        name: "Model A",
+        baseUrl: "https://proxy.example.test",
+        key: "key-a",
+        model: "gpt-model-a",
+        mode: "responses",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  try {
+    const result = router.stopAndRestoreDirect();
+    assert.equal(result.released, true);
+    assert.equal(result.removedManagedProvider, false);
+    assert.equal(result.keptUserProvider, true);
+    const configToml = fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8");
+    assert.doesNotMatch(configToml, /local-router/);
+    assert.doesNotMatch(configToml, /td-direct/);
+    assert.match(configToml, /^model_provider = "custom-user-provider"$/m);
+    assert.match(configToml, /^\[model_providers\.custom-user-provider\]$/m);
+    assert.match(configToml, /^model = "gpt-model-a"$/m);
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("disabling an already-stopped local route removes its Codex takeover", { concurrency: false }, () => {
+  const fx = fixture({
+    configToml: [
+      'model_provider = "local-router"',
+      'model = "gpt-model-a"',
+      "",
+      "[model_providers.local-router]",
+      'name = "本地路由"',
+      'base_url = "http://127.0.0.1:8787"',
+      'wire_api = "responses"',
+      "",
+    ].join("\n"),
+    auth: {
+      auth_mode: "chatgpt",
+      OPENAI_API_KEY: "rk-test-router-key",
+      tokens: { access_token: "official-access-token" },
+    },
+    groups: [],
+  });
+  const router = loadRouter(fx);
+  try {
+    assert.equal(router.status().running, false);
+    assert.equal(router.status().codexApplied, true);
+    const result = router.disableCodex();
+    assert.equal(result.released, true);
+    assert.equal(result.removedManagedProvider, true);
+    assert.equal(result.keptUserProvider, false);
+    const configToml = fs.readFileSync(path.join(fx.codexHome, "config.toml"), "utf-8");
+    const auth = JSON.parse(fs.readFileSync(path.join(fx.codexHome, "auth.json"), "utf-8"));
+    assert.doesNotMatch(configToml, /local-router/);
+    assert.doesNotMatch(configToml, /^model_provider\s*=/m);
+    assert.doesNotMatch(configToml, /^model\s*=/m);
+    assert.equal(auth.OPENAI_API_KEY, undefined);
+    assert.equal(router.status().codexApplied, false);
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("large chunked requests are forwarded with one content-length and no client hop-by-hop headers", { concurrency: false }, async () => {
+  let observed;
+  const upstream = http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      observed = {
+        headers: req.headers,
+        rawHeaders: req.rawHeaders,
+        body: Buffer.concat(chunks),
+      };
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end('{"ok":true}');
+    });
+  });
+  const upstreamPort = await listen(upstream);
+  const probe = http.createServer();
+  const routerPort = await listen(probe);
+  await close(probe);
+  const fx = fixture({
+    port: routerPort,
+    activeId: "model-a",
+    configToml: [
+      'model_provider = "local-router"',
+      'model = "gpt-model-a"',
+      "",
+      "[model_providers.local-router]",
+      'name = "Local route"',
+      `base_url = "http://127.0.0.1:${routerPort}"`,
+      'wire_api = "responses"',
+      "",
+    ].join("\n"),
+    auth: {
+      auth_mode: "chatgpt",
+      OPENAI_API_KEY: "rk-test-router-key",
+      tokens: { access_token: "official-access-token" },
+    },
+    groups: [
+      {
+        id: "model-a",
+        name: "Model A",
+        baseUrl: `http://127.0.0.1:${upstreamPort}`,
+        key: "upstream-key",
+        model: "gpt-model-a",
+        mode: "responses",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  const payload = Buffer.from(JSON.stringify({
+    model: "gpt-model-a",
+    instructions: "x".repeat(180 * 1024),
+    input: [{ role: "user", content: "long conversation" }],
+  }));
+  try {
+    await router.start();
+    const response = await new Promise((resolve, reject) => {
+      const req = http.request({
+        method: "POST",
+        host: "127.0.0.1",
+        port: routerPort,
+        path: "/responses",
+        headers: {
+          authorization: "Bearer " + fx.routerKey,
+          "content-type": "application/json",
+          connection: "keep-alive, x-remove-me",
+          "x-remove-me": "must-not-reach-upstream",
+          "transfer-encoding": "chunked",
+          te: "trailers",
+          trailer: "x-client-trailer",
+          upgrade: "websocket",
+        },
+      }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve({
+          statusCode: res.statusCode,
+          body: Buffer.concat(chunks).toString("utf-8"),
+        }));
+      });
+      req.on("error", reject);
+      for (let offset = 0; offset < payload.length; offset += 4096) {
+        req.write(payload.subarray(offset, offset + 4096));
+      }
+      req.end();
+    });
+
+    assert.equal(response.statusCode, 200);
+    assert.equal(response.body, '{"ok":true}');
+    assert.ok(observed);
+    assert.equal(observed.body.length, payload.length);
+    assert.deepEqual(JSON.parse(observed.body.toString("utf-8")), JSON.parse(payload.toString("utf-8")));
+    assert.equal(observed.headers["content-length"], String(payload.length));
+    assert.equal(observed.headers["transfer-encoding"], undefined);
+    assert.equal(observed.headers.te, undefined);
+    assert.equal(observed.headers.trailer, undefined);
+    assert.equal(observed.headers.upgrade, undefined);
+    assert.equal(observed.headers["x-remove-me"], undefined);
+    assert.equal(observed.headers.host, `127.0.0.1:${upstreamPort}`);
+    assert.equal(
+      observed.rawHeaders.filter((_, index) => index % 2 === 0 && observed.rawHeaders[index].toLowerCase() === "content-length").length,
+      1
+    );
+  } finally {
+    router.stop();
+    await close(upstream);
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("chat multimodal group injects MiniMax evidence before forwarding to DeepSeek", { concurrency: false }, async () => {
+  let upstreamBody;
+  const upstream = http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      upstreamBody = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+      res.writeHead(200, { "content-type": "text/event-stream" });
+      res.end('data: {"choices":[{"delta":{"content":"ok"}}]}\n\ndata: [DONE]\n\n');
+    });
+  });
+  const upstreamPort = await listen(upstream);
+  const probe = http.createServer();
+  const routerPort = await listen(probe);
+  await close(probe);
+  const fx = fixture({
+    port: routerPort,
+    activeId: "deepseek-chat",
+    groups: [
+      {
+        id: "deepseek-chat",
+        name: "DeepSeek",
+        baseUrl: `http://127.0.0.1:${upstreamPort}`,
+        key: "deepseek-key",
+        model: "deepseek-chat",
+        mode: "chat",
+        multimodal: true,
+      },
+    ],
+  });
+  const previousFetch = global.fetch;
+  const previousKey = process.env.TD_MULTIMODAL_GATEWAY_KEY;
+  process.env.TD_MULTIMODAL_GATEWAY_KEY = "test-multimodal-key";
+  global.fetch = async () => ({
+    ok: true,
+    json: async () => ({
+      choices: [{
+        message: {
+          content: '{"summary":"登录页截图","items":[{"kind":"ocr","text":"账号登录","confidence":0.99}]}',
+        },
+      }],
+    }),
+  });
+  const router = loadRouter(fx);
+  try {
+    await router.start();
+    await new Promise((resolve, reject) => {
+      const req = http.request({
+        method: "POST",
+        host: "127.0.0.1",
+        port: routerPort,
+        path: "/responses",
+        headers: {
+          authorization: "Bearer " + fx.routerKey,
+          "content-type": "application/json",
+        },
+      }, (res) => {
+        res.resume();
+        res.on("end", resolve);
+      });
+      req.on("error", reject);
+      req.end(JSON.stringify({
+        model: "gpt-5",
+        stream: true,
+        tool_choice: "auto",
+        tools: [
+          { type: "function", name: "exec_command", parameters: { type: "object" } },
+          { type: "function", name: "view_image", parameters: { type: "object" } },
+        ],
+        input: [{
+          type: "message",
+          role: "user",
+          content: [
+            { type: "input_text", text: "图片里有什么？" },
+            { type: "input_image", image_url: "data:image/png;base64,cm91dGVyLXRlc3Q=" },
+          ],
+        }],
+      }));
+    });
+
+    assert.ok(upstreamBody);
+    assert.equal(upstreamBody.model, "deepseek-chat");
+    const userContent = upstreamBody.messages
+      .filter((message) => message.role === "user")
+      .map((message) => message.content)
+      .join("\n");
+    assert.match(userContent, /图片里有什么/);
+    assert.match(userContent, /\[TD 多模态识别证据\]/);
+    assert.match(userContent, /账号登录/);
+    assert.doesNotMatch(userContent, /test-multimodal-key/);
+    assert.equal(upstreamBody.tool_choice, "auto");
+    assert.deepEqual(upstreamBody.tools.map((tool) => tool.function.name), ["exec_command"]);
+  } finally {
+    router.stop();
+    global.fetch = previousFetch;
+    if (previousKey == null) delete process.env.TD_MULTIMODAL_GATEWAY_KEY;
+    else process.env.TD_MULTIMODAL_GATEWAY_KEY = previousKey;
+    await close(upstream);
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("explicit model routes total control and worker requests to their registered groups", { concurrency: false }, async () => {
+  const seen = [];
+  const makeUpstream = (name) => http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      seen.push({ name, body: JSON.parse(Buffer.concat(chunks).toString("utf-8")) });
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end('{"ok":true}');
+    });
+  });
+  const gptUpstream = makeUpstream("gpt");
+  const deepseekUpstream = makeUpstream("deepseek");
+  const gptPort = await listen(gptUpstream);
+  const deepseekPort = await listen(deepseekUpstream);
+  const probe = http.createServer();
+  const routerPort = await listen(probe);
+  await close(probe);
+  const fx = fixture({
+    port: routerPort,
+    activeId: "gpt-group",
+    groups: [
+      {
+        id: "gpt-group",
+        name: "GPT 总控",
+        baseUrl: `http://127.0.0.1:${gptPort}`,
+        key: "gpt-key",
+        model: "gpt-5.6-luna",
+        mode: "responses",
+      },
+      {
+        id: "deepseek-group",
+        name: "DeepSeek 执行",
+        baseUrl: `http://127.0.0.1:${deepseekPort}`,
+        key: "deepseek-key",
+        model: "deepseek-v4-flash",
+        mode: "responses",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  const send = (model) => new Promise((resolve, reject) => {
+    const payload = JSON.stringify({ model, input: [{ role: "user", content: "ping" }] });
+    const req = http.request({
+      method: "POST",
+      host: "127.0.0.1",
+      port: routerPort,
+      path: "/responses",
+      headers: {
+        authorization: "Bearer " + fx.routerKey,
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(payload),
+      },
+    }, (res) => {
+      res.resume();
+      res.on("end", () => resolve(res.statusCode));
+    });
+    req.on("error", reject);
+    req.end(payload);
+  });
+  try {
+    await router.start();
+    const route = router.registerModelRoute("deepseek-group", "deepseek-v4-flash");
+    assert.equal(route.ok, true);
+    assert.equal(route.groupId, "deepseek-group");
+    const saved = JSON.parse(fs.readFileSync(path.join(fx.userData, "router.json"), "utf-8"));
+    assert.deepEqual(saved.groups.find((g) => g.id === "deepseek-group").routeModels, ["deepseek-v4-flash"]);
+
+    assert.equal(await send("gpt-5.6-luna"), 200);
+    assert.equal(await send("deepseek-v4-flash"), 200);
+    assert.deepEqual(seen.map((x) => [x.name, x.body.model]), [
+      ["gpt", "gpt-5.6-luna"],
+      ["deepseek", "deepseek-v4-flash"],
+    ]);
+  } finally {
+    router.stop();
+    await close(gptUpstream);
+    await close(deepseekUpstream);
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("stale selector model does not override the active group while router is running", { concurrency: false }, async () => {
+  const seen = [];
+  const makeUpstream = (name) => http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      seen.push({ name, body: JSON.parse(Buffer.concat(chunks).toString("utf-8")) });
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end('{"ok":true}');
+    });
+  });
+  const kimiUpstream = makeUpstream("kimi");
+  const deepseekUpstream = makeUpstream("deepseek");
+  const kimiPort = await listen(kimiUpstream);
+  const deepseekPort = await listen(deepseekUpstream);
+  const probe = http.createServer();
+  const routerPort = await listen(probe);
+  await close(probe);
+  const fx = fixture({
+    port: routerPort,
+    activeId: "deepseek-group",
+    groups: [
+      {
+        id: "kimi-group",
+        name: "Kimi",
+        baseUrl: `http://127.0.0.1:${kimiPort}`,
+        key: "kimi-key",
+        model: "kimi-k3",
+        mode: "responses",
+      },
+      {
+        id: "deepseek-group",
+        name: "DeepSeek",
+        baseUrl: `http://127.0.0.1:${deepseekPort}`,
+        key: "deepseek-key",
+        model: "deepseek-v4-pro",
+        mode: "responses",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  // Codex 顶部选择器尚未刷新，普通请求仍携带旧模型名。它不应覆盖 activeId。
+  const payload = JSON.stringify({
+    model: "kimi-k3",
+    instructions: "hello",
+    input: [{ role: "user", content: "ping" }],
+  });
+  try {
+    await router.start();
+    const status = await new Promise((resolve, reject) => {
+      const req = http.request({
+        method: "POST",
+        host: "127.0.0.1",
+        port: routerPort,
+        path: "/responses",
+        headers: {
+          authorization: "Bearer " + fx.routerKey,
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(payload),
+        },
+      }, (res) => {
+        res.resume();
+        res.on("end", () => resolve(res.statusCode));
+      });
+      req.on("error", reject);
+      req.end(payload);
+    });
+    assert.equal(status, 200);
+    assert.deepEqual(seen.map((x) => [x.name, x.body.model]), [
+      ["deepseek", "deepseek-v4-pro"],
+    ]);
+  } finally {
+    router.stop();
+    await close(kimiUpstream);
+    await close(deepseekUpstream);
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test("agent route hint overrides root model for worker requests", { concurrency: false }, async () => {
+  const seen = [];
+  const makeUpstream = (name) => http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      seen.push({ name, body: JSON.parse(Buffer.concat(chunks).toString("utf-8")) });
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end('{"ok":true}');
+    });
+  });
+  const gptUpstream = makeUpstream("gpt");
+  const deepseekUpstream = makeUpstream("deepseek");
+  const gptPort = await listen(gptUpstream);
+  const deepseekPort = await listen(deepseekUpstream);
+  const probe = http.createServer();
+  const routerPort = await listen(probe);
+  await close(probe);
+  const fx = fixture({
+    port: routerPort,
+    activeId: "gpt-group",
+    groups: [
+      {
+        id: "gpt-group",
+        name: "GPT 总控",
+        baseUrl: `http://127.0.0.1:${gptPort}`,
+        key: "gpt-key",
+        model: "gpt-5.6-luna",
+        mode: "responses",
+      },
+      {
+        id: "deepseek-group",
+        name: "DeepSeek 执行",
+        baseUrl: `http://127.0.0.1:${deepseekPort}`,
+        key: "deepseek-key",
+        model: "deepseek-v4-flash",
+        mode: "responses",
+      },
+    ],
+  });
+  const router = loadRouter(fx);
+  const payload = JSON.stringify({
+    model: "gpt-5.6-luna",
+    instructions: '你是 worker。\n[TD_MODEL_ROUTE model="deepseek-v4-flash" role="worker" agent="frontend"; runtime hint only.]',
+    input: [{ role: "user", content: "ping" }],
+  });
+  try {
+    await router.start();
+    router.registerModelRoute("deepseek-group", "deepseek-v4-flash");
+    const status = await new Promise((resolve, reject) => {
+      const req = http.request({
+        method: "POST",
+        host: "127.0.0.1",
+        port: routerPort,
+        path: "/responses",
+        headers: {
+          authorization: "Bearer " + fx.routerKey,
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(payload),
+        },
+      }, (res) => {
+        res.resume();
+        res.on("end", () => resolve(res.statusCode));
+      });
+      req.on("error", reject);
+      req.end(payload);
+    });
+    assert.equal(status, 200);
+    assert.deepEqual(seen.map((x) => [x.name, x.body.model]), [
+      ["deepseek", "deepseek-v4-flash"],
+    ]);
+  } finally {
+    router.stop();
+    await close(gptUpstream);
+    await close(deepseekUpstream);
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
diff --git a/test/session-restore.test.js b/test/session-restore.test.js
new file mode 100644
index 0000000..9baa385
--- /dev/null
+++ b/test/session-restore.test.js
@@ -0,0 +1,166 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const Module = require("node:module");
+const childProcess = require("node:child_process");
+const initSqlJs = require("sql.js");
+
+const PROVIDER_MODULE = path.resolve(__dirname, "../electron/lib/provider_sync.js");
+const DESKTOP_MODULE = path.resolve(__dirname, "../electron/lib/codex_desktop.js");
+
+function writeRollout(root, id) {
+  const dir = path.join(root, "sessions", "2026", "08", "09");
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `rollout-${id}.jsonl`), [
+    JSON.stringify({ type: "session_meta", payload: { session_id: id, cwd: "C:/work/demo", timestamp: "2026-08-09T10:00:00.000Z", model_provider: "old" } }),
+    JSON.stringify({ type: "event_msg", payload: { type: "user_message", message: "Windows restore test" } }),
+  ].join("\n") + "\n");
+}
+
+// subagent 会话的 session_meta.payload.source 是对象（{subagent:{thread_spawn:{...}}}），
+// 不是字符串。曾导致 Windows（无 sqlite3 CLI，走 sql.js 绑定）整批 upsert 抛错回滚，
+// state 库 0 线程而侧栏 catalog 正常，Codex 启动 full reconcile 后会话"闪现后全部消失"。
+function writeSubagentRollout(root, id, parentId) {
+  const dir = path.join(root, "sessions", "2026", "08", "09");
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `rollout-${id}.jsonl`), [
+    JSON.stringify({
+      type: "session_meta",
+      payload: {
+        session_id: id,
+        cwd: "C:/work/demo",
+        timestamp: "2026-08-09T11:00:00.000Z",
+        model_provider: "old",
+        source: { subagent: { thread_spawn: { parent_thread_id: parentId, depth: 1, agent_path: null, agent_nickname: "Dirac", agent_role: null } } },
+        thread_source: "subagent",
+      },
+    }),
+    JSON.stringify({ type: "event_msg", payload: { type: "user_message", message: "subagent task" } }),
+  ].join("\n") + "\n");
+}
+
+test("会话恢复在没有 sqlite3 时插入线程并创建侧栏目录", { concurrency: false }, async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-session-restore-"));
+  const dataDir = path.join(root, "codex");
+  const userData = path.join(root, "app-data");
+  const id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+  const originalLoad = Module._load;
+  const originalSpawnSync = childProcess.spawnSync;
+  const originalBundleRoot = global.__BUNDLE_ROOT__;
+
+  try {
+    fs.mkdirSync(userData, { recursive: true });
+    fs.mkdirSync(path.join(dataDir, "sessions"), { recursive: true });
+    fs.writeFileSync(path.join(dataDir, "config.toml"), 'model_provider = "openai"\n');
+    writeRollout(dataDir, id);
+
+    Module._load = function (request, parent, isMain) {
+      if (request === "electron") return { app: { getPath: () => userData } };
+      return originalLoad.call(this, request, parent, isMain);
+    };
+    childProcess.spawnSync = function (command, args, options) {
+      if (command === "sqlite3") return { error: new Error("sqlite3 not installed"), status: null, stdout: "", stderr: "" };
+      return originalSpawnSync.call(this, command, args, options);
+    };
+    delete require.cache[PROVIDER_MODULE];
+    delete require.cache[DESKTOP_MODULE];
+    global.__BUNDLE_ROOT__ = path.resolve(__dirname, "..");
+    const provider = require(PROVIDER_MODULE);
+    const desktop = require(DESKTOP_MODULE);
+    desktop.codexRunning = () => false;
+    provider.setCodexDataDir(dataDir);
+
+    const result = await provider.syncProviderToCurrent(() => {});
+    assert.equal(result.insertedRows, 1);
+    assert.equal(result.catalogRebuilt, 1);
+    assert.equal(result.stateDbCreated, 1);
+    assert.equal(result.stateDbCreateError, "");
+    assert.equal(fs.existsSync(path.join(dataDir, "sqlite", "codex-dev.db")), true);
+    assert.equal(fs.existsSync(path.join(dataDir, "session_index.jsonl")), true);
+    assert.equal(fs.existsSync(path.join(dataDir, "state_5.sqlite")), true);
+
+    const SQL = await initSqlJs({ locateFile: (file) => path.join(__dirname, "../node_modules/sql.js/dist", file) });
+    const restoredState = new SQL.Database(fs.readFileSync(path.join(dataDir, "state_5.sqlite")));
+    assert.equal(restoredState.exec("SELECT COUNT(*) FROM threads")[0].values[0][0], 1);
+    assert.equal(restoredState.exec("SELECT has_user_event FROM threads WHERE id='" + id + "'")[0].values[0][0], 1);
+    assert.equal(restoredState.exec("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name IN ('thread_sections','thread_dynamic_tools','thread_spawn_edges','backfill_state','external_agent_config_imports','remote_control_enrollments')")[0].values[0][0], 6);
+    assert.equal(restoredState.exec("SELECT COUNT(*) FROM _sqlx_migrations")[0].values[0][0], 45);
+    restoredState.close();
+
+    const catalog = new SQL.Database(fs.readFileSync(path.join(dataDir, "sqlite", "codex-dev.db")));
+    assert.equal(catalog.exec("SELECT COUNT(*) FROM local_thread_catalog")[0].values[0][0], 1);
+    catalog.close();
+  } finally {
+    Module._load = originalLoad;
+    childProcess.spawnSync = originalSpawnSync;
+    global.__BUNDLE_ROOT__ = originalBundleRoot;
+    delete require.cache[PROVIDER_MODULE];
+    delete require.cache[DESKTOP_MODULE];
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("subagent source 对象不再让 Windows(sql.js) 路径整批失败，且自建 catalog 库带 user_version", { concurrency: false }, async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-session-restore-"));
+  const dataDir = path.join(root, "codex");
+  const userData = path.join(root, "app-data");
+  const id = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
+  const subId = "cccccccc-cccc-4ccc-8ccc-cccccccccccc";
+  const originalLoad = Module._load;
+  const originalSpawnSync = childProcess.spawnSync;
+  const originalBundleRoot = global.__BUNDLE_ROOT__;
+
+  try {
+    fs.mkdirSync(userData, { recursive: true });
+    fs.mkdirSync(path.join(dataDir, "sessions"), { recursive: true });
+    fs.writeFileSync(path.join(dataDir, "config.toml"), 'model_provider = "openai"\n');
+    writeRollout(dataDir, id);
+    writeSubagentRollout(dataDir, subId, id);
+
+    Module._load = function (request, parent, isMain) {
+      if (request === "electron") return { app: { getPath: () => userData } };
+      return originalLoad.call(this, request, parent, isMain);
+    };
+    childProcess.spawnSync = function (command, args, options) {
+      if (command === "sqlite3") return { error: new Error("sqlite3 not installed"), status: null, stdout: "", stderr: "" };
+      return originalSpawnSync.call(this, command, args, options);
+    };
+    delete require.cache[PROVIDER_MODULE];
+    delete require.cache[DESKTOP_MODULE];
+    global.__BUNDLE_ROOT__ = path.resolve(__dirname, "..");
+    const provider = require(PROVIDER_MODULE);
+    const desktop = require(DESKTOP_MODULE);
+    desktop.codexRunning = () => false;
+    provider.setCodexDataDir(dataDir);
+
+    const result = await provider.syncProviderToCurrent(() => {}, () => {});
+    // 两条线程都必须进 state 库（修复前 subagent 的 source 对象会让整批回滚，insertedRows=0）
+    assert.equal(result.insertedRows, 2);
+
+    const SQL = await initSqlJs({ locateFile: (file) => path.join(__dirname, "../node_modules/sql.js/dist", file) });
+    const state = new SQL.Database(fs.readFileSync(path.join(dataDir, "state_5.sqlite")));
+    assert.equal(state.exec("SELECT COUNT(*) FROM threads")[0].values[0][0], 2);
+    // subagent 的 source 以 JSON 字符串入库（与 Codex 自身存储一致），而不是 '[object Object]'
+    const subSource = state.exec(`SELECT source FROM threads WHERE id='${subId}'`)[0].values[0][0];
+    assert.ok(subSource.startsWith('{"subagent"'), `source 应为 JSON 字符串，实际: ${subSource}`);
+    assert.ok(subSource.includes("Dirac"));
+    state.close();
+
+    // 自建 codex-dev.db 必须带 user_version（对齐 Codex 迁移链 v30），
+    // 否则 Codex 重跑迁移 v27/28/29 会置空 last_full_reconciled_at 触发 full reconcile
+    const catalog = new SQL.Database(fs.readFileSync(path.join(dataDir, "sqlite", "codex-dev.db")));
+    const uv = catalog.exec("PRAGMA user_version")[0].values[0][0];
+    assert.equal(uv, 30);
+    assert.equal(catalog.exec("SELECT COUNT(*) FROM local_thread_catalog")[0].values[0][0], 2);
+    catalog.close();
+  } finally {
+    Module._load = originalLoad;
+    childProcess.spawnSync = originalSpawnSync;
+    global.__BUNDLE_ROOT__ = originalBundleRoot;
+    delete require.cache[PROVIDER_MODULE];
+    delete require.cache[DESKTOP_MODULE];
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/test/team-routing.test.js b/test/team-routing.test.js
new file mode 100644
index 0000000..e0b887c
--- /dev/null
+++ b/test/team-routing.test.js
@@ -0,0 +1,73 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const Module = require("node:module");
+
+function loadTeam() {
+  const originalLoad = Module._load;
+  Module._load = function load(request, parent, isMain) {
+    if (request === "electron") {
+      return {
+        app: { getPath: () => "/tmp/codex-market-team-test" },
+        safeStorage: { isEncryptionAvailable: () => false },
+      };
+    }
+    return originalLoad.call(this, request, parent, isMain);
+  };
+  try {
+    delete require.cache[require.resolve("../electron/lib/team")];
+    delete require.cache[require.resolve("../electron/lib/router")];
+    return require("../electron/lib/team");
+  } finally {
+    Module._load = originalLoad;
+  }
+}
+
+test("team package keeps generation and runtime models separate", () => {
+  const team = loadTeam();
+  const files = team.packFiles({
+    project_name: "model-routing",
+    employees: [{
+      id: "worker",
+      name: "执行 Agent",
+      duty: "实现与测试",
+      model: "deepseek-v4-flash",
+      responsibilities: [],
+      constraints: [],
+      owner_paths: [],
+      review_paths: [],
+      allowed_paths: ["**"],
+      collaborators: [],
+    }],
+    orchestrator: {
+      id: "orchestrator",
+      name: "总控 Agent",
+      duty: "调度与验收",
+      model: "gpt-5.6-luna",
+      responsibilities: [],
+      constraints: [],
+      owner_paths: [],
+      review_paths: ["**"],
+      allowed_paths: [],
+      workflow: [],
+    },
+    model_routing: {
+      generation_model: "gpt-5.4-mini",
+      orchestrator_model: "gpt-5.6-luna",
+      worker_model: "deepseek-v4-flash",
+    },
+  }, "codex");
+
+  const orchestrator = files.find((file) => file.path === "agents/_orchestrator.toml").content;
+  const worker = files.find((file) => file.path === "agents/worker.toml").content;
+  const manifest = JSON.parse(files.find((file) => file.path === "agent-manifest.json").content);
+  assert.match(orchestrator, /model = "gpt-5\.6-luna"/);
+  assert.match(worker, /model = "deepseek-v4-flash"/);
+  assert.match(worker, /TD_MODEL_ROUTE model="deepseek-v4-flash" role="worker" agent="worker"/);
+  assert.doesNotMatch(orchestrator, /gpt-5\.4-mini/);
+  assert.deepEqual(manifest.model_routing, {
+    generation: "gpt-5.4-mini",
+    orchestrator: "gpt-5.6-luna",
+    workers: ["deepseek-v4-flash"],
+    capability_policy: "",
+  });
+});
diff --git a/test/token-inject.test.js b/test/token-inject.test.js
new file mode 100644
index 0000000..b2799f4
--- /dev/null
+++ b/test/token-inject.test.js
@@ -0,0 +1,18 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { TOKEN_INJECT_SCRIPT } = require("../electron/lib/token_inject");
+
+test("token injection script remains compilable", () => {
+  assert.doesNotThrow(() => new Function(TOKEN_INJECT_SCRIPT));
+  assert.doesNotMatch(TOKEN_INJECT_SCRIPT, /const VER = "td-token-v17"/);
+  assert.doesNotMatch(TOKEN_INJECT_SCRIPT, /const STYLE_ID = "td-token-style-v17"/);
+});
+
+test("token bar waits for a visible composer toolbar instead of falling back to the page root", () => {
+  assert.match(TOKEN_INJECT_SCRIPT, /const EDITOR_SELECTOR = "DIV\.ProseMirror/);
+  assert.match(TOKEN_INJECT_SCRIPT, /if \(!toolbar\) return false;[\s\S]*?const bar = document\.getElementById\(BAR_ID\) \|\| buildBar\(\);/);
+  assert.match(TOKEN_INJECT_SCRIPT, /if \(!toolbar\.contains\(bar\)\) return placeInToolbar\(bar, toolbar\);/);
+  assert.doesNotMatch(TOKEN_INJECT_SCRIPT, /centerUnderEditor\(/);
+  assert.doesNotMatch(TOKEN_INJECT_SCRIPT, /document\.body \|\| document\.documentElement\)\.appendChild\(bar\)/);
+});
diff --git a/test/translate.test.js b/test/translate.test.js
new file mode 100644
index 0000000..4bf0921
--- /dev/null
+++ b/test/translate.test.js
@@ -0,0 +1,112 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { responsesToChat } = require("../electron/lib/translate");
+
+test("chat projection keeps completed custom tool results without forwarding tool protocol", () => {
+  const result = responsesToChat({
+    model: "codex-model",
+    stream: true,
+    tool_choice: "auto",
+    input: [
+      { type: "additional_tools", role: "system", tools: [{ name: "exec_command" }] },
+      { type: "message", role: "user", content: [{ type: "input_text", text: "识别这张图" }] },
+      { type: "custom_tool_call", call_id: "call_1", name: "exec_command", input: "tesseract image.png" },
+      { type: "custom_tool_call_output", call_id: "call_1", output: [{ type: "text", text: "识别结果：设置" }] },
+      {
+        type: "message",
+        role: "user",
+        content: [
+          { type: "input_image", image_url: "data:image/png;base64,abc" },
+          { type: "input_text", text: "[TD 多模态识别证据] 设置页面" },
+        ],
+      },
+    ],
+  }, "deepseek-chat");
+
+  assert.equal(result.model, "deepseek-chat");
+  assert.equal(result.tools, undefined);
+  assert.equal(result.tool_choice, undefined);
+  assert.match(result.messages[0].content, /不能调用本地工具/);
+  assert.ok(result.messages.some((message) => /工具：exec_command/.test(message.content)));
+  assert.ok(result.messages.some((message) => /识别结果：设置/.test(message.content)));
+  assert.ok(result.messages.some((message) => /TD 多模态识别证据/.test(message.content)));
+  assert.ok(result.messages.every((message) => message.role !== "tool" && !message.tool_calls));
+});
+
+test("chat projection forwards native tools only when they are supplied", () => {
+  const withoutTools = responsesToChat({ model: "model", tool_choice: "auto", input: "你好" });
+  assert.equal(withoutTools.tool_choice, undefined);
+
+  const withTools = responsesToChat({
+    model: "model",
+    tool_choice: "auto",
+    tools: [{ type: "function", name: "lookup", parameters: { type: "object" } }],
+    input: "你好",
+  });
+  assert.equal(withTools.tool_choice, "auto");
+  assert.equal(withTools.tools[0].function.name, "lookup");
+});
+
+test("chat projection forwards Codex additional_tools so coding agents can execute", () => {
+  const result = responsesToChat({
+    model: "deepseek-chat",
+    tool_choice: "auto",
+    input: [
+      {
+        type: "additional_tools",
+        role: "developer",
+        tools: [{
+          type: "function",
+          name: "exec_command",
+          description: "Run a shell command",
+          parameters: {
+            type: "object",
+            properties: { cmd: { type: "string" } },
+            required: ["cmd"],
+          },
+        }],
+      },
+      { type: "message", role: "user", content: "发布热更" },
+    ],
+  });
+
+  assert.equal(result.tool_choice, "auto");
+  assert.equal(result.tools.length, 1);
+  assert.equal(result.tools[0].function.name, "exec_command");
+  assert.doesNotMatch(result.messages[0].content, /不能调用本地工具/);
+});
+
+test("multimodal chat projection removes image reading but keeps coding tools", () => {
+  const result = responsesToChat({
+    model: "model",
+    tool_choice: "auto",
+    tools: [
+      { type: "function", name: "exec_command", parameters: { type: "object" } },
+      { type: "function", name: "view_image", parameters: { type: "object" } },
+      { type: "web_search_preview" },
+    ],
+    input: "识别图片",
+  }, undefined, { omitVisualTools: true });
+
+  assert.equal(result.tool_choice, "auto");
+  assert.deepEqual(result.tools.map((tool) => tool.function.name), ["exec_command"]);
+});
+
+test("chat projection never forwards media Base64 from tool messages", () => {
+  const image = "data:image/png;base64," + "A".repeat(2 * 1024 * 1024);
+  const result = responsesToChat({
+    model: "deepseek-chat",
+    input: [{
+      type: "message",
+      role: "tool",
+      content: [{ type: "input_image", image_url: image }],
+    }],
+  });
+
+  const content = result.messages.map((message) => String(message.content || "")).join("\n");
+  assert.match(content, /图像二进制已省略/);
+  assert.doesNotMatch(content, /data:image/);
+  assert.ok(result.messages.every((message) => message.role !== "tool"));
+  assert.ok(content.length < 1000);
+});