feat: 发布热更 1.5.94，修复中转历史会话并支持一键清空

- 启动不再自动 router.start()：只想用其它功能的用户不再被接管
- 新增 applyDirectToCodex()：保存 responses 中转分组即把直连配置写进
  config.toml+auth.json(非本地路由),重启 Codex 即用;本地路由降级为
  '启用本地路由(高级)'显式选项
- chat 协议转换分组(DeepSeek/GLM/Kimi)保存时只提示需启用路由,不自动起
- 新增 snapshotOfficialLogin()：首次接管前完整快照官方 auth.json(含OAuth
  tokens)+config.toml(router.json加密存+落盘副本);restoreDirect 优先用它
  100%还原官方登录态,并清理 td-direct 残段
- setActive 按 isRunning 分流:路由在跑走本地路由秒切,否则写直连需重启
- 隔离测试:登录态21/21 + Mac custom回归9/9 全绿
- 版本 1.5.15 → 1.5.16

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.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.

.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"
+}

.gitignore

@@ -0,0 +1,18 @@
+# 依赖 / 构建产物
+node_modules/
+dist/
+dist-hot/
+output/
+.claude/
+
+# sing-box 引擎二进制（太大，用 scripts/fetch-singbox.sh 拉取）
+resources/singbox/*/sing-box
+resources/singbox/*/sing-box.exe
+
+# 杂项
+.DS_Store
+*.log
+*.map
+
+# 多模态免费网关凭据：打包前由发布环境注入，绝不提交。
+resources/multimodal-gateway.json

.learnings/ERRORS.md

@@ -0,0 +1,37 @@
+# Errors
+
+Command failures and integration errors.
+
+---
+
+## [ERR-20260716-001] tavily_skill_local_setup
+
+**Logged**: 2026-07-16T17:27:46+0800
+**Priority**: medium
+**Status**: pending
+**Area**: config
+
+### Summary
+Local Tavily skill script could not run directly and its Python dependency was not installed.
+
+### Error
+```text
+permission denied: .../Tavily-AI-Search/scripts/tavily_search.py
+tavily-python package not installed
+externally-managed-environment
+```
+
+### Context
+- Attempted to use the Tavily skill for a news search.
+- The script lacks executable permission, so `python3 script.py` is needed.
+- Installing `tavily-python` into the system Python was blocked by PEP 668.
+- `TAVILY_API_KEY` was not present in the environment.
+
+### Suggested Fix
+Use a project or skill-local virtual environment for `tavily-python`, make the script executable if desired, and configure `TAVILY_API_KEY` or a supported app config key.
+
+### Metadata
+- Reproducible: yes
+- Related Files: /Users/mac/Library/Application Support/tokendun-codex-client/skills/Tavily-AI-Search/scripts/tavily_search.py
+
+---

.learnings/FEATURE_REQUESTS.md

@@ -0,0 +1,5 @@
+# Feature Requests
+
+Capabilities requested by the user.
+
+---

.learnings/LEARNINGS.md

@@ -0,0 +1,7 @@
+# Learnings
+
+Corrections, insights, and knowledge gaps captured during development.
+
+**Categories**: correction | insight | knowledge_gap | best_practice
+
+---

AGENTS.md

@@ -0,0 +1,45 @@
+<!-- codex-memory:start -->
+## 项目记忆（Codex 插件市场自动维护 · 回答前据此 · 勿手动编辑本段）
+**关于用户 / 长期事实（务必遵守）**：
+- 跟AI/沟通用中文，给生成模型的提示词可中英混写。
+- 图片/视频节点统一 composer 风格
+- 背景采用浅色网格风格，控件用悬浮pill
+- 应用候选需按包身份精确匹配
+- 面板改随机用户名/密码/路径,写SQLite+bcrypt
+- 画布做成独立全屏工作台，采用 tldraw 轻量白板中性风格，支持全屏与可拖动缩放，不做聊天内大表单
+- 助手身份使用 kimi-k3
+**当前状态**：首条需求：你好
+**已定决策**：
+- 热更必须递增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-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 -->
+
+## 发布与热更规则
+
+- 热更、完整安装包和插件资源的归属仓库统一为 `mhgmh/codex-market-app`。
+- `backup-bot` 只是 Gitea 上传认证账号，不是资源归属者；禁止把 release、hot 资源或插件资源发布到 `backup-bot/backup`。
+- 当前 Git 认证远端为 `https://up.tokendun.cc/backup-bot/backup.git`，仅代表上传身份；发布 API 的 owner/repo 必须使用 `mhgmh/codex-market-app`。
+- 热更 manifest 的 `minAppVersion` 表示最低原生 Electron 壳版本，当前为 `1.5.0`，不能直接使用 `hotContentVersion`。
+- 发布热更后必须从 `https://update.tokendun.cc/api/v1/repos/mhgmh/codex-market-app/releases/tags/hot` 验证 manifest、bundle 和 SHA256。

C:\Users\mac\.claude\projects\C--Users-mac-Documents------ProjectDown-codex-market-app\memory\MEMORY.md

@@ -0,0 +1,8 @@
+- [router 双平台配置兼容](router-dual-platform-config.md) — Mac(无tokens/custom直连) 与 Windows(登录态/新格式) 的切回逻辑约束，改 router.js 必读
+- [router 双激活槽](router-dual-active-slots.md) — activeId(OpenAI族)+activeClaudeId(Anthropic族) 双槽按协议派发，Codex/GPT 与 Claude Code 可同时激活，改 router 激活/派发逻辑必读
+- [cocoloop 技能镜像](cocoloop-skills-mirror.md) — 10877 技能镜像仓库、技能商店改造、gitea 服务器约束(匿名401/raw截断)与安装架构
+- [创意画布功能](canvas-studio-feature.md) — Drawflow 画布/节点/中转分组/流式出图的架构、热更交付陷阱、CDP 验证手法，改画布或排查"改了没生效"必读
+- [发布流程](release-publish-flow.md) — 热更(publish:hot)+完整包(mac/win双平台)的版本号、token位置、产物与gitea上传目标、v1.5.5已安装列表中文化修复
+- [Codex CDP 注入](codex-cdp-inject.md) — 往Codex桌面版(网页DOM)注入UI的机制：CDP连接+renderer-inject+execCommand写回composer，做"注入Codex界面"类功能(如语音输入按钮)必读
+- [Claude 桌面 App 第三方推理配置](claude-desktop-3p-config.md) — 接入中转/切回官方登录：托管偏好域 com.anthropic.claudefordesktop、gateway 配置键、deploymentMode 开关、备份还原机制，做 claudedesk 必读
+- [Codex 切模型会话记录消失](codex-model-catalog-history-loss.md) — 真因是 config 的 model 不在模型目录→Codex以未知模型启动、侧栏历史还原失败(数据无损)，applyModelCatalog 漏登记的非对称 bug 与诊断/自愈修复，排查"切模型丢记录"必读

C:\Users\mac\.claude\projects\C--Users-mac-Documents------ProjectDown-codex-market-app\memory\codex-model-catalog-history-loss.md

@@ -0,0 +1,21 @@
+---
+name: codex-model-catalog-history-loss
+description: 「Codex切模型后会话记录消失」的真因——config指向的model不在模型目录→Codex以未知模型启动、侧栏历史还原失败。排查此类"记录丢失"必读
+metadata:
+  type: project
+---
+
+客户报「Codex 切模型后会话记录莫名丢失」。真因不是数据丢失，是**显示丢失**：`~/.codex/config.toml` 的根级 `model` 指向了一个**不在模型目录 `cc-switch-model-catalog.json` 里的 slug** → Codex 本体以未知模型启动，无法解析该模型 → 侧栏历史线程还原失败，看起来"会话没了"。rollout 文件、`state_*.sqlite`(threads)、`session_index.jsonl` 全部无损，切回一个目录内已有的模型（或把该 model 登记进目录）后重启 Codex 即恢复。
+
+**触发的代码 bug（electron/lib/router.js，已修）**：`applyModelCatalog(group)` 旧代码首行 `if (!group.contextWindow) return` + `if(!win) return`，即分组没填「上下文窗口」就跳过目录登记；而 `setConfigModel(model)` 却无条件把 `model=` 写进 config.toml → **非对称**：config 指向的模型没进目录。分组的 contextWindow 除 DeepSeek 外普遍为空，所以切到目录里没有的模型必现。
+
+**修复**：① `applyModelCatalog` 去掉 contextWindow 前置条件，只要有 model 就登记(visibility=list，窗口回退 输入→模板默认→128000)；② 新增 `ensureModelInCatalog()` 内嵌进 `setConfigModel`，写 config 前保证该 slug 在目录里 = 不变量「config 指向的 model 必在目录」，任何切换路径+历史残骸环境都自愈。③ **关键补强**：用户是在 Codex 本体的模型选择器里切模型的，那条路径**不经过本 App**，只登记单个 model 不够——切到别的同代模型（如 tokendun 有 gpt-5.6-luna/sol/terra 三个）又会丢。故新增 `syncCatalogFromProvider(group)`：拉分组 `/v1/models`（复用 `fetchModels`），把全部**文本**模型(排除 image/imagine/whisper/audio/tts/embed/rerank/review 等非对话模型，正则 NON_TEXT_MODEL_RE)一次性登记进目录。在 `applyDirectToCodex` / `applyToCodex`(fire-and-forget) 及 **main.js 应用启动时**(`router.llmGroup()` 取当前激活分组) 各触发一次 → 既有安装无需重存分组即自动修复。
+
+**已发布**：热更 v1.5.20（mandatory=true, min 1.5.0）已上 gitea hot 通道。升级后**仍需用户手动重启 Codex 本体**（App 修好目录，Codex 下次启动才读）。发布见 [[release-publish-flow]]。
+
+**诊断手法（会话本文不用读，只看分布）**：
+- `sqlite3 state_*.sqlite "SELECT model_provider,model,COUNT(*) FROM threads GROUP BY 1,2"` → 全 null/同值说明侧栏不是按 model/provider 过滤，排除 provider-sync 方向。
+- node 读 catalog 打印各 `slug|visibility|context_window`，比对 config.toml 的 `model=` 是否在其中 —— 不在即命中本 bug。
+- `session_index.jsonl.bak-*` 若有多份，是用户反复跑 provider-sync 抢救历史的痕迹。
+
+单机即时抢救：把 config 当前 model 用模板克隆登记进 catalog(写 .bak-fix 备份)，重启 Codex 即回。相关：[[router-dual-platform-config]] [[router-dual-active-slots]] [[release-publish-flow]]。

CANVAS_SPEC.md

@@ -0,0 +1,154 @@
+# 创意画布（Canvas Studio）集成契约 —— 冻结版
+
+主控已勘定的集成事实，技术员必须严格遵守。目标：在插件市场旁新增「创意画布」，
+Drawflow 卡片式节点画布，第一版跑通 **文生图 → 图生视频 → TTS配音** 链路，
+全部走 tokendun 中转，**key 只在主进程**。
+
+## 已知事实（不要重复调研）
+- Electron 应用，**纯原生 JS，无 React/Vue，无构建步骤**：`renderer/index.html` 直接 `<script src="app.js">`。
+- CSP（index.html 第 7 行）：`default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self'; img-src 'self' data:;`
+  - 远程 http 图片/视频 URL 在渲染层**会被拦截** → 所有生成结果必须由**主进程下载并转 base64 data URL** 返回。
+- 渲染层桥接对象：`window.api`（app.js 里别名 `apic`）。所有后端调用走 IPC。
+- Tab 机制：`activatePanel(name)` 显示 `#tab-${name}`，激活 `.tab[data-tab=name]`。
+- 中转分组已由 `electron/lib/router.js` 管理并**已导出** `llmGroup()`：
+  返回当前可用中转分组 `{ id, name, baseUrl, key, model, ... }`（无可用则 `null`）。
+  执行层**直接复用它**，不要新增中转配置。
+- 设计变量在 `renderer/styles.css :root`：`--grad --accent --bg --card --card-2 --border --text --muted --ok --danger --radius --shadow`，含明/暗色。节点样式必须复用这些变量。
+
+## 冻结的 Preload 契约（前后端都按这个来）
+后端在 `electron/preload.js` 的 `window.api` 中新增：
+
+```js
+canvasStatus: () => ipcRenderer.invoke("canvas-status"),
+// → { ready: boolean, provider: { name, model, host } | null, reason?: string }
+
+canvasRun: (kind, params) => ipcRenderer.invoke("canvas-run", { kind, params }),
+// kind ∈ "image" | "video" | "tts"
+// → { ok: true, mime, dataUrl, meta } | { ok: false, error }
+```
+
+### canvasRun 各 kind 的 params 与端点（OpenAI 兼容）
+- `image`：`{ prompt, size?, model? }`
+  → `POST {base}/v1/images/generations`，body `{ model, prompt, size, response_format:"b64_json" }`
+  → 兼容 `data[0].b64_json` 或 `data[0].url`（url 则主进程再 fetch 下载）。返回 `image/png` data URL。
+- `tts`：`{ text, voice?, model?, format? }`
+  → `POST {base}/v1/audio/speech`，body `{ model, input:text, voice:voice||"alloy", response_format:format||"mp3" }`
+  → 响应是二进制音频 → 转 `audio/mpeg` data URL。
+- `video`：`{ prompt, image?, model?, endpointPath?, extra? }`
+  → 视频接口各中转不统一。默认尝试 `POST {base}{endpointPath||"/v1/videos"}`，
+    body `{ model, prompt, image, ...extra }`；若返回任务 id 则轮询（best-effort）。
+    **拿不到就返回 `{ ok:false, error }` 并说明「该中转视频接口待适配」，不要伪造成功。**
+    此节点标注为「实验/可配置」。
+
+`meta` 建议含 `{ model, ms, host }` 便于前端展示。
+
+## 【v2 增补 · 完善配置能力】——本轮必须实现
+用户反馈：图像/视频**不能只用聊天模型**（会 404），必须能自填「模型 + 接口地址」，且尺寸/比例/视频模式要齐全。
+
+### canvasRun 参数扩展（后端）
+- **image** `{ prompt, model, size, endpointPath?, extra?, image?, refField? }`
+  - `model`：**用户填写的图像模型**（如 `gpt-image-1`/`dall-e-3`/`flux-pro`/`seedream-3` 等）。**为空则直接返回 `{ok:false,error:"请先填写图像模型"}`，不要回退聊天模型。**
+  - `size`：`"WxH"`（前端按 比例×清晰度 算好传来）。
+  - `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 / 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。
+  - 不发送旧版 `input_mode`、`metadata`、`resolution`、`generate_audio`、`watermark`、`camera_fixed`、`seed`、`reference_video` 字段。
+  - 创建响应任务 ID 兼容 `request_id/requestId/task_id/taskId/id`，并递归检查 `data/result/task`；字符串和数字 ID 都支持。
+  - **grokVideo** `{ mode, prompt, model, image?, referenceImages?[], resolution?, seconds?, aspectRatio?, endpointPath? }` —— **Grok 视频**。与 Seedance 节点一样通过 CLMM 提交，使用 `{ model, prompt, aspect_ratio, resolution, size, seconds, mySeconds?, reference_image_urls }`；上传/上游传来的 dataURL 会先转公网 URL。模型名必须使用模型列表返回的完整名称，不再发送 Grok 专用的 `image:{url}` 或 `reference_images:[{url}]` 字段。
+- **tts** 增加 `model`（默认 `tts-1` 可保留但允许覆盖）、`format`、可选 `speed`。
+
+### 新增 canvasModels（后端 + preload）
+- preload：`canvasModels: () => ipcRenderer.invoke("canvas-models")`
+- 主进程：调 `router.fetchModels(llm.baseUrl, llm.key)` 返回 `{ ok, models:[...] }`（无可用分组或失败返回 `{ok:false,error}`）。供前端填充「模型」下拉/datalist。
+
+### 前端节点表单要求（每个能力节点都要能配置）
+- **文生图节点**：提示词 + **模型输入框(带 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/2K/4K) + 时长(可选 4s/6s/8s) + 高级(接口地址) + 运行 + 预览/报错。2K/4K 仅透传给中转，是否可用取决于所选 Seedance 模型；官方常规模型通常最高 1080p。图生视频模式吃上游图，文生视频不需要。
+- **TTS 节点**：文本 + 模型输入框 + 音色 + 格式(mp3/wav/opus) + 运行 + 预览。
+- 「拉取模型」按钮：调 `apic.canvasModels()`，把返回的 models 灌进所有模型输入框的 `<datalist>`；失败给 toast。
+- 预置示例(cvSeedSample)里，模型字段留空并加占位提示（如「填入你中转的图像模型，如 flux-pro」），避免又用聊天模型 404。
+所有 base 用 `router.llmGroup()` 的 `baseUrl`（去尾斜杠），鉴权 `Authorization: Bearer <key>`，
+`User-Agent: "codex-market"`（与 router.fetchModels 一致）。用 Electron 内置全局 `fetch`。
+
+## 文件归属（不得越界，避免冲突）
+- 后端技术员：`electron/lib/canvas.js`（新建）、`electron/main.js`（加 require + 两个 ipc handler）、`electron/preload.js`（加两个方法）。
+- 前端技术员：`renderer/index.html`、`renderer/app.js`、`renderer/styles.css`、`renderer/vendor/`（新建，放 drawflow）。
+  仅前端可改 index.html 的 CSP：新增 `media-src 'self' data: blob:;`（供音视频 data URL 播放），其余不动。
+
+## 第一版节点集
+1. 文本/提示词（输入源）
+2. 文生图（image）——出图，输出可连到下游
+3. 图生视频（video，实验）——吃上游图 + 提示词
+4. TTS 配音（tts）——吃文本，出音频
+每个节点自带「运行」按钮、内联结果预览、loading/错误态。节点间用 Drawflow 连线传递输出。
+无可用中转分组时（canvasStatus.ready=false）：画布置灰 + 提示「请先在『路由中转』配置并激活一个中转分组」。
+
+## 【v3 增补 · 按节点选择中转分组】——本轮必须实现
+用户希望：在「路由中转」建好多个分组（如"画图中转""视频中转"），打开画布时**自动加载全部分组**，每个能力节点用一个「分组」下拉自选走哪条中转渠道。设计：**分组=选哪条中转渠道(baseUrl+key)，模型框=选该渠道上的具体模型。**
+
+### router.js（主控已加，勿动）
+已新增只读接口：`groupById(id)`（返回含解密 key 的分组或 null）、`usableGroups()`（非默认且配齐 baseUrl+key 的分组数组）。
+
+### 后端（canvas.js / main.js / preload.js）
+- 新增 `groups()`：基于 `router.usableGroups()` 返回 `{ ok:true, activeId, groups:[{id,name,model,host}] }`（host 由 baseUrl 解析；activeId 来自 router.status().activeId 或 llmGroup 的 id）。无可用分组 `{ok:false,error}`。
+- `run({kind,params})`：若 `params.groupId` 非空 → 用 `router.groupById(groupId)` 解析渠道(baseUrl+key)；否则回退 `router.llmGroup()`。解析到的分组缺 baseUrl/key → 返回明确错误。其余逻辑(模型必填、端点、body 组装)不变。
+- `listModels(groupId)`：接受可选 groupId，有则用该分组的 baseUrl+key，否则 llmGroup。
+- main.js：`ipcMain.handle("canvas-groups", () => canvas.groups());`；把 canvas-models 改为 `(_e,{groupId}) => canvas.listModels(groupId)`。
+- preload.js：`canvasGroups: () => ipcRenderer.invoke("canvas-groups")`；`canvasModels: (groupId) => ipcRenderer.invoke("canvas-models",{groupId})`。
+
+### 前端（renderer/*）
+- 进入画布时调 `apic.canvasGroups()`，缓存分组列表。给**文生图/视频/TTS 每个节点**加一个「分组」下拉 `.cv-field-group`（option value=分组id，文案=`名称 · host`），默认选中 activeId。
+- 节点运行时 params 带上 `groupId=选中的分组id`。
+- 「拉取模型」改为**每节点一个「拉取」小按钮**（放模型框旁），调 `apic.canvasModels(该节点选中的groupId)`，填充该节点自己的 `<datalist id="cv-models-{nodeId}">`；模型框 `list` 指向它。（工具条原全局「拉取模型」可保留为拉取默认分组填充所有，或移除，二选一，别报错即可。）
+- 选择分组后若模型框为空，可用该分组的 model 预填（来自 canvasGroups 数据）。
+- 新增节点(cvAddNode)与预置示例(cvSeedSample)都要带分组下拉并默认选中 activeId；画布首次进入若分组数据未就绪，加载后要回填已存在节点的下拉。
+- 无可用分组时：节点内提示「请先在『路由中转』添加中转分组」。
+
+## 【v4 增补 · 流式图片生成 + 渐进预览】——本轮必须实现
+用户要求图片流式生成（gpt-image 支持 partial image 流式；且 gpt-image 不接受 response_format）。
+
+### 后端（canvas.js / main.js / preload.js）
+- **image 改为 stream-first**：POST `{base}{endpointPath||"/v1/images/generations"}`，body `{ model, prompt, size, n:1, stream:true, partial_images:2, ...extra }`。**不要再发 `response_format`**（gpt-image 会报错；dall-e 系无 stream 时走回退分支即可）。
+  - 用 Electron 全局 fetch，读 `res.body`（web ReadableStream，`for await (const chunk of res.body)` 可迭代）；`TextDecoder` 累积、按行切、解析 `data: {...}`（跳过 `data: [DONE]`）。
+  - 事件里凡带 `b64_json` 的都取出：`type` 含 `partial` → 渐进帧，回调 `onPartial(dataUrl)`；`type` 含 `completed` 或流结束时的最后一帧 → 最终图。返回最终 `{ok:true, mime:"image/png", dataUrl, meta}`。
+  - **回退**：若响应不是 SSE（Content-Type 非 text/event-stream 或首包不是 data:），或 stream 请求返回非 2xx → 退回原「非流式」POST（body 去掉 stream/partial_images，gpt-image 不加 response_format，其它模型可加 b64_json）解析 `data[0].b64_json|url`。错误信息仍带 URL+model。
+- **run 签名**：`run({ kind, params }, onPartial)` — 多接一个可选回调；仅 image 流式用到。
+- **main.js**：`canvas-run` handler 改为
+  `ipcMain.handle("canvas-run", (e, { kind, params }) => canvas.run({ kind, params }, (dataUrl) => { try { e.sender.send("canvas-progress", { runId: params && params.runId, kind, dataUrl }); } catch {} }));`
+- **preload.js**：新增
+  `onCanvasProgress: (cb) => { const h = (_e, p) => cb(p); ipcRenderer.on("canvas-progress", h); return () => ipcRenderer.removeListener("canvas-progress", h); },`
+
+### 前端（renderer/*）
+- 运行前生成 `runId`（如 `nodeId + "-" + (++CANVAS.runSeq)`，Date.now 亦可），塞进 `params.runId`，并把 `nodeId` 与 `runId` 映射记下。
+- 启动时订阅一次 `apic.onCanvasProgress(({runId, dataUrl}) => 用映射找到对应节点预览，把 <img> 的 src 换成 dataUrl)`，实现**边生成边刷新预览**（partial 帧陆续替换）。
+- 最终 `canvasRun` resolve 的成品仍照常渲染覆盖；skeleton 在收到第一帧 partial 后即可替换为图片。
+- 仅 image 节点用到渐进预览；video/tts 不变。
+
+## 【v5 增补 · 接入 TokenDun/Seedance 真实视频接口】
+Seedance 和 Grok 节点都使用 CLMM 异步任务制：建任务→轮询→下载。以下内容按 `/v1/videos` 文档更新，覆盖早期 Seedance/Grok 专有参数版本。
+
+### 后端 runVideo 重写（canvas.js）——统一使用 CLMM /v1/videos 逻辑
+- 端点：create = `joinUrl(base, endpointPath||"/v1/videos")`；poll = `create + "/" + taskId`（GET）。鉴权 `Bearer <key>`（分组由 groupId 解析，同 v3）。
+- **body 组装**（严格照 CLMM）：
+  - 基础字段 `{ model, prompt, aspect_ratio, resolution, size, seconds, reference_image_urls:[] }`。
+  - 模型包含 `-Ns` 时发送 `seconds:"1"` 和 `mySeconds`；包含 `-gz` 时 `mySeconds` 固定为模型声明的 N 秒。
+  - 文生视频发送空的 `reference_image_urls`；首帧、首尾帧、多参考图都统一发送公网 URL 数组。
+  - 图片必须是公网 URL；本地 data URL 先经 `uploadMedia()` 转成公网地址。
+- **建任务**：POST create。2xx 才继续；非 2xx 返回状态、实际 URL、model 和上游详情。响应先读取 text 再解析 JSON，确保非 JSON 错误不会丢失原文。任务 ID 由通用 `pickTaskId()` 提取。
+- **轮询**：GET poll，每 5s 一次，最多约 10 分钟（120 次）。用 `normalizeVideoStatus`；succeeded → `findVideoUrl`（深挖 `video_url/result_url/url`）→ 下载转 base64 → `{ok:true,mime:"video/mp4",dataUrl,meta}`；failed/超时 → 明确错误。仍严禁伪造成功。
+- port 两个纯函数 `normalizeVideoStatus`、`findVideoUrl` 到 canvas.js。全程 try/catch。
+
+### 前端视频节点（renderer/*）
+- 模式：首帧图、双图参考、多参考图/全能参考、文生视频。
+- `prompt` 在所有模式必填；模型可留空使用上游默认，也可通过分组拉取当前可用模型。
+- 比例：16:9 / 9:16 / 1:1 / 4:3；画质：自动 / `hd`；时长：自动 / 5s / 10s / 15s。
+- 高级：接口地址（默认 `/v1/videos`）。多参考图统一使用 CLMM 字段 `reference_image_urls`。
+- 不展示旧接口已不支持的分辨率、音频、水印、固定镜头、seed、参考视频控件。
+- 运行 params：`{ mode, prompt, model?, ratio, quality, seconds, referenceField, image?, lastFrameImage?, referenceImages?, endpointPath?, groupId }`。

CONTRACT.md

@@ -0,0 +1,103 @@
+# Codex 插件市场客户端 —— 开发契约（唯一事实来源）
+
+Electron + Node。三名开发者按本文件分工，**接口/数据结构/文件归属必须严格遵守**，避免联调对不上。
+
+## 分工与文件归属（互不重叠）
+- **负责人（已完成）**：`package.json`、`electron/preload.js`、本契约、`build/` 图标。
+- **开发 A（Node 后端逻辑）**：`electron/main.js` + `electron/lib/*.js`。
+- **开发 B（前端 UI）**：`renderer/index.html`、`renderer/styles.css`、`renderer/app.js`。
+- **开发 C（打包/跨平台）**：`electron-builder.yml`、`README.md`、`scripts/`（如需）。
+
+> 任何人不得修改不属于自己的文件。preload.js 是契约边界，已冻结。
+
+## 常量（写死在 electron/main.js 或 lib，前端不可见）
+```
+MARKET_URL = "https://sc.tokendun.cc"
+MARKET_KEY = "2e8e96d10ea0c223cc5cc6439df00a97bb4543ca58a1e5be"
+```
+市场地址与密钥**绝不能出现在 renderer 前端代码里**，只能在主进程。
+
+## 数据结构
+```ts
+// 本机/仓库里的一个可备份/可还原项
+type Item = {
+  category: "插件 Plugin" | "技能 Skill",
+  source: string,   // 如 openai-primary-runtime；技能为 "skills"
+  name: string,
+  rel: string,      // 相对 ~/.codex，如 plugins/cache/openai-primary-runtime/presentations
+  size: number      // 字节
+}
+
+// 市场条目
+type Entry = {
+  id?: number, name: string, source: string, category: string,
+  rel: string, repo: string, branch: string,
+  web_url: string | null, size: number,
+  description: string | null, published_at?: string
+}
+```
+
+## 前端可调用的 API（preload 已暴露为 window.api）
+全部返回 Promise。出错时 reject（前端用 try/catch 显示错误）。
+
+| 方法 | 入参 | 返回 | 说明 |
+|---|---|---|---|
+| `api.scanLocal()` | — | `Item[]` | 扫描本机 ~/.codex 的插件+技能 |
+| `api.pickDir()` | — | `string \| null` | 弹系统选目录框 |
+| `api.packLocal(rels, destDir)` | `string[], string` | `{path:string}` | 打包选中项到本地目录 |
+| `api.upload(rels, repo, token, isPrivate)` | `string[],string,string,boolean` | `{owner:string, published:number}` | 打包→推 GitHub→自动发布市场 |
+| `api.marketList()` | — | `Entry[]` | 拉官方市场列表 |
+| `api.marketInstall(entry)` | `Entry` | `{ok:true}` | 从市场下载并装进 ~/.codex+启用 |
+| `api.ghPull(repoInput, token)` | `string,string` | `Item[]` | clone 指定仓库并列出可还原项 |
+| `api.ghRestore(rels, enable)` | `string[],boolean` | `{ok:true}` | 把上次 pull 的选中项还原到 ~/.codex |
+| `api.getSecret(name)` | `"github"\|"registry"` | `string` | 取已存密钥（无则空串） |
+| `api.setSecret(name, value)` | `string,string` | `{ok:true}` | 存密钥（safeStorage 加密） |
+| `api.openExternal(url)` | `string` | — | 系统浏览器打开链接 |
+| `api.onLog(cb)` | `(msg:string)=>void` | — | 订阅主进程日志流（安装/上传进度） |
+
+## IPC 通道名（开发 A 在 main.js 用 ipcMain.handle 实现；开发 B 不直接用，只用 window.api）
+`scan-local` `pick-dir` `pack-local` `upload` `market-list` `market-install`
+`gh-pull` `gh-restore` `get-secret` `set-secret` `open-external`
+日志：主进程 `webContents.send("log", msg)` → preload 转成 `api.onLog`。
+
+## 关键逻辑要点（开发 A 必读，从现有 Python 版移植）
+1. **扫描**：`~/.codex/plugins/cache/<source>/<plugin>/` 每个是插件；`~/.codex/skills/<skill>/` 每个是技能。跳过 `.` 开头目录。size 递归求和。
+2. **打包排除**：拷贝时跳过隐私文件 `auth.json`、`config.toml`、`history.jsonl`、`*.sqlite*`、`*.log`、`*.bak`、`.DS_Store`、`installation_id`。
+3. **打包产物**：staging 内保持相对结构；额外生成 `.gitignore`、`restore.sh`、`README.md`、`enabled-plugins.toml`（记录选中插件在本机 config.toml 里的启用状态）。
+4. **上传**：用 isomorphic-git。先 `GET https://api.github.com/user`（Bearer token）拿 owner，并读响应头 `x-oauth-scopes` 校验含 `repo`/`public_repo`（缺失给明确错误：让用户用 classic token 勾 repo）；`POST /user/repos` 建仓（422=已存在则忽略，403/404 继续尝试 push）；git init/add/commit/push（force）。push 认证 `onAuth: () => ({ username: token })`。
+5. **发布市场**：上传成功后，对选中的**插件**项（技能无 config 登记）构造 Entry：`repo=owner/reponame, branch=main, web_url=https://github.com/owner/repo/tree/main/<rel>`，`POST {MARKET_URL}/api/plugins`，头 `X-API-Key: MARKET_KEY`，体 `{plugins:[...]}`。
+6. **克隆/安装**：isomorphic-git clone（私有仓库 onAuth 用 token）到临时目录 → 扫描 → 按 `entry.rel` 精确匹配 → 拷进 `~/.codex/<rel>` → 若是插件则在 `config.toml` 追加 `[plugins."name@source"]\nenabled = true`（已存在则不重复；改动前备份 config.toml）。
+7. **仓库地址解析**：接受 `owner/repo`、`https://github.com/owner/repo(.git)`。
+8. **密钥存储**：`safeStorage.encryptString` 加密后写入 `app.getPath("userData")/secrets.json`；读时解密。name 取 `github` / `registry`。
+9. **市场 API_KEY**：安装（读）不需要 key；仅发布需要，用写死的 MARKET_KEY。
+
+## 会话记忆（新增模块：electron/lib/memory.js）
+自动把 Codex 会话浓缩成交接摘要：监视 `~/.codex/sessions`，会话静默 idleMinutes 后摘要
+（优先走路由中转可用分组的 LLM，失败退化本地提取）→ 存 `userData/memory.db`（sql.js）
+→ 写项目根目录 `HANDOFF.md` + 在 `AGENTS.md` 加带标记的引导段（`<!-- codex-memory:start/end -->`）。
+配置在 `userData/memory.json`（enabled / disabledProjects / idleMinutes / backfillDays / handoffSessions）。
+
+前端 API（preload 已暴露）：
+| 方法 | 入参 | 返回 | 说明 |
+|---|---|---|---|
+| `api.memoryStatus()` | — | `{enabled, engine, total, pending, idleMinutes, projects[]}` | 状态 + 项目列表 |
+| `api.memoryList(opts)` | `{project?, q?, limit?}` | 摘要行数组 | 检索记忆库 |
+| `api.memorySetEnabled(b)` | `boolean` | status | 总开关 |
+| `api.memoryToggleProject(cwd, b)` | `string, boolean` | status | 项目级写入开关 |
+| `api.memoryResummarize(path)` | rollout 路径 | `{ok}` | 手动重摘要一条 |
+| `api.memoryDelete(id)` | 会话 id | `{ok}` | 删一条摘要 |
+| `api.memoryOpenHandoff(cwd)` | 项目路径 | — | Finder 中显示 HANDOFF.md |
+| `api.onMemoryChanged(cb)` | 回调 | 取消函数 | 摘要更新推送 |
+
+IPC 通道：`memory-status` `memory-list` `memory-set-enabled` `memory-toggle-project`
+`memory-resummarize` `memory-delete` `memory-open-handoff`；事件 `memory-changed`。
+router.js 新增导出 `llmGroup()`（供内部功能取可调用的中转分组）。
+
+## UI 设计方向（开发 B）
+- 现代、精致、可直接对外发布的观感；深色为主、支持浅色；圆角卡片、柔和阴影、清晰层级。
+- 主色建议靛蓝→紫渐变（与图标一致 #5B6CFF→#A855F7），强调按钮用该渐变。
+- 两大区域：**① 插件市场**（卡片列表 + 搜索框 + 分类筛选 + 每卡「安装」按钮 + 安装态/进度）；**② 备份与还原**（子区：从本机导出上传 / 从 GitHub 拉取还原）。可用侧边栏或顶部标签切换。
+- 顶部品牌区（logo + 名称「Codex 插件市场」）。底部或抽屉式「运行日志」。
+- 无外部 CDN（离线可用），字体用系统字体栈。图标可用内联 SVG。
+- 所有后端调用走 `window.api.*`；**不得**在前端出现市场地址或密钥。
+- 空状态、加载中、错误提示都要有像样的样式。

HANDOFF.md

@@ -0,0 +1,41 @@
+<!-- 本文件由「Codex 插件市场 · 会话记忆」自动生成与覆盖，请勿手动编辑 -->
+# HANDOFF —— 会话交接快照（补充细节）
+
+> 核心记忆已写进本项目 `AGENTS.md`（Codex 每次会话自动读）。本文件是更详细的近期快照，供需要时参考；关键信息不依赖本文件。
+
+## 最近会话 · 2026-08-15 23:02 · 你好
+
+首条需求：你好
+
+## 更早会话 · 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 · 简单问候
+
+用户仅进行了两次问候，尚未提出具体项目需求或技术任务。
+
+**下一步**：
+- 等待用户提供具体需求
+
+## 更早会话 · 2026-08-14 06:14 · 修复长会话执行与工具调用问题
+
+已修复 DeepSeek/Kimi Chat 模式下工具调用参数转换、工具保留及长会话压缩配置问题，避免会话过长后只回复一句而不执行。DeepSeek 默认窗口 64K、Kimi 128K，压缩阈值为 80%，相关测试已全部通过（32/32）。token 统计位置和顶部全局代理入口尚未确认完成。
+
+**已确定的决策**：
+- 保留标准 function 工具及完整参数 schema
+- 多模态模式仅移除 view_image 工具
+- DeepSeek 默认窗口设为 64K
+- Kimi 默认窗口设为 128K
+- 模型目录压缩阈值设为 80%
+
+**下一步**：
+- 定位并修复 token 统计进度条位置
+- 移除顶部全局代理模式入口
+- 回归验证 DeepSeek/Kimi 长会话执行
+- 确认 npm test 及界面功能均正常
+
+**涉及文件**：electron/lib/translate.js、electron/lib/router.js

README.md

@@ -1,13 +1,82 @@
-# tokendun插件市场
+# Codex 插件市场 —— 桌面客户端
 
-跨平台桌面客户端：AI Agent 技能商店（cocoloop 镜像）、备份还原、路由中转、全局代理、会话记忆。
+跨平台（macOS / Windows / Linux）的 Codex 插件 · 技能 **备份 / 分享 / 一键安装** 工具。
+基于 Electron，全部逻辑本地运行；凭证只存在本机（系统安全存储加密）。
 
-## 下载
+## 功能
+- **插件市场**：浏览官方市场，搜索 / 筛选，一键安装到 `~/.codex` 并自动启用。
+- **从本机导出 / 上传**：扫描本机插件与技能，勾选后导出到本地目录，或打包推送到 GitHub 并自动登记到市场。**凭证文件（auth.json / config.toml / history 等）已自动排除。**
+- **从 GitHub 拉取还原**：输入任意仓库，拉取后勾选还原到本机，可选自动在 `config.toml` 启用。
+- **设置**：保存默认 GitHub Token（`safeStorage` 加密存储）。
+- **会话记忆**：软件开着就自动工作——监视 `~/.codex/sessions`，每次会话告一段落（静默几分钟）后自动浓缩成「交接摘要」：
+  存入本机 SQLite 记忆库（可检索），并写到对应项目根目录的 `HANDOFF.md`（状态快照），同时在项目 `AGENTS.md` 里加一段
+  「先读 HANDOFF」引导。之后**新开 Codex 会话说「继续」，就能接上之前聊的**，不用带着超长上下文。
+  摘要优先调用「路由中转」当前分组的 LLM，未配置或失败时退化为本地规则提取；可全局或按项目关闭。
 
-前往 [Releases](https://update.tokendun.cc/mhgmh/codex-market-app/releases) 下载最新版：
+## 开发运行
+```bash
+npm install
+npm start
+```
 
-- **macOS（Apple 芯片）**：`CodexMarket-<版本>-arm64.dmg`
+## 打包分发
-- **macOS（Intel）**：`CodexMarket-<版本>-x64.dmg`
+```bash
-- **Windows**：`CodexMarket-<版本>-Setup.exe`
+# 当前平台
+npm run dist
 
-软件内「设置 → 检查更新」会从本仓库 Releases 检测新版本（国内可达）。
+# 指定平台（需对应系统或已配置交叉编译）
+npm run dist:mac    # 产出 dist/*.dmg（x64 + arm64）
+npm run dist:win    # 产出 dist/*Setup.exe
+```
+产物在 `dist/`。打包配置见 `electron-builder.yml`，图标在 `build/`（icns/ico/png）。
+
+## macOS 首次打开报「已损坏，移到废纸篓」
+
+**这不是包坏了。** 本应用未购买 Apple 开发者证书、未做公证(notarization)，
+只有临时(ad-hoc)签名。macOS 对「从网上下载」的这类 app 会自动加隔离标记
+(`com.apple.quarantine`) 并由 Gatekeeper 拦截，在 Apple 芯片上表现为「已损坏」。
+
+**解决**：把 app 拖到「应用程序」后，双击 DMG 里的 `fix-quarantine.command`，或在「终端」执行一次（去掉隔离标记）：
+
+```bash
+xattr -cr "/Applications/TD工具箱.app"
+```
+
+之后正常双击即可打开，只需做一次。（若提示权限不足，命令前加 `sudo ` 再回车输入开机密码。）
+
+DMG 里同时放了 `激活教程.txt`，客户可以先看这个文件再操作。
+
+> 想彻底免掉这一步、让用户双击即开，需要 Apple Developer 账号($99/年)做
+> Developer ID 签名 + 公证，届时在 `electron-builder.yml` 的 `mac` 段配置证书即可。
+
+## GitHub Token 说明
+上传功能需要 **classic** personal access token，并勾选最上面的 **repo** 复选框：
+<https://github.com/settings/tokens>
+
+- 传**公开**仓库：`public_repo` 权限即可。
+- 传**私有**仓库：需要完整 `repo` 权限。
+- fine-grained token 目前不受支持（推送会失败），请用 classic token。
+
+安装公开仓库的插件无需任何 token；安装私有仓库需在「设置」里保存 token。
+
+## 项目结构
+```
+electron/
+  main.js        主进程：窗口 + IPC + GitHub(isomorphic-git) + 市场 API
+  preload.js     契约边界，暴露 window.api（冻结）
+  lib/
+    codex.js     扫描 / 打包 / 还原 / config.toml 启用
+    secrets.js   safeStorage 密钥存储
+renderer/
+  index.html     UI 结构
+  styles.css     深色为主 · 靛蓝→紫渐变
+  app.js         前端逻辑（只经 window.api.*）
+build/           打包图标
+electron-builder.yml  打包配置
+CONTRACT.md      前后端 / 分工契约（唯一事实来源）
+```
+
+## 隐私
+- 市场地址与密钥只存在于主进程，不出现在前端代码。
+- 打包上传时严格排除：`auth.json`、`config.toml`、`history.jsonl`、`*.sqlite*`、`*.log`、`*.bak`、`.DS_Store`、`installation_id`。
+- 还原写入 `config.toml` 前会自动备份为 `config.toml.bak-exporter`。

build/activation-guide.txt

@@ -0,0 +1,18 @@
+TD工具箱 macOS 激活教程
+
+如果你第一次打开时被 macOS 拦截，请按下面步骤操作：
+
+1. 把「TD工具箱.app」拖到「Applications」。
+2. 双击本 DMG 里下方的「fix-quarantine.command」。
+3. 如果系统提示需要权限，输入当前 Mac 的登录密码。
+4. 重新打开「TD工具箱.app」。
+
+如果仍然提示「Apple 无法验证」：
+
+1. 先在终端里执行：
+   xattr -cr "/Applications/TD工具箱.app"
+2. 再手动打开应用。
+
+说明：
+- 这个包使用的是临时签名，不是 Apple Developer 正式证书。
+- 小范围内部使用通常够用；如果要长期稳定发给客户，建议改成 Developer ID + notarization。

build/fix-quarantine.command

@@ -0,0 +1,49 @@
+#!/bin/bash
+# 双击本文件即可修复 macOS「已损坏，移到废纸篓」——去掉隔离标记(quarantine)。
+# 只需运行一次。原理：本应用为免费分发、未做 Apple 公证，被系统加了隔离标记。
+
+APP_NAME="TD工具箱.app"
+
+echo "==================================================="
+echo "  修复 macOS「已损坏」提示 —— TD工具箱"
+echo "==================================================="
+echo
+
+# 依次在常见位置查找已安装的 app
+CANDIDATES=(
+  "/Applications/$APP_NAME"
+  "$HOME/Applications/$APP_NAME"
+  "$(cd "$(dirname "$0")" && pwd)/$APP_NAME"   # 脚本旁边(DMG 内)
+)
+
+TARGET=""
+for p in "${CANDIDATES[@]}"; do
+  if [ -d "$p" ]; then TARGET="$p"; break; fi
+done
+
+if [ -z "$TARGET" ]; then
+  echo "❌ 没找到「$APP_NAME」。"
+  echo "   请先把 app 拖到「应用程序」文件夹，再双击本脚本。"
+  echo
+  read -n 1 -s -r -p "按任意键关闭…"
+  exit 1
+fi
+
+echo "找到应用：$TARGET"
+echo "正在去除隔离标记…"
+
+if xattr -cr "$TARGET" 2>/dev/null; then
+  echo "✅ 完成！现在可以正常双击打开「$APP_NAME」了。"
+else
+  echo "普通权限失败，尝试用管理员权限（可能需要输入开机密码）…"
+  if sudo xattr -cr "$TARGET"; then
+    echo "✅ 完成！现在可以正常双击打开了。"
+  else
+    echo "❌ 仍失败。请手动在终端执行："
+    echo "   sudo xattr -cr \"$TARGET\""
+  fi
+fi
+
+echo
+read -n 1 -s -r -p "按任意键关闭…"
+echo

electron-builder.yml

@@ -0,0 +1,122 @@
+appId: cc.tokendun.codexmarket
+productName: TD工具箱
+copyright: Copyright © 2026 Tokendun
+
+directories:
+  output: dist
+  buildResources: build
+
+protocols:
+  - name: TD ToolBox Import
+    schemes:
+      - tdtoolbox
+
+# 无 Apple 证书时，electron-builder 会跳过签名、留下残缺封印；
+# 此钩子在打 DMG 前对 mac app 做完整 ad-hoc 重签名，修复封印。
+afterPack: scripts/afterPack.js
+
+# 只打包运行必需的文件（源码 + 运行时依赖）
+files:
+  - electron/**/*
+  - renderer/**/*
+  - build/icon.png
+  - build/icon.ico
+  - build/icon.icns
+  - package.json
+  - "!**/*.map"
+
+# isomorphic-git 是纯 JS，无需解包 asar；保持默认 asar 打包即可
+asar: true
+# sql.js 的 wasm 需从 asar 解出，保证运行时可读取
+asarUnpack:
+  - "node_modules/sql.js/**"
+
+mac:
+  # 内置 sing-box 引擎(全局代理用)——按架构只打对应的一份
+  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 账号 ——
+  # 不设 identity：electron-builder 在无证书环境自动做 ad-hoc 签名，
+  # 会对 app 及内置 sing-box 完整重新封印(seal)，保证用户去掉隔离标记后能稳定运行。
+  # 切勿设 identity: null——那会完全跳过签名、破坏 bundle 封印。
+  notarize: false
+  target:
+    - target: dmg
+      arch:
+        - x64
+        - arm64
+    # zip 供 Mac 自动更新使用（dmg 无法自动更新）
+    - target: zip
+      arch:
+        - x64
+        - arm64
+  # 纯英文文件名，保证自动更新下载可靠
+  artifactName: "CodexMarket-${version}-${arch}.${ext}"
+
+dmg:
+  title: "${productName}-${arch}"
+  # 加大窗口，容纳「修复已损坏」脚本
+  window:
+    width: 560
+    height: 500
+  contents:
+    # app 图标（左）
+    - x: 140
+      y: 170
+      type: file
+    # 「应用程序」快捷方式（右）
+    - x: 400
+      y: 170
+      type: link
+      path: /Applications
+    # 一键修复「已损坏」脚本（下方居中）——双击运行去除隔离标记
+    - x: 270
+      y: 320
+      type: file
+      path: build/fix-quarantine.command
+    # 激活教程（底部文本文件）
+    - x: 270
+      y: 410
+      type: file
+      path: build/activation-guide.txt
+      name: 激活教程.txt
+
+win:
+  # 内置 sing-box 引擎(全局代理用)
+  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
+      arch:
+        - x64
+  artifactName: "CodexMarket-${version}-Setup.${ext}"
+
+nsis:
+  oneClick: false
+  perMachine: false
+  allowToChangeInstallationDirectory: true
+  createDesktopShortcut: true
+  createStartMenuShortcut: true
+
+linux:
+  extraResources:
+    - from: "resources/multimodal-gateway.json"
+      to: "multimodal-gateway.json"
+  icon: build/icon.png
+  category: Development
+  target:
+    - AppImage
+
+# 在线更新：发布到 GitHub Releases（公开仓库，客户端免密钥拉取更新）
+publish:
+  provider: generic
+  url: https://up.tokendun.cc/mhgmh/codex-market-app/releases/download/latest

electron/bootstrap.js

@@ -0,0 +1,54 @@
+// bootstrap.js —— 应用入口（引导加载器）。零第三方依赖，只用 electron + node 内置。
+// 职责：
+//  1) 计算包内根 BUNDLE_ROOT 与有效根 APP_ROOT（可能是 userData/hot/<ver>）。
+//  2) 注入模块解析，使从热更目录加载的代码仍能 require 到【包内】node_modules。
+//  3) 健康门控选版本；try/catch 加载真正的 main.js，失败拉黑回退包内。
+//  本文件始终从包内运行（package.json main 指向它，不随热更），因此修改它需发完整包。
+"use strict";
+const path = require("path");
+const Module = require("module");
+const { app } = require("electron");
+
+const BUNDLE_ROOT = app.getAppPath();                 // 打包后 = .../Resources/app.asar；dev = 项目根
+const HOT_BASE = path.join(app.getPath("userData"), "hot");
+
+// —— 让热更目录里的代码能解析到包内第三方依赖（isomorphic-git / sql.js / electron-updater）——
+try {
+  const bundleNM = path.join(BUNDLE_ROOT, "node_modules");
+  process.env.NODE_PATH = bundleNM + (process.env.NODE_PATH ? path.delimiter + process.env.NODE_PATH : "");
+  Module._initPaths(); // 把 NODE_PATH 灌进 Module.globalPaths，作为裸模块 require 的兜底搜索路径
+} catch {}
+
+// —— 选择有效版本 ——
+let APP_ROOT = BUNDLE_ROOT;
+let chosenVer = null;
+if (app.isPackaged) {
+  try {
+    const hotstate = require("./lib/hotstate");
+    chosenVer = hotstate.chooseVersion(HOT_BASE); // 有副作用：pending 版本自增 attempts 并先落盘
+    if (chosenVer) APP_ROOT = path.join(HOT_BASE, chosenVer);
+  } catch {
+    APP_ROOT = BUNDLE_ROOT; // 热更状态读取失败 → 安全回退包内
+  }
+}
+
+global.__BUNDLE_ROOT__ = BUNDLE_ROOT;
+global.__APP_ROOT__ = APP_ROOT;
+global.__HOT_BASE__ = HOT_BASE;
+
+function loadMain(rootDir) {
+  return require(path.join(rootDir, "electron", "main.js"));
+}
+
+try {
+  loadMain(APP_ROOT);
+} catch (e) {
+  if (APP_ROOT !== BUNDLE_ROOT) {
+    // 该热更版本在 require 阶段就崩 → 拉黑 + 回退包内重载
+    try { require("./lib/hotstate").blacklistVersion(HOT_BASE, chosenVer, e && e.stack || e); } catch {}
+    global.__APP_ROOT__ = BUNDLE_ROOT;
+    loadMain(BUNDLE_ROOT);
+  } else {
+    throw e; // 包内都崩 = 真错误
+  }
+}

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 };

electron/lib/claudedesk.js

@@ -0,0 +1,259 @@
+// claudedesk.js —— 把中转分组接入 Claude 桌面 App（图形客户端），免登录直用中转。
+// 关键：走 App 自己的「已保存配置库」(configLibrary)，不是托管偏好(defaults/.mobileconfig)。
+//   托管偏好那条路是企业 MDM 通道，会强制 SSO 登录，个人账号卡登录页 —— 早期踩过坑，已弃用。
+// 做法对照 cc-switch 源码 src-tauri/src/claude_desktop_config.rs（farion1231/cc-switch）核实。
+// 详见 memory/claude-desktop-3p-config.md。
+"use strict";
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const router = require("./router");
+
+const PLATFORM = process.platform; // 'darwin' | 'win32' | ...
+const CONFIG_FILE = "claude_desktop_config.json";
+const CONFIG_LIBRARY_DIR = "configLibrary";
+const PROFILE_ID = "00000000-0000-4000-8000-000000157210";
+const PROFILE_NAME = "TokenDun";
+// 备份根：复用现有 ~/.codex/backups_state 约定
+const BACKUP_DIR = path.join(os.homedir(), ".codex", "backups_state", "claudedesk", "official");
+
+// —— 平台路径 ——
+// 返回 { normalConfig, threepConfig, libDir, profilePath, metaPath } 或 null（不支持）
+function platformPaths() {
+  if (PLATFORM === "darwin") {
+    const appSupport = path.join(os.homedir(), "Library", "Application Support");
+    return dirsToPaths(path.join(appSupport, "Claude"), path.join(appSupport, "Claude-3p"));
+  }
+  if (PLATFORM === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return dirsToPaths(pickWinDir(localAppData, "Claude"), pickWinDir(localAppData, "Claude-3p"));
+  }
+  return null;
+}
+// Windows 下 App 目录名可能带后缀，先精确后模糊匹配
+function pickWinDir(base, exact) {
+  const p = path.join(base, exact);
+  if (fs.existsSync(p)) return p;
+  try {
+    const hit = fs.readdirSync(base).find((n) => {
+      const full = path.join(base, n);
+      const isDir = (() => { try { return fs.statSync(full).isDirectory(); } catch { return false; } })();
+      if (!isDir) return false;
+      return exact === "Claude-3p" ? /claude.*3p/i.test(n) : (/claude/i.test(n) && !/3p/i.test(n));
+    });
+    if (hit) return path.join(base, hit);
+  } catch {}
+  return p;
+}
+function dirsToPaths(normalDir, threepDir) {
+  const libDir = path.join(threepDir, CONFIG_LIBRARY_DIR);
+  return {
+    normalConfig: path.join(normalDir, CONFIG_FILE),
+    threepConfig: path.join(threepDir, CONFIG_FILE),
+    libDir,
+    profilePath: path.join(libDir, `${PROFILE_ID}.json`),
+    metaPath: path.join(libDir, "_meta.json"),
+  };
+}
+
+// —— JSON 读写小工具 ——
+const readJson = (p) => { try { return JSON.parse(fs.readFileSync(p, "utf-8")); } catch { return null; } };
+const readJsonOrEmpty = (p) => { const v = readJson(p); return v && typeof v === "object" && !Array.isArray(v) ? v : {}; };
+function writeJson(p, obj) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2) + "\n");
+}
+const isSupported = () => PLATFORM === "darwin" || PLATFORM === "win32";
+
+// —— gateway profile 本体（写进 configLibrary/<id>.json）——
+function buildGatewayProfile(group) {
+  const oneM = new Set(Array.isArray(group.oneMillionModels) ? group.oneMillionModels : []);
+  const profile = {
+    coworkEgressAllowedHosts: ["*"],
+    disableDeploymentModeChooser: true,
+    inferenceGatewayApiKey: group.key || "",
+    inferenceGatewayAuthScheme: "bearer",
+    inferenceGatewayBaseUrl: String(group.baseUrl || "").replace(/\/+$/, ""),
+    inferenceProvider: "gateway",
+  };
+  if (group.model) {
+    const item = { id: group.model };
+    if (oneM.has(group.model)) item.supports1m = true; // 1M 长上下文标记（不是 beta 头）
+    profile.inferenceModels = [item];
+  }
+  return profile;
+}
+
+// —— deploymentMode 写入（就地改，不动其它字段，尤其保留官方账号绑定 preferences）——
+function writeDeploymentMode(p, mode) {
+  const v = readJsonOrEmpty(p);
+  v.deploymentMode = mode;
+  writeJson(p, v);
+}
+
+// —— _meta.json：登记/清除本 profile ——
+function writeMeta(metaPath, applied) {
+  const v = readJsonOrEmpty(metaPath);
+  let entries = Array.isArray(v.entries) ? v.entries : [];
+  entries = entries.filter((e) => !(e && e.id === PROFILE_ID)); // 去重
+  if (applied) {
+    entries.push({ id: PROFILE_ID, name: PROFILE_NAME });
+    v.appliedId = PROFILE_ID;
+  } else if (v.appliedId === PROFILE_ID) {
+    // 取消：若当前 applied 指向本 profile，切到剩余任一或清空
+    const next = entries.find((e) => e && e.id);
+    if (next) v.appliedId = next.id; else delete v.appliedId;
+  }
+  v.entries = entries;
+  writeJson(metaPath, v);
+}
+
+// ============================================================================
+//  备份 / 还原（防「回不去官方登录」）—— 幂等 write-once 快照那 4 个文件
+// ============================================================================
+const SNAP_FILES = (p) => [
+  ["normalConfig", p.normalConfig],
+  ["threepConfig", p.threepConfig],
+  ["profile", p.profilePath],
+  ["meta", p.metaPath],
+];
+
+function snapshotOfficial() {
+  fs.mkdirSync(BACKUP_DIR, { recursive: true });
+  const marker = path.join(BACKUP_DIR, "done.json");
+  if (fs.existsSync(marker)) return { firstTime: false, dir: BACKUP_DIR };
+  const p = platformPaths();
+  const meta = { ts: Date.now(), platform: PLATFORM, files: {} };
+  if (p) {
+    for (const [key, src] of SNAP_FILES(p)) {
+      const dst = path.join(BACKUP_DIR, key + ".json");
+      if (fs.existsSync(src)) {
+        try { fs.copyFileSync(src, dst); meta.files[key] = { existed: true }; try { fs.chmodSync(dst, 0o600); } catch {} }
+        catch { meta.files[key] = { existed: true, copyFailed: true }; }
+      } else {
+        meta.files[key] = { existed: false }; // 记录原本不存在 → 还原时删除
+      }
+    }
+  }
+  fs.writeFileSync(marker, JSON.stringify(meta, null, 2));
+  return { firstTime: true, dir: BACKUP_DIR };
+}
+
+// 还原官方：把中转配置抹掉，deploymentMode 回 1p，App 恢复官方账号登录。
+// 优先用首份快照精确复原；无快照则按规则清理（删 profile、meta 清 entry、config 回 1p）。
+function restoreOfficial() {
+  if (!isSupported()) return { ok: false, error: "当前系统不支持（仅 macOS / Windows）" };
+  const p = platformPaths();
+  if (!p) return { ok: false, error: "无法定位 Claude 桌面 App 配置目录" };
+  const marker = path.join(BACKUP_DIR, "done.json");
+  const meta = readJson(marker);
+
+  try {
+    if (meta && meta.files) {
+      // 精确复原：有备份写回，标记「原本不存在」的删掉
+      for (const [key, src] of SNAP_FILES(p)) {
+        const info = meta.files[key] || {};
+        const bak = path.join(BACKUP_DIR, key + ".json");
+        if (info.existed && fs.existsSync(bak)) {
+          fs.mkdirSync(path.dirname(src), { recursive: true });
+          fs.copyFileSync(bak, src);
+        } else if (!info.existed && fs.existsSync(src)) {
+          try { fs.unlinkSync(src); } catch {}
+        }
+      }
+    } else {
+      // 无备份：按规则清理回官方
+      writeDeploymentMode(p.normalConfig, "1p");
+      writeDeploymentMode(p.threepConfig, "1p");
+      if (fs.existsSync(p.profilePath)) { try { fs.unlinkSync(p.profilePath); } catch {} }
+      writeMeta(p.metaPath, null);
+    }
+  } catch (e) {
+    return { ok: false, error: "还原失败：" + (e.message || e) };
+  }
+  return { ok: true, message: "已还原 Claude 官方配置，请重启 Claude 桌面 App（会回到账号登录）" };
+}
+
+// ============================================================================
+//  一键接入（写 configLibrary，免登录）
+// ============================================================================
+function applyGroup(groupId) {
+  if (!isSupported()) return { ok: false, error: "当前系统暂不支持（仅 macOS / Windows）" };
+  const g = router.groupById(groupId);
+  if (!g) return { ok: false, error: "未找到该分组" };
+  if (g.isDefault) return { ok: false, error: "默认直连分组不能接入" };
+  if (!g.baseUrl || !g.key) return { ok: false, error: "该分组缺少 API 地址或密钥" };
+  if ((g.mode || "responses") !== "claude") {
+    return { ok: false, error: "Claude 桌面 App 只接受 Anthropic 协议（/v1/messages）分组，请把该分组的接口类型改成 Claude Code" };
+  }
+  const p = platformPaths();
+  if (!p) return { ok: false, error: "无法定位 Claude 桌面 App 配置目录（未安装？）" };
+
+  // 写前强制备份官方现状（幂等 write-once）
+  let backup;
+  try { backup = snapshotOfficial(); } catch (e) { return { ok: false, error: "备份官方配置失败：" + (e.message || e) }; }
+
+  // 失败回滚：先记住本次要写的 4 个文件的当前内容
+  const rollback = SNAP_FILES(p).map(([k, f]) => ({ f, content: fs.existsSync(f) ? fs.readFileSync(f) : null }));
+  try {
+    const profile = buildGatewayProfile(g);
+    writeDeploymentMode(p.normalConfig, "3p");
+    writeDeploymentMode(p.threepConfig, "3p");
+    writeJson(p.profilePath, profile);
+    writeMeta(p.metaPath, true);
+  } catch (e) {
+    // 回滚
+    for (const r of rollback) {
+      try { if (r.content === null) { if (fs.existsSync(r.f)) fs.unlinkSync(r.f); } else fs.writeFileSync(r.f, r.content); } catch {}
+    }
+    return { ok: false, error: "写入 Claude 桌面配置失败：" + (e.message || e) };
+  }
+  const has1m = Array.isArray(g.oneMillionModels) && g.model && g.oneMillionModels.includes(g.model);
+  return {
+    ok: true,
+    firstTimeBackup: backup.firstTime,
+    has1m: !!has1m,
+    message: "已接入 Claude 桌面 App，请重启 App 生效（无需登录，直接用中转）。官方配置已备份，可随时一键还原。",
+  };
+}
+
+// 导出 profile JSON（供高级用户手动放置 / 备份）
+function exportConfig(groupId, format) {
+  const g = router.groupById(groupId);
+  if (!g) return { ok: false, error: "未找到该分组" };
+  if (!g.baseUrl || !g.key) return { ok: false, error: "该分组缺少 API 地址或密钥" };
+  const profile = buildGatewayProfile(g);
+  const content = JSON.stringify(profile, null, 2) + "\n";
+  return { ok: true, content, filename: `${PROFILE_ID}.json`, ext: "json" };
+}
+
+// 复制片段（configLibrary profile 内容）
+function snippet(groupId) {
+  const r = exportConfig(groupId, "json");
+  return r.ok ? { ok: true, text: r.content } : r;
+}
+
+function status() {
+  const marker = path.join(BACKUP_DIR, "done.json");
+  const meta = readJson(marker);
+  const p = platformPaths();
+  let applied = false;
+  if (p) {
+    const cfg = readJson(p.threepConfig) || readJson(p.normalConfig);
+    const m = readJson(p.metaPath);
+    applied = !!(cfg && cfg.deploymentMode === "3p" && m && m.appliedId === PROFILE_ID);
+  }
+  return {
+    supported: isSupported(),
+    platform: PLATFORM,
+    hasBackup: !!meta,
+    backupTs: meta ? meta.ts : 0,
+    currentApplied: applied,
+  };
+}
+
+module.exports = {
+  status, applyGroup, restoreOfficial, exportConfig, snippet,
+  // 供测试
+  buildGatewayProfile, platformPaths, snapshotOfficial, PROFILE_ID,
+};

electron/lib/codex.js

@@ -0,0 +1,383 @@
+// codex.js —— 扫描 ~/.codex、打包（排除隐私文件 + 生成辅助文件）、还原、config.toml 启用
+// 忠实移植自 codex_exporter.py，纯 Node（fs / path / os）。
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const codexDataDir = require("./codex_data_dir");
+
+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",
+  "config.toml",
+  "history.jsonl",
+  ".DS_Store",
+  "installation_id",
+  ".codex-global-state.json",
+  ".codex-global-state.json.bak",
+]);
+const BLOCKLIST_SUFFIX = [".sqlite", ".sqlite-shm", ".sqlite-wal", ".log", ".bak"];
+
+function isBlocked(name) {
+  if (BLOCKLIST_NAMES.has(name)) return true;
+  return BLOCKLIST_SUFFIX.some((s) => name.endsWith(s));
+}
+
+function humanSize(num) {
+  const units = ["B", "K", "M", "G"];
+  let n = num;
+  for (const unit of units) {
+    if (n < 1024) {
+      return unit === "B" ? `${Math.round(n)}${unit}` : `${n.toFixed(1)}${unit}`;
+    }
+    n /= 1024;
+  }
+  return `${n.toFixed(1)}T`;
+}
+
+// 递归求目录大小
+function dirSize(dir) {
+  let total = 0;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (e) {
+    return 0;
+  }
+  for (const ent of entries) {
+    const full = path.join(dir, ent.name);
+    try {
+      if (ent.isDirectory()) {
+        total += dirSize(full);
+      } else if (ent.isFile()) {
+        total += fs.statSync(full).size;
+      }
+    } catch (e) {
+      /* 忽略无法访问的文件 */
+    }
+  }
+  return total;
+}
+
+// 扫描一个 codex 结构目录（可以是 ~/.codex，也可以是 clone 下来的备份）。
+// 返回 [{category, source, name, path, size, rel}]，rel 相对 base（用 "/" 分隔）。
+function scanBase(base) {
+  const items = [];
+  const pluginsCache = path.join(base, "plugins", "cache");
+  const skillsDir = path.join(base, "skills");
+
+  if (isDir(pluginsCache)) {
+    for (const source of sortedDirNames(pluginsCache)) {
+      if (source.startsWith(".")) continue;
+      const sourcePath = path.join(pluginsCache, source);
+      if (!isDir(sourcePath)) continue;
+      for (const plugin of sortedDirNames(sourcePath)) {
+        if (plugin.startsWith(".")) continue;
+        const pluginPath = path.join(sourcePath, plugin);
+        if (!isDir(pluginPath)) continue;
+        items.push({
+          category: "插件 Plugin",
+          source,
+          name: plugin,
+          path: pluginPath,
+          size: dirSize(pluginPath),
+          rel: `plugins/cache/${source}/${plugin}`,
+        });
+      }
+    }
+  }
+
+  if (isDir(skillsDir)) {
+    for (const skill of sortedDirNames(skillsDir)) {
+      if (skill.startsWith(".")) continue;
+      const skillPath = path.join(skillsDir, skill);
+      if (!isDir(skillPath)) continue;
+      items.push({
+        category: "技能 Skill",
+        source: "skills",
+        name: skill,
+        path: skillPath,
+        size: dirSize(skillPath),
+        rel: `skills/${skill}`,
+      });
+    }
+  }
+  return items;
+}
+
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch (e) {
+    return false;
+  }
+}
+
+function sortedDirNames(dir) {
+  try {
+    return fs.readdirSync(dir).sort();
+  } catch (e) {
+    return [];
+  }
+}
+
+// 拷贝目录，跳过隐私 / 垃圾文件（对齐 python copy_clean）。
+function copyClean(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const ent of entries) {
+    if (isBlocked(ent.name)) continue;
+    const srcPath = path.join(src, ent.name);
+    const dstPath = path.join(dst, ent.name);
+    if (ent.isDirectory()) {
+      copyClean(srcPath, dstPath);
+    } else if (ent.isSymbolicLink()) {
+      try {
+        const link = fs.readlinkSync(srcPath);
+        try {
+          fs.unlinkSync(dstPath);
+        } catch (e) {
+          /* 目标不存在 */
+        }
+        fs.symlinkSync(link, dstPath);
+      } catch (e) {
+        /* 忽略坏链接 */
+      }
+    } else if (ent.isFile()) {
+      fs.copyFileSync(srcPath, dstPath);
+    }
+  }
+}
+
+// 插件在 config.toml 里的登记键： name@source 。技能返回 null。
+function pluginKey(item) {
+  if (item.category.startsWith("插件")) {
+    return `${item.name}@${item.source}`;
+  }
+  return null;
+}
+
+// 从 config.toml 文本里取出所有已登记的 [plugins."KEY"] 键。
+function configPluginHeaders(text) {
+  const set = new Set();
+  const re = /\[plugins\."([^"]+)"\]/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    set.add(m[1]);
+  }
+  return set;
+}
+
+// 把选中插件在本机的启用状态，写进备份包的 enabled-plugins.toml。返回记录的 keys。
+function writeEnabledFile(selected, staging) {
+  const configPath = getConfigPath();
+  const srcText = fs.existsSync(configPath)
+    ? fs.readFileSync(configPath, "utf-8")
+    : "";
+  const enabledNow = configPluginHeaders(srcText);
+  const keys = selected
+    .map((it) => pluginKey(it))
+    .filter((k) => k && enabledNow.has(k));
+  const lines = [
+    "# 由 Codex 备份工具生成：仅记录插件启用状态，不含任何敏感配置",
+    "# 还原时会把这些插件在新机器的 config.toml 里标记为 enabled\n",
+  ];
+  for (const k of keys) {
+    lines.push(`[plugins."${k}"]`);
+    lines.push("enabled = true\n");
+  }
+  fs.writeFileSync(path.join(staging, ENABLED_FILE), lines.join("\n"), "utf-8");
+  return keys;
+}
+
+// 把选中的项拷进 staging，保持相对结构，并生成辅助文件。
+function packageItems(selected, staging, log) {
+  if (fs.existsSync(staging)) {
+    fs.rmSync(staging, { recursive: true, force: true });
+  }
+  fs.mkdirSync(staging, { recursive: true });
+
+  for (const it of selected) {
+    const dst = path.join(staging, it.rel);
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    log(`  打包 ${it.category}: ${it.name}  (${humanSize(it.size)})`);
+    copyClean(it.path, dst);
+  }
+
+  fs.writeFileSync(
+    path.join(staging, ".gitignore"),
+    [
+      "# 隐私 / 凭证，绝对不上传",
+      "auth.json",
+      "config.toml",
+      "history.jsonl",
+      "*.sqlite",
+      "*.sqlite-*",
+      "*.log",
+      "*.bak",
+      ".DS_Store",
+      "installation_id",
+    ].join("\n") + "\n",
+    "utf-8"
+  );
+
+  const restorePath = path.join(staging, "restore.sh");
+  fs.writeFileSync(
+    restorePath,
+    "#!/bin/bash\n" +
+      "# 在新电脑上运行本脚本，把插件/技能还原到 ~/.codex\n" +
+      "set -e\n" +
+      'DIR="$(cd "$(dirname "$0")" && pwd)"\n' +
+      'mkdir -p "$HOME/.codex/plugins/cache" "$HOME/.codex/skills"\n' +
+      '[ -d "$DIR/plugins/cache" ] && cp -R "$DIR/plugins/cache/." "$HOME/.codex/plugins/cache/" && echo "已还原插件"\n' +
+      '[ -d "$DIR/skills" ] && cp -R "$DIR/skills/." "$HOME/.codex/skills/" && echo "已还原技能"\n' +
+      'echo "完成 ✅ 重启 codex 生效"\n',
+    "utf-8"
+  );
+  try {
+    fs.chmodSync(restorePath, 0o755);
+  } catch (e) {
+    /* 忽略 */
+  }
+
+  // Windows 还原：restore.ps1（PowerShell 逻辑，用正斜杠，Windows 也接受）
+  fs.writeFileSync(
+    path.join(staging, "restore.ps1"),
+    [
+      '# 在 Windows 上运行：把插件/技能还原到 %USERPROFILE%\\.codex',
+      '$ErrorActionPreference = "Stop"',
+      '$dir = Split-Path -Parent $MyInvocation.MyCommand.Definition',
+      '$codex = "$env:USERPROFILE/.codex"',
+      'New-Item -ItemType Directory -Force -Path "$codex/plugins/cache" | Out-Null',
+      'New-Item -ItemType Directory -Force -Path "$codex/skills" | Out-Null',
+      'if (Test-Path "$dir/plugins/cache") {',
+      '  Copy-Item -Recurse -Force -Path "$dir/plugins/cache/*" -Destination "$codex/plugins/cache"',
+      '  Write-Host "已还原插件"',
+      '}',
+      'if (Test-Path "$dir/skills") {',
+      '  Copy-Item -Recurse -Force -Path "$dir/skills/*" -Destination "$codex/skills"',
+      '  Write-Host "已还原技能"',
+      '}',
+      'Write-Host "完成，重启 codex 生效"',
+    ].join("\r\n") + "\r\n",
+    "utf-8"
+  );
+
+  // Windows 还原：restore.bat（双击即用，内部以 Bypass 策略调用 restore.ps1）
+  fs.writeFileSync(
+    path.join(staging, "restore.bat"),
+    [
+      "@echo off",
+      "chcp 65001 >nul",
+      'powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0restore.ps1"',
+      "echo.",
+      "pause",
+    ].join("\r\n") + "\r\n",
+    "utf-8"
+  );
+
+  const lines = [
+    "# Codex 插件 / 技能 备份\n",
+    "由 Codex 备份工具生成。**已自动排除凭证文件**。\n",
+    "## 包含内容\n",
+  ];
+  for (const it of selected) {
+    lines.push(`- \`${it.rel}\`  (${humanSize(it.size)})`);
+  }
+  lines.push(
+    "\n## 在新电脑上还原",
+    "推荐用本工具的「从 GitHub 拉取还原」标签页；也可手动：\n",
+    "**macOS / Linux：**",
+    "```bash",
+    "bash restore.sh",
+    "```",
+    "**Windows：** 双击 `restore.bat`（或在 PowerShell 里运行 `restore.ps1`）\n",
+    "还原后重启 codex 即可。\n"
+  );
+  fs.writeFileSync(path.join(staging, "README.md"), lines.join("\n"), "utf-8");
+
+  const enabledKeys = writeEnabledFile(selected, staging);
+  if (enabledKeys.length) {
+    log(`  已记录 ${enabledKeys.length} 个插件的启用状态`);
+  }
+  log("打包完成 ✅");
+}
+
+// 把 keys 里缺失的插件登记项【追加】进本机 config.toml（带备份，不覆盖已有项）。
+function enablePluginsInConfig(keys, log) {
+  keys = keys.filter((k) => k);
+  if (!keys.length) return;
+  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));
+  if (!toAdd.length) {
+    log("  启用状态已是最新，config.toml 无需改动");
+    return;
+  }
+  // 备份
+  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")) {
+    text += "\n";
+  }
+  const blocks = ["", "# --- 由 Codex 备份工具还原的插件启用项 ---"];
+  for (const k of toAdd) {
+    blocks.push(`[plugins."${k}"]`);
+    blocks.push("enabled = true");
+    blocks.push("");
+  }
+  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(codexHome, it.rel);
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    log(`  还原 ${it.category}: ${it.name}  -> ${dst}`);
+    copyClean(it.path, dst);
+  }
+  if (enable) {
+    const keys = selected.map((it) => pluginKey(it));
+    enablePluginsInConfig(keys, log);
+  }
+  log("还原完成 ✅ 重启 codex 生效");
+}
+
+const api = {
+  getCodexHome,
+  ENABLED_FILE,
+  humanSize,
+  dirSize,
+  scanBase,
+  copyClean,
+  pluginKey,
+  configPluginHeaders,
+  packageItems,
+  enablePluginsInConfig,
+  restoreItems,
+};
+
+Object.defineProperty(api, "CODEX_HOME", { enumerable: true, get: getCodexHome });
+Object.defineProperty(api, "CONFIG_PATH", { enumerable: true, get: getConfigPath });
+
+module.exports = api;

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 };

electron/lib/codex_desktop.js

@@ -0,0 +1,738 @@
+"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;
+
+const GLOBAL_DICTATION_HIDE_SCRIPT = `
+set hiddenCount to 0
+tell application "System Events"
+  set targetProcesses to every process whose name is "ChatGPT" or name is "Codex"
+  repeat with p in targetProcesses
+    tell p
+      repeat with w in windows
+        try
+          set titleText to title of w as text
+          set roleText to role of w as text
+          set subroleText to subrole of w as text
+          set windowSize to size of w
+          set widthValue to item 1 of windowSize as integer
+          set heightValue to item 2 of windowSize as integer
+          if titleText is "Codex" and roleText is "AXWindow" and subroleText is "AXDialog" and widthValue >= 500 and widthValue <= 900 and heightValue >= 60 and heightValue <= 120 then
+            set position of w to {-10000, -10000}
+            set hiddenCount to hiddenCount + 1
+          end if
+        end try
+      end repeat
+    end tell
+  end repeat
+end tell
+return hiddenCount
+`;
+
+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 execFileText(file, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(file, args, {
+      encoding: "utf-8",
+      windowsHide: true,
+      timeout: options.timeout === undefined
+        ? 2200
+        : Math.max(1, Number(options.timeout) || 1),
+      signal: options.signal,
+      env: options.env || process.env,
+    }, (error, stdout) => {
+      if (error) {
+        error.stdout = stdout || error.stdout || "";
+        reject(error);
+        return;
+      }
+      resolve(String(stdout || ""));
+    });
+  });
+}
+
+function isCodexProcessCommand(command) {
+  const text = String(command || "").replace(/\s+/g, " ").trim();
+  if (!text || isOwnWindowsAppCandidate(text, "")) return false;
+  return /(?:^|[\\/])(?:Codex|ChatGPT)\.app[\\/]/i.test(text) ||
+    /(?:^|[\\/\s])(?:Codex|ChatGPT)(?:\.exe)?(?:\s|$)/i.test(text) ||
+    /WindowsApps[\\/]OpenAI\.(?:Codex|CodexBeta|ChatGPT-Desktop)_/i.test(text);
+}
+
+function hideGlobalDictationWindows(options = {}) {
+  if (process.platform !== "darwin") {
+    return Promise.resolve({
+      ok: false,
+      status: "unsupported-platform",
+      hidden: 0,
+      error: "native global dictation window cleanup is only available on macOS",
+    });
+  }
+
+  const run = options.execFile || execFile;
+  return new Promise((resolve) => {
+    run("osascript", ["-e", GLOBAL_DICTATION_HIDE_SCRIPT], {
+      encoding: "utf-8",
+      windowsHide: true,
+      timeout: Math.max(500, Number(options.timeoutMs) || 5000),
+      signal: options.signal,
+    }, (error, stdout, stderr) => {
+      const output = String(stdout || "").trim();
+      const hidden = /^\d+$/.test(output) ? Number(output) : 0;
+      if (error) {
+        resolve({
+          ok: false,
+          status: "native-command-failed",
+          hidden,
+          error: String((error && error.message) || stderr || error),
+        });
+        return;
+      }
+      resolve({
+        ok: true,
+        status: hidden ? "hidden" : "not-found",
+        hidden,
+        error: "",
+      });
+    });
+  });
+}
+
+async function debugPortOwner(port, options = {}) {
+  const value = Number(port);
+  if (!Number.isInteger(value) || value < 1 || value > 65535) {
+    return { verified: false, owned: false, reason: "invalid-port", processes: [] };
+  }
+  const signal = options.signal;
+  const totalTimeoutMs = Math.max(1, Number(options.timeoutMs) || 5000);
+  const deadline = Date.now() + totalTimeoutMs;
+  const commandOptions = (maxMs) => {
+    if (signal && signal.aborted) {
+      throw signal.reason instanceof Error ? signal.reason : new Error("debug port owner check aborted");
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      const error = new Error("debug port owner check timed out");
+      error.code = "ETIMEDOUT";
+      throw error;
+    }
+    return {
+      timeout: Math.max(1, Math.min(maxMs, remaining)),
+      signal,
+    };
+  };
+
+  if (process.platform === "darwin") {
+    try {
+      const output = await execFileText("lsof", [
+        "-nP",
+        "-a",
+        `-iTCP:${value}`,
+        "-sTCP:LISTEN",
+        "-Fp",
+      ], commandOptions(2200));
+      const pids = [...new Set(
+        output.split(/\r?\n/).filter((line) => /^p\d+$/.test(line)).map((line) => line.slice(1)),
+      )];
+      const processes = [];
+      for (const pid of pids) {
+        try {
+          const command = (await execFileText(
+            "ps",
+            ["-p", pid, "-o", "command="],
+            commandOptions(2200),
+          )).trim();
+          processes.push({ pid: Number(pid), command });
+        } catch {}
+      }
+      return {
+        verified: true,
+        owned: processes.some((item) => isCodexProcessCommand(item.command)),
+        reason: processes.length ? "process-inspected" : "listener-not-found",
+        processes,
+      };
+    } catch (e) {
+      return {
+        verified: false,
+        owned: false,
+        reason: String((e && e.message) || e),
+        processes: [],
+      };
+    }
+  }
+
+  if (process.platform === "win32") {
+    const script = [
+      "$port=[int]$env:TD_CODEX_DEBUG_PORT",
+      "$rows=@()",
+      "Get-NetTCPConnection -State Listen -LocalPort $port -ErrorAction SilentlyContinue | ForEach-Object {",
+      "  $p=Get-CimInstance Win32_Process -Filter ('ProcessId=' + $_.OwningProcess) -ErrorAction SilentlyContinue",
+      "  if($p){ $rows += [pscustomobject]@{ProcessId=$p.ProcessId;Name=$p.Name;ExecutablePath=$p.ExecutablePath;CommandLine=$p.CommandLine} }",
+      "}",
+      "$rows|ConvertTo-Json -Depth 4 -Compress",
+    ].join(";");
+    for (const shell of ["powershell.exe", "pwsh.exe"]) {
+      try {
+        const output = (await execFileText(shell, [
+          "-NoProfile",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-Command",
+          script,
+        ], {
+          ...commandOptions(3500),
+          env: { ...process.env, TD_CODEX_DEBUG_PORT: String(value) },
+        })).trim();
+        const parsed = output ? JSON.parse(output) : [];
+        const rows = Array.isArray(parsed) ? parsed : [parsed];
+        const processes = rows.map((row) => ({
+          pid: Number(row.ProcessId) || 0,
+          command: [row.Name, row.ExecutablePath, row.CommandLine].filter(Boolean).join(" "),
+        }));
+        return {
+          verified: true,
+          owned: processes.some((item) => isCodexProcessCommand(item.command)),
+          reason: processes.length ? "process-inspected" : "listener-not-found",
+          processes,
+        };
+      } catch {}
+    }
+    return { verified: false, owned: false, reason: "process-inspection-failed", processes: [] };
+  }
+
+  return { verified: false, owned: false, reason: "unsupported-platform", processes: [] };
+}
+
+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,
+  debugPortOwner,
+  hideGlobalDictationWindows,
+  windowsProcessDiagnostics,
+  killCodex,
+};

electron/lib/deeplink.js

@@ -0,0 +1,54 @@
+// TD工具箱自定义协议解析。保持纯 Node 实现，便于单独测试。
+const { URL } = require("url");
+
+const SCHEME = "tdtoolbox";
+
+function trim(value) {
+  return String(value || "").trim();
+}
+
+function isHttpUrl(value) {
+  try {
+    const u = new URL(value);
+    return u.protocol === "https:" || u.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+
+function parseTdToolboxImport(rawUrl) {
+  let url;
+  try {
+    url = new URL(String(rawUrl || ""));
+  } catch {
+    return { ok: false, error: "深链格式无效" };
+  }
+  if (url.protocol !== `${SCHEME}:`) return { ok: false, error: "深链协议无效" };
+  if (url.host !== "v1" || url.pathname !== "/import") return { ok: false, error: "深链接口不存在" };
+
+  const q = url.searchParams;
+  const input = {
+    resource: trim(q.get("resource")),
+    app: trim(q.get("app")),
+    name: trim(q.get("name")),
+    endpoint: trim(q.get("endpoint")),
+    apiKey: trim(q.get("apiKey")),
+    model: trim(q.get("model")),
+    source: trim(q.get("source")),
+    sourceGroupId: trim(q.get("sourceGroupId")),
+  };
+
+  if (input.resource !== "provider") return { ok: false, error: "仅支持导入 provider 资源" };
+  if (input.app !== "codex") return { ok: false, error: "仅支持 Codex 分组导入" };
+  if (input.source !== "sub2api") return { ok: false, error: "仅支持 Sub2API 来源" };
+  if (!input.name || input.name.length > 80) return { ok: false, error: "分组名称无效" };
+  if (!isHttpUrl(input.endpoint)) return { ok: false, error: "API 地址必须是 http/https URL" };
+  if (!input.apiKey || input.apiKey.length > 4096) return { ok: false, error: "API 密钥无效" };
+  if (!input.model || input.model.length > 200) return { ok: false, error: "模型无效" };
+  if (!/^[A-Za-z0-9_-]{1,128}$/.test(input.sourceGroupId)) return { ok: false, error: "来源分组 ID 无效" };
+
+  input.name = input.name.replace(/[\r\n\0]/g, "");
+  return { ok: true, input };
+}
+
+module.exports = { SCHEME, parseTdToolboxImport };

electron/lib/global_dictation.js

@@ -0,0 +1,656 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const KEEP_VISIBLE_KEY = "global-dictation-keep-visible";
+const GLOBAL_DICTATION_ROUTE = "/global-dictation";
+const DEFAULT_HTTP_TIMEOUT_MS = 1500;
+const DEFAULT_OWNER_TIMEOUT_MS = 5000;
+const DEFAULT_CLOSE_SETTLE_MS = 100;
+const DEFAULT_CLOSE_RETRIES = 2;
+const RETRYABLE_IO_CODES = new Set(["EACCES", "EBUSY", "EEXIST", "ENOTEMPTY", "EPERM"]);
+
+let codexHome = path.join(os.homedir(), ".codex");
+let watchedStateFile = "";
+let guardLog = () => {};
+let guardBusy = false;
+let endpointOwnerVerifier = null;
+const cleanupFlights = new Map();
+
+function sleepSync(ms) {
+  if (!ms) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function retryIo(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_IO_CODES.has(e && e.code)) throw e;
+    }
+  }
+  throw lastError;
+}
+
+function setCodexDataDir(dir) {
+  if (typeof dir !== "string" || !dir.trim() || !path.isAbsolute(dir.trim())) {
+    throw new Error("Codex data directory must be an absolute path");
+  }
+  codexHome = path.resolve(dir.trim());
+}
+
+function setEndpointOwnerVerifier(verifier) {
+  endpointOwnerVerifier = typeof verifier === "function" ? verifier : null;
+}
+
+function stateFileFor(home = codexHome) {
+  return path.join(home, ".codex-global-state.json");
+}
+
+function acquireLock(file, waitMs = 600) {
+  const lockFile = file + ".td-dictation.lock";
+  const deadline = Date.now() + Math.max(0, waitMs);
+  while (true) {
+    try {
+      const fd = fs.openSync(lockFile, "wx", 0o600);
+      return { fd, lockFile };
+    } catch (e) {
+      if (!e || e.code !== "EEXIST") throw e;
+      try {
+        const ageMs = Date.now() - fs.statSync(lockFile).mtimeMs;
+        if (ageMs > 30000) {
+          fs.rmSync(lockFile, { force: true });
+          continue;
+        }
+      } catch {}
+      if (Date.now() >= deadline) return null;
+      sleepSync(25);
+    }
+  }
+}
+
+function releaseLock(lock) {
+  if (!lock) return;
+  try { fs.closeSync(lock.fd); } catch {}
+  try { fs.rmSync(lock.lockFile, { force: true }); } catch {}
+}
+
+function writeCompleteTemp(file, content, mode, label) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.${label}.tmp`;
+  const fd = fs.openSync(tmp, "wx", mode || 0o600);
+  try {
+    fs.writeFileSync(fd, content);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try { fs.chmodSync(tmp, mode || 0o600); } catch {}
+  return tmp;
+}
+
+function writeBackupOnce(file, content, mode) {
+  const backup = file + ".td-before-global-dictation.bak";
+  let tmp = "";
+  try {
+    tmp = writeCompleteTemp(backup, content, mode, "backup");
+    fs.linkSync(tmp, backup);
+  } catch (e) {
+    if (!e || e.code !== "EEXIST") throw e;
+  } finally {
+    if (tmp) {
+      try { fs.rmSync(tmp, { force: true }); } catch {}
+    }
+  }
+  return backup;
+}
+
+function isJsonWhitespaceByte(value) {
+  return value === 0x20 || value === 0x09 || value === 0x0a || value === 0x0d;
+}
+
+function patchKeepVisibleFalse(file, original) {
+  const text = original.toString("latin1");
+  const pattern = new RegExp(`"${KEEP_VISIBLE_KEY}"\\s*:\\s*true`, "g");
+  let match;
+  let valueOffset = -1;
+  while ((match = pattern.exec(text))) {
+    valueOffset = match.index + match[0].lastIndexOf("true");
+  }
+  if (valueOffset < 1 || !isJsonWhitespaceByte(original[valueOffset - 1])) {
+    return { ok: false, changed: false, reason: "unsafe-format" };
+  }
+
+  const patchOffset = valueOffset - 1;
+  let fd;
+  try {
+    fd = retryIo(() => fs.openSync(file, "r+"));
+    const current = retryIo(() => fs.readFileSync(fd));
+    if (!current.equals(original)) {
+      return { ok: false, changed: false, reason: "concurrent-write" };
+    }
+    const descriptorStat = fs.fstatSync(fd);
+    const pathStat = fs.statSync(file);
+    if (descriptorStat.dev !== pathStat.dev || descriptorStat.ino !== pathStat.ino) {
+      return { ok: false, changed: false, reason: "concurrent-write" };
+    }
+
+    const patch = Buffer.from("false", "ascii");
+    const written = fs.writeSync(fd, patch, 0, patch.length, patchOffset);
+    if (written !== patch.length) throw new Error("global dictation state short write");
+    fs.fsyncSync(fd);
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch {}
+    }
+  }
+
+  const saved = retryIo(() => fs.readFileSync(file));
+  try {
+    const parsed = JSON.parse(saved.toString("utf8"));
+    if (parsed && parsed[KEEP_VISIBLE_KEY] === false) {
+      return { ok: true, changed: true, reason: "disabled" };
+    }
+  } catch {}
+  return { ok: false, changed: false, reason: "concurrent-write" };
+}
+
+function sleepAsync(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal && signal.aborted) {
+      reject(signal.reason instanceof Error ? signal.reason : abortError("request aborted"));
+      return;
+    }
+    const timer = setTimeout(done, Math.max(0, Number(ms) || 0));
+    function done() {
+      if (signal) signal.removeEventListener("abort", aborted);
+      resolve();
+    }
+    function aborted() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", aborted);
+      reject(signal.reason instanceof Error ? signal.reason : abortError("request aborted"));
+    }
+    if (signal) signal.addEventListener("abort", aborted, { once: true });
+  });
+}
+
+function createFileIfMissing(file, content, mode) {
+  let tmp = "";
+  try {
+    tmp = writeCompleteTemp(file, content, mode, "td-dictation-create");
+    try {
+      fs.linkSync(tmp, file);
+    } catch (e) {
+      if (e && e.code === "EEXIST") return false;
+      throw e;
+    }
+    const written = retryIo(() => fs.readFileSync(file));
+    return written.equals(content);
+  } finally {
+    if (tmp) {
+      try { fs.rmSync(tmp, { force: true }); } catch {}
+    }
+  }
+}
+
+function rewriteStateAtomically(file, original, state, mode) {
+  const next = Buffer.from(JSON.stringify(state), "utf8");
+  if (next.equals(original)) {
+    return { ok: true, changed: false, reason: "already-disabled" };
+  }
+
+  let tmp = "";
+  try {
+    const current = retryIo(() => fs.readFileSync(file));
+    if (!current.equals(original)) {
+      return { ok: false, changed: false, reason: "concurrent-write" };
+    }
+    tmp = writeCompleteTemp(file, next, mode, "td-dictation-atomic");
+    const beforeRename = retryIo(() => fs.readFileSync(file));
+    if (!beforeRename.equals(original)) {
+      return { ok: false, changed: false, reason: "concurrent-write" };
+    }
+    fs.renameSync(tmp, file);
+    tmp = "";
+
+    const saved = retryIo(() => fs.readFileSync(file));
+    const parsed = JSON.parse(saved.toString("utf8"));
+    if (parsed && parsed[KEEP_VISIBLE_KEY] === false) {
+      return { ok: true, changed: true, reason: "disabled-atomic" };
+    }
+    return { ok: false, changed: false, reason: "verification-failed" };
+  } finally {
+    if (tmp) {
+      try { fs.rmSync(tmp, { force: true }); } catch {}
+    }
+  }
+}
+
+function disableKeepVisible(options = {}) {
+  const home = options.codexHome ? path.resolve(options.codexHome) : codexHome;
+  const file = stateFileFor(home);
+
+  let lock;
+  try {
+    lock = acquireLock(file, options.lockWaitMs);
+    if (!lock) return { ok: false, changed: false, reason: "locked", file };
+
+    for (let attempt = 0; attempt < 5; attempt++) {
+      if (!fs.existsSync(file)) {
+        const next = Buffer.from(JSON.stringify({ [KEEP_VISIBLE_KEY]: false }, null, 2) + "\n", "utf8");
+        if (createFileIfMissing(file, next, 0o600)) {
+          return { ok: true, changed: true, reason: "created-disabled", file };
+        }
+        continue;
+      }
+
+      const original = retryIo(() => fs.readFileSync(file));
+      let state;
+      try {
+        state = JSON.parse(original.toString("utf8"));
+      } catch (e) {
+        return { ok: false, changed: false, reason: "invalid-json", error: e.message, file };
+      }
+      if (!state || typeof state !== "object" || Array.isArray(state)) {
+        return { ok: false, changed: false, reason: "invalid-state", file };
+      }
+      if (state[KEEP_VISIBLE_KEY] === false) {
+        return { ok: true, changed: false, reason: "already-disabled", file };
+      }
+
+      state[KEEP_VISIBLE_KEY] = false;
+      const mode = fs.statSync(file).mode & 0o777;
+      writeBackupOnce(file, original, mode);
+      const patched = patchKeepVisibleFalse(file, original);
+      if (patched.ok) return { ...patched, file };
+      if (patched.reason === "unsafe-format") {
+        const rewritten = rewriteStateAtomically(file, original, state, mode);
+        if (rewritten.ok) return { ...rewritten, file };
+        if (rewritten.reason === "concurrent-write") continue;
+        return { ...rewritten, file };
+      }
+      if (patched.reason === "concurrent-write") continue;
+      return { ...patched, file };
+    }
+    return { ok: false, changed: false, reason: "concurrent-write", file };
+  } catch (e) {
+    return {
+      ok: false,
+      changed: false,
+      reason: "write-failed",
+      error: String((e && e.message) || e),
+      file,
+    };
+  } finally {
+    releaseLock(lock);
+  }
+}
+
+function decodeRoute(value) {
+  let route = String(value || "").trim();
+  for (let i = 0; i < 2 && /%[0-9a-f]{2}/i.test(route); i++) {
+    try { route = decodeURIComponent(route); } catch { break; }
+  }
+  if (route && !route.startsWith("/")) route = "/" + route;
+  return route.toLowerCase();
+}
+
+function parseCodexPageUrl(rawUrl) {
+  try {
+    const url = new URL(String(rawUrl || ""));
+    const pathname = url.pathname.toLowerCase();
+    if (
+      url.protocol !== "app:" ||
+      url.hostname !== "-" ||
+      (pathname !== "/index.html" && pathname !== "/index.html/")
+    ) return null;
+    return url;
+  } catch {}
+  return null;
+}
+
+function routeInfo(rawUrl) {
+  const url = parseCodexPageUrl(rawUrl);
+  if (!url) return { url: null, present: false, route: "" };
+  for (const [key, value] of url.searchParams.entries()) {
+    if (key.toLowerCase() === "initialroute") {
+      return { url, present: true, route: decodeRoute(value) };
+    }
+  }
+  return { url, present: false, route: "" };
+}
+
+function initialRoute(rawUrl) {
+  return routeInfo(rawUrl).route;
+}
+
+function isCodexMainTarget(target) {
+  if (!target || String(target.type || "").toLowerCase() !== "page") return false;
+  const info = routeInfo(target.url);
+  return !!info.url && !info.present;
+}
+
+function isGlobalDictationTarget(target) {
+  if (!target || String(target.type || "").toLowerCase() !== "page") return false;
+  const info = routeInfo(target.url);
+  return !!info.url && info.present && info.route === GLOBAL_DICTATION_ROUTE;
+}
+
+async function fetchWithTimeout(fetchImpl, url, timeoutMs, signal) {
+  return runWithTimeout(
+    (requestSignal) => fetchImpl(url, { signal: requestSignal }),
+    timeoutMs,
+    signal,
+  );
+}
+
+function abortError(message, code) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  if (code) error.code = code;
+  return error;
+}
+
+async function runWithTimeout(task, timeoutMs, signal) {
+  const controller = new AbortController();
+  let timer;
+  let abortListener;
+  const interrupted = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const error = abortError("request timed out", "ETIMEDOUT");
+      controller.abort(error);
+      reject(error);
+    }, Math.max(1, Number(timeoutMs) || DEFAULT_HTTP_TIMEOUT_MS));
+    if (signal) {
+      abortListener = () => {
+        const reason = signal.reason instanceof Error
+          ? signal.reason
+          : abortError(signal.reason ? String(signal.reason) : "request aborted");
+        controller.abort(reason);
+        reject(reason);
+      };
+      if (signal.aborted) abortListener();
+      else signal.addEventListener("abort", abortListener, { once: true });
+    }
+  });
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => task(controller.signal)),
+      interrupted,
+    ]);
+  } finally {
+    clearTimeout(timer);
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+}
+
+async function listTargets(port, options = {}) {
+  const fetchImpl = options.fetchImpl || global.fetch;
+  if (typeof fetchImpl !== "function") {
+    return { available: false, status: "failed", targets: [], error: "fetch unavailable" };
+  }
+  try {
+    const { response, targets } = await runWithTimeout(
+      async (requestSignal) => {
+        const response = await fetchImpl(`http://127.0.0.1:${Number(port)}/json`, {
+          signal: requestSignal,
+        });
+        const targets = response && response.ok ? await response.json() : null;
+        return { response, targets };
+      },
+      options.timeoutMs || DEFAULT_HTTP_TIMEOUT_MS,
+      options.signal,
+    );
+    if (!response || !response.ok) {
+      return {
+        available: false,
+        status: "port-unavailable",
+        targets: [],
+        error: response ? `HTTP ${response.status || "error"}` : "empty response",
+      };
+    }
+    if (!Array.isArray(targets)) {
+      return { available: false, status: "failed", targets: [], error: "invalid target list" };
+    }
+    return { available: true, status: "available", targets, error: "" };
+  } catch (e) {
+    const aborted = !!(options.signal && options.signal.aborted);
+    const timedOut = !!(e && e.code === "ETIMEDOUT");
+    return {
+      available: false,
+      status: aborted ? "aborted" : timedOut ? "timeout" : "port-unavailable",
+      targets: [],
+      error: String((e && e.message) || e),
+    };
+  }
+}
+
+async function runCloseGlobalDictationTargets(port, options = {}) {
+  const fetchImpl = options.fetchImpl || global.fetch;
+  const listed = Array.isArray(options.targets)
+    ? { available: true, status: "available", targets: options.targets, error: "" }
+    : await listTargets(port, options);
+  const matches = listed.targets.filter(isGlobalDictationTarget);
+  const result = {
+    ok: listed.available,
+    status: listed.status,
+    available: listed.available,
+    matched: matches.length,
+    closed: 0,
+    remaining: listed.available ? matches.length : null,
+    targetIds: matches.map((target) => target.id).filter(Boolean),
+    errors: [],
+  };
+  if (!listed.available || typeof fetchImpl !== "function") {
+    result.status = listed.status || "port-unavailable";
+    if (listed.error) result.errors.push(listed.error);
+    return result;
+  }
+  if (!matches.length) {
+    result.status = "not-found";
+    result.remaining = 0;
+    return result;
+  }
+  if (!listed.targets.some(isCodexMainTarget)) {
+    const verifier = options.endpointOwnerVerifier || endpointOwnerVerifier;
+    let ownership = null;
+    if (typeof verifier === "function") {
+      try {
+        ownership = await runWithTimeout(
+          (requestSignal) => verifier(Number(port), {
+            signal: requestSignal,
+            timeoutMs: options.ownerTimeoutMs || DEFAULT_OWNER_TIMEOUT_MS,
+          }),
+          options.ownerTimeoutMs || DEFAULT_OWNER_TIMEOUT_MS,
+          options.signal,
+        );
+      } catch (e) {
+        ownership = {
+          verified: false,
+          owned: false,
+          reason: String((e && e.message) || e),
+        };
+      }
+    }
+    const owned = ownership === true || !!(ownership && ownership.owned);
+    if (!owned) {
+      result.ok = false;
+      result.status = ownership && ownership.verified ? "foreign-endpoint" : "unverified-endpoint";
+      result.errors.push((ownership && ownership.reason) || "Codex endpoint ownership could not be verified");
+      return result;
+    }
+  }
+
+  const closeResults = await Promise.all(matches.map(async (target) => {
+    if (!target.id) {
+      return { closed: false, error: "global dictation target has no id" };
+    }
+    try {
+      const response = await fetchWithTimeout(
+        fetchImpl,
+        `http://127.0.0.1:${Number(port)}/json/close/${encodeURIComponent(target.id)}`,
+        options.timeoutMs || DEFAULT_HTTP_TIMEOUT_MS,
+        options.signal,
+      );
+      if (response && response.ok) return { closed: true, error: "" };
+      return { closed: false, error: `failed to close target ${target.id}` };
+    } catch (e) {
+      return { closed: false, error: String((e && e.message) || e) };
+    }
+  }));
+  result.closed = closeResults.filter((item) => item.closed).length;
+  result.errors.push(...closeResults.map((item) => item.error).filter(Boolean));
+  if (result.errors.length) {
+    result.ok = false;
+    result.status = options.signal && options.signal.aborted ? "aborted" : "failed";
+    return result;
+  }
+
+  const settleMs = options.settleMs === undefined
+    ? DEFAULT_CLOSE_SETTLE_MS
+    : Math.max(0, Number(options.settleMs) || 0);
+  if (settleMs) {
+    try {
+      await sleepAsync(settleMs, options.signal);
+    } catch (e) {
+      result.ok = false;
+      result.status = "aborted";
+      result.remaining = null;
+      result.errors.push(String((e && e.message) || e));
+      return result;
+    }
+  }
+
+  const verified = await listTargets(port, options);
+  if (!verified.available) {
+    result.ok = false;
+    result.status = verified.status === "aborted" ? "aborted" : "verification-failed";
+    result.remaining = null;
+    if (verified.error) result.errors.push(verified.error);
+    return result;
+  }
+  const remaining = verified.targets.filter(isGlobalDictationTarget);
+  result.remaining = remaining.length;
+  if (remaining.length) {
+    result.ok = false;
+    result.status = "still-present";
+    result.targetIds = remaining.map((target) => target.id).filter(Boolean);
+    return result;
+  }
+  result.status = "closed";
+  return result;
+}
+
+async function runCloseGlobalDictationWithRetry(port, options = {}) {
+  const retries = options.retries === undefined
+    ? DEFAULT_CLOSE_RETRIES
+    : Math.max(0, Number(options.retries) || 0);
+  const retryDelayMs = options.retryDelayMs === undefined
+    ? 120
+    : Math.max(0, Number(options.retryDelayMs) || 0);
+  let totalClosed = 0;
+  let lastResult = null;
+
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const attemptOptions = attempt === 0
+      ? options
+      : { ...options, targets: undefined };
+    lastResult = await runCloseGlobalDictationTargets(port, attemptOptions);
+    totalClosed += lastResult.closed || 0;
+    if (lastResult.status !== "still-present") {
+      return { ...lastResult, closed: totalClosed, attempts: attempt + 1 };
+    }
+    if (attempt < retries && retryDelayMs) {
+      try {
+        await sleepAsync(retryDelayMs, options.signal);
+      } catch (e) {
+        return {
+          ...lastResult,
+          ok: false,
+          status: "aborted",
+          closed: totalClosed,
+          remaining: null,
+          attempts: attempt + 1,
+          errors: [...lastResult.errors, String((e && e.message) || e)],
+        };
+      }
+    }
+  }
+  return { ...lastResult, closed: totalClosed, attempts: retries + 1 };
+}
+
+function closeGlobalDictationTargets(port, options = {}) {
+  const hasCustomOptions =
+    !!options.fetchImpl ||
+    !!options.signal ||
+    !!options.endpointOwnerVerifier ||
+    Array.isArray(options.targets) ||
+    options.timeoutMs !== undefined ||
+    options.ownerTimeoutMs !== undefined ||
+    options.settleMs !== undefined ||
+    options.retries !== undefined ||
+    options.retryDelayMs !== undefined;
+  if (hasCustomOptions) return runCloseGlobalDictationWithRetry(port, options);
+  const key = String(Number(port));
+  if (cleanupFlights.has(key)) return cleanupFlights.get(key);
+  const flight = runCloseGlobalDictationWithRetry(port, options).finally(() => {
+    if (cleanupFlights.get(key) === flight) cleanupFlights.delete(key);
+  });
+  cleanupFlights.set(key, flight);
+  return flight;
+}
+
+function enforceGuard() {
+  if (guardBusy) return;
+  guardBusy = true;
+  try {
+    const result = disableKeepVisible();
+    if (result.changed) guardLog("已关闭 Codex 全局听写栏常驻显示");
+    else if (!result.ok && result.reason !== "locked") {
+      guardLog(`关闭 Codex 全局听写栏常驻显示失败：${result.error || result.reason}`);
+    }
+  } finally {
+    guardBusy = false;
+  }
+}
+
+function startGuard(options = {}) {
+  stopGuard();
+  if (options.codexHome) setCodexDataDir(options.codexHome);
+  guardLog = typeof options.log === "function" ? options.log : () => {};
+  watchedStateFile = stateFileFor();
+  const initial = disableKeepVisible();
+  fs.watchFile(watchedStateFile, { interval: options.intervalMs || 2000, persistent: false }, enforceGuard);
+  return initial;
+}
+
+function stopGuard() {
+  if (watchedStateFile) {
+    try { fs.unwatchFile(watchedStateFile, enforceGuard); } catch {}
+  }
+  watchedStateFile = "";
+  guardLog = () => {};
+}
+
+module.exports = {
+  KEEP_VISIBLE_KEY,
+  GLOBAL_DICTATION_ROUTE,
+  setCodexDataDir,
+  setEndpointOwnerVerifier,
+  disableKeepVisible,
+  startGuard,
+  stopGuard,
+  isCodexMainTarget,
+  isGlobalDictationTarget,
+  closeGlobalDictationTargets,
+  _initialRoute: initialRoute,
+  _listTargets: listTargets,
+  _stateFileFor: stateFileFor,
+};

electron/lib/hotstate.js

@@ -0,0 +1,113 @@
+// hotstate.js —— 热更新版本状态机（纯 fs，bootstrap 与 main 共用）。
+// 维护 userData/hot/current.json：{ target, confirmed, blacklist[], attempts{} }
+// - target    ：期望运行的热更版本
+// - confirmed ：最近一次证明健康（渲染层成功加载）的版本 = 安全回退点
+// - blacklist ：损坏版本，永不再选
+// - attempts  ：未确认版本的启动尝试计数（先落盘再加载，崩溃后下次可判砖）
+"use strict";
+const fs = require("fs");
+const path = require("path");
+
+const MAX_TRY = 1; // 未确认版本最多尝试次数；超过即判砖回退
+
+function statePath(hotBase) {
+  return path.join(hotBase, "current.json");
+}
+function readState(hotBase) {
+  try {
+    const s = JSON.parse(fs.readFileSync(statePath(hotBase), "utf8"));
+    return {
+      target: s.target || null,
+      confirmed: s.confirmed || null,
+      blacklist: Array.isArray(s.blacklist) ? s.blacklist : [],
+      attempts: s.attempts && typeof s.attempts === "object" ? s.attempts : {},
+    };
+  } catch {
+    return { target: null, confirmed: null, blacklist: [], attempts: {} };
+  }
+}
+function writeState(hotBase, state) {
+  try {
+    fs.mkdirSync(hotBase, { recursive: true });
+    fs.writeFileSync(statePath(hotBase), JSON.stringify(state, null, 2));
+    return true;
+  } catch {
+    return false; // 无写权限等 → 由调用方降级
+  }
+}
+// 版本目录是否为可加载的完整结构
+function versionUsable(hotBase, ver) {
+  if (!ver) return false;
+  try {
+    return fs.existsSync(path.join(hotBase, ver, "electron", "main.js"));
+  } catch {
+    return false;
+  }
+}
+
+// bootstrap 调用：决定本次启动加载哪个版本。返回版本名（字符串）或 null（=用包内）。
+// 有副作用：对 pending 版本自增 attempts 并【先落盘】，超限则拉黑回退。
+function chooseVersion(hotBase) {
+  const state = readState(hotBase);
+  let cand = state.target;
+  if (!cand) return null;
+  // 被拉黑或目录不可用 → 回退 confirmed
+  if (state.blacklist.includes(cand) || !versionUsable(hotBase, cand)) {
+    cand = state.confirmed;
+  }
+  if (!versionUsable(hotBase, cand)) return null; // confirmed 也没了 → 包内
+  if (cand === state.confirmed) return cand; // 已确认健康，直接用
+  // cand 是刚应用、尚未确认的新版本（pending）
+  state.attempts[cand] = (state.attempts[cand] || 0) + 1;
+  const over = state.attempts[cand] > MAX_TRY;
+  if (over) {
+    // 之前给过机会仍未确认 → 判砖，拉黑并回退
+    if (!state.blacklist.includes(cand)) state.blacklist.push(cand);
+    delete state.attempts[cand];
+    state.target = state.confirmed;
+    writeState(hotBase, state);
+    return versionUsable(hotBase, state.confirmed) ? state.confirmed : null;
+  }
+  writeState(hotBase, state); // 关键：先落盘尝试计数，再返回让 bootstrap 加载
+  return cand;
+}
+
+// 加载崩溃时拉黑某版本
+function blacklistVersion(hotBase, ver, reason) {
+  if (!ver) return;
+  const state = readState(hotBase);
+  if (!state.blacklist.includes(ver)) state.blacklist.push(ver);
+  delete state.attempts[ver];
+  if (state.target === ver) state.target = state.confirmed;
+  state.lastError = { ver, reason: String(reason || "").slice(0, 500) };
+  writeState(hotBase, state);
+}
+
+// 渲染层成功加载后确认健康
+function confirmHealthy(hotBase, ver) {
+  if (!ver) return;
+  const state = readState(hotBase);
+  state.confirmed = ver;
+  state.target = ver;
+  delete state.attempts[ver];
+  state.blacklist = state.blacklist.filter((v) => v !== ver);
+  writeState(hotBase, state);
+}
+
+// 应用新版本后设为 target（等重启生效）
+function setTarget(hotBase, ver) {
+  const state = readState(hotBase);
+  state.target = ver;
+  writeState(hotBase, state);
+}
+
+// 当前“有效内容版本”：优先已确认，其次包内（由调用方给 fallback）
+function effectiveVersion(hotBase) {
+  const state = readState(hotBase);
+  return state.confirmed || null;
+}
+
+module.exports = {
+  MAX_TRY, readState, writeState, versionUsable,
+  chooseVersion, blacklistVersion, confirmHealthy, setTarget, effectiveVersion,
+};

electron/lib/hotupdate.js

@@ -0,0 +1,144 @@
+// hotupdate.js —— 热更新：拉取 manifest、下载、校验、解压应用（复用 lib/zip.js）。
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { extractZip } = require("./zip");
+const hotstate = require("./hotstate");
+
+const UA = "codex-market";
+const OWNER = "mhgmh";
+const REPO = "codex-market-app";
+const API = `https://update.tokendun.cc/api/v1/repos/${OWNER}/${REPO}`;
+const HOT_TAG = "hot";
+// 可选 ed25519 公钥（SPKI PEM）。留空则只做 sha256 校验；填入后强制校验签名。
+const HOT_PUBKEY_PEM = "";
+
+// 语义版本比较：a>b→1, a<b→-1, 相等→0
+function cmp(a, b) {
+  const pa = String(a || "0").replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = String(b || "0").replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+async function fetchJson(url, ms = 8000) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), ms);
+  try {
+    const res = await fetch(url, { headers: { "User-Agent": UA }, signal: ctrl.signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.json();
+  } finally { clearTimeout(t); }
+}
+
+// 拉取 hot release 里的 hotupdate.json；失败返回 null（断网/无 release 时静默）
+async function fetchManifest() {
+  let rel;
+  try {
+    rel = await fetchJson(`${API}/releases/tags/${HOT_TAG}`);
+  } catch { return null; }
+  const assets = (rel && rel.assets) || [];
+  const mAsset = assets.find((a) => a.name === "hotupdate.json");
+  if (!mAsset) return null;
+  try {
+    const m = await fetchJson(mAsset.browser_download_url || `${API.replace("/api/v1/repos", "")}/`);
+    // 若 bundleUrl 缺失，尝试从同 release 的 asset 里按 contentVersion 找 bundle
+    if (m && !m.bundleUrl && m.contentVersion) {
+      const b = assets.find((a) => a.name === `bundle-${m.contentVersion}.zip`);
+      if (b) m.bundleUrl = b.browser_download_url;
+    }
+    return m;
+  } catch { return null; }
+}
+
+// 评估是否有可用热更 / 是否需完整包。
+// bundledHotVersion：随包内置的内容版本；appVersion：当前原生版本。
+function evaluate(manifest, appVersion, bundledHotVersion, hotBase) {
+  if (!manifest || !manifest.contentVersion) return { hasHot: false };
+  const confirmed = hotstate.effectiveVersion(hotBase); // 已确认的热更版本
+  const effective = cmp(confirmed || "0", bundledHotVersion || "0") > 0 ? confirmed : (bundledHotVersion || "0");
+  const newer = cmp(manifest.contentVersion, effective) > 0;
+  const minOk = cmp(appVersion, manifest.minAppVersion || "0") >= 0;
+  const needFull = !!manifest.requiresFull || !minOk;
+  const fullAppVersion = manifest.fullAppVersion || "";
+  // 兼容协议注册等必须由完整安装包完成的场景：
+  // 旧版先安装热更，热更生效后再引导安装同版本完整包。
+  const needFullAfterHot = !!manifest.requiresFullAfterHot &&
+    (!fullAppVersion || cmp(appVersion, fullAppVersion) < 0);
+  return {
+    hasHot: newer,
+    needFull: newer && needFull,       // 有新内容但当前原生版本不够 → 必须下完整包
+    canHot: newer && minOk && !manifest.requiresFull,
+    needFullAfterHot,
+    contentVersion: manifest.contentVersion,
+    fullAppVersion: fullAppVersion || null,
+    minAppVersion: manifest.minAppVersion || null,
+    notes: manifest.notes || "",
+    mandatory: !!manifest.mandatory,
+  };
+}
+
+// 下载 + 校验 + 解压 + 置 target。onProgress(percent 0..100)
+async function applyManifest(manifest, hotBase, onProgress) {
+  if (!manifest || !manifest.bundleUrl || !manifest.sha256) {
+    throw new Error("热更清单不完整");
+  }
+  const ver = manifest.contentVersion;
+  onProgress && onProgress(1);
+  const res = await fetch(manifest.bundleUrl, { headers: { "User-Agent": UA } });
+  if (!res.ok) throw new Error(`下载失败（${res.status}）`);
+  // 带进度读取
+  const total = Number(res.headers.get("content-length")) || 0;
+  const reader = res.body.getReader();
+  const chunks = [];
+  let got = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    got += value.length;
+    if (total && onProgress) onProgress(Math.min(99, Math.round((got / total) * 100)));
+  }
+  const buf = Buffer.concat(chunks.map((c) => Buffer.from(c)));
+
+  // sha256（必做）
+  const sum = crypto.createHash("sha256").update(buf).digest("hex");
+  if (sum.toLowerCase() !== String(manifest.sha256).toLowerCase()) {
+    throw new Error("SHA256 校验失败，已丢弃");
+  }
+  // ed25519 签名（可选：仅当内嵌公钥非空）
+  if (HOT_PUBKEY_PEM) {
+    if (!manifest.signature) throw new Error("缺少签名");
+    const ok = crypto.verify(
+      null,
+      Buffer.from(`${manifest.sha256}:${ver}`),
+      HOT_PUBKEY_PEM,
+      Buffer.from(manifest.signature, "base64")
+    );
+    if (!ok) throw new Error("签名校验失败");
+  }
+
+  // 解压到中转目录 → 校验结构 → 原子 rename
+  fs.mkdirSync(hotBase, { recursive: true });
+  const tmp = path.join(hotBase, `.tmp-${ver}`);
+  fs.rmSync(tmp, { recursive: true, force: true });
+  fs.mkdirSync(tmp, { recursive: true });
+  extractZip(buf, tmp);
+  if (!fs.existsSync(path.join(tmp, "electron", "main.js")) ||
+      !fs.existsSync(path.join(tmp, "renderer", "index.html"))) {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    throw new Error("热更包结构不完整");
+  }
+  const dst = path.join(hotBase, ver);
+  fs.rmSync(dst, { recursive: true, force: true });
+  fs.renameSync(tmp, dst);
+  hotstate.setTarget(hotBase, ver); // 下次启动生效
+  onProgress && onProgress(100);
+  return { ok: true, version: ver };
+}
+
+module.exports = { fetchManifest, evaluate, applyManifest, cmp };

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,
+};

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 };

electron/lib/prompt-analysis.js

@@ -0,0 +1,162 @@
+// prompt-analysis.js —— 图片反推生图提示词（移植自「提示词提取」项目）
+// LLM 通道走本应用的 router 分组（直接读中转分组列表），与 team.js 同模式。
+"use strict";
+const router = require("./router");
+const { SYSTEM_PROMPT, USER_INSTRUCTION } = require("./team-prompt");
+
+// ============================================================================
+//  以下 <CORE> 自 提示词提取/server.js 原样提取（extractJson / callChat），未改动逻辑。
+// ============================================================================
+
+function extractJson(text) {
+  if (!text) throw new Error('模型返回为空');
+  let t = text.trim();
+  const fence = t.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence) t = fence[1].trim();
+  const start = t.indexOf('{');
+  const end = t.lastIndexOf('}');
+  if (start !== -1 && end !== -1 && end > start) t = t.slice(start, end + 1);
+
+  const tryParse = (s) => { try { return JSON.parse(s); } catch (_) { return undefined; } };
+  let r = tryParse(t);
+  if (r !== undefined) return r;
+  r = tryParse(t.replace(/,\s*([}\]])/g, '$1'));
+  if (r !== undefined) return r;
+  throw new Error('模型输出的 JSON 格式有误，请重试');
+}
+
+// 流式调用：空闲超时——120 秒收不到任何数据就判定挂起并中止
+const CHAT_IDLE_MS = 120000;
+function chatTimeoutError() {
+  return Object.assign(new Error('模型长时间无响应（可能渠道不稳或模型太慢），请重试或换个更快的模型'), { status: 504 });
+}
+async function callChat(gwBase, apiKey, model, messages, maxTokens) {
+  const ctrl = new AbortController();
+  let idle;
+  const resetIdle = () => { clearTimeout(idle); idle = setTimeout(() => ctrl.abort(), CHAT_IDLE_MS); };
+  resetIdle();
+
+  let upstream;
+  try {
+    upstream = await fetch(`${gwBase}/chat/completions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({ model, temperature: 0.4, max_tokens: maxTokens, messages, stream: true }),
+      signal: ctrl.signal,
+    });
+  } catch (e) {
+    clearTimeout(idle);
+    if (e.name === 'AbortError') throw chatTimeoutError();
+    throw e;
+  }
+  if (!upstream.ok) {
+    clearTimeout(idle);
+    const detail = await upstream.text().catch(() => '');
+    const err = new Error(`上游模型调用失败 (${upstream.status})`);
+    err.status = upstream.status === 401 ? 401 : 502;
+    err.detail = detail.slice(0, 300);
+    throw err;
+  }
+
+  const reader = upstream.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = '';
+  let content = '';
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      resetIdle();
+      buf += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, nl).trim();
+        buf = buf.slice(nl + 1);
+        if (!line.startsWith('data:')) continue;
+        const data = line.slice(5).trim();
+        if (!data || data === '[DONE]') continue;
+        try {
+          const j = JSON.parse(data);
+          const delta = j.choices?.[0]?.delta;
+          if (delta?.content) content += delta.content;
+          else if (j.choices?.[0]?.message?.content) content += j.choices[0].message.content;
+        } catch (_) { /* 跳过 keep-alive / 非 JSON 行 */ }
+      }
+    }
+  } catch (e) {
+    if (e.name === 'AbortError') throw chatTimeoutError();
+    throw e;
+  } finally {
+    clearTimeout(idle);
+  }
+  if (!content) throw new Error('模型未返回内容（可能超时或渠道异常）');
+  return content;
+}
+
+// ============================================================================
+//  适配层：LLM 走 router 分组
+// ============================================================================
+
+// 把分组 baseUrl 归一成「+ /chat/completions 即正确」的基址（对齐 team.js）
+function chatBase(baseUrl) {
+  const base = String(baseUrl || "").replace(/\/+$/, "");
+  if (/\/chat\/completions$/.test(base)) return base.replace(/\/chat\/completions$/, "");
+  if (/\/v\d+$/.test(base)) return base;
+  return base + "/v1";
+}
+
+// 取分组：优先按 id，否则用默认 LLM 分组
+function resolveGroup(groupId) {
+  let g = null;
+  if (groupId != null && groupId !== "" && typeof router.groupById === "function") {
+    g = router.groupById(groupId);
+  }
+  if (!g && typeof router.llmGroup === "function") g = router.llmGroup();
+  if (!g) throw new Error("没有可用的中转分组，请先在「路由」里配置好带 baseUrl 和密钥的分组");
+  if (!g.baseUrl || !g.key) throw new Error(`分组「${g.name || g.id}」缺少 baseUrl 或密钥`);
+  return g;
+}
+
+// 获取所有可用分组列表（给前端下拉用）
+function listGroups() {
+  try {
+    return router.usableGroups().map((g) => ({
+      id: g.id,
+      name: g.name || g.id,
+      host: (() => { try { return new (require("url").URL)(g.baseUrl).host; } catch (_) { return ""; } })(),
+      mode: g.mode || "chat",
+    }));
+  } catch (_) {
+    return [];
+  }
+}
+
+// 拉取指定分组的模型列表
+async function listModels(groupId) {
+  const g = resolveGroup(groupId);
+  const models = await router.fetchModels(g.baseUrl, g.key);
+  return models;
+}
+
+// 核心：图片 → 提示词分析
+async function analyze({ image, model, groupId } = {}) {
+  if (!image || typeof image !== "string") throw new Error("缺少图片数据");
+  if (!model) throw new Error("未选择模型");
+  const g = resolveGroup(groupId);
+  const gwBase = chatBase(g.baseUrl);
+
+  const content = await callChat(gwBase, g.key, model, [
+    { role: "system", content: SYSTEM_PROMPT },
+    {
+      role: "user",
+      content: [
+        { type: "text", text: USER_INSTRUCTION },
+        { type: "image_url", image_url: { url: image } },
+      ],
+    },
+  ], 2000);
+
+  return { result: extractJson(content), model };
+}
+
+module.exports = { analyze, listGroups, listModels };

electron/lib/proxy.js

@@ -0,0 +1,673 @@
+// proxy.js —— 全局 / 系统代理：内置 sing-box，把「要密码的上游 SOCKS5」转成
+//   ① 系统代理：本地 mixed 端口(不要密码) + 设置 macOS/Windows 系统代理指过来；
+//   ② 全局 TUN：创建虚拟网卡接管整机流量(需管理员权限，启动时弹一次密码框)。
+// macOS 系统代理不会发送用户名/密码，所以必须走本地中转——这正是本模块存在的原因。
+const { app, safeStorage } = require("electron");
+const { spawn, execFile } = require("child_process");
+const { promisify } = require("util");
+const fs = require("fs");
+const net = require("net");
+const path = require("path");
+const http = require("http");
+
+const pExecFile = promisify(execFile);
+
+// —— 运行时状态（内存）——
+let state = {
+  mode: "off", // off | system | global
+  child: null, // sing-box 子进程(系统模式) 或 osascript/powershell 提权进程(全局模式)
+  localPort: 0, // 系统模式本地 mixed 端口
+  services: [], // macOS：已设置系统代理的网络服务名，停止时逐一还原
+  onChange: null, // 状态变化回调(通知前端 + 托盘)
+};
+
+function setOnChange(cb) {
+  state.onChange = cb;
+}
+function emit() {
+  if (typeof state.onChange === "function") {
+    try {
+      state.onChange(status());
+    } catch {}
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 路径：sing-box 二进制 / 运行时目录 / 配置文件
+// ---------------------------------------------------------------------------
+function resDir() {
+  // 打包后二进制在 resources/singbox；开发时在项目 resources/singbox
+  return app.isPackaged
+    ? path.join(process.resourcesPath, "singbox")
+    : path.join(__dirname, "..", "..", "resources", "singbox");
+}
+function binPath() {
+  const plat = process.platform;
+  let sub;
+  let name = "sing-box";
+  if (plat === "darwin") sub = process.arch === "arm64" ? "darwin-arm64" : "darwin-x64";
+  else if (plat === "win32") {
+    sub = "windows-x64";
+    name = "sing-box.exe";
+  } else {
+    throw new Error("全局代理暂只支持 macOS 与 Windows");
+  }
+  return path.join(resDir(), sub, name);
+}
+function binExists() {
+  try {
+    return fs.existsSync(binPath());
+  } catch {
+    return false;
+  }
+}
+function runtimeDir() {
+  const d = path.join(app.getPath("userData"), "proxy-runtime");
+  fs.mkdirSync(d, { recursive: true });
+  return d;
+}
+function cfgPath() {
+  return path.join(app.getPath("userData"), "proxy.json");
+}
+
+// ---------------------------------------------------------------------------
+// 配置持久化（proxyStr 用 safeStorage 加密）
+// ---------------------------------------------------------------------------
+function enc(s) {
+  if (!s) return "";
+  try {
+    if (safeStorage.isEncryptionAvailable()) return "v1:" + safeStorage.encryptString(s).toString("base64");
+  } catch {}
+  return "b64:" + Buffer.from(s, "utf-8").toString("base64");
+}
+function dec(s) {
+  if (!s) return "";
+  try {
+    if (s.startsWith("v1:")) return safeStorage.decryptString(Buffer.from(s.slice(3), "base64"));
+    if (s.startsWith("b64:")) return Buffer.from(s.slice(4), "base64").toString("utf-8");
+  } catch {}
+  return "";
+}
+
+let conf = null;
+function defaultConf() {
+  return { proxyStr: "", localPort: 0, appliedPort: 0 };
+}
+function loadConf() {
+  if (conf) return conf;
+  try {
+    const raw = JSON.parse(fs.readFileSync(cfgPath(), "utf-8"));
+    raw.proxyStr = raw.proxyStr ? dec(raw.proxyStr) : "";
+    conf = { ...defaultConf(), ...raw };
+  } catch {
+    conf = defaultConf();
+  }
+  return conf;
+}
+function saveConf() {
+  const out = { ...conf, proxyStr: enc(conf.proxyStr) };
+  const p = cfgPath();
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(out, null, 2));
+  try {
+    fs.chmodSync(p, 0o600);
+  } catch {}
+}
+function getConfig() {
+  loadConf();
+  return { proxyStr: conf.proxyStr, localPort: conf.localPort || 0 };
+}
+function setConfig({ proxyStr, localPort } = {}) {
+  loadConf();
+  if (proxyStr !== undefined) conf.proxyStr = String(proxyStr || "").trim();
+  if (localPort !== undefined) conf.localPort = parseInt(localPort, 10) || 0;
+  saveConf();
+  return getConfig();
+}
+
+// ---------------------------------------------------------------------------
+// 解析上游代理字符串：支持
+//   host:port:user:pass  /  host:port  /  socks5://user:pass@host:port
+// ---------------------------------------------------------------------------
+function parseProxy(str) {
+  str = String(str || "").trim();
+  if (!str) return null;
+  const m = str.match(/^socks5?:\/\/(?:([^:@/]+):([^@/]+)@)?([^:/@]+):(\d+)/i);
+  if (m) return { host: m[3], port: parseInt(m[4], 10), user: m[1] || "", pass: m[2] || "" };
+  const parts = str.split(":");
+  if (parts.length === 4 && /^\d+$/.test(parts[1])) {
+    return { host: parts[0], port: parseInt(parts[1], 10), user: parts[2], pass: parts[3] };
+  }
+  if (parts.length === 2 && /^\d+$/.test(parts[1])) {
+    return { host: parts[0], port: parseInt(parts[1], 10), user: "", pass: "" };
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// 找空闲端口（优先用用户指定端口，占用则随机取）
+// ---------------------------------------------------------------------------
+function findFreePort(preferred) {
+  return new Promise((resolve) => {
+    const tryListen = (port, fallback) => {
+      const srv = net.createServer();
+      srv.once("error", () => {
+        if (fallback) tryListen(0, false);
+        else resolve(0);
+      });
+      srv.listen(port, "127.0.0.1", () => {
+        const p = srv.address().port;
+        srv.close(() => resolve(p));
+      });
+    };
+    tryListen(preferred || 0, !!preferred);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// sing-box 配置生成
+// ---------------------------------------------------------------------------
+function outbounds(p) {
+  const proxy = { type: "socks", tag: "proxy", server: p.host, server_port: p.port, version: "5" };
+  if (p.user) {
+    proxy.username = p.user;
+    proxy.password = p.pass;
+  }
+  return [proxy, { type: "direct", tag: "direct" }];
+}
+function systemConfig(p, port) {
+  return {
+    log: { level: "warn" },
+    inbounds: [{ type: "mixed", tag: "mixed-in", listen: "127.0.0.1", listen_port: port }],
+    outbounds: outbounds(p),
+    route: { final: "proxy" },
+  };
+}
+function globalConfig(p, logPath) {
+  return {
+    // 让 sing-box 直接把日志写到文件(UTF-8)，不依赖 shell 重定向 → 中文路径无损、判断启动可靠
+    log: { level: "info", output: logPath, timestamp: true },
+    dns: {
+      servers: [
+        // 用 TCP-53 远程 DNS(经代理解析)——比 DoT(853) 更通用，避免代理不放行加密 DNS 导致全站解析失败
+        { type: "tcp", tag: "remote-dns", server: "8.8.8.8", detour: "proxy" },
+        { type: "local", tag: "local-dns" },
+      ],
+      final: "remote-dns",
+      strategy: "ipv4_only",
+    },
+    inbounds: [
+      // gvisor 用户态协议栈：Windows 上比 system 栈更稳、兼容性好
+      { type: "tun", tag: "tun-in", address: ["172.19.0.1/30"], auto_route: true, strict_route: true, stack: "gvisor" },
+    ],
+    outbounds: outbounds(p),
+    route: {
+      auto_detect_interface: true,
+      default_domain_resolver: "local-dns",
+      rules: [
+        { action: "sniff" }, // 嗅探协议，供下面识别 DNS / QUIC
+        // 关键：把 DNS 查询劫持给 sing-box 自己用 TCP 解析。否则浏览器的 UDP DNS 被塞进 TUN → 交给只支持 TCP 的 SOCKS5 → 丢弃 → 全站解析失败 = 没网
+        { protocol: "dns", action: "hijack-dns" },
+        { port: 53, action: "hijack-dns" },
+        // QUIC(HTTP/3, UDP 443)经只支持 TCP 的 SOCKS5 会全丢 → 直接拒绝，逼浏览器回落到 TCP
+        { network: "udp", port: 443, action: "reject" },
+      ],
+      final: "proxy",
+    },
+  };
+}
+function writeCfg(name, obj) {
+  const p = path.join(runtimeDir(), name);
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2));
+  return p;
+}
+
+// ---------------------------------------------------------------------------
+// macOS：系统代理设置 / 还原
+// ---------------------------------------------------------------------------
+async function macServices() {
+  // 列出所有网络服务，去掉标题行与被禁用(带*)的
+  const { stdout } = await pExecFile("networksetup", ["-listallnetworkservices"]);
+  return stdout
+    .split("\n")
+    .slice(1)
+    .map((s) => s.trim())
+    .filter((s) => s && !s.startsWith("*"));
+}
+async function macSetSystemProxy(port) {
+  const services = await macServices();
+  const applied = [];
+  for (const svc of services) {
+    try {
+      await pExecFile("networksetup", ["-setwebproxy", svc, "127.0.0.1", String(port)]);
+      await pExecFile("networksetup", ["-setsecurewebproxy", svc, "127.0.0.1", String(port)]);
+      await pExecFile("networksetup", ["-setsocksfirewallproxy", svc, "127.0.0.1", String(port)]);
+      applied.push(svc);
+    } catch {
+      /* 某个服务设置失败(如未连接)则跳过 */
+    }
+  }
+  return applied;
+}
+async function macUnsetSystemProxy(services) {
+  for (const svc of services || []) {
+    for (const kind of ["-setwebproxystate", "-setsecurewebproxystate", "-setsocksfirewallproxystate"]) {
+      try {
+        await pExecFile("networksetup", [kind, svc, "off"]);
+      } catch {}
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Windows：系统代理设置 / 还原（HKCU，无需管理员）
+// ---------------------------------------------------------------------------
+const WIN_INET = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
+// 通知 WinINET 代理设置已变更，让浏览器(Chrome/Edge 等)立即重新读取，而不是等重启
+async function winRefreshInet() {
+  const ps =
+    `$s='[DllImport("wininet.dll",SetLastError=true)]public static extern bool InternetSetOption(IntPtr h,int o,IntPtr b,int l);';` +
+    `$t=Add-Type -MemberDefinition $s -Name W -Namespace I -PassThru;` +
+    `$t::InternetSetOption([IntPtr]::Zero,39,[IntPtr]::Zero,0)|Out-Null;` + // INTERNET_OPTION_SETTINGS_CHANGED
+    `$t::InternetSetOption([IntPtr]::Zero,37,[IntPtr]::Zero,0)|Out-Null`; // INTERNET_OPTION_REFRESH
+  await pExecFile("powershell", ["-NoProfile", "-Command", ps]).catch(() => {});
+}
+async function winSetSystemProxy(port) {
+  await pExecFile("reg", ["add", WIN_INET, "/v", "ProxyEnable", "/t", "REG_DWORD", "/d", "1", "/f"]);
+  await pExecFile("reg", ["add", WIN_INET, "/v", "ProxyServer", "/d", `127.0.0.1:${port}`, "/f"]);
+  // 排除本地地址直连
+  await pExecFile("reg", ["add", WIN_INET, "/v", "ProxyOverride", "/d", "localhost;127.*;<local>", "/f"]).catch(() => {});
+  await winRefreshInet();
+}
+async function winUnsetSystemProxy() {
+  await pExecFile("reg", ["add", WIN_INET, "/v", "ProxyEnable", "/t", "REG_DWORD", "/d", "0", "/f"]).catch(() => {});
+  await winRefreshInet();
+}
+
+// ---------------------------------------------------------------------------
+// 系统代理模式：启动本地 sing-box mixed + 设系统代理
+// ---------------------------------------------------------------------------
+async function startSystem(p) {
+  const port = await findFreePort(conf.localPort || 0);
+  if (!port) throw new Error("找不到可用的本地端口");
+  const cfg = writeCfg("system.json", systemConfig(p, port));
+
+  const child = spawn(binPath(), ["run", "-c", cfg], { stdio: ["ignore", "pipe", "pipe"] });
+  let stderr = "";
+  child.stderr.on("data", (d) => (stderr += d.toString()));
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    child.on("error", (e) => {
+      if (!settled) {
+        settled = true;
+        reject(e);
+      }
+    });
+    child.on("exit", (code) => {
+      if (!settled) {
+        settled = true;
+        reject(new Error(`sing-box 启动失败(${code})：${stderr.slice(0, 300)}`));
+      }
+    });
+    // 轮询本地端口，通了就算启动成功
+    const t0 = Date.now();
+    const poll = () => {
+      const s = net.connect(port, "127.0.0.1");
+      s.on("connect", () => {
+        s.destroy();
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      });
+      s.on("error", () => {
+        s.destroy();
+        if (Date.now() - t0 > 8000) {
+          if (!settled) {
+            settled = true;
+            reject(new Error("sing-box 端口未就绪：" + stderr.slice(0, 200)));
+          }
+        } else setTimeout(poll, 300);
+      });
+    };
+    poll();
+  });
+
+  // 端口通了 → 设系统代理
+  let services = [];
+  if (process.platform === "darwin") services = await macSetSystemProxy(port);
+  else if (process.platform === "win32") await winSetSystemProxy(port);
+
+  state.mode = "system";
+  state.child = child;
+  state.localPort = port;
+  state.services = services;
+  conf.appliedPort = port;
+  saveConf();
+  child.on("exit", () => {
+    // 子进程意外退出 → 复位（并尝试还原系统代理）
+    if (state.child === child) {
+      cleanupSystemProxy().catch(() => {});
+      state.mode = "off";
+      state.child = null;
+      emit();
+    }
+  });
+  emit();
+  return status();
+}
+
+async function cleanupSystemProxy() {
+  if (process.platform === "darwin") await macUnsetSystemProxy(state.services);
+  else if (process.platform === "win32") await winUnsetSystemProxy();
+  state.services = [];
+}
+
+// ---------------------------------------------------------------------------
+// 全局 TUN 模式：提权启动 sing-box（flag 文件做“可停止”，全程只弹一次密码）
+//   原理：提权 shell 里后台跑 sing-box，前台 while 循环盯住 flag 文件；
+//   我方(普通权限)删除 flag → 提权循环发现文件没了 → kill sing-box 退出。
+// ---------------------------------------------------------------------------
+function flagPath() {
+  return path.join(runtimeDir(), "global.flag");
+}
+function stripAnsi(s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, "");
+}
+// 读日志：Windows 的系统错误常是 GBK 中文，UTF-8 读出来是乱码 → 检测到乱码就用 GBK 兜底
+function readLogSmart(logf) {
+  let buf;
+  try {
+    buf = fs.readFileSync(logf);
+  } catch {
+    return "";
+  }
+  let s = buf.toString("utf-8");
+  if (s.includes("�")) {
+    for (const enc of ["gbk", "gb18030", "big5"]) {
+      try {
+        const d = new TextDecoder(enc).decode(buf);
+        if (!d.includes("�")) {
+          s = d;
+          break;
+        }
+      } catch {}
+    }
+  }
+  return stripAnsi(s);
+}
+// 盯 sing-box 日志判断启动成败（mac / Windows 通用）：
+//   出现 "sing-box started" → 成功；出现 FATAL → 失败；
+//   提权进程(仅 mac)提前退出且无 started → 取消授权；超时同理。
+function waitForStart(logf, timeoutMs, child, watchChildExit) {
+  return new Promise((resolve) => {
+    const t0 = Date.now();
+    let childExited = false;
+    if (watchChildExit && child) child.on("exit", () => (childExited = true));
+    const tick = () => {
+      const txt = readLogSmart(logf);
+      if (/sing-box started/i.test(txt)) return resolve({ ok: true });
+      const fatal = txt.match(/FATAL[^\n]*/i) || txt.match(/ERROR[^\n]*(bind|permission|denied|wintun|tun)[^\n]*/i);
+      if (fatal) return resolve({ ok: false, reason: "引擎启动失败：" + fatal[0].trim().slice(0, 260) });
+      if (childExited && Date.now() - t0 > 1500) {
+        return resolve({
+          ok: false,
+          reason: txt ? "启动失败：" + txt.trim().slice(-260) : "已取消管理员授权，全局代理未启动。",
+        });
+      }
+      if (Date.now() - t0 > timeoutMs) {
+        return resolve({
+          ok: false,
+          reason: txt
+            ? "启动超时：" + txt.trim().slice(-260)
+            : "未获得管理员授权(密码框 / UAC 被取消)，或引擎无法启动。",
+        });
+      }
+      setTimeout(tick, 400);
+    };
+    tick();
+  });
+}
+
+async function startGlobal(p) {
+  const flag = flagPath();
+  const logf = path.join(runtimeDir(), "global.log");
+  const cfg = writeCfg("global.json", globalConfig(p, logf));
+  // 先自检配置，避免弹了密码才发现配置错
+  await pExecFile(binPath(), ["check", "-c", cfg]);
+  try {
+    fs.unlinkSync(logf); // 清掉上次日志，保证这次判断读到的是本次输出
+  } catch {}
+  fs.writeFileSync(flag, "run");
+
+  let child;
+  if (process.platform === "darwin") {
+    // 提权 bash：后台跑 sing-box(日志由 sing-box 自己写文件)，盯 flag；flag 删了或引擎挂了就退出
+    const sh = path.join(runtimeDir(), "run-global.sh");
+    fs.writeFileSync(
+      sh,
+      `#!/bin/bash
+"${binPath()}" run -c "${cfg}" &
+SB=$!
+while [ -f "${flag}" ]; do sleep 1; kill -0 $SB 2>/dev/null || break; done
+kill $SB 2>/dev/null
+wait $SB 2>/dev/null
+`
+    );
+    fs.chmodSync(sh, 0o755);
+    const osa = `do shell script "/bin/bash '${sh}'" with administrator privileges`;
+    child = spawn("osascript", ["-e", osa]);
+  } else if (process.platform === "win32") {
+    // PowerShell(Unicode 原生，兼容中文用户名路径)：提权后台跑 sing-box，盯 flag，删了就杀。
+    // sing-box 自己把日志写进 log.output，不用 shell 重定向 → 避开 cmd 的 GBK 编码坑。
+    const ps = path.join(runtimeDir(), "run-global.ps1");
+    const psBody =
+      "" + // UTF-8 BOM，保证 PowerShell 按 UTF-8 读取(路径含中文也不乱)
+      `$ErrorActionPreference='SilentlyContinue'\r\n` +
+      // 先杀掉上次残留的引擎(此脚本已提权，能杀掉之前遗留的管理员进程)，释放被占用的 wintun 网卡
+      `Stop-Process -Name sing-box -Force\r\n` +
+      `Start-Sleep -Milliseconds 800\r\n` +
+      `$proc = Start-Process -FilePath '${binPath()}' -ArgumentList @('run','-c','${cfg}') -WindowStyle Hidden -PassThru\r\n` +
+      `while (Test-Path '${flag}') { if ($proc.HasExited) { break }; Start-Sleep -Seconds 1 }\r\n` +
+      `if (-not $proc.HasExited) { Stop-Process -Id $proc.Id -Force }\r\n` +
+      `Stop-Process -Name sing-box -Force\r\n`;
+    fs.writeFileSync(ps, psBody, "utf-8");
+    // 非提权的外层 powershell 负责触发一次 UAC，把上面的脚本以管理员+隐藏窗口运行
+    const outer = `Start-Process powershell -Verb RunAs -WindowStyle Hidden -ArgumentList '-NoProfile','-ExecutionPolicy','Bypass','-File','${ps}'`;
+    child = spawn("powershell", ["-NoProfile", "-Command", outer], { windowsHide: true });
+  } else {
+    throw new Error("全局代理暂只支持 macOS 与 Windows");
+  }
+
+  // mac 的提权进程会随 sing-box 存活；win 的外层进程点完 UAC 立刻退出，故只在 mac 盯它早退
+  // 开 wintun/utun 网卡可能较慢，给 40 秒；那句 "open interface take too much time" 只是 WARN，会继续尝试
+  const res = await waitForStart(logf, 40000, child, process.platform === "darwin");
+  if (!res.ok) {
+    try {
+      fs.unlinkSync(flag);
+    } catch {}
+    try {
+      if (child) child.kill();
+    } catch {}
+    throw new Error(res.reason);
+  }
+
+  state.mode = "global";
+  state.localPort = 0;
+  if (process.platform === "darwin") {
+    // mac：提权进程存活即代理存活，它退出就复位状态
+    state.child = child;
+    child.on("exit", () => {
+      if (state.child === child) {
+        try {
+          fs.unlinkSync(flag);
+        } catch {}
+        state.mode = "off";
+        state.child = null;
+        emit();
+      }
+    });
+  } else {
+    // win：外层进程已退出，靠 flag 文件控制生命周期
+    state.child = null;
+  }
+  emit();
+  return status();
+}
+
+// ---------------------------------------------------------------------------
+// 统一启动 / 停止
+// ---------------------------------------------------------------------------
+async function start(mode) {
+  loadConf();
+  if (!binExists()) throw new Error("缺少 sing-box 引擎文件，请重新安装本软件");
+  const p = parseProxy(conf.proxyStr);
+  if (!p) throw new Error("请先填写正确的代理地址，格式：host:port:user:pass");
+  if (state.mode !== "off") await stop();
+  if (mode === "system") return startSystem(p);
+  if (mode === "global") return startGlobal(p);
+  throw new Error("未知模式：" + mode);
+}
+
+async function stop() {
+  const prev = state.mode;
+  if (prev === "system") {
+    await cleanupSystemProxy();
+    if (state.child) {
+      try {
+        state.child.kill();
+      } catch {}
+    }
+  } else if (prev === "global") {
+    // 删 flag → 提权循环自行 kill sing-box 并拆除 TUN
+    try {
+      fs.unlinkSync(flagPath());
+    } catch {}
+    // 兜底：等提权进程收尾
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+  state.mode = "off";
+  state.child = null;
+  state.localPort = 0;
+  state.services = [];
+  emit();
+  return status();
+}
+
+// 退出前清理：确保不把系统代理 / TUN 残留给用户
+async function shutdown() {
+  if (state.mode === "off") return;
+  try {
+    await stop();
+  } catch {}
+}
+
+// 启动时的残留清理：上次若崩溃遗留了「指向我们端口的系统代理」，且引擎已不在 → 关掉它，
+// 但不动用户自己(如 Clash)设的其它端口，避免误伤。
+async function cleanupStale() {
+  loadConf();
+  if (process.platform !== "darwin" || !conf.appliedPort) return;
+  try {
+    const services = await macServices();
+    for (const svc of services) {
+      const { stdout } = await pExecFile("networksetup", ["-getsocksfirewallproxy", svc]).catch(() => ({ stdout: "" }));
+      if (/Enabled:\s*Yes/i.test(stdout) && stdout.includes("127.0.0.1") && stdout.includes(String(conf.appliedPort))) {
+        await macUnsetSystemProxy([svc]);
+      }
+    }
+  } catch {}
+}
+
+// ---------------------------------------------------------------------------
+// 测试连通性：临时起一个本地 mixed 口，经它请求取出口 IP
+// ---------------------------------------------------------------------------
+async function testProxy() {
+  loadConf();
+  if (!binExists()) throw new Error("缺少 sing-box 引擎文件");
+  const p = parseProxy(conf.proxyStr);
+  if (!p) throw new Error("代理地址格式不对，应为 host:port:user:pass");
+  const port = await findFreePort(0);
+  const cfg = writeCfg("test.json", systemConfig(p, port));
+  const child = spawn(binPath(), ["run", "-c", cfg], { stdio: ["ignore", "ignore", "pipe"] });
+  let stderr = "";
+  child.stderr.on("data", (d) => (stderr += d.toString()));
+  try {
+    // 等端口就绪
+    await new Promise((resolve, reject) => {
+      const t0 = Date.now();
+      const poll = () => {
+        const s = net.connect(port, "127.0.0.1");
+        s.on("connect", () => {
+          s.destroy();
+          resolve();
+        });
+        s.on("error", () => {
+          s.destroy();
+          if (Date.now() - t0 > 6000) reject(new Error("引擎未就绪：" + stderr.slice(0, 200)));
+          else setTimeout(poll, 250);
+        });
+      };
+      poll();
+    });
+    const ip = await httpGetViaProxy(port, "http://api.ipify.org/");
+    return { ok: true, ip, proxy: `${p.host}:${p.port}` };
+  } finally {
+    try {
+      child.kill();
+    } catch {}
+  }
+}
+
+// 经本地 HTTP 代理端口发一个 GET，返回响应体（用于取出口 IP）
+function httpGetViaProxy(port, targetUrl) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(targetUrl);
+    const req = http.request(
+      {
+        host: "127.0.0.1",
+        port,
+        method: "GET",
+        path: targetUrl, // 绝对 URL → 走代理
+        headers: { Host: u.host, "User-Agent": "codex-market", Connection: "close" },
+        timeout: 15000,
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8").trim()));
+      }
+    );
+    req.on("timeout", () => req.destroy(new Error("请求超时(15s)")));
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// 状态
+// ---------------------------------------------------------------------------
+function status() {
+  loadConf();
+  const p = parseProxy(conf.proxyStr);
+  return {
+    mode: state.mode, // off | system | global
+    running: state.mode !== "off",
+    localPort: state.localPort || 0,
+    binOk: binExists(),
+    platform: process.platform,
+    proxy: p ? { host: p.host, port: p.port, hasAuth: !!p.user } : null,
+    hasConfig: !!p,
+  };
+}
+
+module.exports = {
+  getConfig,
+  setConfig,
+  start,
+  stop,
+  status,
+  testProxy,
+  shutdown,
+  cleanupStale,
+  setOnChange,
+};

electron/lib/purge.js

@@ -0,0 +1,182 @@
+// purge.js —— 检测本机 Codex 的所有安装位置，并「强制清除」。
+// 跨平台（macOS / Windows / Linux）自动识别：数据目录、PATH 里的可执行文件、
+// npm 全局包、Homebrew 安装等。用于「更新后中转失效 → 彻底清干净再重装」。
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { exec } = require("child_process");
+
+const codex = require("./codex");
+const codexDesktop = require("./codex_desktop");
+
+const IS_WIN = process.platform === "win32";
+
+// 跑一条 shell 命令，带超时；失败返回 null（用于探测，绝不抛错）。
+function run(command) {
+  return new Promise((resolve) => {
+    try {
+      exec(command, { timeout: 8000, windowsHide: true }, (err, stdout) => {
+        if (err) return resolve(null);
+        resolve(String(stdout || "").trim() || null);
+      });
+    } catch (e) {
+      resolve(null);
+    }
+  });
+}
+
+// 某个路径存在吗？（含符号链接本身）
+function lstat(p) {
+  try {
+    return fs.lstatSync(p);
+  } catch (e) {
+    return null;
+  }
+}
+
+// 求路径体积：目录递归、文件取 size、符号链接算 0。
+function sizeOf(p, st) {
+  if (!st) return 0;
+  if (st.isSymbolicLink()) return 0;
+  if (st.isDirectory()) return codex.dirSize(p);
+  try {
+    return fs.statSync(p).size;
+  } catch (e) {
+    return 0;
+  }
+}
+
+// 从可执行文件的真实路径回溯出 @openai/codex 包根目录。
+// 例：.../@openai/codex/bin/codex.js -> .../@openai/codex
+function pkgRootFromBin(realBin) {
+  let dir = path.dirname(realBin);
+  for (let i = 0; i < 6; i++) {
+    if (
+      path.basename(dir) === "codex" &&
+      path.basename(path.dirname(dir)) === "@openai"
+    ) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// 探测所有可能的 Codex 安装位置。返回去重后的候选清单（含 exists / size）。
+async function detectInstalls() {
+  const home = os.homedir();
+  // key（绝对路径）-> 候选
+  const found = new Map();
+
+  const add = (label, kind, p) => {
+    if (!p) return;
+    let abs;
+    try {
+      abs = path.resolve(p);
+    } catch (e) {
+      return;
+    }
+    if (found.has(abs)) return;
+    found.set(abs, { label, kind, path: abs });
+  };
+
+  // 1) 数据目录（配置 / 登录凭证 / 会话 / 插件 / 技能）——始终列出
+  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/)) {
+      const bin = line.trim();
+      if (!bin) continue;
+      add("Codex 可执行文件（PATH）", "bin", bin);
+      // 顺着符号链接找到真实文件，再回溯 npm 包根
+      try {
+        const real = fs.realpathSync(bin);
+        if (real !== bin) add("Codex 可执行文件（真实位置）", "bin", real);
+        const root = pkgRootFromBin(real);
+        if (root) add("@openai/codex 安装包", "npm-package", root);
+      } catch (e) {
+        /* 断链/权限：忽略 */
+      }
+    }
+  }
+
+  // 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"));
+
+  const npmPrefix = await run(IS_WIN ? "npm.cmd prefix -g" : "npm prefix -g");
+  if (npmPrefix) {
+    const binDir = IS_WIN ? npmPrefix : path.join(npmPrefix, "bin");
+    for (const n of ["codex", "codex.cmd", "codex.ps1", "codex.exe"]) {
+      add("Codex 启动脚本（npm bin）", "bin", path.join(binDir, n));
+    }
+    add("@openai/codex 安装包（npm 全局）", "npm-package", path.join(npmPrefix, IS_WIN ? "node_modules" : "lib/node_modules", "@openai", "codex"));
+  }
+
+  // 5) 各平台常见固定位置兜底
+  if (IS_WIN) {
+    const appdata = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    for (const n of ["codex", "codex.cmd", "codex.ps1"]) {
+      add("Codex 启动脚本（%APPDATA%\\npm）", "bin", path.join(appdata, "npm", n));
+    }
+    add("@openai/codex 安装包（%APPDATA%\\npm）", "npm-package", path.join(appdata, "npm", "node_modules", "@openai", "codex"));
+  } else {
+    // macOS / Linux：Homebrew 与常见全局前缀
+    for (const prefix of ["/opt/homebrew", "/usr/local", path.join(home, ".npm-global")]) {
+      add("Codex 可执行文件（" + prefix + "）", "bin", path.join(prefix, "bin", "codex"));
+      add("@openai/codex 安装包（" + prefix + "）", "npm-package", path.join(prefix, "lib", "node_modules", "@openai", "codex"));
+    }
+  }
+
+  // 收尾：补 exists / size，只保留真实存在的项
+  const items = [];
+  for (const c of found.values()) {
+    const st = lstat(c.path);
+    if (!st) continue; // 不存在的不展示
+    items.push({
+      ...c,
+      exists: true,
+      isSymlink: st.isSymbolicLink(),
+      isDir: st.isDirectory() && !st.isSymbolicLink(),
+      size: sizeOf(c.path, st),
+      sizeText: codex.humanSize(sizeOf(c.path, st)),
+    });
+  }
+  // 数据目录排最前，其余按体积降序
+  items.sort((a, b) => {
+    if (a.kind === "data") return -1;
+    if (b.kind === "data") return 1;
+    return b.size - a.size;
+  });
+  return items;
+}
+
+// 强制删除给定路径。为安全起见，只删除「当前探测得到」的路径，
+// 防止渲染进程传入任意路径。返回每一项的删除结果。
+async function purge(requestedPaths) {
+  const wanted = new Set((requestedPaths || []).map((p) => path.resolve(p)));
+  const detected = await detectInstalls();
+  const allowed = detected.filter((d) => wanted.has(d.path));
+
+  const results = [];
+  for (const item of allowed) {
+    try {
+      fs.rmSync(item.path, { recursive: true, force: true });
+      results.push({ path: item.path, label: item.label, ok: true, stillExists: !!lstat(item.path) });
+    } catch (e) {
+      results.push({ path: item.path, label: item.label, ok: false, error: String(e && e.message || e) });
+    }
+  }
+  return results;
+}
+
+module.exports = { detectInstalls, purge };

electron/lib/secrets.js

@@ -0,0 +1,66 @@
+// 密钥安全存储：用 Electron safeStorage 加密后写入 userData/secrets.json
+// name 取 "github" / "registry"。读时解密；无则返回空串。
+const fs = require("fs");
+const path = require("path");
+const { app, safeStorage } = require("electron");
+
+function secretsPath() {
+  return path.join(app.getPath("userData"), "secrets.json");
+}
+
+function readStore() {
+  try {
+    const txt = fs.readFileSync(secretsPath(), "utf-8");
+    return JSON.parse(txt || "{}");
+  } catch (e) {
+    return {};
+  }
+}
+
+function writeStore(store) {
+  const p = secretsPath();
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+  try {
+    fs.chmodSync(p, 0o600);
+  } catch (e) {
+    /* 忽略权限设置失败（非 POSIX 平台） */
+  }
+}
+
+// 取密钥；无则空串
+function getSecret(name) {
+  const store = readStore();
+  const enc = store[name];
+  if (!enc) return "";
+  try {
+    if (safeStorage.isEncryptionAvailable()) {
+      return safeStorage.decryptString(Buffer.from(enc, "base64"));
+    }
+    // 加密不可用时的降级：明文（base64）存储
+    return Buffer.from(enc, "base64").toString("utf-8");
+  } catch (e) {
+    return "";
+  }
+}
+
+// 存密钥；空值视为删除
+function setSecret(name, value) {
+  const store = readStore();
+  if (!value) {
+    delete store[name];
+    writeStore(store);
+    return { ok: true };
+  }
+  let encB64;
+  if (safeStorage.isEncryptionAvailable()) {
+    encB64 = safeStorage.encryptString(value).toString("base64");
+  } else {
+    encB64 = Buffer.from(value, "utf-8").toString("base64");
+  }
+  store[name] = encB64;
+  writeStore(store);
+  return { ok: true };
+}
+
+module.exports = { getSecret, setSecret };

electron/lib/sessions.js

@@ -0,0 +1,857 @@
+// sessions.js —— 读取 / 解析 / 导出 / 备份 / 导入 Codex 会话记录。
+// 直接读 ~/.codex/sessions / archived_sessions 下的 rollout-*.jsonl，不依赖数据库，跨平台。
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const initSqlJs = require("sql.js");
+const { cleanThreadTitle, cleanUserVisibleText, stripInternalThoughtBlocks, looksLikeSkillMentionTitle } = require("./title_clean");
+const codexDataDir = require("./codex_data_dir");
+
+let permanentDeleteBusy = false;
+let clearAllBusy = false;
+const DEFAULT_LIST_LIMIT = 500;
+const ALL_LIST_LIMIT = 5000;
+
+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) {
+  const out = [];
+  function walk(dir) {
+    let ents;
+    try {
+      ents = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of ents) {
+      const full = path.join(dir, ent.name);
+      if (ent.isDirectory()) walk(full);
+      else if (ent.isFile() && ent.name.startsWith("rollout-") && ent.name.endsWith(".jsonl")) out.push(full);
+    }
+  }
+  walk(base);
+  return out;
+}
+
+// 读取 session_index.jsonl，得到 {会话id: Codex 生成的标题}
+function loadIndexTitles() {
+  const map = {};
+  try {
+    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] = cleanThreadTitle(d.thread_name, "", 80);
+      } catch {}
+    }
+  } catch {}
+  return map;
+}
+
+// 只读文件开头一段，快速取元信息与首条用户消息（避免整读大文件）
+function peekMeta(file) {
+  let head = "";
+  try {
+    const fd = fs.openSync(file, "r");
+    const buf = Buffer.alloc(262144); // 256KB：足够越过超长系统提示找到首条用户消息
+    const n = fs.readSync(fd, buf, 0, buf.length, 0);
+    fs.closeSync(fd);
+    head = buf.slice(0, n).toString("utf-8");
+  } catch {
+    return null;
+  }
+  const meta = { id: "", cwd: "", ts: "", source: "", threadSource: "", provider: "", title: "" };
+  const lines = head.split("\n");
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let d;
+    try {
+      d = JSON.parse(line);
+    } catch {
+      continue; // 可能是被截断的最后一行
+    }
+    const p = d.payload || {};
+    if (d.type === "session_meta") {
+      // 新版 subagent 的 session_id 指向父线程，id 才是当前子线程。
+      meta.id = p.id || p.session_id || "";
+      meta.cwd = p.cwd || "";
+      meta.ts = p.timestamp || d.timestamp || "";
+      meta.source = p.source || "";
+      meta.threadSource = p.thread_source || "";
+      meta.provider = p.model_provider || "";
+    } else if (d.type === "event_msg" && p.type === "user_message" && !meta.title) {
+      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;
+  }
+}
+
+// 清空全部 Codex 会话：删除 rollout 正文、状态库线程关联记录、桌面侧栏目录和会话索引。
+// 配置、登录态、项目、插件、自动化任务均保留；执行前由调用方保证 Codex 已完全退出。
+function deleteAllThreadLinkedRows(SQL, dbPath, { requireThreads = false } = {}) {
+  if (!fs.existsSync(dbPath)) return { changed: false, rows: 0 };
+  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 (requireThreads && !tables.includes("threads")) return { changed: false, rows: 0 };
+    db.run("PRAGMA foreign_keys=ON");
+    db.run("PRAGMA secure_delete=ON");
+    db.run("BEGIN");
+    let rows = 0;
+    const deferred = [];
+    for (const table of tables) {
+      // 自动化定义不是会话正文；即使它记录了 target_thread_id，也必须保留。
+      if (table === "automations") 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 linked = columns.filter((name) => /(^|_)(thread_id|parent_thread_id|child_thread_id)$/i.test(name));
+      const referencesThreads = fks
+        .filter((fk) => String(fk.table || "").toLowerCase() === "threads")
+        .map((fk) => String(fk.from || ""));
+      const targets = Array.from(new Set(linked.concat(referencesThreads))).filter(Boolean);
+      if (table === "threads") {
+        deferred.push(table);
+        continue;
+      }
+      for (const column of targets) {
+        db.run("DELETE FROM " + quoteIdent(table) + " WHERE " + quoteIdent(column) + " IS NOT NULL");
+        rows += db.getRowsModified();
+      }
+    }
+    if (tables.includes("threads")) {
+      db.run("DELETE FROM " + quoteIdent("threads"));
+      rows += db.getRowsModified();
+    }
+    db.run("COMMIT");
+    if (!rows) return { changed: false, rows: 0 };
+    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 清空会话后完整性校验失败，已停止替换");
+    }
+    replaceStateDb(dbPath, Buffer.from(db.export()));
+    return { changed: true, rows };
+  } catch (e) {
+    if (db) try { db.run("ROLLBACK"); } catch {}
+    throw e;
+  } finally {
+    if (db) try { db.close(); } catch {}
+  }
+}
+
+function copyIfExists(source, target) {
+  if (!fs.existsSync(source)) return false;
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const stat = fs.statSync(source);
+  if (stat.isDirectory()) {
+    fs.cpSync(source, target, { recursive: true, force: true });
+  } else {
+    fs.copyFileSync(source, target);
+  }
+  return true;
+}
+
+function pruneEmptyDirs(root) {
+  if (!fs.existsSync(root)) return;
+  let entries;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return; }
+  for (const entry of entries) {
+    if (entry.isDirectory()) pruneEmptyDirs(path.join(root, entry.name));
+  }
+  try {
+    if (!fs.readdirSync(root).length) fs.rmdirSync(root);
+  } catch {}
+}
+
+async function clearAllConversations() {
+  if (clearAllBusy) throw new Error("已有清空会话任务正在执行，请稍后重试");
+  clearAllBusy = true;
+  let backup = "";
+  const stagedDirs = [];
+  const copiedFiles = [];
+  try {
+    const { codexHome, sessionsDir, archivedSessionsDir, sessionIndex } = paths();
+    const rolloutFiles = sessionRoots().flatMap((root) => findRolloutFiles(root));
+    const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+    backup = path.join(codexHome, "backups_state", "session-clear", timestamp);
+    fs.mkdirSync(backup, { recursive: true });
+
+    // 会话正文用同盘 rename 暂存，不复制 700+ 个大 JSONL；清空成功后保留备份，便于恢复。
+    for (const [name, source] of [["sessions", sessionsDir], ["archived_sessions", archivedSessionsDir]]) {
+      if (!fs.existsSync(source)) continue;
+      const target = path.join(backup, name);
+      fs.renameSync(source, target);
+      stagedDirs.push({ source, target });
+      fs.mkdirSync(source, { recursive: true });
+    }
+    if (fs.existsSync(sessionIndex)) {
+      copyIfExists(sessionIndex, path.join(backup, "session_index.jsonl"));
+      copiedFiles.push([sessionIndex, path.join(backup, "session_index.jsonl")]);
+      fs.writeFileSync(sessionIndex, "", "utf-8");
+    }
+
+    for (const name of fs.readdirSync(codexHome)) {
+      if (!/^state_.*\.sqlite(?:-(?:wal|shm))?$/.test(name)) continue;
+      const source = path.join(codexHome, name);
+      const target = path.join(backup, name);
+      copyIfExists(source, target);
+      copiedFiles.push([source, target]);
+    }
+    const catalogDb = path.join(codexHome, "sqlite", "codex-dev.db");
+    for (const suffix of ["", "-wal", "-shm"]) {
+      const source = catalogDb + suffix;
+      if (!fs.existsSync(source)) continue;
+      const target = path.join(backup, "codex-dev.db" + suffix);
+      copyIfExists(source, target);
+      copiedFiles.push([source, target]);
+    }
+
+    const indexLines = copiedFiles.some(([source]) => source === sessionIndex)
+      ? fs.readFileSync(path.join(backup, "session_index.jsonl"), "utf-8").split("\n").filter((line) => line.trim()).length
+      : 0;
+    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 fs.readdirSync(codexHome).filter((item) => /^state_.*\.sqlite$/.test(item))) {
+      const result = deleteAllThreadLinkedRows(SQL, path.join(codexHome, name), { requireThreads: true });
+      stateRowsRemoved += result.rows;
+    }
+    const catalog = deleteAllThreadLinkedRows(SQL, catalogDb);
+    return {
+      ok: true,
+      filesRemoved: rolloutFiles.length,
+      indexEntriesRemoved: indexLines,
+      stateRowsRemoved,
+      catalogRowsRemoved: catalog.rows,
+      backup,
+    };
+  } catch (error) {
+    // 任一 SQLite/文件步骤失败，恢复正文目录、索引和数据库备份，避免半清空状态。
+    for (const [source, target] of copiedFiles) {
+      try {
+        if (fs.existsSync(target)) {
+          fs.mkdirSync(path.dirname(source), { recursive: true });
+          fs.copyFileSync(target, source);
+        }
+      } catch {}
+    }
+    for (const { source, target } of stagedDirs.reverse()) {
+      try {
+        fs.rmSync(source, { recursive: true, force: true });
+        if (fs.existsSync(target)) fs.renameSync(target, source);
+      } catch {}
+    }
+    throw error;
+  } finally {
+    clearAllBusy = 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, limit: DEFAULT_LIST_LIMIT };
+  const requestedLimit = Number(opts && opts.limit);
+  const limit = Number.isFinite(requestedLimit) && requestedLimit > 0
+    ? Math.min(Math.floor(requestedLimit), ALL_LIST_LIMIT)
+    : DEFAULT_LIST_LIMIT;
+  return {
+    includeSubagent: !!(opts && opts.includeSubagent),
+    includeArchived: !!(opts && opts.includeArchived),
+    limit,
+  };
+}
+
+// 列出会话（默认只列当前 sessions，并排除子 agent 派生线程；全量模式会带 archived_sessions）
+function listConversations(opts = {}) {
+  const { includeSubagent, includeArchived, limit } = normalizeListOptions(opts);
+  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) {
+    const files = findRolloutFiles(root.dir);
+    for (const file of files) {
+      const m = peekMeta(file);
+      if (!m) continue;
+      if (!includeSubagent && m.threadSource === "subagent") continue;
+      let size = 0;
+      try {
+        size = fs.statSync(file).size;
+      } catch {}
+      items.push({
+        id: m.id,
+        title: cleanThreadTitle(titles[m.id] || "", m.title, 80) || "(无标题对话)",
+        project: m.cwd ? path.basename(m.cwd) : "",
+        cwd: m.cwd,
+        ts: m.ts,
+        source: m.source,
+        threadSource: m.threadSource,
+        provider: m.provider,
+        path: file,
+        size,
+        archived: root.archived,
+      });
+    }
+  }
+  items.sort((a, b) => (b.ts || "").localeCompare(a.ts || ""));
+  return items.slice(0, limit);
+}
+
+// 解析单个会话文件为可读消息列表
+function readConversation(file) {
+  const messages = [];
+  let meta = {};
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf-8");
+  } catch (e) {
+    return { meta, messages, error: String(e) };
+  }
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    let d;
+    try {
+      d = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const p = d.payload || {};
+    const ts = d.timestamp || "";
+    if (d.type === "session_meta") {
+      meta = { id: p.id || p.session_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: cleanUserVisibleText(String(p.message || "")), ts });
+    } else if (d.type === "event_msg" && p.type === "agent_message") {
+      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 });
+    }
+  }
+  return { meta, messages };
+}
+
+// 导出为 Markdown 文本
+function toMarkdown(item, conv) {
+  const lines = [];
+  lines.push(`# ${item.title || "Codex 会话记录"}`);
+  lines.push("");
+  if (item.project) lines.push(`- 项目：${item.project}`);
+  if (item.cwd) lines.push(`- 目录：${item.cwd}`);
+  if (item.ts) lines.push(`- 时间：${item.ts}`);
+  if (item.provider) lines.push(`- Provider：${item.provider}`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const m of conv.messages) {
+    if (m.role === "user") lines.push(`## 👤 用户\n\n${m.text}\n`);
+    else if (m.role === "assistant") lines.push(`## 🤖 Codex\n\n${m.text}\n`);
+    else if (m.role === "tool") lines.push(`> 🔧 ${m.text}\n`);
+  }
+  return lines.join("\n");
+}
+
+// 备份：把 sessions/、archived_sessions/ 与索引复制到目标目录下的 codex-sessions-backup/
+function backupAll(destDir, log = () => {}) {
+  const out = path.join(destDir, "codex-sessions-backup");
+  fs.mkdirSync(out, { recursive: true });
+  let n = 0;
+  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);
+      const dst = path.join(out, name, rel);
+      fs.mkdirSync(path.dirname(dst), { recursive: true });
+      fs.copyFileSync(f, dst);
+      n++;
+    }
+  }
+  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 sourceRoot = resolveImportRoot(srcDir);
+  const { sessionsDir, archivedSessionsDir } = paths();
+  const roots = fs.existsSync(path.join(sourceRoot, "sessions"))
+    ? [
+        { base: path.join(sourceRoot, "sessions"), dest: sessionsDir },
+        { base: path.join(sourceRoot, "archived_sessions"), dest: archivedSessionsDir },
+      ]
+    : [{ base: sourceRoot, dest: sessionsDir }];
+  for (const root of roots) {
+    const files = findRolloutFiles(root.base);
+    for (const f of files) {
+      const rel = path.relative(root.base, f);
+      const dst = path.join(root.dest, rel);
+      if (fs.existsSync(dst)) {
+        skipped++;
+        continue;
+      }
+      fs.mkdirSync(path.dirname(dst), { recursive: true });
+      fs.copyFileSync(f, dst);
+      added++;
+    }
+  }
+  const indexMerged = mergeSessionIndex(path.join(sourceRoot, "session_index.jsonl"), paths().sessionIndex);
+  log(`导入完成：新增 ${added} 个，跳过 ${skipped} 个（已存在），合并索引 ${indexMerged} 条`);
+  return { added, skipped, indexMerged };
+}
+
+module.exports = {
+  getCodexHome: () => paths().codexHome,
+  getSessionsDir: () => paths().sessionsDir,
+  getArchivedSessionsDir: () => paths().archivedSessionsDir,
+  listConversations,
+  readConversation,
+  toMarkdown,
+  backupAll,
+  importSessions,
+  deleteConversation,
+  clearAllConversations,
+  findConversationById,
+  repairSkillMentionTitles,
+};

electron/lib/team-prompt.js

@@ -0,0 +1,293 @@
+// ============================================================================
+//  核心提示词工程 —— 整个产品的命门
+//  这段 System Prompt 决定了视觉模型"如何看图 + 输出什么结构的结果"。
+//  想提升效果，绝大多数时候是改这里，而不是改界面。
+// ============================================================================
+
+const SYSTEM_PROMPT = `You are a world-class visual analyst and prompt engineer. Your single job: look at an image and reverse-engineer the most effective text-to-image generation prompt that would let a modern model (Flux / 即梦 / 可灵 / SDXL 等自然语言生图模型) reproduce an image as close as possible to the original.
+
+# How to look (analyze systematically, do NOT skip a dimension)
+1. Subject 主体：who/what is the focus, count, pose, action, expression, clothing, key objects.
+2. Scene / environment 场景：location, background, foreground, time of day, weather, season.
+3. Style / medium 风格媒介：photography? 3D render? oil painting? anime? watercolor? pixel art? Name the concrete style and, if it clearly matches a well-known aesthetic, name it (e.g. cyberpunk, Ghibli-like, film photography, cinematic).
+4. Composition & camera 构图镜头：shot type (close-up / wide / bird's-eye / low-angle), framing, rule of thirds, symmetry, subject placement, aspect ratio if obvious.
+5. Lighting 光影：source & direction (backlight, rim light, soft light, hard light), golden hour, neon, studio, dramatic shadows.
+6. Color 色彩：palette, temperature (warm/cool), saturation, contrast, dominant colors, any grading (teal-orange, Morandi, pastel).
+7. Texture & detail 材质细节：skin texture, fabric, metal reflection, depth of field / bokeh, grain, sharpness.
+8. Technical cues 技术线索：if photographic — plausible lens/focal length, aperture, camera feel; if rendered — engine/render look (octane, unreal, cel-shading).
+9. Mood / atmosphere 氛围：the overall feeling the image conveys.
+
+# Rules that decide quality
+- The ENGLISH prompt is the primary deliverable — make it the most effective one. Modern T2I models are trained mostly on English; English gives the best results.
+- Write the English prompt as ONE flowing, natural, descriptive paragraph (natural-language style, NOT a bare comma-list). Front-load the most important elements (subject → style → composition → lighting → color → detail). Be concrete and specific; never rely on vague adjectives alone.
+- NEVER invent content that is not supported by the image. If something is uncertain, describe only what is actually visible. Do not hallucinate text, logos, or details you cannot see.
+- Provide a faithful Chinese translation that mirrors the English prompt one-to-one (same information, natural Chinese).
+- Provide a negative prompt: things a generator should AVOID to keep quality high and stay faithful (e.g. deformed hands, extra fingers, blurry, watermark, low-res, plus anything clearly absent from THIS image's style).
+- Provide a per-dimension breakdown so the user understands and can tweak individual aspects.
+- Provide a compact English keyword tag list (for users who prefer Midjourney-style comma prompts).
+- Give an honest confidence level about how faithfully the prompt can reproduce the original.
+
+# Output format — CRITICAL
+Return ONLY a single valid JSON object. No markdown, no code fences, no commentary before or after. Use exactly this schema:
+
+{
+  "prompt_en": "the primary English generation prompt, one rich natural-language paragraph",
+  "prompt_zh": "对应的中文提示词（与英文一一对应）",
+  "negative_prompt_en": "comma-separated things to avoid",
+  "negative_prompt_zh": "需要规避的内容（中文）",
+  "tags_en": ["keyword1", "keyword2", "..."],
+  "breakdown": [
+    { "label_zh": "主体", "label_en": "Subject", "value_zh": "中文描述", "value_en": "english description" },
+    { "label_zh": "风格", "label_en": "Style", "value_zh": "…", "value_en": "…" },
+    { "label_zh": "构图/镜头", "label_en": "Composition & Camera", "value_zh": "…", "value_en": "…" },
+    { "label_zh": "光影", "label_en": "Lighting", "value_zh": "…", "value_en": "…" },
+    { "label_zh": "色彩", "label_en": "Color", "value_zh": "…", "value_en": "…" },
+    { "label_zh": "材质/细节", "label_en": "Texture & Detail", "value_zh": "…", "value_en": "…" },
+    { "label_zh": "氛围", "label_en": "Mood", "value_zh": "…", "value_en": "…" }
+  ],
+  "confidence": "high | medium | low",
+  "notes_zh": "一句话给出复现建议或需要注意的地方"
+}`;
+
+// 用户消息里附带的文字指令（图片作为 image_url 一起发送）
+const USER_INSTRUCTION =
+  '请精准分析这张图片，反推出能复现它的生图提示词，严格按 System 里的 JSON schema 输出，只返回 JSON。';
+
+// ============================================================================
+//  员工团队生成 —— 分析客户需求，拆解出一支带约束的 AI agent 团队
+// ============================================================================
+
+// —— 通用工程协同规范（写死，保证每次生成都一致；会注入进每个 agent 的 prompt）——
+const TEAM_CONVENTIONS = {
+  // 每个 Agent 完成任务后必须固定输出的结构化报告
+  output_format: [
+    '变更摘要：一句话说明这次做了什么',
+    '修改文件：列出新增 / 修改 / 删除的文件路径',
+    '测试结果：跑了哪些测试、是否通过（贴关键输出）',
+    '风险与影响：可能波及的其他模块或接口',
+    '需要配合：需要哪个角色接手 / 确认，以及交接内容与格式',
+    '跨职责说明：为什么修改非本职责文件 / 影响哪个角色 / 需要谁复核 / 是否改动契约、数据库结构、安全策略、部署配置（无则写"无"）',
+  ],
+  // 任务的完成定义（基线，模型可追加项目特有项）
+  definition_of_done: [
+    'Lint / 类型检查通过',
+    '相关单元与集成测试通过',
+    '接口契约与文档同步更新',
+    '数据库迁移可回滚（有 up/down）',
+    'README / 变更说明已更新',
+    '跨职责修改已在报告中说明并获得对应 owner 复核',
+  ],
+  // Git / 职责归属规范（开放写权限模式：owner_paths 表达审核归属，不限制编辑）
+  git_rules: [
+    '开放写权限：所有执行角色技术上可改动项目内任意文件',
+    '跨职责（他人 owner_paths）修改必须在完成报告中说明并请对应 owner 复核',
+    '涉及接口契约 / 数据库结构 / 安全策略 / 部署配置的改动，必须提请对应 owner 与总控确认后合入',
+    '文件冲突或边界不清时，交总控 Agent 裁决',
+    '提交信息格式：type(scope): 摘要（如 feat(order): 新增下单接口）',
+    '一个任务对应一组内聚提交，便于审核与回滚',
+  ],
+  // 任务交接协议
+  handoff_protocol: [
+    '交接用结构化「交接单」传递：来源角色 / 目标角色 / 交接物 / 约定格式 / 验收点',
+    '接口相关交接必须附契约：路径、方法、入参、出参、错误码、分页、权限码',
+    '数据库变更交接必须附：变更说明、迁移脚本、回滚脚本、受影响表',
+    '接收方动工前先确认契约；有异议退回来源角色或总控，不擅自改契约',
+  ],
+  model_routing: [
+    '团队生成模型只用于把需求转换成角色与协作配置，不等于生成后总控或执行角色的运行模型',
+    '总控使用 orchestrator.model：负责需求拆解、架构设计、契约收敛、代码审计、安全审核、视觉验收与最终集成验收；总控不直接写业务代码',
+    '执行角色使用各自的 model：负责实现、测试、文档和明确授权范围内的修复；默认优先使用成本更低的执行模型',
+    '能力分流：需要识图、截图对比、视频理解、音频语义分析或视觉验收时，任务必须留在总控，或交给明确声明支持对应能力的模型',
+    '多模态任务完成后，总控只把结构化视觉证据、明确约束和验收标准交给执行角色，不把无法处理的原始图片/视频直接派给不支持多模态的模型',
+    '执行角色遇到视觉、视频、复杂架构、安全或跨职责问题，立即暂停并交总控裁决，不得假装已理解媒体内容',
+  ],
+};
+
+// 总控调度状态机
+const ORCHESTRATOR_WORKFLOW = [
+  '需求分析：澄清目标、边界与验收标准',
+  '能力分流：识别视觉 / 视频 / 音频 / 复杂审计任务，确认由总控处理，不派给不具备对应能力的执行模型',
+  '任务拆分：拆成可独立交付的小任务，标注负责角色与依赖关系',
+  '契约收敛：先让契约 owner 定稿接口契约（OpenAPI / DTO / 错误码 / 分页 / 权限码），各方确认',
+  '任务立契：分派前为每个任务产出《任务契约》（套 templates/task-charter.md），必须写明目标、可判定的验收标准、以及至少 2 条「明确不做（out of scope）」；写不出 out of scope 说明任务没想清楚，不得分派',
+  '分派执行：把任务连同《任务契约》、契约、DoD 一起分派给对应角色，并在 docs/coordination/task-ledger.md 登记为 assigned',
+  '进度跟踪：收集各角色的结构化产出报告，更新 task-ledger 状态',
+  '交叉审核：对照该任务《任务契约》审核——产出是否只落在目标内、是否命中 out of scope、契约一致性、安全与 DoD 达成情况',
+  '返工闭环：不达标的退回对应角色，打回理由必须引用《任务契约》或 DoD 的具体条款并写入 task-ledger；同一任务打回 ≥ 2 次时不再简单退回，改为重新澄清任务契约（判断是不是任务边界本身没定义清楚），避免无限返工',
+  '集成验收：全部满足 DoD 后做集成验证，仅当 task-ledger 状态为 accepted 才关闭任务，输出最终验收结论',
+];
+
+// 任务契约模板：领域无关的「目标边界」骨架。out of scope 由运行时总控按本次需求填，生成器不预设领域内容。
+const TASK_CHARTER = `# 任务契约 · <task-id>
+
+> 分派任何任务前由总控产出。它是「防跑飞」的依据：agent 每一步都对照此表，总控打回也引用此表的条款。
+
+- 负责角色：
+- 目标（一句话，可衡量）：
+- 验收标准（逐条可判定真假）：
+  - [ ]
+  - [ ]
+- 明确不做 / out of scope（至少 2 条；越界即视为跑飞）：
+  - 不改动 <某模块 / 某能力>
+  - 不新增 <与本任务无关的功能 / 承诺>
+  - 不重构 / 不顺手动 <现有某处>
+- 允许触碰的文件范围（本角色 owner_paths 的子集或明确列举）：
+- 依赖 / 前置（需要哪个角色先交付什么）：
+- 完成信号：产出 templates/acceptance-report.md 并经总控验收，task-ledger 置为 accepted
+
+---
+判定「跑飞」的通用标准（与领域无关）：agent 做的事若无法在本契约「目标」里找到依据，或命中「out of scope」，即为跑飞 —— 立即停下、写入 task-ledger、交总控裁决，不得自行扩大范围。
+`;
+
+// 安全 / 权限审核清单（涉及鉴权、RBAC、敏感数据时启用）
+const SECURITY_CHECKLIST = [
+  '越权访问：每个接口都校验身份与资源归属',
+  '水平越权：用户只能访问自己的数据（按 owner 过滤）',
+  '垂直越权：RBAC 权限码校验，前后端权限一致',
+  '敏感字段：密码 / 令牌 / 隐私字段不落日志、不明文返回',
+  '审计日志：关键操作留痕（谁 / 何时 / 做了什么）',
+  '会话 / 令牌：按项目选定的方案（JWT 或 HttpOnly Cookie）——设置过期、可注销失效、防重放',
+  '输入校验：所有外部输入做校验与转义，防注入（Web 另需防 XSS / CSRF）',
+];
+
+const EMPLOYEE_SYSTEM_PROMPT = `You are a senior technical lead and AI-agent team architect. The user gives you a project requirement in natural language. Design a COLLABORATING team of specialized AI agents ("employees") plus one orchestrator that could actually build and ship this project together.
+
+# ⚠️ PROJECT-AGNOSTIC — this is the #1 rule
+The project can be ANY kind: web app, mobile app, desktop app, CLI tool, backend service/API, data/ML pipeline, game, embedded/firmware, browser extension, library/SDK, automation script, smart-contract, etc. DO NOT assume it is a web app or Node/Next.js. Infer the RIGHT stack, roles, file layout, interfaces, CI commands and security concerns for the ACTUAL project and domain.
+Everything below that mentions REST / API / Next.js / NextAuth / npm is ONLY an ILLUSTRATIVE EXAMPLE for web projects — replace ALL of it with what THIS project truly needs (e.g. a Python data pipeline has no REST contract; a CLI has commands not endpoints; a Go service uses go test not npm; a mobile app has screens not pages).
+
+# Analyze
+1. Understand the real intent and the concrete, realistic tech stack (languages, frameworks, database, infra).
+   🔴 ARCHITECTURE COHERENCE: pick ONE coherent architecture. A full-stack framework (Next.js / Nuxt / SvelteKit) already provides the backend — do NOT also add a separate backend framework (NestJS / Express / Fastify) unless the requirement explicitly demands a separated service. If two apps are genuinely needed, give each a distinct root dir (e.g. apps/web, apps/api) with its own owner and start command, and state this split explicitly in contract_spec. Never list two overlapping frameworks in stack without defining their boundary.
+2. Decompose into a MINIMAL but COMPLETE set of specialized employees (usually 4-7): typically backend, frontend, database, testing, devops, and — whenever the project involves auth / permissions / RBAC / sensitive data — a dedicated security engineer. No redundant or vague roles.
+3. Design one orchestrator (总控) whose ONLY job is to break down tasks, converge the API contract, dispatch, review/audit, and drive acceptance. It does NOT write feature code.
+
+# Collaboration is the point — every agent must be designed to work WITH the others
+For EACH employee you MUST fill:
+- collaborators: the ids of the other agents it hands work to or receives work from.
+- handoff_in: what it receives from others and in what form.
+- handoff_out: what it produces for others and in what form (be concrete).
+
+Team-level you MUST decide — make the contract CONCRETE, not generic:
+- contract_owner: the id of the single role that OWNS the API contract (usually backend). Others must not change the contract unilaterally.
+- contract_spec: a CONCRETE contract for THIS project — unified response body with ALL fields (e.g. { code, message, data, requestId }), pagination shape (e.g. { items, page, pageSize, total, hasNext }), error-code table, RBAC permission codes, DTO conventions, and the auth scheme.
+- auth_scheme: if the project needs auth, ONE exact string (e.g. "Bearer JWT" | "NextAuth Credentials" | "HttpOnly session cookie" | "none"). It MUST appear verbatim in contract_spec and every auth-related agent prompt; env_vars must contain exactly that scheme's secrets (JWT→JWT_SECRET; NextAuth→NEXTAUTH_SECRET+NEXTAUTH_URL; cookie→SESSION_SECRET) and NO other scheme's vars. Never mix schemes.
+- package_manager: if the stack uses one, ONE value (npm|pnpm|yarn|pip|poetry|cargo|go|... ; else "none"). The install/build commands in ci_steps, the lockfile in devops owner_paths, and .gitignore MUST all match this one (npm→package-lock.json, pnpm→pnpm-lock.yaml, yarn→yarn.lock). Never mix npm with pnpm-lock etc.
+- interface_kind: what this project exposes — one of "rest" / "graphql" / "grpc" / "cli" / "library" / "gui" / "none". Drives the contract shape.
+- api_endpoints: ONLY if interface_kind is an API (rest/graphql/grpc) — the actual endpoint/RPC list, each { method, path, desc, owner }. For CLI describe commands, for library the public functions — put those in contract_spec instead and leave api_endpoints empty.
+- ci_steps: the ACTUAL commands to lint/test/build for THIS stack, in order (e.g. Node: ["npm ci","npm test","npm run build"]; Python: ["pip install -r requirements.txt","ruff check .","pytest"]; Go: ["go vet ./...","go test ./..."]; Rust: ["cargo test"]). This generates the CI — do NOT default to npm unless it's actually Node.
+- env_vars: a COMPLETE list of what THIS project needs, each { name, desc } (only if it has env/config; a pure library may have none). Cover DB/connection, auth/secrets, external services, storage, runtime — whatever fits the stack.
+- db_models: the main data entities IF the project has a datastore (may be empty for stateless tools).
+- security_checklist: project-specific security/permission checks (extend the standard ones for this project's sensitive areas).
+- dod_extra: any project-specific "definition of done" items (e.g. responsive breakpoints, safe Markdown/HTML rendering, draft/preview/publish, public-vs-admin boundary, search/tags/archive, migrations reversible).
+
+# Hard rules
+- Every agent MUST be constrained to work ONLY inside the current project scope. Always include such a constraint.
+- Focused, non-overlapping duties; concrete Chinese "prompt" (system instructions) per agent describing role, what it does, and its boundaries.
+- ALWAYS include a devops-engineer (CI / deploy / path-boundary enforcement / env / root config).
+
+# File-responsibility rules (owner_paths — 职责/审核归属, NOT an edit restriction; conflicts here break review attribution)
+- ⚠️ PERMISSION MODEL: every employee's allowed_paths is set by the SYSTEM to ["**"] (open write — any executor can technically edit any file in the project). Do NOT output allowed_paths for employees. What YOU output per role is owner_paths = the paths that role OWNS (职责归属：谁对这片文件负责、谁需要审核这片文件的改动).
+- owner_paths MUTUALLY EXCLUSIVE across roles: every path owned by exactly ONE role. Never let two roles list the same dir (only ONE role owns "prisma/", the DB schema, etc.).
+- NO NESTING across roles: no role's owner_path may be a parent of another role's owner_path. "src/app" (frontend) and "src/app/api" (backend) is a CONFLICT — the parent swallows the child.
+- CROSS-DUTY COLLABORATION: any executor MAY edit files under another role's owner_paths, but the completion report MUST state why it changed them / which role is affected / who must review / whether it touched the interface contract, DB schema, security policy or deploy config — and request the owner's review before merge.
+- 🔴 OWNER COVERAGE — be COMPREHENSIVE, not minimal: every file category the project will actually contain must have a review owner; 1-2 dirs per role is NOT enough. For the chosen stack, enumerate each role's FULL typical territory. Web/Next.js illustration (adapt to the real stack):
+  - backend: "src/app/api/**" + business layer ("src/server/**" or "src/lib/server/**") + auth ("src/lib/auth/**") + "src/middleware.ts" + shared server types.
+  - frontend: page groups + "src/components/**" + "src/styles/**" + "public/**" (static assets) + client libs it renders ("src/lib/client/**", feature libs like "src/lib/markdown/**") + layout/globals files.
+  - testing: "tests/**","__tests__/**", e2e dir ("playwright/**"), test configs ("playwright.config.*","vitest.config.*","vitest.setup.*","jest.config.*") + "src/test-utils/**".
+  - security: "security/**" + "docs/security/**" (threat model / audit reports live somewhere owned).
+  - devops: ".github/**","scripts/**", infra ("Dockerfile","docker-compose.*","docker/**","deploy/**") + ALL root configs including the lockfile matching package_manager, ".gitignore", build-tool configs ("postcss.config.*","prettier.config.*", etc.).
+  A config file that exists in the project but has NO owner = invalid output.
+- 🔴 FRAMEWORK ENTRY IS MANDATORY (this is NOT part of the "illustrative example you may discard"): every framework FIXES the physical location of its HTTP route entry, ORM models & migrations. You may organize business logic freely (clean-arch/layers), but you may NOT relocate or omit the framework's fixed entry paths. The backend/API role MUST own the exact entry path and put THIN handlers there (validate + auth + call the business layer, which lives in another path the SAME role owns). Frontend NEVER owns the API entry nor any parent that swallows it. If the stack has a framework below and no role owns its entry path, your output is INVALID.
+  Framework → fixed paths (owner):
+  - Next.js App Router: HTTP entry "src/app/api/**/route.ts" → backend; pages "src/app/(public)/**","src/app/(admin)/**","src/components/**","src/app/layout.tsx","src/app/globals.css" → frontend (NEVER "src/app/**").
+  - Next.js Pages Router: "src/pages/api/**" → backend; "src/pages/**" non-api → frontend.
+  - Nuxt3: "server/api/**","server/routes/**" → backend; "pages/**","components/**" → frontend.
+  - Django: "**/urls.py","**/views.py","*/settings.py","*/asgi.py" → backend; "**/models.py","**/migrations/**" → db; templates/static → frontend.
+  - Rails: "app/controllers/**","config/routes.rb" → backend; "app/models/**","db/migrate/**" → db; "app/views/**" → frontend.
+  - NestJS: "**/*.controller.ts" thin → backend. Spring Boot: "**/*Controller.java" → backend, "**/migration/**" → db.
+  - Vite SPA / Flutter / library / CLI: NO HTTP api dir — do NOT invent api routes; entry is index.html+src/main.* / lib/main.dart / the public API / the command layer.
+- 🔴 COLOCATION frameworks (SvelteKit / Remix / Astro) put UI and backend in the SAME route tree or SAME file — directory-level split is impossible. Do NOT fabricate fake sub-splits. Instead: (a) split by FILE-SUFFIX glob when possible — SvelteKit backend owns "src/routes/**/+server.ts" + "src/lib/server/**", frontend owns "src/routes/**/+page.svelte","+layout.svelte","+page.ts"; (b) if backend+UI share one file (Remix loader/action in app/routes/x.tsx), assign the whole feature folder to ONE owner and note it in that role's constraints. Always use glob suffix patterns (not bare dirs) so CODEOWNERS and the path-check script can tell them apart.
+- Consistent API prefix: pick ONE prefix for ALL endpoints (e.g. all under "/api/v1/…" OR all "/api/…") and use it everywhere in api_endpoints + contract_spec.
+- ROOT CONFIG files (package.json, tsconfig.json, next.config.*, tailwind.config.*, eslint config, .env.example, etc.) MUST be owned by exactly ONE role → give them to devops-engineer. Never leave them unowned (bootstrap always edits them).
+- devops-engineer owns ".github/", "scripts/", "infra/", docker/deploy files AND the root config files above.
+- security-engineer OWNS only its own files ("security/" or "docs/security"); it PROVIDES the checklist and reviews. Security TEST code is implemented by the testing/QA role (security keeps it in review_paths).
+- 🔴 OWNERSHIP COMPLETENESS (NOT part of the discardable illustrative example):
+  - If the project has a datastore (db_models non-empty OR the stack contains a DB/ORM), exactly ONE role must own that stack's schema + migration path (Prisma → "prisma/**"; Django → "**/migrations/**"; Rails → "db/**"; generic → "migrations/**"). If a dedicated database/data role EXISTS, the schema+migration paths MUST belong to that role — NEVER give them to backend as well (no duplicate claims). Only when there is no dedicated db role does that path go to the backend / contract_owner role.
+  - Exactly ONE role (usually devops-engineer) must own "README.md" and the TOP-LEVEL docs files "docs/*.md" (the collaboration-doc maintainer) — otherwise the DoD item "README / change notes updated" has no legal executor. NEVER give anyone broad "docs/**": role-specific doc subdirs (e.g. "docs/security/**" → security role, "docs/api/**" → backend) belong to their own roles, and a broad docs/** would swallow them AND the shared coordination zone.
+  - "docs/coordination/**" is the SHARED coordination area (handoff / acceptance / decision records that EVERY role writes to). Do NOT assign it to any single role and do NOT list it in any owner_paths — the boundary checker whitelists it globally, and CODEOWNERS explicitly clears its ownership.
+- SECURITY COLLABORATION: if a security-type role exists, every role in charge of auth / login / session / upload / permissions / RBAC (at least the backend role) MUST include it in collaborators, and the security role must list those roles back in its own collaborators.
+- If a role needs to REVIEW another's area beyond its own duty, put it in review_paths (read/audit focus), NOT owner_paths.
+- orchestrator: READ-ONLY — allowed_paths = [] AND owner_paths = [] (writes NO files, ever); review_paths = ["**"]. It only decomposes, dispatches, converges the contract, arbitrates and accepts.
+- ids: lowercase english, kebab-case, unique. 🔴 EVERY role reference — collaborators / contract_owner / api_endpoints[].owner AND any role name you write inside an agent's "prompt" text — MUST be an exact id from employees[].id. Do NOT invent a role name (e.g. don't write "qa-engineer" if the testing employee's id is "testing-engineer"). Decide each role's id ONCE and use that exact string everywhere.
+
+# Output — CRITICAL
+Return ONLY one valid JSON object, no markdown, no code fences.
+⚠️ The values below are a WEB-PROJECT EXAMPLE just to show the SHAPE — replace EVERY value with what THIS project actually is (roles, paths, interface_kind, ci_steps, contract, env, models must all fit the real stack/domain; a non-web project will look completely different).
+
+{
+  "project_name": "简短项目名",
+  "stack": ["按真实技术栈", "..."],
+  "summary": "一句话概括你对项目的理解",
+  "interface_kind": "rest | graphql | grpc | cli | library | gui | none",
+  "auth_scheme": "有鉴权才填的单一方案，如 Bearer JWT / NextAuth Credentials / HttpOnly session cookie / none",
+  "package_manager": "如 npm|pnpm|yarn|pip|poetry|cargo|go；无则 none",
+  "contract_owner": "某个角色 id（有对外契约时）",
+  "contract_spec": "本项目的契约/约定——Web 是响应体/分页/错误码/鉴权；CLI 是命令与参数约定；库是公开 API 与语义化版本；数据管道是输入输出 schema 与调度约定。按真实项目写。",
+  "api_endpoints": [
+    { "method": "GET", "path": "/api/v1/...", "desc": "仅当是 API 项目时填", "owner": "backend-engineer" }
+  ],
+  "ci_steps": ["按真实技术栈的 lint/测试/构建命令，如 go test ./... 或 pytest 或 npm test"],
+  "env_vars": [
+    { "name": "按真实项目", "desc": "有才写，纯库可为空" }
+  ],
+  "db_models": ["有数据存储才写，无状态工具可为空"],
+  "security_checklist": ["按本项目真实安全点（Web 是越权/XSS；CLI 是命令注入/密钥；固件是刷写签名…）"],
+  "dod_extra": ["本项目特有的完成标准（按真实项目，不要照搬 Web 博客那套）"],
+  "orchestrator": {
+    "id": "orchestrator",
+    "name": "总控 Agent",
+    "duty": "调度 + 契约收敛 + 审核 + 验收",
+    "responsibilities": ["职责点"],
+    "allowed_paths": [],
+    "review_paths": ["**"],
+    "constraints": ["仅在当前项目内工作", "只做调度与审核，不直接实现业务代码，不写入任何文件"],
+    "prompt": "总控的完整中文系统指令"
+  },
+  "employees": [
+    {
+      "id": "backend-engineer",
+      "name": "后端工程师",
+      "duty": "一句话职责",
+      "responsibilities": ["职责点"],
+      "owner_paths": ["src/server"],
+      "review_paths": ["src/db"],
+      "collaborators": ["frontend-engineer", "db-engineer"],
+      "handoff_in": "从数据库工程师接收表结构与迁移脚本",
+      "handoff_out": "向前端交付定稿的接口契约与联调地址",
+      "constraints": ["仅在当前项目内操作", "不擅自变更接口契约"],
+      "prompt": "该角色的完整中文系统指令"
+    }
+  ]
+}`;
+
+function buildEmployeeInstruction(requirement, tool) {
+  const toolNote =
+    tool === 'codex'
+      ? '目标工具是 Codex，总控 agent 专门负责调度、契约收敛与代码审核、不直接写业务代码。'
+      : tool === 'claude'
+      ? '目标工具是 Claude Code（员工对应 subagent）。'
+      : '生成通用的 agent 团队。';
+  return `${toolNote}\n\n客户的项目需求如下，请严格按 System 的 JSON schema 输出（只返回 JSON）：\n\n"""${requirement}"""`;
+}
+
+module.exports = {
+  SYSTEM_PROMPT,
+  USER_INSTRUCTION,
+  EMPLOYEE_SYSTEM_PROMPT,
+  buildEmployeeInstruction,
+  TEAM_CONVENTIONS,
+  ORCHESTRATOR_WORKFLOW,
+  TASK_CHARTER,
+  SECURITY_CHECKLIST,
+};

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,
+};

electron/lib/token_inject.js

@@ -0,0 +1,722 @@
+// token_inject.js —— 注入到 Codex 页面的 Token 用量 UI 脚本，以字符串形式导出。
+// 由 voice_cdp.js 经 CDP Runtime.evaluate 注入（复用语音 CDP 连接，无需独立端口）。
+//
+// 职责（仅 UI 层）：
+//   1. 在输入框下方工具栏内创建 token 用量条（优先放在模型选择左侧）
+//   2. 读写 localStorage["td-token-daily"]（按日期分桶，跨天自动清零）
+//   3. 暴露 window.__tdTokenAdd(usage) 给主进程调用来累加并触发动画
+//   4. 暴露 window.__tdTokenGet() / __tdTokenReset() 给主进程调用来读取/重置
+//   5. 页面内兜底解析 fetch/XHR usage 与 Codex DOM token 文本
+//
+// Token 抓取优先由 voice_cdp.js 在 CDP 层面通过 Network.responseReceived 完成，
+// 页面内 fetch/XHR 解析只作为兜底。
+//
+// 注意：脚本体用普通模板字符串包裹；内部避免出现 ${ 与裸反引号。
+
+const TOKEN_INJECT_SCRIPT = `
+(() => {
+  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", "td-token-style-v18"].forEach((id) => {
+    const el = document.getElementById(id);
+    if (el) el.remove();
+  });
+  window.__tdTokenInstalled = VER;
+
+  // ============================================================================
+  //  1. 持久化
+  // ============================================================================
+  const STORE_KEY = "td-token-daily";
+  function todayKey() {
+    const d = new Date();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return d.getFullYear() + "-" + m + "-" + day;
+  }
+  function loadDaily() {
+    try {
+      const raw = localStorage.getItem(STORE_KEY);
+      if (!raw) return blankDaily();
+      const d = JSON.parse(raw);
+      if (d.date !== todayKey()) return blankDaily();
+      return normalizeDaily(d);
+    } catch { return blankDaily(); }
+  }
+  function blankDaily() {
+    return { date: todayKey(), total: 0, input: 0, output: 0, cached: 0, estimate: 0, unknown: 0, lastSource: "" };
+  }
+  function cleanNum(n) {
+    n = Number(n);
+    return Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
+  }
+  function normalizeDaily(d) {
+    const out = blankDaily();
+    out.date = d && d.date ? d.date : todayKey();
+    out.input = cleanNum(d && d.input);
+    out.output = cleanNum(d && d.output);
+    out.cached = cleanNum(d && d.cached);
+    out.estimate = cleanNum(d && (d.estimate || d.estimated));
+    out.unknown = cleanNum(d && d.unknown);
+    out.total = cleanNum(d && d.total) || out.input + out.output + out.cached + out.estimate + out.unknown;
+    const known = out.input + out.output + out.cached + out.estimate + out.unknown;
+    if (out.total > known) out.unknown += out.total - known;
+    out.lastSource = String((d && (d.lastSource || d.source)) || "");
+    if (out.unknown && !out.lastSource) out.lastSource = "legacy";
+    return out;
+  }
+  function saveDaily(data) {
+    try { localStorage.setItem(STORE_KEY, JSON.stringify(normalizeDaily(data))); } catch {}
+  }
+  let daily = loadDaily();
+
+  // ============================================================================
+  //  2. 创建 UI
+  // ============================================================================
+  const BAR_ID = "td-token-bar";
+  const STYLE_ID = "td-token-style-v18";
+  const TOKEN_CAP = 5000000000;
+
+  if (!document.getElementById(STYLE_ID)) {
+    const st = document.createElement("style");
+    st.id = STYLE_ID;
+    st.textContent = \`
+      #td-token-bar{
+        display:inline-block;position:relative;
+        flex:0 0 auto;width:228px;max-width:32vw;height:28px;
+        margin:0 6px;padding:0;border-radius:999px;
+        font:11px system-ui,-apple-system,sans-serif;
+        user-select:none;-webkit-app-region:no-drag;
+        pointer-events:none;opacity:.96;transition:opacity .18s,filter .18s;
+        background:transparent;border:0;
+        vertical-align:middle;box-sizing:border-box;
+      }
+      #td-token-bar:hover{opacity:1;filter:saturate(1.08)}
+      .td-tk-track{
+        position:absolute;left:0;right:0;top:50%;height:28px;
+        border-radius:8px;transform:translateY(-50%);
+        background:#fff;overflow:hidden;
+        box-shadow:0 1px 0 rgba(255,255,255,.92) inset,0 0 0 1px rgba(15,23,42,.10),0 5px 16px rgba(15,23,42,.20);
+      }
+      .td-tk-segments{
+        position:absolute;left:18px;right:72px;top:50%;
+        display:grid;grid-template-columns:repeat(8,1fr);gap:3px;
+        height:12px;transform:translateY(-50%);
+      }
+      .td-tk-seg{
+        position:relative;overflow:hidden;border-radius:3px;transform:skewX(-7deg);
+        background:linear-gradient(180deg,rgba(138,217,255,.22),rgba(23,103,204,.22));
+        box-shadow:0 0 0 1px rgba(54,157,239,.18) inset;
+      }
+      .td-tk-seg::before{
+        content:"";position:absolute;left:0;top:0;bottom:0;width:var(--td-tk-seg-fill,0%);
+        border-radius:inherit;background:linear-gradient(180deg,#52c8ff 0%,#2673dd 58%,#1554c5 100%);
+        box-shadow:0 0 9px rgba(42,163,255,.72),0 1px 0 rgba(255,255,255,.45) inset;
+        transition:width .8s cubic-bezier(.25,.8,.25,1);
+      }
+      .td-tk-segments.beat .td-tk-seg::before{animation:tdTkBeat .55s ease}
+      .td-tk-segments::after{
+        content:"";position:absolute;left:-30px;top:-3px;bottom:-3px;width:24px;
+        pointer-events:none;opacity:0;border-radius:999px;
+        background:linear-gradient(90deg,transparent,rgba(255,255,255,.9),transparent);
+        transform:skewX(-12deg);
+      }
+      .td-tk-segments.beat::after{animation:tdTkSweep .7s ease}
+      .td-tk-segments.beat + .td-tk-badge{animation:tdTkBadgeBeat .62s ease}
+      @keyframes tdTkBeat{
+        0%{filter:brightness(1)}
+        45%{filter:brightness(1.26)}
+        100%{filter:brightness(1)}
+      }
+      @keyframes tdTkSweep{
+        0%{left:-30px;opacity:0}
+        18%{opacity:.9}
+        100%{left:calc(100% + 30px);opacity:0}
+      }
+      @keyframes tdTkBadgeBeat{
+        0%{transform:translateY(-50%) scale(1)}
+        45%{transform:translateY(-50%) scale(1.08);filter:brightness(1.18)}
+        100%{transform:translateY(-50%) scale(1)}
+      }
+      .td-tk-badge{
+        position:absolute;right:18px;top:50%;z-index:2;
+        display:inline-flex;align-items:center;gap:3px;height:18px;padding:0 7px 0 5px;
+        border-radius:7px;transform:translateY(-50%);
+        color:#fff;font-size:11px;font-weight:800;letter-spacing:0;white-space:nowrap;
+        background:linear-gradient(180deg,#63c8ff 0%,#2c77df 64%,#1f60c9 100%);
+        box-shadow:0 0 12px rgba(53,159,246,.75),0 1px 0 rgba(255,255,255,.45) inset;
+      }
+      .td-tk-check{
+        display:inline-flex;align-items:center;justify-content:center;width:12px;height:12px;
+        border-radius:50%;background:#fff;color:#266bd5;font-size:10px;line-height:1;
+      }
+      .td-tk-cap{
+        position:absolute;right:7px;bottom:4px;width:10px;height:12px;border-radius:3px 3px 4px 4px;
+        background:linear-gradient(180deg,#dcffff 0%,#61ddfb 100%);
+        box-shadow:0 0 8px rgba(82,222,255,.75);opacity:.95;
+      }
+      .td-tk-cap::before{
+        content:"";position:absolute;left:2px;right:2px;top:-3px;height:3px;border-radius:2px 2px 0 0;
+        background:#cfffff;
+      }
+      .td-tk-delta{
+        position:absolute;right:38px;top:-8px;z-index:3;
+        font-size:10px;font-weight:700;white-space:nowrap;color:#fff;
+        padding:1px 5px;border-radius:999px;background:#2b7ee7;
+        opacity:0;transform:translateY(2px);transition:none;
+      }
+      .td-tk-delta.show{
+        animation:tdTkDeltaIn 1.6s ease forwards;
+      }
+      @keyframes tdTkDeltaIn{
+        0%{opacity:0;transform:translateY(2px)}
+        20%{opacity:1;transform:translateY(0)}
+        85%{opacity:1;transform:translateY(0)}
+        100%{opacity:0;transform:translateY(-4px)}
+      }
+      @media (max-width:640px){#td-token-bar{width:186px;max-width:44vw;margin:0 4px}.td-tk-segments{left:14px;right:58px;gap:2px}.td-tk-badge{right:12px;font-size:10px;padding:0 5px;height:17px}.td-tk-cap{display:none}}
+      @media (prefers-color-scheme:dark){
+        .td-tk-track{background:#fff;box-shadow:0 1px 0 rgba(255,255,255,.92) inset,0 0 0 1px rgba(255,255,255,.2),0 5px 16px rgba(0,0,0,.36)}
+      }
+    \`;
+    (document.head || document.documentElement).appendChild(st);
+  }
+
+  function buildBar() {
+    const div = document.createElement("div");
+    div.id = BAR_ID;
+    div.innerHTML =
+      '<div class="td-tk-track"><div class="td-tk-segments" id="td-tk-segments">' +
+      '<i class="td-tk-seg"></i><i class="td-tk-seg"></i><i class="td-tk-seg"></i><i class="td-tk-seg"></i>' +
+      '<i class="td-tk-seg"></i><i class="td-tk-seg"></i><i class="td-tk-seg"></i><i class="td-tk-seg"></i>' +
+      '</div><span class="td-tk-badge"><span class="td-tk-check">✓</span><span id="td-tk-badge-text">0 token</span></span><span class="td-tk-cap"></span></div>' +
+      '<span class="td-tk-delta" id="td-tk-delta"></span>';
+    return div;
+  }
+
+  // ============================================================================
+  //  3. 格式化 + 颜色 + 渲染
+  // ============================================================================
+  function fmtTokens(n) {
+    if (n < 1000) return String(n);
+    if (n < 1000000) return (n / 1000).toFixed(1) + "K";
+    if (n < 1000000000) return (n / 1000000).toFixed(2) + "M";
+    return (n / 1000000000).toFixed(2) + "B";
+  }
+  function fmtBadgeTokens(n) {
+    n = cleanNum(n);
+    if (n < 1000) return n + " token";
+    if (n < 1000000) return (n / 1000).toFixed(1).replace(/\.0$/, "") + "k token";
+    if (n < 1000000000) return (n / 1000000).toFixed(1).replace(/\.0$/, "") + "M token";
+    return (n / 1000000000).toFixed(1).replace(/\.0$/, "") + "B token";
+  }
+  function fmtDelta(n) {
+    if (n < 1000) return "+" + n;
+    if (n < 1000000) return "+" + (n / 1000).toFixed(1) + "K";
+    if (n < 1000000000) return "+" + (n / 1000000).toFixed(2) + "M";
+    return "+" + (n / 1000000000).toFixed(2) + "B";
+  }
+
+  function fillColor(total) {
+    return "linear-gradient(180deg,#52c8ff 0%,#2673dd 58%,#1554c5 100%)";
+  }
+
+  function progressPct(total) {
+    total = cleanNum(total);
+    if (!total) return 0;
+    return Math.max(0.8, Math.min(100, (total / TOKEN_CAP) * 100));
+  }
+
+  // 5B 上限下，低于几十 MB 的线性变化肉眼几乎不可见；视觉分段采用对数映射，实际百分比仍保留在线程提示中。
+  function visualProgressPct(total) {
+    total = cleanNum(total);
+    if (!total) return 0;
+    const scale = 100000;
+    const pct = Math.log1p(total / scale) / Math.log1p(TOKEN_CAP / scale) * 100;
+    return Math.max(2.4, Math.min(100, pct));
+  }
+
+  function paintSegments(pct) {
+    const segs = Array.from(document.querySelectorAll(".td-tk-seg"));
+    if (!segs.length) return;
+    const span = 100 / segs.length;
+    segs.forEach((seg, i) => {
+      const start = i * span;
+      const fill = Math.max(0, Math.min(100, ((pct - start) / span) * 100));
+      seg.style.setProperty("--td-tk-seg-fill", fill + "%");
+    });
+  }
+
+  let beatTimer = null;
+  function triggerBeat() {
+    const segments = document.getElementById("td-tk-segments");
+    if (!segments) return;
+    render();
+    segments.classList.remove("beat");
+    void segments.offsetWidth;
+    segments.classList.add("beat");
+    clearTimeout(beatTimer);
+    beatTimer = setTimeout(() => {
+      segments.classList.remove("beat");
+    }, 650);
+  }
+
+  function render() {
+    daily = normalizeDaily(daily);
+    const bar = document.getElementById(BAR_ID);
+    const badge = document.getElementById("td-tk-badge-text");
+    const pct = visualProgressPct(daily.total);
+    paintSegments(pct);
+    if (badge) badge.textContent = fmtBadgeTokens(daily.total);
+    if (bar) {
+      bar.title = usageTitle(daily);
+    }
+  }
+
+  function usageTitle(d) {
+    d = normalizeDaily(d);
+    const parts = ["今日 " + fmtTokens(d.total), "额度 5B", "进度 " + progressPct(d.total).toFixed(4).replace(/0+$/,"").replace(/\\.$/,"") + "%"];
+    if (d.input) parts.push("输入 " + fmtTokens(d.input));
+    if (d.output) parts.push("输出 " + fmtTokens(d.output));
+    if (d.cached) parts.push("缓存 " + fmtTokens(d.cached));
+    if (d.estimate) parts.push("估算 " + fmtTokens(d.estimate));
+    if (d.unknown) parts.push("未知 " + fmtTokens(d.unknown));
+    if (d.lastSource) parts.push("来源 " + d.lastSource);
+    return parts.join(" · ");
+  }
+
+  // ============================================================================
+  //  4. 动画：主进程通过 Runtime.evaluate 调用此函数触发
+  // ============================================================================
+  let lastNetworkAt = 0;
+  let lastPageUsageAt = 0;
+  let estimatedSinceUsage = 0;
+  let recentRealAdds = [];
+  let lastSessionTotal = null;
+  function showDelta(total) {
+    const delta = document.getElementById("td-tk-delta");
+    if (!delta || total <= 0) return;
+    delta.textContent = fmtDelta(total);
+    delta.classList.remove("show");
+    void delta.offsetWidth;
+    delta.classList.add("show");
+  }
+  function normalizeUsagePayload(payload, source) {
+    if (typeof payload === "number" || typeof payload === "string") {
+      return { total: cleanNum(payload), input: 0, output: 0, cached: 0, estimate: 0, source: source || "manual" };
+    }
+    const u = payload && typeof payload === "object" ? payload : {};
+    const input = cleanNum(u.input || u.input_tokens || u.prompt_tokens || u.promptTokenCount || u.prompt_token_count || u.inputTokenCount);
+    const output = cleanNum(u.output || u.output_tokens || u.completion_tokens || u.candidatesTokenCount || u.candidates_token_count || u.outputTokenCount);
+    const reasoning = cleanNum(u.reasoning_tokens || u.thoughtsTokenCount || u.thoughts_token_count);
+    const cached = cleanNum(u.cached || u.cached_tokens || u.cache_creation_input_tokens || 0) +
+      cleanNum(u.cache_read_input_tokens || 0) +
+      cleanNum(u.cachedContentTokenCount || 0) +
+      cleanNum(u.cached_content_token_count || 0);
+    const estimate = cleanNum(u.estimate || u.estimated);
+    const unknown = cleanNum(u.unknown);
+    const total = cleanNum(u.total || u.total_tokens || u.totalTokenCount || u.total_token_count || u.token_count) || input + output + reasoning + cached + estimate + unknown;
+    return { total, input, output: output + reasoning, cached, estimate, unknown, source: String(source || u.source || "manual") };
+  }
+  function animateTokenAdd(payload, source) {
+    const usage = normalizeUsagePayload(payload, source);
+    if (usage.total <= 0) return;
+    const src = usage.source || "manual";
+    const now = Date.now();
+    if (src === "network" || src === "page") {
+      recentRealAdds = recentRealAdds.filter((item) => now - item.at < 15000);
+      if (recentRealAdds.some((item) => item.total === usage.total && item.source !== src)) return;
+      recentRealAdds.push({ total: usage.total, source: src, at: now });
+    }
+    if (src === "network") lastNetworkAt = now;
+    if (src === "page") lastPageUsageAt = now;
+    if (src === "dom" && (now - lastNetworkAt < 12000 || now - lastPageUsageAt < 12000)) return;
+    if (src === "page" && now - lastNetworkAt < 8000) return;
+    if (src === "network" || src === "page") {
+      daily = loadDaily();
+      const subtract = Math.min(estimatedSinceUsage || daily.estimate, daily.total);
+      if (subtract > 0) {
+        daily.total = Math.max(0, daily.total - subtract);
+        daily.estimate = Math.max(0, daily.estimate - subtract);
+        saveDaily(daily);
+        estimatedSinceUsage = 0;
+      }
+    }
+    daily = loadDaily();
+    daily.total += usage.total;
+    daily.input += usage.input;
+    daily.output += usage.output;
+    daily.cached += usage.cached;
+    daily.unknown += usage.unknown;
+    if (src === "estimate") {
+      const est = usage.estimate || usage.total;
+      daily.estimate += est;
+      estimatedSinceUsage += est;
+    }
+    daily.lastSource = src;
+    saveDaily(daily);
+    // 本地 session 已接管时，Network 只保留兜底记账，不重复播放动画。
+    if (lastSessionTotal === null || src === "session") triggerBeat();
+    const shouldShowDelta = src !== "estimate" && src !== "dom";
+    if (shouldShowDelta && (lastSessionTotal === null || src === "session")) showDelta(usage.total);
+  }
+
+  function usageTotal(u) {
+    return u ? cleanNum(u.total) : 0;
+  }
+  function betterUsage(a, b) {
+    return usageTotal(b) > usageTotal(a) ? b : a;
+  }
+  function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+  function looksLikeUsage(usage) {
+    if (!usage || typeof usage !== "object") return false;
+    const keys = [
+      "input_tokens", "prompt_tokens", "output_tokens", "completion_tokens", "total_tokens",
+      "promptTokenCount", "prompt_token_count", "inputTokenCount", "outputTokenCount",
+      "candidatesTokenCount", "candidates_token_count", "totalTokenCount", "total_token_count",
+      "token_count", "cache_creation_input_tokens", "cache_read_input_tokens",
+      "cachedContentTokenCount", "cached_content_token_count", "reasoning_tokens",
+      "thoughtsTokenCount", "thoughts_token_count"
+    ];
+    if (keys.some((key) => hasOwn(usage, key))) return true;
+    return hasOwn(usage, "total") && (hasOwn(usage, "input") || hasOwn(usage, "output") || hasOwn(usage, "cached"));
+  }
+  function extractUsageFromRawUsage(usage) {
+    if (!usage || typeof usage !== "object") return null;
+    if (!looksLikeUsage(usage)) return null;
+    const input = cleanNum(usage.input_tokens || usage.prompt_tokens || usage.promptTokenCount || usage.prompt_token_count || usage.inputTokenCount);
+    const output = cleanNum(usage.output_tokens || usage.completion_tokens || usage.candidatesTokenCount || usage.candidates_token_count || usage.outputTokenCount);
+    const reasoning = cleanNum(usage.reasoning_tokens || usage.thoughtsTokenCount || usage.thoughts_token_count);
+    const details = usage.input_tokens_details || usage.prompt_tokens_details || usage.inputTokenDetails || usage.promptTokenDetails || {};
+    const cached = cleanNum(details.cached_tokens) +
+      cleanNum(usage.cache_creation_input_tokens) +
+      cleanNum(usage.cache_read_input_tokens) +
+      cleanNum(usage.cachedContentTokenCount) +
+      cleanNum(usage.cached_content_token_count);
+    const total = cleanNum(usage.total_tokens || usage.totalTokenCount || usage.total_token_count || usage.token_count || usage.total) || input + output + reasoning + cached;
+    if (!total) return null;
+    return { total, input, output: output + reasoning, cached };
+  }
+  function extractUsageFromObject(obj) {
+    if (!obj || typeof obj !== "object") return null;
+    const direct = extractUsageFromRawUsage(obj.usage) ||
+      extractUsageFromRawUsage(obj.usage_metadata) ||
+      extractUsageFromRawUsage(obj.usageMetadata) ||
+      extractUsageFromRawUsage(obj);
+    if (direct) return direct;
+    let best = null;
+    for (const val of Object.values(obj)) {
+      if (!val || typeof val !== "object") continue;
+      if (Array.isArray(val)) {
+        for (const item of val) best = betterUsage(best, extractUsageFromObject(item));
+      } else {
+        best = betterUsage(best, extractUsageFromObject(val));
+      }
+    }
+    return best;
+  }
+
+  function extractUsageFromText(text) {
+    let best = null;
+    const take = (obj) => { best = betterUsage(best, extractUsageFromObject(obj)); };
+    try { take(JSON.parse(text)); } catch {}
+    const lines = String(text || "").split(String.fromCharCode(13)).join("").split(String.fromCharCode(10));
+    for (const line of lines) {
+      const s = line.trim();
+      if (!s.startsWith("data:")) continue;
+      const payload = s.slice(5).trim();
+      if (!payload || payload === "[DONE]") continue;
+      try { take(JSON.parse(payload)); } catch {}
+    }
+    return best;
+  }
+
+  function installNetworkFallback() {
+    if (window.__tdTokenNetFallbackInstalled === VER) return;
+    window.__tdTokenNetFallbackInstalled = VER;
+    const API_URL_RE = new RegExp("chat/completions|/responses|/messages|conversation|codex", "i");
+    const TEXT_CT_RE = new RegExp("json|text|event-stream", "i");
+    const rawFetch = window.fetch;
+    if (typeof rawFetch === "function") {
+      window.fetch = async function(...args) {
+        const res = await rawFetch.apply(this, args);
+        try {
+          const url = String((args[0] && args[0].url) || args[0] || "");
+          if (API_URL_RE.test(url)) {
+            const ct = (res.headers && res.headers.get && res.headers.get("content-type")) || "";
+            if (TEXT_CT_RE.test(ct)) {
+              res.clone().text().then((txt) => {
+                const usage = extractUsageFromText(txt);
+                if (usage && usage.total > 0) animateTokenAdd(usage, "page");
+              }).catch(() => {});
+            }
+          }
+        } catch {}
+        return res;
+      };
+    }
+    const XHR = window.XMLHttpRequest;
+    if (XHR && XHR.prototype) {
+      const rawOpen = XHR.prototype.open;
+      const rawSend = XHR.prototype.send;
+      XHR.prototype.open = function(method, url, ...rest) {
+        try { this.__tdTokenUrl = String(url || ""); } catch {}
+        return rawOpen.call(this, method, url, ...rest);
+      };
+      XHR.prototype.send = function(...args) {
+        try {
+          this.addEventListener("loadend", () => {
+            try {
+              const url = this.__tdTokenUrl || "";
+              const ct = this.getResponseHeader && (this.getResponseHeader("content-type") || "");
+              if (!API_URL_RE.test(url)) return;
+              if (!TEXT_CT_RE.test(ct)) return;
+              const txt = typeof this.responseText === "string" ? this.responseText : "";
+              const usage = extractUsageFromText(txt);
+              if (usage && usage.total > 0) animateTokenAdd(usage, "page");
+            } catch {}
+          });
+        } catch {}
+        return rawSend.apply(this, args);
+      };
+    }
+  }
+
+  function parseTokenText(text) {
+    const matches = String(text || "").matchAll(new RegExp("([0-9.,]+) *([KkMm]?) *tokens?", "gi"));
+    let best = 0;
+    for (const m of matches) {
+      let num = parseFloat(String(m[1]).replace(/,/g, ""));
+      if (!isFinite(num) || num <= 0) continue;
+      const unit = String(m[2] || "").toLowerCase();
+      if (unit === "k") num *= 1000;
+      else if (unit === "m") num *= 1000000;
+      best = Math.max(best, Math.round(num));
+    }
+    return best;
+  }
+
+  let domTokenBaseline = 0;
+  let domTokenBest = 0;
+  let domScanTimer = null;
+  function scanDomTokenText() {
+    const text = document.body ? document.body.innerText || "" : "";
+    const best = parseTokenText(text);
+    if (best <= 0) return;
+    if (!domTokenBaseline) {
+      domTokenBaseline = best;
+      domTokenBest = best;
+      return;
+    }
+    if (best > domTokenBest) {
+      const delta = best - domTokenBest;
+      domTokenBest = best;
+      if (delta > 0 && delta < 2000000) animateTokenAdd(delta, "dom");
+    }
+  }
+
+  function primeEstimateBaseline() {
+    const raw = document.body ? document.body.innerText || "" : "";
+    const best = parseTokenText(raw);
+    if (best > 0) {
+      domTokenBaseline = best;
+      domTokenBest = best;
+    }
+  }
+
+  function scheduleDomScan() {
+    clearTimeout(domScanTimer);
+    domScanTimer = setTimeout(() => {
+      scanDomTokenText();
+    }, 700);
+  }
+
+  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();
+  }
+
+  function findModelControl(toolbar) {
+    const controls = Array.from(toolbar.querySelectorAll("button, [role='button'], [aria-haspopup], [data-testid*='model'], [class*='model']"));
+    const modelLike = controls.find((el) => /model|模型|gpt|claude|codex|o[0-9]|gemini|deepseek|glm|kimi/i.test(visibleText(el)));
+    if (modelLike) return modelLike;
+    const buttons = Array.from(toolbar.querySelectorAll("button, [role='button']"));
+    return buttons.length > 1 ? buttons[buttons.length - 2] : buttons[0] || null;
+  }
+
+  function placeInToolbar(bar, toolbar) {
+    toolbar = toolbar || findToolbar();
+    if (!toolbar) return false;
+    const model = findModelControl(toolbar);
+    if (model && model.parentElement && toolbar.contains(model.parentElement)) {
+      model.parentElement.insertBefore(bar, model);
+    } else if (model && toolbar.contains(model)) {
+      toolbar.insertBefore(bar, model);
+    } else {
+      toolbar.appendChild(bar);
+    }
+    return true;
+  }
+
+  function mountBar() {
+    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);
+    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() {
+    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) => {
+      scheduleRelocate();
+      scheduleDomScan();
+    });
+    window.__tdTokenObserver = mo;
+    const root = document.body || document.documentElement;
+    if (root) mo.observe(root, { childList: true, subtree: true });
+    tryMount();
+    primeEstimateBaseline();
+    scheduleDomScan();
+  }
+  function ensureStarted() {
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", startObserver, { once: true });
+    } else {
+      startObserver();
+    }
+  }
+  ensureStarted();
+
+  // ============================================================================
+  //  7. 对外 API（主进程通过 Runtime.evaluate 调用）
+  // ============================================================================
+  window.__tdTokenAdd = (usage, source) => {
+    try {
+      const u = normalizeUsagePayload(usage, source || "external");
+      if (!u.total) return "bad";
+      animateTokenAdd(u, u.source);
+      return "ok";
+    } catch { return "err"; }
+  };
+  window.__tdTokenGet = () => {
+    const d = loadDaily();
+    return JSON.stringify(d);
+  };
+  window.__tdTokenSet = (usage) => {
+    try {
+      const next = normalizeUsagePayload(usage, "session");
+      const previousSessionTotal = lastSessionTotal;
+      lastSessionTotal = next.total;
+      daily = normalizeDaily({ ...next, date: todayKey(), lastSource: "session" });
+      saveDaily(daily);
+      render();
+      const delta = previousSessionTotal === null ? 0 : next.total - previousSessionTotal;
+      if (delta > 0) {
+        triggerBeat();
+        showDelta(delta);
+      }
+      return "ok";
+    } catch { return "err"; }
+  };
+  window.__tdTokenReset = () => {
+    daily = blankDaily();
+    estimatedSinceUsage = 0;
+    recentRealAdds = [];
+    lastSessionTotal = 0;
+    saveDaily(daily);
+    render();
+    return "ok";
+  };
+})();
+`;
+
+module.exports = { TOKEN_INJECT_SCRIPT };

electron/lib/token_usage.js

@@ -0,0 +1,187 @@
+// Read Codex's own cumulative token snapshots from ~/.codex/sessions.
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+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);
+  return Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
+}
+
+function dayKey(date = new Date()) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+function blank(date = dayKey()) {
+  return {
+    available: false,
+    date,
+    total: 0,
+    input: 0,
+    output: 0,
+    cached: 0,
+    reasoning: 0,
+    unknown: 0,
+    lastSource: "session",
+  };
+}
+
+function snapshotUsage(info) {
+  const u = info && typeof info === "object" ? info : {};
+  const input = clean(u.input_tokens || u.prompt_tokens || u.inputTokenCount || u.promptTokenCount);
+  const cached = clean(
+    u.cached_input_tokens ||
+      u.cache_read_input_tokens ||
+      u.cached_tokens ||
+      (u.input_tokens_details && u.input_tokens_details.cached_tokens)
+  );
+  const output = clean(u.output_tokens || u.completion_tokens || u.candidatesTokenCount);
+  const reasoning = clean(u.reasoning_output_tokens || u.reasoning_tokens || u.thoughtsTokenCount);
+  const total = clean(u.total_tokens || u.totalTokenCount || u.total) || input + output;
+  return { total, input, output, cached, reasoning };
+}
+
+function snapshotAt(line) {
+  let item;
+  try { item = JSON.parse(line); } catch { return null; }
+  if (item?.type !== "event_msg" || item?.payload?.type !== "token_count") return null;
+  const timestamp = new Date(item.timestamp);
+  if (!Number.isFinite(timestamp.getTime())) return null;
+  const usage = snapshotUsage(item.payload.info?.total_token_usage);
+  return usage.total > 0 ? { timestamp, usage } : null;
+}
+
+async function parseSessionFile(file) {
+  try {
+    const stat = await fsp.stat(file);
+    const cached = fileCache.get(file);
+    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 = [];
+    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, readAt: Date.now() });
+    return value;
+  } catch {
+    return { snapshots: [] };
+  }
+}
+
+function utcDatePath(date) {
+  return path.join(
+    SESSIONS_ROOT,
+    String(date.getUTCFullYear()).padStart(4, "0"),
+    String(date.getUTCMonth() + 1).padStart(2, "0"),
+    String(date.getUTCDate()).padStart(2, "0")
+  );
+}
+
+function sessionFilesForDay(start, end) {
+  const dirs = new Set();
+  for (const cursor = new Date(start); cursor < end; cursor.setDate(cursor.getDate() + 1)) {
+    dirs.add(utcDatePath(cursor));
+  }
+  dirs.add(utcDatePath(new Date(end.getTime() - 1)));
+  const files = [];
+  for (const dir of dirs) {
+    try {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isFile() && entry.name.endsWith(".jsonl")) files.push(path.join(dir, entry.name));
+      }
+    } catch {}
+  }
+  return files;
+}
+
+function delta(current, before) {
+  return Math.max(0, clean(current) - clean(before));
+}
+
+function readReset() {
+  try {
+    const value = JSON.parse(fs.readFileSync(RESET_PATH, "utf8"));
+    return value && typeof value === "object" ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function applyReset(value) {
+  const reset = readReset();
+  if (!reset || reset.date !== value.date) return value;
+  return {
+    ...value,
+    total: delta(value.total, reset.total),
+    input: delta(value.input, reset.input),
+    output: delta(value.output, reset.output),
+    cached: delta(value.cached, reset.cached),
+    reasoning: delta(value.reasoning, reset.reasoning),
+  };
+}
+
+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);
+  const result = blank(date);
+  result.available = fs.existsSync(SESSIONS_ROOT);
+
+  for (const file of sessionFilesForDay(start, end)) {
+    const snapshots = (await parseSessionFile(file)).snapshots;
+    let before = null;
+    let current = null;
+    for (const snapshot of snapshots) {
+      if (snapshot.timestamp < start) before = snapshot;
+      else if (snapshot.timestamp < end && (!current || snapshot.timestamp > current.timestamp)) current = snapshot;
+    }
+    if (!current) continue;
+    const b = before?.usage || {};
+    const u = current.usage;
+    result.total += delta(u.total, b.total);
+    result.input += delta(u.input, b.input);
+    result.output += delta(u.output, b.output);
+    result.cached += delta(u.cached, b.cached);
+    result.reasoning += delta(u.reasoning, b.reasoning);
+  }
+  return result;
+}
+
+async function readDaily(now = new Date()) {
+  return applyReset(await 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));
+}
+
+module.exports = {
+  readDaily,
+  reset,
+  _snapshotUsage: snapshotUsage,
+  _sessionFilesForDay: sessionFilesForDay,
+};

electron/lib/token_watch.js

@@ -0,0 +1,43 @@
+// token_watch.js —— Token 用量监控（对外的薄包装层）。
+// 注入脚本由 voice_cdp.js 在连接 Codex 时自动注入（与语音脚本同 session）。
+// 本模块暴露 status / reset 给 IPC handler 和前端面板。
+"use strict";
+const voice = require("./voice_cdp");
+const tokenUsage = require("./token_usage");
+
+function status() {
+  const snap = voice.status();
+  return {
+    phase: snap.phase,
+    date: "",
+    total: 0,
+  };
+}
+
+async function tokenStatus() {
+  try {
+    const snap = voice.status();
+    const page = await voice.tokenStatus();
+    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 };
+    }
+    return { ok: true, phase: snap.phase, connected: snap.phase === "connected", ...page };
+  } catch {
+    return { ok: false, error: "无法读取 token 用量（Codex 可能未连接）" };
+  }
+}
+
+async function tokenReset() {
+  try {
+    const local = await tokenUsage.reset();
+    const ok = await voice.tokenSet(local);
+    await voice.tokenReset();
+    return { ok: ok || true };
+  } catch {
+    return { ok: false, error: "无法重置" };
+  }
+}
+
+module.exports = { status, tokenStatus, tokenReset };

electron/lib/translate.js

@@ -0,0 +1,450 @@
+// translate.js —— Responses API ⇄ Chat Completions 协议转换。
+// 让只支持 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");
+}
+
+// content parts / string → 纯文本
+function partsToText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => {
+        if (typeof p === "string") return p;
+        if (p && (p.type === "input_text" || p.type === "output_text" || p.type === "text")) return p.text || "";
+        return "";
+      })
+      .join("");
+  }
+  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 || (t.function && t.function.name),
+        description: t.description || (t.function && t.function.description) || "",
+        parameters: params,
+      },
+    };
+  }
+  return null; // 托管型工具(web_search 等)无 chat 等价，先跳过
+}
+function toChatToolChoice(tc) {
+  if (typeof tc === "string") return tc;
+  if (tc && tc.type === "function" && tc.name) return { type: "function", function: { name: tc.name } };
+  return tc;
+}
+
+// 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 });
+  } else if (Array.isArray(input)) {
+    for (const item of input) {
+      const t = item.type;
+      if (t === "message" || (item.role && !t)) {
+        const role = item.role === "developer" ? "system" : item.role;
+        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 上游用不到)
+    }
+  }
+
+  const out = { model: overrideModel || req.model, messages, stream: req.stream !== false };
+  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;
+  if (req.parallel_tool_calls != null) out.parallel_tool_calls = req.parallel_tool_calls;
+  const eff = req.reasoning && req.reasoning.effort;
+  if (eff) out.reasoning_effort = eff;
+  if (out.stream) out.stream_options = { include_usage: true };
+  return out;
+}
+
+function mapUsage(u) {
+  if (!u) return null;
+  return {
+    input_tokens: u.prompt_tokens || 0,
+    input_tokens_details: { cached_tokens: (u.prompt_tokens_details && u.prompt_tokens_details.cached_tokens) || 0 },
+    output_tokens: u.completion_tokens || 0,
+    output_tokens_details: { reasoning_tokens: 0 },
+    total_tokens: u.total_tokens || 0,
+  };
+}
+
+// —— 响应：Chat Completions 流 → Responses 流事件（有状态转换器）——
+class ChatToResponses {
+  constructor(model) {
+    this.model = model;
+    this.responseId = genId("resp_");
+    this.msgId = genId("msg_");
+    this.seq = 0;
+    this.outIndex = 0;
+    this.msgOpen = false;
+    this.msgClosed = false;
+    this.msgRawText = "";
+    this.msgText = "";
+    this.msgOutputIndex = null;
+    this.tools = {}; // index → {id,name,arguments,outputIndex,closed}
+    this.usage = null;
+    this.started = false;
+    // 推理模型(DeepSeek-R1/v4、GLM、Kimi)的思考内容
+    this.reasonOpen = false;
+    this.reasonClosed = false;
+    this.reasonText = "";
+    this.reasonId = null;
+    this.reasonOutputIndex = null;
+  }
+  openReason() {
+    if (this.reasonOpen) return "";
+    this.reasonOpen = true;
+    this.reasonId = genId("rs_");
+    this.reasonOutputIndex = this.outIndex++;
+    let s = this.ev("response.output_item.added", {
+      output_index: this.reasonOutputIndex,
+      item: { id: this.reasonId, type: "reasoning", summary: [] },
+    });
+    s += this.ev("response.reasoning_summary_part.added", {
+      item_id: this.reasonId,
+      output_index: this.reasonOutputIndex,
+      summary_index: 0,
+      part: { type: "summary_text", text: "" },
+    });
+    return s;
+  }
+  closeReason() {
+    if (!this.reasonOpen || this.reasonClosed) return "";
+    this.reasonClosed = true;
+    let s = this.ev("response.reasoning_summary_text.done", {
+      item_id: this.reasonId,
+      output_index: this.reasonOutputIndex,
+      summary_index: 0,
+      text: this.reasonText,
+    });
+    s += this.ev("response.reasoning_summary_part.done", {
+      item_id: this.reasonId,
+      output_index: this.reasonOutputIndex,
+      summary_index: 0,
+      part: { type: "summary_text", text: this.reasonText },
+    });
+    s += this.ev("response.output_item.done", {
+      output_index: this.reasonOutputIndex,
+      item: { id: this.reasonId, type: "reasoning", summary: [{ type: "summary_text", text: this.reasonText }] },
+    });
+    return s;
+  }
+  ev(type, obj) {
+    const payload = Object.assign({ type, sequence_number: this.seq++ }, obj);
+    return `event: ${type}\ndata: ${JSON.stringify(payload)}\n\n`;
+  }
+  baseResponse(status, output) {
+    return {
+      id: this.responseId,
+      object: "response",
+      created_at: Math.floor(Date.now() / 1000),
+      status,
+      error: null,
+      incomplete_details: null,
+      instructions: null,
+      model: this.model,
+      output,
+      parallel_tool_calls: true,
+      previous_response_id: null,
+      reasoning: { effort: null, summary: null },
+      store: false,
+      temperature: 1.0,
+      text: { format: { type: "text" } },
+      tool_choice: "auto",
+      tools: [],
+      top_p: 1.0,
+      truncation: "disabled",
+      usage: this.usage,
+      metadata: {},
+    };
+  }
+  start() {
+    const r = this.baseResponse("in_progress", []);
+    return this.ev("response.created", { response: r }) + this.ev("response.in_progress", { response: r });
+  }
+  openMsg() {
+    if (this.msgOpen) return "";
+    this.msgOpen = true;
+    this.msgOutputIndex = this.outIndex++;
+    let s = this.ev("response.output_item.added", {
+      output_index: this.msgOutputIndex,
+      item: { id: this.msgId, type: "message", status: "in_progress", role: "assistant", content: [] },
+    });
+    s += this.ev("response.content_part.added", {
+      item_id: this.msgId,
+      output_index: this.msgOutputIndex,
+      content_index: 0,
+      part: { type: "output_text", text: "", annotations: [] },
+    });
+    return s;
+  }
+  closeMsg() {
+    if (!this.msgOpen || this.msgClosed) return "";
+    this.msgClosed = true;
+    let s = this.ev("response.output_text.done", {
+      item_id: this.msgId,
+      output_index: this.msgOutputIndex,
+      content_index: 0,
+      text: this.msgText,
+      logprobs: [],
+    });
+    s += this.ev("response.content_part.done", {
+      item_id: this.msgId,
+      output_index: this.msgOutputIndex,
+      content_index: 0,
+      part: { type: "output_text", text: this.msgText, annotations: [] },
+    });
+    s += this.ev("response.output_item.done", {
+      output_index: this.msgOutputIndex,
+      item: {
+        id: this.msgId,
+        type: "message",
+        status: "completed",
+        role: "assistant",
+        content: [{ type: "output_text", text: this.msgText, annotations: [] }],
+      },
+    });
+    return s;
+  }
+  onToolDelta(tc) {
+    let out = "";
+    const index = tc.index != null ? tc.index : 0;
+    const fn = tc.function || {};
+    let st = this.tools[index];
+    if (!st) {
+      out += this.closeReason(); // 先关推理
+      out += this.closeMsg(); // 再关文本消息，才开工具项
+      const callId = tc.id || "call_" + index;
+      st = { id: callId, name: fn.name || "", arguments: "", outputIndex: this.outIndex++, closed: false };
+      this.tools[index] = st;
+      out += this.ev("response.output_item.added", {
+        output_index: st.outputIndex,
+        item: { id: st.id, type: "function_call", status: "in_progress", call_id: st.id, name: st.name, arguments: "" },
+      });
+    } else if (fn.name) {
+      st.name += fn.name;
+    }
+    if (fn.arguments) {
+      st.arguments += fn.arguments;
+      out += this.ev("response.function_call_arguments.delta", {
+        item_id: st.id,
+        output_index: st.outputIndex,
+        delta: fn.arguments,
+      });
+    }
+    return out;
+  }
+  closeTool(st) {
+    if (st.closed) return "";
+    st.closed = true;
+    let s = this.ev("response.function_call_arguments.done", {
+      item_id: st.id,
+      output_index: st.outputIndex,
+      arguments: st.arguments,
+    });
+    s += this.ev("response.output_item.done", {
+      output_index: st.outputIndex,
+      item: { id: st.id, type: "function_call", status: "completed", call_id: st.id, name: st.name, arguments: st.arguments },
+    });
+    return s;
+  }
+  // 喂一个 chat 流 chunk（已解析的 JSON），返回要写给 Codex 的 Responses 事件串
+  onChunk(obj) {
+    let out = "";
+    if (!this.started) {
+      out += this.start();
+      this.started = true;
+    }
+    if (obj.usage) this.usage = mapUsage(obj.usage);
+    const choice = obj.choices && obj.choices[0];
+    if (!choice) return out;
+    const delta = choice.delta || {};
+    // 推理内容(reasoning_content)→ 思考事件
+    const rc = delta.reasoning_content || delta.reasoning;
+    if (rc) {
+      out += this.openReason();
+      this.reasonText += rc;
+      out += this.ev("response.reasoning_summary_text.delta", {
+        item_id: this.reasonId,
+        output_index: this.reasonOutputIndex,
+        summary_index: 0,
+        delta: rc,
+      });
+    }
+    if (delta.content) {
+      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);
+    }
+    return out;
+  }
+  finish() {
+    let out = "";
+    if (!this.started) {
+      out += this.start();
+      this.started = true;
+    }
+    out += this.closeReason();
+    out += this.closeMsg();
+    const sts = Object.values(this.tools).sort((a, b) => a.outputIndex - b.outputIndex);
+    for (const st of sts) out += this.closeTool(st);
+    const output = [];
+    if (this.reasonOpen)
+      output.push({ id: this.reasonId, type: "reasoning", summary: [{ type: "summary_text", text: this.reasonText }] });
+    if (this.msgOpen)
+      output.push({
+        id: this.msgId,
+        type: "message",
+        status: "completed",
+        role: "assistant",
+        content: [{ type: "output_text", text: this.msgText, annotations: [] }],
+      });
+    for (const st of sts)
+      output.push({ id: st.id, type: "function_call", status: "completed", call_id: st.id, name: st.name, arguments: st.arguments });
+    out += this.ev("response.completed", { response: this.baseResponse("completed", output) });
+    return out;
+  }
+}
+
+module.exports = { responsesToChat, ChatToResponses };

electron/lib/voice_inject.js

@@ -0,0 +1,819 @@
+// voice_inject.js —— 注入到 Codex 页面(app://-/index.html)的脚本，以字符串形式导出。
+// 由 voice_cdp.js 经 CDP Page.addScriptToEvaluateOnNewDocument(常驻) + Runtime.evaluate(立即) 注入。
+// 职责：在 .composer-footer 插麦克风按钮；点击录音→MediaRecorder 出 Blob→base64 经
+// window.__voiceBridge(CDP binding) 回传主进程转写→回传文字→execCommand('insertText') 写回 composer。
+// 写回手法参考 CodexPlusPlus 粘贴修复(renderer-inject.js 约第 8952 行)：document.execCommand('insertText', false, text)。
+
+// 注意：脚本体用普通模板字符串包裹；内部避免出现 ${（已无）与裸反引号（内部的模板字符串反引号需转义为 \`)。
+const INJECT_SCRIPT = `
+(() => {
+  const VER = "voice-inject-v13";
+  if (window.__voiceInjectInstalled === VER) return;
+  // 版本变了或首次：完整卸载旧实例，避免旧 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-v13";
+  let disposed = false;
+
+  // —— 样式 ——
+  if (!document.getElementById(STYLE_ID)) {
+    const st = document.createElement("style");
+    st.id = STYLE_ID;
+    st.textContent = \`
+      .codex-voice-input-btn{
+        display:inline-flex;align-items:center;justify-content:center;flex:none;
+        width:32px;height:32px;padding:0;border:0;border-radius:999px;
+        background:rgba(17,24,39,.04);color:var(--text-secondary,#6b7280);
+        cursor:pointer;line-height:1;transition:background .15s,color .15s,box-shadow .15s,transform .15s;
+        -webkit-app-region:no-drag;
+      }
+      .codex-voice-input-btn:hover{
+        background:rgba(17,24,39,.08);color:var(--text-primary,#111827);
+        box-shadow:0 1px 4px rgba(15,23,42,.08);
+      }
+      .codex-voice-input-btn:active{transform:scale(.96);}
+      .codex-voice-input-btn:focus-visible{outline:2px solid rgba(59,130,246,.55);outline-offset:2px;}
+      .codex-voice-input-btn .cv-ico{width:17px;height:17px;display:block;}
+      .codex-voice-input-btn .cv-ico svg{width:100%;height:100%;display:block;stroke:currentColor;}
+      .codex-voice-input-btn[data-state="recording"]{
+        background:rgba(239,68,68,.12);color:#ef4444;
+        animation:codexVoicePulse 1.1s ease-in-out infinite;
+      }
+      .codex-voice-input-btn[data-state="transcribing"]{background:rgba(59,130,246,.1);color:#2563eb;cursor:wait;}
+      .codex-voice-input-btn[data-state="transcribing"] .cv-ico{animation:codexVoiceSpin .8s linear infinite;}
+      .codex-voice-input-btn[data-state="error"]{background:rgba(239,68,68,.1);color:#dc2626;}
+      @media (prefers-color-scheme:dark){
+        .codex-voice-input-btn{background:rgba(255,255,255,.05);color:var(--text-secondary,#a1a1aa);}
+        .codex-voice-input-btn:hover{background:rgba(255,255,255,.1);color:var(--text-primary,#f4f4f5);box-shadow:none;}
+      }
+      @keyframes codexVoicePulse{0%,100%{box-shadow:0 0 0 0 rgba(239,68,68,.42)}50%{box-shadow:0 0 0 7px rgba(239,68,68,0)}}
+      @keyframes codexVoiceSpin{to{transform:rotate(360deg)}}
+      .codex-voice-toast{
+        position:fixed;left:50%;bottom:96px;transform:translateX(-50%);
+        background:rgba(24,24,27,.96);color:#f3f4f6;padding:9px 16px;border-radius:10px;
+        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;
+    document.body.appendChild(t);
+    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;
+  window.__voiceInjectHandle = (msg) => {
+    let p;
+    try {
+      p = typeof msg === "string" ? JSON.parse(msg) : msg;
+    } catch {
+      return;
+    }
+    const entry = pending.get(p.id);
+    if (!entry) return;
+    pending.delete(p.id);
+    if (p.err) entry.reject(new Error(p.err));
+    else entry.resolve(p.text || "");
+  };
+  function sendToBackend(audioB64, mime) {
+    const id = String(++seq);
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      if (typeof window.__voiceBridge !== "function") {
+        pending.delete(id);
+        reject(new Error("语音通道未就绪，请重新连接工具箱"));
+        return;
+      }
+      try {
+        window.__voiceBridge(JSON.stringify({ id, kind: "transcribe", audioB64, mime }));
+      } catch (e) {
+        pending.delete(id);
+        reject(e);
+      }
+    });
+  }
+
+  // —— 找底部输入工具栏：从编辑器往上找含 footer 的工具行容器 ——
+  function findToolbar() {
+    const rich = document.querySelector("DIV.ProseMirror, [contenteditable], textarea");
+    if (!rich) return null;
+    let p = rich;
+    for (let i = 0; i < 6 && 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;
+    }
+    return null;
+  }
+  function findEditor() {
+    return (
+      document.querySelector("DIV.ProseMirror") ||
+      document.querySelector("[contenteditable='true'],[contenteditable='']") ||
+      document.querySelector("textarea")
+    );
+  }
+
+  // —— 录音 ——
+  let mediaRecorder = null;
+  let activeStream = null;
+  let chunks = [];
+  let curBtn = null;
+  let stopTimer = null;
+
+  function setBtnState(btn, st) {
+    if (!btn) return;
+    btn.dataset.state = st || "";
+    const label =
+      st === "recording" ? "停止录音" :
+      st === "transcribing" ? "转写中…" :
+      st === "error" ? "语音输入出错" :
+      "语音输入";
+    const icon =
+      st === "recording"
+        ? '<svg viewBox="0 0 24 24" fill="none" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="8" y="8" width="8" height="8" rx="1.5"></rect></svg>'
+        : st === "transcribing"
+        ? '<svg viewBox="0 0 24 24" fill="none" stroke-width="2.3" stroke-linecap="round" aria-hidden="true"><path d="M12 3a9 9 0 1 1-8.2 5.3"></path></svg>'
+        : '<svg viewBox="0 0 24 24" fill="none" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 3a3 3 0 0 0-3 3v5a3 3 0 0 0 6 0V6a3 3 0 0 0-3-3Z"></path><path d="M19 10v1a7 7 0 0 1-14 0v-1"></path><path d="M12 18v3"></path><path d="M8 21h8"></path></svg>';
+    btn.innerHTML = '<span class="cv-ico">' + icon + '</span>';
+    btn.title = label;
+    btn.setAttribute("aria-label", label);
+  }
+
+  async function startRecording(btn) {
+    if (disposed) return;
+    if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+      toast("此环境不支持麦克风");
+      setBtnState(btn, "error");
+      return;
+    }
+    let stream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    } catch (e) {
+      const name = (e && e.name) || "";
+      if (name === "NotAllowedError" || name === "SecurityError") {
+        toast("麦克风被拒绝：系统设置 → 隐私 → 麦克风 → 允许 ChatGPT", 4200);
+      } else {
+        toast("无法访问麦克风：" + (e && e.message ? e.message : name));
+      }
+      setBtnState(btn, "error");
+      return;
+    }
+    curBtn = btn;
+    activeStream = stream;
+    chunks = [];
+    const mime = MediaRecorder.isTypeSupported("audio/webm")
+      ? "audio/webm"
+      : MediaRecorder.isTypeSupported("audio/mp4")
+      ? "audio/mp4"
+      : "";
+    try {
+      mediaRecorder = new MediaRecorder(stream, mime ? { mimeType: mime } : undefined);
+    } catch (e) {
+      toast("录音器初始化失败");
+      setBtnState(btn, "error");
+      stream.getTracks().forEach((t) => t.stop());
+      return;
+    }
+    mediaRecorder.ondataavailable = (e) => {
+      if (e.data && e.data.size) chunks.push(e.data);
+    };
+    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("未录到声音");
+        setBtnState(btn, "");
+        return;
+      }
+      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;
+        try {
+          const text = await sendToBackend(b64, mime || "audio/webm");
+          if (text) writeBack(text);
+          else toast("转写结果为空");
+        } catch (err) {
+          toast("转写失败：" + (err && err.message ? err.message : err), 4200);
+          setBtnState(btn, "error");
+          return;
+        }
+        setBtnState(btn, "");
+      };
+      reader.onerror = () => {
+        if (disposed) return;
+        toast("音频读取失败");
+        setBtnState(btn, "error");
+      };
+      reader.readAsDataURL(blob);
+    };
+    mediaRecorder.start();
+    setBtnState(btn, "recording");
+    stopTimer = setTimeout(() => stopRecording(), 60000);
+  }
+  function stopRecording() {
+    if (stopTimer) {
+      clearTimeout(stopTimer);
+      stopTimer = null;
+    }
+    if (mediaRecorder && mediaRecorder.state !== "inactive") {
+      try {
+        mediaRecorder.stop();
+      } catch {}
+    }
+  }
+
+  function writeBack(text) {
+    const ed = findEditor();
+    if (!ed) {
+      toast("未找到输入框，文字已无法填入", 3600);
+      return;
+    }
+    try {
+      ed.focus();
+    } catch {}
+    const inserted = document.execCommand("insertText", false, text);
+    if (!inserted) {
+      // 兜底：textarea / input 用 setRangeText
+      if (ed.tagName === "TEXTAREA" || ed.tagName === "INPUT") {
+        const s = ed.selectionStart || 0;
+        const e = ed.selectionEnd || 0;
+        const v = ed.value || "";
+        ed.value = v.slice(0, s) + text + v.slice(e);
+        const pos = s + text.length;
+        try {
+          ed.setSelectionRange(pos, pos);
+        } catch {}
+        ed.dispatchEvent(new Event("input", { bubbles: true }));
+      } else {
+        // contenteditable 兜底
+        try {
+          const sel = window.getSelection();
+          const range = sel && sel.rangeCount ? sel.getRangeAt(0) : null;
+          if (range) {
+            range.deleteContents();
+            range.insertNode(document.createTextNode(text));
+          }
+        } catch {}
+      }
+    }
+  }
+
+  function onBtnClick(btn) {
+    if (disposed) return;
+    if (mediaRecorder && mediaRecorder.state === "recording") {
+      stopRecording();
+      return;
+    }
+    startRecording(btn);
+  }
+
+  function makeButton() {
+    const b = document.createElement("button");
+    b.type = "button";
+    b.id = BTN_ID;
+    b.className = "codex-voice-input-btn";
+    b.setAttribute("aria-label", "语音输入");
+    b.addEventListener("click", (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      onBtnClick(b);
+    });
+    setBtnState(b, "");
+    return b;
+  }
+
+  // 在工具栏里找「发送按钮」：默认取工具栏最后一个 button（Codex 里发送在最右）。
+  // 新版 Codex 会把模型选择和发送按钮包在右侧 action 容器里，语音按钮要挂到
+  // 发送按钮的直接父容器，才能落在「模型选择」与「发送」之间。
+  function findSendButton(toolbar) {
+    const btns = toolbar.querySelectorAll("button, [role='button']");
+    if (!btns || !btns.length) return null;
+    return btns[btns.length - 1];
+  }
+
+  function containsNode(parent, child) {
+    return !!(parent && child && (parent === child || parent.contains(child)));
+  }
+
+  let firstMount = true;
+  function tryMount() {
+    if (disposed) return;
+    if (!firstMount && document.getElementById(BTN_ID)) return; // 已在，避免频繁重建丢焦点
+    firstMount = false;
+    const existing = document.getElementById(BTN_ID);
+    if (existing) existing.remove(); // 重新注入时刷新一次，确保新样式/位置
+    const toolbar = findToolbar();
+    if (!toolbar) { firstMount = true; return; } // 工具栏还没出来，下次再试
+    const sendBtn = findSendButton(toolbar);
+    const btn = makeButton();
+    const sendParent = sendBtn && sendBtn.parentElement;
+    if (sendParent && containsNode(toolbar, sendParent)) {
+      sendParent.insertBefore(btn, sendBtn); // 插在发送按钮前，保持在右侧 action 组内
+    } else {
+      toolbar.appendChild(btn);
+    }
+  }
+
+  // —— MutationObserver：composer/页面重建后重挂 ——
+  let mo = null;
+  function startObserver() {
+    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();
+})();
+`;
+
+module.exports = { INJECT_SCRIPT };

electron/lib/zip.js

@@ -0,0 +1,147 @@
+// zip.js —— 零依赖 ZIP 解压（stored/deflate），供技能安装与热更新复用。
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+
+// 解析中央目录，把 zip 内容写入 destDir；返回写出的文件数。
+function extractZip(buf, destDir) {
+  // 找 EOCD（0x06054b50），从尾部回扫
+  let eocd = -1;
+  for (let i = buf.length - 22; i >= 0 && i >= buf.length - 22 - 65536; i--) {
+    if (buf.readUInt32LE(i) === 0x06054b50) { eocd = i; break; }
+  }
+  if (eocd < 0) throw new Error("不是有效的 zip（找不到 EOCD）");
+  const count = buf.readUInt16LE(eocd + 10);
+  let ptr = buf.readUInt32LE(eocd + 16); // 中央目录起始偏移
+  let written = 0;
+  for (let n = 0; n < count; n++) {
+    if (buf.readUInt32LE(ptr) !== 0x02014b50) break;
+    const method = buf.readUInt16LE(ptr + 10);
+    const compSize = buf.readUInt32LE(ptr + 20);
+    const nameLen = buf.readUInt16LE(ptr + 28);
+    const extraLen = buf.readUInt16LE(ptr + 30);
+    const commentLen = buf.readUInt16LE(ptr + 32);
+    const localOff = buf.readUInt32LE(ptr + 42);
+    const name = buf.toString("utf8", ptr + 46, ptr + 46 + nameLen);
+    ptr += 46 + nameLen + extraLen + commentLen;
+    // 读本地头，定位数据
+    if (buf.readUInt32LE(localOff) !== 0x04034b50) continue;
+    const lNameLen = buf.readUInt16LE(localOff + 26);
+    const lExtraLen = buf.readUInt16LE(localOff + 28);
+    const dataStart = localOff + 30 + lNameLen + lExtraLen;
+    const comp = buf.subarray(dataStart, dataStart + compSize);
+    // 防目录穿越
+    const safe = name.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (safe.includes("../")) continue;
+    const outPath = path.join(destDir, safe);
+    if (safe.endsWith("/")) { fs.mkdirSync(outPath, { recursive: true }); continue; }
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    let data;
+    if (method === 0) data = comp;
+    else if (method === 8) data = zlib.inflateRawSync(comp);
+    else throw new Error(`不支持的压缩方式 ${method}`);
+    fs.writeFileSync(outPath, data);
+    written++;
+  }
+  return written;
+}
+
+// ---- 零依赖 ZIP 压缩（deflate/stored），供员工团队打包等复用 ----
+// CRC32 表（懒加载）
+let CRC_TABLE = null;
+function crc32(buf) {
+  if (!CRC_TABLE) {
+    CRC_TABLE = new Int32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+      CRC_TABLE[n] = c;
+    }
+  }
+  let crc = ~0;
+  for (let i = 0; i < buf.length; i++) crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ buf[i]) & 0xff];
+  return (~crc) >>> 0;
+}
+
+// MS-DOS 时间/日期（固定用一个合法值即可，不追求精确时间戳）
+function dosDateTime(d) {
+  const date = d || new Date();
+  const time = ((date.getHours() & 0x1f) << 11) | ((date.getMinutes() & 0x3f) << 5) | ((date.getSeconds() / 2) & 0x1f);
+  const day = (((date.getFullYear() - 1980) & 0x7f) << 9) | (((date.getMonth() + 1) & 0x0f) << 5) | (date.getDate() & 0x1f);
+  return { time: time & 0xffff, date: day & 0xffff };
+}
+
+// files: [{ path, content(string|Buffer), mode?(unix 权限，如 0o755) }]
+// 返回一个 zip 的 Buffer。目录靠文件路径里的 "/" 隐含，无需单独目录项。
+function createZip(files) {
+  const { time, date } = dosDateTime();
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const f of files) {
+    const nameBuf = Buffer.from(String(f.path).replace(/^\/+/, ""), "utf8");
+    const raw = Buffer.isBuffer(f.content) ? f.content : Buffer.from(String(f.content == null ? "" : f.content), "utf8");
+    const crc = crc32(raw);
+    // 尝试 deflate；若压不小就存储（method 0）
+    let method = 8;
+    let comp = zlib.deflateRawSync(raw, { level: 9 });
+    if (comp.length >= raw.length) { method = 0; comp = raw; }
+
+    // 本地文件头
+    const lh = Buffer.alloc(30);
+    lh.writeUInt32LE(0x04034b50, 0);
+    lh.writeUInt16LE(20, 4);            // version needed
+    lh.writeUInt16LE(0, 6);             // flags
+    lh.writeUInt16LE(method, 8);
+    lh.writeUInt16LE(time, 10);
+    lh.writeUInt16LE(date, 12);
+    lh.writeUInt32LE(crc, 14);
+    lh.writeUInt32LE(comp.length, 18);
+    lh.writeUInt32LE(raw.length, 22);
+    lh.writeUInt16LE(nameBuf.length, 26);
+    lh.writeUInt16LE(0, 28);           // extra len
+    locals.push(lh, nameBuf, comp);
+
+    // 中央目录项
+    const ch = Buffer.alloc(46);
+    // unix 权限写进外部属性高 16 位（低位保留），默认 0644，可执行给 0755
+    const unixMode = f.mode ? f.mode : 0o644;
+    const externalAttr = (unixMode << 16) >>> 0;
+    ch.writeUInt32LE(0x02014b50, 0);
+    ch.writeUInt16LE(0x031e, 4);       // version made by (unix)
+    ch.writeUInt16LE(20, 6);           // version needed
+    ch.writeUInt16LE(0, 8);            // flags
+    ch.writeUInt16LE(method, 10);
+    ch.writeUInt16LE(time, 12);
+    ch.writeUInt16LE(date, 14);
+    ch.writeUInt32LE(crc, 16);
+    ch.writeUInt32LE(comp.length, 20);
+    ch.writeUInt32LE(raw.length, 24);
+    ch.writeUInt16LE(nameBuf.length, 28);
+    ch.writeUInt16LE(0, 30);           // extra len
+    ch.writeUInt16LE(0, 32);           // comment len
+    ch.writeUInt16LE(0, 34);           // disk number
+    ch.writeUInt16LE(0, 36);           // internal attr
+    ch.writeUInt32LE(externalAttr, 38);
+    ch.writeUInt32LE(offset, 42);
+    centrals.push(ch, nameBuf);
+
+    offset += lh.length + nameBuf.length + comp.length;
+  }
+
+  const localPart = Buffer.concat(locals);
+  const centralPart = Buffer.concat(centrals);
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(0x06054b50, 0);
+  eocd.writeUInt16LE(0, 4);
+  eocd.writeUInt16LE(0, 6);
+  eocd.writeUInt16LE(files.length, 8);
+  eocd.writeUInt16LE(files.length, 10);
+  eocd.writeUInt32LE(centralPart.length, 12);
+  eocd.writeUInt32LE(localPart.length, 16); // central dir offset
+  eocd.writeUInt16LE(0, 20);
+  return Buffer.concat([localPart, centralPart, eocd]);
+}
+
+module.exports = { extractZip, createZip };

electron/preload.js

@@ -0,0 +1,178 @@
+// 契约边界（已冻结）：把主进程能力安全暴露给前端 window.api
+const { contextBridge, ipcRenderer } = require("electron");
+
+contextBridge.exposeInMainWorld("api", {
+  scanLocal: () => ipcRenderer.invoke("scan-local"),
+  pickDir: () => ipcRenderer.invoke("pick-dir"),
+  packLocal: (rels, destDir) => ipcRenderer.invoke("pack-local", { rels, destDir }),
+  upload: (rels, repo, token, isPrivate) =>
+    ipcRenderer.invoke("upload", { rels, repo, token, isPrivate }),
+  marketList: () => ipcRenderer.invoke("market-list"),
+  marketInstall: (entry) => ipcRenderer.invoke("market-install", { entry }),
+  // —— 技能商店（cocoloop 镜像）——
+  skillCatalog: () => ipcRenderer.invoke("skill-catalog"),
+  skillInstall: (skill) => ipcRenderer.invoke("skill-install", { skill }),
+  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: (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"),
+  hotConfirm: () => ipcRenderer.invoke("hot-confirm"),
+  hotRestart: () => ipcRenderer.invoke("hot-restart"),
+  onHotProgress: (cb) => {
+    const handler = (_e, p) => cb(p);
+    ipcRenderer.on("hot-progress", handler);
+    return () => ipcRenderer.removeListener("hot-progress", handler);
+  },
+  ghPull: (repoInput, token) => ipcRenderer.invoke("gh-pull", { repoInput, token }),
+  ghRestore: (rels, enable) => ipcRenderer.invoke("gh-restore", { rels, enable }),
+  getSecret: (name) => ipcRenderer.invoke("get-secret", { name }),
+  setSecret: (name, value) => ipcRenderer.invoke("set-secret", { name, value }),
+  openExternal: (url) => ipcRenderer.invoke("open-external", { url }),
+  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 }),
+  sessionsClearAll: () => ipcRenderer.invoke("sessions-clear-all"),
+  sessionExport: (item) => ipcRenderer.invoke("session-export", { item }),
+  sessionsBackup: () => ipcRenderer.invoke("sessions-backup"),
+  sessionsImport: () => ipcRenderer.invoke("sessions-import"),
+  // —— 会话记忆 ——
+  memoryStatus: () => ipcRenderer.invoke("memory-status"),
+  memoryList: (opts) => ipcRenderer.invoke("memory-list", opts),
+  memorySetEnabled: (enabled) => ipcRenderer.invoke("memory-set-enabled", { enabled }),
+  memoryToggleProject: (cwd, enabled) => ipcRenderer.invoke("memory-toggle-project", { cwd, enabled }),
+  memoryResummarize: (path) => ipcRenderer.invoke("memory-resummarize", { path }),
+  memoryDelete: (id) => ipcRenderer.invoke("memory-delete", { id }),
+  memoryOpenHandoff: (cwd) => ipcRenderer.invoke("memory-open-handoff", { cwd }),
+  onMemoryChanged: (cb) => {
+    const handler = () => cb();
+    ipcRenderer.on("memory-changed", handler);
+    return () => ipcRenderer.removeListener("memory-changed", handler);
+  },
+  providerSyncStatus: () => ipcRenderer.invoke("provider-sync-status"),
+  providerSync: () => ipcRenderer.invoke("provider-sync"),
+  onProviderSyncProgress: (cb) => {
+    const handler = (_e, p) => cb(p);
+    ipcRenderer.on("provider-sync-progress", handler);
+    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"),
+  routerRestoreClaude: () => ipcRenderer.invoke("router-restore-claude"),
+  routerSnippet: () => ipcRenderer.invoke("router-snippet"),
+  routerFetchModels: (baseUrl, key, groupId) => ipcRenderer.invoke("router-fetch-models", { baseUrl, key, groupId }),
+  // —— 接入 Claude 桌面 App ——
+  claudedeskStatus: () => ipcRenderer.invoke("claudedesk-status"),
+  claudedeskApply: (groupId) => ipcRenderer.invoke("claudedesk-apply", { groupId }),
+  claudedeskRestore: () => ipcRenderer.invoke("claudedesk-restore"),
+  claudedeskSnippet: (groupId) => ipcRenderer.invoke("claudedesk-snippet", { groupId }),
+  claudedeskExport: (groupId, format) => ipcRenderer.invoke("claudedesk-export", { groupId, format }),
+  onRouterChanged: (cb) => {
+    const handler = (_e, s) => cb(s);
+    ipcRenderer.on("router-changed", handler);
+    return () => ipcRenderer.removeListener("router-changed", handler);
+  },
+  // —— 创意画布（中转执行层）——
+  canvasStatus: () => ipcRenderer.invoke("canvas-status"),
+  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 || {}),
+  teamPack: (params) => ipcRenderer.invoke("team-pack", params || {}),
+  // —— 提示词提取（图片 → 反推生图提示词）——
+  promptGroups: () => ipcRenderer.invoke("prompt-groups"),
+  promptModels: (groupId) => ipcRenderer.invoke("prompt-models", { groupId }),
+  promptAnalyze: (params) => ipcRenderer.invoke("prompt-analyze", params || {}),
+  onCanvasProgress: (cb) => {
+    const h = (_e, p) => cb(p);
+    ipcRenderer.on("canvas-progress", h);
+    return () => ipcRenderer.removeListener("canvas-progress", h);
+  },
+  // —— Codex 语音输入注入（CDP 连 Codex，注入麦克风按钮）——
+  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) => {
+    const h = (_e, s) => cb(s);
+    ipcRenderer.on("voice-status", h);
+    return () => ipcRenderer.removeListener("voice-status", h);
+  },
+  // —— Token 用量监控（注入 Codex，复用 CDP 连接）——
+  tokenStatus: () => ipcRenderer.invoke("token-status"),
+  tokenReset: () => ipcRenderer.invoke("token-reset"),
+  // —— 全局 / 系统代理 ——
+  proxyStatus: () => ipcRenderer.invoke("proxy-status"),
+  proxyGetConfig: () => ipcRenderer.invoke("proxy-get-config"),
+  proxySetConfig: (cfg) => ipcRenderer.invoke("proxy-set-config", cfg),
+  proxyStart: (mode) => ipcRenderer.invoke("proxy-start", { mode }),
+  proxyStop: () => ipcRenderer.invoke("proxy-stop"),
+  proxyTest: () => ipcRenderer.invoke("proxy-test"),
+  onProxyChanged: (cb) => {
+    const handler = (_e, s) => cb(s);
+    ipcRenderer.on("proxy-changed", handler);
+    return () => ipcRenderer.removeListener("proxy-changed", handler);
+  },
+
+  // —— 检测 / 强制清除本机 Codex ——
+  codexDetect: () => ipcRenderer.invoke("codex-detect"),
+  codexPurge: (paths) => ipcRenderer.invoke("codex-purge", { paths }),
+
+  appVersion: () => ipcRenderer.invoke("app-version"),
+  checkUpdate: () => ipcRenderer.invoke("check-update"),
+  onUpdateStatus: (cb) => {
+    const handler = (_e, s) => cb(s);
+    ipcRenderer.on("update-status", handler);
+    return () => ipcRenderer.removeListener("update-status", handler);
+  },
+  onLog: (cb) => {
+    const handler = (_e, msg) => cb(msg);
+    ipcRenderer.on("log", handler);
+    return () => ipcRenderer.removeListener("log", handler);
+  },
+});

gen-image/.env.example

@@ -0,0 +1,14 @@
+# 大模型中转站 · OpenAI 图片接口生图配置
+#
+# 推荐：TD工具箱「中转」里勾选一个分组「用于 Codex 生图」，会自动写入本目录 .env。
+# 手动：复制本文件为 .env 并填入你自己的真实值。不要提交含真实 Key 的文件到 git。
+
+# 你自己的中转站基址（不要带 /v1/images/... 后缀，脚本会自动补全）
+# 例：https://api.your-relay.com
+IMAGE_API_BASE_URL=https://your-relay.com
+
+# 你自己的中转站 API Key
+IMAGE_API_KEY=sk-your-key-here
+
+# 默认生图模型（可用 --model 临时覆盖）
+IMAGE_MODEL=gpt-image-2

gen-image/.gitignore

@@ -0,0 +1,12 @@
+# 凭证，绝不提交
+.env
+
+# 生图输出
+output/
+
+# Python
+__pycache__/
+*.pyc
+
+# macOS
+.DS_Store

gen-image/AGENTS.md

@@ -0,0 +1,72 @@
+# AGENTS.md — 生图能力（供 Codex 等 Agent 自动读取）
+
+本目录是一个「生图」工具：通过大模型中转站调用 OpenAI 图片接口，生成位图图像。
+当用户表达以下意图时，**应主动调用本工具**，而不是自己画 SVG/HTML 或拒绝：
+
+- 「生成一张图 / 画一张 / AI 出图 / 做个头像·海报·封面·视频封面·标题图·插画·图标·壁纸」
+- 「文生图 / image generation / 做封面」
+- 给了一张图并说「基于它改 / 换背景 / 局部重绘」→ 图生图
+
+## 如何调用
+
+统一入口是**所加载技能目录**下的 `gen.sh`。先根据 `SKILL.md` 的所在目录解析 `<skill-root>`，执行 `<skill-root>/gen.sh`；不要在用户工作区用 `./gen.sh` 猜测路径，否则可能读到另一份 `.env`。
+
+```bash
+# 文生图（默认 1024x1024）
+"<skill-root>/gen.sh" "a fluffy orange cat on a windowsill, soft morning light, highly detailed"
+
+# 指定尺寸 / 画质 / 张数
+"<skill-root>/gen.sh" "cyberpunk city poster" --size 1536x1024 --quality high --n 2
+
+# 透明背景（图标 / 贴纸）
+"<skill-root>/gen.sh" "a minimalist mountain logo, flat vector" --background transparent
+
+# 图生图 / 编辑（用户提供了输入图）
+"<skill-root>/gen.sh" "把背景换成雪山日落" --edit /path/to/input.png
+
+# 局部重绘（mask PNG 中透明处 = 要重绘的区域）
+"<skill-root>/gen.sh" "戴上一顶红帽子" --edit input.png --mask mask.png
+```
+
+生成的图片保存在本目录 `output/`，命令会打印完整路径。把该路径告诉用户。
+
+## 参数速查
+
+| 需求 | 参数 |
+|------|------|
+| 方图（头像/图标） | `--size 1024x1024` |
+| 横图（海报/封面） | `--size 1536x1024` |
+| 竖图（壁纸/人像） | `--size 1024x1536` |
+| 透明背景 | `--background transparent` |
+| 画质 | `--quality low\|medium\|high\|auto` |
+| 多张挑选 | `--n 4` |
+| 换模型 | `--model dall-e-3` |
+| 图生图 | `--edit 图片路径`（可多次） |
+| 局部重绘 | `--edit 图.png --mask mask.png` |
+
+## 使用要点
+
+1. **提示词原样直传（最高优先级）**：被触发后，把用户这段话**原样**作为提示词——不改写、不扩写、不翻译、不加风格/光线/构图/画质词，尤其标题/文字一个字都别动。你只判断一件事：用户**是不是要生图**；是，就转发原话。图像模型自己懂自然语言，不需要你替它加工；多一次加工只会改坏用户要保留的内容（尤其标题）。唯一例外：用户**明确**说"帮我润色/扩写提示词"时才加工。
+2. **凭证（每人用自己的号）**：首次使用前若本目录无 `.env`，引导用户去 TD工具箱「中转」，给一个支持 OpenAI 图片接口的分组勾选「☑ 在 Codex 中用于生图」并保存——工具箱会自动把该分组的 base_url+密钥写进本技能 `.env`。无工具箱时改用 `cp .env.example .env` 手动填。之后脚本自动读取，无需在命令里传 key。**不要把 key 打印到对话里，也不要提交到 git。**
+3. **报错处理**：
+   - 401/403 → key 无效或额度不足（403 error 1010 是 WAF 拦截，脚本已带浏览器 UA 规避）。
+   - 404 → base_url 或接口路径不对。
+   - 400 model 相关 → 中转站不认该模型，换 `--model dall-e-3` 或问用户支持的模型名。
+4. 不适用：HTML 原型、幻灯片、矢量图标、图表可视化——那些应直接写代码，不要用本工具。
+
+## ⚠️ 带文字的封面 / 视频封面 / 海报（重点）
+
+「做个 B站/抖音视频封面」「带标题的海报」**整个任务就是一次生图调用**——不要拆成「生个背景图 + 自己用 SVG/HTML 画文字」两步，也不要自作主张补风格词。这是最常见的跑偏。
+
+正确做法：把**标题和用户原话原样**写进提示词，用横图尺寸，一次性出成品：
+```bash
+"<skill-root>/gen.sh" "B站视频封面图，标题是《从零搭建个人知识库》" --size 1536x1024 --quality high
+```
+- 不要在生图之后再用代码叠标题文字。
+- 不要给用户提示词擅自加 "neural network background / high contrast" 等用户没说的词。
+- 中文标题图像渲染常有错字/乱码，交付时如实告知用户；若标题出错，用图生图 `--edit` + `--mask` 局部重绘标题区，或建议用户缩短标题再试。
+
+## 前置条件
+
+- 需要 `python3`（macOS 自带，零第三方依赖）。
+- 首次使用需配置自己的中转站：在工具箱「中转」勾选一个分组「用于 Codex 生图」（自动写入本目录 `.env`），或手动 `cp .env.example .env` 填写。

gen-image/README.md

@@ -0,0 +1,44 @@
+# gen-image · 生图 Skill
+
+通过大模型中转站，直接调用 OpenAI 图片接口生图。文生图 / 图生图 / 局部重绘 / 透明背景，零第三方依赖。
+
+## 快速开始
+
+```bash
+# 1. 文生图
+./gen.sh "a cozy cabin in snowy mountains, golden hour, cinematic" \
+  --size 1536x1024 --quality high
+
+# 2. 图生图 / 编辑
+./gen.sh "把背景换成星空" --edit input.png
+
+# 3. 局部重绘（mask 透明处为重绘区域）
+./gen.sh "戴上一顶红帽子" --edit input.png --mask mask.png
+```
+
+图片保存到 `output/`，脚本打印完整路径。
+
+## 配置（每人用自己的中转站账号）
+
+**TD工具箱用户（推荐）：** 在工具箱「中转」里，给一个支持 OpenAI 图片接口的中转分组勾选 **☑ 在 Codex 中用于生图** 并保存——工具箱自动把该分组的 base_url+密钥写进本技能的 `.env`，无需手动配置。重装技能后工具箱会自动重写。
+
+**手动方式（无工具箱）：** `cp .env.example .env`，填三项：
+
+| 变量 | 说明 |
+|------|------|
+| `IMAGE_API_BASE_URL` | 你的中转站基址，如 `https://api.xxx.com`（自动补 `/v1/images/...`） |
+| `IMAGE_API_KEY` | 你的中转站 API Key |
+| `IMAGE_MODEL` | 默认模型，默认 `gpt-image-2`，可用 `--model` 覆盖 |
+
+读取优先级：**环境变量 > skill 目录 `.env`**。CI/临时场景可直接 `export IMAGE_API_KEY=...`。
+
+## 参数
+
+`--size` `--n` `--quality` `--background transparent` `--edit`(可多次) `--mask` `--model` `--output`
+详见 `python3 scripts/gen_image.py --help` 与 `SKILL.md`。
+
+## 安全
+
+- 凭证存在本技能目录的 `.env`（工具箱写入时权限 600），已被 `.gitignore` 忽略，不进 git。
+- 分发包只含 `.env.example` 模板，绝不含真实 Key。
+- 切勿把 API Key 写进代码、日志或对话。

gen-image/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: gen-image
+description: 调用大模型中转站的 OpenAI 图片接口生图（文生图、图生图/编辑、局部重绘、透明背景）。触发词：生图、生成图片、画一张、AI 画图、文生图、图生图、生成插画/头像/海报/封面/视频封面/标题图/图标、image generation、根据这张图改、做封面。需要外部 API 生成位图图像时使用；纯 HTML/SVG/矢量设计不适用。
+---
+
+# gen-image · 生图
+
+通过大模型中转站，直接调用 OpenAI 图片接口生成位图图像。支持**文生图**、**图生图/编辑**、**局部重绘（mask）**、**透明背景**。
+
+核心是零依赖脚本 `scripts/gen_image.py`（纯 Python 标准库，无需 pip install）。
+
+> **核心原则 · 原话直传（最高优先级，覆盖下方一切"打磨/扩写"措辞）。** 被触发后，把用户这段话**原样**作为提示词传给脚本——不改写、不扩写、不翻译、不加风格/构图/画质关键词。你只需要判断一件事：用户**是不是要生图**；是，就转发原话。用户没说的风格，不要替他编；用户给的标题/文字，一个字都不要动。只有当用户**明确**说"帮我润色/扩写提示词"时才加工。理由：图像模型本身懂自然语言，外面这层多一次"加工"只会改坏用户要保留的内容（尤其标题）、并让产出不可控。
+
+
+## 何时用 / 不用
+
+- ✅ 用户要「生成一张图 / 画一张 / AI 出图 / 做个头像/海报/插画/图标」
+- ✅ 用户给了一张图要「基于它改 / 换背景 / 局部重绘」→ 图生图
+- ❌ 用户要 HTML 原型、幻灯片、矢量图标、CSS 效果 → 用 `huashu-design` 或直接写代码
+- ❌ 用户要图表/数据可视化 → 用 `dataviz`
+
+## ⚠️ 带文字的封面 / 海报 / 标题图（重点）
+
+用户说「做个 **B站/抖音/视频封面**」「**带标题的海报**」「封面 + 标题是 XXX」时，**整个任务就是一次生图调用**——不要拆成「生个背景图 + 我自己用 SVG/HTML 把文字画上去」两步。正确做法是一条命令把标题写进提示词、整张图让模型一起生成。
+
+**正确流程：**
+1. 把用户给的**标题原文原样**写进提示词，连同用户说的其它要求一起原话直传——不要自己补风格/背景词。
+2. 尺寸默认用横图 `--size 1536x1024`（视频封面标配）；用户指定了其它比例则照用户的。
+3. 一次性运行所加载技能目录的 `gen.sh`，如 `"<skill-root>/gen.sh" "原话提示词" --size 1536x1024 --quality high` 出成品。**不要**在用户工作区用 `./gen.sh` 猜测路径，也不要后续用代码去叠文字。
+4. 中文标题风险**如实告诉用户**再交付：图像模型渲染中文常有错字/乱码，建议用户验收后若文字有误，用「图生图 + 局部重绘」把标题区域 mask 掉重画，或改用极短标题。
+
+**示例：** 用户说「帮我生成一个 B 站视频封面图，标题是《从零搭建个人知识库》」。
+✅ 正确（原话直传，用户没说的不编）：
+```bash
+"<skill-root>/gen.sh" "B站视频封面图，标题是《从零搭建个人知识库》" --size 1536x1024 --quality high
+```
+❌ 错误（不要自己补词，更不要拆成两步）：给用户的提示词擅自加上 "neural network background / high contrast / eye-catching" 等用户没说的风格词；或者先 `./gen.sh "某背景"` 生成背景图、再用 SVG/HTML 自己去拼中文标题——这两种都是 agent 自行发挥，必须避免。
+
+> 反面案例：曾出现「用户要 B 站封面，agent 却只生成一张背景图、标题自己画」「agent 擅自给用户提示词加一堆风格词」两种跑偏，根因都是 agent 多做了"加工"。记住：**被触发即原话直传**。
+
+## 首次使用：配置凭证（每个用户用自己的中转站账号）
+
+生图需要**用户自己的**中转站地址和 API Key（各自的号、各付各费）。这个技能**不内置任何 key**。
+
+第一次生图前，检查是否已配置：
+
+```bash
+test -f "$(dirname "$0")/.env" && echo "已配置" || echo "未配置"
+```
+
+**推荐方式（TD工具箱用户）：** 在工具箱「中转」里，给一个支持 OpenAI 图片接口的中转分组，勾选 **☑ 在 Codex 中用于生图** 并保存——工具箱会自动把该分组的 `base_url` + 密钥写进本技能的 `.env`。用户全程不碰配置文件。若用户还没勾，就引导他去「中转」勾一下。
+
+**手动方式（无工具箱时）：** 从模板建 `.env` 并让用户填自己的中转信息（**不要把 key 写进对话或提交 git**）：
+
+```bash
+cp .env.example .env
+# 编辑 .env，填 IMAGE_API_BASE_URL 和 IMAGE_API_KEY
+```
+
+`.env` 三项：
+- `IMAGE_API_BASE_URL` — 用户自己的中转站基址，如 `https://api.xxx.com`（脚本自动补 `/v1/images/...`）
+- `IMAGE_API_KEY` — 用户中转站的 API Key
+- `IMAGE_MODEL` — 默认模型，默认 `gpt-image-2`
+
+读取优先级：**环境变量 > skill 目录 `.env`**。CI/临时场景可直接 `export IMAGE_API_KEY=...`。
+注意：工具箱重装本技能会清空目录，但装完会**按「中转」里勾选的分组自动重写 `.env`**，无需手动恢复。
+
+## 标准流程
+
+**1. 提示词原样直传。** 用户这段描述**原封不动**作为提示词。不要扩写、不要翻译、不要加风格/光线/构图/画质词——尤其用户给的标题或文字，一个字都不要改。你只做一件翻译判断：用户**是否在要生图**；要，就转发原话。图像模型自己懂自然语言，不需要你替它"加工"。（唯一例外：用户**明确**要求"帮我润色/扩写提示词"时才加工。）
+
+**2. 选参数：**
+- `--size`：`1024x1024`（方，头像/图标）、`1536x1024`（横，海报/封面）、`1024x1536`（竖，手机壁纸/人像）、`auto`
+- `--quality`：`low`/`medium`/`high`/`auto`（gpt-image 系支持；越高越慢越贵）
+- `--background transparent`：要透明底的图标/贴纸时加
+- `--n`：一次出几张（默认 1；多给几张让用户挑时用 `--n 2` 或 `4`）
+
+**3. 执行（文生图）：**
+
+```bash
+cd "<skill 根目录>" && python3 scripts/gen_image.py \
+  "a fluffy orange tabby cat on a windowsill, soft morning light, cozy tones, highly detailed" \
+  --size 1024x1024 --quality high
+```
+
+图片存到 `output/img-<时间戳>-<序号>.png`，脚本会打印完整路径。
+
+**4. 图生图 / 编辑**（用户给了输入图）：
+
+```bash
+python3 scripts/gen_image.py "把背景换成雪山日落" --edit /path/to/input.png --size 1024x1024
+```
+
+多图参考：多次 `--edit a.png --edit b.png`。局部重绘：加 `--mask mask.png`（PNG 中**透明区域**为要重绘的部分，其余保留）。
+
+**5. 交付。** 打印出保存路径后，简要告诉用户生成了什么、存在哪。图无法在终端直接显示，用户会自己打开；若在支持预览的环境可提示路径。
+
+## 常见参数速查
+
+| 需求 | 命令片段 |
+|------|---------|
+| 头像/图标（方图） | `--size 1024x1024` |
+| 海报/封面（横） | `--size 1536x1024` |
+| 手机壁纸/人像（竖） | `--size 1024x1536` |
+| 透明背景贴纸 | `--background transparent` |
+| 多出几张挑选 | `--n 4` |
+| 高画质 | `--quality high` |
+| 换模型 | `--model dall-e-3` |
+| 基于图改 | `--edit input.png` |
+| 局部重绘 | `--edit input.png --mask mask.png` |
+
+## 排错
+
+- **缺 IMAGE_API_BASE_URL / IMAGE_API_KEY** → 还没配置。让用户去工具箱「中转」勾选一个分组「用于 Codex 生图」并保存；无工具箱则 `cp .env.example .env` 手动填。
+- **HTTP 401/403** → key 无效或额度不足，让用户核对中转站账户。
+- **HTTP 404** → base_url 写错，或该中转站不支持 `/v1/images/generations`；确认接口路径。
+- **HTTP 400 model 相关** → 该中转站不认 `gpt-image-2`，换 `--model dall-e-3` 或问用户支持的模型名。
+- **响应没有图片数据** → 部分中转站返回结构不同，把打印的原始响应给用户看以便排查。
+
+不要把 API Key 输出到对话里，也不要提交 `.env`。

gen-image/gen.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# gen.sh — 生图快捷入口。用法：
+#   ./gen.sh "提示词"                     # 文生图，默认 1024x1024
+#   ./gen.sh "提示词" --size 1536x1024    # 透传任意 gen_image.py 参数
+#   ./gen.sh "换成雪山背景" --edit in.png  # 图生图
+# 无论从哪个目录调用都能正确定位脚本与 .env。
+set -euo pipefail
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ "$#" -eq 0 ]; then
+  echo "用法: ./gen.sh \"提示词\" [--size 1024x1024] [--quality high] [--edit 图.png] ..." >&2
+  exit 1
+fi
+exec python3 "$DIR/scripts/gen_image.py" "$@"

gen-image/scripts/gen_image.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+gen_image.py — 通过大模型中转站调用 OpenAI 图片接口生图（文生图 / 图生图）。
+
+零第三方依赖，仅用 Python 标准库。凭证从环境变量或 skill 目录下的 .env 读取。
+
+用法:
+  # 文生图
+  python3 gen_image.py "一只戴墨镜的柴犬，赛博朋克霓虹背景" --size 1024x1024 --n 1
+
+  # 图生图 / 编辑（可选 --mask 做局部重绘）
+  python3 gen_image.py "把背景换成雪山" --edit input.png --mask mask.png
+
+环境变量（也可写进 .env）:
+  IMAGE_API_BASE_URL   中转站基址，如 https://your-relay.com  (会自动补 /v1/images/...)
+  IMAGE_API_KEY        API Key
+  IMAGE_MODEL          默认模型，如 gpt-image-2（默认 gpt-image-2）
+"""
+
+import argparse
+import base64
+import json
+import mimetypes
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+import uuid
+
+
+# ---------------------------------------------------------------------------
+# 配置加载
+# ---------------------------------------------------------------------------
+def load_dotenv():
+    """从脚本上级目录（skill 根）的 .env 读取 KEY=VALUE，不覆盖已存在的环境变量。"""
+    skill_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    env_path = os.path.join(skill_root, ".env")
+    if not os.path.isfile(env_path):
+        return
+    with open(env_path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, _, val = line.partition("=")
+            key, val = key.strip(), val.strip().strip('"').strip("'")
+            os.environ.setdefault(key, val)
+
+
+def get_config():
+    base = os.environ.get("IMAGE_API_BASE_URL", "").rstrip("/")
+    key = os.environ.get("IMAGE_API_KEY", "")
+    model = os.environ.get("IMAGE_MODEL", "gpt-image-2")
+    if not base:
+        die("缺少 IMAGE_API_BASE_URL（中转站基址）。请在工具箱「中转」里勾选用于生图，或在 .env 中配置。")
+    if not key:
+        die("缺少 IMAGE_API_KEY。请在工具箱「中转」里勾选用于生图，或在 .env 中配置。")
+    # 允许用户直接填到 /v1，做个兼容归一
+    if base.endswith("/v1"):
+        base = base[: -len("/v1")]
+    return base, key, model
+
+
+# ---------------------------------------------------------------------------
+# HTTP 辅助
+# ---------------------------------------------------------------------------
+def die(msg, code=1):
+    print(f"[gen_image] 错误: {msg}", file=sys.stderr)
+    sys.exit(code)
+
+
+# 部分中转站前置 Cloudflare/WAF，会按 UA 拦截默认的 Python-urllib（error 1010）。
+# 用常规浏览器 UA 规避。
+BROWSER_UA = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+)
+
+
+def _request(url, key, data, content_type):
+    req = urllib.request.Request(url, data=data, method="POST")
+    req.add_header("Authorization", f"Bearer {key}")
+    req.add_header("Content-Type", content_type)
+    req.add_header("User-Agent", BROWSER_UA)
+    req.add_header("Accept", "application/json")
+    try:
+        with urllib.request.urlopen(req, timeout=300) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", "replace")
+        die(f"HTTP {e.code} — {body[:800]}")
+    except urllib.error.URLError as e:
+        die(f"网络错误: {e.reason}")
+
+
+def post_json(url, key, payload):
+    return _request(url, key, json.dumps(payload).encode("utf-8"), "application/json")
+
+
+def post_multipart(url, key, fields, files):
+    """fields: dict[str,str]; files: list[(field, filepath)]。手写 multipart，无依赖。"""
+    boundary = "----genimg" + uuid.uuid4().hex
+    buf = bytearray()
+
+    def w(s):
+        buf.extend(s.encode("utf-8") if isinstance(s, str) else s)
+
+    for name, value in fields.items():
+        if value is None:
+            continue
+        w(f"--{boundary}\r\n")
+        w(f'Content-Disposition: form-data; name="{name}"\r\n\r\n')
+        w(f"{value}\r\n")
+
+    for name, path in files:
+        if not path:
+            continue
+        fname = os.path.basename(path)
+        ctype = mimetypes.guess_type(path)[0] or "application/octet-stream"
+        with open(path, "rb") as fh:
+            content = fh.read()
+        w(f"--{boundary}\r\n")
+        w(f'Content-Disposition: form-data; name="{name}"; filename="{fname}"\r\n')
+        w(f"Content-Type: {ctype}\r\n\r\n")
+        w(content)
+        w("\r\n")
+
+    w(f"--{boundary}--\r\n")
+    return _request(url, key, bytes(buf), f"multipart/form-data; boundary={boundary}")
+
+
+# ---------------------------------------------------------------------------
+# 结果保存
+# ---------------------------------------------------------------------------
+def save_images(resp, out_dir, prefix):
+    data = resp.get("data")
+    if not data:
+        die(f"响应中没有图片数据。原始响应: {json.dumps(resp)[:800]}")
+    os.makedirs(out_dir, exist_ok=True)
+    saved = []
+    for i, item in enumerate(data):
+        ts = time.strftime("%Y%m%d-%H%M%S")
+        fname = f"{prefix}-{ts}-{i}.png"
+        fpath = os.path.join(out_dir, fname)
+        if item.get("b64_json"):
+            with open(fpath, "wb") as f:
+                f.write(base64.b64decode(item["b64_json"]))
+        elif item.get("url"):
+            try:
+                dl = urllib.request.Request(item["url"], headers={"User-Agent": BROWSER_UA})
+                with urllib.request.urlopen(dl, timeout=120) as r:
+                    with open(fpath, "wb") as f:
+                        f.write(r.read())
+            except Exception as e:
+                die(f"下载图片失败 {item['url']}: {e}")
+        else:
+            die(f"未知的图片条目格式: {json.dumps(item)[:400]}")
+        saved.append(fpath)
+    return saved
+
+
+# ---------------------------------------------------------------------------
+# 主流程
+# ---------------------------------------------------------------------------
+def main():
+    load_dotenv()
+    p = argparse.ArgumentParser(description="通过中转站调用 OpenAI 图片接口生图")
+    p.add_argument("prompt", help="生图提示词")
+    p.add_argument("--model", default=None, help="覆盖默认模型")
+    p.add_argument("--size", default="1024x1024", help="尺寸，如 1024x1024 / 1536x1024 / 1024x1536 / auto")
+    p.add_argument("--n", type=int, default=1, help="生成张数")
+    p.add_argument("--quality", default=None, help="质量: low/medium/high/auto（gpt-image 系）")
+    p.add_argument("--background", default=None, help="transparent/opaque/auto（gpt-image 系，透明背景）")
+    p.add_argument("--edit", action="append", default=[], help="图生图/编辑的输入图（可多次传入多图）")
+    p.add_argument("--mask", default=None, help="局部重绘蒙版 PNG（透明处为要重绘的区域）")
+    p.add_argument("--output", default=None, help="输出目录（默认 skill 根下 output/）")
+    args = p.parse_args()
+
+    base, key, default_model = get_config()
+    model = args.model or default_model
+    skill_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    out_dir = args.output or os.path.join(skill_root, "output")
+
+    if args.edit:
+        # 图生图 / 编辑：multipart 到 /v1/images/edits
+        url = f"{base}/v1/images/edits"
+        fields = {"model": model, "prompt": args.prompt, "n": str(args.n), "size": args.size}
+        if args.quality:
+            fields["quality"] = args.quality
+        if args.background:
+            fields["background"] = args.background
+        files = [("image[]", pth) for pth in args.edit]  # 多图统一用 image[]
+        if len(args.edit) == 1:
+            files = [("image", args.edit[0])]  # 单图用 image，兼容 dall-e-2 风格
+        if args.mask:
+            files.append(("mask", args.mask))
+        print(f"[gen_image] 图生图 · model={model} · {len(args.edit)} 张输入 · size={args.size}")
+        resp = post_multipart(url, key, fields, files)
+        prefix = "edit"
+    else:
+        # 文生图：JSON 到 /v1/images/generations
+        url = f"{base}/v1/images/generations"
+        payload = {"model": model, "prompt": args.prompt, "n": args.n, "size": args.size}
+        if args.quality:
+            payload["quality"] = args.quality
+        if args.background:
+            payload["background"] = args.background
+        print(f"[gen_image] 文生图 · model={model} · n={args.n} · size={args.size}")
+        resp = post_json(url, key, payload)
+        prefix = "img"
+
+    saved = save_images(resp, out_dir, prefix)
+    print(f"[gen_image] 完成，已保存 {len(saved)} 张:")
+    for s in saved:
+        print(f"  {s}")
+
+
+if __name__ == "__main__":
+    main()

package.json

@@ -0,0 +1,30 @@
+{
+  "name": "codex-market",
+  "version": "1.5.86",
+  "description": "TD工具箱 / 技能商店 / 备份工具 —— 跨平台桌面客户端",
+  "author": "Codex Market",
+  "license": "MIT",
+  "main": "electron/bootstrap.js",
+  "hotContentVersion": "1.5.94",
+  "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",
+    "publish:hot": "node scripts/publish-hot.js"
+  },
+  "devDependencies": {
+    "electron": "^34.0.0",
+    "electron-builder": "^24.13.3"
+  },
+  "dependencies": {
+    "electron-updater": "^6.8.9",
+    "isomorphic-git": "^1.29.0",
+    "pdfjs-dist": "^4.10.38",
+    "sql.js": "^1.14.1"
+  }
+}

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);

renderer/index.html

@@ -0,0 +1,830 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <meta http-equiv="Content-Security-Policy"
+        content="default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self'; img-src 'self' data:; media-src 'self' data: blob:;" />
+  <title>TD工具箱</title>
+  <link rel="stylesheet" href="vendor/drawflow.min.css" />
+  <link rel="stylesheet" href="styles.css" />
+</head>
+<body>
+  <!-- 顶部品牌区 -->
+  <header class="topbar">
+    <div class="brand">
+      <div class="logo" aria-hidden="true">
+        <img src="logo.png" alt="tokendun" width="40" height="40" />
+      </div>
+      <div class="brand-text">
+        <div class="brand-name">TD工具箱</div>
+        <div class="brand-sub">tokendun 工具箱 · 技能 / 插件 · 路由</div>
+      </div>
+    </div>
+
+    <a class="promo" href="#" data-open="https://api.tokendun.cc" title="官方推荐中转 · api.tokendun.cc">
+      <span class="promo-badge">官方推荐</span>
+      <span class="promo-text">推荐中转 · <b>安全 · 稳定 · 可靠</b>（自备魔法访问）</span>
+      <span class="promo-arrow">↗</span>
+    </a>
+
+    <nav class="tabs" role="tablist">
+      <button class="tab active" data-tab="market" role="tab">技能市场</button>
+      <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="settings" role="tab">设置</button>
+    </nav>
+  </header>
+
+  <main class="content">
+    <!-- ① 技能商店 -->
+    <section class="panel active" id="tab-market">
+      <div class="store">
+        <!-- 左侧分类导航 -->
+        <aside class="store-nav">
+          <div class="store-nav-head">
+            <span class="store-nav-title">浏览分类</span>
+            <span class="store-nav-total" id="store-total">—</span>
+          </div>
+          <div class="store-nav-list" id="store-nav"></div>
+        </aside>
+
+        <!-- 右侧内容 -->
+        <div class="store-main">
+          <div class="store-head">
+            <div class="store-heading">
+              <div class="store-title-row">
+                <h2 id="store-cat-title">全部技能</h2>
+                <span class="store-crumb-sep">/</span>
+                <span class="store-count" id="store-count">—</span>
+              </div>
+              <p class="muted store-sub" id="store-cat-sub">通用 SKILL.md 标准，适配 Claude · Codex · OpenClaw</p>
+            </div>
+            <div class="store-tools">
+              <input id="market-search" class="search" type="search" placeholder="搜索技能 / 作者 / 功能…" />
+              <div class="segmented" id="store-sort" aria-label="技能排序方式">
+                <button class="seg active" data-sort="hot">热门</button>
+                <button class="seg" data-sort="downloads">下载量</button>
+                <button class="seg" data-sort="stars">星标</button>
+              </div>
+            </div>
+          </div>
+          <div class="store-filter-row" aria-label="快捷分类">
+            <div class="store-filter-label">分类</div>
+            <div class="store-category-chips" id="store-category-chips"></div>
+          </div>
+          <div id="market-grid" class="grid store-grid"></div>
+          <div id="store-more" class="store-more hidden"></div>
+          <div id="market-empty" class="empty hidden"></div>
+        </div>
+      </div>
+    </section>
+
+    <!-- ② 插件市场（tokendun 自研插件 + 内置工具） -->
+    <section class="panel" id="tab-plugins">
+      <div class="panel-head">
+        <div>
+          <h2>插件市场</h2>
+          <p class="muted">tokendun 官方自研插件与内置工具</p>
+        </div>
+        <div class="head-actions">
+          <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 hidden" id="codex-link-disconnect-btn" data-voice-link-disconnect>断开</button>
+          </div>
+          <input id="plugin-search" class="search" type="search" placeholder="搜索插件 / 作者…" />
+          <button id="plugin-refresh" class="btn ghost">刷新</button>
+        </div>
+      </div>
+
+      <!-- 内置工具 -->
+      <div class="tools-title">内置工具</div>
+      <div class="tools-grid">
+        <div class="tool-card">
+          <div class="tool-top"><span class="tool-ico">🗂️</span><div class="tool-name">会话记录</div></div>
+          <div class="tool-desc">浏览、搜索、导出本机 Codex 的全部历史对话。支持一键备份 / 导入；切换账号后还能把历史对话「同步认领」回当前账号，让侧栏重新显示。</div>
+          <div class="tool-foot"><button class="btn primary small" data-open-panel="sessions">打开</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-desc">自动把历史会话摘要成「长期记忆」并写入项目 HANDOFF，让 AI 跨会话记住上下文。可按项目开关，检索每次的决策 / 下一步 / 涉及文件。</div>
+          <div class="tool-foot"><button class="btn primary small" data-open-panel="memory">打开</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-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-desc">用一段话描述项目需求，自动拆解出一支带约束、能协作的 AI 员工团队（含总控 + 契约 + 文件边界 + 协同规范），打包成 Codex / Claude Code 可直接用的配置 zip。</div>
+          <div class="tool-foot"><button class="btn primary small" data-open-panel="team">打开</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-desc">上传图片或视频，AI 自动反推出能复现它的生图提示词。中英双语、七维拆解、负面提示词、关键词标签，直接用你的中转分组运行。</div>
+          <div class="tool-foot"><button class="btn primary small" data-open-panel="prompt">打开</button></div>
+        </div>
+        <div class="tool-card">
+          <div class="tool-top"><span class="tool-ico">⚡</span><div class="tool-name">Token 用量</div></div>
+          <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>
+
+      <!-- 已安装插件 -->
+      <div class="tools-title">已安装插件 <span id="plugin-installed-count" class="muted small"></span></div>
+      <div id="plugin-installed-grid" class="grid"></div>
+      <div id="plugin-installed-empty" class="empty hidden"></div>
+
+      <!-- 自研插件 -->
+      <div class="tools-title">官方插件</div>
+      <div id="plugin-grid" class="grid"></div>
+      <div id="plugin-empty" class="empty hidden"></div>
+    </section>
+
+    <!-- 语音输入（注入 Codex 输入框麦克风按钮） -->
+    <section class="panel" id="tab-voice">
+      <div class="panel-head">
+        <div>
+          <h2><button class="btn ghost small back-btn" data-back-plugins>← 插件市场</button> 语音输入</h2>
+          <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">点击「启用语音输入」开始。若 ChatGPT 正在运行，会提示你确认重启 ChatGPT 以启用调试端口。</div>
+        </div>
+        <div class="voice-card">
+          <div class="voice-card-title">转写分组 / 模型</div>
+          <div class="voice-row">
+            <span class="muted small">当前转写来源：</span>
+            <strong id="voice-stt-name">—</strong>
+            <span class="muted small">·</span>
+            <strong id="voice-stt-model">—</strong>
+            <button id="voice-refresh-stt" class="btn ghost small">刷新</button>
+            <button id="voice-probe-stt" class="btn ghost small">诊断接口</button>
+          </div>
+          <div id="voice-probe-result" class="muted small"></div>
+          <div class="muted small">在「路由中转」里勾选分组的「支持语音转文字」并填转写模型（如 whisper-1 / speech-01）。优先用当前激活分组，否则用任一勾选 STT 的分组。</div>
+        </div>
+        <div class="voice-card">
+          <div class="voice-card-title">使用说明</div>
+          <ol class="voice-ol">
+            <li>点击「启用语音输入」。若 ChatGPT 在运行且未带调试端口，会弹窗提示重启（当前窗口会关闭一次，登录态保留）。</li>
+            <li>连接成功后，Codex 输入框旁出现 🎤 按钮。点击 → 授权麦克风权限 → 说话 → 再次点击停止。</li>
+            <li>转写完成后文字自动填入输入框。首次需在「系统设置 → 隐私 → 麦克风」允许 ChatGPT。</li>
+            <li>macOS 误杀进程风险已规避：仅在确认后重启。Codex 升级后若按钮消失，可能需等待工具箱适配。</li>
+          </ol>
+        </div>
+      </div>
+    </section>
+
+    <!-- ②.5 创意画布（Drawflow 节点画布） -->
+    <section class="panel" id="tab-canvas">
+      <div class="cv-toolbar">
+        <div class="cv-toolbar-left">
+          <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">
+          <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-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-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">
+            <div class="cv-mask-ico">🔌</div>
+            <div class="cv-mask-title">中转未就绪</div>
+            <p class="cv-mask-text" id="cv-mask-text">请先在『路由中转』配置并激活一个中转分组</p>
+            <button class="btn primary small" id="cv-goto-router">前往路由中转</button>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- 员工团队：需求 → AI 员工团队 → 打包 zip -->
+    <section class="panel" id="tab-team">
+      <div class="tm-wrap">
+        <!-- 左侧：需求输入 + 配置 -->
+        <div class="tm-input-col">
+          <h2 class="tm-title"><button class="btn ghost small back-btn" data-back-plugins>← 插件市场</button> 生成 AI 员工团队</h2>
+          <p class="tm-sub">用一段话描述项目需求，自动拆解出一支带约束、能协作的 AI 员工团队（含总控），打包成 Codex / Claude Code 可直接用的配置。</p>
+          <textarea id="tm-req" class="tm-req" placeholder="例如：做一个电商后台管理系统，需要商品管理、订单处理、库存、用户权限和数据看板，前端要好看，后端要稳。"></textarea>
+
+          <div class="tm-field">
+            <label class="tm-label">目标工具</label>
+            <div class="tm-chips" id="tm-tool">
+              <button class="tm-chip active" data-tool="codex">Codex</button>
+              <button class="tm-chip" data-tool="claude">Claude Code</button>
+            </div>
+            <div class="tm-hint" id="tm-tool-hint">生成 .toml 员工 + 总控（调度 / 审核）+ AGENTS.md</div>
+          </div>
+
+          <div class="tm-field">
+            <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">只负责把需求转换成团队配置；它不会决定生成后 Agent 执行任务使用的模型</div>
+          </div>
+
+          <div class="tm-field">
+            <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>
+        </div>
+
+        <!-- 右侧：结果 -->
+        <div class="tm-result-col">
+          <div class="tm-result-head">
+            <span class="tm-result-title">员工团队</span>
+            <button class="btn small primary" id="tm-download" hidden>⬇ 打包下载 .zip</button>
+          </div>
+          <div class="tm-result-body">
+            <div class="tm-empty" id="tm-empty">
+              <div class="tm-empty-ico">👤→👥</div>
+              <p class="tm-empty-title">描述需求，自动组建 AI 员工团队</p>
+              <p class="tm-empty-sub">拆解职责 · 定义契约 · 划分文件边界 · 生成协同规范</p>
+            </div>
+            <div class="tm-loading" id="tm-loading" hidden>
+              <div class="tm-spinner"></div>
+              <div class="tm-loading-text" id="tm-loading-text">正在分析需求、拆解团队…</div>
+            </div>
+            <div class="tm-content" id="tm-content" hidden>
+              <div class="tm-team-head" id="tm-team-head"></div>
+              <div id="tm-team-list"></div>
+            </div>
+            <div class="tm-error" id="tm-error" hidden></div>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- ②.⑥ 提示词提取（图片 → 反推生图提示词） -->
+    <section class="panel" id="tab-prompt">
+      <div class="panel-head">
+        <div>
+          <h2><button class="btn ghost small back-btn" data-back-plugins>← 插件市场</button> 提示词提取</h2>
+          <p class="muted">上传图片或视频，AI 自动分析九个视觉维度，反推出能复现它的中英双语生图提示词。直接用你的中转分组运行。</p>
+        </div>
+      </div>
+
+      <div class="pm-wrap">
+        <!-- 左侧：上传 + 设置 -->
+        <div class="pm-input-col">
+          <div class="pm-dropzone" id="pm-dropzone">
+            <input type="file" id="pm-fileInput" accept="image/*,video/*" hidden />
+            <div class="pm-dz-empty" id="pm-dzEmpty">
+              <div class="pm-dz-icon">📤</div>
+              <div class="pm-dz-title">拖拽图片 / 视频到这里</div>
+              <div class="pm-dz-sub">或点击选择 · JPG / PNG / WebP / MP4</div>
+            </div>
+            <div class="pm-dz-preview" id="pm-dzPreview" hidden>
+              <img id="pm-previewImg" alt="预览" />
+              <button class="pm-dz-clear" id="pm-clearBtn" title="移除">✕</button>
+            </div>
+          </div>
+
+          <div class="pm-field">
+            <label class="pm-label">分析模型（中转分组）</label>
+            <div class="pm-row">
+              <select class="pm-select" id="pm-group"></select>
+              <button class="btn small ghost" id="pm-fetch">🔄 拉取模型</button>
+            </div>
+            <select class="pm-select" id="pm-model" style="margin-top:8px"></select>
+            <div class="pm-hint" id="pm-model-hint">先在『路由中转』配置好分组，再选具体模型（需要视觉/多模态模型）</div>
+          </div>
+
+          <button id="pm-analyze" class="btn primary pm-gen" disabled>开始分析</button>
+        </div>
+
+        <!-- 右侧：结果（分析完成后动态渲染，平时只展示空状态） -->
+        <div class="pm-result-col">
+          <div class="pm-result-body" id="pm-result-body">
+            <div class="pm-empty" id="pm-empty">
+              <div class="pm-empty-ico">🖼️→📝</div>
+              <p class="pm-empty-title">上传素材，反推它的生图提示词</p>
+              <p class="pm-empty-sub">精准分析九个视觉维度，输出可直接复现的双语提示词</p>
+              <div class="pm-empty-feats"><span>七维拆解</span><span>中英双语</span><span>负面提示词</span><span>关键词标签</span></div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- ②.⑦ Token 用量（Codex 输入框下方工具栏进度条） -->
+    <section class="panel" id="tab-token">
+      <div class="panel-head">
+        <div>
+          <h2><button class="btn ghost small back-btn" data-back-plugins>← 插件市场</button> Token 用量</h2>
+          <p class="muted">在 Codex 输入框下方、模型选择左侧显示 Token 累计消耗条。复用语音 CDP 连接自动注入，每天 24 点自动清零。</p>
+        </div>
+        <div class="head-actions">
+          <span id="tk-dot" class="voice-dot" data-state="unknown"></span>
+          <span id="tk-phase-text" class="muted small">未连接</span>
+        </div>
+      </div>
+
+      <div class="tk-body">
+        <!-- 今日用量 Hero -->
+        <div class="tk-card hero">
+          <div class="tk-hero-num" id="tk-total">—</div>
+          <div class="tk-hero-label">今日累计消耗</div>
+          <div class="tk-breakdown" id="tk-breakdown">
+            <span>输入 <b id="tk-input">0</b></span>
+            <span>输出 <b id="tk-output">0</b></span>
+            <span>缓存 <b id="tk-cached">0</b></span>
+            <span>估算 <b id="tk-estimate">0</b></span>
+            <span>未知 <b id="tk-unknown">0</b></span>
+          </div>
+          <div class="tk-hero-date" id="tk-date"></div>
+        </div>
+
+        <!-- Codex 效果预览 -->
+        <div class="tk-card">
+          <div class="tk-card-title">Codex 输入框下方效果</div>
+          <div class="tk-preview">
+            <div class="tk-preview-bar" id="tk-preview-bar">
+              <div class="tk-preview-meter">
+                <div class="tk-preview-track">
+                  <div class="tk-preview-segments" id="tk-preview-segments">
+                    <i class="tk-preview-seg"></i><i class="tk-preview-seg"></i><i class="tk-preview-seg"></i><i class="tk-preview-seg"></i>
+                    <i class="tk-preview-seg"></i><i class="tk-preview-seg"></i><i class="tk-preview-seg"></i><i class="tk-preview-seg"></i>
+                  </div>
+                  <span class="tk-preview-badge"><span class="tk-preview-check">✓</span><span id="tk-preview-badge-text">0 token</span></span>
+                  <span class="tk-preview-cap"></span>
+                </div>
+              </div>
+            </div>
+            <div class="tk-preview-input">输入消息…</div>
+          </div>
+		</div>
+
+        <!-- 操作 -->
+        <div class="tk-card">
+          <div class="tk-card-title">操作</div>
+          <div class="tk-row">
+            <button id="tk-refresh" class="btn ghost">🔄 刷新用量</button>
+            <button id="tk-reset" class="btn danger small">↺ 手动清零</button>
+          </div>
+          <div class="muted small" style="margin-top:8px">
+            用量数据保存在 Codex 页面 localStorage 中，跨天自动清零。<br />需要先在「插件市场」主页连接 Codex（Token 脚本随连接一起注入）。
+          </div>
+          <div class="tk-diag muted small" id="tk-diag"></div>
+        </div>
+        <div class="tk-card">
+          <div class="tk-card-title">工作原理</div>
+          <ol class="voice-ol">
+            <li>语音连接 Codex 时，Token 监控脚本自动注入同一个 CDP 连接。</li>
+            <li>主进程优先读取 Codex 本地 session 的 <code>token_count</code> 累计快照，网络 <code>usage</code> 仅作为兼容兜底。</li>
+            <li>用量条挂在输入框下方工具栏，优先放在模型选择左侧。</li>
+          </ol>
+        </div>
+      </div>
+    </section>
+
+    <!-- ③ 会话记录 -->
+    <section class="panel" id="tab-sessions">
+      <div class="panel-head">
+        <div>
+          <h2><button class="btn ghost small back-btn" data-back-plugins>← 插件市场</button> 会话记录</h2>
+          <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="搜索标题 / 项目…" />
+          <span id="sess-scope" class="muted small">当前会话</span>
+          <button id="sess-refresh" class="btn ghost">刷新</button>
+          <button id="sess-fetch-all" class="btn ghost">获取全部记录</button>
+          <button id="sess-clear-all" class="btn danger">一键清除</button>
+          <button id="sess-import" class="btn ghost">导入备份…</button>
+          <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>
+          <span class="muted small">切换账号后历史对话在 Codex 里不显示？点这里把 sessions 与 archived_sessions 的全部对话"认领"到当前账号。<b>需先完全退出 Codex。</b></span>
+          <div class="sync-progress hidden" id="sync-progress">
+            <div class="sync-progress-bar"><div class="sync-progress-fill" id="sync-progress-fill"></div></div>
+            <span class="sync-progress-label small muted" id="sync-progress-label"></span>
+          </div>
+        </div>
+        <button id="sync-btn" class="btn primary">一键同步</button>
+      </div>
+      <div class="sess-layout">
+        <div class="sess-list" id="sess-list"></div>
+        <div class="sess-reader" id="sess-reader">
+          <div class="empty" id="sess-empty">← 左侧选一条对话查看</div>
+          <div class="sess-conv hidden" id="sess-conv">
+            <div class="sess-conv-head">
+              <div class="sess-conv-title" id="sess-conv-title"></div>
+              <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>
+        </div>
+      </div>
+    </section>
+
+    <!-- ③.5 会话记忆 -->
+    <section class="panel" id="tab-memory">
+      <div class="panel-head">
+        <div>
+          <h2><button class="btn ghost small back-btn" data-back-plugins>← 插件市场</button> 会话记忆</h2>
+          <p class="muted">自动把每次 Codex 会话浓缩成「交接摘要」：存入本地记忆库，并写到项目根目录的 <code>HANDOFF.md</code>。新开会话说「继续」，Codex 会先读它再接着干。</p>
+        </div>
+        <div class="head-actions">
+          <input id="mem-search" class="search" type="search" placeholder="搜索主题 / 摘要 / 决策…" />
+          <button id="mem-refresh" class="btn ghost">刷新</button>
+          <button id="mem-toggle" class="btn primary">—</button>
+        </div>
+      </div>
+
+      <div class="card action-card">
+        <div class="row between">
+          <div class="field">
+            <span>状态</span>
+            <div><span class="pc-badge" id="mem-state">—</span> <span class="muted small" id="mem-engine"></span></div>
+          </div>
+          <span class="muted small" id="mem-count"></span>
+        </div>
+        <p class="muted small" style="margin:6px 0 0">
+          工作方式：会话静默几分钟后自动摘要（优先走「路由中转」当前分组的 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">
+        <div><h3>项目</h3><p class="muted">按项目开关写入（关闭后记忆库照常记录，但不再更新该项目的 HANDOFF.md / AGENTS.md）</p></div>
+      </div>
+      <div id="mem-projects" class="checklist"></div>
+
+      <div class="panel-head" style="margin-top:14px">
+        <div><h3>历史摘要</h3><p class="muted">全部存在本机 SQLite（memory.db），可随时检索</p></div>
+        <select id="mem-project-filter" class="grp-select" style="margin-top:0;max-width:280px"><option value="">全部项目</option></select>
+      </div>
+      <div id="mem-list"></div>
+      <div id="mem-empty" class="empty hidden"></div>
+    </section>
+
+    <!-- ④ 路由中转 -->
+    <section class="panel" id="tab-router">
+      <div class="panel-head">
+        <div>
+          <h2>路由中转</h2>
+          <p class="muted">Codex 直连本软件本地路由 → 转发到"当前分组"的中转 API。在此秒切分组，<b>无需重启 Codex</b>。</p>
+        </div>
+      </div>
+
+      <div class="card action-card">
+        <div class="row between">
+          <div class="field">
+            <span>本地路由地址（Codex 连这里）</span>
+            <div><code id="router-addr">—</code> <span class="pc-badge" id="router-state">未启动</span></div>
+          </div>
+          <div class="btn-group">
+            <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">
+          <label class="field grow">
+            <span>路由 Key（已自动写入 Codex）</span>
+            <input id="router-key" type="text" readonly />
+          </label>
+          <label class="field">
+            <span>端口</span>
+            <input id="router-port" type="number" style="width:100px" />
+          </label>
+          <button id="router-save-port" class="btn ghost" style="align-self:flex-end">改端口</button>
+        </div>
+        <p class="muted small">点「一键配置到 Codex」后，Codex 的 config.toml 会自动指向本地路由（只需一次）。之后切分组即时生效。</p>
+        <p class="muted small">「接入 Claude Code」会把 <code>~/.claude/settings.json</code> 的 <code>ANTHROPIC_BASE_URL</code> 指向本地路由（只需一次），须搭配 <b>Anthropic 格式</b>的中转分组。之后同样切分组即时生效。</p>
+      </div>
+
+      <div class="panel-head" style="margin-top:18px">
+        <div><h3>中转分组</h3><p class="muted">每个分组：名称 + API 地址 + 密钥 +（可选）模型。按协议分两栏：Codex/GPT 与 Claude Code 各选一个，<b>两者可同时激活一起用</b>。</p></div>
+        <button id="grp-add" class="btn">+ 新增分组</button>
+      </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">
+          <div class="modal-head"><h3 id="grp-modal-title">新增分组</h3><button class="modal-close" id="grp-modal-close">✕</button></div>
+          <div class="modal-body">
+            <label class="field grow"><span>分组名称</span><input id="grp-name" placeholder="如：TokenDun 高速组" /></label>
+            <label class="field grow" style="margin-top:10px">
+              <span>接口类型</span>
+              <select id="grp-mode" class="grp-select" style="margin-top:0">
+                <option value="responses">Responses 直连（OpenAI / TokenDun 等 Codex 原生）</option>
+                <option value="chat">Chat 补全 · 自动转换（国产：DeepSeek / GLM / Kimi / 通义）</option>
+                <option value="claude">Claude Code（接入 Claude Code CLI，写入 ~/.claude/settings.json）</option>
+              </select>
+            </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>
+            <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">
+              <span>默认模型（可选，填了则强制用它）</span>
+              <div class="row" style="gap:8px; align-items:center">
+                <input id="grp-model" placeholder="如 gpt-5.5，可留空" style="flex:1" />
+                <button id="grp-fetch-models" class="btn ghost" type="button">获取模型</button>
+              </div>
+              <select id="grp-model-list" class="grp-select hidden"><option value="">— 从下拉选择模型 —</option></select>
+              <span class="muted small" id="grp-model-hint"></span>
+            </div>
+            <div class="field grow" id="grp-1m-field" style="margin-top:10px; display:none">
+              <span>1M 长上下文（勾选支持百万上下文的模型；转发这些模型时自动带 1M beta 头）</span>
+              <div id="grp-1m-list" class="grp-1m-list"></div>
+              <span class="muted small">仅对本身支持 1M 的模型有效（如 GPT/GLM/Claude 的 1M 版）。勾选后经此分组转发该模型即解锁 1M 窗口。</span>
+            </div>
+            <div class="field grow" style="margin-top:10px">
+              <span>上下文窗口 tokens（国产模型建议填，Codex 据此自动压缩）</span>
+              <div class="row" style="gap:6px; flex-wrap:wrap; align-items:center">
+                <input id="grp-ctx" type="number" placeholder="如 131072" style="flex:1; min-width:120px" />
+                <button type="button" class="btn small ghost" data-ctx="65536">64K</button>
+                <button type="button" class="btn small ghost" data-ctx="131072">128K</button>
+                <button type="button" class="btn small ghost" data-ctx="204800">200K</button>
+              </div>
+              <span class="muted small">DeepSeek≈64K/128K · GLM≈128K · Kimi≈128K/200K · 通义≈128K。留空则用 Codex 默认(可能过大导致超限)</span>
+            </div>
+
+            <div class="field grow claudedesk-block" id="grp-claudedesk" style="margin-top:14px; border-top:1px solid var(--border); padding-top:14px">
+              <span>接入 Claude 桌面 App（第三方推理）</span>
+              <div class="muted small" id="grp-cd-hint" style="margin:2px 0 8px">把该分组一键写入 Claude 桌面 App，重启 App 即用你的中转。仅支持 Anthropic 协议分组。</div>
+              <div class="row" style="gap:8px; flex-wrap:wrap; align-items:center">
+                <button type="button" class="btn primary small" id="grp-cd-apply">⚡ 一键接入</button>
+                <button type="button" class="btn ghost small" id="grp-cd-export">导出配置文件</button>
+                <button type="button" class="btn ghost small" id="grp-cd-copy">复制配置</button>
+                <button type="button" class="btn small" id="grp-cd-restore" style="border-color:var(--danger); color:var(--danger)">↩ 还原官方登录</button>
+              </div>
+              <div class="muted small" id="grp-cd-status" style="margin-top:8px"></div>
+            </div>
+
+            <div class="row between" style="margin-top:16px">
+              <span></span>
+              <button id="grp-save" class="btn primary">保存</button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <!-- 设置 -->
+    <section class="panel" id="tab-settings">
+      <div class="panel-head"><div><h2>设置</h2><p class="muted">密钥用系统安全存储加密后保存在本机</p></div></div>
+      <div class="card action-card">
+        <label class="field grow">
+          <span>默认 GitHub Token</span>
+          <input id="set-github" type="password" placeholder="ghp_…（安装私有仓库 / 上传时复用）" />
+        </label>
+        <div class="row between">
+          <span class="muted small">保存后，上传 / 拉取页会自动带出</span>
+          <button id="btn-save-secret" class="btn primary">保存</button>
+        </div>
+      </div>
+
+      <div class="card action-card">
+        <label class="field grow">
+          <span>🔑 管理员密钥（上架插件到市场需要，普通用户留空）</span>
+          <input id="set-admin" type="password" placeholder="仅管理员填写 · 用于上架市场" />
+        </label>
+        <div class="row between">
+          <span class="muted small">没有此密钥的用户只能备份到自己仓库、安装市场插件，<b>不能上架到市场</b>，防止恶意插件。</span>
+          <button id="btn-save-admin" class="btn primary">保存</button>
+        </div>
+      </div>
+
+      <div class="card action-card">
+        <div class="row between">
+          <div class="field">
+            <span>软件版本</span>
+            <div><b id="app-version">—</b> <span class="muted small" id="update-info"></span></div>
+          </div>
+          <button id="btn-check-update" class="btn">检查更新</button>
+        </div>
+      </div>
+
+      <div class="card action-card">
+        <div class="row between">
+          <div class="field">
+            <span>🧹 强制清除本机 Codex</span>
+            <p class="muted small" style="margin:0;max-width:520px">
+              自动识别 Windows / macOS 上 Codex 的安装位置（数据目录、可执行文件、npm 全局包等）。
+              更新后中转失效时，可在此彻底清干净，再重新安装。<b style="color:var(--danger)">删除不可撤销</b>，
+              会清掉配置、登录凭证、会话与插件。
+            </p>
+          </div>
+          <button id="btn-purge-scan" class="btn">检测安装位置</button>
+        </div>
+        <div id="purge-list" class="checklist" style="margin:0"></div>
+        <div class="row between" id="purge-actions" style="display:none">
+          <span class="muted small">将删除上方全部已勾选的位置</span>
+          <button id="btn-purge-do" class="btn danger">彻底清除 Codex</button>
+        </div>
+      </div>
+    </section>
+  </main>
+
+  <!-- 运行日志抽屉 -->
+  <div class="logbar">
+    <button id="log-toggle" class="log-toggle">运行日志 <span id="log-caret">▲</span></button>
+    <div id="log-panel" class="log-panel hidden"><pre id="log-out"></pre></div>
+  </div>
+
+  <!-- 版权 / 使用说明 常驻页脚 -->
+  <footer class="footer-notice">
+    <span class="fn-text">本市场收录的插件版权归各自作者（含 OpenAI）所有，仅供已获授权用户备份 · 还原使用。</span>
+    <span class="fn-links">
+      <button class="fn-link" id="open-usage">📖 使用说明</button>
+      <button class="fn-link" id="open-notice">📄 版权声明</button>
+    </span>
+  </footer>
+
+  <!-- Toast -->
+  <div id="toast" class="toast hidden"></div>
+
+  <!-- 说明弹窗 -->
+  <div id="modal-overlay" class="modal-overlay hidden">
+    <div class="modal" role="dialog" aria-modal="true">
+      <div class="modal-head">
+        <h3 id="modal-title"></h3>
+        <button class="modal-close" id="modal-close" aria-label="关闭">✕</button>
+      </div>
+      <div class="modal-body" id="modal-body"></div>
+    </div>
+  </div>
+
+  <!-- 更新弹窗 -->
+  <div id="update-modal" class="modal-overlay hidden">
+    <div class="modal update-modal" role="dialog" aria-modal="true">
+      <div class="update-head">
+        <div class="update-ico">🚀</div>
+        <div>
+          <h3 id="update-title">发现新版本</h3>
+          <p class="muted small" id="update-ver"></p>
+        </div>
+        <span class="update-badge" id="update-badge"></span>
+      </div>
+      <div class="update-notes" id="update-notes"></div>
+      <div class="update-foot" id="update-foot"></div>
+    </div>
+  </div>
+
+  <script src="vendor/drawflow.min.js"></script>
+  <script src="canvas-inputs.js"></script>
+  <script src="app.js"></script>
+</body>
+</html>

renderer/plugins.json

@@ -0,0 +1 @@
+{"source": "tokendun 官方插件", "repo": "https://up.tokendun.cc/mhgmh/codex-market-app", "plugins": [{"name": "presentations", "displayName": "演示文稿", "source": "openai-primary-runtime", "rel": "plugins/cache/openai-primary-runtime/presentations", "description": "用一句话创建或编辑 PowerPoint / Google Slides 演示文稿，支持新建、改版、渲染导出。", "platform": "", "size": 7833601, "zipName": "presentations.zip", "url": "https://up.tokendun.cc/mhgmh/codex-market-app/releases/download/plugins/presentations.zip"}, {"name": "product-design", "displayName": "产品设计", "source": "openai-curated-remote", "rel": "plugins/cache/openai-curated-remote/product-design", "description": "完整的产品与 UX 设计工作流：用户研究、产品审计、视觉创意，从想法/网址/图片/Figma 生成可运行原型，再到设计 QA 与分享。", "platform": "", "size": 238496, "zipName": "product-design.zip", "url": "https://up.tokendun.cc/mhgmh/codex-market-app/releases/download/plugins/product-design.zip"}, {"name": "hyperframes", "displayName": "HTML 视频", "source": "openai-api-curated", "rel": "plugins/cache/openai-api-curated/hyperframes", "description": "用写 HTML 的方式做视频：合成动画、字幕、配音、音频可视化、转场，一键渲染成 MP4，还能把网站直接变成宣传视频。", "platform": "", "size": 371425, "zipName": "hyperframes.zip", "url": "https://up.tokendun.cc/mhgmh/codex-market-app/releases/download/plugins/hyperframes.zip"}, {"name": "computer-use", "displayName": "电脑操控", "source": "openai-bundled", "rel": "plugins/cache/openai-bundled/computer-use", "description": "让 Codex 直接操控本机 Mac 应用：自动点击、输入、滚动、拖拽、按键，完成需要动手操作 App 界面的任务（附带 HyperFrames 视频插件）。", "platform": "macos", "size": 60690310, "zipName": "computer-use.zip", "url": "https://up.tokendun.cc/mhgmh/codex-market-app/releases/download/plugins/computer-use.zip"}, {"name": "creative-production", "displayName": "创意创作", "source": "openai-curated-remote", "rel": "plugins/cache/openai-curated-remote/creative-production", "description": "从想法到成图的商业视觉创作插件：一站式探索定位、情绪板、场景、广告、Logo、分镜，并把选中的图精修成可发布成品。", "platform": "", "size": 2640342, "zipName": "creative-production.zip", "url": "https://up.tokendun.cc/mhgmh/codex-market-app/releases/download/plugins/creative-production.zip"}]}

renderer/vendor/drawflow.min.css

@@ -0,0 +1 @@
+.drawflow,.drawflow .parent-node{position:relative}.parent-drawflow{display:flex;overflow:hidden;touch-action:none;outline:0}.drawflow{width:100%;height:100%;user-select:none;perspective:0}.drawflow .drawflow-node{display:flex;align-items:center;position:absolute;background:#0ff;width:160px;min-height:40px;border-radius:4px;border:2px solid #000;color:#000;z-index:2;padding:15px}.drawflow .drawflow-node.selected{background:red}.drawflow .drawflow-node:hover{cursor:move}.drawflow .drawflow-node .inputs,.drawflow .drawflow-node .outputs{width:0}.drawflow .drawflow-node .drawflow_content_node{width:100%;display:block}.drawflow .drawflow-node .input,.drawflow .drawflow-node .output{position:relative;width:20px;height:20px;background:#fff;border-radius:50%;border:2px solid #000;cursor:crosshair;z-index:1;margin-bottom:5px}.drawflow .drawflow-node .input{left:-27px;top:2px;background:#ff0}.drawflow .drawflow-node .output{right:-3px;top:2px}.drawflow svg{z-index:0;position:absolute;overflow:visible!important}.drawflow .connection{position:absolute;pointer-events:none;aspect-ratio:1/1}.drawflow .connection .main-path{fill:none;stroke-width:5px;stroke:#4682b4;pointer-events:all}.drawflow .connection .main-path:hover{stroke:#1266ab;cursor:pointer}.drawflow .connection .main-path.selected{stroke:#43b993}.drawflow .connection .point{cursor:move;stroke:#000;stroke-width:2;fill:#fff;pointer-events:all}.drawflow .connection .point.selected,.drawflow .connection .point:hover{fill:#1266ab}.drawflow .main-path{fill:none;stroke-width:5px;stroke:#4682b4}.drawflow-delete{position:absolute;display:block;width:30px;height:30px;background:#000;color:#fff;z-index:4;border:2px solid #fff;line-height:30px;font-weight:700;text-align:center;border-radius:50%;font-family:monospace;cursor:pointer}.drawflow>.drawflow-delete{margin-left:-15px;margin-top:15px}.parent-node .drawflow-delete{right:-15px;top:-15px}

resources/multimodal-gateway.example.json

@@ -0,0 +1,6 @@
+{
+  "baseUrl": "https://api.tokendun.com",
+  "key": "replace-at-release-time",
+  "model": "MiniMax-M3",
+  "sttModel": ""
+}

resources/singbox/README.md

@@ -0,0 +1,17 @@
+# sing-box 引擎（全局代理功能）
+
+「全局代理」功能内置 [sing-box](https://github.com/SagerNet/sing-box) 做本地中转 / TUN。
+这些二进制体积较大（每个约 45–50MB），**不纳入 git**。
+
+打包 / 运行前先拉取一次：
+
+```bash
+bash scripts/fetch-singbox.sh
+```
+
+会下载到：
+- `darwin-arm64/sing-box`
+- `darwin-x64/sing-box`
+- `windows-x64/sing-box.exe`
+
+electron-builder 会按目标架构把对应二进制打进安装包（见 `electron-builder.yml` 的 `extraResources`）。

scripts/afterPack.js

@@ -0,0 +1,26 @@
+// afterPack 钩子：未购买 Apple 证书时，electron-builder(24) 会「跳过签名」，
+// 导致 .app 的 bundle 封印(seal)残缺（codesign --verify 报 "code has no resources
+// but signature indicates they must be present"）。这里在打 DMG 前，用 ad-hoc 身份
+// 对整个 app（含内置 sing-box）做一次完整深度重新签名，得到有效封印——
+// 用户去掉隔离标记后即可稳定运行。
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+exports.default = async function afterPack(context) {
+  if (context.electronPlatformName !== 'darwin') return;
+
+  const appName = `${context.packager.appInfo.productFilename}.app`;
+  const appPath = path.join(context.appOutDir, appName);
+
+  console.log(`  • ad-hoc 深度重签名  app=${appPath}`);
+  // --force 覆盖已有签名，--deep 递归签所有嵌套二进制(sing-box 等)，-s - 表示 ad-hoc
+  execFileSync('codesign', ['--force', '--deep', '--sign', '-', appPath], {
+    stdio: 'inherit',
+  });
+
+  // 校验封印是否完整（失败则中断构建，避免发出坏包）
+  execFileSync('codesign', ['--verify', '--deep', '--strict', '--verbose=2', appPath], {
+    stdio: 'inherit',
+  });
+  console.log('  • ad-hoc 签名校验通过 ✔');
+};

scripts/fetch-singbox.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# 下载全局代理功能所需的 sing-box 引擎二进制(macOS arm64/x64 + Windows x64)。
+# 这些二进制不进 git(太大)，打包前跑一次即可。用法： bash scripts/fetch-singbox.sh
+set -euo pipefail
+VER="${SINGBOX_VERSION:-1.13.14}"
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+DEST="$ROOT/resources/singbox"
+mkdir -p "$DEST"
+cd "$DEST"
+
+fetch() { # $1=平台目录 $2=资源名(不含扩展) $3=压缩类型 $4=包内二进制名
+  local dir="$1" asset="$2" kind="$3" bin="$4"
+  echo "▶ $dir …"
+  if [ -f "$dir/$bin" ]; then echo "  已存在，跳过"; return; fi
+  mkdir -p "$dir"
+  local url="https://github.com/SagerNet/sing-box/releases/download/v${VER}/${asset}.${kind}"
+  if [ "$kind" = "tar.gz" ]; then
+    curl -fsSL "$url" -o t.tgz && tar xzf t.tgz && mv "${asset}/${bin}" "$dir/" && rm -rf t.tgz "$asset"
+  else
+    curl -fsSL "$url" -o t.zip && unzip -qo t.zip && mv "${asset}/${bin}" "$dir/" && rm -rf t.zip "$asset"
+  fi
+  chmod +x "$dir/$bin" 2>/dev/null || true
+  echo "  ✓ $dir/$bin"
+}
+
+fetch "darwin-arm64" "sing-box-${VER}-darwin-arm64" "tar.gz" "sing-box"
+fetch "darwin-x64"   "sing-box-${VER}-darwin-amd64" "tar.gz" "sing-box"
+fetch "windows-x64"  "sing-box-${VER}-windows-amd64" "zip"   "sing-box.exe"
+echo "全部就位 ✅ （sing-box v${VER}）"

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)}`);
+}

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`);
+})();

scripts/publish-full.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// publish-full.js —— 发布完整安装包到自建 gitea。
+// 把 dist/ 下的 dmg/zip/blockmap/latest-*.yml 上传到：
+//   - latest release（electron-updater 自动更新目标，文件名固定，覆盖上传）
+//   - v<version> release（版本存档，供手动下载）
+"use strict";
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+const ROOT = path.join(__dirname, "..");
+const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf8"));
+const version = pkg.version;
+
+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); }
+
+const OWNER = "mhgmh", REPO = "codex-market-app";
+const API = `https://up.tokendun.cc/api/v1/repos/${OWNER}/${REPO}`;
+const DIST = path.join(ROOT, "dist");
+
+// 要上传的产物：dmg/zip/exe/blockmap + latest*.yml（mac 的 latest-mac.yml + win 的 latest.yml）
+const files = fs.readdirSync(DIST).filter((f) =>
+  /\.(dmg|zip|exe)(\.blockmap)?$/.test(f) || /^latest.*\.yml$/.test(f)
+);
+if (!files.length) { console.error("dist/ 下没有可上传的产物"); process.exit(1); }
+console.log(`待上传 ${files.length} 个文件：\n  ` + files.join("\n  "));
+
+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) {
+  try { return JSON.parse(api(method, urlPath, body)); } catch { return null; }
+}
+
+// 确保 release 存在（按 tag 取，缺则建）
+function ensureRelease(tag, name, prerelease) {
+  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, body: `TD工具箱 ${version} 完整安装包`,
+      draft: false, prerelease: !!prerelease,
+    });
+  }
+  if (!rel || !rel.id) { console.error(`无法创建/获取 release ${tag}`); process.exit(1); }
+  return rel;
+}
+
+function uploadTo(rel, tag) {
+  // 删同名旧 asset，再上传
+  const existing = new Map((rel.assets || []).map((a) => [a.name, a.id]));
+  for (const name of files) {
+    if (existing.has(name)) {
+      api("DELETE", `/releases/${rel.id}/assets/${existing.get(name)}`);
+      console.log(`  [${tag}] 删除旧 asset: ${name}`);
+    }
+  }
+  for (const name of files) {
+    const file = path.join(DIST, name);
+    const code = execFileSync("curl", ["-s", "-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", maxBuffer: 64 * 1024 * 1024 });
+    console.log(`  [${tag}] 上传 ${name} → HTTP ${code}`);
+    if (code !== "201") { console.error(`  上传 ${name} 失败`); process.exit(1); }
+  }
+}
+
+// 1) latest release —— electron-updater 自动更新目标
+const latest = ensureRelease("latest", "自动更新通道", true);
+uploadTo(latest, "latest");
+
+// 2) v<version> release —— 版本存档
+const verRel = ensureRelease(`v${version}`, `TD工具箱 ${version}`, false);
+uploadTo(verRel, `v${version}`);
+
+console.log(`\n✅ 完整包 v${version} 已发布到 latest 与 v${version} 两个 release。`);
+console.log(`   自动更新地址：https://update.tokendun.cc/${OWNER}/${REPO}/releases/download/latest`);

scripts/publish-hot.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+// publish-hot.js —— 发布热更新包到自建 gitea。
+//
+// 用法：
+//   GIT_TOKEN=xxx node scripts/publish-hot.js --version 1.5.1 [--min 1.5.0] \
+//       [--notes "更新说明"] [--mandatory] [--requires-full]
+//   token 也可放在 ~/.tokendun-git-token 文件里（优先用环境变量 GIT_TOKEN）。
+//
+// 流程：打包 electron/+renderer/ 成 zip → sha256(+可选签名) → 写 hotupdate.json
+//       → gitea 的 tag=hot release：删旧 bundle/manifest、传新的。
+"use strict";
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const crypto = require("crypto");
+const { execFileSync } = require("child_process");
+
+const ROOT = path.join(__dirname, "..");
+const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf8"));
+
+// —— 参数 ——
+const argv = process.argv.slice(2);
+function arg(name, def) {
+  const i = argv.indexOf(name);
+  return i >= 0 && argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[i + 1] : def;
+}
+const has = (name) => argv.includes(name);
+const version = arg("--version", pkg.hotContentVersion || pkg.version);
+// 这是原生 Electron 壳的最低版本，不是热更内容版本。
+const minAppVersion = arg("--min", pkg.hotMinAppVersion || "1.5.0");
+const notes = arg("--notes", "");
+const mandatory = has("--mandatory");
+const requiresFull = has("--requires-full");
+const requiresFullAfterHot = has("--requires-full-after-hot");
+const fullAppVersion = arg("--full-app-version", "");
+
+// —— token ——
+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); }
+
+const OWNER = "mhgmh", REPO = "codex-market-app", TAG = "hot";
+// Authenticated writes go through the direct upstream host; public download
+// URLs must use update.tokendun.cc because that is what clients/users read.
+const API = `https://up.tokendun.cc/api/v1/repos/${OWNER}/${REPO}`;
+const DL = `https://update.tokendun.cc/${OWNER}/${REPO}/releases/download/${TAG}`;
+
+const OUT = path.join(ROOT, "dist-hot");
+fs.mkdirSync(OUT, { recursive: true });
+const bundleName = `bundle-${version}.zip`;
+const bundlePath = path.join(OUT, bundleName);
+
+// —— 0) 版本复用守卫：远端 manifest 已是该版本时拒绝发布（除非 --force）。
+// 客户端按 contentVersion 判断是否更新，同名覆盖会让已装用户永远收不到新内容。
+try {
+  const rel = JSON.parse(execFileSync("curl", ["-s", `-H`, `Authorization: token ${token}`,
+    `${API}/releases/tags/${TAG}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }));
+  const mAsset = (rel.assets || []).find((a) => a.name === "hotupdate.json");
+  if (mAsset) {
+    const remote = JSON.parse(execFileSync("curl", ["-s", "-H", `Authorization: token ${token}`,
+      mAsset.browser_download_url], { encoding: "utf8" }));
+    if (remote && remote.contentVersion === version && !has("--force")) {
+      console.error(`✖ 版本 ${version} 已发布过（远端 manifest contentVersion 相同）。`);
+      console.error("  客户端会认为已是最新而忽略同名覆盖。请递增 --version 后重试，或确需覆盖时加 --force。");
+      process.exit(1);
+    }
+  }
+} catch (e) { /* 拉不到远端 manifest 时不阻塞发布 */ }
+
+// —— 1) 打包（zip，deflate，可被 lib/zip.js 解压）——
+fs.rmSync(bundlePath, { force: true });
+console.log(`打包 electron/ + renderer/ → ${bundleName} …`);
+execFileSync("zip", ["-r", "-X", "-q", bundlePath, "electron", "renderer",
+  "-x", "*.map", "-x", "*/node_modules/*"], { cwd: ROOT, stdio: "inherit" });
+
+// —— 2) sha256（+ 可选 ed25519 签名）——
+const buf = fs.readFileSync(bundlePath);
+const sha256 = crypto.createHash("sha256").update(buf).digest("hex");
+let signature = "";
+try {
+  const keyPath = path.join(os.homedir(), ".codex-hot-key.pem"); // 私钥（不入库）
+  if (fs.existsSync(keyPath)) {
+    const key = fs.readFileSync(keyPath);
+    signature = crypto.sign(null, Buffer.from(`${sha256}:${version}`), key).toString("base64");
+    console.log("已用本地私钥签名");
+  }
+} catch (e) { console.warn("签名跳过：" + e.message); }
+
+// —— 3) manifest ——
+const manifest = {
+  contentVersion: version,
+  minAppVersion,
+  requiresFull,
+  requiresFullAfterHot,
+  fullAppVersion,
+  bundleUrl: `${DL}/${bundleName}`,
+  size: buf.length,
+  sha256,
+  signature,
+  notes,
+  mandatory,
+};
+const manifestPath = path.join(OUT, "hotupdate.json");
+fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+console.log(`sha256=${sha256}  size=${(buf.length / 1048576).toFixed(2)}MB`);
+
+// —— 4) gitea API ——
+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; }
+}
+
+// 确保 hot release 存在
+let rel = apiJson("GET", `/releases/tags/${TAG}`);
+if (!rel || !rel.id) {
+  console.log("创建 hot release …");
+  rel = apiJson("POST", `/releases`, { tag_name: TAG, target_commitish: "main", name: "热更新通道", body: "asar 热更新包（自动发布）", draft: false, prerelease: false });
+}
+if (!rel || !rel.id) { console.error("无法创建/获取 hot release"); process.exit(1); }
+
+// 删除同名旧 asset
+for (const a of rel.assets || []) {
+  if (a.name === bundleName || a.name === "hotupdate.json" || /^bundle-.*\.zip$/.test(a.name)) {
+    api("DELETE", `/releases/${rel.id}/assets/${a.id}`);
+    console.log("删除旧 asset:", a.name);
+  }
+}
+// 上传 bundle + manifest
+function upload(file, name) {
+  const code = execFileSync("curl", ["-s", "-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" });
+  console.log(`上传 ${name} → HTTP ${code}`);
+  if (code !== "201") {
+    console.error(`上传 ${name} 失败，HTTP ${code}`);
+    process.exit(1);
+  }
+}
+upload(bundlePath, bundleName);
+upload(manifestPath, "hotupdate.json");
+
+console.log(`\n✅ 热更 v${version} 已发布。`);
+console.log(`   minAppVersion=${minAppVersion}  mandatory=${mandatory}  requiresFull=${requiresFull}`);
+console.log(`   客户端将从 ${API}/releases/tags/${TAG} 检测到。`);

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);
+  });

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",
+  ]);
+});

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/);
+});

test/codex-data-dir.test.js

@@ -0,0 +1,167 @@
+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-${id}.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 });
+  }
+});
+
+test("会话列表默认限量，避免大量历史记录一次性阻塞 IPC", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-market-data-dir-"));
+  const userData = path.join(root, "user-data");
+  const dataDir = path.join(root, "many-codex");
+  fs.mkdirSync(userData, { recursive: true });
+  for (let i = 0; i < 520; i++) {
+    const id = `${String(i).padStart(8, "0")}-1111-4111-8111-111111111111`;
+    writeRollout(dataDir, id, `第 ${i} 份记录`);
+  }
+
+  try {
+    const { dataDir: codexDir, sessions } = loadModules(userData);
+    codexDir.set(dataDir);
+    assert.equal(sessions.listConversations().length, 500);
+    assert.equal(sessions.listConversations({ limit: 12 }).length, 12);
+    assert.equal(sessions.listConversations({ limit: 9999 }).length, 520);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("subagent 同时含 id/session_id 时使用自身 id，不误绑定父线程", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-market-data-dir-"));
+  const userData = path.join(root, "user-data");
+  const dataDir = path.join(root, "subagent-codex");
+  const parentId = "33333333-3333-4333-8333-333333333333";
+  const childId = "44444444-4444-4444-8444-444444444444";
+  const dir = path.join(dataDir, "sessions", "2026", "08", "17");
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `rollout-${childId}.jsonl`), [
+    JSON.stringify({
+      type: "session_meta",
+      payload: {
+        id: childId,
+        session_id: parentId,
+        cwd: "/work/subagent",
+        timestamp: "2026-08-17T10:00:00.000Z",
+        thread_source: "subagent",
+      },
+    }),
+    JSON.stringify({ type: "event_msg", payload: { type: "user_message", message: "子任务" } }),
+  ].join("\n") + "\n");
+
+  try {
+    const { dataDir: codexDir, sessions } = loadModules(userData);
+    codexDir.set(dataDir);
+    const items = sessions.listConversations({ includeSubagent: true, limit: 10 });
+    assert.equal(items.length, 1);
+    assert.equal(items[0].id, childId);
+    const conversation = sessions.readConversation(items[0].path);
+    assert.equal(conversation.meta.id, childId);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+
+test("一键清空会话会清理正文、索引、状态库和侧栏目录并保留备份", async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-market-clear-sessions-"));
+  const userData = path.join(root, "user-data");
+  const dataDir = path.join(root, "codex");
+  const id = "55555555-5555-4555-8555-555555555555";
+  fs.mkdirSync(userData, { recursive: true });
+  writeRollout(dataDir, id, "待清除会话");
+  fs.mkdirSync(path.join(dataDir, "archived_sessions", "2026", "08"), { recursive: true });
+  fs.writeFileSync(path.join(dataDir, "archived_sessions", "2026", "08", `rollout-${id}.jsonl`), "archived\n");
+  fs.writeFileSync(path.join(dataDir, "session_index.jsonl"), JSON.stringify({ id, thread_name: "待清除会话" }) + "\n");
+  const SQL = require("sql.js");
+  const init = await SQL({ locateFile: (file) => path.join(__dirname, "../node_modules/sql.js/dist", file) });
+  const state = new init.Database();
+  state.run("CREATE TABLE threads (id TEXT PRIMARY KEY, title TEXT)");
+  state.run("CREATE TABLE thread_artifacts (thread_id TEXT, payload TEXT)");
+  state.run("INSERT INTO threads VALUES (?, ?)", [id, "待清除会话"]);
+  state.run("INSERT INTO thread_artifacts VALUES (?, ?)", [id, "artifact"]);
+  fs.writeFileSync(path.join(dataDir, "state_5.sqlite"), Buffer.from(state.export()));
+  state.close();
+  fs.mkdirSync(path.join(dataDir, "sqlite"), { recursive: true });
+  const catalog = new init.Database();
+  catalog.run("CREATE TABLE local_thread_catalog (thread_id TEXT, display_title TEXT)");
+  catalog.run("CREATE TABLE automations (id TEXT PRIMARY KEY, name TEXT)");
+  catalog.run("INSERT INTO local_thread_catalog VALUES (?, ?)", [id, "待清除会话"]);
+  catalog.run("INSERT INTO automations VALUES (?, ?)", ["keep", "保留自动化"]);
+  fs.writeFileSync(path.join(dataDir, "sqlite", "codex-dev.db"), Buffer.from(catalog.export()));
+  catalog.close();
+
+  try {
+    const { dataDir: codexDir, sessions } = loadModules(userData);
+    codexDir.set(dataDir);
+    const result = await sessions.clearAllConversations();
+    assert.equal(result.filesRemoved, 2);
+    assert.equal(sessions.listConversations({ includeArchived: true, includeSubagent: true }).length, 0);
+    assert.equal(fs.readFileSync(path.join(dataDir, "session_index.jsonl"), "utf-8"), "");
+    assert.equal(fs.existsSync(result.backup), true);
+    const stateAfter = new init.Database(fs.readFileSync(path.join(dataDir, "state_5.sqlite")));
+    assert.equal(stateAfter.exec("SELECT COUNT(*) FROM threads")[0].values[0][0], 0);
+    assert.equal(stateAfter.exec("SELECT COUNT(*) FROM thread_artifacts")[0].values[0][0], 0);
+    stateAfter.close();
+    const catalogAfter = new init.Database(fs.readFileSync(path.join(dataDir, "sqlite", "codex-dev.db")));
+    assert.equal(catalogAfter.exec("SELECT COUNT(*) FROM local_thread_catalog")[0].values[0][0], 0);
+    assert.equal(catalogAfter.exec("SELECT COUNT(*) FROM automations")[0].values[0][0], 1);
+    catalogAfter.close();
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

test/codex-desktop.test.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const codexDesktop = require("../electron/lib/codex_desktop");
+
+test("native dictation cleanup moves only the bounded Codex dialog off-screen", async () => {
+  let command = null;
+  const result = await codexDesktop.hideGlobalDictationWindows({
+    execFile(file, args, options, callback) {
+      command = { file, args, options };
+      callback(null, "2\n", "");
+    },
+  });
+
+  if (process.platform === "darwin") {
+    assert.equal(result.ok, true);
+    assert.equal(result.status, "hidden");
+    assert.equal(result.hidden, 2);
+    assert.equal(command.file, "osascript");
+    assert.deepEqual(command.args.slice(0, 1), ["-e"]);
+    assert.match(command.args[1], /titleText is "Codex"/);
+    assert.match(command.args[1], /subroleText is "AXDialog"/);
+    assert.match(command.args[1], /set position of w to \{-10000, -10000\}/);
+  } else {
+    assert.equal(result.ok, false);
+    assert.equal(result.status, "unsupported-platform");
+    assert.equal(result.hidden, 0);
+    assert.equal(command, null);
+  }
+});

test/deeplink.test.js

@@ -0,0 +1,34 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { parseTdToolboxImport } = require("../electron/lib/deeplink");
+
+const validUrl =
+  "tdtoolbox://v1/import?resource=provider&app=codex&name=Sub2API&endpoint=https%3A%2F%2Fapi.example.com&apiKey=sk-test&model=gpt-5.5&source=sub2api&sourceGroupId=42";
+
+test("parses a valid Sub2API provider deep link", () => {
+  const result = parseTdToolboxImport(validUrl);
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.input, {
+    resource: "provider",
+    app: "codex",
+    name: "Sub2API",
+    endpoint: "https://api.example.com",
+    apiKey: "sk-test",
+    model: "gpt-5.5",
+    source: "sub2api",
+    sourceGroupId: "42",
+  });
+});
+
+test("rejects unsupported schemes, endpoints, and sources", () => {
+  for (const url of [
+    "ccswitch://v1/import?resource=provider",
+    validUrl.replace("endpoint=https%3A%2F%2Fapi.example.com", "endpoint=ftp%3A%2F%2Fapi.example.com"),
+    validUrl.replace("source=sub2api", "source=unknown"),
+  ]) {
+    const result = parseTdToolboxImport(url);
+    assert.equal(result.ok, false);
+    assert.ok(result.error);
+  }
+});

test/global-dictation.test.js

@@ -0,0 +1,440 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const globalDictation = require("../electron/lib/global_dictation");
+
+function fixture(state = {}) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "td-global-dictation-"));
+  const file = path.join(home, ".codex-global-state.json");
+  fs.writeFileSync(file, JSON.stringify(state, null, 2) + "\n");
+  return { home, file };
+}
+
+test("disables persistent dictation bar without changing unrelated state", { concurrency: false }, () => {
+  const fx = fixture({
+    globalDictationHotkey: "LeftCommand",
+    "global-dictation-keep-visible": true,
+    "project-order": ["/work/a"],
+    nested: { enabled: true },
+  });
+
+  try {
+    const result = globalDictation.disableKeepVisible({ codexHome: fx.home });
+    const saved = JSON.parse(fs.readFileSync(fx.file, "utf8"));
+    const backup = JSON.parse(fs.readFileSync(fx.file + ".td-before-global-dictation.bak", "utf8"));
+
+    assert.equal(result.ok, true);
+    assert.equal(result.changed, true);
+    assert.equal(saved["global-dictation-keep-visible"], false);
+    assert.equal(saved.globalDictationHotkey, "LeftCommand");
+    assert.deepEqual(saved["project-order"], ["/work/a"]);
+    assert.deepEqual(saved.nested, { enabled: true });
+    assert.equal(backup["global-dictation-keep-visible"], true);
+    assert.equal(fs.readdirSync(fx.home).some((name) => name.endsWith(".td-dictation.tmp")), false);
+  } finally {
+    fs.rmSync(fx.home, { recursive: true, force: true });
+  }
+});
+
+test("changes only the keep-visible token instead of rewriting the state file", { concurrency: false }, () => {
+  const fx = fixture({
+    before: "保留",
+    "global-dictation-keep-visible": true,
+    after: { nested: 1 },
+  });
+
+  try {
+    const original = fs.readFileSync(fx.file);
+    const tokenOffset = original.indexOf(Buffer.from(" true"));
+    const result = globalDictation.disableKeepVisible({ codexHome: fx.home });
+    const saved = fs.readFileSync(fx.file);
+
+    assert.equal(result.ok, true);
+    assert.equal(saved.subarray(0, tokenOffset).equals(original.subarray(0, tokenOffset)), true);
+    assert.equal(saved.subarray(tokenOffset, tokenOffset + 5).toString("ascii"), "false");
+    assert.equal(saved.subarray(tokenOffset + 5).equals(original.subarray(tokenOffset + 5)), true);
+  } finally {
+    fs.rmSync(fx.home, { recursive: true, force: true });
+  }
+});
+
+test("atomically rewrites minified state while preserving unrelated state", { concurrency: false }, () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "td-global-dictation-minified-"));
+  const file = path.join(home, ".codex-global-state.json");
+  const original = Buffer.from('{"global-dictation-keep-visible":true,"untouched":1,"nested":{"enabled":true}}');
+  fs.writeFileSync(file, original);
+
+  try {
+    const result = globalDictation.disableKeepVisible({ codexHome: home });
+    const saved = JSON.parse(fs.readFileSync(file, "utf8"));
+    assert.equal(result.ok, true);
+    assert.equal(result.reason, "disabled-atomic");
+    assert.equal(saved["global-dictation-keep-visible"], false);
+    assert.equal(saved.untouched, 1);
+    assert.deepEqual(saved.nested, { enabled: true });
+    assert.equal(fs.readFileSync(file).equals(original), false);
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("persistent lock prevents an unsafe concurrent write", { concurrency: false }, () => {
+  const fx = fixture({ "global-dictation-keep-visible": true, untouched: 1 });
+  const lock = fx.file + ".td-dictation.lock";
+  fs.writeFileSync(lock, "busy");
+
+  try {
+    const result = globalDictation.disableKeepVisible({ codexHome: fx.home, lockWaitMs: 0 });
+    const saved = JSON.parse(fs.readFileSync(fx.file, "utf8"));
+
+    assert.equal(result.ok, false);
+    assert.equal(result.reason, "locked");
+    assert.equal(saved["global-dictation-keep-visible"], true);
+    assert.equal(saved.untouched, 1);
+  } finally {
+    fs.rmSync(fx.home, { recursive: true, force: true });
+  }
+});
+
+test("creates an explicit disabled state when the state file is absent", { concurrency: false }, () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "td-global-dictation-missing-"));
+  const file = path.join(home, ".codex-global-state.json");
+
+  try {
+    const result = globalDictation.disableKeepVisible({ codexHome: home });
+    const saved = JSON.parse(fs.readFileSync(file, "utf8"));
+
+    assert.equal(result.ok, true);
+    assert.equal(result.changed, true);
+    assert.equal(result.reason, "created-disabled");
+    assert.deepEqual(saved, { "global-dictation-keep-visible": false });
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("recognizes only the exact global dictation page route", () => {
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "page",
+    url: "app://-/index.html?initialRoute=/global-dictation",
+  }), true);
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "page",
+    url: "app://-/index.html?initialRoute=%2Fglobal-dictation",
+  }), true);
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "page",
+    url: "app://-/index.html?initialRoute=global-dictation",
+  }), true);
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "page",
+    url: "app://-/index.html",
+  }), false);
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "page",
+    url: "app://-/index.html?initialRoute=/avatar-overlay",
+  }), false);
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "worker",
+    url: "app://-/index.html?initialRoute=/global-dictation",
+  }), false);
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "page",
+    url: "https://example.com/index.html?initialRoute=/global-dictation",
+  }), false);
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "page",
+    url: "app://other/index.html?initialRoute=/global-dictation",
+  }), false);
+  assert.equal(globalDictation.isGlobalDictationTarget({
+    type: "page",
+    url: "app://-/other.html?initialRoute=/global-dictation",
+  }), false);
+  assert.equal(globalDictation.isCodexMainTarget({
+    type: "page",
+    url: "app://-/index.html?theme=light",
+  }), true);
+  assert.equal(globalDictation.isCodexMainTarget({
+    type: "page",
+    url: "app://-/index.html?initialRoute=/avatar-overlay",
+  }), false);
+});
+
+test("closes only global dictation targets through CDP HTTP", async () => {
+  const calls = [];
+  const initialTargets = [
+    { id: "main", type: "page", url: "app://-/index.html" },
+    { id: "avatar", type: "page", url: "app://-/index.html?initialRoute=/avatar-overlay" },
+    { id: "dictation", type: "page", url: "app://-/index.html?initialRoute=%2Fglobal-dictation" },
+  ];
+  const remainingTargets = initialTargets.filter((target) => target.id !== "dictation");
+  let listCount = 0;
+  const fetchImpl = async (url) => {
+    calls.push(url);
+    if (url.endsWith("/json")) {
+      const targets = listCount++ === 0 ? initialTargets : remainingTargets;
+      return { ok: true, json: async () => targets };
+    }
+    return { ok: true };
+  };
+
+  const result = await globalDictation.closeGlobalDictationTargets(19222, { fetchImpl });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.available, true);
+  assert.equal(result.matched, 1);
+  assert.equal(result.closed, 1);
+  assert.equal(result.remaining, 0);
+  assert.equal(result.status, "closed");
+  assert.deepEqual(calls, [
+    "http://127.0.0.1:19222/json",
+    "http://127.0.0.1:19222/json/close/dictation",
+    "http://127.0.0.1:19222/json",
+  ]);
+});
+
+test("CDP unavailable is reported as unavailable instead of success", async () => {
+  const result = await globalDictation.closeGlobalDictationTargets(19222, {
+    fetchImpl: async () => {
+      throw new Error("connection refused");
+    },
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.available, false);
+  assert.equal(result.status, "port-unavailable");
+  assert.equal(result.matched, 0);
+  assert.equal(result.closed, 0);
+  assert.equal(result.remaining, null);
+});
+
+test("does not close a matching route on a foreign debug endpoint", async () => {
+  const calls = [];
+  const fetchImpl = async (url) => {
+    calls.push(url);
+    return {
+      ok: true,
+      json: async () => [{
+        id: "foreign-dictation",
+        type: "page",
+        url: "app://-/index.html?initialRoute=/global-dictation",
+      }],
+    };
+  };
+
+  const result = await globalDictation.closeGlobalDictationTargets(19222, {
+    fetchImpl,
+    endpointOwnerVerifier: async () => ({ verified: true, owned: false, reason: "other app" }),
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "foreign-endpoint");
+  assert.equal(result.closed, 0);
+  assert.deepEqual(calls, ["http://127.0.0.1:19222/json"]);
+});
+
+test("closes an orphaned dictation target only when the port owner is Codex", async () => {
+  const calls = [];
+  let listCount = 0;
+  const fetchImpl = async (url) => {
+    calls.push(url);
+    if (url.endsWith("/json")) {
+      const targets = listCount++ === 0
+        ? [{ id: "orphan", type: "page", url: "app://-/index.html?initialRoute=/global-dictation" }]
+        : [];
+      return { ok: true, json: async () => targets };
+    }
+    return { ok: true };
+  };
+
+  const result = await globalDictation.closeGlobalDictationTargets(19222, {
+    fetchImpl,
+    endpointOwnerVerifier: async () => ({ verified: true, owned: true, reason: "Codex" }),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.status, "closed");
+  assert.equal(result.closed, 1);
+  assert.deepEqual(calls, [
+    "http://127.0.0.1:19222/json",
+    "http://127.0.0.1:19222/json/close/orphan",
+    "http://127.0.0.1:19222/json",
+  ]);
+});
+
+test("aborts a slow orphan owner check at the shared deadline", async () => {
+  let verifierSignal;
+  const fetchImpl = async (url) => {
+    assert.equal(url, "http://127.0.0.1:19222/json");
+    return {
+      ok: true,
+      json: async () => [{
+        id: "orphan",
+        type: "page",
+        url: "app://-/index.html?initialRoute=/global-dictation",
+      }],
+    };
+  };
+  const endpointOwnerVerifier = async (_port, options) => {
+    verifierSignal = options.signal;
+    await new Promise((resolve) => {
+      if (options.signal.aborted) resolve();
+      else options.signal.addEventListener("abort", resolve, { once: true });
+    });
+    return { verified: false, owned: false, reason: "timed out" };
+  };
+
+  const result = await globalDictation.closeGlobalDictationTargets(19222, {
+    fetchImpl,
+    endpointOwnerVerifier,
+    ownerTimeoutMs: 20,
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "unverified-endpoint");
+  assert.equal(verifierSignal.aborted, true);
+});
+
+test("reports when keep-visible immediately recreates the target", async () => {
+  const initialTargets = [
+    { id: "main", type: "page", url: "app://-/index.html" },
+    { id: "dictation-a", type: "page", url: "app://-/index.html?initialRoute=/global-dictation" },
+  ];
+  const recreatedTargets = [
+    initialTargets[0],
+    { id: "dictation-b", type: "page", url: "app://-/index.html?initialRoute=/global-dictation" },
+  ];
+  let listCount = 0;
+  const fetchImpl = async (url) => {
+    if (url.endsWith("/json")) {
+      return {
+        ok: true,
+        json: async () => listCount++ === 0 ? initialTargets : recreatedTargets,
+      };
+    }
+    return { ok: true };
+  };
+
+  const result = await globalDictation.closeGlobalDictationTargets(19222, {
+    fetchImpl,
+    retries: 0,
+    settleMs: 0,
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "still-present");
+  assert.equal(result.closed, 1);
+  assert.equal(result.remaining, 1);
+  assert.deepEqual(result.targetIds, ["dictation-b"]);
+});
+
+test("retries when Codex immediately recreates the dictation target", async () => {
+  const main = { id: "main", type: "page", url: "app://-/index.html" };
+  const targetA = { id: "dictation-a", type: "page", url: "app://-/index.html?initialRoute=/global-dictation" };
+  const targetB = { id: "dictation-b", type: "page", url: "app://-/index.html?initialRoute=/global-dictation" };
+  const targetLists = [
+    [main, targetA],
+    [main, targetB],
+    [main, targetB],
+    [main],
+  ];
+  let listCount = 0;
+  const closed = [];
+  const fetchImpl = async (url) => {
+    if (url.endsWith("/json")) {
+      const targets = targetLists[Math.min(listCount, targetLists.length - 1)];
+      listCount += 1;
+      return { ok: true, json: async () => targets };
+    }
+    closed.push(url.split("/").pop());
+    return { ok: true };
+  };
+
+  const result = await globalDictation.closeGlobalDictationTargets(19222, {
+    fetchImpl,
+    settleMs: 0,
+    retryDelayMs: 0,
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.status, "closed");
+  assert.equal(result.closed, 2);
+  assert.equal(result.attempts, 2);
+  assert.deepEqual(closed, ["dictation-a", "dictation-b"]);
+});
+
+test("target response body parsing cannot outlive the configured timeout", async () => {
+  const result = await globalDictation.closeGlobalDictationTargets(19222, {
+    timeoutMs: 20,
+    fetchImpl: async () => ({
+      ok: true,
+      json: async () => new Promise(() => {}),
+    }),
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.available, false);
+  assert.equal(result.status, "timeout");
+  assert.equal(result.closed, 0);
+});
+
+test("failed post-close verification is not reported as success", async () => {
+  const initialTargets = [
+    { id: "main", type: "page", url: "app://-/index.html" },
+    { id: "dictation", type: "page", url: "app://-/index.html?initialRoute=/global-dictation" },
+  ];
+  let listCount = 0;
+  const fetchImpl = async (url) => {
+    if (url.endsWith("/json")) {
+      listCount += 1;
+      if (listCount > 1) throw new Error("verification endpoint disconnected");
+      return { ok: true, json: async () => initialTargets };
+    }
+    return { ok: true };
+  };
+
+  const result = await globalDictation.closeGlobalDictationTargets(19222, { fetchImpl });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.status, "verification-failed");
+  assert.equal(result.closed, 1);
+  assert.equal(result.remaining, null);
+  assert.match(result.errors.join(" "), /verification endpoint disconnected/);
+});
+
+test("custom cleanup calls do not share stale targets or abort signals", async () => {
+  const firstTargets = [
+    { id: "main-a", type: "page", url: "app://-/index.html" },
+    { id: "dictation-a", type: "page", url: "app://-/index.html?initialRoute=/global-dictation" },
+  ];
+  const secondTargets = [
+    { id: "main-b", type: "page", url: "app://-/index.html" },
+    { id: "dictation-b", type: "page", url: "app://-/index.html?initialRoute=/global-dictation" },
+  ];
+  const closed = [];
+  const fetchImpl = async (url) => {
+    if (url.includes("/json/close/")) {
+      closed.push(url.split("/").pop());
+      return { ok: true };
+    }
+    return { ok: true, json: async () => [] };
+  };
+
+  const first = globalDictation.closeGlobalDictationTargets(19222, {
+    fetchImpl,
+    targets: firstTargets,
+  });
+  const second = globalDictation.closeGlobalDictationTargets(19222, {
+    fetchImpl,
+    targets: secondTargets,
+  });
+
+  assert.notEqual(first, second);
+  await Promise.all([first, second]);
+  assert.deepEqual(closed.sort(), ["dictation-a", "dictation-b"]);
+});

test/hotupdate.test.js

@@ -0,0 +1,43 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const hotupdate = require("../electron/lib/hotupdate");
+
+test("旧壳先热更，再提示安装完整包", () => {
+  const result = hotupdate.evaluate(
+    {
+      contentVersion: "1.5.86",
+      minAppVersion: "1.5.0",
+      requiresFull: false,
+      requiresFullAfterHot: true,
+      fullAppVersion: "1.5.86",
+    },
+    "1.5.22",
+    "1.5.85",
+    "/tmp/codex-market-hot-test",
+  );
+
+  assert.equal(result.hasHot, true);
+  assert.equal(result.canHot, true);
+  assert.equal(result.needFull, false);
+  assert.equal(result.needFullAfterHot, true);
+  assert.equal(result.fullAppVersion, "1.5.86");
+});
+
+test("完整包版本一致后不再重复提示", () => {
+  const result = hotupdate.evaluate(
+    {
+      contentVersion: "1.5.86",
+      minAppVersion: "1.5.0",
+      requiresFull: false,
+      requiresFullAfterHot: true,
+      fullAppVersion: "1.5.86",
+    },
+    "1.5.86",
+    "1.5.86",
+    "/tmp/codex-market-hot-test",
+  );
+
+  assert.equal(result.hasHot, false);
+  assert.equal(result.needFullAfterHot, false);
+});

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;
+  }
+});

test/session-restore.test.js

@@ -0,0 +1,241 @@
+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");
+}
+
+async function writeLegacyPollutedState(root, id, subId) {
+  const SQL = await initSqlJs({ locateFile: (file) => path.join(__dirname, "../node_modules/sql.js/dist", file) });
+  const state = new SQL.Database();
+  state.run("CREATE TABLE threads (id TEXT PRIMARY KEY, source TEXT, thread_source TEXT, has_user_event INTEGER)");
+  state.run("INSERT INTO threads VALUES (?,?,?,?)", [id, "vscode", "user", 1]);
+  state.run("INSERT INTO threads VALUES (?,?,?,?)", [subId, "[object Object]", "subagent", 1]);
+  fs.writeFileSync(path.join(root, "state_5.sqlite"), Buffer.from(state.export()));
+  state.close();
+
+  fs.mkdirSync(path.join(root, "sqlite"), { recursive: true });
+  const catalog = new SQL.Database();
+  catalog.run("CREATE TABLE local_thread_catalog (thread_id TEXT PRIMARY KEY, thread_source TEXT)");
+  catalog.run("CREATE TABLE local_thread_catalog_metadata (id INTEGER PRIMARY KEY, catalog_revision INTEGER NOT NULL DEFAULT 0)");
+  catalog.run("INSERT INTO local_thread_catalog VALUES (?,?)", [id, "user"]);
+  catalog.run("INSERT INTO local_thread_catalog VALUES (?,?)", [subId, "subagent"]);
+  catalog.run("INSERT INTO local_thread_catalog_metadata VALUES (1,0)");
+  fs.writeFileSync(path.join(root, "sqlite", "codex-dev.db"), Buffer.from(catalog.export()));
+  catalog.close();
+}
+
+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"));
+    assert.equal(state.exec(`SELECT has_user_event FROM threads WHERE id='${subId}'`)[0].values[0][0], 0);
+    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);
+    // 子任务仍进 state 库，但不再作为 Codex 顶层侧栏任务展示；
+    // 否则大量 subagent 会话会污染侧栏，点击派生线程容易一直转圈。
+    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 顶层目录污染", { concurrency: false }, async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-session-repair-"));
+  const dataDir = path.join(root, "codex");
+  const userData = path.join(root, "app-data");
+  const id = "dddddddd-dddd-4ddd-8ddd-dddddddddddd";
+  const subId = "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee";
+  const originalLoad = Module._load;
+  const originalSpawnSync = childProcess.spawnSync;
+  const originalBundleRoot = global.__BUNDLE_ROOT__;
+
+  try {
+    fs.mkdirSync(userData, { recursive: true });
+    fs.mkdirSync(dataDir, { recursive: true });
+    await writeLegacyPollutedState(dataDir, id, subId);
+    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.repairLegacySessionVisibility(() => {});
+    assert.equal(result.stateRows, 1);
+    assert.equal(result.catalogRows, 1);
+
+    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 has_user_event FROM threads WHERE id='${subId}'`)[0].values[0][0], 0);
+    state.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);
+    assert.equal(catalog.exec(`SELECT COUNT(*) FROM local_thread_catalog WHERE thread_id='${subId}'`)[0].values[0][0], 0);
+    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/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: "",
+  });
+});

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\)/);
+});

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);
+});