zen-gitsync 2.17.29 → 2.17.30

package/README.md

@@ -384,7 +384,8 @@ A dedicated view for running coding agents across one or many projects. Every ta
 | Progress report | The console's **Instruction** pane reports where your running tasks actually stand instead of listing what was dispatched and what finished (the board already shows that). The master agent reads each running job — elapsed time, **its latest thinking**, **what mix of tools it has been calling**, **how long it has been silent**, and the latest output — and writes a short paragraph per report: what each task is doing, how far it has got, and whether it looks stuck. The thinking line is what makes this work for tasks that never write a line of prose (they are the common case — their output stays empty from start to finish); "looks stuck" now has to come with evidence — a silence figure, or a tool mix going in circles — instead of being inferred from a high call count. Reports appear on an interval you pick (5 / 10 / 15 / 30 / 60 minutes, or off) or whenever you hit **Report now**, and the newest one is shown with the facts behind it (project, elapsed, tool mix, latest thinking, last tool call, silence) while earlier ones stay browsable from the history list. Automatic reports are generated **server-side**, so the history keeps filling up while the tab is closed and is waiting for you when you come back. Nothing running means nothing filed: automatic reports are skipped outright, and **Report now** answers with a plain "no task is running right now" rather than filing an empty entry (no empty entries, no wasted model call), while two identical reports arriving seconds apart are collapsed into one so a double click leaves no duplicate. The paragraph is written in the UI language and, when a task's output is inconclusive, it says so rather than inventing progress |
 | Dispatch default prompts | Give every dispatch a standing prompt: one **global** entry that applies to all projects, plus one **per project** that is appended after it whenever you dispatch to that project (it supplements the global one rather than replacing it). Both are edited from the gear button in the console's composer; the combined text is prepended to the instruction, a "Default prompt (global + this project)" checkbox appears next to **Run now** so a single dispatch can opt out, and the instruction log records which level was attached. The prompt is copied onto the task at dispatch time, so editing the setting later never rewrites tasks that already exist; it lands in the task's own prompt field, where you can still edit it per task |
 | Open-with menu per project | Hovering a project row in the board's project list reveals two buttons: **Open folder** (straight to your file manager) and **Open with**, a menu holding file manager / terminal / `g ui` in a new tab plus every editor and AI tool (VS Code, Codex, OpenCode, Kimi Code, ZCode, DeepSeek Harness, and Claude Code in default or fully-approved mode). Tools that are not installed are dimmed and labelled "Not installed" — clicking one opens the very same install guide the top bar uses. Every action applies to that row's project only; the board's selection is never touched |
-| Task editor overlay | Clicking a board card opens the editor as an overlay: a flat sidebar holding the task list and prompt presets, then the task header, preset selector, executor split-button, the execution-log / clear-execution actions, and a chat-style execution body. The description collapses into a one-line "Task description (optional)" summary until clicked, showing a "Filled" badge and the attachment count once there is content. Opening the overlay lands the conversation on its **newest** turn rather than its first: the flow keeps re-pinning to the bottom while markdown highlighting and tool-call folding are still growing it after mount, and lets go as soon as you scroll yourself |
+| Task editor overlay | Clicking a board card opens the editor as an overlay: a flat sidebar holding the task list and prompt presets, then the task header, preset selector, executor split-button, the copy-execution / execution-log / clear-execution actions, and a chat-style execution body. The description collapses into a one-line "Task description (optional)" summary until clicked, showing a "Filled" badge and the attachment count once there is content. Opening the overlay lands the conversation on its **newest** turn rather than its first: the flow keeps re-pinning to the bottom while markdown highlighting and tool-call folding are still growing it after mount, and lets go as soon as you scroll yourself |
+| Copy execution content | **Copy execution content** in the task header puts the whole task — every turn, not just whatever is on screen — on the clipboard as plain Markdown: a header line for the task and its project, then one section per turn (`## Round N`, with the executor, status and start time on the line under it) holding the user's prompt, the agent's thinking, its tool calls (arguments and results in fenced blocks) and the model's output. It is assembled from the run records rather than scraped from the DOM, so what you get never depends on what happens to be selected. The user side goes through the same trimming the chat bubbles use, so what you copy is what you typed — the injected environment / memory blocks and the attachment list stay behind in `job.prompt`. Turns with nothing in them are skipped without renumbering the ones after them, and a task that has never run answers with a "nothing to copy" toast instead of putting an empty string on the clipboard |
 | Executor choice | Run each task with **Claude Code**, **OpenCode** or **Codex**. The global default is set in **Settings → General → Task executor** (`config.taskExecutor`); the split-button next to the run button switches it for the next run and remembers that pick in the browser. A continued conversation always stays on the executor that started it — Claude's `--resume`, OpenCode's `--session` and Codex's thread id are not interchangeable |
 | Attachments | Up to 9 files per task (image / PDF / text / Markdown / CSV / JSON / log, ≤ 20 MB each); images over 3.5 MB are re-encoded / downscaled in the browser before upload so 4K screenshots still fit what the model and the reader can take. Their absolute paths are appended to the prompt so the agent reads them directly. Right-click an image attachment to copy it to the system clipboard (`image/png` / `jpeg` / `webp` / `gif`) |
 | Prompt presets | Reusable prompt templates with `{{task.title}}` / `{{task.desc}}` / `{{repo.path}}` / `{{branch}}` variable interpolation |
@@ -396,10 +397,11 @@ A dedicated view for running coding agents across one or many projects. Every ta
 | Live log | The "执行日志 / Execution log" panel **opens by default** and auto-scrolls, showing accumulated `stdout` + `stderr` (last 64 KB rendered client-side; the server keeps up to 100 MB per job) |
 | Live status | Task status (pending / running / done / error / cancelled) and PID stream in real time over SSE |
 | Tool-call stream | The model's tool calls are rendered inline in the conversation flow, so you can follow what the agent actually did |
+| Inline images in a reply | The agent can put a picture in its reply body: write it as a Markdown image pointing at a local file — `![caption](C:\...\docs\shot.png)` — and it is rendered right in the conversation flow. That path is rewritten to a server endpoint that only serves images from **the task's own repository** (path traversal, absolute paths outside the repo and symlinks pointing out of it are all rejected, and the response carries `nosniff` plus a sandbox CSP), and the executor is told the syntax through the injected environment block — pasting a bare path is what it does otherwise, and a bare path or one wrapped in a code fence stays plain text. Follow-up turns carry a one-line version of the same hint. A file the run cannot read renders as a broken image rather than silently disappearing; png / jpg / jpeg / gif / webp / bmp / svg up to 20 MB |
 | Finish notice | When a run finishes or fails you get a chime (a distinct tone for done vs. error; stopping on purpose stays silent) plus an in-app toast while the page is in the foreground, and a system notification when it is not — so you can be looking at another view or window and still be told. The chime has its **own switch** under the notice toggle, so you can keep the notices but mute the sound, or the other way round. Sounds are CC0 assets under `public/sounds/`; see `CREDITS.txt` there to swap in another tone |
 | Cross-view indicator | While any Workbench task is running, a pulsing dot appears on the Workbench icon in the Activity Bar so you can see job state from the Git or Editor view |
 | Execution log manager (dialog) | The "Execution logs" button in the workbench top bar opens a dialog with the list / filter / batch delete / clear / retention-policy UI (defaults: 500 records, 256 MB); the task execution view stays mounted so no work-in-progress state is dropped |
