opencode-idea 0.0.14 → 0.0.15

package/README.md

@@ -12,10 +12,14 @@ OpenCode 插件,面向 JetBrains 项目 (IntelliJ IDEA / PyCharm / WebStorm 等)
 > (含 fnm / SDKMAN 这类靠 shell init 切版本的场景)。详见「项目命令执行」。
 
 非 JetBrains 项目完全不受影响。 **手动接入**:插件启动不探测、不连接 IDE,只有跑 `/open-in-idea` 才接入。跑过一次后,该**项目**
-被「标记」(持久化在 `ctx.storage`,重启 OpenCode 后仍在):之后插件在后台**每 5s 探活**该 IDE——**掉线就注销 `idea` MCP**(杀掉不会自愈的
-stdio 僵尸桥 + 移除 `idea_*` 工具,让模型调不到、**不会挂起**),并锁存"待重建";**下一条用户消息**读到锁存后**静默重建**(用户无感)。
+被「标记」(持久化在 `ctx.storage`,重启 OpenCode 后仍在)。之后**没有任何后台轮询**——恢复完全靠请求驱动:插件发现"该有 `idea_*`
+工具却没有"(新实例)或"`idea_*` 调用失败"(掉线)时,**在下一条消息发出前静默接回**(用户无感)。
 `/close-in-idea` 注销 IDE MCP + 删除标记。没跑过 `/open-in-idea` 的项目保持全手动、零自主动作。
 
+> **为什么改成请求驱动**:OpenCode 把一个 Location(项目)的全部服务缓存在 `LayerMap` 里,空闲 **60 分钟**
+> (`idleTimeToLive`)后整体驱逐——插件实例连同 `idea` MCP 注册一起消失。这一点两种传输都躲不过,所以与其后台探活
+> (永远晚一步、还刷 IDE 日志),不如在请求前发现并把连接接回来。
+
 ## 工作原理
 
 ```text
@@ -30,9 +34,8 @@ setup(启动, 每项目一次):
      - 已就绪 → 再问 IDE「当前项目是否已打开」(`get_project_modules`,带项目路径)
        · 已打开 → 不重复 open;未打开 → open -a 打开
      - 未就绪(冷启动)→ open -a 拉起,再轮询等到就绪(上限 60s)
-  4. **先注销旧的 idea MCP(杀掉旧的 stdio 桥子进程),再重新注册**
-     (`idea stdioMcpServer`,env 带项目路径 + 端口;每项目一个子进程)
-     —— 每次执行都重建,因为断掉的桥不会自愈、也不能靠 refresh 复活
+  4. **先注销旧的 idea MCP,再重新注册**(`type: "remote"` 指向 `http://127.0.0.1:<port>/stream`,项目路径走请求头)
+     —— 每次执行都重建:OpenCode 的 reconcile 会跳过配置未变的 re-`set`,不先拆就换不掉一个已经死掉的注册
   5. 等 `idea_*` 工具进入注册表;读 IDE 终端环境更新 shell 环境;启用引导
   6. 发结果通知(用户看到干净气泡,模型只回"收到")
 
@@ -47,16 +50,14 @@ setup(启动, 每项目一次):
      - 普通业务错误(File not found 等)→ 不动作
   2. 触发成功 → 把该错误改写为"已重连 / 已重新打开,请重试",模型同一回合重试;失败 → 保持原错误
 
-后台探活(心跳;仅"已标记 + 桥已注册"的项目):
-  1. 每 5s 探测一次 IDE 端口(/stream);探一次不通 →
-  2. **注销 `idea` MCP**:杀掉僵尸桥子进程 + 从注册表移除 `idea_*` 工具
-     (→ 模型调不到,也就不会挂起;这一步是"从根上避免挂起"的关键)
-  3. 锁存 `needRebuild = true`(不会因端口恢复而清,因为桥不会自愈);
-     同理,任一请求若发现「本会话曾有工具、本请求没有」也置同一锁存——
-     端口还在答、只是桥子进程死了这类情况,心跳看不到
-  4. 下一条用户消息:纯内存读到锁存 → 自动重跑接入流程(IDE 不在则 `open -a` 拉起),成功后清锁存
-     —— 全程静默,用户无感
-  ※ 这是**每个 Location(项目)各跑一份**探活;IDE 只有一个,所以所有项目的桥几乎同时被注销、再各自重建
+请求驱动的恢复(没有后台轮询;每个 Location(项目)各一份插件实例):
+  1. `prompt` 钩子(消息进入时,OpenCode 会 await 它)——「已标记 + 本实例没有任何 `idea` 注册」→
+     探测端口,**只注册、绝不 `open -a`**;命中就重建,于是**这条消息本身**就带上了 `idea_*` 工具
+  2. `context` 钩子——某条请求"曾经有 `idea_*`、现在没有" → 立刻锁存并在后台重建(不等下一条消息)
+  3. `execute.after` 钩子——`idea_*` 调用以"不可用"告终(`MCP server "idea" is not available` /
+     `Error POSTing to endpoint`)→ 重跑接入流程,并把错误改写成"已重连,请重试";
+     普通业务错误(文件不存在等)不动作
+  ※ 三者都只在**确实有事发生**时动;没人用这个项目时,插件完全静止
 ```
 
 ## 在 IDE 中打开项目 (`/open-in-idea`)
@@ -70,7 +71,7 @@ setup(启动, 每项目一次):
 3. 未就绪 → 说明 IDEA 是冷启动,继续用 `open -a` 拉起并**轮询等到 MCP 就绪**(冷启动约数十秒,上限 60s);
 4. 等不到(例如 IDE 里 MCP 服务未开启)→ 提示在 IDEA 的 `Settings → MCP Server` 开启 MCP 服务并启用 **Brave Mode**,用户设置好后
    再次执行 `/open-in-idea`;
-5. 就绪后 **先注销旧的 `idea` MCP(杀掉旧的 stdio 桥子进程)→ 再重新注册**(每次执行都重建,因为断掉的桥不会自愈),然后重读
+5. 就绪后 **先注销旧的 `idea` MCP → 再重新注册**(每次执行都重建:配置未变的 re-`set` 会被 reconcile 跳过),然后重读
    IDE 环境、启用系统引导,并**等到 `idea_*` 工具进入注册表**才返回。
 
 > **通知不触发 AI 干活**:默认 `feedback: "message"` 把结果作为一条 **标注清楚的通知**发到会话里 —— 用户看到干净的通知气泡
@@ -171,36 +172,22 @@ IDE MCP 只能 **查**(`get_run_configurations`)和 **执行**(`execute_run_conf
 - JetBrains IDE 已开启 MCP 服务 (IDE 设置里的 MCP Server / AI Assistant MCP),版本需 **2026.2+**(提供 Streamable HTTP 端点
   `/stream`);若关闭,`/open-in-idea` 会立即提示如何重新开启。
 - 要读 IDE 终端环境,需要在 IDE 里开启 **Brave Mode**(否则 `execute_terminal_command` 会等确认);MCP 未就绪时通知会同时提醒开启它。
