opencode-idea 0.0.9 → 0.0.10

package/README.md

@@ -8,18 +8,21 @@ OpenCode 插件,面向 JetBrains 项目 (IntelliJ IDEA / PyCharm / WebStorm 等)
    (正常回退,无需声明)。
 3. **注入 IDE 环境变量** —— 从 IDE 集成终端读取它实际运行的环境,注入每个 OpenCode shell。
 
-非 JetBrains 项目完全不受影响。 **全手动**:插件启动不探测、不连接 IDE,只有跑 `/open-in-idea` 才接入;接入之后也没有
-任何自主动作(环境变量只在 `/open-in-idea` 时刷新)。
+非 JetBrains 项目完全不受影响。 **手动接入**:插件启动不探测、不连接 IDE,只有跑 `/open-in-idea` 才接入。跑过一次后,该**项目**
+被「标记」(持久化在 `ctx.storage`,重启 OpenCode 后仍在):之后每条用户消息都默认 IDE 仍在,一旦发现 IDE MCP 未连接,插件会在
+构建本次请求前自动重跑一遍接入流程并按需补一条通知。`/close-in-idea` 删除该标记。没跑过 `/open-in-idea` 的项目保持全手动、零自主动作。
 
 ## 工作原理
 
 ```text
-setup(启动):
-  a. 读 IDE 集成终端环境 → 通过 shell create.before 钩子注入每个 shell(null: 未连 IDE 时为空)
-  b. 注册 /open-in-idea 命令 + session context 钩子(注入引导)
+setup(启动, 每项目一次):
+  a. 读项目标记(ctx.storage: project/<项目路径>; OpenCode 重启后仍生效)
+  b. 读 IDE 集成终端环境 → 通过 shell create.before 钩子注入每个 shell(null: 未连 IDE 时为空)
+  c. 注册 /open-in-idea 与 /close-in-idea 命令 + session context/prompt 钩子
   不探测、不注册 MCP
 
 /open-in-idea(手动触发):
+  0. 写项目标记 = true(持久化)+ 清内存缓存(下次读取者回源)
   1. 探测本地 JetBrains IDE MCP 服务(/stream)
   2. 已就绪 → 直接连接
   3. 未就绪 → open -a "IntelliJ IDEA" <项目目录>(复用已运行实例),然后立即提示:
@@ -30,6 +33,16 @@ setup(启动):
        b. 读 IDE 终端环境 → 更新注入每个 shell 的环境变量
        c. 启用系统提示引导(直接调用 `idea_*` 工具)+ IDEA MCP 工具描述前缀
   6. 发一条结果通知(用户看到干净气泡,模型只回"收到")
+
+/close-in-idea(手动触发):
+  1. 删项目标记 + 清内存缓存
+  2. 发一条结果通知(不改动已建立的连接)
+
+后续用户消息(仅在被标记的项目里):
+  1. 项目已标记 → 默认 IDE 仍在线
+  2. 查 OpenCode 里 `idea` MCP server 状态;不是 connected/pending(真断了)→ 在 prompt 钩子里同步重跑上面的接入流程
+  3. 成功 → 本条消息即可用 `idea_*` 工具,并补一条"已自动重新连接"通知(排在用户消息之后)
+  4. 失败 → 静默,沿用 fast-fail 恢复提示(不会每条消息都重复拉起 IDE)
 ```
 
 ## 在 IDE 中打开项目 (`/open-in-idea`)
@@ -53,6 +66,11 @@ Brave Mode 后再次执行 `/open-in-idea` 即可接上。
 **热更新会断开**:插件源码变更会触发 V2 热重载,注册随旧实例一起释放,`activePort` 归零。这是手动模式的预期行为 ——
 **改完插件后重跑一次 `/open-in-idea`** 即可恢复。
 
+## 关闭接入 (`/close-in-idea`)
+
+输入 `/close-in-idea`:删除当前项目的接入标记(持久化 + 内存缓存一并清),之后 IDE MCP 即使断开也**不再自动重连**。命令只删标记,
+**不主动断开已建立的连接**——当前已注册的工具会保留到连接自然中断为止。想重新接入,再次执行 `/open-in-idea`。
+
 ## IDE 工具优先 (直接调用引导)
 
 IDE MCP 可用时,插件通过 **系统提示注入**提高模型主动使用 IDEA MCP 的概率;不修改任何工具 (原生或 IDEA)