-| Continue chat | After a task reaches a done / error / cancelled state, a follow-up composer appears; sending a message resumes the previous session (`claude --resume <session_id>` for Claude Code, `--session` for OpenCode, `codex exec resume <thread_id>` for Codex), and each new turn stacks into the same chat-style flow. Since the resumed session already carries the previous turn's context, follow-up turns inject only a **slim refresh** of the run-environment block (current project + board totals + truth-file paths) instead of the full project list — the chat log no longer repeats the same list every round |
+| Continue chat | After a task reaches a done / error / cancelled state, a follow-up composer appears; sending a message resumes the previous session (`claude --resume <session_id>` for Claude Code, `--session` for OpenCode, `codex exec resume <thread_id>` for Codex), and each new turn stacks into the same chat-style flow. Since the resumed session already carries the previous turn's context, follow-up turns inject only a **slim refresh** of the run-environment block (current project + board totals + truth-file paths) instead of the full project list. The bubbles show only what the user actually typed: the injected environment / memory blocks and the attachment list stay in the raw `job.prompt` (readable and copyable in the run log), so copying a conversation out and pasting it back no longer drags a whole round of background along |
 | Local tool detection | On startup + every 10 min the server probes 7 CLIs (`code`, `claude`, `codex`, `opencode`, `kimi`, `zcode`, `dsh`). Tools that are missing are dimmed and labelled "Not installed" — clicking one opens the install guide, and right-clicking a tool button offers an update to the latest published version |
 
 Prompt presets and tasks are persisted to `~/.zen-gitsync/prompts.json` and `~/.zen-gitsync/tasks.json` (cross-project, shared across repos); run history and the retention policy live in `jobs.json` / `jobs-config.json`, the master-agent console state in `orchestrator.json` (with its report history in `orchestrator-reports.json` — kept apart so the polled state file stays small), and task attachments under `~/.zen-gitsync/workbench-images/_task-<taskId>/`.
@@ -420,7 +422,7 @@ A dedicated view (robot icon in the activity bar) for chatting with the built-in
 | Task plan | Multi-step work gets a visible plan: the agent calls the built-in `update_plan` tool to split the task into 3-8 verifiable steps before touching anything, then updates each step's status as it goes. Steps render as a checklist with completed / in-progress / pending states and a `2/5` progress header — in the terminal as a `✓ / ▶ / ○` list, in the Web panel as a card that **stays visible even when the tool group is collapsed** (collapsing hides other tool calls, never the current plan) |
 | Recent-projects awareness | Ask "which of my projects need a pull?" and the agent calls its built-in `list_projects` tool instead of scanning the disk: it returns exactly the list behind the GUI's **Recent projects** panel (recent directories plus any directory a task was created in, with branch / ahead / behind / uncommitted counts and task progress), so the agent's answer and the UI agree. Ahead/behind reads local refs, so the agent can pass `refresh=true` to run a `git fetch` pass first when the question is about pulling |
 | Session persistence | All conversations are saved to `~/.zen-gitsync/agent-sessions/` as JSON files; the CLI agent (`g ai`) writes to the same directory so Web and CLI sessions are unified |
-| Skill / MCP plaza | The **Skill plaza** and **MCP plaza** tabs list skills and MCP servers from several sources, each with its description, weekly downloads / usage count and install state. Install one into the **current project** or into the **`g ai` agent** — entries already installed can be opened in the system file manager or uninstalled from the same row, and ones that still need environment variables are flagged. The installed list shows both the skill's own `name` and the on-disk id, since a repository often ships a skill whose `SKILL.md` calls itself something else. From a terminal, `g ai` lists what is installed with `/skills` (`/mcp` is an alias) |
+| Skill / MCP plaza | The **Skill plaza** and **MCP plaza** tabs list skills and MCP servers from several sources, each with its description, weekly downloads / usage count and install state. Install one into the **current project** (`<project>/.zen-gitsync/ai/skills/<id>/SKILL.md` and `<project>/.zen-gitsync/ai/mcp.json`) or into the **`g ai` agent** (`~/.zen-gitsync/ai/`, applying to every project) — zen-gitsync's own directories, not another tool's. Entries already installed can be opened in the system file manager or uninstalled from the same row, and ones that still need environment variables are flagged. The installed list shows both the skill's own `name` and the on-disk id, since a repository often ships a skill whose `SKILL.md` calls itself something else. From a terminal, `g ai` lists what is installed with `/skills` (`/mcp` is an alias) |
 | SSH-first cloning | When you ask it to clone a repo (or add a remote) it uses the SSH form — `git@github.com:owner/repo.git` / `git@gitee.com:owner/repo.git` — converting an `https://` URL first, so the clone never stalls on a Git Credential Manager username/password prompt; it falls back to https only when SSH genuinely fails (`Permission denied (publickey)` / host-key verification) and says which one it used. The same preference is injected into every workbench task, whose executor is an external CLI with a system prompt this app does not own |
 | Per-turn tool limit | A single message may trigger up to N tool calls in a row (default **200**, range 1–2000). Configurable in **Settings → AI models → Agent Runtime**; hitting the limit ends the turn and asks you to send another message. The same setting drives the CLI agent |
 | Preset questions | Quick-start buttons on the welcome screen for common tasks (view project structure, analyze code quality, write tests, check git status, start the project) |
@@ -470,6 +472,20 @@ git add --renormalize .
 
 All `package.json` scripts use **npm** (`npm install`, `npm run dev`, `npm run release`, etc.). The `package-lock.json` is git-ignored, so each developer generates it locally. The CLI's own `bin` entry and most devDeps are pinned to caret ranges.
 
+### Release
+
+`npm run release` (`scripts/release.js`) runs the whole publish in one shot: bump the patch version → `vue-tsc` type check → build the frontend → verify the package contents (`files` whitelist vs relative imports, plus a real `npm pack` manifest) → commit + tag + push → `npm publish` → `npm install -g zen-gitsync@<version>`.
+
+The last step is the slow one: the registry can take anywhere from seconds to over 30 minutes to make a freshly published version installable, so the script polls on two readiness signals (packument has the version / tarball is fetchable) and force-installs every 4 rounds — the probes only save a doomed call, **`npm` itself is the judge**. Each failed attempt prints an `[E404]` / `[EPERM]` short code, and giving up prints the breakdown of what it kept hitting.
+
+**You don't have to watch it.** When the run ends you get a desktop notification plus a sound (success and failure use different sounds), and the terminal / taskbar title switches to the result. All of it is best-effort and can never fail the release itself; pass `--no-notify` (or set `ZEN_NO_NOTIFY=1`) to turn it off. The three outcomes are reported separately, because "published but the global install failed" is neither success nor failure:
+
+- **release complete** — published to npm and the global version was verified.
+- **published, global not updated** — the version is on npm but the global install didn't land. Re-running the release won't help (the version number is taken); just run `npm install -g zen-gitsync@<version>`.
+- **release failed** — an earlier step (type check / package self-check / git / `npm publish`) aborted the run.
+
+Other switches: `--dry-run` (print the plan only), `--skip-push`, `--skip-self-update`, `--keep-instances`, `--poll-timeout=<seconds>`.
+
 ---
 
 ## CLI Commands