-- 插件注册给 OpenCode 的 MCP 配置。默认用 **stdio 桥**:
+- 插件注册给 OpenCode 的 MCP 配置(**只支持 Streamable HTTP**):
 
 ```jsonc
 {
-  "type": "local",
-  // OpenCode 的 `LocalConfig.command` 是【字符串数组】:可执行文件 + 参数
-  // (源码 `client.ts` 里 `const [command, ...args] = config.command`)。没有单独的 `args` 字段。
-  "command": ["/Applications/IntelliJ IDEA.app/Contents/MacOS/idea", "stdioMcpServer"],
-  "environment": {
-    "IJ_MCP_SERVER_PROJECT_PATH": "<项目路径>",
-    "IJ_MCP_SERVER_PORT": "64342",
-  },
+  "type": "remote",
+  "url": "http://127.0.0.1:64342/stream",
+  "headers": { "IJ_MCP_SERVER_PROJECT_PATH": "<项目路径>" },
+  "codemode": false,
 }
 ```
 
-`idea stdioMcpServer` 是 IDE 自带的桥:OpenCode 通过 **stdin/stdout 子进程管道**跟它通信,它在后端连 IDE 的 MCP。
-**客户端侧是持久管道,不存在 HTTP 空闲断流**——这正是默认选它的原因。每个项目一个插件实例、各带自己的
-`IJ_MCP_SERVER_PROJECT_PATH`,所以每个项目会起一个独立的 stdio 客户端进程。
+项目通过 `IJ_MCP_SERVER_PROJECT_PATH` 头选择,所以一个 IDE 能同时服务多个项目,而**不需要为每个项目起一个子进程**。
 
-> **为什么不用远程 `/stream`**:Streamable HTTP 的客户端会挂一条用于 server→client 通知的 SSE 流;这条流**空闲一段时间会
-> 被关**,而**远程传输在客户端侧不重连**(OpenCode 只为 legacy session 过期重连)。于是"闲置一会儿"就会掉。stdio 桥没有这个
-> 问题。`transport: "http"` 可切回远程模式:
->
-> ```jsonc
-> {
->   "type": "remote",
->   "url": "http://127.0.0.1:64342/stream",
->   "headers": { "IJ_MCP_SERVER_PROJECT_PATH": "<项目路径>" },
-> }
-> ```
+> **为什么不用 IDE 的 stdio 桥**(`idea stdioMcpServer`,子进程管道):它的故障是"沉默"的——IDE 连接断掉后子进程只挂起、
+> 不回任何错误,只能靠后台心跳兜;而 Location 空闲 60 分钟被驱逐时,桥进程与注册一起消失——**两种传输都躲不过**。
+> HTTP 至少把"端点没了"变成一次普通的调用错误,插件能分类并自愈。OpenCode 2.0.19+ 也已无 SSE 客户端传输,当初选 stdio 的理由不再成立。
 >
 > **为什么不用 `/sse`**:OpenCode V2 的远程 MCP 客户端**只支持 Streamable HTTP**,没有旧版 SSE 传输。IDE 的 `/sse` 是旧版
 > SSE (POST 返回 405),V2 连不上。插件对 IDE 的**探测**仍走 `/stream`(一次 `initialize`),用来确认 IDE MCP 已就绪并拿到端口。
@@ -267,14 +254,10 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
         "ports": [64342], // IDE MCP 端口;默认 [64342]
         "injectGuidance": true, // IDE 可用时向系统提示注入「优先使用 IDEA MCP」引导
         "openInIde": "idea", // false 关闭;或任意 macOS 应用名(如 "IntelliJ IDEA")
-        "transport": "stdio", // "stdio"(默认,本地桥,不会空闲断流)| "http"(远程 Streamable HTTP)
-        "ideExecutable": undefined, // 可显式指定 IDE 可执行文件;默认从 .app 里推断
         "launchCooldownMs": 120000, // 启动保护冷却
         "launchMaxAttempts": 5,
         "mcpProbeTimeoutMs": 1000, // 单个 MCP 端口的短探测超时
         "executionTimeoutMs": 600000, // 单次 idea_* 工具调用硬上限;默认 10 分钟(OpenCode 默认 12 小时)
-        "heartbeatIntervalMs": 5000, // 后台端口探活间隔
-        "heartbeatFailures": 1, // 探活失败几次后注销 idea MCP(默认一次即注销)
         "feedback": "message", // "message"(默认,会话通知,AI 只回"收到")| false(静默)
       },
     },
@@ -284,20 +267,16 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
 
 不传 options 时全部使用下表默认值。
 
-| 选项                  | 类型                 | 默认        | 说明                                                                                    |
-| --------------------- | -------------------- | ----------- | --------------------------------------------------------------------------------------- |
-| `ports`               | `number[]`           | `[64342]`   | 依次探测的 IDE MCP 端口                                                                 |
-| `injectGuidance`      | `boolean`            | `true`      | IDE 可用时是否向系统提示注入「优先使用 IDEA MCP」引导                                   |
-| `openInIde`           | `boolean \| string`  | `"idea"`    | 拉起哪个 IDE;`false` 关闭,`"idea"` 映射到 IntelliJ IDEA                                 |
-| `transport`           | `"stdio" \| "http"`  | `"stdio"`   | `stdio` 注册 IDE 自带的 stdio 桥(本地子进程,不会空闲断流);`http` 用远程 Streamable HTTP |
-| `ideExecutable`       | `string`             | (推断)      | IDE 可执行文件绝对路径;默认从 `<App>.app/Contents/MacOS/` 推断                          |
-| `launchCooldownMs`    | `number`             | `120000`    | 启动保护冷却:冷却期内不重复 spawn                                                       |
-| `launchMaxAttempts`   | `number`             | `5`         | 单次会话内最多 spawn 次数,超出后停止重试                                                |
-| `mcpProbeTimeoutMs`   | `number`             | `1000`      | 单个 MCP 端口的短探测超时                                                               |
-| `executionTimeoutMs`  | `number`             | `600000`    | 单次 `idea_*` 工具调用的硬上限(毫秒);防止桥挂起后无限等待(OpenCode 默认 12 小时)        |
-| `heartbeatIntervalMs` | `number`             | `5000`      | 后台 IDE 端口探活间隔(毫秒);仅"已标记 + 桥已注册"的项目有效                             |
-| `heartbeatFailures`   | `number`             | `1`         | 探活失败几次后注销 `idea` MCP(杀僵尸桥 + 移除工具),下一条消息自动重建                   |
-| `feedback`            | `"message" \| false` | `"message"` | 结果反馈:`message` 会话通知(用户可见,AI 只回"收到");`false` 静默                        |
+| 选项                 | 类型                 | 默认        | 说明                                                                               |
+| -------------------- | -------------------- | ----------- | ---------------------------------------------------------------------------------- |
+| `ports`              | `number[]`           | `[64342]`   | 依次探测的 IDE MCP 端口                                                            |
+| `injectGuidance`     | `boolean`            | `true`      | IDE 可用时是否向系统提示注入「优先使用 IDEA MCP」引导                              |
+| `openInIde`          | `boolean \| string`  | `"idea"`    | 拉起哪个 IDE;`false` 关闭,`"idea"` 映射到 IntelliJ IDEA                            |
+| `launchCooldownMs`   | `number`             | `120000`    | 启动保护冷却:冷却期内不重复 spawn                                                  |
+| `launchMaxAttempts`  | `number`             | `5`         | 单次会话内最多 spawn 次数,超出后停止重试                                           |
+| `mcpProbeTimeoutMs`  | `number`             | `1000`      | 单个 MCP 端口的短探测超时                                                          |
+| `executionTimeoutMs` | `number`             | `600000`    | 单次 `idea_*` 工具调用的硬上限(毫秒);防止端点卡住后无限等待(OpenCode 默认 12 小时) |
+| `feedback`           | `"message" \| false` | `"message"` | 结果反馈:`message` 会话通知(用户可见,AI 只回"收到");`false` 静默                   |
 
 ## 行为
 