@@ -78,7 +96,7 @@ IDE MCP 可用时,插件通过 **系统提示注入**提高模型主动使用 ID
 ## Run Configuration 管理 (skill)
 
 IDE MCP 只能 **查**(`get_run_configurations`)和 **执行**(`execute_run_configuration`)run configuration, **没有增删改**
-。插件在 **JetBrains 项目**(存在 `.idea`)里注册一个 `idea-run-config` skill 来补上这块:
+。插件在**被标记的项目**里注册一个 `idea-run-config` skill 来补上这块:
 
 - 只操作 **项目级** `.run/<name>.run.xml`(可提交 git、团队共享), **不碰** `.idea/workspace.xml`;
 - 不内置任何按类型的模板 —— 先找项目里的 **真实样本**(`**/*.run.xml`,或让用户在 IDEA 里勾 "Store as project file"
@@ -86,9 +104,9 @@ IDE MCP 只能 **查**(`get_run_configurations`)和 **执行**(`execute_run_conf
 - 写完必须用 `idea_get_run_configurations` **校验它能被列出**、并用 `idea_execute_run_configuration` **实跑确认**;
 - 改配置用 `idea_apply_patch` **定向改 option**,不整文件重写。
 
-skill 由 `ctx.skill.transform` 在插件 `setup` 时注册, **与 `/open-in-idea` 无关**;非 JetBrains 项目不受影响。文档放在
-`skills/<id>/SKILL.md`(每个 skill 一个目录,`name` / `description` 走 YAML frontmatter),由 `src/skill/loader.js` 扫描加载 ——
-**加新 skill 只需加一个目录,不用改代码**。
+**skill 的生命周期跟随项目标记**:`/open-in-idea` 打标记时注册、`/close-in-idea` 清标记时注销;曾被标记过的项目在
+`setup` 时(读回标记)就会注册。未标记的项目不受影响。文档放在 `skills/<id>/SKILL.md`(每个 skill 一个目录,`name` /
+`description` 走 YAML frontmatter),由 `src/skill/loader.js` 扫描加载 —— **加新 skill 只需加一个目录,不用改代码**。
 
 ## 环境变量注入
 
@@ -212,16 +230,23 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
 
 ## 行为
 
-- **JetBrains 项目**:启动即注入 IDE 终端环境 (若此前已连过 IDE);`/open-in-idea` 接入 IDE MCP + 启用引导。
-- **非 JetBrains 项目**:不改环境、不注册、不注入任何 IDEA 提示 (每请求零开销)。
-- **手动接入 + 零自主动作**:启动 **不探测、不连接 IDE MCP**;注册、**环境重读**、引导注入全部由 `/open-in-idea` 触发。
+- **被标记的项目**:启动读回标记后挂上 shell 环境钩子 (环境值待接入后填充)、注册 `idea-run-config` skill;
+  `/open-in-idea` 接入 IDE MCP + 启用引导。
+- **未标记的项目**:不改环境、不注册、不注入任何 IDEA 提示 (每请求零开销;setup 时只做一次项目标记读取)。
+- **手动接入**:启动 **不探测、不连接 IDE MCP**;注册、**环境重读**、引导注入全部由 `/open-in-idea` 触发。
   `context` 钩子按「每次模型调用」触发 (含工具续跑),是**请求的纯函数**:它只看本次请求自带的工具快照 ——
-  有 `idea_*` 就剥离隐藏工具并注入引导,没有就只给恢复提示。**不做任何 I/O,没有缓存状态,没有定时器,没有事件订阅**。
-  一次失败的调用不会触发探测或注销,断开的连接也不会被自动重连 —— **恢复的唯一方式是用户再次执行 `/open-in-idea`**。
+  有 `idea_*` 就剥离隐藏工具并注入引导;没有则只在项目被标记时给恢复提示。**不做任何 I/O(get 只看内存缓存),没有定时器,
+  没有事件订阅**。一次失败的调用不会触发探测或注销。
+- **项目标记自动重连**:`/open-in-idea` 会持久化一个**项目级**标记(插件名下 KV,key 为 `project/<项目根路径>`,重启 OpenCode 后
+  仍在),并在内存缓存。之后每条用户消息经 `prompt` 钩子处理时,先查 OpenCode 里 `idea` MCP server 的状态:不是
+  `connected`/`pending`(真断了)才同步重跑一遍完整接入流程 (探测 → `open -a` → 等 MCP → 注册 + `tool.reload`),让**这条消息
+  本身**就能用上 IDEA 工具;恢复成功后补一条会话通知。`/close-in-idea` 删标记后即不再自愈。失败时沿用启动保护的冷却与次数上限
+  (`launchCooldownMs` / `launchMaxAttempts`),不会每条消息都重复拉起 IDE。
+- **判定只看 MCP 状态,不看工具报错**:是否重连只取决于 `idea` MCP server 的连接状态(`ctx.mcp.list()`)。工具调用的业务报错
+  (如 `File not found`)只可能发生在 server 仍 `connected` 时,所以**永远不会**被误判成断开;插件也不注册 `tool.execute.after`
+  钩子,一次失败的调用不会触发探测或注销。
 - **`/open-in-idea`**:手动打开当前项目并即时加载能力 (已在 IDE 打开时则只重新加载);MCP 未开启时只发一次提示并
-  fast-fail,用户手动开启 MCP + Brave Mode 后重试。
-- **不响应工具报错**:插件**不注册** `tool.execute.after` 钩子。一次 `idea_*` 调用失败 (业务错误如 `File not found`、
-  或偶发传输抖动) 不会触发任何探测、注销或重连 —— 连接状态只由 `/open-in-idea` 决定。
+  fast-fail,用户手动开启 MCP + Brave Mode 后重试。**`/close-in-idea`**:删项目标记,不改动已建立的连接。
 
 ## 限制
 
@@ -240,7 +265,14 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
 - 探测只确认「MCP 服务是否在监听」,不校验「当前项目是否已在 IDE 打开」;MCP 关闭时会用一次短探测并立即给出设置提示。
 - OpenCode 的 MCP 自动重连**只覆盖 legacy Streamable HTTP 的 session 过期**(`SessionExpiredError`:有 session id + 404 /
   "Server not initialized" → `recover()` + 重试该次调用);modern 端点 (IDE 2026.2,protocol 2025-06-18,不带 session id)
-  的连接被关只会置 `failed` 并移除工具,**不会自动重连**。插件刻意不补这个缺口:恢复一律走手动 `/open-in-idea`。
+  的连接被关只会置 `failed` 并移除工具,**不会自动重连**。**被标记的项目**由插件在 `prompt` 钩子里查 MCP 状态并按需重跑接入
+  流程补这个缺口;未标记的项目仍走手动 `/open-in-idea`。
+- 项目标记存在插件名下 KV (`plugin:opencode-idea:project/<项目根路径>`)。插件实例按 **Location**(项目/打开目录)创建,标记按
+  **项目根路径**共享;但两个不同 Location(例如项目根与某子目录)各有自己的内存缓存 —— 在其中一个执行 open/close 命令,另一个
+  实例要等它下次回源(目前只在 setup 读一次)才会看到。单目录打开项目的常见用法不受影响。
+- `/close-in-idea` **只删标记,不断开已建立的连接**:已注册的 IDEA 工具会保留到连接自然中断,期间标记与实际连接可能短暂不一致。
+- 插件**完全不再检查 `.idea` 目录**:是否是 IDEA 项目只由项目标记(`/open-in-idea` 设置、`/close-in-idea` 清除)决定。
+  (`/open-in-idea` 会让 IDEA 打开并导入该项目,`.idea` 由 IDEA 自己生成,插件无需也不应据此判断。)
 - 打开 IDE 仅实现 macOS (`open -a`);首次打开若弹 Trust 对话框,需确认后重试。
 - IDE MCP 没有「打开项目」工具,因此打开动作走 OS/CLI,而非 MCP。
 - 插件热重载会断开 IDE 连接,需重跑 `/open-in-idea`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-idea",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "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/mcp/idea.js

@@ -81,7 +81,7 @@ export async function probePort(port, options = {}) {
         params: {
           protocolVersion: PROTOCOL_VERSION,
           capabilities: {},
-          clientInfo: { name: 'opencode-idea', version: '0.0.9' },
+          clientInfo: { name: 'opencode-idea', version: '0.0.10' },
         },
       }),
       signal: controller.signal,
@@ -151,7 +151,7 @@ export async function callTool(port, projectPath, name, args = {}, options = {})
       params: {
         protocolVersion: PROTOCOL_VERSION,
         capabilities: {},
-        clientInfo: { name: 'opencode-idea', version: '0.0.9' },
+        clientInfo: { name: 'opencode-idea', version: '0.0.10' },
       },
     });
     const response = await post({

package/src/plugin.js

@@ -1,22 +1,31 @@
 // opencode-idea — OpenCode plugin entry.
 //
-// For a JetBrains project this plugin:
+// For a project the user opted into IDEA this plugin:
 //   1. injects the IDE integrated-terminal environment (JAVA_HOME / GOROOT /
 //      Node / Maven / ...) into every OpenCode shell;
 //   2. registers the IDE MCP server with OpenCode (scoped to the project via the
 //      IJ_MCP_SERVER_PROJECT_PATH header), injects direct-call guidance for
 //      IDEA MCP tools, and updates only IDEA MCP tool descriptions;
 //   3. registers the `/open-in-idea` command, which opens the current project
-//      in IntelliJ IDEA (reusing a running instance) and then loads the IDE
-//      capabilities immediately;
-//   4. registers the `idea-run-config` skill (JetBrains projects only),
-//      which teaches the model how to manage `.run/*.run.xml` run
-//      configurations — a capability the IDE MCP server does not expose.
+//      in IntelliJ IDEA (reusing a running instance), loads the IDE
+//      capabilities immediately, and marks the project as an IDEA project;
+//      `/close-in-idea` clears that mark;
+//   4. registers the `idea-run-config` skill (marked projects only), which
+//      teaches the model how to manage `.run/*.run.xml` run configurations — a
+//      capability the IDE MCP server does not expose.
 //
-// Non-JetBrains projects are left untouched. Everything is manual: setup does
-// NOT probe or connect the IDE (only the IDE-terminal env is read when a probe
-// is requested). `/open-in-idea` probes, opens the IDE, and loads the IDE MCP +
-// guidance on demand.
+// A project that was never marked is left untouched. Everything is manual:
+// setup does NOT probe or connect the IDE (only the IDE-terminal env is read
+// when a probe is requested). `/open-in-idea` probes, opens the IDE, and loads
+// the IDE MCP + guidance on demand.
+//
+// Once the user runs `/open-in-idea` in a project, that project is marked as an
+// IDEA project. The mark is persisted through `ctx.storage` (durable across
+// restarts) and cleared by `/close-in-idea`. While a project is marked, every
+// user message assumes the IDE is still up: the plugin asks OpenCode for the
+// `idea` MCP server's status and, when it is not connected, re-runs the open
+// flow before the request is built. Detection is by MCP status, never by tool
+// errors, so a normal business error can never look like a dropped connection.
 //
 // `Plugin.define` from `@opencode/plugin` is an identity function, so a plain
 // `{ id, setup }` object is the whole plugin contract. Exporting it directly
@@ -29,7 +38,7 @@ import {
   serverConfig,
 } from './mcp/idea.js';
 import { readIdeTerminalEnv } from './mcp/ide-env.js';
-import { currentProjectPath, hasIdeaDirectory } from './project.js';
+import { currentProjectPath } from './project.js';
 import { applyEnv, mergeEnv } from './env.js';
 import {
   createLaunchGuard,
@@ -149,10 +158,11 @@ function toolIds(tools) {
 
 /**
  * @typedef {{
- *   status: 'connected' | 'tools-loading' | 'mcp-unavailable' | 'launch-failed' | 'disabled',
+ *   status: 'connected' | 'tools-loading' | 'mcp-unavailable' | 'launch-failed' | 'disabled' | 'closed',
  *   port?: number,
  *   opened?: boolean,
- *   unavailableNoticeSent?: boolean
+ *   unavailableNoticeSent?: boolean,
+ *   autoRecovered?: boolean
  * }} IdeCommandResult
  */
 
@@ -172,6 +182,9 @@ const asPositiveNumber = (value, fallback) =>
 /** User-facing status text for a `/open-in-idea` result. */
 /** @param {IdeCommandResult} result */
 export function ideFeedback(result) {
+  if (result?.autoRecovered) {
+    return '检测到 IDE MCP 连接已断开,已自动重新连接并恢复 IDEA 原生工具。';
+  }
   switch (result?.status) {
     case 'connected':
       return 'IDE MCP 已连接;IDEA 原生工具已注册并可用于后续请求。';
@@ -185,6 +198,8 @@ export function ideFeedback(result) {
       return '无法拉起 IntelliJ IDEA(未找到应用或启动失败)。请确认已安装 IDEA,或手动打开后重试 /open-in-idea。';
     case 'disabled':
       return '插件已通过 openInIde: false 关闭 IDE 启动。请手动打开 IntelliJ IDEA,在 Settings → MCP Server 开启 MCP 服务并启用 Brave Mode,然后重试 /open-in-idea。';
+    case 'closed':
+      return '已关闭当前项目的 IDEA 接入标记;IDE MCP 断开后将不再自动重连。如需重新接入,请再次执行 /open-in-idea。';
     default:
       return '已处理 /open-in-idea。';
   }
@@ -245,6 +260,8 @@ export default {
    *       agent?: string,
    *       system?: unknown[],
    *       tools?: Record<string, unknown>,
+   *       prompt?: { text?: string },
+   *       metadata?: Record<string, unknown>,
    *     }) => void | Promise<void>) => Promise<{ dispose: () => Promise<void> | void }>,
    *   },
    *   tool?: {
@@ -254,18 +271,19 @@ export default {
    *   mcp: {
    *     transform: (cb: (editor: { set: (name: string, config: unknown) => void }) => void) => Promise<{ dispose: () => Promise<void> | void }>,
    *     reload?: () => Promise<void>,
+   *     list?: () => Promise<{ data?: ReadonlyArray<{ name?: string, status?: { status?: string } }> }>,
    *   },
    *   shell: { hook: (name: string, cb: (input: { env: Record<string, string | undefined> }) => void) => Promise<{ dispose: () => Promise<void> | void }> },
+   *   storage?: {
+   *     get: (key: string) => Promise<unknown>,
+   *     set: (key: string, value: unknown) => Promise<void>,
+   *     remove: (key: string) => Promise<void>,
+   *   },
    * }} ctx
    */
   async setup(ctx) {
     const projectPath = currentProjectPath(ctx.location);
     if (!projectPath) return;
-    // Where IDEA tools can exist at all. Computed once: the recovery guidance is
-    // injected per model request, so it must not cost a filesystem check each
-    // time, and unrelated projects must not receive IDEA prompts they can never
-    // use.
-    const isIdeaProject = hasIdeaDirectory(projectPath);
 
     const options = ctx.options || {};
     const ports = asArray(options.ports, DEFAULT_PORTS);
@@ -292,11 +310,68 @@ export default {
     /** @type {{ dispose: () => Promise<void> | void } | undefined} */
     let sessionRegistration;
     /** @type {{ dispose: () => Promise<void> | void } | undefined} */
+    let promptRegistration;
+    /** @type {{ dispose: () => Promise<void> | void } | undefined} */
     let commandRegistration;
     /** @type {{ dispose: () => Promise<void> | void } | undefined} */
     let skillRegistration;
+    let skillsRegistered = false;
     let disposed = false;
 
+    // Project-level mark: has the user opted this project into IDEA via
+    // `/open-in-idea`? One plugin instance serves one project (OpenCode
+    // activates plugins per Location), so a single boolean is the whole cache.
+    // The durable copy lives in `ctx.storage` under `project/<projectPath>`.
+    // The commands are the only writers: they persist first, then invalidate
+    // this cache so the next read comes back from storage.
+    const storage = ctx.storage;
+    const markKey = `project/${projectPath}`;
+    /** @type {boolean | undefined} undefined = a storage read is due */
+    let markCache;
+    // One auto-recovery run per project at a time; overlapping prompts share it.
+    /** @type {Promise<void> | undefined} */
+    let autoRecovering;
+
+    /** Read the durable mark into the cache; at most one storage read per invalidation. */
+    const readMark = async () => {
+      if (markCache !== undefined) return markCache;
+      if (!storage || typeof storage.get !== 'function') {
+        markCache = false;
+        return markCache;
+      }
+      try {
+        markCache = (await storage.get(markKey)) === true;
+      } catch {
+        // storage is best effort; fall back to unmarked
+        markCache = false;
+      }
+      return markCache;
+    };
+
+    /**
+     * Persist the mark, then invalidate the cache so the next reader re-reads
+     * storage. Best effort: an in-memory invalidation still applies if the write
+     * fails.
+     * @param {boolean} marked
+     */
+    const setMark = async (marked) => {
+      try {
+        if (marked) await storage?.set?.(markKey, true);
+        else await storage?.remove?.(markKey);
+      } catch {
+        // best effort
+      }
+      markCache = undefined;
+      // The skill lifecycle follows the mark: marking the project registers the
+      // IDEA skills, clearing the mark removes them again. Same semantics as the
+      // reconnect behavior, so the two can never disagree.
+      if (marked) await ensureSkills();
+      else await removeSkills();
+    };
+
+    // Resolve the mark once, so the request hooks can read it synchronously.
+    await readMark();
+
     const deactivateIde = async () => {
       const current = registrations.slice();
       registrations.length = 0;
@@ -365,7 +440,7 @@ export default {
       // Manual: only `/open-in-idea` probes the IDE. Setup calls this with
       // `probeIde: false` so it never connects until the command asks.
       const port = probeIde ? await findIdePort(ports, { timeoutMs: mcpProbeTimeoutMs }) : undefined;
-      const isJetBrains = isIdeaProject || port !== undefined;
+      const isJetBrains = markCache === true || port !== undefined;
       if (!isJetBrains) {
         currentEnv = { env: {}, prependPath: [] };
         await deactivateIde();
@@ -485,6 +560,30 @@ export default {
       return run;
     };
 
+    /**
+     * The whole `/open-in-idea` flow, shared by the command and the auto-recovery
+     * path: ensure an IDE MCP endpoint, then register it and load capabilities.
+     *
+     * @param {{ onUnavailable?: (result: IdeCommandResult) => Promise<boolean> }} [options]
+     * @returns {Promise<IdeCommandResult>}
+     */
+    const runOpenInIdea = async ({ onUnavailable } = {}) => {
+      const result = await ensureIde({ onUnavailable });
+      const { port } = result;
+      let toolsReady = false;
+      try {
+        // Do not repeat the expensive probe when the preflight already found no
+        // MCP endpoint. The command will retry after the user enables MCP +
+        // Brave Mode.
+        toolsReady = (await reconcile({ probeIde: port !== undefined })) === true;
+      } catch {
+        // capability load is best effort; feedback still matters
+      }
+      return result.status === 'connected' && !toolsReady
+        ? { ...result, status: 'tools-loading' }
+        : result;
+    };
+
     // Setup never probes or connects the IDE — everything is on `/open-in-idea`.
     await reconcile({ probeIde: false });
 
@@ -505,67 +604,153 @@ export default {
       }
     };
 
+    /**
+     * Is the plugin's `idea` MCP server connected right now? OpenCode tracks
+     * every server's status in memory, and this is the authoritative "the IDE
+     * MCP is down" signal: it reflects the transport, not the result of any
+     * single tool call, so a business error can never look like a disconnect.
+     * `pending` means "still connecting" and is treated as healthy, so a server
+     * that is merely starting up is left alone.
+     *
+     * @returns {Promise<boolean>}
+     */
+    const isIdeaConnected = async () => {
+      if (typeof ctx.mcp?.list !== 'function') return false;
+      try {
+        const result = await ctx.mcp.list();
+        const servers = Array.isArray(result) ? result : (result?.data ?? []);
+        return servers.some((server) => {
+          const status = server?.status?.status;
+          return server?.name === IDEA_SERVER_NAME && (status === 'connected' || status === 'pending');
+        });
+      } catch {
+        return false;
+      }
+    };
+
+    /**
+     * Marked-project recovery: while the project is marked (the user ran
+     * `/open-in-idea`), treat the IDE as expected and rebuild the connection
+     * whenever its MCP server is not connected. Runs before the prompt's request
+     * is built, so a successful recovery makes its `idea_*` tools available to
+     * that very message.
+     *
+     * Only a confirmed reconnect is announced. A failed recovery stays silent:
+     * the per-request recovery guidance already tells the model what to say, and
+     * a notice per failed message would be noise (the launch guard, shared with
+     * the command, keeps it from re-spawning on every message).
+     *
+     * @param {string} sessionID the notice target; the mark itself is per-project
+     */
+    const autoReconnect = (sessionID) => {
+      if (autoRecovering) return autoRecovering;
+      const run = (async () => {
+        try {
+          if (disposed) return;
+          if (await isIdeaConnected()) return;
+          const result = await runOpenInIdea();
+          // A found endpoint is what counts as recovered, even if its tool
+          // catalog is still registering (`tools-loading`).
+          if (result.port === undefined) return;
+          // Queue the notice so it is delivered after the user's own message,
+          // never mixed into the same model turn as it.
+          await sendFeedback(
+            { sessionID, prompt: { text: '' }, delivery: 'queue' },
+            { status: 'connected', autoRecovered: true },
+          );
+        } catch {
+          // auto-recovery is best effort
+        }
+      })();
+      autoRecovering = run;
+      void run.finally(() => {
+        if (autoRecovering === run) autoRecovering = undefined;
+      });
+      return run;
+    };
+
     // The shipped skills are static knowledge (`skills/<id>/SKILL.md`), e.g. the
     // run-configuration workflow: where `.run/*.run.xml` live, how to bootstrap a
-    // schema from a real example, and how to verify a write. JetBrains projects
-    // only, and independent of `/open-in-idea`.
+    // schema from a real example, and how to verify a write. Registered only for
+    // a project that has been marked as an IDEA project, so unrelated projects
+    // never see an IDEA-specific skill.
     //
     // Deliberately NOT wrapped in a catch: these are core features of the plugin,
     // so a rejected definition must fail loudly. Swallowing it would ship a
     // silently incomplete plugin — which is exactly how 0.0.6 lost
     // `/open-in-idea` without anyone noticing until the command was gone.
-    if (isIdeaProject && typeof ctx.skill?.transform === 'function') {
+    const ensureSkills = async () => {
+      if (skillsRegistered || typeof ctx.skill?.transform !== 'function') return;
+      skillsRegistered = true;
       // Read the documents before the transform: callbacks must stay synchronous.
       const skills = readSkills();
       skillRegistration = await ctx.skill.transform((editor) => {
         for (const skill of skills) editor.add(skill);
       });
-    }
+    };
+    /** Remove the IDEA skills again when the project is unmarked. */
+    const removeSkills = async () => {
+      if (!skillsRegistered || !skillRegistration) return;
+      skillsRegistered = false;
+      const registration = skillRegistration;
+      skillRegistration = undefined;
+      try {
+        await registration.dispose();
+      } catch {
+        // best effort
+      }
+    };
+    // A project marked in an earlier run gets its skills at setup; a project
+    // marked for the first time gets them when `/open-in-idea` runs (both paths
+    // go through `setMark` / this setup hook).
+    if (markCache === true) await ensureSkills();
 
     // `/open-in-idea`: manual, re-entrant trigger that also loads the IDE
-    // capabilities immediately.
+    // capabilities immediately, and marks the project so later messages keep the
+    // IDE alive. `/close-in-idea` removes that mark. Both persist through
+    // `ctx.storage` and invalidate the in-memory cache.
     if (typeof ctx.command?.transform === 'function') {
       commandRegistration = await ctx.command.transform((editor) => {
         editor.add({
           name: 'open-in-idea',
           description: '用 IntelliJ IDEA 打开当前项目,并即时加载 IDE MCP 与项目 SDK 环境',
           execute: async (input) => {
+            // Mark the project before running: the mark means "this is an IDEA
+            // project", so it is persisted as soon as the user asks, whether or
+            // not the IDE happens to be reachable right now. `setMark` also
+            // registers the IDEA skills.
+            await setMark(true);
             /** @type {boolean} */
             let unavailableNoticeSent = false;
-            const result = await ensureIde({
+            const result = await runOpenInIdea({
               onUnavailable: async (notice) => {
                 unavailableNoticeSent = await sendFeedback(input, notice);
                 return unavailableNoticeSent;
               },
             });
-            const { port } = result;
-            let toolsReady = false;
-            try {
-              // Do not repeat the expensive probe when the preflight already
-              // found no MCP endpoint. The command will retry after the user
-              // enables MCP + Brave Mode.
-              toolsReady = (await reconcile({ probeIde: port !== undefined })) === true;
-            } catch {
-              // capability load is best effort; feedback still matters
-            }
-            const finalResult = result.status === 'connected' && !toolsReady
-              ? { ...result, status: 'tools-loading' }
-              : result;
             // The unavailable notice is the final result for this command. If
             // it was already delivered, do not show the same warning twice.
             const unavailableAlreadySent = unavailableNoticeSent || result.unavailableNoticeSent;
-            if (!unavailableAlreadySent || finalResult.status !== 'mcp-unavailable') {
-              await sendFeedback(input, finalResult);
+            if (!unavailableAlreadySent || result.status !== 'mcp-unavailable') {
+              await sendFeedback(input, result);
             }
           },
         });
+        editor.add({
+          name: 'close-in-idea',
+          description: '取消当前项目的 IDEA 接入标记,断开后不再自动重连',
+          execute: async (input) => {
+            await setMark(false);
+            await sendFeedback(input, { status: 'closed' });
+          },
+        });
       });
     }
 
     // Hide the tools the model must not see, and point it at the rest. This hook
     // runs for every agent-loop step (including tool-driven continuations), so
-    // it is deliberately a pure function of the request: no I/O, no cached
-    // connection state, and no action of its own.
+    // it stays a cheap, I/O-free function of the request: it checks the cached
+    // project mark and this request's own tool snapshot, and takes no action.
     //
     // `event.tools` is this request's tool snapshot, and OpenCode's own registry
     // adds IDEA tools when the server connects and drops them when it stops
@@ -577,13 +762,36 @@ export default {
         const tools = event?.tools;
         const serving = tools !== undefined && Object.keys(tools).some((name) => name.startsWith('idea_'));
         if (serving) removeIdeaToolDefinitions(tools, HIDDEN_IDEA_TOOLS);
-        if (isIdeaProject || serving) appendIdeRecoveryGuidance(event?.system);
+        if (markCache === true || serving) appendIdeRecoveryGuidance(event?.system);
         if (!injectGuidance) return;
         // Guidance promises tools the model can call, so it only goes out when
         // they are actually in this request.
         if (!serving) return;
         appendIdeGuidance(event?.system, projectPath);
       });
+
+      // Project-level auto-recovery. The only self-initiated action in the
+      // plugin, and only for a marked project. It belongs to the `prompt` hook
+      // (not `context`) because the tool catalog for a request is already fixed
+      // by the time `context` runs: a `prompt`-time reconnect is what lets the
+      // message that triggered it use `idea_*` tools.
+      //
+      // The returned promise is awaited by OpenCode before the request is built,
+      // so a slow cold start delays that message — the accepted cost of treating
+      // a marked project's IDE as always up.
+      promptRegistration = await ctx.session.hook('prompt', async (event) => {
+        const sessionID = event?.sessionID;
+        if (typeof sessionID !== 'string') return;
+        // Never react to the plugin's own notices, or auto-recovery would feed
+        // on itself. Notices carry `metadata.displayText`; the prefix guards
+        // against an older notice shape.
+        const displayText = event?.metadata?.displayText;
+        if (typeof displayText === 'string') return;
+        const text = event?.prompt?.text;
+        if (typeof text === 'string' && text.startsWith('【插件通知】')) return;
+        if (!(await readMark())) return;
+        return autoReconnect(sessionID);
+      });
     }
 
     return async () => {
@@ -602,6 +810,13 @@ export default {
           // best effort
         }
       }
+      if (promptRegistration) {
+        try {
+          await promptRegistration.dispose();
+        } catch {
+          // best effort
+        }
+      }
       if (commandRegistration) {
         try {
           await commandRegistration.dispose();

package/src/project.js

@@ -1,8 +1,5 @@
 // Pure helpers for locating the current OpenCode project.
 
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-
 /**
  * Resolve the absolute project root for the current plugin location.
  * OpenCode exposes a `Location.Info` on the plugin context.
@@ -15,15 +12,3 @@ export function currentProjectPath(location) {
   const projectDirectory = location.project && location.project.directory;
   return projectDirectory || location.directory || undefined;
 }
-
-/**
- * True when the directory looks like a JetBrains project (has a `.idea` folder).
- * This is a convenience signal only; the plugin does not require it, because an
- * IDE may have created the project entry without writing `.idea` yet.
- *
- * @param {string | undefined} directory
- * @returns {boolean}
- */
-export function hasIdeaDirectory(directory) {
-  return typeof directory === 'string' && existsSync(path.join(directory, '.idea'));
-}