@@ -1051,7 +1067,8 @@ Activity Bar 第四个视图，在 GUI 内直接浏览并编辑项目文件：
 | 派发执行器 | 派出去的任务由哪个 CLI 跑：**对话模式**在输入框下方选，**指令模式**在派发栏选 —— 两处是同一个组件、同一份选择，与执行按钮的临时切换也共用。注意「引擎」和「执行器」不是一回事：只有**内置 g ai** 能在服务端跑工具循环、才有派发能力，所以对话模式下把引擎切成外部 CLI 时，执行器选择会换成一句「当前引擎只能对话，不能派发任务 —— 切到内置 g ai 才能派活」的说明，而不是让你点了个不会生效的下拉 |
 | 派发默认提示词 | 给每次派发配一段常驻提示词：一条**全局**的（所有项目都附加）+ 每个项目一条（派发到该项目时追加在全局之后，是补充而不是覆盖）。两者都在控制台输入区的齿轮按钮里设置；拼好的正文放在指令**之前**，「立即执行」旁边会多出一个「默认提示词（全局 + 本项目）」勾选，单次派发可以取消勾选，指令流水里也记下这条指令附带的是哪一级。提示词在派发那一刻就抄进任务自己的提示词字段，之后改设置不会回头改写已建任务，单条任务仍可再改 |
 | 项目行打开方式 | 编排台项目列表里 hover 任意一行会出现两个按钮：「打开文件夹」一键进资源管理器，以及「打开方式」菜单 —— 文件管理器 / 终端 / 新标签页跑 `g ui`，以及各编辑器与 AI 工具（VS Code、Codex、OpenCode、Kimi Code、ZCode、DeepSeek Harness，加上默认权限或完全批准的 Claude Code）。没安装的工具会置灰并标「未安装」，点它弹的是顶栏那套安装引导；菜单里的动作只作用于该行项目，不会改变看板选中态 |
-| 任务编辑器浮层 | 点击看板卡片时以浮层打开：左侧是扁平化的任务列表与提示词预置，右侧依次是任务头部、预置下拉、执行器 split 按钮、「执行日志 / 清空执行」动作，以及对话式执行主体。描述默认折叠成一行「任务描述（可选）」摘要，点击展开；已填写描述或挂有附件时摘要右侧显示「已填写」徽标与附件数量。打开浮层时对话流直接落在**最新一轮**而不是第一轮：正文异步高亮与工具调用折叠会在挂载后继续长高，这段时间里持续贴底，用户自己一滚就立刻撒手 |
+| 任务编辑器浮层 | 点击看板卡片时以浮层打开：左侧是扁平化的任务列表与提示词预置，右侧依次是任务头部、预置下拉、执行器 split 按钮、「复制执行内容 / 执行日志 / 清空执行」动作，以及对话式执行主体。描述默认折叠成一行「任务描述（可选）」摘要，点击展开；已填写描述或挂有附件时摘要右侧显示「已填写」徽标与附件数量。打开浮层时对话流直接落在**最新一轮**而不是第一轮：正文异步高亮与工具调用折叠会在挂载后继续长高，这段时间里持续贴底，用户自己一滚就立刻撒手 |
+| 复制执行内容 | 任务头部的「复制执行内容」把**整条任务**（所有轮次，不只是屏幕上那一段）以纯 Markdown 放进剪贴板：先是任务与项目的标题行，然后一轮一节（`## 第 N 轮`，下面一行是本轮执行器、状态与开始时间），每节依次是用户提示词、智能体思考、工具调用（参数与结果都放在围栏代码块里）与模型返回。内容是从执行记录现拼的、不是从 DOM 里抠的，所以复制到什么跟你当前选中了哪段文字无关。用户侧走的是与对话气泡同一套裁剪，复制出来的就是你真正说过的话 —— 注入的环境块 / 记忆块 / 附件清单留在 `job.prompt` 里不跟着出去。一个字都没有的轮次会被跳过，且不让后面的轮次跟着往前重编号；从没跑过的任务回答「暂无执行内容可复制」，而不是把空串写进剪贴板 |
 | 执行器选择 | 每个任务可用 **Claude Code** / **OpenCode** / **Codex** 执行。全局默认在 **设置 → 通用设置 → 任务执行器**（`config.taskExecutor`）；执行按钮旁的 split 按钮可临时切换下一次执行用的执行器，选择记在浏览器里。续聊固定沿用最初那个执行器 —— Claude 的 `--resume`、OpenCode 的 `--session`、Codex 的 thread id 互不通用 |
 | 附件 | 每个任务最多挂 9 个附件（图片 / PDF / 文本 / Markdown / CSV / JSON / log，单个 ≤ 20 MB）；超过 3.5 MB 的图片会先在浏览器里压缩（先按原分辨率转 WebP，压不下去再逐级降采样），4K 屏截图不用再手动裁剪；执行时绝对路径会自动追加到 prompt 末尾，智能体直接按路径读取。**右键图片附件可一键复制到系统剪贴板**（支持 png / jpeg / webp / gif） |
 | 提示词预置 | 可复用提示词模板，支持 `{{task.title}}` / `{{task.desc}}` / `{{repo.path}}` / `{{branch}}` 变量插值 |
@@ -1063,10 +1080,11 @@ Activity Bar 第四个视图，在 GUI 内直接浏览并编辑项目文件：
 | 实时日志 | 「执行日志」面板**默认展开**，方便随时回看上次执行结果；面板内自动滚到底，展示累积的 stdout / stderr（客户端渲染最近 64 KB，服务端单个 job 最多保留 100 MB 输出） |
 | 实时状态 | 任务状态（pending / running / done / error / cancelled）和 PID 通过 SSE 实时推送 |
 | 工具调用流 | 模型的工具调用直接渲染在对话流里，能看清智能体具体做了什么 |