@@ -305,27 +284,28 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
   `/open-in-idea` 注册。
 - **未标记的项目**:不改环境、不注册、不注入任何 IDEA 提示 (每请求零开销;setup 时只做一次项目标记读取)。
 - **手动接入 + 就绪即返回**:`/open-in-idea` 会 `open -a` 拉起 IDEA 并**等 IDE MCP 就绪**(冷启动数十秒,上限 60s);就绪后
-  **先注销旧的 `idea`(杀掉旧 stdio 桥)→ 再以 stdio 重新注册**,等 `idea_*` 工具就绪,最后才通知。**每次执行都重建**,所以断掉的
-  僵尸桥只要重跑一次命令就能恢复。命令返回即可用;`/close-in-idea` 注销 `idea` + 删标记 + 清环境。
+  **先注销旧的 `idea` → 再重新注册**(远程 Streamable HTTP),等 `idea_*` 工具就绪,最后才通知。**每次执行都重建**。命令返回即可用;
+  `/close-in-idea` 注销 `idea` + 删标记 + 清环境。
 - **`context` 钩子是请求的纯函数**:按「每次模型调用」触发 (含工具续跑),只看本次请求自带的工具快照 —— 有 `idea_*` 就剥离隐藏
   工具并注入引导;没有则只在项目被标记时给恢复提示。该钩子本身**不做任何 I/O**(只看内存缓存),也不订阅任何事件。
-- **后台心跳(仅"已标记 + 桥已注册"的项目)**:每 `heartbeatIntervalMs`(默认 5s)探一次 IDE 端口;`heartbeatFailures`
-  (默认 1)次不通就**注销 `idea` MCP** —— 杀掉僵尸桥子进程 + 移除 `idea_*` 工具,于是模型**调不到、也就不会挂起** —— 并锁存
-  `needRebuild`。下一条用户消息在 `prompt` 钩子里读到锁存 → 自动重跑接入流程(IDE 不在则 `open -a` 拉起),成功后清锁存。**全程静默**。
-  锁存还有**第二个来源**:`context` 钩子(每个 agent-loop step 都跑)发现「本会话见过 `idea_*` 工具、本请求却没有」也置位 ——
-  心跳只认"端口不通",而桥子进程自己死了、或一次失败的重连把注册拆掉(`reconcileOnce` 先拆后建,建不起来就只剩拆)时端口可能还是通的,
-  这两种情况以前**不会置锁存**,于是下一条消息什么都不做,只能手动 `/open-in-idea`。工具缺失时注入的恢复引导也改为**明确禁止**
-  调用 `idea_*`(此前复用"重试一次"的文案,反而诱导模型去调一个不在工具表里的工具,得到 `No tool named ... available`)。
-  探活是**每个 Location(项目)各一份**;IDE 只有一个,所以 IDE 一挂、所有项目的桥几乎同时被注销,再由各自的消息触发重建。
+- **请求驱动的恢复(没有后台轮询)**:
+  - **`prompt` 钩子**:「已标记 + 本实例没有任何 `idea` 注册」时**探测端口并重新注册**(只探测、绝不 `open -a`)。OpenCode 会
+    await `prompt` 才构建请求,所以**触发它的那条消息本身**就带上了 `idea_*` 工具,没有空窗。这正是 Location 被空闲驱逐
+    (60 分钟 `idleTimeToLive`)或 OpenCode 重启后,新实例自动接回连接的路径。
+  - **`context` 钩子**:发现「本会话见过 `idea_*` 工具、本请求却没有」→ 立刻锁存并在后台重建(不等下一条消息)。工具缺失时注入的
+    恢复引导会**明确禁止**调用 `idea_*`(此前复用"重试一次"的文案,反而诱导模型去调一个不在工具表里的工具,得到
+    `No tool named ... available`)。
+  - **`execute.after` 钩子**:见下一条。
+  恢复是**每个 Location(项目)各一份**;没有任何定时器,插件在不使用时完全静止。
 - **失败触发的自动接入(仅被标记项目)**:`tool.execute.after` 钩子监听 `idea_*` 工具报错并**分类**:
   - IDE MCP 不可用(掉了)→ 重跑 `/open-in-idea` 的接入流程;
   - IDE 在、但项目没打开(`Unable to determine the target project` / `doesn't correspond to any open project`)→ 让 IDEA 重新打开该项目;
   - 普通业务错误(`File not found` 等)→ **不动作**。判定只认**传输层专有标记**(`MCP server "idea" is not available` /
-    `MCP server is not connected` / `Error POSTing to endpoint` / `SseClientTransport is closed`),**不认**工具输出里出现的通用串
+    `MCP server is not connected` / `Error POSTing to endpoint`),**不认**工具输出里出现的通用串
     (例如 SQL 工具报的 `Connection refused`) —— MCP 工具错误的 message 就是工具自己的输出,认通用串会把正常业务失败误判成掉线并重建。
     触发成功会把该工具错误改写为"已重连 / 已重新打开,请重试",模型在同一回合内重试;失败则保持原错误。非 `idea_*` 工具、未标记
     项目都不受影响。启动保护 (`launchCooldownMs` / `launchMaxAttempts`) 限制重复拉起 IDE。
-- **`/open-in-idea`**:手动打开当前项目;**等 IDE MCP 就绪 → 先注销旧的 `idea`(杀旧桥)→ 再重新注册 → 等 `idea_*` 工具就绪**才返回。
+- **`/open-in-idea`**:手动打开当前项目;**等 IDE MCP 就绪 → 先注销旧的 `idea` → 再重新注册 → 等 `idea_*` 工具就绪**才返回。
   **`/close-in-idea`**:注销 IDE MCP + 删项目标记 + 清空注入的环境。
 
 ## 限制
@@ -345,18 +325,15 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
   (`get_project_modules`,带 `IJ_MCP_SERVER_PROJECT_PATH`):返回模块 = 已打开 → 跳过 `open -a`;报
   `Unable to determine the target project` = 未打开 → `open -a` 打开。MCP 关闭时会用一次短探测并立即给出设置提示。
   项目刚打开时的短暂"项目未就绪"由工具失败分类兜底(「IDE 在、但项目没打开」→ 重新打开并让模型重试)。