+| 正文配图 | 智能体可以在回答正文里直接给你看图：按 Markdown 图片语法写 `![说明](C:\...\docs\shot.png)`，界面就在对话流里渲染出来。该路径会被重写成只服务**本任务仓库内**图片的后端端点（`..` 穿越、仓库外的绝对路径、指向仓库外的符号链接一律拒掉，响应带 `nosniff` 与 sandbox CSP）；同时通过注入的环境上下文块把这条写法告诉执行器 —— 不告诉它，它默认只会贴一行路径（裸路径、或放进代码块的路径，仍是纯文本）。续聊轮发的是这条提示的一句话版本。读不到的图会显示成裂图而不是悄悄消失；限 png / jpg / jpeg / gif / webp / bmp / svg，单张 20 MB |
 | 结束提示 | 任务结束或报错时响一声提示音（完成 / 出错各一种音色，主动停止不响），同时页面在前台弹应用内提示、页面在后台/别的窗口发系统通知，切到别的视图也不会漏掉结果。提示音在总开关下**有自己的开关**——可以"要提示但静音"，也可以反过来只要声音。音源是 CC0 资源（`public/sounds/`），换音色见同目录 `CREDITS.txt` |
 | 跨视图指示 | 任意任务运行中时，Activity Bar 上的工作台图标会显示脉动小圆点；切换到 Git 或编辑器视图也能看到运行状态 |
 | 执行日志管理（弹窗） | 顶部「执行日志」按钮唤起弹窗：列表 / 过滤 / 批量删除 / 清空 / 保留策略全部可在此一次性管理（默认保留 500 条、256 MB）；弹窗关闭后任务执行视图常驻，避免切换时不必要的卸载 |
-| 继续对话 | 任务进入终态（done / error / cancelled）后出现续聊输入框；发送续聊消息会用 `claude --resume <session_id>`（Claude Code）、`--session`（OpenCode）或 `codex exec resume <thread_id>`（Codex）续接上一轮会话，**新一轮 = 新 job**，多轮纵向堆叠成对话流。续接的会话本身就带着上一轮的上下文，所以续聊轮注入的是**精简刷新版**运行环境块（当前项目 + 看板合计 + 真相源路径），不再重发整份项目清单 —— 聊天记录里也就不会每轮复制一遍同一张表 |
+| 继续对话 | 任务进入终态（done / error / cancelled）后出现续聊输入框；发送续聊消息会用 `claude --resume <session_id>`（Claude Code）、`--session`（OpenCode）或 `codex exec resume <thread_id>`（Codex）续接上一轮会话，**新一轮 = 新 job**，多轮纵向堆叠成对话流。续接的会话本身就带着上一轮的上下文，所以续聊轮注入的是**精简刷新版**运行环境块（当前项目 + 看板合计 + 真相源路径），不再重发整份项目清单。对话气泡只显示用户真正说过的那句话 —— 注入的环境块 / 记忆块 / 附件清单仍留在 `job.prompt` 原文里（执行日志详情可看可复制），所以把对话复制出来再粘回续聊框时不会连带一整套背景一起回去 |
 | 本地工具检测 | 启动时 + 每 10 分钟探测 7 个 CLI（`code` / `claude` / `codex` / `opencode` / `kimi` / `zcode` / `dsh`）。未安装的工具置灰并标「未安装」，点击弹出安装引导；右键工具按钮可升级到最新已发布版本 |
 
 提示词预置与任务数据持久化到 `~/.zen-gitsync/prompts.json` 和 `~/.zen-gitsync/tasks.json`（跨项目共享）；执行历史与保留策略在 `jobs.json` / `jobs-config.json`，主 Agent 控制台状态在 `orchestrator.json`（进度报告历史另存 `orchestrator-reports.json` —— 与"配置和历史分两个文件"同一个理由：被 5s 轮询的那份要小），任务附件落盘在 `~/.zen-gitsync/workbench-images/_task-<taskId>/`。
@@ -1087,7 +1105,7 @@ Activity Bar 中的机器人图标视图，可直接在浏览器中与内置 AI
 | 任务计划 | 多步任务有一份看得见的计划：智能体在动手之前先调内置的 `update_plan` 工具，把任务拆成 3-8 个可核对的步骤，随后逐步更新状态。步骤以清单渲染，区分完成 / 进行中 / 待办三态，标题右侧带 `2/5` 进度 —— 终端里是 `✓ / ▶ / ○` 列表，Web 面板里是一张卡片，且**工具组折叠时仍然常驻**（折叠只藏别的工具调用，绝不藏当前计划） |
 | 最近项目感知 | 问「我哪些项目需要 pull」时，智能体调用内置的 `list_projects` 工具，而不是自己去扫盘：返回的就是 GUI「最近项目」面板那份清单（最近目录 + 建过任务的目录，带分支 / 领先 / 落后 / 未提交数与任务进度），回答与界面对得上。领先/落后读的是本地引用，因此问到"要不要拉"时它可以带 `refresh=true` 先联网 fetch 一轮再答 |
 | 会话持久化 | 所有对话保存为 JSON 文件到 `~/.zen-gitsync/agent-sessions/`；CLI 智能体（`g ai`）写入同一目录，Web 端与 CLI 端会话统一管理 |
-| Skill / MCP 广场 | **Skill 广场** 与 **MCP 广场** 两个 tab 列出多个来源的 Skill 与 MCP 服务，每项带说明、周下载 / 使用次数与安装状态。可安装到**当前项目**或 **`g ai` 智能体**；已安装的可在同一行「打开文件夹」定位到落盘位置，或直接卸载，还缺环境变量的会标出「还缺环境变量」。已安装清单同时显示 skill 自报的 `name` 和实际落盘的目录 id —— 仓库名和 `SKILL.md` 里自称的名字经常不是一个。终端侧 `g ai` 用 `/skills`（`/mcp` 为别名）查看已装清单 |
+| Skill / MCP 广场 | **Skill 广场** 与 **MCP 广场** 两个 tab 列出多个来源的 Skill 与 MCP 服务，每项带说明、周下载 / 使用次数与安装状态。可安装到**当前项目**（`<项目>/.zen-gitsync/ai/skills/<id>/SKILL.md` 与 `<项目>/.zen-gitsync/ai/mcp.json`）或 **`g ai` 智能体**（`~/.zen-gitsync/ai/`，对所有项目生效）—— 两处都是 zen-gitsync 自己的目录，不借别家工具的。已安装的可在同一行「打开文件夹」定位到落盘位置，或直接卸载，还缺环境变量的会标出「还缺环境变量」。已安装清单同时显示 skill 自报的 `name` 和实际落盘的目录 id —— 仓库名和 `SKILL.md` 里自称的名字经常不是一个。终端侧 `g ai` 用 `/skills`（`/mcp` 为别名）查看已装清单 |
 | 克隆优先 SSH | 让它克隆仓库（或加远端）时走 SSH 形式 —— `git@github.com:owner/repo.git` / `git@gitee.com:owner/repo.git`；拿到 `https://` 地址先换算，克隆不会停在 Git Credential Manager 的账号密码弹窗上。只有 SSH 真的不可用（`Permission denied (publickey)` / 主机密钥校验失败）才退回 https，并说明这次走的是哪条。同一条偏好也会注入到每个工作台任务的 prompt —— 那里执行器是外部 CLI，系统提示词不归本应用管，环境上下文块是唯一的注入口 |
 | 单轮工具调用上限 | 一条消息内智能体最多连续调用多少次工具（默认 **200**，可调范围 1–2000）。在 **设置 → AI 模型配置 → 智能体运行时** 中修改；达到上限本轮会被强制结束并提示再发一条消息继续。CLI 智能体共用同一项设置 |
 | 预设问题 | 开场界面提供快捷按钮（查看项目结构、分析代码质量、写测试、Git 状态检查、帮我启动项目）|
@@ -1133,6 +1151,20 @@ GUI 底栏版本号每个会话会向 npm 查询一次最新版本。检测到
 git add --renormalize .
 ```
 
+### 发布到 npm
+
+`npm run release`（`scripts/release.js`）一条命令跑完整个发版流程：patch 版本号 +1 → `vue-tsc` 类型检查 → 构建前端 → 发布物自检（`files` 白名单 vs 相对 import，外加一次真实 `npm pack` 清单）→ 提交 + 打标签 + 推送 → `npm publish` → `npm install -g zen-gitsync@<版本>`。
+
+最后一步最慢：registry 让刚发布的版本变得可安装，实测从几秒到 30 分钟以上都有，所以脚本用两个就绪信号（packument 里有没有该版本 / tarball 能否取到）轮询，并每 4 轮强制真装一次 —— 探针只负责省下一次注定失败的调用，**判据只有 npm 自己**。每次失败打 `[E404]` / `[EPERM]` 短码，放弃时汇总失败构成。
+
+**不用盯着它。** 流程结束时你会收到一条系统通知 + 提示音（成功与失败是两种不同的音），终端 / 任务栏标题也会变成结果。这些都是尽力而为，**绝不会**影响发布本身的成败；加 `--no-notify`（或设 `ZEN_NO_NOTIFY=1`）可关掉。三种结局分开报，因为"包发出去了但全局没装上"既不是成功也不是失败：
+
+- **发布完成** —— 已发布到 npm，且全局版本已校验通过。
+- **已发布但全局没更新** —— 版本已经在 npm 上，只是没装到全局。重发没有意义（版本号已被占用），按提示手动装一次即可。
+- **发布失败** —— 更早的一步（类型检查 / 发布物自检 / git / `npm publish`）把流程中断了。
+
+其它开关：`--dry-run`（只打印计划）、`--skip-push`、`--skip-self-update`、`--keep-instances`、`--poll-timeout=<秒>`。
+
 ---
 
 ## 命令行

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zen-gitsync",
-  "version": "2.17.29",
+  "version": "2.17.30",
   "description": "Auto commit, scheduled sync, and visual GUI for Git. Run `g` in any repo for one-key commit & push, AI commit messages, scheduled background sync, and a drag-and-drop workflow builder.",
   "main": "index.js",
   "type": "module",
@@ -40,6 +40,8 @@
     "verify:wb-dispatch": "node scripts/verify-workbench-dispatch-attach.cjs",
     "verify:wb-env-context": "node scripts/verify-workbench-env-context.mjs",
     "verify:wb-live-jobs": "node scripts/verify-wb-live-jobs.mjs",
+    "verify:wb-bubble-prompt": "node scripts/verify-wb-bubble-prompt.cjs",
+    "verify:wb-copy-execution": "node scripts/verify-wb-copy-execution.cjs",
     "verify:wb-overview": "node scripts/verify-workbench-overview.cjs",
     "verify:wb-progress-report": "node scripts/verify-wb-progress-report.cjs",
     "verify:wb-card-live": "node scripts/verify-wb-card-live.cjs",
@@ -96,7 +98,8 @@
     "npm:ls:g": "npm ls -g",
     "npm:2fa:get": "npm profile get",
     "npm:2fa:disable": "npm profile disable-2fa",
-    "verify:wb-select-popup": "node scripts/verify-native-select-popup.cjs"
+    "verify:wb-select-popup": "node scripts/verify-native-select-popup.cjs",
+    "verify:wb-inline-images": "node scripts/verify-wb-inline-images.mjs"
   },
   "files": [
     "src/ui/public/**",

package/scripts/release.js

@@ -31,6 +31,7 @@
  *   npm run release -- --poll-timeout=3600                # 窗口上限(秒,默认 1800 = 30 分钟)
  *   npm run release -- --poll-fast-window=600 --poll-slow-interval=60  # 600s 后退避到 60s 一跳
  *   npm run release -- --install-timeout=900               # 单次 npm install 上限(秒),0 = 不限时(默认)
+ *   npm run release -- --no-notify                         # 结束时不再弹系统通知 / 响提示音
  *
  * 发布后自更新:每轮看两个就绪信号(packument 里有没有这个版本 / tarball 能不能取),
  * 任一为真就真调 npm,并两条路(`pkg@<版本>` / tarball URL 直连)都试,装上后校验全局版本;
@@ -38,6 +39,11 @@
  * 原因见 tarballUrl() / selfUpdateGlobal() 处注释 —— publish 成功不等于
  * packument 立即可见,也不等于 tarball 立即可取(两种先后顺序都实测出现过)。
  *
+ * 结束时**离开终端也能收到**提醒(见 announceRelease):系统通知 + 提示音 + 终端标题。
+ * 装全局那步实测能磨十几分钟,用户不可能一直盯着;终端里再醒目的一行字,对已经走去
+ * 干别的事的人等于没打。三种结局(成功 / 已发布但全局没装上 / 失败)各有各的文案与音,
+ * 用 `--no-notify`(或环境变量 ZEN_NO_NOTIFY=1)可关掉。
+ *
  * "这一轮要不要真调 npm"的判定抽在 src/utils/selfUpdatePolicy.js(有单测);
  * 动那里的阈值/分支请连带跑 `node --test src/utils/selfUpdatePolicy.test.js`。
  *
@@ -61,6 +67,7 @@ import {
   classifyInstallError,
   FORCE_INSTALL_EVERY,
 } from '../src/utils/selfUpdatePolicy.js'
+import { notifyDesktop, setTerminalTitle } from '../src/utils/desktopNotify.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -71,6 +78,9 @@ const DRY_RUN = argv.includes('--dry-run')
 const SKIP_SELF_UPDATE = argv.includes('--skip-self-update')
 const SKIP_PUSH = argv.includes('--skip-push')
 const KEEP_INSTANCES = argv.includes('--keep-instances')
+// 关掉结束时的桌面提醒(系统通知 / 提示音 / 终端标题)。环境变量那份是给
+// "通过 npm script 起、不方便追加参数"的场景留的口子(CI / 别的工具代跑)。
+const NO_NOTIFY = argv.includes('--no-notify') || process.env.ZEN_NO_NOTIFY === '1'
 
 const NPM_REGISTRY = 'https://registry.npmjs.org/'
 const PKG_NAME = 'zen-gitsync'
@@ -365,8 +375,7 @@ async function checkEnvironment() {
       console.log(chalk.yellow('发布已取消'))
       process.exit(0)
     }
-    console.error(chalk.red('环境检查失败:'), err.message || err)
-    process.exit(1)
+    abortRelease('环境检查失败:', err.message || err)
   }
 }
 
@@ -386,8 +395,7 @@ async function runTypeCheck() {
     execSync('npx vue-tsc -b --noEmit', { cwd: frontendDir, stdio: 'inherit' })
     console.log(chalk.green('vue-tsc 类型检查通过'))
   } catch (err) {
-    console.error(chalk.red('vue-tsc 类型检查失败,请修复以上错误后重新发布'))
-    process.exit(1)
+    abortRelease('vue-tsc 类型检查失败,请修复以上错误后重新发布')
   }
 }
 
@@ -442,6 +450,8 @@ async function buildFrontend() {
     console.error(chalk.red('前端项目构建失败:'), err.message || err)
     const shouldContinue = await askContinue(chalk.yellow('前端构建失败,是否继续发布? (Y/n): '))
     if (!shouldContinue) {
+      // 这里**故意不提醒**:用户刚亲手回答了上面的提示,人就在键盘前(与 abortRelease 那些
+      // "进程自己撞墙"的出口不同,那些才需要把人叫回来)。
       console.log(chalk.red('发布流程已取消'))
       process.exit(1)
     }
@@ -467,11 +477,10 @@ async function verifyPackageContents() {
   try {
     execSync(`"${process.execPath}" --test test/package-files.test.mjs`, { cwd: rootDir, stdio: 'inherit' })
   } catch {
-    console.error(chalk.red(
+    abortRelease(
       '发布物自检失败:package.json#files 覆盖不全(上面哪几条 not ok 就补哪几个文件)。\n'
       + '继续发布会打出缺文件的包 —— 用户装上就是 ERR_MODULE_NOT_FOUND。'
-    ))
-    process.exit(1)
+    )
   }
   console.log(chalk.green('① files 覆盖所有被 import 的本地模块'))
 
@@ -482,15 +491,13 @@ async function verifyPackageContents() {
     // npm 可能在前/后混入提示行,这里取第一个 '[' 到最后一个 ']' 之间
     packJson = JSON.parse(out.slice(out.indexOf('['), out.lastIndexOf(']') + 1))
   } catch (err) {
-    console.error(chalk.red('npm pack --dry-run 失败:'), err.message || err)
-    process.exit(1)
+    abortRelease('npm pack --dry-run 失败:', err.message || err)
   }
 
   const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'))
   const packed = new Set((packJson[0]?.files || []).map((f) => f.path))
   if (packed.size === 0) {
-    console.error(chalk.red('npm pack 打出了空包,绝对有问题'))
-    process.exit(1)
+    abortRelease('npm pack 打出了空包,绝对有问题')
   }
 
   const notPacked = (pkg.files || []).filter((entry) => {
@@ -502,11 +509,10 @@ async function verifyPackageContents() {
   })
 
   if (notPacked.length) {
-    console.error(chalk.red(
+    abortRelease(
       `npm pack 里有 ${notPacked.length} 条 files 白名单没真正进包(大概率是 .npmignore / .gitignore 排除了):\n`
       + notPacked.map((e) => `  - ${e}`).join('\n')
-    ))
-    process.exit(1)
+    )
   }
   console.log(chalk.green(`② 真实打包 ${packed.size} 个文件,白名单逐条命中`))
 }
@@ -534,9 +540,9 @@ function stageReleaseFiles() {
     .filter(Boolean)
   const unexpected = stagedOut.filter((f) => !RELEASE_FILES.includes(f))
   if (unexpected.length) {
-    console.error(chalk.red('staged 范围超出白名单,中止提交:'))
-    for (const f of unexpected) console.error('  - ' + f)
-    process.exit(1)
+    abortRelease(
+      'staged 范围超出白名单,中止提交:\n' + unexpected.map((f) => `  - ${f}`).join('\n')
+    )
   }
 }
 
@@ -609,8 +615,7 @@ async function commitChanges(version) {
       }
     }
   } catch (err) {
-    console.error(chalk.red('Git 提交失败:'), err.message || err)
-    process.exit(1)
+    abortRelease('Git 提交失败:', err.message || err)
   }
 }
 
@@ -885,6 +890,11 @@ async function selfUpdateGlobal(version) {
     + `单次安装${INSTALL_TIMEOUT_MS > 0 ? `上限 ${INSTALL_TIMEOUT_MS / 1000}s` : '不限时'}`
     + '(可用 --install-timeout=<秒> 调,0 = 不限时)。'
   ))
+  console.log(chalk.gray(
+    '这一步可能要等几分钟到半小时,**不用盯着** —— 装好或彻底失败时会弹一条系统通知'
+    + ' + 响一声(成功失败两种音),终端标题也会变成结果。'
+    + (NO_NOTIFY ? '(本次带了 --no-notify,提醒已关掉)' : '(想关掉用 --no-notify)')
+  ))
 
   const startedAt = Date.now()
   const deadline = startedAt + POLL_TIMEOUT_MS
@@ -970,7 +980,7 @@ async function selfUpdateGlobal(version) {
 
     if (plan.attempt) {
       const res = await runInstallRound(packumentHasVersion)
-      if (res.ok) return
+      if (res.ok) return { ok: true }
     } else {
       skippedRounds += 1
       if (skippedRounds === FORCE_INSTALL_EVERY - 1) {
@@ -1015,7 +1025,7 @@ async function selfUpdateGlobal(version) {
       + '(探针可能误报,事实判据只有 npm 自己)。'
     ))
     const res = await runInstallRound(readPackumentHasVersion(version), '超时前补的真装')
-    if (res.ok) return
+    if (res.ok) return { ok: true }
   }
 
   console.error(chalk.red(
@@ -1055,9 +1065,22 @@ async function selfUpdateGlobal(version) {
     + '若报 ETARGET / E404(registry 元数据与 tarball 还没对齐),直连 tarball:\n'
     + `  npm install -g ${tarballUrl(version)}`
   ))
+
+  // 把结论交回调用方:这一阶段失败**不会**抛异常(包已经发布成功了,只是没装到全局),
+  // 所以 main() 那边光看有没有异常是分不出"全成了"和"只成了一半"的 ——
+  // 曾经这里什么都不返回,于是自更新失败时终端照样打出 "🎉 发布完成!"。
+  const tally = [...errorTally.entries()].sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k} ×${n}`)
+  return {
+    ok: false,
+    reason: tally.length
+      ? `${POLL_TIMEOUT_MS / 1000}s 内真调 npm ${installAttempts} 次仍未装上(${tally.join(' / ')})`
+      : `${POLL_TIMEOUT_MS / 1000}s 窗口内没装上(npm 没给出失败原因)`,
+  }
 }
 