-- IDE **2026.2+** 提供官方 stdio 桥 (`idea stdioMcpServer`),插件默认用它注册。stdio 是子进程管道,不像 Streamable HTTP 那样
-  会空闲断流;但它**启动时要求 IDE MCP 已在监听**,所以 `/open-in-idea` 必须先等就绪再注册(冷启动约数十秒)。`transport: "http"`
-  可切回远程 Streamable HTTP(OpenCode 会因连接关闭把 server 置 failed 并移除工具,不自动重连)。
-- **stdio 的边界(已实测)**:IDE 中途退出后,桥进程会变成"僵尸"——进程还在、调用挂起、**不回任何错误**。两种情况都实测过:**调用之后**IDE 挂、
-  以及**调用进行中**IDE 挂(在 IDE 里跑 `sleep 120` 时 `kill` 掉 IDEA),桥都只在 stderr 打一行错误(`SseClientTransport is closed!` /
-  `Request timeout has expired`),**stdout 一个字节都不回**。而且**重开 IDEA 也不会自愈**(实测:重开 IDEA 后连续探测 5 分钟仍全部 TIMEOUT);
-  OpenCode 依旧显示 connected,`refresh`/`reload` 只会 `reconcile`,配置没变就跳过,不会重启它。所以:
-  - **后台心跳(见上)自动兜底**:5s 探活、探一次不通就注销 `idea`(杀僵尸桥 + 移除工具);此外任一请求发现工具缺失也会置锁存,
-    两种情况都是下一条消息自动重建 —— 常态下**不需要用户手动做什么**;
-  - 手动重建仍可用:重开 IDEA 后再执行一次 `/open-in-idea`(先注销旧 `idea`、再重新注册);
-  - 插件给 `idea` server 配 `executionTimeoutMs`(默认 **10 分钟**)作为硬上限:兜住"心跳尚未触发、工具已在途"的那次挂起,不再沿用 OpenCode 默认的 12 小时;
-  - "IDE 被关掉 → 工具挂起"这类**不会**走工具失败分类(没有 error);能自动分类处理的是"IDE 在、项目没打开"和"server 掉了(启动即失败)"。
+- IDE **2026.2+** 提供 Streamable HTTP 端点 `/stream`,这是插件**唯一**使用的传输(`type: "remote"`)。注册本身不启动任何子进程,
+  所以没有"桥进程被 IDE 拖死后变成僵尸"这一类问题。`/open-in-idea` 仍要求 IDE MCP 已在监听(冷启动约数十秒),因此会先等就绪再注册。
+- **空闲驱逐(已实测)**:OpenCode 把一个 Location 的服务缓存在 `LayerMap` 里,`idleTimeToLive` = **60 分钟**;空闲到期即整体驱逐,
+  插件实例连同 `idea` MCP 注册一起消失。**两种传输都躲不过**,所以对策不是换传输,而是请求驱动的恢复(见「行为」):
+  - 新实例上第一条用户消息的 `prompt` 钩子会把连接接回来 —— 常态下**不需要用户手动做什么**;
+  - 手动重建仍可用:执行 `/open-in-idea`(先注销旧 `idea`、再重新注册);
+  - 插件给 `idea` server 配 `executionTimeoutMs`(默认 **10 分钟**)作为硬上限:兜住端点卡住时的单次调用,不再沿用 OpenCode 默认的 12 小时;
+  - "IDE 被关掉"这一类会被下一次 `idea_*` 调用暴露(HTTP 直接报错),由 `execute.after` 钩子分类后自愈;不产生 error 的场景(例如
+    IDE 进程还在但项目没打开)由「IDE 在、项目没打开」分支处理。
 - 项目标记存在插件名下 KV (`plugin:opencode-idea:project/<项目根路径>`)。插件实例按 **Location**(项目/打开目录)创建,标记按
   **项目根路径**共享;但两个不同 Location(例如项目根与某子目录)各有自己的内存缓存 —— 单目录打开项目的常见用法不受影响。
 - `/close-in-idea` 会**注销 IDE MCP** 并删标记 + 清空注入的环境。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-idea",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "OpenCode plugin that connects to JetBrains IDE MCP servers and prefers IDE tools when the current project is open in the IDE",
   "main": "src/index.js",
   "type": "module",

package/src/ide-launcher.js

@@ -12,8 +12,6 @@
 // unavailable; this module only requests opening/activating the project.
 
 import { spawn } from 'node:child_process';
-import { readdirSync, statSync } from 'node:fs';
-import path from 'node:path';
 
 /** Default macOS app name for IntelliJ IDEA. */
 export const DEFAULT_IDE_APP = 'IntelliJ IDEA';
@@ -37,62 +35,6 @@ export function resolveIdeApp(value) {
   return IDE_APPS[value.toLowerCase()] ?? value;
 }
 
-/** Preferred launcher binary name per app, used when `Contents/MacOS` has several. */
-const IDE_EXECUTABLES = {
-  'IntelliJ IDEA': 'idea',
-  PyCharm: 'pycharm',
-  'PyCharm Community': 'pycharm',
-  WebStorm: 'webstorm',
-  GoLand: 'goland',
-  CLion: 'clion',
-  PhpStorm: 'phpstorm',
-  RubyMine: 'rubymine',
-  Rider: 'rider',
-  DataGrip: 'datagrip',
-  'Android Studio': 'studio',
-};
-
-/**
- * Absolute path to the IDE launcher binary (`<App>.app/Contents/MacOS/<bin>`).
- * The stdio bridge is started by running this binary with `stdioMcpServer`.
- *
- * Returns undefined when the app bundle cannot be found — the caller then falls
- * back to the remote transport.
- *
- * @param {string | undefined} app macOS app name, e.g. "IntelliJ IDEA"
- * @param {{ dirs?: string[] }} [options] search roots (defaults to the two
- *   standard Applications folders); tests pass their own.
- * @returns {string | undefined}
- */
-export function resolveIdeExecutable(app, options = {}) {
-  if (typeof app !== 'string' || app.length === 0) return undefined;
-  const home = process.env.HOME;
-  const dirs = options.dirs ?? [home ? path.join(home, 'Applications') : undefined, '/Applications'].filter(
-    (value) => typeof value === 'string',
-  );
-  const preferred = IDE_EXECUTABLES[app];
-  for (const dir of dirs) {
-    const macos = path.join(dir, `${app}.app`, 'Contents', 'MacOS');
-    let entries;
-    try {
-      entries = readdirSync(macos);
-    } catch {
-      continue;
-    }
-    const executable = (name) => {
-      try {
-        const stats = statSync(path.join(macos, name));
-        return stats.isFile() && (stats.mode & 0o111) !== 0;
-      } catch {
-        return false;
-      }
-    };
-    const chosen = (preferred && entries.includes(preferred) && preferred) || entries.find(executable);
-    if (chosen) return path.join(macos, chosen);
-  }
-  return undefined;
-}
-
 /**
  * Open `directory` in the IDE, reusing a running instance when possible.
  * Never throws; resolves `true` when `open` reported success.

package/src/mcp/idea.js

@@ -3,13 +3,14 @@
 // HOW THE IDE MCP SERVER WORKS (verified against a real IntelliJ IDEA 2026.2
 // server):
 //
-//   * The IDE exposes a local MCP server. IntelliJ 2026.2+ exposes the modern
-//     Streamable-HTTP endpoint at `http://127.0.0.1:<port>/stream`; older builds
-//     only had the legacy SSE endpoint at `/sse`.
-//   * The project a call targets is selected by the project path: the HTTP
-//     header `IJ_MCP_SERVER_PROJECT_PATH` for the remote transport, or the
-//     `IJ_MCP_SERVER_PROJECT_PATH` environment variable for the stdio bridge
-//     (see `serverConfig` / `stdioServerConfig`).
+//   * The IDE exposes a local MCP server at the Streamable-HTTP endpoint
+//     `http://127.0.0.1:<port>/stream` (IntelliJ 2026.2+). That is the only
+//     transport this plugin supports. The IDE's `stdioMcpServer` bridge was
+//     dropped: both transports die with the project's Location services, and the
+//     HTTP one at least reports a dead endpoint as an ordinary tool error
+//     (which the plugin then heals) instead of hanging silently.
+//   * The project a call targets is selected by the project path, carried in the
+//     HTTP header `IJ_MCP_SERVER_PROJECT_PATH` (see `serverConfig`).
 //   * Availability probe: a single `initialize` POST to `/stream` succeeds when
 //     the MCP server is up. We do NOT check whether a specific project is open —
 //     the user triggers `/open-in-idea` for the project they want, so "server is
@@ -17,15 +18,6 @@
 
 export const PROJECT_HEADER = 'IJ_MCP_SERVER_PROJECT_PATH';
 
-/** Environment variable the IDE's stdio bridge uses to select the project. */
-export const PROJECT_ENV = 'IJ_MCP_SERVER_PROJECT_PATH';
-
-/** Environment variable the IDE's stdio bridge uses to reach the running server. */
-export const PORT_ENV = 'IJ_MCP_SERVER_PORT';
-
-/** Argument that puts the IDE launcher into its stdio MCP bridge mode. */
-export const STDIO_ARG = 'stdioMcpServer';
-
 /** OpenCode MCP server name registered for the IDE. */
 export const IDEA_SERVER_NAME = 'idea';
 