-// 发布到 NPM
+// 发布到 NPM。返回 `{ published, selfUpdate, reason }` —— 自更新失败时 `published`
+// 仍是 true(包已经在 npm 上了),`selfUpdate: 'failed'` + `reason` 才是给 main() 拿去做
+// "已发布但全局没更新"提醒用的。`selfUpdate` 取值:`'ok' | 'failed' | 'skipped'`。
 async function publishToNpm(version) {
   console.log(chalk.blue('\n=== 发布到 NPM ==='))
 
@@ -1070,24 +1093,117 @@ async function publishToNpm(version) {
       console.log(chalk.yellow(
         '[dry-run] 安装前先停掉实例注册表里的所有运行实例(见 stopRunningInstances)'
       ))
-      return
+      return { published: false, selfUpdate: 'skipped', reason: '' }
     }
     execSync(`npm publish --registry=${NPM_REGISTRY}`, { stdio: 'inherit' })
     console.log(chalk.green('已成功发布到 NPM'))
 
     if (SKIP_SELF_UPDATE) {
       console.log(chalk.yellow('--skip-self-update: 不自动 `npm install -g zen-gitsync`'))
-      return
+      return { published: true, selfUpdate: 'skipped', reason: '--skip-self-update' }
     }
 
     // 发版后可选:把刚发布的版本装到全局(默认开启,可用 --skip-self-update 关掉)
-    await selfUpdateGlobal(version)
+    const selfUpdate = await selfUpdateGlobal(version)
+    return {
+      published: true,
+      selfUpdate: selfUpdate.ok ? 'ok' : 'failed',
+      reason: selfUpdate.reason ?? '',
+    }
   } catch (err) {
-    console.error(chalk.red('发布到 NPM 失败:'), err.message || err)
-    process.exit(1)
+    abortRelease('发布到 NPM 失败:', err.message || err)
   }
 }
 