@@ -65,48 +57,13 @@ export function serverConfig(port, projectPath, options = {}) {
   return withExecutionTimeout(config, options);
 }
 
-/**
- * Build the OpenCode MCP server config for the IDE's **stdio bridge**.
- *
- * The IDE launcher (`<App>.app/Contents/MacOS/<binary>`) with the
- * `stdioMcpServer` argument runs a small proxy that speaks MCP over
- * stdin/stdout and connects to the running IDE MCP server selected by the
- * environment. That makes the client side a child-process pipe instead of a
- * Streamable-HTTP stream, so it does not suffer the idle-close that the remote
- * transport does. The project and port are carried in the environment, matching
- * what the remote config carries in a header and URL.
- *
- * @param {string} executable absolute path to the IDE launcher
- * @param {number} port IDE MCP port to bridge to
- * @param {string} projectPath project root the bridge should target
- * @param {{ executionTimeoutMs?: number }} [options]
- */
-export function stdioServerConfig(executable, port, projectPath, options = {}) {
-  /** @type {Record<string, unknown>} */
-  const config = {
-    type: 'local',
-    // OpenCode's `LocalConfig.command` is a STRING ARRAY holding the executable
-    // followed by its arguments (`client.ts` does `const [command, ...args] =
-    // config.command`). There is no separate `args` field — passing one, or a
-    // bare string command, fails schema validation and the server never spawns.
-    command: [executable, STDIO_ARG],
-    environment: {
-      [PROJECT_ENV]: projectPath,
-      [PORT_ENV]: String(port),
-    },
-    codemode: false,
-  };
-  return withExecutionTimeout(config, options);
-}
-
 /**
  * Attach OpenCode's per-server execution timeout to an MCP config.
  *
- * OpenCode defaults this to **12 hours**. The IDE's stdio bridge never answers a
- * call whose upstream IDE connection has dropped (it logs on stderr but sends no
- * JSON-RPC response), so without a cap a call made after the IDE died would sit
- * unresolved for the whole default. A finite cap turns that permanent hang into
- * an ordinary timeout error.
+ * OpenCode defaults this to **12 hours**. A wedged IDE MCP server can accept the
+ * POST and never answer it, so without a cap a call made after the IDE died
+ * would sit unresolved for the whole default. A finite cap turns that hang into
+ * an ordinary timeout error the plugin can classify and heal from.
  *
  * @param {Record<string, unknown>} config
  * @param {{ executionTimeoutMs?: number }} options
@@ -146,7 +103,7 @@ export async function probePort(port, options = {}) {
         params: {
           protocolVersion: PROTOCOL_VERSION,
           capabilities: {},
-          clientInfo: { name: 'opencode-idea', version: '0.0.14' },
+          clientInfo: { name: 'opencode-idea', version: '0.0.15' },
         },
       }),
       signal: controller.signal,
@@ -217,7 +174,7 @@ export async function callTool(port, projectPath, name, args = {}, options = {})
       params: {
         protocolVersion: PROTOCOL_VERSION,
         capabilities: {},
-        clientInfo: { name: 'opencode-idea', version: '0.0.14' },
+        clientInfo: { name: 'opencode-idea', version: '0.0.15' },
       },
     });
     // The IDE's Streamable-HTTP endpoint binds follow-up requests to the session

package/src/plugin.js

@@ -1,10 +1,10 @@
 // opencode-idea — OpenCode plugin entry.
 //
 // For a project the user opted into IDEA this plugin:
-//   1. registers the IDE MCP server with OpenCode — by default as the IDE's
-//      stdio bridge (`idea stdioMcpServer`), scoped to the project through
-//      `IJ_MCP_SERVER_PROJECT_PATH` — injects direct-call guidance for IDEA MCP
-//      tools, and updates only IDEA MCP tool descriptions;
+//   1. registers the IDE MCP server with OpenCode as the IDE's Streamable-HTTP
+//      endpoint, scoped to the project through the `IJ_MCP_SERVER_PROJECT_PATH`
+//      header; injects direct-call guidance for IDEA MCP tools; and updates only
+//      IDEA MCP tool descriptions;
 //   2. registers the `/open-in-idea` command, which opens the current project
 //      in IntelliJ IDEA (reusing a running instance), loads the IDE
 //      capabilities immediately, and marks the project as an IDEA project;
@@ -18,20 +18,27 @@
 // IDE, and loads the IDE MCP + guidance on demand.
 //
 // `/open-in-idea` opens the project in the IDE, waits until its MCP endpoint is
-// ready, registers `idea` (stdio, project-scoped) and marks the project in
+// ready, registers `idea` (remote, project-scoped) and marks the project in
 // `ctx.storage`; `/close-in-idea` unregisters the server and clears the mark.
 // A live endpoint alone does NOT mean our project is open there (the running IDE
 // may have a different project open), so the open flow asks the IDE directly —
 // one project-scoped MCP call — and runs `open -a` only when the project is not
 // open yet.
-// The mark gates the IDEA skills and the failure-driven recovery. After a manual
-// open, an `idea_*` call that fails because the IDE MCP is not usable (the server
-// dropped, or the project is not open in the IDE) re-runs the open flow; a plain
-// business error is classified apart and left alone. Because a stdio bridge whose
-// IDE connection drops never reports it (it hangs), a background heartbeat probes
-// the IDE endpoint and, once it is clearly gone, deactivates the server — killing
-// the zombie bridge and removing the tools so a call cannot hang — and the next
-// user message rebuilds it.
+//
+// Recovery is request-driven: there is NO background polling. The mark gates it,
+// and it fires from three places, each observing a real fact:
+//   * the `prompt` hook, when the project is marked but this plugin instance has
+//     no `idea` server at all. That is exactly what a fresh instance looks like
+//     after OpenCode evicted the project's Location services (the Location's
+//     LayerMap uses `idleTimeToLive: "60 minutes"`) or after the process
+//     restarted — setup deliberately does not connect, so without this the
+//     session would stay tool-less until the user ran `/open-in-idea` by hand.
+//     `prompt` is awaited before the request is built, so the message that
+//     triggers it already carries the tools;
+//   * the `context` hook, when a request that HAD `idea_*` tools no longer does;
+//   * the `execute.after` hook, when an `idea_*` call fails in a way that means
+//     the IDE MCP is not usable (the server dropped, or the project is not open
+//     in the IDE). A plain business error is classified apart and left alone.
 //
 // `Plugin.define` from `@opencode/plugin` is an identity function, so a plain
 // `{ id, setup }` object is the whole plugin contract. Exporting it directly
@@ -43,15 +50,12 @@ import {
   callTool,
   findIdePort,
   serverConfig,
-  stdioServerConfig,
 } from './mcp/idea.js';
 import { currentProjectPath } from './project.js';
 import {
   createLaunchGuard,
-  DEFAULT_IDE_APP,
   openInIde,
   resolveIdeApp,
-  resolveIdeExecutable,
 } from './ide-launcher.js';
 import {
   appendIdeGuidance,
@@ -69,25 +73,15 @@ const DEFAULT_MCP_PROBE_TIMEOUT_MS = 1000;
 const DEFAULT_MCP_START_TIMEOUT_MS = 60000;
 const MCP_START_POLL_MS = 1000;
 const DEFAULT_TOOL_REFRESH_TIMEOUT_MS = 5000;
-const TOOL_REFRESH_POLL_MS = 25;
-// Hard cap on ONE IDE MCP tool call. OpenCode's own default is 12 hours, and the
-// IDE's stdio bridge NEVER answers a call once its upstream IDE connection has
-// dropped (it logs on stderr but sends no JSON-RPC response) — so a call made
+// 等工具目录落地时的轮询间隔。这是一次**有界等待**(见 waitForIdeaTools),不是
+// 状态轮询:100ms 足够快,又不会在 5s 上限内空转几十次。
+const TOOL_REFRESH_POLL_MS = 100;
+// Hard cap on ONE IDE MCP tool call. OpenCode's own default is 12 hours, and a
+// wedged IDE MCP server can accept a POST and never answer it — so a call made
 // after the IDE died would otherwise sit unresolved for 12h. 10 minutes is far
-// beyond any normal IDE tool and turns that permanent hang into a normal error.
+// beyond any normal IDE tool and turns that hang into a normal error the failure
+// classifier can act on.
 const DEFAULT_EXECUTION_TIMEOUT_MS = 600000;
-// Background IDE liveness probe. The stdio bridge NEVER reports a dropped IDE
-// connection (it just hangs), so the plugin watches the IDE endpoint itself.
-// ONE miss is already conclusive: a healthy localhost endpoint answers in
-// milliseconds, and a single probe already tolerates up to `mcpProbeTimeoutMs`
-// (1s). Requiring consecutive misses would only widen the window in which a
-// call already made against the zombie bridge keeps hanging. So on a miss the
-// plugin deactivates the `idea` server — killing the zombie bridge child AND
-// removing the `idea_*` tools, so the model can never call into a dead pipe —
-// and latches a rebuild for the next user message (the bridge never heals on
-// its own).
-const DEFAULT_HEARTBEAT_INTERVAL_MS = 5000;
-const DEFAULT_HEARTBEAT_FAILURES = 1;
 // Every IDE tool comes from the MCP server the plugin registers as `idea`, and
 // OpenCode namespaces a server's tools with its name — so `idea_*` IS the whole
 // set, the same predicate the request hooks use. "Ready" means at least one of
@@ -207,7 +201,10 @@ function toolIds(tools) {
  * - `project`: the IDE is up but the requested project is not open in it, e.g.
  *   "`projectPath`=... doesn't correspond to any open project." Re-opening the
  *   project fixes it.
- * - `mcp`: the IDE MCP server itself is gone (dropped / transport closed).
+ * - `mcp`: the IDE MCP server itself is gone — the endpoint stopped answering,
+ *   the transport closed, or the connection was refused. See the marker list in
+ *   the body; it includes the connect failure OpenCode's own MCP client emits
+ *   (`Unable to connect…`, and the structural `code: "ConnectionRefused"`).
  *
  * Everything else is `none`.
  *
@@ -218,11 +215,10 @@ function classifyIdeaFailure(error) {
   const message = typeof error?.message === 'string' ? error.message : '';
   // "Project not open in the IDE" comes in two shapes, both meaning the same
   // thing and both fixed by opening the project again:
-  //   - the called tool carried no `projectPath`, so the server could not pick
-  //     one: "Unable to determine the target project for the current MCP tool
-  //     call." (this is what the plugin's stdio registration produces, since it
-  //     sets the project through env, not through the call)
-  //   - an explicit `projectPath` was passed but is not open: "`projectPath`=...
+  //   - the server could not pick a project for the call: "Unable to determine
+  //     the target project for the current MCP tool call." (the project path in
+  //     the request header did not resolve — the IDE may still be opening it)
+  //   - the project was resolved but is not open: "`projectPath`=...
   //     doesn't correspond to any open project."
   if (
     message.includes('Unable to determine the target project') ||
@@ -230,20 +226,35 @@ function classifyIdeaFailure(error) {
   ) {
     return 'project';
   }
-  // Only transport-level markers, which OpenCode / the IDE bridge emit
-  // themselves. The message of an MCP *tool error* is the tool's own content
-  // (`tool/mcp.ts` turns `result.isError` into `ToolFailure({ message: <text> })`),
-  // so a generic string such as "Connection refused" from a SQL or run-config
-  // tool would otherwise be misread as a dropped connection and rebuild a
-  // healthy bridge.
+  // Only transport-level markers, which OpenCode's own MCP client emits. The
+  // message of an MCP *tool error* is the tool's own content (`tool/mcp.ts`
+  // turns `result.isError` into `ToolFailure({ message: <text> })`), so a
+  // generic string such as "Connection refused" from a SQL or run-config tool
+  // would otherwise be misread as a dropped connection and rebuild a healthy
+  // server.
+  //
+  // MEASURED (2026-09-30, OpenCode 2.0.19, IDE process killed): a dead remote
+  // MCP endpoint does NOT produce any of the shapes above. OpenCode's client
+  // reports its own connect failure instead:
+  //
+  //   level=WARN message="mcp http request failed"
+  //     errors="[{\"type\":\"TypeError\",
+  //               \"message\":\"Unable to connect. Is the computer able to access the url?\",
+  //               \"code\":\"ConnectionRefused\",\"errno\":0}]"
+  //
+  // so the text is matched on its stable prefix, and the underlying `code` is
+  // accepted as a structural signal too (a wording change must not silently
+  // disable the heal).
   if (
     message.includes(`MCP server "${IDEA_SERVER_NAME}" is not available`) ||
     message.includes('MCP server is not connected') ||
     message.includes('Error POSTing to endpoint') ||
-    message.includes('SseClientTransport is closed')
+    message.includes('Unable to connect')
   ) {
     return 'mcp';
   }
+  const causeCode = error?.error?.code ?? error?.cause?.code ?? error?.code;
+  if (causeCode === 'ConnectionRefused' || causeCode === 'ECONNREFUSED') return 'mcp';
   return 'none';
 }
 
@@ -360,10 +371,6 @@ export default {
    *     mcpStartTimeoutMs?: number,
    *     toolRefreshTimeoutMs?: number,
    *     executionTimeoutMs?: number,
-   *     heartbeatIntervalMs?: number,
-   *     heartbeatFailures?: number,
-   *     transport?: 'stdio' | 'http',
-   *     ideExecutable?: string,
    *     feedback?: false | 'message',
    *   },
    *   command?: {
@@ -423,28 +430,12 @@ export default {
     const ports = asArray(options.ports, DEFAULT_PORTS);
     const injectGuidance = options.injectGuidance !== false;
     const ideApp = resolveIdeApp(options.openInIde);
-    // Transport for the IDE MCP server. `stdio` (default) registers the IDE's
-    // stdio bridge as a local server: the client side is a child-process pipe,
-    // which — unlike the remote Streamable-HTTP stream — does not get closed
-    // while idle and never reconnected. `http` keeps the older remote config.
-    const transport = options.transport === 'http' ? 'http' : 'stdio';
-    const ideExecutable = typeof options.ideExecutable === 'string'
-      ? options.ideExecutable
-      // Resolve independently of `openInIde`: that option only controls whether
-      // the plugin may LAUNCH the IDE, not which transport the MCP server uses.
-      // Falling back to the default app when launching is disabled keeps stdio
-      // the default there too (otherwise `openInIde: false` silently registered
-      // the remote HTTP transport).
-      : resolveIdeExecutable(ideApp ?? DEFAULT_IDE_APP);
-    const useStdio = transport === 'stdio' && typeof ideExecutable === 'string';
     const mcpProbeTimeoutMs = asPositiveNumber(options.mcpProbeTimeoutMs, DEFAULT_MCP_PROBE_TIMEOUT_MS);
     const mcpStartTimeoutMs = asPositiveNumber(options.mcpStartTimeoutMs, DEFAULT_MCP_START_TIMEOUT_MS);
     const toolRefreshTimeoutMs = asPositiveNumber(options.toolRefreshTimeoutMs, DEFAULT_TOOL_REFRESH_TIMEOUT_MS);
-    // Cap on a single IDE tool call, so a bridge that hangs (IDE died) fails in
-    // finite time instead of OpenCode's 12h default. See DEFAULT_EXECUTION_TIMEOUT_MS.
+    // Cap on a single IDE tool call, so a wedged server fails in finite time
+    // instead of OpenCode's 12h default. See DEFAULT_EXECUTION_TIMEOUT_MS.
     const executionTimeoutMs = asPositiveNumber(options.executionTimeoutMs, DEFAULT_EXECUTION_TIMEOUT_MS);
-    const heartbeatIntervalMs = asPositiveNumber(options.heartbeatIntervalMs, DEFAULT_HEARTBEAT_INTERVAL_MS);
-    const heartbeatFailures = asPositiveNumber(options.heartbeatFailures, DEFAULT_HEARTBEAT_FAILURES);
     // "message" (default) injects a clearly-labelled notification that the
     // model only acknowledges ("收到"); the user sees the clean notice via
     // metadata.displayText. false is silent.
@@ -469,15 +460,10 @@ export default {
     let skillsRegistered = false;
     let disposed = false;
 
-    // Background heartbeat state (see DEFAULT_HEARTBEAT_INTERVAL_MS).
-    /** @type {ReturnType<typeof setInterval> | undefined} */
-    let heartbeatTimer;
-    let heartbeatMisses = 0;
-    // Latches when the IDE was seen down and the server was deactivated. It is
-    // cleared ONLY by a successful rebuild — never by the endpoint coming back —
-    // because the bridge does not heal on its own. It is set from TWO places:
-    // the heartbeat (the IDE port stopped answering) and the `context` hook (a
-    // request arrived without the `idea_*` tools).
+    // Latches when a request showed the `idea_*` tools are gone. It is cleared
+    // only by a successful rebuild. It is set from the `context` hook (a request
+    // that HAD the tools no longer does); the `prompt` hook also heals without
+    // this latch when the instance has no registration at all.
     let needsRebuild = false;
     // Set once a request in this session actually carried `idea_*` tools, so a
     // later request without them is a DROP of this session's own connection —