+// ===========================================================================
+// 结束提醒(系统通知 + 提示音 + 终端标题)
+// ===========================================================================
+//
+// 为什么值得专门做:装全局那一步实测能磨十几分钟(registry 元数据/对象就绪慢,见文件头
+// 注释),而且整条流程常常是"开着就走人"的。终端里再醒目的一行字,对已经走去干别的事的
+// 人等于没打 —— 提醒必须走**终端之外**的信道(实现见 src/utils/desktopNotify.js)。
+//
+// 覆盖所有提前结束的出口:类型检查 / 发布物自检 / git / npm publish 失败原本都是直接
+// `process.exit(1)`,进程当场就没了,提醒根本没机会发 —— 而这些恰恰是最该被通知的结局
+// (用户走开 15 分钟,失败发生在第 40 秒)。所以它们统一改走 abortRelease()。
+
+// 发布时间与版本号挂在模块作用域:abortRelease() 可能在 updateVersion() 之前就被调用
+// (类型检查失败就是这么早),那时版本号还不存在,文案里得能优雅地少一段。
+let releaseStartedAt = 0
+let currentVersion = null
+
+// 秒数换成人话:"耗时 698.7s" 是给日志看的,"11 分 38 秒" 才是给通知看的
+function humanDuration(ms) {
+  const total = Math.max(0, Math.round(ms / 1000))
+  if (total < 60) return `${total} 秒`
+  return `${Math.floor(total / 60)} 分 ${total % 60} 秒`
+}
+
+// 通知正文压成一行并截断:toast 塞不下长文本,而报错原文常常是多行 + 一长串 URL
+function oneLine(text, max = 160) {
+  const s = String(text ?? '').replace(/\s+/g, ' ').trim()
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s
+}
+
+// 各结局的文案。集中在一处,是因为"通知里说什么"和"终端里说什么"必须是同一件事 ——
+// 尤其 partial:包已经发出去了,但全局没装上,报"发布完成"是误导,报"发布失败"也是误导。
+function releaseOutcome({ status, version, durationMs, reason }) {
+  const spent = humanDuration(durationMs)
+  if (status === 'ok') {
+    return {
+      ok: true,
+      title: `发布完成 · zen-gitsync v${version}`,
+      message: `已发布到 npm,全局版本已更新为 v${version}。耗时 ${spent}。`,
+    }
+  }
+  if (status === 'ok-skipped') {
+    return {
+      ok: true,
+      title: `发布完成 · zen-gitsync v${version}`,
+      message: `已发布到 npm。本次带 --skip-self-update,全局版本没动。耗时 ${spent}。`,
+    }
+  }
+  if (status === 'partial') {
+    return {
+      ok: false,
+      title: `已发布但全局没更新 · zen-gitsync v${version}`,
+      message: `npm 上已有 v${version},全局仍是旧版。${oneLine(reason)} `
+        + `手动装:npm install -g ${PKG_NAME}@${version}`,
+    }
+  }
+  return {
+    ok: false,
+    title: `发布失败 · zen-gitsync${version ? ` v${version}` : ''}`,
+    message: oneLine(reason || '见终端输出'),
+  }
+}
+
+// 发提醒 + 把结果写上终端标题。DRY_RUN 一律不提醒:什么都没发生,响一声只会让人以为发成功了。
+function announceRelease(outcome) {
+  if (DRY_RUN) return
+  setTerminalTitle(outcome.title)
+  if (NO_NOTIFY) {
+    console.log(chalk.gray('--no-notify:跳过系统通知 / 提示音(终端标题已更新)'))
+    return
+  }
+  notifyDesktop({ title: outcome.title, message: outcome.message, ok: outcome.ok })
+  console.log(chalk.gray('已发送结束提醒(系统通知 + 提示音;发不出去也不影响发布结果)'))
+}
+
+// 发布提前结束的统一出口:打日志 → 发提醒 → 退出 1。
+// 原本这些地方各自写 `console.error(...)` + `process.exit(1)`,提醒没机会发(见上面注释)。
+function abortRelease(message, detail) {
+  if (detail === undefined) console.error(chalk.red(message))
+  else console.error(chalk.red(message), detail)
+  announceRelease(releaseOutcome({
+    status: 'fail',
+    version: currentVersion,
+    durationMs: Date.now() - releaseStartedAt,
+    reason: detail ?? message,
+  }))
+  process.exit(1)
+}
+
 // 主流程
 async function main() {
   console.log(chalk.cyan(`\n🚀 开始发布流程${DRY_RUN ? '(DRY RUN)' : ''}...\n`))
@@ -1099,15 +1215,21 @@ async function main() {
   if (SKIP_SELF_UPDATE) console.log(chalk.yellow('--skip-self-update: 发版后不自动 npm install -g'))
   if (KEEP_INSTANCES) console.log(chalk.yellow('--keep-instances: 装全局前不停运行中的实例'))
   if (SKIP_PUSH) console.log(chalk.yellow('--skip-push: 不 push git'))
+  if (NO_NOTIFY) console.log(chalk.yellow('--no-notify: 结束时不再弹系统通知 / 响提示音'))
+
+  releaseStartedAt = Date.now()
+  // 先把"发布中"写上终端标题:整条流程常要十几分钟,人不在时任务栏那行字是唯一能看出
+  // "还在跑"的地方;结束时会被 announceRelease 换成结果。
+  if (!DRY_RUN) setTerminalTitle('发布中 · zen-gitsync')
 
   try {
     await checkEnvironment()
     await runTypeCheck()
-    const newVersion = updateVersion()
+    currentVersion = updateVersion()
     await buildFrontend()
     await verifyPackageContents()
-    await commitChanges(newVersion)
-    await publishToNpm(newVersion)
+    await commitChanges(currentVersion)
+    const { selfUpdate, reason } = await publishToNpm(currentVersion)
 
     if (stoppedInstanceCount > 0) {
       console.log(chalk.yellow(
@@ -1116,10 +1238,31 @@ async function main() {
       ))
     }
 
+    // 自更新失败**不抛异常**(包已经发上去了,只是没装到全局),所以这里必须显式分支 ——
+    // 否则终端会照样打 "🎉 发布完成!",而那是对用户的误导。
+    if (selfUpdate === 'failed') {
+      console.log(chalk.yellow(`\n⚠️ v${currentVersion} 已经发布到 npm,但全局版本没装上。`))
+      console.log(chalk.yellow('   重发没有意义(版本已经占掉了),按上面的命令手动装一次即可。'))
+      announceRelease(releaseOutcome({
+        status: 'partial',
+        version: currentVersion,
+        durationMs: Date.now() - releaseStartedAt,
+        reason,
+      }))
+      return
+    }
+
     console.log(chalk.green('\n🎉 发布完成!'))
+    if (selfUpdate === 'skipped' && !DRY_RUN) {
+      console.log(chalk.gray('(全局版本没动,见上面的 --skip-self-update)'))
+    }
+    announceRelease(releaseOutcome({
+      status: selfUpdate === 'skipped' ? 'ok-skipped' : 'ok',
+      version: currentVersion,
+      durationMs: Date.now() - releaseStartedAt,
+    }))
   } catch (err) {
-    console.error(chalk.red('\n❌ 发布失败:'), err.message || err)
-    process.exit(1)
+    abortRelease('\n❌ 发布失败:', err.message || err)
   }
 }
 

package/src/cli/ai/agent.js

@@ -682,7 +682,7 @@ export async function handleSlashCommand(state, input, t) {
       const st = await fsp.stat(target)
       if (!st.isDirectory()) throw new Error('not a dir')
       state.ctx.cwd = target
-      // 项目级 skill 与 .mcp.json 跟着工作目录走:先重载扩展(会关掉旧目录起的 MCP 子进程),
+      // 项目级 skill 与项目级 mcp.json 跟着工作目录走:先重载扩展(会关掉旧目录起的 MCP 子进程),
       // 再重建首条 system 消息 —— 顺序反了会把旧目录的 skill 清单写进新目录的提示词。
       await state.extensions?.reload({ cwd: target, locale: state.locale, onWarn: printWarn })
       state.messages[0] = { role: 'system', content: await buildProjectPrompt({ cwd: target, locale: state.locale, shellDesc: state.shellDesc, extra: extensionSuffix(state) }) }

package/src/cli/ai/extensions.js

@@ -93,7 +93,7 @@ export class AgentExtensions {
   }
 
   /**
-   * 切换工作目录:重读项目级 skill 与 .mcp.json,先关掉旧目录起的子进程。
+   * 切换工作目录:重读项目级 skill 与项目级 mcp.json,先关掉旧目录起的子进程。
    * 全局级配置不受影响,但一起重载更简单也更好推理。
    *
    * @param {{ cwd: string, locale?: string, onWarn?: (message: string) => void,

package/src/cli/ai/mcp.js

@@ -20,9 +20,10 @@
 //   自己写≈200 行,换取零依赖 + 完全可控的超时与降级行为。
 //
 // 配置来源(两级,项目级覆盖全局同名 server):
-//   1) ~/.zen-gitsync/ai/mcp.json      「g ai 智能体」全局安装(对所有项目生效)
-//   2) <cwd>/.mcp.json                 项目级安装
-//   形状沿用 Claude 的 mcpServers,便于与生态里其他工具共享配置:
+//   1) ~/.zen-gitsync/ai/mcp.json                    「g ai 智能体」全局安装(对所有项目生效)
+//   2) <cwd>/.zen-gitsync/ai/mcp.json                项目级安装
+//   形状沿用生态通行的 mcpServers。项目级路径常量与广场安装端共用 src/paths.js 那一份;
+//   项目级**不再读** <cwd>/.mcp.json(那是 Claude Code 一系的约定路径,2026-09-30 迁出)。
 //   { "mcpServers": { "github": { "command": "npx", "args": ["-y", "@..."], "env": {} } } }
 //
 // ⚠️ Windows 上 spawn 的两个坑(已实测,不要"优化"掉):
@@ -38,7 +39,7 @@ import { spawn } from 'node:child_process';
 import { promises as fs, statSync } from 'node:fs';
 import path from 'node:path';
 import { trackChild } from '../cleanup.js';
-import { AI_MCP_FILE } from '../../paths.js';
+import { AI_MCP_FILE, projectMcpFile } from '../../paths.js';
 
 const IS_WIN = process.platform === 'win32';
 
@@ -171,7 +172,7 @@ async function readServersFile(file) {
  */
 export async function loadMcpServers({ cwd, globalFile = AI_MCP_FILE, projectFile } = {}) {
   const globalServers = await readServersFile(globalFile);
-  const projectPath = projectFile || (cwd ? path.join(path.resolve(cwd), '.mcp.json') : null);
+  const projectPath = projectFile || (cwd ? projectMcpFile(cwd) : null);
   const projectServers = projectPath ? await readServersFile(projectPath) : {};
   return {
     servers: { ...globalServers, ...projectServers },

package/src/cli/ai/mcp.test.js

@@ -94,7 +94,10 @@ test('loadMcpServers: 项目级覆盖全局同名 server,坏的 JSON 只当没
       broken: { args: ['no-command'] },
     },
   }), 'utf8');
-  await fs.writeFile(path.join(project, '.mcp.json'), JSON.stringify({
+  // 项目级落在 .zen-gitsync/ai/mcp.json —— 写死字面量,常量漂了要在这里炸
+  const projectFile = path.join(project, '.zen-gitsync', 'ai', 'mcp.json');
+  await fs.mkdir(path.dirname(projectFile), { recursive: true });
+  await fs.writeFile(projectFile, JSON.stringify({
     mcpServers: { shared: { command: 'npx', args: ['project'] } },
   }), 'utf8');
 
@@ -103,11 +106,20 @@ test('loadMcpServers: 项目级覆盖全局同名 server,坏的 JSON 只当没
   assert.ok(servers.onlyGlobal);
   assert.equal(servers.broken, undefined, '没有 command 的条目应被丢弃');
   assert.equal(sources.length, 2);
+  assert.equal(sources[1].file, projectFile, '项目级来源路径必须就是那个文件');
 
   // 坏文件:整个文件当空配置,不抛错
-  await fs.writeFile(path.join(project, '.mcp.json'), '{ this is not json', 'utf8');
+  await fs.writeFile(projectFile, '{ this is not json', 'utf8');
   const broken = await loadMcpServers({ cwd: project });
   assert.deepEqual(broken.servers.shared.args, ['global'], '坏的项目配置应回落到全局配置');
+
+  // 反向自证:老位置 <cwd>/.mcp.json 不再被读
+  const legacyProject = await fs.mkdtemp(path.join(os.tmpdir(), 'zen-mcp-legacy-'));
+  await fs.writeFile(path.join(legacyProject, '.mcp.json'), JSON.stringify({
+    mcpServers: { fromClaude: { command: 'npx', args: ['legacy'] } },
+  }), 'utf8');
+  const legacy = await loadMcpServers({ cwd: legacyProject });
+  assert.equal(legacy.servers.fromClaude, undefined, '项目根 .mcp.json 是别家工具的路径,不该再被读');
 });
 
 // ── 真实 stdio 往返 ───────────────────────────────────────────