@@ -565,27 +551,6 @@ export default {
       return false;
     };
 
-    /**
-     * Does the local registry still list any of this server's tools?
-     *
-     * The IDE endpoint answering says nothing about the bridge OpenCode actually
-     * calls: when that child process dies, OpenCode drops every `idea_*` tool
-     * while the IDE keeps serving. The port probe reports "fine" and the model
-     * gets a tool list without the IDE — so this near end needs its own check,
-     * and it is a purely local read.
-     *
-     * Unavailable or failed reads report `true`: inventing a miss would tear down
-     * a working bridge, which is worse than skipping one tick.
-     */
-    const ideaToolsPresent = async () => {
-      if (typeof ctx.tool?.list !== 'function') return true;
-      try {
-        return toolIds(await ctx.tool.list()).some((id) => id.startsWith(IDEA_TOOL_PREFIX));
-      } catch {
-        return true;
-      }
-    };
-
     const refreshIdeTools = async () => {
       if (typeof ctx.mcp.reload === 'function') await ctx.mcp.reload();
       // Reconcile the MCP servers above, then replay the tool registry so the
@@ -597,9 +562,7 @@ export default {
     };
 
     const activateIde = async (port) => {
-      const config = useStdio
-        ? stdioServerConfig(ideExecutable, port, projectPath, { executionTimeoutMs })
-        : serverConfig(port, projectPath, { executionTimeoutMs });
+      const config = serverConfig(port, projectPath, { executionTimeoutMs });
       const mcpRegistration = await ctx.mcp.transform((editor) => {
         editor.set(IDEA_SERVER_NAME, config);
       });
@@ -619,15 +582,11 @@ export default {
         return false;
       }
 
-      // Always tear the server down and register it again. A stdio bridge whose
-      // IDE connection dropped becomes a permanent zombie: the child process is
-      // still alive, so OpenCode keeps reporting it as connected, never restarts
-      // it, and SKIPS a re-`set` whose config is unchanged (`reconcile()` compares
-      // the config). Disposing the registration removes the server from the
-      // reconciled config, which is what actually kills the child process — so a
-      // full rebuild is the only reliable way back to a working bridge.
-      // `/open-in-idea` is manual and rare; rebuilding an already-healthy bridge
-      // costs one restart, which is the right trade for never leaving a zombie.
+      // Always tear the server down and register it again. OpenCode's reconcile
+      // SKIPS a re-`set` whose config is unchanged, so re-registering without a
+      // teardown would leave a dropped server in place forever. `/open-in-idea`
+      // and the request hooks are rare; rebuilding costs one restart, which is
+      // the right trade for never leaving a dead registration behind.
       await deactivateIde();
       if (port === undefined) return false;
       return activateIde(port);
@@ -636,9 +595,7 @@ export default {
     // Serialize reconciles so overlapping callers can never register/activate
     // the IDE concurrently (which would leak registrations).
     let reconcileChain = Promise.resolve();
-    // Non-zero while a reconcile is queued or running. A rebuild tears the
-    // registration down before it registers again, so the tools are briefly
-    // absent on purpose — the heartbeat must not read that as a loss.
+    // Non-zero while a reconcile is queued or running.
     let reconcileBusy = 0;
     const enqueue = (task) => {
       reconcileBusy += 1;
@@ -824,7 +781,6 @@ export default {
           }
           if (result.port !== undefined) {
             needsRebuild = false;
-            heartbeatMisses = 0;
           }
         } catch {
           // best effort: the latch stays set, and the prompt hook retries
@@ -840,56 +796,6 @@ export default {
     // Setup never probes or connects the IDE — everything is on `/open-in-idea`.
     await reconcile({ probeIde: false });
 
-    /**
-     * One heartbeat tick. Only marked projects are watched, and it only acts
-     * when an `idea` server is actually registered: the point is to protect an
-     * ESTABLISHED connection. A project that never connected has no zombie to
-     * kill, and must not have IDEA launched on its behalf. The deactivation
-     * runs under the reconcile chain, so a tick cannot race `/open-in-idea`.
-     */
-    let heartbeatBusy = false;
-    const heartbeatTick = async () => {
-      if (disposed || heartbeatBusy) return;
-      if (markCache !== true || registrations.length === 0) {
-        heartbeatMisses = 0;
-        return;
-      }
-      heartbeatBusy = true;
-      try {
-        const port = await findIdePort(ports, { timeoutMs: mcpProbeTimeoutMs }).catch(() => undefined);
-        // Two independent failures to catch. The endpoint can stop answering (the
-        // IDE is gone), or it can keep answering while the bridge OpenCode calls
-        // has died — the second one is invisible to the probe AND to the model,
-        // which is why the local registry gets checked too.
-        if (port !== undefined && (reconcileBusy > 0 || (await ideaToolsPresent()))) {
-          heartbeatMisses = 0;
-          return;
-        }
-        heartbeatMisses += 1;
-        if (heartbeatMisses < heartbeatFailures) return;
-        // Either end is down. Deactivating kills the zombie bridge child and
-        // removes the `idea_*` tools, so the model cannot call into a dead pipe.
-        const kicked = await enqueue(async () => {
-          if (disposed || registrations.length === 0) return false;
-          await deactivateIde();
-          return true;
-        });
-        if (kicked) needsRebuild = true;
-        // The IDE is still reachable, so reconnecting needs no launch — reconnect
-        // now instead of leaving the session tool-less until the next message. A
-        // dead endpoint still waits for one: that path may `open -a`, and the
-        // heartbeat must never start the IDE on its own.
-        if (needsRebuild && port !== undefined) await reviveIde();
-      } finally {
-        heartbeatBusy = false;
-      }
-    };
-    heartbeatTimer = setInterval(() => {
-      heartbeatTick().catch(() => {});
-    }, heartbeatIntervalMs);
-    // Never keep the host process alive just to probe (also keeps tests from hanging).
-    if (typeof heartbeatTimer?.unref === 'function') heartbeatTimer.unref();
-
     const sendFeedback = async (input, result) => {
       if (feedback !== 'message' || typeof ctx.session?.prompt !== 'function') return false;
       try {
@@ -979,10 +885,10 @@ export default {
           description: '取消当前项目的 IDEA 接入:注销 IDE MCP 并清除项目标记',
           execute: async (input) => {
             await setMark(false);
-            // Unregister the IDE MCP server and clear the injected env. Reuses
-            // the serialized reconcile, so a concurrent rebuild (an in-flight
-            // `/open-in-idea`, or a heartbeat tick) cannot re-register the
-            // server after the mark is gone.
+            // Unregister the IDE MCP server. Reuses the serialized reconcile, so
+            // a concurrent rebuild (an in-flight `/open-in-idea`, or a
+            // request-time heal) cannot re-register the server after the mark is
+            // gone.
             await reconcile({ probeIde: false });
             await sendFeedback(input, { status: 'closed' });
           },
@@ -1003,21 +909,17 @@ export default {
     if (typeof ctx.session?.hook === 'function') {
       sessionRegistration = await ctx.session.hook('context', (event) => {
         const tools = event?.tools;
-        const serving = tools !== undefined && Object.keys(tools).some((name) => name.startsWith('idea_'));
+        const serving = tools !== undefined && Object.keys(tools).some((name) => name.startsWith(IDEA_TOOL_PREFIX));
         if (serving) {
           wasServing = true;
           removeIdeaToolDefinitions(tools, HIDDEN_IDEA_TOOLS);
         } else if (wasServing && tools !== undefined && markCache === true) {
-          // This session HAD the tools and this request does not. The heartbeat
-          // alone cannot catch every way that happens: a bridge child can die
-          // while the IDE port keeps answering, and a failed reconnect tears the
-          // registration down WITHOUT latching anything (`reconcileOnce` tears
-          // down first and then finds no port, so `kicked` never runs). Without
-          // a latch the `prompt` hook has nothing to fire on, so the next
-          // message would send the model a tool list without `idea_*` and
-          // recover nothing. Latch it here instead, where "is the IDE serving
-          // THIS request?" is a fact. `wasServing` keeps this from firing for a
-          // project that never connected in this session — setup deliberately
+          // This session HAD the tools and this request does not. Latch a
+          // rebuild here, where "is the IDE serving THIS request?" is a fact: a
+          // failed reconnect can tear the registration down without anything else
+          // noticing. `wasServing` keeps this from firing for a project that
+          // never connected in this session — the `prompt` hook covers that case
+          // (a fresh instance has no registration at all) and setup deliberately
           // does not connect on its own.
           needsRebuild = true;
           wasServing = false;
@@ -1037,14 +939,23 @@ export default {
         appendIdeGuidance(event?.system, projectPath);
       });
 
-      // Rebuild after a detected drop — the heartbeat (dead port) or the context
-      // hook above (tools gone from a request) latches `needsRebuild`. Reading
-      // only that in-memory latch keeps this a cheap no-op on every other
-      // message. OpenCode awaits `prompt` before the request is built, so when
-      // the IDE is back, the message that triggers this already carries working
-      // tools.
+      // 自愈入口(钩子型)。OpenCode 会 await `prompt`,所以在这里修好的连接会在
+      // **本次请求**里就带上 `idea_*` 工具,没有"先回一句正在重连、下一条才行"
+      // 的空窗。
+      //
+      // 两种"需要重连"的形状都从这里进:
+      //   * `needsRebuild` — 之前的请求已经证明工具没了;
+      //   * `registrations.length === 0` — 本插件实例压根没有 `idea` 服务器,这
+      //     正是 OpenCode 回收 Location 服务(LayerMap idleTimeToLive = 60 分钟)
+      //     或进程重启后新实例的样子。setup 故意不连接,没有这一步会话就会永久
+      //     没有工具,只能靠用户手敲 `/open-in-idea`。
+      //
+      // 只探测、不启动 IDE:走 `reconcile({ probeIde: true })`,而不是会 `open -a`
+      // 的 `reviveIde()` —— 一条用户消息不该把 IDEA 拉起来。
       promptRegistration = await ctx.session.hook('prompt', async (event) => {
-        if (disposed || !needsRebuild || markCache !== true) return;
+        if (disposed || markCache !== true) return;
+        const fresh = registrations.length === 0;
+        if (!needsRebuild && !fresh) return;
         // Never react to the plugin's own notices, or recovery would feed on
         // itself. Match the notice TEXT, never `metadata.displayText`: OpenCode
         // also sets `displayText` on ordinary user messages (it is the message
@@ -1052,15 +963,12 @@ export default {
         // — verified live, and it made this rebuild never run.
         const text = event?.prompt?.text;
         if (typeof text === 'string' && text.startsWith(NOTICE_PREFIX)) return;
-        // Awaited on purpose: the message that triggers this already carries
-        // working tools. A background attempt already in flight is joined — but
-        // joining is not trying: if that attempt had already failed, this message
-        // would be swallowed and would carry no tools, which is exactly the bug
-        // this hook exists to prevent. So when we joined one and the latch is
-        // still set, this message gets an attempt of its own.
-        const joined = reviveInFlight !== undefined;
-        await reviveIde();
-        if (joined && needsRebuild) await reviveIde();
+        try {
+          await reconcile({ probeIde: true });
+        } catch {
+          // best effort: the latch stays set and the next message retries
+        }
+        if (registrations.length > 0) needsRebuild = false;
       });
 
       // The only self-initiated action: when an `idea_*` call fails in a way
@@ -1091,7 +999,6 @@ export default {
 
     return async () => {
       disposed = true;
-      if (heartbeatTimer) clearInterval(heartbeatTimer);
       if (sessionRegistration) {
         try {
           await sessionRegistration.dispose();