feat(agents): reference chips, quote blocks and a richer completion in the composer (#3091 )

The agent composer is now a CodeMirror editor: the text stays plain and is what's sent, while @ file references are drawn as chips (icon, name, lines) that move and delete as one piece, open on click and preview on hover; Backspace after a chip opens it as text. Quotes show as blocks, and sent messages get the same chips and quote blocks. The @ completion lists open editors first, highlights matches and shows the folder; the focused editor's file is offered above the text, a pasted project path becomes a reference, and dropping files shows a hint. Lines copied from an editor paste as a reference, terminal output as a terminal block, and code blocks show as cards. The reference trimming regex avoids lookbehind for WebKit before 16.4.
test(i18n): allow CLI to stay untranslated (#3186 )
2026-11-13 04:34:21 -10:00 · 2026-11-13 22:29:59 +08:00 · 2026-11-13 22:27:11 +08:00 · 2026-11-13 22:25:10 +08:00 · 2026-11-13 22:23:12 +08:00 · 2026-11-13 22:17:50 +08:00
383 changed files with 13672 additions and 1743 deletions
@@ -78,7 +78,7 @@ jobs:
      - uses: dtolnay/rust-toolchain@stable
        with: { targets: "${{ matrix.target }}" }
      - uses: Swatinem/rust-cache@v2
-        with: { key: "${{ matrix.target }}" }
+        with: { key: "${{ matrix.target }}", cache-on-failure: true }
      - name: Linux deps
        if: runner.os == 'Linux'
        run: |
@@ -181,7 +181,7 @@ jobs:
      - uses: dtolnay/rust-toolchain@stable
        with: { targets: "${{ matrix.target }}" }
      - uses: Swatinem/rust-cache@v2
-        with: { key: "server-${{ matrix.target }}" }
+        with: { key: "server-${{ matrix.target }}", cache-on-failure: true }
      - name: musl toolchain
        if: runner.os == 'Linux'
        run: sudo apt-get update && sudo apt-get install -y musl-tools
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"

 [[package]]
 name = "ide-agent"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dunce",
 "encoding_rs",
@@ -4168,7 +4168,7 @@ dependencies = [

 [[package]]
 name = "ide-analysis"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ast-grep-core",
 "ide-core",
@@ -4182,7 +4182,7 @@ dependencies = [

 [[package]]
 name = "ide-android"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "serde",
@@ -4193,7 +4193,7 @@ dependencies = [

 [[package]]
 name = "ide-build"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "blake3",
 "chardetng",
@@ -4211,7 +4211,7 @@ dependencies = [

 [[package]]
 name = "ide-cli"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dirs 6.0.0",
 "serde",
@@ -4225,7 +4225,7 @@ dependencies = [

 [[package]]
 name = "ide-clipboard"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "gtk",
 "objc2 0.6.5",
@@ -4235,7 +4235,7 @@ dependencies = [

 [[package]]
 name = "ide-core"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dunce",
 "encoding_rs",
@@ -4252,7 +4252,7 @@ dependencies = [

 [[package]]
 name = "ide-coverage"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "ide-run",
@@ -4266,7 +4266,7 @@ dependencies = [

 [[package]]
 name = "ide-dap"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "futures",
 "ide-core",
@@ -4288,11 +4288,12 @@ dependencies = [
 "tokio",
 "tracing",
 "tracing-subscriber",
+ "windows-sys 0.61.2",
 ]

 [[package]]
 name = "ide-db"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "base64 0.22.1",
 "bb8",
@@ -4328,7 +4329,7 @@ dependencies = [

 [[package]]
 name = "ide-docker"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "serde",
@@ -4341,7 +4342,7 @@ dependencies = [

 [[package]]
 name = "ide-extension"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "base64 0.22.1",
 "blake3",
@@ -4362,7 +4363,7 @@ dependencies = [

 [[package]]
 name = "ide-fonts"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "objc2-core-foundation",
 "objc2-core-text",
@@ -4374,7 +4375,7 @@ dependencies = [

 [[package]]
 name = "ide-github"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "ide-vcs",
@@ -4387,7 +4388,7 @@ dependencies = [

 [[package]]
 name = "ide-heap"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "criterion",
 "ide-core",
@@ -4405,7 +4406,7 @@ dependencies = [

 [[package]]
 name = "ide-host"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "base64 0.22.1",
 "blake3",
@@ -4476,7 +4477,7 @@ dependencies = [

 [[package]]
 name = "ide-http"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "ide-vfs",
@@ -4495,7 +4496,7 @@ dependencies = [

 [[package]]
 name = "ide-index"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "blake3",
 "criterion",
@@ -4517,7 +4518,7 @@ dependencies = [

 [[package]]
 name = "ide-jdwp"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-jvm-inspect",
 "proptest",
@@ -4529,7 +4530,7 @@ dependencies = [

 [[package]]
 name = "ide-jsonrpc"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "encoding_rs",
 "futures",
@@ -4546,7 +4547,7 @@ dependencies = [

 [[package]]
 name = "ide-jvm-attach"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "libc",
 "tempfile",
@@ -4555,7 +4556,7 @@ dependencies = [

 [[package]]
 name = "ide-jvm-inspect"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "futures",
 "serde",
@@ -4566,7 +4567,7 @@ dependencies = [

 [[package]]
 name = "ide-language"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "blake3",
 "criterion",
@@ -4623,7 +4624,7 @@ dependencies = [

 [[package]]
 name = "ide-lsp"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dunce",
 "encoding_rs",
@@ -4651,7 +4652,7 @@ dependencies = [

 [[package]]
 name = "ide-mcp"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "bytes",
 "dunce",
@@ -4670,7 +4671,7 @@ dependencies = [

 [[package]]
 name = "ide-notebook"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "futures",
 "ide-core",
@@ -4693,7 +4694,7 @@ dependencies = [

 [[package]]
 name = "ide-plugin"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "blake3",
 "dunce",
@@ -4716,7 +4717,7 @@ dependencies = [

 [[package]]
 name = "ide-profiler"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "ide-jvm-attach",
@@ -4730,7 +4731,7 @@ dependencies = [

 [[package]]
 name = "ide-remote"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dunce",
 "futures",
@@ -4750,7 +4751,7 @@ dependencies = [

 [[package]]
 name = "ide-run"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dunce",
 "encoding_rs",
@@ -4774,7 +4775,7 @@ dependencies = [

 [[package]]
 name = "ide-scaffold"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "ide-tools",
@@ -4790,7 +4791,7 @@ dependencies = [

 [[package]]
 name = "ide-sdk"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dunce",
 "ide-core",
@@ -4811,7 +4812,7 @@ dependencies = [

 [[package]]
 name = "ide-search"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "criterion",
 "encoding_rs",
@@ -4832,7 +4833,7 @@ dependencies = [

 [[package]]
 name = "ide-spell"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "parking_lot",
@@ -4845,7 +4846,7 @@ dependencies = [

 [[package]]
 name = "ide-ssh"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dirs 6.0.0",
 "flate2",
@@ -4870,7 +4871,7 @@ dependencies = [

 [[package]]
 name = "ide-syntax"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "ide-language",
@@ -4885,7 +4886,7 @@ dependencies = [

 [[package]]
 name = "ide-terminal"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "ide-core",
 "libc",
@@ -4898,7 +4899,7 @@ dependencies = [

 [[package]]
 name = "ide-text"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "criterion",
 "ide-core",
@@ -4911,7 +4912,7 @@ dependencies = [

 [[package]]
 name = "ide-tools"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "flate2",
 "hex",
@@ -4932,7 +4933,7 @@ dependencies = [

 [[package]]
 name = "ide-vcs"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "blake3",
 "dunce",
@@ -4953,7 +4954,7 @@ dependencies = [

 [[package]]
 name = "ide-vfs"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "chardetng",
 "dunce",
@@ -4977,7 +4978,7 @@ dependencies = [

 [[package]]
 name = "ide-web"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "dirs 6.0.0",
 "ide-core",
@@ -4993,7 +4994,7 @@ dependencies = [

 [[package]]
 name = "ide-workspace"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "blake3",
 "dunce",
@@ -6594,7 +6595,7 @@ dependencies = [

 [[package]]
 name = "openidea"
-version = "0.1.43"
+version = "0.1.44"
 dependencies = [
 "base64 0.22.1",
 "blake3",
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
 exclude = ["sdk", "plugins"]

 [workspace.package]
-version = "0.1.43"
+version = "0.1.44"
 edition = "2024"
 rust-version = "1.96"
 license = "Apache-2.0"
@@ -9,6 +9,10 @@
  The IDE you know, rebuilt in Rust.
 </p>

+<p align="center">
+  English · <a href="README.zh-CN.md">简体中文</a>
+</p>
+
 <p align="center">
  <a href="https://github.com/l0ng-ai/openidea/releases/latest"><b>Download</b></a>
  &nbsp;·&nbsp;
@@ -19,8 +23,6 @@
  <a href="#plugins">Plugins</a>
  &nbsp;·&nbsp;
  <a href="#community">Community</a>
-  &nbsp;·&nbsp;
-  <a href="#sponsor">Sponsor</a>
 </p>

 https://github.com/user-attachments/assets/234dd54c-1255-4b3a-b35c-533d78d737c0
@@ -70,17 +72,6 @@ the [official plugins](plugins/official). The plugin API is still a preview.

 - Contributing: see [CONTRIBUTING.md](CONTRIBUTING.md) and the [contributor docs](https://openidea.sh/en/contribute/setup).

-## Sponsor
-
-If OpenIDEA saves you time, you can support its development with Alipay or WeChat Pay.
-
-<table>
-  <tr>
-    <td align="center"><img src=".github/assets/sponsor-alipay.png" alt="Alipay QR code" width="200"><br>Alipay</td>
-    <td align="center"><img src=".github/assets/sponsor-wechat.png" alt="WeChat Pay QR code" width="200"><br>WeChat Pay</td>
-  </tr>
-</table>
-
 ## License

 [Apache 2.0](LICENSE). Bundled third-party assets are listed in [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md).
@@ -0,0 +1,88 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="src-tauri/icons/source/openidea-wordmark-dark.svg">
+    <img src="src-tauri/icons/source/openidea-wordmark.svg" alt="OpenIDEA" height="56">
+  </picture>
+</p>
+
+<p align="center">
+  你熟悉的 IDE，用 Rust 重新打造。
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> · 简体中文
+</p>
+
+<p align="center">
+  <a href="https://github.com/l0ng-ai/openidea/releases/latest"><b>下载</b></a>
+  &nbsp;·&nbsp;
+  <a href="https://openidea.sh/zh">文档</a>
+  &nbsp;·&nbsp;
+  <a href="#性能对比">性能对比</a>
+  &nbsp;·&nbsp;
+  <a href="#插件">插件</a>
+  &nbsp;·&nbsp;
+  <a href="#社区">社区</a>
+  &nbsp;·&nbsp;
+  <a href="#赞助">赞助</a>
+</p>
+
+https://github.com/user-attachments/assets/234dd54c-1255-4b3a-b35c-533d78d737c0
+
+OpenIDEA 把 IntelliJ IDEA 的使用方式（快捷键、工具窗口、随处搜索的习惯）带到一个以 Rust
+为核心的原生桌面应用里。
+
+编辑器、代码洞察、调试器、Git、终端、数据库客户端和 HTTP 客户端，支持 60 多种语言。
+提供 macOS、Windows 和 Linux 版本。
+
+## 性能对比
+
+在缓存已预热的情况下打开 [freqtrade](https://github.com/freqtrade/freqtrade)（Python，约 770 个文件），
+取 5 次运行的中位数：
+
+|                       | OpenIDEA       | IntelliJ IDEA 2026.2.3 |
+| --------------------- | -------------- | ---------------------- |
+| 显示项目窗口          | **0.9 s**      | 3.1 s                  |
+| 就绪（CPU 平稳）      | **1.1 s**      | 13.2 s                 |
+| 内存（USS，所有进程） | **169 MB**     | 2011 MB                |
+| 就绪前消耗的 CPU 时间 | **2.4 s**      | 47.9 s                 |
+| 空闲 CPU              | 单核的 **4 %** | 单核的 7 %             |
+| 退出                  | **0.3 s**      | 5.9 s                  |
+
+测试使用 `main` 分支的 OpenIDEA release 构建，以及默认设置和插件的 IDEA，环境为 Windows 11、
+32 核 AMD、62 GB 内存。IDEA 对 Python 的分析更深入，所以两边的“就绪”并不代表完成了同样多的工作。
+两者都以相同方式从外部测量：可以用 [`perf/compare`](perf/compare) 在自己的机器和项目上复现。
+
+## 插件
+
+插件可以添加操作、补全、快速修复、工具窗口、自定义编辑器、主题、文件图标和语言。插件以沙箱化的
+WebAssembly 组件运行；主题、图标主题和语言无需编写代码。
+
+在“设置 › 插件”中安装，或用 `openidea-plugin new` 创建自己的插件：参见
+[编写 OpenIDEA 插件](https://openidea.sh/zh/plugins)和[官方插件](plugins/official)。插件 API 目前仍是预览版。
+
+## 社区
+
+- [Discord](https://discord.gg/2Zy4yn7gP)：提问、反馈和版本发布消息。
+- 微信群，扫码加入：
+
+  <img src=".github/assets/wechat-group.png" alt="微信群二维码" width="200">
+
+- 参与贡献：参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
+
+## 赞助
+
+如果 OpenIDEA 帮你节省了时间，可以通过支付宝或微信支付支持它的开发。
+
+<table>
+  <tr>
+    <td align="center"><img src=".github/assets/sponsor-alipay.png" alt="支付宝收款码" width="200"><br>支付宝</td>
+    <td align="center"><img src=".github/assets/sponsor-wechat.png" alt="微信支付收款码" width="200"><br>微信支付</td>
+  </tr>
+</table>
+
+## 许可证
+
+[Apache 2.0](LICENSE)。随附的第三方资源列在 [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md) 中。
+
+<sub>与 JetBrains 无关联。IntelliJ IDEA 是 JetBrains s.r.o. 的商标。</sub>
@@ -3,11 +3,13 @@
 //!
 //! Only the native providers keep transcripts on disk in a readable form: Claude Code
 //! (`<config>/projects/*/<id>.jsonl`, see `native::claude::history`) and Codex
-//! (`<home>/.codex/sessions/**`, rollout files with a `session_meta` line).
+//! (`<home>/.codex/sessions/**`, rollout files with a `session_meta` line, named in
+//! `<home>/.codex/session_index.jsonl`).

 use super::native::claude::history;
 use serde::Serialize;
 use specta::Type;
+use std::collections::HashMap;
 use std::io::BufRead;
 use std::path::{Path, PathBuf};

@@ -206,11 +208,39 @@ fn rollout_files(dir: &Path, depth: usize, out: &mut Vec<PathBuf>) {
    }
 }

-/// Codex sessions of the project at `root`: `<home>/.codex/sessions/**`.
+/// Thread names Codex keeps in `session_index.jsonl`, by thread id. A rename adds a line,
+/// so the last one wins.
+fn codex_names(codex_home: &Path) -> HashMap<String, String> {
+    let Ok(file) = std::fs::File::open(codex_home.join("session_index.jsonl")) else { return HashMap::new() };
+    let mut names = HashMap::new();
+    for line in std::io::BufReader::new(file).lines() {
+        let Ok(line) = line else { break };
+        let Ok(v) = serde_json::from_str::<serde_json::Value>(&line) else { continue };
+        let id = v.get("id").and_then(serde_json::Value::as_str);
+        let name = v.get("thread_name").and_then(serde_json::Value::as_str).map(str::trim).filter(|n| !n.is_empty());
+        if let (Some(id), Some(name)) = (id, name) {
+            names.insert(id.to_owned(), name.to_owned());
+        }
+    }
+    names
+}
+
+/// Codex sessions of the project at `root`: `<home>/.codex/sessions/**`, titled by their
+/// thread names, else by their first prompts.
 pub fn codex_sessions(codex_home: &Path, root: &Path) -> Vec<ExternalSession> {
    let mut files = Vec::new();
    rollout_files(&codex_home.join("sessions"), 4, &mut files);
-    files.iter().filter_map(|p| codex_file(p)).filter(|s| in_project(s.cwd.as_deref(), root)).collect()
+    let mut sessions: Vec<ExternalSession> =
+        files.iter().filter_map(|p| codex_file(p)).filter(|s| in_project(s.cwd.as_deref(), root)).collect();
+    if !sessions.is_empty() {
+        let names = codex_names(codex_home);
+        for s in &mut sessions {
+            if let Some(name) = names.get(&s.session_id) {
+                s.title = short(name);
+            }
+        }
+    }
+    sessions
 }

 #[cfg(test)]
@@ -282,6 +312,16 @@ mod tests {
        assert_eq!((s.provider.as_str(), s.session_id.as_str()), ("codex", "thread-1"));
        assert_eq!(s.title, "add tests");
        assert_eq!(s.cwd.as_deref(), Some("/work/app"));
+
+        write(
+            &tmp.path().join("session_index.jsonl"),
+            &[
+                json!({"id": "thread-1", "thread_name": "Add tests", "updated_at": "t1"}),
+                json!({"id": "thread-2", "thread_name": "Other", "updated_at": "t1"}),
+                json!({"id": "thread-1", "thread_name": "Add parser tests", "updated_at": "t2"}),
+            ],
+        );
+        assert_eq!(codex_sessions(tmp.path(), Path::new("/work"))[0].title, "Add parser tests");
    }

    #[test]
@@ -1097,6 +1097,8 @@ impl AgentManager {
                title_renamed: s.title_renamed,
            }
        };
+        // Copying may have started the source's agent: it stops again once idle.
+        source.release_when_idle();
        let task = Task::restore(file, self.shared.clone());
        self.tasks.write().insert(task.id.clone(), task.clone());
        task.persist();
@@ -1166,6 +1168,8 @@ impl AgentManager {
        task.persist();
        self.shared.emit(AgentEvent::Truncated { task: id.to_owned(), length: cut as u32 });
        task.emit_task();
+        // Undoing may have started the agent: it stops again once idle.
+        task.release_when_idle();
        Ok(first)
    }

@@ -158,6 +158,42 @@ pub(crate) fn title(entries: &[Value]) -> Option<String> {
        .map(str::to_owned)
 }

+/// Claude Code titles a session from the last 1000 characters of its text.
+const TITLE_SOURCE_CHARS: usize = 1000;
+/// Below this Claude Code gives no title without asking the model.
+const TITLE_SOURCE_MIN_CHARS: usize = 10;
+
+/// The conversation's own text to title the session after: the prompts and the replies,
+/// without the files attached to the prompts. `None` while there is too little.
+pub(super) fn title_source(entries: &[Value]) -> Option<String> {
+    let mut text = String::new();
+    for e in chain(entries, None) {
+        if !(is_turn_start(e) || kind(e) == "assistant") {
+            continue;
+        }
+        let blocks = match e.pointer("/message/content") {
+            Some(Value::String(s)) => vec![s.as_str()],
+            Some(Value::Array(blocks)) => blocks
+                .iter()
+                .filter(|b| b.get("type").and_then(Value::as_str) == Some("text"))
+                .filter_map(|b| b.get("text").and_then(Value::as_str))
+                .filter(|t| !t.starts_with("\n<context ref="))
+                .collect(),
+            _ => Vec::new(),
+        };
+        for block in blocks {
+            text.push_str(block);
+            text.push('\n');
+        }
+    }
+    let text = text.trim();
+    let len = text.chars().count();
+    if len < TITLE_SOURCE_MIN_CHARS {
+        return None;
+    }
+    Some(text.chars().skip(len.saturating_sub(TITLE_SOURCE_CHARS)).collect())
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -219,6 +255,29 @@ mod tests {
        assert_eq!(cut(&c, 1), Ok(None));
    }

+    #[test]
+    fn titles_come_from_prompts_and_replies() {
+        let mut prompt = user("u1", None, "Fix the login form");
+        prompt["message"]["content"]
+            .as_array_mut()
+            .unwrap()
+            .push(json!({"type": "text", "text": "\n<context ref=\"file:///p/a.rs\">\nfn a() {}\n</context>"}));
+        let entries = vec![
+            prompt,
+            assistant(
+                "a1",
+                "u1",
+                json!([{"type": "thinking", "thinking": "hm"}, {"type": "text", "text": "Done."},
+                    {"type": "tool_use", "id": "t1", "name": "Bash", "input": {}}]),
+            ),
+            json!({"type": "user", "uuid": "r1", "parentUuid": "a1", "message": {"content": [{"type": "tool_result", "tool_use_id": "t1", "content": "out"}]}}),
+        ];
+        assert_eq!(title_source(&entries).as_deref(), Some("Fix the login form\nDone."));
+        assert_eq!(title_source(&[user("u1", None, "hi")]), None);
+        let long = "x".repeat(TITLE_SOURCE_CHARS + 5);
+        assert_eq!(title_source(&[user("u1", None, &long)]).map(|t| t.chars().count()), Some(TITLE_SOURCE_CHARS));
+    }
+
    #[test]
    fn project_directory_names() {
        assert_eq!(escape(Path::new("/private/tmp/a.b/c_d")), "-private-tmp-a-b-c-d");
@@ -191,6 +191,8 @@ struct State {
    limit_resets_ms: Option<f64>,
    terminal_only: Vec<String>,
    titled: bool,
+    /// A title is being read or generated.
+    titling: bool,
 }

 struct Turn {
@@ -365,6 +367,7 @@ impl Shim {
                limit_resets_ms: None,
                terminal_only: Vec::new(),
                titled: false,
+                titling: false,
            }),
            cwd,
            starting: tokio::sync::Mutex::new(()),
@@ -583,11 +586,12 @@ impl Shim {
 impl super::Shim for Shim {
    fn attach(&self, client: Peer) {
        let _ = self.client.set(client.clone());
-        // The client went away: so do the processes.
-        let weak = self.me.clone();
+        // The client went away: so do the processes. Held until then: the connection drops
+        // its handler (this shim) as it closes, and the sessions would go without stopping.
+        let me = self.me.upgrade();
        tokio::spawn(async move {
            client.closed().await;
-            if let Some(me) = weak.upgrade() {
+            if let Some(me) = me {
                me.closed.store(true, Ordering::Release);
                let sessions: Vec<Arc<Session>> = me.sessions.lock().drain().map(|(_, s)| s).collect();
                for s in sessions {
@@ -598,6 +602,15 @@ impl super::Shim for Shim {
    }
 }

+impl Drop for Session {
+    /// A session dropped without being stopped (the shim went away) takes its process along.
+    fn drop(&mut self) {
+        if let Some(p) = self.st.get_mut().proc.take() {
+            p.kill.cancel();
+        }
+    }
+}
+
 impl Session {
    fn shim(&self) -> Option<Arc<Shim>> {
        self.shim.upgrade()
@@ -1048,7 +1061,8 @@ impl Session {
                    } else if matches!(st.start, Start::New { .. }) {
                        st.start = Start::Resume { id: self.id.clone(), at: None };
                    }
-                    read_title = !st.titled;
+                    read_title = !st.titled && !st.titling;
+                    st.titling |= read_title;
                    if let Some(turn) = st.turn.as_ref()
                        && belongs(turn, &msg)
                    {
@@ -1073,13 +1087,29 @@ impl Session {
        }
    }

-    /// Sends the title Claude Code gave the session, once it has one.
+    /// Sends the session's title once it has one: the one in its transcript, or else one
+    /// Claude Code is asked for, as it titles no session run the way the Agent SDK runs it.
+    /// Without a title the next turn tries again.
    fn read_title(self: &Arc<Self>) {
        let me = self.clone();
-        tokio::task::spawn_blocking(move || {
-            let Some(title) = chain_title(&me) else { return };
-            me.st.lock().titled = true;
-            if let Some(shim) = me.shim() {
+        tokio::spawn(async move {
+            let reader = me.clone();
+            let entries = tokio::task::spawn_blocking(move || transcript_entries(&reader)).await.ok().flatten();
+            let mut title = entries.as_deref().and_then(history::title);
+            if title.is_none()
+                && let Some(source) = entries.as_deref().and_then(history::title_source)
+            {
+                title = me.generate_title(source).await;
+            }
+            {
+                let mut st = me.st.lock();
+                st.titling = false;
+                if title.is_none() {
+                    return;
+                }
+                st.titled = true;
+            }
+            if let (Some(title), Some(shim)) = (title, me.shim()) {
                shim.notify(vec![Update {
                    session: me.id.clone(),
                    update: json!({ "sessionUpdate": "session_info_update", "title": title }),
@@ -1088,6 +1118,19 @@ impl Session {
        });
    }

+    /// A title Claude Code generates from `source`, also written to the transcript.
+    async fn generate_title(&self, source: String) -> Option<String> {
+        let proc = self.st.lock().proc.clone()?;
+        let request = json!({ "subtype": "generate_session_title", "description": source, "persist": true });
+        match proc.control(request).await {
+            Ok(r) => r.get("title").and_then(Value::as_str).map(str::trim).filter(|t| !t.is_empty()).map(str::to_owned),
+            Err(e) => {
+                tracing::debug!("generating a claude session title: {e}");
+                None
+            }
+        }
+    }
+
    async fn on_cli_request(self: &Arc<Self>, proc: &Arc<Proc>, msg: Value) {
        let id = msg.get("request_id").and_then(Value::as_str).unwrap_or_default().to_owned();
        let request = msg.get("request").cloned().unwrap_or_default();
@@ -1417,9 +1460,13 @@ fn strings(v: Option<&Value>) -> Vec<String> {

 /// The title in a session's transcript (or that of the session it continues).
 fn chain_title(session: &Session) -> Option<String> {
+    history::title(&transcript_entries(session)?)
+}
+
+fn transcript_entries(session: &Session) -> Option<Vec<Value>> {
    let shim = session.shim()?;
    let path = shim.transcript(&session.cwd, &session.id).filter(|p| p.exists())?;
-    history::title(&history::read(&path).ok()?)
+    history::read(&path).ok()
 }

 fn start_json(start: &Start) -> Value {
@@ -311,6 +311,8 @@ struct Replay {
    sent: Arc<Mutex<Vec<Vec<Value>>>>,
    launched: Mutex<Vec<Vec<String>>>,
    errors: Arc<Mutex<Vec<String>>>,
+    /// Each process's kill token.
+    kills: Mutex<Vec<CancellationToken>>,
 }

 impl Cli for Replay {
@@ -331,6 +333,7 @@ impl Cli for Replay {
        let (shim_in, cli_in) = tokio::io::duplex(1 << 20);
        let (mut cli_out, shim_out) = tokio::io::duplex(1 << 20);
        let kill = CancellationToken::new();
+        self.kills.lock().push(kill.clone());
        let (sent, errors, token) = (self.sent.clone(), self.errors.clone(), kill.clone());
        sent.lock().push(Vec::new());
        tokio::spawn(async move {
@@ -421,14 +424,18 @@ impl Replayed {
    }
 }

-async fn replay(name: &str) -> Replayed {
-    let processes = load_fixture(name);
-    let cli = Arc::new(Replay {
+fn replay_cli(processes: Vec<Vec<Frame>>) -> Arc<Replay> {
+    Arc::new(Replay {
        processes: Mutex::new(processes.into()),
        sent: Arc::default(),
        launched: Mutex::default(),
        errors: Arc::default(),
-    });
+        kills: Mutex::default(),
+    })
+}
+
+async fn replay(name: &str) -> Replayed {
+    let cli = replay_cli(load_fixture(name));
    let (config, cwd) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
    let cwd_path = std::fs::canonicalize(cwd.path()).unwrap();
    let h =
@@ -461,6 +468,69 @@ async fn replay_simple() {
    assert_eq!(user["message"]["content"][0]["text"], "Reply with exactly: hello there");
 }

+/// The app closing the connection (an idle task released, archived or deleted) stops the
+/// CLI processes of its sessions, idle ones included.
+#[tokio::test(flavor = "multi_thread")]
+async fn closing_the_connection_stops_the_processes() {
+    let r = replay("simple").await;
+    assert!(r.cli.kills.lock().iter().all(|k| !k.is_cancelled()));
+    r.h.client.kill();
+    let kills = r.cli.kills.lock().clone();
+    tokio::time::timeout(Duration::from_secs(5), async {
+        for k in kills {
+            k.cancelled().await;
+        }
+    })
+    .await
+    .expect("every process was stopped");
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn sessions_without_a_title_get_one_generated() {
+    let mut processes = load_fixture("simple");
+    processes[0].extend([
+        Frame::Shim(json!({"type": "control_request", "request_id": "req_3",
+            "request": {"subtype": "generate_session_title"}})),
+        Frame::Cli(json!({"type": "control_response",
+            "response": {"subtype": "success", "request_id": "req_3", "response": {"title": "Say hello"}}})),
+    ]);
+    let cli = replay_cli(processes);
+    let (config, cwd) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
+    let cwd_path = std::fs::canonicalize(cwd.path()).unwrap();
+    let h = Harness::connect(
+        cli.clone(),
+        config.path().into(),
+        config.path().join("pending"),
+        cwd_path.clone(),
+        Vec::new(),
+    )
+    .await;
+    let session = h.new_session().await;
+    // The transcript Claude Code writes, without the title it gives sessions in a terminal.
+    let dir = config.path().join("projects").join(history::escape(&cwd_path));
+    std::fs::create_dir_all(&dir).unwrap();
+    let prompt = json!({"type": "user", "uuid": "u1", "parentUuid": null,
+        "message": {"role": "user", "content": "Reply with exactly: hello there"}});
+    std::fs::write(dir.join(format!("{session}.jsonl")), format!("{prompt}\n")).unwrap();
+
+    h.prompt(&session, "Reply with exactly: hello there").await.unwrap();
+    let mut titles = Vec::new();
+    for _ in 0..100 {
+        titles = h.updates(&session, "session_info_update");
+        if !titles.is_empty() {
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    assert!(cli.errors.lock().is_empty(), "{:?}", cli.errors.lock());
+    assert_eq!(titles.iter().map(|t| t["title"].clone()).collect::<Vec<_>>(), [json!("Say hello")]);
+    let sent = cli.sent.lock()[0].clone();
+    let request =
+        sent.iter().find(|m| m.pointer("/request/subtype") == Some(&json!("generate_session_title"))).unwrap();
+    assert_eq!(request["request"]["description"], "Reply with exactly: hello there");
+    assert_eq!(request["request"]["persist"], true);
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn replay_multi_turn() {
    let r = replay("multi_turn").await;
@@ -727,6 +797,7 @@ async fn a_stop_ahead_of_its_prompt_cancels_it() {
        sent: Arc::default(),
        launched: Mutex::default(),
        errors: Arc::default(),
+        kills: Mutex::default(),
    });
    let (dir, cwd) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
    let h = Harness::connect(cli.clone(), dir.path().into(), dir.path().join("p"), cwd.path().into(), Vec::new()).await;
@@ -770,6 +841,7 @@ async fn a_failed_turn_reports_its_failure() {
            sent: Arc::default(),
            launched: Mutex::default(),
            errors: Arc::default(),
+            kills: Mutex::default(),
        });
        let (dir, cwd) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
        let h =
@@ -28,6 +28,9 @@ const OUTPUT_EVERY: Duration = Duration::from_millis(200);
 const EARLY_CANCEL: Duration = Duration::from_secs(1);
 /// How long the client's connection outlives codex.
 const EXIT_GRACE: Duration = Duration::from_millis(100);
+/// What a thread's name is asked for with, after its first turn.
+const NAME_PROMPT: &str = "Name this conversation for a list of tasks: a short title of at most six words, in the \
+    language the user writes in. Reply with the title only, without quotes or a closing period.";

 pub(crate) fn connect(
    spec: &ProviderSpec,
@@ -126,6 +129,10 @@ struct Thread {
    early_cancel: Option<Instant>,
    /// The latest agent message (a subagent's answer).
    answer: String,
+    /// The thread has a name.
+    named: bool,
+    /// A name is being asked for.
+    naming: bool,
 }

 struct PendingPrompt {
@@ -329,6 +336,7 @@ impl CodexShim {
        t.parent = None;
        t.settings = Some(settings);
        t.cwd = cwd;
+        t.named = thread.get("name").and_then(Value::as_str).is_some_and(|n| !n.trim().is_empty());
        (id, options)
    }

@@ -625,8 +633,9 @@ impl CodexShim {
                Some(translate::plan(params))
            }),
            "thread/tokenUsage/updated" => self.with_thread(thread, |_, _| translate::usage(params)),
-            "thread/name/updated" => self.with_thread(thread, |_, _| {
+            "thread/name/updated" => self.with_thread(thread, |t, _| {
                let title = params.get("threadName").and_then(Value::as_str)?;
+                t.named = true;
                Some(json!({ "sessionUpdate": "session_info_update", "title": title }))
            }),
            "thread/started" => self.thread_started(params.get("thread").unwrap_or(&Value::Null)),
@@ -812,9 +821,10 @@ impl CodexShim {
        }
    }

-    fn turn_completed(&self, thread: &str, turn: &Value) {
+    fn turn_completed(self: &Arc<Self>, thread: &str, turn: &Value) {
        let id = turn.get("id").and_then(Value::as_str).unwrap_or_default();
-        let (parent, answer) = {
+        let completed = turn.get("status").and_then(Value::as_str) == Some("completed");
+        let (parent, answer, name) = {
            let mut state = self.state.lock();
            let Some(t) = state.threads.get_mut(thread) else { return };
            if t.turn.as_deref().is_none_or(|r| r == id) {
@@ -830,8 +840,15 @@ impl CodexShim {
                let _ = p.done.send((turn.clone(), error.clone()));
            }
            let answer = std::mem::take(&mut t.answer);
-            (t.parent.clone(), (answer, error))
+            let name =
+                completed && !id.is_empty() && t.parent.is_none() && t.settings.is_some() && !t.named && !t.naming;
+            t.naming |= name;
+            (t.parent.clone(), (answer, error), name)
        };
+        if name {
+            let (shim, thread, turn) = (self.clone(), thread.to_owned(), id.to_owned());
+            self.runtime.spawn(async move { shim.name_thread(&thread, &turn).await });
+        }
        let Some(parent) = parent else { return };
        let (answer, error) = answer;
        let mut state_of = match turn.get("status").and_then(Value::as_str) {
@@ -853,6 +870,28 @@ impl CodexShim {
        }
    }

+    /// Names a thread from what it holds after `turn`, as codex leaves naming to its
+    /// clients; `thread/name/updated` brings the name back. Unnamed, the next turn tries again.
+    async fn name_thread(&self, thread: &str, turn: &str) {
+        let sample = json!({ "threadId": thread, "expectedTurnId": turn, "prompt": NAME_PROMPT, "effort": "low" });
+        let named = match self.call("thread/sample", sample).await {
+            Ok(r) => match r.get("text").and_then(Value::as_str).and_then(translate::thread_name) {
+                Some(name) => {
+                    self.call("thread/name/set", json!({ "threadId": thread, "name": name })).await.map(|_| ())
+                }
+                None => Err(error(codes::INTERNAL_ERROR, "codex gave no name")),
+            },
+            Err(e) => Err(e),
+        };
+        if let Err(e) = &named {
+            tracing::debug!("naming codex thread {thread}: {}", e.message);
+        }
+        if let Some(t) = self.state.lock().threads.get_mut(thread) {
+            t.naming = false;
+            t.named |= named.is_ok();
+        }
+    }
+
    /// Requests from codex: approvals and questions, asked as ACP permission requests.
    fn on_codex_request(&self, method: &str, params: &Value) -> Result<Value, (i64, String)> {
        let thread = params.get("threadId").and_then(Value::as_str).unwrap_or_default().to_owned();
@@ -535,8 +535,10 @@ async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
                    .unwrap()
                    .unwrap_or_else(|| panic!("the shim closed before {frame}"));
                let actual: Value = serde_json::from_str(&line).unwrap();
-                // Older recordings predate skill discovery; play an unsupported server.
-                if actual["method"] == "skills/list" && frame["method"] != "skills/list" {
+                // Older recordings predate skill discovery and thread naming; play an
+                // unsupported server.
+                let method = actual["method"].as_str().unwrap_or_default();
+                if matches!(method, "skills/list" | "thread/sample") && frame["method"] != method {
                    let reply = json!({ "id": actual["id"], "error": { "code": -32601, "message": "unsupported" } });
                    write.write_all(format!("{reply}\n").as_bytes()).await.unwrap();
                    continue;
@@ -574,7 +576,14 @@ async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
 /// Runs `scenario` against its transcript; returns the ACP results, the client and
 /// the frames the shim sent.
 async fn replay(scenario: Scenario) -> (Results, Arc<Client>, Vec<Value>, Value) {
-    let t = load(scenario.file());
+    let (results, client, sent, meta, _codex) = replay_transcript(scenario, load(scenario.file())).await;
+    (results, client, sent, meta)
+}
+
+/// Both connections of a replay, which stay open while it is held.
+type CodexEnd = Box<dyn std::any::Any>;
+
+async fn replay_transcript(scenario: Scenario, t: Transcript) -> (Results, Arc<Client>, Vec<Value>, Value, CodexEnd) {
    let (ours, theirs) = tokio::io::duplex(1 << 20);
    let (tr, tw) = tokio::io::split(theirs);
    let client = Arc::new(Client::default());
@@ -590,8 +599,8 @@ async fn replay(scenario: Scenario) -> (Results, Arc<Client>, Vec<Value>, Value)
        .await
        .expect("the scenario finished");
    // Codex stays up until the scenario is over.
-    let (sent, _read, _write) = player.await.unwrap();
-    (results, client, sent, meta)
+    let (sent, read, write) = player.await.unwrap();
+    (results, client, sent, meta, Box::new((acp, read, write)))
 }

 fn sent<'a>(frames: &'a [Value], method: &str) -> Vec<&'a Value> {
@@ -801,6 +810,42 @@ async fn a_simple_turn_streams_reasoning_text_and_usage() {
    assert_eq!(info["title"], "Say hi");
 }

+#[tokio::test(flavor = "multi_thread")]
+async fn an_unnamed_thread_is_named_after_its_first_turn() {
+    let mut t = load(Scenario::Simple.file());
+    t.frames.retain(|(_, f)| f["method"] != "thread/name/updated");
+    let thread = "01a18300-0000-7000-8000-000000000001";
+    t.frames.extend([
+        (true, json!({"id": 90, "method": "thread/sample"})),
+        (false, json!({"id": 90, "result": {"responseId": "r", "sourceTurnId": thread, "text": "\"Say hi.\"\n"}})),
+        (true, json!({"id": 91, "method": "thread/name/set"})),
+        (false, json!({"id": 91, "result": {}})),
+        (false, json!({"method": "thread/name/updated", "params": {"threadId": thread, "threadName": "Say hi"}})),
+    ]);
+    let (results, client, frames, _, _codex) = replay_transcript(Scenario::Simple, t).await;
+    let session = session_of(&results, "new");
+    let sample = &sent(&frames, "thread/sample")[0]["params"];
+    assert_eq!((sample["threadId"].as_str(), sample["expectedTurnId"].as_str()), (Some(thread), Some(thread)));
+    assert_eq!(sent(&frames, "thread/name/set")[0]["params"], json!({"threadId": thread, "name": "Say hi"}));
+    let mut info = Vec::new();
+    for _ in 0..100 {
+        info = client.of(&session).into_iter().filter(|u| u["sessionUpdate"] == "session_info_update").collect();
+        if !info.is_empty() {
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    assert_eq!(info.iter().map(|u| u["title"].clone()).collect::<Vec<_>>(), [json!("Say hi")]);
+}
+
+#[test]
+fn thread_names_are_the_first_line_of_the_reply() {
+    assert_eq!(thread_name("  \n“修复登录表单。”\nmore").as_deref(), Some("修复登录表单"));
+    assert_eq!(thread_name("**Fix the login form.**").as_deref(), Some("Fix the login form"));
+    assert_eq!(thread_name(" \n\"\" "), None);
+    assert_eq!(thread_name(&"x".repeat(100)).map(|n| n.chars().count()), Some(80));
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn settings_apply_to_the_next_turn() {
    let (results, client, frames, _) = replay(Scenario::MultiTurn).await;
@@ -612,6 +612,16 @@ pub(super) fn usage(params: &Value) -> Option<Value> {
    Some(json!({ "sessionUpdate": "usage_update", "used": used, "size": size }))
 }

+/// A thread name from the model's reply to the naming prompt: its first line, without
+/// quotes or a closing period. `None` when nothing is left.
+pub(super) fn thread_name(reply: &str) -> Option<String> {
+    const MAX_NAME: usize = 80;
+    let line = reply.lines().map(str::trim).find(|l| !l.is_empty())?;
+    let line = line.trim_matches(|c: char| matches!(c, '"' | '\'' | '`' | '“' | '”' | '「' | '」' | '*'));
+    let line = line.trim_end_matches(['.', '。']).trim();
+    (!line.is_empty()).then(|| line.chars().take(MAX_NAME).collect())
+}
+
 /// How a failed turn is reported.
 #[derive(Debug, PartialEq)]
 pub(super) enum Failure {
@@ -2391,6 +2391,27 @@ async fn idle_agents_stop_and_resume_their_session_on_the_next_message() {
    assert!(live(&mgr, &task.id));
    mgr.shutdown();

+    // Undoing turns or copying the conversation starts a stopped agent: it stops again too.
+    let tmp = tempfile::tempdir().unwrap();
+    let agent = Arc::new(FakeAgent::default());
+    let mgr = manager(tmp.path(), agent.clone());
+    mgr.set_idle_release(Duration::from_millis(200));
+    let task = mgr.create(new()).await.unwrap();
+    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
+    mgr.prompt(&task.id, text("again"), false).await.unwrap();
+    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
+    tokio::time::sleep(Duration::from_millis(600)).await;
+    assert!(!live(&mgr, &task.id));
+    mgr.rollback(&task.id, 1).await.unwrap();
+    assert!(live(&mgr, &task.id));
+    tokio::time::sleep(Duration::from_millis(600)).await;
+    assert!(!live(&mgr, &task.id), "an agent started to undo turns stops too");
+    mgr.fork(&task.id, None).await.unwrap();
+    assert!(live(&mgr, &task.id));
+    tokio::time::sleep(Duration::from_millis(600)).await;
+    assert!(!live(&mgr, &task.id), "an agent started to copy the conversation stops too");
+    mgr.shutdown();
+
    // An agent that can't reload its session keeps running: stopping it would lose the conversation.
    let tmp = tempfile::tempdir().unwrap();
    let agent = Arc::new(FakeAgent { no_load: true, ..FakeAgent::default() });
@@ -225,6 +225,15 @@ fn same_file(a: &Path, b: &Path) -> bool {
    }
 }

+/// The bytes of `path` (`Some(None)`: no file there), or `None` when it is there but can't be read.
+fn existing(path: &Path) -> Option<Option<Vec<u8>>> {
+    match std::fs::read(path) {
+        Ok(bytes) => Some(Some(bytes)),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Some(None),
+        Err(_) => None,
+    }
+}
+
 fn crlf_to_lf(bytes: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(bytes.len());
    for (i, &b) in bytes.iter().enumerate() {
@@ -411,25 +420,31 @@ pub(crate) fn accept(
    let copyable = |rel: &str| task_side.allows(rel) && checkout_side.allows(rel);
    let renamed_from: BTreeMap<String, String> =
        repo.diff_with_worktree(base)?.into_iter().filter_map(|f| Some((f.path, f.old_path?))).collect();
-    // Brings one path of the checkout to the task's version, unless the checkout changed it itself.
-    let apply = |rel: &str| -> IdeResult<bool> {
-        let local = local_root.join(rel);
+    // The task's version of one path of the checkout (`Some(None)`: absent there), or `None` when
+    // the checkout changed it itself.
+    let target = |rel: &str| -> IdeResult<Option<Option<Vec<u8>>>> {
        let in_task = repo.root().join(rel);
-        let base_bytes = repo.file_bytes_at(&in_task, Some(base))?;
        let current = std::fs::read(&in_task).ok();
-        let local_bytes = std::fs::read(&local).ok();
+        // A file there that can't be read is the checkout's own: never written over.
+        let Some(local_bytes) = existing(&local_root.join(rel)) else { return Ok(None) };
        if local_bytes == current {
-            return Ok(true);
+            return Ok(Some(current));
        }
+        let base_bytes = repo.file_bytes_at(&in_task, Some(base))?;
        // The checkout may hold the committed LF text with CRLF line ends (`core.autocrlf`).
        let unchanged = match (&local_bytes, &base_bytes) {
            (Some(now), Some(at_base)) => now == at_base || crlf_to_lf(now) == *at_base,
            (now, at_base) => now == at_base,
        };
-        if !unchanged {
-            return Ok(false);
+        Ok(unchanged.then_some(current))
+    };
+    // Puts `bytes` (`None`: nothing) at `rel` of the checkout.
+    let write = |rel: &str, bytes: Option<Vec<u8>>| -> IdeResult<()> {
+        let local = local_root.join(rel);
+        if std::fs::read(&local).ok() == bytes {
+            return Ok(());
        }
-        match current {
+        match bytes {
            Some(bytes) => {
                if let Some(parent) = local.parent() {
                    std::fs::create_dir_all(parent)?;
@@ -441,6 +456,12 @@ pub(crate) fn accept(
                _ => {}
            },
        }
+        Ok(())
+    };
+    // Brings one path of the checkout to the task's version, unless the checkout changed it itself.
+    let apply = |rel: &str| -> IdeResult<bool> {
+        let Some(bytes) = target(rel)? else { return Ok(false) };
+        write(rel, bytes)?;
        Ok(true)
    };
    let mut accepted = Vec::with_capacity(changes.len());
@@ -466,8 +487,9 @@ pub(crate) fn accept(
        // A case-only rename (`a.txt` → `A.txt`). Where the disk resolves both
        // spellings to one file it is renamed in place and `apply` then refreshes
        // the content. On a case-sensitive disk the two names are different files:
-        // the old one's unchanged-ness (it is the file the checkout had) decides —
-        // then the task's version lands at the new name and the old one goes.
+        // both are checked before either changes — the old one must be the file the
+        // checkout had, the new one absent or already the task's — then the task's
+        // version lands at the new name before the old one goes.
        let case_only =
            old.is_some_and(|o| o != &change.rel_path && o.to_lowercase() == change.rel_path.to_lowercase());
        if case_only {
@@ -476,20 +498,18 @@ pub(crate) fn accept(
            if same_file(&old_path, &new_path) {
                std::fs::rename(&old_path, &new_path)?;
            } else {
-                if !apply(old)? {
+                let Some(old_target) = target(old)? else {
                    skipped.push(skip(old));
                    continue;
+                };
+                let task_bytes = std::fs::read(repo.root().join(&change.rel_path)).ok();
+                let at_new = existing(&new_path);
+                if at_new.as_ref().is_none_or(|at_new| at_new.is_some() && *at_new != task_bytes) {
+                    skipped.push(skip(&change.rel_path));
+                    continue;
                }
-                // `apply(old)` removed the old file (the task's tree has it only at
-                // the new name); now write that version under the new name. `apply`
-                // can't do it — it reads the new name's own base/absence — so the
-                // write is open-coded from the same task bytes `apply` would use.
-                if let Ok(bytes) = std::fs::read(repo.root().join(&change.rel_path)) {
-                    if let Some(parent) = new_path.parent() {
-                        std::fs::create_dir_all(parent)?;
-                    }
-                    std::fs::write(&new_path, bytes)?;
-                }
+                write(&change.rel_path, task_bytes)?;
+                write(old, old_target)?;
                accepted.push(change.rel_path.clone());
                continue;
            }
@@ -960,6 +980,41 @@ mod tests {
        assert_eq!(names, ["A.txt"]);
    }

+    #[test]
+    fn a_case_only_rename_keeps_a_file_the_checkout_has_at_the_new_name() {
+        let (_tmp, repo, created) = accept_repo();
+        std::fs::write(repo.join("A.txt"), "mine\n").unwrap();
+        if std::fs::read_to_string(repo.join("a.txt")).unwrap() == "mine\n" {
+            eprintln!("this disk doesn't tell a.txt from A.txt; nothing to check");
+            return;
+        }
+        git(&created.path, &["mv", "a.txt", "A.txt"]);
+        let changes = listed(&created.path, &created.base_commit);
+        let outcome = accept(&repo, &created.path, &created.base_commit, &changes).unwrap();
+        assert_eq!(outcome.skipped.iter().map(|s| s.path.as_str()).collect::<Vec<_>>(), ["A.txt"]);
+        assert_eq!(std::fs::read_to_string(repo.join("A.txt")).unwrap(), "mine\n");
+        assert_eq!(std::fs::read_to_string(repo.join("a.txt")).unwrap(), "one\ntwo\n");
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn accept_leaves_a_checkout_file_it_cannot_read() {
+        use std::os::unix::fs::PermissionsExt;
+        let (_tmp, repo, created) = accept_repo();
+        std::fs::write(created.path.join("new.txt"), "task\n").unwrap();
+        std::fs::write(repo.join("new.txt"), "mine\n").unwrap();
+        std::fs::set_permissions(repo.join("new.txt"), std::fs::Permissions::from_mode(0o200)).unwrap();
+        if std::fs::read(repo.join("new.txt")).is_ok() {
+            eprintln!("running as a user that reads any file; nothing to check");
+            return;
+        }
+        let changes = listed(&created.path, &created.base_commit);
+        let outcome = accept(&repo, &created.path, &created.base_commit, &changes).unwrap();
+        std::fs::set_permissions(repo.join("new.txt"), std::fs::Permissions::from_mode(0o644)).unwrap();
+        assert_eq!(outcome.skipped.iter().map(|s| s.path.as_str()).collect::<Vec<_>>(), ["new.txt"]);
+        assert_eq!(std::fs::read_to_string(repo.join("new.txt")).unwrap(), "mine\n");
+    }
+
    #[cfg(windows)]
    #[test]
    fn accept_does_not_write_into_the_checkouts_git_folder_through_its_short_name() {
@@ -12,7 +12,8 @@ mod up_to_date;
 pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
 pub use launch_resources::process_launch_resources;
 pub use single::{
-    SingleFileTarget, compile_file_plan, find_javac, javac_step, single_file_classpath, single_file_target,
+    SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
+    single_file_target,
 };
 pub use up_to_date::{menu_up_to_date, record_menu_build};

@@ -4,12 +4,21 @@
 //! walks the whole reactor; compiling one file only needs that file's module
 //! outputs plus its dependency classpath, which is much faster to assemble.
 use super::*;
+use serde::{Deserialize, Serialize};
 use std::fs;
 use std::process::Command as ProcCommand;

 /// Output file of the `dependency:build-classpath` probe, relative to each module.
 const CP_FILE: &str = "target/ide-compile-cp.txt";

+/// The resolved dependency classpath for one module and scope, tied to the same
+/// inputs as its launch build so POM, JDK, settings and profile changes invalidate it.
+#[derive(Debug, Deserialize, Serialize)]
+struct CachedClasspath {
+    fingerprint: LaunchFingerprint,
+    classpath: String,
+}
+
 /// A `.java` source and the module build that compiles it.
 pub struct SingleFileTarget {
    /// Absolute module directory.
@@ -64,6 +73,28 @@ pub fn single_file_target(root: &Path, model: &BuildModel, file: &Path) -> IdeRe
    Ok(SingleFileTarget { module, test, out_dir, top: top.clone(), pl, java_version: project.java_version })
 }

+/// The Maven reactor target for a launch module whose source file is not known yet.
+fn module_target(root: &Path, model: &BuildModel, module: &Path, test: bool) -> IdeResult<SingleFileTarget> {
+    let Some(m) = &model.maven else {
+        return Err(IdeError::not_found("no linked Maven project found for module"));
+    };
+    let module = if module.is_absolute() { module.to_path_buf() } else { root.join(module) };
+    let project = m
+        .projects
+        .iter()
+        .find(|p| root.join(&p.dir) == module)
+        .ok_or_else(|| IdeError::not_found("no linked Maven project found for module"))?;
+    if project.packaging == "pom" {
+        return Err(IdeError::not_found("the launch module is a Maven aggregator without sources"));
+    }
+    let top = maven_reactor(m, &project.dir)
+        .ok_or_else(|| IdeError::not_found("no linked Maven reactor found for module"))?;
+    let top_dir = subdir(root, &top.dir);
+    let pl = module.strip_prefix(&top_dir).map(|r| r.to_string_lossy().replace('\\', "/")).unwrap_or_default();
+    let out_dir = module.join("target").join(if test { "test-classes" } else { "classes" });
+    Ok(SingleFileTarget { module, test, out_dir, top: top.clone(), pl, java_version: project.java_version })
+}
+
 /// `javac` for the module: its `JAVA_HOME`, else `PATH`.
 pub fn find_javac(env: &BTreeMap<String, String>) -> String {
    let home = env.get("JAVA_HOME").map(Path::new);
@@ -78,6 +109,88 @@ pub fn find_javac(env: &BTreeMap<String, String>) -> String {
 /// `mvn dependency:build-classpath` (which resolves without compiling anything,
 /// so `-am` stays cheap). Entries are platform-separated (`;` on Windows).
 pub fn single_file_classpath(root: &Path, model: &BuildModel, target: &SingleFileTarget) -> IdeResult<String> {
+    classpath(root, model, target, "test", false)
+}
+
+/// Runtime (or test) dependency classpath for a launch module.
+///
+/// The Java language server runs on its own JDK, so its Maven model can select a
+/// different JDK profile and dependency classifier than the project launch. Use the
+/// same Maven process that builds the module instead.
+pub fn module_classpath(
+    root: &Path,
+    model: &BuildModel,
+    module: &Path,
+    test: bool,
+    local_repo: Option<PathBuf>,
+    cache: &Path,
+    cancel: &ide_core::CancellationToken,
+) -> IdeResult<String> {
+    let target = module_target(root, model, module, test)?;
+    let fingerprint = launch_fingerprint(root, model, &target.module, test, local_repo, cancel)?;
+    let cache_path = classpath_cache_path(root, cache, &target.module, test);
+    if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
+        && let Ok(bytes) = fs::read(path)
+        && let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
+        && cached.fingerprint == *fingerprint
+        && classpath_entries_exist(root, &cached.classpath)
+    {
+        return Ok(cached.classpath);
+    }
+    let classpath = classpath(root, model, &target, if test { "test" } else { "runtime" }, true)?;
+    if cancel.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
+    if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
+        let cached = CachedClasspath { fingerprint, classpath: classpath.clone() };
+        if let Err(error) = cache_classpath(&path, &cached) {
+            tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
+        }
+    }
+    Ok(classpath)
+}
+
+/// One cache file per module and scope. Mirroring the module path keeps nested
+/// modules and their different dependency scopes from overwriting each other.
+fn classpath_cache_path(root: &Path, cache: &Path, module: &Path, test: bool) -> Option<PathBuf> {
+    let relative = module.strip_prefix(root).ok()?;
+    let mut path = cache.join("java-launch/classpaths");
+    path.push(if relative.as_os_str().is_empty() { Path::new("_root") } else { relative });
+    path.push(if test { "test.json" } else { "runtime.json" });
+    Some(path)
+}
+
+/// Best-effort cache persistence. A failed write only costs one later Maven
+/// probe, so the launch still succeeds even when the cache directory is unusable.
+fn cache_classpath(path: &Path, cached: &CachedClasspath) -> IdeResult<()> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    fs::write(path, serde_json::to_vec(cached).map_err(|e| IdeError::internal(e.to_string()))?)?;
+    Ok(())
+}
+
+/// A cache entry stays valid while every file exists. Maven also emits reactor
+/// output directories for modules with no classes, which may legitimately never be
+/// created; the launch snapshot already supplies the module's classes in that case.
+fn classpath_entries_exist(root: &Path, classpath: &str) -> bool {
+    // Temp directories on macOS are commonly reached through `/var`, while Maven
+    // reports the canonical `/private/var` path. Compare against both spellings.
+    let canonical_root = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
+    std::env::split_paths(classpath).all(|entry| {
+        entry.exists()
+            || ((entry.starts_with(root) || entry.starts_with(&canonical_root))
+                && (entry.ends_with(Path::new("target/classes")) || entry.ends_with(Path::new("target/test-classes"))))
+    })
+}
+
+fn classpath(
+    root: &Path,
+    model: &BuildModel,
+    target: &SingleFileTarget,
+    scope: &str,
+    compile_first: bool,
+) -> IdeResult<String> {
    let mut entries: Vec<String> = Vec::new();
    // The module's own classes first: the file almost always uses classes next to it.
    let own: &[&str] = if target.test { &["target/test-classes", "target/classes"] } else { &["target/classes"] };
@@ -110,7 +223,14 @@ pub fn single_file_classpath(root: &Path, model: &BuildModel, target: &SingleFil
        args.extend(["-pl", target.pl.as_str(), "-am"]);
    }
    let output_arg = format!("-Dmdep.outputFile={probe}");
-    args.extend(["dependency:build-classpath", output_arg.as_str(), "-Dmdep.includeScope=test", "-q"]);
+    let scope_arg = format!("-Dmdep.includeScope={scope}");
+    // A launch build may only have reached `compile`. Running `compile` in this
+    // same Maven session lets the dependency plugin resolve Reactor siblings from
+    // their target/classes without paying for package-phase plugins.
+    if compile_first {
+        args.push("compile");
+    }
+    args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
    let top_dir = subdir(root, &target.top.dir);
    let status = ProcCommand::new(&target.top.command)
        .args(&args)
@@ -119,8 +239,10 @@ pub fn single_file_classpath(root: &Path, model: &BuildModel, target: &SingleFil
        .output()
        .map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
    if !status.status.success() {
+        let stdout = String::from_utf8_lossy(&status.stdout);
        let stderr = String::from_utf8_lossy(&status.stderr);
-        let tail: Vec<&str> = stderr.lines().filter(|l| !l.trim().is_empty()).collect();
+        // Maven reports reactor/dependency failures on stdout, not only stderr.
+        let tail: Vec<&str> = stdout.lines().chain(stderr.lines()).filter(|l| !l.trim().is_empty()).collect();
        let tail = tail.iter().rev().take(5).rev().cloned().collect::<Vec<_>>().join("\n");
        return Err(IdeError::internal(format!("cannot resolve the compile classpath:\n{tail}")));
    }
@@ -305,7 +427,7 @@ mod tests {
        let script = root.join("mvnw");
        fs::write(
            &script,
-            "#!/bin/sh\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/a.jar:/repo/b.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
+            "#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/a.jar:/repo/b.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
        )
        .unwrap();
        fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
@@ -327,5 +449,90 @@ mod tests {
        assert!(cp.contains("/repo/a.jar"), "{cp}");
        assert!(cp.contains("/repo/b.jar"), "{cp}");
        assert!(cp.split(separator).count() >= 3, "{cp}");
+        let args = fs::read_to_string(root.join("args.txt")).unwrap();
+        assert!(!args.lines().any(|a| a == "compile" || a == "package"), "{args}");
+    }
+
+    /// A launch uses runtime dependencies, while tests additionally see test-scope ones.
+    #[cfg(unix)]
+    #[test]
+    fn launch_module_classpath_uses_the_matching_dependency_scope() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        fixture(root);
+        let script = root.join("mvnw");
+        fs::write(
+            &script,
+            "#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/test.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
+        )
+        .unwrap();
+        fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
+        let model = crate::load(root, &root.join("cache"), None);
+
+        let cache = root.join("cache");
+        let runtime =
+            module_classpath(root, &model, &root.join("app"), false, None, &cache, &CancellationToken::new()).unwrap();
+        assert!(runtime.contains("/repo/runtime.jar"), "{runtime}");
+        let args = fs::read_to_string(root.join("args.txt")).unwrap();
+        assert!(args.lines().any(|a| a == "compile"), "{args}");
+        assert!(!args.lines().any(|a| a == "package"), "{args}");
+        assert!(args.lines().any(|a| a == "-Dmdep.includeScope=runtime"), "{args}");
+
+        let test =
+            module_classpath(root, &model, &root.join("app"), true, None, &cache, &CancellationToken::new()).unwrap();
+        assert!(test.contains("/repo/test.jar"), "{test}");
+        let args = fs::read_to_string(root.join("args.txt")).unwrap();
+        assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
+    }
+
+    /// The launch classpath follows the Maven runner JDK and is reused until that
+    /// build input changes; the probe does not run packaging plugins.
+    #[cfg(unix)]
+    #[test]
+    fn launch_classpath_cache_follows_the_runner_jdk() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        fixture(root);
+        let script = root.join("mvnw");
+        // `dependency:build-classpath` reports reactor outputs as absolute paths. Keep
+        // the fake probe faithful so the cache's existence check sees the output.
+        fs::write(
+            &script,
+            "#!/bin/sh\nprintf x >> calls.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target/classes\" \"$JAVA_HOME/classpath\"\n: > \"$JAVA_HOME/classpath/jdk.jar\"\nprintf '%s/classpath/jdk.jar:%s/%s/target/classes:%s/empty/target/classes' \"$JAVA_HOME\" \"$(pwd)\" \"$pl\" \"$(pwd)\" > \"$pl/target/ide-compile-cp.txt\"\n",
+        )
+        .unwrap();
+        fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
+        let mut model = crate::load(root, &root.join("cache"), None);
+        for (name, version) in [("jdk21", "21"), ("jdk8", "8")] {
+            let home = root.join(name);
+            fs::create_dir_all(home.join("bin")).unwrap();
+            fs::write(home.join("release"), format!("JAVA_VERSION=\"{version}\"\n")).unwrap();
+            fs::write(home.join("bin/java"), "").unwrap();
+        }
+        let cache = root.join("classpath-cache");
+        let cancel = CancellationToken::new();
+        let jdk21 = root.join("jdk21");
+        for project in &mut model.maven.as_mut().unwrap().projects {
+            project.env.insert("JAVA_HOME".into(), jdk21.to_string_lossy().into_owned());
+        }
+        let first = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
+        assert!(first.contains("jdk21/classpath/jdk.jar"), "{first}");
+        assert!(!first.contains("jdk8/classpath/jdk.jar"), "{first}");
+        let second = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
+        assert_eq!(second, first);
+        assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "x");
+
+        let jdk8 = root.join("jdk8");
+        for project in &mut model.maven.as_mut().unwrap().projects {
+            project.env.insert("JAVA_HOME".into(), jdk8.to_string_lossy().into_owned());
+        }
+        let switched = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
+        assert!(switched.contains("jdk8/classpath/jdk.jar"), "{switched}");
+        assert!(!switched.contains("jdk21/classpath/jdk.jar"), "{switched}");
+        assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "xx");
    }
 }
@@ -712,18 +712,27 @@ pub(crate) fn launch_inputs(
        // Profile activation may depend on the presence of an otherwise unrelated file.
        let activation = parent == "file" && matches!(el.name.as_str(), "exists" | "missing");
        if input || activation {
-            // Other properties can be overridden by -D, profiles or settings.
-            // Without Maven's effective roots, conservatively disable reuse for them.
-            let value = el
-                .text
-                .trim()
-                .replace("${project.basedir}", &dir.to_string_lossy())
-                .replace("${basedir}", &dir.to_string_lossy());
-            if value.contains("${") {
-                return None;
-            }
-            if !value.is_empty() {
-                out.push(dir.join(value));
+            // A source root under Maven's build directory is generated by the build itself.
+            // Skip it without resolving the property: `<build><directory>` may be custom, and
+            // hashing its rewritten files would make every launch look changed.
+            if !(input && el.text.contains("${project.build.directory}")) {
+                // Other properties can be overridden by -D, profiles or settings. Without
+                // Maven's effective model, leave them unresolved to conservatively disable reuse.
+                let value = el
+                    .text
+                    .trim()
+                    .replace("${project.basedir}", &dir.to_string_lossy())
+                    .replace("${basedir}", &dir.to_string_lossy());
+                if value.contains("${") {
+                    return None;
+                }
+                if !value.is_empty() {
+                    let path = dir.join(value);
+                    // Conventional generated sources under target are also build outputs.
+                    if !(input && path.starts_with(dir.join("target"))) {
+                        out.push(path);
+                    }
+                }
            }
        }
        for child in &el.children {
@@ -2140,6 +2149,52 @@ mod tests {
        assert_eq!(known.goals, ["compile", "help", "testCompile"], "the common plugins keep their table");
    }

+    #[test]
+    fn launch_inputs_skip_generated_sources_under_the_project_build_directory() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        write(
+            root,
+            "pom.xml",
+            "<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>\
+             <packaging>pom</packaging><modules><module>app</module></modules></project>",
+        );
+        write(
+            root,
+            "app/pom.xml",
+            r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
+               <artifactId>app</artifactId><build><plugins><plugin>
+                 <groupId>org.codehaus.mojo</groupId><artifactId>build-helper-maven-plugin</artifactId>
+                 <executions><execution><configuration><sources>
+                   <source>${project.build.directory}/generated-sources/java</source>
+                 </sources></configuration></execution></executions>
+               </plugin></plugins></build></project>"#,
+        );
+        let model = load_with_repo(root, None);
+        let projects: Vec<&MavenProject> = model.projects.iter().collect();
+        let inputs = launch_inputs(root, &projects, None).expect("portable launch inputs");
+        assert!(!inputs.contains(&root.join("app/target/generated-sources/java")), "{inputs:?}");
+        assert!(inputs.contains(&root.join("app/src")), "conventional sources stay fingerprinted");
+    }
+
+    #[test]
+    fn launch_inputs_disable_reuse_for_file_activation_on_the_build_directory() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        write(
+            root,
+            "pom.xml",
+            r#"<project><groupId>demo</groupId><artifactId>app</artifactId><version>1</version>
+               <build><directory>${project.basedir}/custom-build</directory></build>
+               <profiles><profile><id>generated</id><activation><file>
+                 <exists>${project.build.directory}/enable-profile</exists>
+               </file></activation></profile></profiles></project>"#,
+        );
+        let model = load_with_repo(root, None);
+        let projects: Vec<&MavenProject> = model.projects.iter().collect();
+        assert!(launch_inputs(root, &projects, None).is_none());
+    }
+
    fn write(dir: &Path, rel: &str, text: &str) {
        let p = dir.join(rel);
        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
@@ -393,11 +393,13 @@ fn scan_versions(dir: &Path, typed: &str, budget: &mut u32) -> Vec<PomCompletion
    out
 }

-/// The repository directory of the `/`-separated `coordinates` (a group id, or
-/// a group and an artifact id), each segment validated against the layout's
-/// alphabet so POM text cannot walk outside `repo`.
+/// The repository directory of `coordinates` (a group id, or a group and an artifact
+/// id): the group's dots are directories, an artifact id is one directory whatever dots
+/// it has (`org/eclipse/platform/org.eclipse.core.runtime`). Each segment is validated
+/// against the layout's alphabet so POM text cannot walk outside `repo`.
 fn repo_dir(repo: &Path, coordinates: &[&str]) -> Option<PathBuf> {
-    let segments: Vec<&str> = coordinates.iter().flat_map(|c| c.split('.')).collect();
+    let (group, artifact) = coordinates.split_first()?;
+    let segments: Vec<&str> = group.split('.').chain(artifact.iter().copied()).collect();
    segments.iter().all(|s| segment(s)).then(|| segments.iter().fold(repo.to_path_buf(), |p, s| p.join(s)))
 }

@@ -460,6 +462,7 @@ mod tests {
            "org/example/lib/2.0-beta-1/lib-2.0-beta-1.jar",
            "org/example/lib/2.0/lib-2.0.pom",
            "net/nu/netty/4.1.100/netty-4.1.100.jar",
+            "org/eclipse/platform/org.eclipse.core.runtime/3.31.0/org.eclipse.core.runtime-3.31.0.jar",
            // Failed downloads (a version typed while editing): tracking files only, not installed.
            "org/example/lib/2/lib-2.jar.lastUpdated",
            "org/example/lib/3.0/lib-3.0.pom.lastUpdated",
@@ -570,9 +573,10 @@ mod tests {
        };
        // Only directories holding artifacts are group ids: `net` and `org`
        // alone never receive an install, their deeper levels do.
-        assert_eq!(options(""), ["net.nu", "org.apache.maven", "org.apache.maven.plugins", "org.example"]);
-        assert_eq!(options("org"), ["org.apache.maven", "org.apache.maven.plugins", "org.example"]);
-        assert_eq!(options("org."), ["org.apache.maven", "org.apache.maven.plugins", "org.example"]);
+        let org = ["org.apache.maven", "org.apache.maven.plugins", "org.eclipse.platform", "org.example"];
+        assert_eq!(options(""), [&["net.nu"][..], &org].concat());
+        assert_eq!(options("org"), org);
+        assert_eq!(options("org."), org);
        assert_eq!(options("org.spr"), Vec::<String>::new());
        assert_eq!(options("net."), ["net.nu"]);
    }
@@ -623,6 +627,19 @@ mod tests {
        };
        assert_eq!(options(""), ["2.0", "2.0-beta-1", "1.10", "1.9.1", "1.0"]);
        assert_eq!(options("1."), ["1.10", "1.9.1", "1.0"]);
+        // An artifact id with dots is one directory.
+        let dotted = local_options(
+            &repo,
+            &PomCompletionTarget {
+                from: 0,
+                to: 0,
+                typed: "".into(),
+                kind: PomCompletionKind::Version,
+                group: Some("org.eclipse.platform".into()),
+                artifact: Some("org.eclipse.core.runtime".into()),
+            },
+        );
+        assert_eq!(dotted.into_iter().map(|o| o.label).collect::<Vec<_>>(), ["3.31.0"]);
    }

    #[test]
@@ -270,6 +270,13 @@ fn run(

 /// The first error lines of a failed build, for the tool window.
 pub(crate) fn error_summary(text: &str) -> String {
+    // The JVM's "could not find or load main class" (localized) when `gradlew` has no jar.
+    if text.contains("org.gradle.wrapper.GradleWrapperMain") {
+        return "gradle/wrapper/gradle-wrapper.jar is missing (often excluded by a `*.jar` rule in .gitignore). \
+                Restore it, run `gradle wrapper` with an installed Gradle, or choose Distribution: Local installation \
+                in Settings › Build, Execution, Deployment › Gradle."
+            .to_owned();
+    }
    let lines: Vec<&str> = text
        .lines()
        .filter(|l| {
@@ -909,6 +916,8 @@ mod tests {
        let text = "[INFO] x\n[ERROR] Failed to execute goal\n[ERROR] \n[ERROR] Re-run Maven using -X\n";
        assert_eq!(error_summary(text), "Failed to execute goal");
        assert_eq!(error_summary("one\nlast line\n\n"), "last line");
+        let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
+        assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
    }

    #[test]
@@ -270,6 +270,8 @@ pub struct SmartKeysSettings {
    pub pair_quotes: bool,
    pub surround_selection: bool,
    pub tab_out_of_pair: bool,
+    /// Simultaneous `<tag></tag>` editing: renaming a tag renames its matching tag.
+    pub simultaneous_tag_editing: bool,
    /// Reformat on paste: `none` | `indentBlock` | `indentEachLine`.
    pub reformat_on_paste: String,
    pub escape_on_paste: bool,
@@ -289,6 +291,7 @@ impl Default for SmartKeysSettings {
            pair_quotes: true,
            surround_selection: true,
            tab_out_of_pair: true,
+            simultaneous_tag_editing: true,
            reformat_on_paste: "indentEachLine".into(),
            escape_on_paste: true,
            smart_indent: true,
@@ -77,6 +77,9 @@ pub enum IdeEvent {
    WorkspaceEditApplied {
        id: u32,
        paths: Vec<crate::IpcPath>,
+        /// Made by an agent through the MCP server's tools: undoable like a refactoring, but
+        /// not announced as one.
+        by_agent: bool,
    },
    /// An open document's language changed (Settings › File Types, Override File
    /// Type), or its UI mode (a framework's root marker appeared or went).
@@ -77,6 +77,8 @@ pub enum AutoUpload {
 #[serde(default, rename_all = "camelCase")]
 pub struct DeploymentSettings {
    pub servers: Vec<DeploymentServer>,
+    /// Server groups: Upload to… on a group uploads to each of its servers.
+    pub groups: Vec<DeploymentGroup>,
    /// Server used by Upload / Download / Sync and automatic upload; empty = none.
    pub default_server: String,
    pub auto_upload: AutoUpload,
@@ -92,6 +94,7 @@ impl Default for DeploymentSettings {
    fn default() -> Self {
        Self {
            servers: Vec::new(),
+            groups: Vec::new(),
            default_server: String::new(),
            auto_upload: AutoUpload::Never,
            delete_remote: false,
@@ -103,6 +106,16 @@ impl Default for DeploymentSettings {
    }
 }

+/// Named set of deployment servers that files are uploaded to together.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(default, rename_all = "camelCase")]
+pub struct DeploymentGroup {
+    pub id: String,
+    pub name: String,
+    /// [`DeploymentServer::id`]s, in upload order.
+    pub servers: Vec<String>,
+}
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub enum DeploymentType {
@@ -300,11 +300,30 @@ pub struct McpServerSettings {
    pub agent_tab_limit: u32,
    /// Archived agent tabs kept; older ones are closed.
    pub agent_archive_limit: u32,
+    /// Listen on [`Self::port`] in every run, rather than a free port each time, so HTTP clients and
+    /// port forwards keep working after a restart.
+    pub fixed_port: bool,
+    /// The port of [`Self::fixed_port`].
+    pub port: u16,
+    /// Keep the bearer token across runs (in the app data, readable by this user only) rather than
+    /// make a new one each run.
+    pub fixed_token: bool,
 }

+/// The default of [`McpServerSettings::port`].
+pub const DEFAULT_MCP_PORT: u16 = 26371;
+
 impl Default for McpServerSettings {
    fn default() -> Self {
-        Self { enabled: false, run_without_confirmation: false, agent_tab_limit: 1, agent_archive_limit: 999 }
+        Self {
+            enabled: false,
+            run_without_confirmation: false,
+            agent_tab_limit: 1,
+            agent_archive_limit: 999,
+            fixed_port: true,
+            port: DEFAULT_MCP_PORT,
+            fixed_token: false,
+        }
    }
 }

@@ -28,6 +28,9 @@ tracing.workspace = true
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"

+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.61", features = ["Wdk_System_Threading", "Win32_Foundation", "Win32_System_Diagnostics_ToolHelp", "Win32_System_Threading"] }
+
 [dev-dependencies]
 tracing-subscriber.workspace = true
 tokio = { workspace = true, features = ["net", "rt-multi-thread", "macros", "test-util"] }
@@ -1,6 +1,7 @@
 //! Attach to Process: the current user's processes, grouped by the debugger that can
 //! attach to them (IDEA's `XAttachDebuggerProvider`s): JVMs with a JDWP agent, Node,
-//! Python (debugpy injection), Go binaries (Delve) and anything else natively (LLDB).
+//! Python (debugpy injection), .NET (netcoredbg), Go binaries (Delve) and anything else
+//! natively (LLDB).

 use crate::adapter;
 use ide_core::{IdeError, IdeResult};
@@ -14,6 +15,7 @@ pub enum AttachKind {
    Java,
    Node,
    Python,
+    Dotnet,
    Go,
    Native,
 }
@@ -95,13 +97,29 @@ fn file_name(path: &str) -> &str {
    path.rsplit(['/', '\\']).next().unwrap_or(path)
 }

+/// A .NET app: the `dotnet` host, or an apphost next to its `<name>.runtimeconfig.json`.
+pub fn is_dotnet(exe: &str) -> bool {
+    let path = Path::new(exe);
+    let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else { return false };
+    if stem == "dotnet" {
+        return true;
+    }
+    path.is_absolute() && path.with_file_name(format!("{stem}.runtimeconfig.json")).is_file()
+}
+
 fn is_python(name: &str) -> bool {
    let n = name.strip_suffix(".exe").unwrap_or(name);
    n == "Python" || n.strip_prefix("python").is_some_and(|v| v.chars().all(|c| c.is_ascii_digit() || c == '.'))
 }

-/// Classifies a process; `is_go` is asked only for processes no interpreter claims.
-pub fn classify(p: &RawProcess, is_go: impl Fn(&str) -> bool, native_adapter: &str) -> Option<AttachableProcess> {
+/// Classifies a process; `is_dotnet` and `is_go` are asked only for processes no
+/// interpreter claims.
+pub fn classify(
+    p: &RawProcess,
+    is_dotnet: impl Fn(&str) -> bool,
+    is_go: impl Fn(&str) -> bool,
+    native_adapter: &str,
+) -> Option<AttachableProcess> {
    let name = file_name(&p.exe).to_owned();
    let make = |kind, adapter: &str, addr: Option<(Option<String>, u16)>| {
        let (host, port) = match addr {
@@ -129,6 +147,9 @@ pub fn classify(p: &RawProcess, is_go: impl Fn(&str) -> bool, native_adapter: &s
    if is_python(&name) {
        return make(AttachKind::Python, "debugpy", debugpy_listen(&p.args));
    }
+    if is_dotnet(&p.exe) {
+        return make(AttachKind::Dotnet, "netcoredbg", None);
+    }
    if is_go(&p.exe) {
        return make(AttachKind::Go, "delve", None);
    }
@@ -143,7 +164,7 @@ const GO_SCAN_LIMIT: u64 = 96 << 20;
 pub fn is_go_binary(exe: &str) -> bool {
    use std::io::Read;
    let skip = ["/System/", "/usr/", "/bin/", "/sbin/", "/Library/Apple/", "/Applications/"];
-    if skip.iter().any(|p| exe.starts_with(p)) || !Path::new(exe).is_absolute() {
+    if skip.iter().any(|p| exe.starts_with(p)) || is_windows_system(exe) || !Path::new(exe).is_absolute() {
        return false;
    }
    let Ok(file) = std::fs::File::open(exe) else { return false };
@@ -165,6 +186,17 @@ pub fn is_go_binary(exe: &str) -> bool {
    }
 }

+/// Windows' own and installed programs (`C:\Windows\…`, `C:\Program Files…`), like the
+/// system locations skipped on Unix.
+fn is_windows_system(exe: &str) -> bool {
+    let lower = exe.to_ascii_lowercase();
+    lower.get(1..).is_some_and(|rest| {
+        rest.starts_with(":\\windows\\")
+            || rest.starts_with(":\\program files\\")
+            || rest.starts_with(":\\program files (x86)\\")
+    })
+}
+
 /// The current user's processes (without this one).
 #[cfg(unix)]
 pub fn list_processes() -> IdeResult<Vec<RawProcess>> {
@@ -181,7 +213,7 @@ pub fn list_processes() -> IdeResult<Vec<RawProcess>> {
        let (pid, rest) = line.split_once(char::is_whitespace)?;
        Some((pid.parse().ok()?, rest.trim().to_owned()))
    };
-    // `comm` is the executable path on macOS; on Linux it is truncated, so read /proc.
+    // `comm` is the executable path as started on macOS; on Linux it is truncated, so read /proc.
    let exes: HashMap<u32, String> =
        if cfg!(target_os = "linux") { HashMap::new() } else { ps("pid=,comm=")?.lines().filter_map(split).collect() };
    let me = std::process::id();
@@ -190,9 +222,8 @@ pub fn list_processes() -> IdeResult<Vec<RawProcess>> {
        .filter_map(split)
        .filter(|(pid, _)| *pid != me)
        .map(|(pid, args)| {
-            let exe = exes
-                .get(&pid)
-                .cloned()
+            let exe = exe_path(pid)
+                .or_else(|| exes.get(&pid).cloned())
                .or_else(|| std::fs::read_link(format!("/proc/{pid}/exe")).ok().map(|p| p.display().to_string()))
                .unwrap_or_else(|| args.split_whitespace().next().unwrap_or_default().to_owned());
            RawProcess { pid, exe, args }
@@ -200,9 +231,134 @@ pub fn list_processes() -> IdeResult<Vec<RawProcess>> {
        .collect())
 }

-#[cfg(not(unix))]
+/// The processes this user may open (without this one): system and other users'
+/// processes refuse `PROCESS_QUERY_LIMITED_INFORMATION` and are left out.
+#[cfg(windows)]
 pub fn list_processes() -> IdeResult<Vec<RawProcess>> {
-    Err(IdeError::unavailable("Attach to Process is not supported on this platform yet"))
+    windows_processes::list()
+}
+
+#[cfg(windows)]
+mod windows_processes {
+    use super::RawProcess;
+    use ide_core::{IdeError, IdeResult};
+    use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
+    use windows_sys::Wdk::System::Threading::{NtQueryInformationProcess, ProcessCommandLineInformation};
+    use windows_sys::Win32::Foundation::{INVALID_HANDLE_VALUE, UNICODE_STRING};
+    use windows_sys::Win32::System::Diagnostics::ToolHelp::{
+        CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
+    };
+    use windows_sys::Win32::System::Threading::{
+        OpenProcess, PROCESS_NAME_WIN32, PROCESS_QUERY_LIMITED_INFORMATION, QueryFullProcessImageNameW,
+    };
+
+    pub fn list() -> IdeResult<Vec<RawProcess>> {
+        let me = std::process::id();
+        Ok(pids()?
+            .into_iter()
+            .filter(|&pid| pid != 0 && pid != me)
+            .filter_map(|pid| {
+                // SAFETY: plain call; a non-null result is a process handle owned here.
+                let handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
+                if handle.is_null() {
+                    return None;
+                }
+                // SAFETY: as above.
+                let process = unsafe { OwnedHandle::from_raw_handle(handle) };
+                let exe = image_path(&process)?;
+                let args = command_line(&process).unwrap_or_else(|| exe.clone());
+                Some(RawProcess { pid, exe, args })
+            })
+            .collect())
+    }
+
+    fn pids() -> IdeResult<Vec<u32>> {
+        let mut out = Vec::new();
+        // SAFETY: a snapshot handle owned here and an entry sized as the API requires.
+        unsafe {
+            let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+            if snapshot.is_null() || snapshot == INVALID_HANDLE_VALUE {
+                return Err(IdeError::unavailable(format!(
+                    "cannot list processes: {}",
+                    std::io::Error::last_os_error()
+                )));
+            }
+            let snapshot = OwnedHandle::from_raw_handle(snapshot);
+            let mut entry = PROCESSENTRY32W { dwSize: size_of::<PROCESSENTRY32W>() as u32, ..Default::default() };
+            let mut more = Process32FirstW(snapshot.as_raw_handle(), &mut entry);
+            while more != 0 {
+                out.push(entry.th32ProcessID);
+                more = Process32NextW(snapshot.as_raw_handle(), &mut entry);
+            }
+        }
+        Ok(out)
+    }
+
+    fn image_path(process: &OwnedHandle) -> Option<String> {
+        let mut buf = vec![0u16; 32 * 1024];
+        let mut len = buf.len() as u32;
+        // SAFETY: a live process handle with query access; `len` is the buffer's capacity.
+        let ok = unsafe {
+            QueryFullProcessImageNameW(process.as_raw_handle(), PROCESS_NAME_WIN32, buf.as_mut_ptr(), &mut len)
+        };
+        (ok != 0).then(|| String::from_utf16_lossy(&buf[..len as usize]))
+    }
+
+    /// The command line (Windows 8.1+), read with the same limited query access.
+    fn command_line(process: &OwnedHandle) -> Option<String> {
+        let mut size = 0u32;
+        // SAFETY: a size query with no buffer; it fails and reports the size it needs.
+        unsafe {
+            NtQueryInformationProcess(
+                process.as_raw_handle(),
+                ProcessCommandLineInformation,
+                std::ptr::null_mut(),
+                0,
+                &mut size,
+            )
+        };
+        if (size as usize) < size_of::<UNICODE_STRING>() {
+            return None;
+        }
+        // u64 elements keep the UNICODE_STRING header aligned.
+        let mut buf = vec![0u64; (size as usize).div_ceil(8)];
+        // SAFETY: a buffer of at least `size` bytes.
+        let status = unsafe {
+            NtQueryInformationProcess(
+                process.as_raw_handle(),
+                ProcessCommandLineInformation,
+                buf.as_mut_ptr().cast(),
+                size,
+                &mut size,
+            )
+        };
+        if status < 0 {
+            return None;
+        }
+        // SAFETY: on success the buffer starts with a UNICODE_STRING whose text lies inside it.
+        let text = unsafe {
+            let s = &*buf.as_ptr().cast::<UNICODE_STRING>();
+            if s.Buffer.is_null() {
+                return None;
+            }
+            std::slice::from_raw_parts(s.Buffer, usize::from(s.Length) / 2)
+        };
+        Some(String::from_utf16_lossy(text))
+    }
+}
+
+/// The full executable path: `comm` keeps a relative path a process was started with.
+#[cfg(target_os = "macos")]
+fn exe_path(pid: u32) -> Option<String> {
+    let mut buf = vec![0u8; libc::PROC_PIDPATHINFO_MAXSIZE as usize];
+    // SAFETY: the buffer holds `PROC_PIDPATHINFO_MAXSIZE` bytes, as the call requires.
+    let n = unsafe { libc::proc_pidpath(i32::try_from(pid).ok()?, buf.as_mut_ptr().cast(), buf.len() as u32) };
+    (n > 0).then(|| String::from_utf8_lossy(&buf[..n as usize]).into_owned())
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+fn exe_path(_pid: u32) -> Option<String> {
+    None
 }

 /// Node's default inspector port, which `SIGUSR1` opens.
@@ -244,7 +400,7 @@ pub fn attachable_processes() -> IdeResult<Vec<AttachableProcess>> {
    let cwd = std::env::temp_dir();
    let native = if adapter::resolve_binary("codelldb", &cwd).is_some() { "codelldb" } else { "lldb-dap" };
    let mut out: Vec<AttachableProcess> =
-        list_processes()?.iter().filter_map(|p| classify(p, is_go_binary, native)).collect();
+        list_processes()?.iter().filter_map(|p| classify(p, is_dotnet, is_go_binary, native)).collect();
    out.sort_by(|a, b| a.kind.cmp(&b.kind).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())));
    Ok(out)
 }
@@ -258,7 +414,8 @@ mod tests {
    }

    fn kind(exe: &str, args: &str) -> Option<(AttachKind, Option<u16>)> {
-        classify(&raw(exe, args), |e| e.ends_with("/gosrv"), "codelldb").map(|p| (p.kind, p.port))
+        classify(&raw(exe, args), |e| e.ends_with("/Api"), |e| e.ends_with("/gosrv"), "codelldb")
+            .map(|p| (p.kind, p.port))
    }

    #[test]
@@ -292,11 +449,37 @@ mod tests {
            kind("/Library/Frameworks/Python.framework/Versions/3.12/Resources/Python.app/Contents/MacOS/Python", "x"),
            Some((AttachKind::Python, None))
        );
+        assert_eq!(kind("/home/me/Api", "./Api"), Some((AttachKind::Dotnet, None)));
        assert_eq!(kind("/home/me/gosrv", "./gosrv"), Some((AttachKind::Go, None)));
        assert_eq!(kind("/home/me/a.out", "./a.out"), Some((AttachKind::Native, None)));
        assert!(!is_python("pythonista"));
    }

+    #[test]
+    fn detects_dotnet_hosts_and_apphosts() {
+        let dir = std::env::temp_dir().join(format!("openidea-attach-dotnet-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let app = dir.join("Api");
+        std::fs::write(&app, b"").unwrap();
+        std::fs::write(dir.join("Api.runtimeconfig.json"), b"{}").unwrap();
+        let tool = dir.join("tool");
+        std::fs::write(&tool, b"").unwrap();
+        assert!(is_dotnet(app.to_str().unwrap()));
+        assert!(!is_dotnet(tool.to_str().unwrap()));
+        assert!(is_dotnet("/usr/local/share/dotnet/dotnet"));
+        assert!(is_dotnet("dotnet"));
+        assert!(!is_dotnet("Api"));
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
+    #[test]
+    fn skips_windows_system_programs() {
+        assert!(is_windows_system(r"C:\Windows\System32\svchost.exe"));
+        assert!(is_windows_system(r"c:\program files (x86)\App\app.exe"));
+        assert!(!is_windows_system(r"D:\src\srv\srv.exe"));
+        assert!(!is_windows_system("/usr/bin/true"));
+    }
+
    #[test]
    fn detects_go_binaries_by_buildinfo() {
        let dir = std::env::temp_dir().join(format!("openidea-attach-{}", std::process::id()));
@@ -557,6 +557,17 @@ async fn attach_to_processes() {
            extra: |pid, _| serde_json::json!({"pid": pid}),
        },
    ];
+    // A .NET app built into `dotnet/bin` (`<OutDir>bin</OutDir>`), attached by its apphost.
+    let dotnet_app = dir.join("dotnet/bin").join(if cfg!(windows) { "Server.exe" } else { "Server" });
+    if dotnet_app.is_file() {
+        cases.push(AttachCase {
+            kind: attach::AttachKind::Dotnet,
+            command: vec![s(&dotnet_app)],
+            source: dir.join("dotnet/Program.cs"),
+            line: 1,
+            extra: |pid, _| serde_json::json!({"processId": pid, "justMyCode": true}),
+        });
+    }
    if java_server.is_some() {
        cases.insert(
            0,
@@ -753,7 +753,7 @@ impl Pool {
            return crate::oracle::OraclePool::connect(source, password, &setup).await.map(Pool::Oracle);
        }
        if source.driver == DbDriver::Snowflake {
-            return crate::snowflake::SnowflakePool::connect(source, password, setup).await.map(Pool::Snowflake);
+            return crate::snowflake::SnowflakePool::connect(source, password, setup, root).await.map(Pool::Snowflake);
        }
        let timeout = setup.connect_timeout.unwrap_or(Duration::from_secs(30));
        let init = Arc::new(setup.statements);
@@ -1491,18 +1491,21 @@ impl DbManager {
        let Some(session) = session else { return Ok(()) };
        let mut held = session.lock().await;
        let Some(mut conn) = held.take() else { return Ok(()) };
-        let result = async {
-            conn.command(if commit { "COMMIT" } else { "ROLLBACK" }).await?;
-            conn.restore_default().await
-        }
-        .await;
-        match result {
-            Ok(()) => Ok(()),
-            Err(e) => {
+        if let Err(e) = conn.command(if commit { "COMMIT" } else { "ROLLBACK" }).await {
+            // Discarding a Snowflake connection doesn't end its session, which the data source's
+            // other targets share: the transaction stays open, so it stays held to be ended again.
+            if matches!(conn, conn::Held::Snowflake(..)) {
+                *held = Some(conn);
+            } else {
                conn.discard().await;
-                Err(e)
            }
+            return Err(e);
        }
+        if let Err(e) = conn.restore_default().await {
+            conn.discard().await;
+            return Err(e);
+        }
+        Ok(())
    }

    #[allow(clippy::too_many_arguments)]
@@ -78,7 +78,8 @@ pub(crate) fn sso_seed(key: &str, token: &str) {
    }
 }

-/// Live sessions by their connection settings, so targets opened with the same settings share one.
+/// Live sessions by data source and connection settings, so the targets of one data source (its
+/// databases, the tree, consoles) opened with the same settings share one.
 static SESSIONS: LazyLock<parking_lot::Mutex<HashMap<String, Weak<State>>>> =
    LazyLock::new(|| parking_lot::Mutex::new(HashMap::new()));

@@ -106,6 +107,15 @@ struct Lane {
    context: parking_lot::Mutex<Option<String>>,
 }

+/// What [`SnowflakePool::statement`] does when the session is gone and it signs in again.
+#[derive(Clone, Copy)]
+enum Lost<'a> {
+    /// Runs the statement again on the new session, after this `USE` when there is one.
+    Enter(Option<&'a str>),
+    /// Fails: the statement was part of a transaction that ended with the session.
+    Fail,
+}
+
 const CONSOLE: usize = 0;
 const METADATA: usize = 1;

@@ -251,7 +261,12 @@ fn gunzip(bytes: Vec<u8>) -> IdeResult<Vec<u8>> {
 }

 impl SnowflakePool {
-    pub(crate) async fn connect(source: &DataSource, secret: Option<&str>, setup: Setup) -> IdeResult<Self> {
+    pub(crate) async fn connect(
+        source: &DataSource,
+        secret: Option<&str>,
+        setup: Setup,
+        root: Option<&std::path::Path>,
+    ) -> IdeResult<Self> {
        let settings = source.snowflake();
        let endpoint = account::endpoint(source)?;
        let user = source.user.trim();
@@ -302,9 +317,15 @@ impl SnowflakePool {
            lane: CONSOLE,
        };
        // Everything that makes a session what it is, the secret included (hashed: the key is only compared).
+        // The data source and its project too: its databases share a session, but another data source
+        // with the same settings, or the same one in another project (a plugin's source has the same id
+        // in every project), gets its own: its statements and transactions are not this one's. A browser
+        // sign-in is still shared through the cached ID token.
        let key = blake3::hash(
            format!(
-                "{}\0{user}\0{:?}\0{}\0{}\0{}\0{}\0{:?}\0{:?}",
+                "{:?}\0{}\0{}\0{user}\0{:?}\0{}\0{}\0{}\0{}\0{:?}\0{:?}",
+                root,
+                source.id,
                api.address(),
                settings.auth,
                secret.unwrap_or_default(),
@@ -636,13 +657,18 @@ impl SnowflakePool {
            () = self.closed.cancelled() => return Err(closed()),
            turn = self.lane().turn.lock() => turn,
        };
-        // A `USE` needs no schema to run in, and may be what makes the schema reachable.
-        if first_word(sql) != "USE" {
-            self.enter(schema, cancel).await?;
-        }
+        // A `USE` needs no schema to run in, and may be what makes the schema reachable. Ending a
+        // transaction needs none either, and must not fail because the schema is gone meanwhile.
+        let context = match first_word(sql).as_str() {
+            "USE" | "COMMIT" | "ROLLBACK" => None,
+            _ => {
+                self.enter(schema, cancel).await?;
+                self.context(schema)
+            }
+        };
        // These can move the session to another database or schema.
        let moves = matches!(first_word(sql).as_str(), "USE" | "CALL" | "EXECUTE");
-        let result = self.statement(sql, skip, max_rows, cancel).await;
+        let result = self.statement(sql, skip, max_rows, Lost::Enter(context.as_deref()), cancel).await;
        if moves {
            *self.lane().context.lock() = None;
        }
@@ -655,16 +681,14 @@ impl SnowflakePool {
            && self.lane().context.lock().as_deref() != Some(wanted.as_str())
        {
            *self.lane().context.lock() = None;
-            match self.statement(&wanted, 0, 0, cancel).await {
-                Ok(_) => {}
-                // The session's role may not use this database or schema (after `USE ROLE`, or a
-                // schema that is gone). The statement still runs, in the session's own context:
-                // it may be the `USE` that leads back, or name its objects in full. Asked again
-                // once a statement moves the session.
-                Err(refused) if refused.kind == ErrorKind::InvalidInput => {
-                    tracing::warn!("Snowflake: the session did not enter its database and schema");
-                }
-                Err(error) => return Err(error),
+            // Refused (the session's role may not use this database or schema): the statement
+            // does not run, since the session is still wherever it was, which may be another
+            // target's database. Tried again with the next statement.
+            if let Err(error) = self.statement(&wanted, 0, 0, Lost::Enter(None), cancel).await {
+                return Err(IdeError {
+                    message: format!("{wanted} failed, so the statement was not run: {}", error.message),
+                    ..error
+                });
            }
            *self.lane().context.lock() = Some(wanted);
        }
@@ -680,11 +704,11 @@ impl SnowflakePool {
        let _turn = self.lane().turn.lock().await;
        let cancel = CancellationToken::new();
        self.enter(None, &cancel).await?;
-        self.statement("BEGIN", 0, 0, &cancel).await?;
+        self.statement("BEGIN", 0, 0, Lost::Enter(self.context(None).as_deref()), &cancel).await?;
        let changes = async {
            let mut total = 0;
            for (sql, expect_one) in statements {
-                let changed = self.statement(sql, 0, 0, &cancel).await?.affected.unwrap_or(0.0) as u64;
+                let changed = self.statement(sql, 0, 0, Lost::Fail, &cancel).await?.affected.unwrap_or(0.0) as u64;
                if *expect_one && changed != 1 {
                    return Err(IdeError::invalid(format!(
                        "{sql}: expected to change 1 row, changed {changed}; nothing was saved"
@@ -697,22 +721,24 @@ impl SnowflakePool {
        .await;
        match changes {
            Ok(total) => {
-                self.statement("COMMIT", 0, 0, &cancel).await?;
+                self.statement("COMMIT", 0, 0, Lost::Fail, &cancel).await?;
                Ok(total)
            }
            Err(error) => {
-                let _ = self.statement("ROLLBACK", 0, 0, &cancel).await;
+                let _ = self.statement("ROLLBACK", 0, 0, Lost::Fail, &cancel).await;
                Err(error)
            }
        }
    }

-    /// One statement on the session; the caller holds the session's turn.
+    /// One statement on the session; the caller holds the session's turn. `lost`: what to do when
+    /// the session is gone and a new one is signed in to.
    async fn statement(
        &self,
        sql: &str,
        skip: usize,
        max_rows: usize,
+        lost: Lost<'_>,
        cancel: &CancellationToken,
    ) -> IdeResult<QueryResult> {
        let started = Instant::now();
@@ -743,7 +769,24 @@ impl SnowflakePool {
                Ok(Outcome::Done(result)) => return Ok(*result),
                Ok(Outcome::Expired { gone }) if !renewed => {
                    renewed = true;
-                    tokens = if gone { self.login().await? } else { self.renew(&tokens).await? };
+                    if !gone {
+                        tokens = self.renew(&tokens).await?;
+                        continue;
+                    }
+                    if let Lost::Fail = lost {
+                        // The transaction ended with the session: nothing of it was saved.
+                        let _ = self.login().await;
+                        return Err(IdeError::new(
+                            ErrorKind::Io,
+                            "Snowflake: the session was lost during the transaction; nothing was saved",
+                        ));
+                    }
+                    // The new session is under the login's database and schema, which may be another
+                    // target's: back to this one's before the statement runs again.
+                    tokens = self.login().await?;
+                    if let Lost::Enter(Some(wanted)) = lost {
+                        self.reenter(wanted, &tokens, cancel).await?;
+                    }
                }
                Ok(Outcome::Expired { .. }) => {
                    return Err(IdeError::new(ErrorKind::Io, "Snowflake: the session expired; reconnect"));
@@ -753,6 +796,33 @@ impl SnowflakePool {
        }
    }

+    /// [`enter`](Self::enter) on a session just signed in to (its `tokens`), within [`statement`](Self::statement).
+    async fn reenter(&self, wanted: &str, tokens: &Tokens, cancel: &CancellationToken) -> IdeResult<()> {
+        let request_id = uuid();
+        let outcome = tokio::select! {
+            biased;
+            () = cancel.cancelled() => return Err(IdeError::cancelled()),
+            () = self.closed.cancelled() => return Err(closed()),
+            outcome = self.run(wanted, 0, 0, tokens, &request_id, Instant::now()) => outcome,
+        };
+        match outcome {
+            Ok(Outcome::Done(_)) => {
+                *self.lane().context.lock() = Some(wanted.to_owned());
+                Ok(())
+            }
+            Ok(Outcome::Expired { .. }) => {
+                Err(IdeError::new(ErrorKind::Io, "Snowflake: the session expired; reconnect"))
+            }
+            Err(error) => {
+                let error = self.shared.api.scrub.clean(error);
+                Err(IdeError {
+                    message: format!("{wanted} failed, so the statement was not run: {}", error.message),
+                    ..error
+                })
+            }
+        }
+    }
+
    async fn run(
        &self,
        sql: &str,
@@ -407,13 +407,64 @@ async fn a_lost_session_signs_in_again() {
    let (listener, port) = bind().await;
    let gone = r#"{"success":false,"code":"390114","message":"Authentication token has expired. The user must authenticate again."}"#;
    let again = r#"{"success":true,"data":{"token":"session-token-3","masterToken":"master-token-3"}}"#;
-    let server = serve(listener, vec![ok(LOGIN_OK), ok(gone), ok(again), ok(one()), ok(CLOSED_OK)]);
+    let status = json!({ "success": true, "data": { "rowtype": [{ "name": "status", "type": "text" }],
+        "rowset": [["Statement executed successfully."]], "queryResultFormat": "json", "statementTypeId": 0x5000 } })
+    .to_string();
+    let server = serve(listener, vec![ok(LOGIN_OK), ok(gone), ok(again), ok(status), ok(one()), ok(CLOSED_OK)]);
    let pool = Pool::connect(&source(port), None, None).await.unwrap();
    pool.execute("select 1", 5, &CancellationToken::new()).await.unwrap();
    pool.close().await;
    let seen = server.await.unwrap();
    assert!(seen[2].line().starts_with("POST /session/v1/login-request?"), "{}", seen[2].line());
-    assert_eq!(seen[3].header("authorization"), Some("Snowflake Token=\"session-token-3\""));
+    // The new session enters the target's schema before the statement runs again.
+    assert_eq!(seen[3].json()["sqlText"], "USE SCHEMA \"ANALYTICS\".\"PUBLIC\"");
+    assert_eq!(seen[4].json()["sqlText"], "select 1");
+    assert_eq!(seen[4].header("authorization"), Some("Snowflake Token=\"session-token-3\""));
+}
+
+#[tokio::test]
+async fn a_lost_session_runs_the_statement_in_its_own_database_again() {
+    let (listener, port) = bind().await;
+    let gone = r#"{"success":false,"code":"390114","message":"Authentication token has expired. The user must authenticate again."}"#;
+    let again = r#"{"success":true,"data":{"token":"session-token-3","masterToken":"master-token-3"}}"#;
+    let status = || {
+        json!({ "success": true, "data": { "rowtype": [{ "name": "status", "type": "text" }],
+            "rowset": [["Statement executed successfully."]], "queryResultFormat": "json", "statementTypeId": 0x5000 } })
+        .to_string()
+    };
+    // Raw Data entered, the statement finds the session gone, a new login (under ANALYTICS),
+    // Raw Data entered again, the statement.
+    let replies = vec![ok(LOGIN_OK), ok(status()), ok(gone), ok(again), ok(status()), ok(one()), ok(CLOSED_OK)];
+    let server = serve(listener, replies);
+    let first = Pool::connect(&source(port), None, None).await.unwrap();
+    let mut other = source(port);
+    other.database = "Raw Data".into();
+    other.options.default_schema = String::new();
+    let second = Pool::connect(&other, None, None).await.unwrap();
+    second.execute("delete from t", 1, &CancellationToken::new()).await.unwrap();
+    first.close().await;
+    second.close().await;
+    let sent: Vec<String> =
+        server.await.unwrap()[1..6].iter().map(|r| r.json()["sqlText"].as_str().unwrap_or("").to_owned()).collect();
+    let raw = "USE DATABASE \"Raw Data\"";
+    assert_eq!(sent, [raw, "delete from t", "", raw, "delete from t"]);
+}
+
+#[tokio::test]
+async fn a_transaction_ends_even_when_its_schema_is_gone() {
+    let (listener, port) = bind().await;
+    let status = json!({ "success": true, "data": { "rowtype": [{ "name": "status", "type": "text" }],
+        "rowset": [["Statement executed successfully."]], "queryResultFormat": "json", "statementTypeId": 0x5000 } })
+    .to_string();
+    let server = serve(listener, vec![ok(LOGIN_OK), ok(status), ok(CLOSED_OK)]);
+    let pool = Pool::connect(&source(port), None, None).await.unwrap();
+    // The console's schema was dropped since it was picked: ending the transaction doesn't switch to it.
+    let mut console = crate::conn::Held::acquire(&pool).await.unwrap();
+    console.apply_context(Some("Dropped")).await.unwrap();
+    console.execute(&pool, "ROLLBACK", 0, &CancellationToken::new()).await.unwrap();
+    pool.close().await;
+    let seen = server.await.unwrap();
+    assert_eq!(seen[1].json()["sqlText"], "ROLLBACK");
 }

 #[tokio::test]
@@ -714,7 +765,7 @@ async fn a_console_schema_is_switched_with_its_statement_and_only_when_needed()
 }

 #[tokio::test]
-async fn a_role_that_may_not_use_the_schema_still_runs_statements() {
+async fn a_role_that_may_not_use_the_schema_runs_nothing_elsewhere() {
    let status = || {
        json!({ "success": true, "data": { "rowtype": [{ "name": "status", "type": "text" }],
            "rowset": [["Statement executed successfully."]], "queryResultFormat": "json", "statementTypeId": 0x5000 } })
@@ -722,14 +773,12 @@ async fn a_role_that_may_not_use_the_schema_still_runs_statements() {
    };
    let refused = r#"{"success":false,"code":"002043","message":"SQL compilation error:\nObject does not exist, or operation cannot be performed."}"#;
    let (listener, port) = bind().await;
-    // use role | the schema is refused once, the statement runs | the next one does not ask again |
-    // a role that is not granted | use role back, the schema is entered again
+    // use role | the schema is refused, the statement is not sent | asked again, refused again |
+    // use role back, the schema is entered, the statement runs
    let replies = vec![
        ok(LOGIN_OK),
        ok(status()),
        ok(refused),
-        ok(one()),
-        ok(one()),
        ok(refused),
        ok(status()),
        ok(status()),
@@ -740,20 +789,22 @@ async fn a_role_that_may_not_use_the_schema_still_runs_statements() {
    let pool = Pool::connect(&source(port), None, None).await.unwrap();
    let cancel = CancellationToken::new();
    pool.execute("use role auditor", 0, &cancel).await.unwrap();
-    pool.execute("select 1", 1, &cancel).await.unwrap();
-    pool.execute("select 2", 1, &cancel).await.unwrap();
-    let missing = pool.execute("use role nobody", 0, &cancel).await.unwrap_err();
-    assert!(missing.message.contains("002043") && missing.message.contains("granted"), "{}", missing.message);
+    let error = pool.execute("delete from t", 1, &cancel).await.unwrap_err();
+    assert!(
+        error.message.contains("USE SCHEMA")
+            && error.message.contains("was not run")
+            && error.message.contains("002043"),
+        "{}",
+        error.message
+    );
+    assert!(pool.execute("select 2", 1, &cancel).await.is_err());
    pool.execute("use role analyst", 0, &cancel).await.unwrap();
    pool.execute("select 3", 1, &cancel).await.unwrap();
    pool.close().await;
    let sent: Vec<String> =
-        server.await.unwrap()[1..9].iter().map(|r| r.json()["sqlText"].as_str().unwrap().to_owned()).collect();
+        server.await.unwrap()[1..7].iter().map(|r| r.json()["sqlText"].as_str().unwrap().to_owned()).collect();
    let schema = "USE SCHEMA \"ANALYTICS\".\"PUBLIC\"";
-    assert_eq!(
-        sent,
-        ["use role auditor", schema, "select 1", "select 2", "use role nobody", "use role analyst", schema, "select 3"]
-    );
+    assert_eq!(sent, ["use role auditor", schema, schema, "use role analyst", schema, "select 3"]);
 }

 #[tokio::test]
@@ -785,6 +836,45 @@ async fn databases_of_one_data_source_share_a_login() {
    assert!(seen[4].line().starts_with("POST /session?delete=true"), "{}", seen[4].line());
 }

+#[tokio::test]
+async fn data_sources_with_the_same_settings_have_their_own_sessions() {
+    let (listener, port) = bind().await;
+    let second = r#"{"success":true,"data":{"token":"session-token-2","masterToken":"master-token-2"}}"#;
+    let server = serve(listener, vec![ok(LOGIN_OK), ok(second), ok(one()), ok(one()), ok(CLOSED_OK), ok(CLOSED_OK)]);
+    let first = Pool::connect(&source(port), None, None).await.unwrap();
+    let mut copy = source(port);
+    copy.id = format!("{}-copy", copy.id);
+    let other = Pool::connect(&copy, None, None).await.unwrap();
+    let cancel = CancellationToken::new();
+    first.execute("select 1", 1, &cancel).await.unwrap();
+    other.execute("select 2", 1, &cancel).await.unwrap();
+    first.close().await;
+    other.close().await;
+    let seen = server.await.unwrap();
+    assert!(seen[1].line().starts_with("POST /session/v1/login-request?"), "{}", seen[1].line());
+    assert_eq!(seen[2].header("authorization"), Some("Snowflake Token=\"session-token-1\""));
+    assert_eq!(seen[3].header("authorization"), Some("Snowflake Token=\"session-token-2\""));
+}
+
+#[tokio::test]
+async fn one_data_source_in_two_projects_has_a_session_in_each() {
+    let (listener, port) = bind().await;
+    let second = r#"{"success":true,"data":{"token":"session-token-2","masterToken":"master-token-2"}}"#;
+    let server = serve(listener, vec![ok(LOGIN_OK), ok(second), ok(one()), ok(one()), ok(CLOSED_OK), ok(CLOSED_OK)]);
+    // A plugin's data source has the same id in every project.
+    let first = Pool::connect(&source(port), None, Some(std::path::Path::new("/projects/a"))).await.unwrap();
+    let other = Pool::connect(&source(port), None, Some(std::path::Path::new("/projects/b"))).await.unwrap();
+    let cancel = CancellationToken::new();
+    first.execute("select 1", 1, &cancel).await.unwrap();
+    other.execute("select 2", 1, &cancel).await.unwrap();
+    first.close().await;
+    other.close().await;
+    let seen = server.await.unwrap();
+    assert!(seen[1].line().starts_with("POST /session/v1/login-request?"), "{}", seen[1].line());
+    assert_eq!(seen[2].header("authorization"), Some("Snowflake Token=\"session-token-1\""));
+    assert_eq!(seen[3].header("authorization"), Some("Snowflake Token=\"session-token-2\""));
+}
+
 #[tokio::test]
 async fn metadata_runs_on_its_own_session_beside_a_busy_console() {
    let (listener, port) = bind().await;
@@ -180,6 +180,7 @@ impl Host {
            open_locks: Default::default(),
        };
        host.apply_proxy();
+        ops::agent::move_user_mcp_values(&host);
        host
    }

@@ -87,7 +87,7 @@ async fn create_or_replace(call: &Call, path: PathBuf, text: Option<String>, ove
        return Ok(());
    }
    let edit = crate::ops::lsp::prepare_workspace_edit(&call.host, call.window(), edit).await?;
-    crate::ops::lsp::apply_workspace_edit(&call.host, call.window(), edit).await
+    crate::ops::lsp::apply_agent_workspace_edit(&call.host, call.window(), edit).await
 }

 /// The open document of `path`, or a transient one (`true`: close it after use).
@@ -317,7 +317,7 @@ async fn apply_op(call: &Call, op: FileOp, notes: &mut Vec<String>) -> IdeResult
                preconditions: Vec::new(),
            };
            let edit = crate::ops::lsp::prepare_workspace_edit(&host, call.window(), edit).await?;
-            crate::ops::lsp::apply_workspace_edit(&host, call.window(), edit).await
+            crate::ops::lsp::apply_agent_workspace_edit(&host, call.window(), edit).await
        }
        FileOp::Update { path: first, move_to, hunks, or } => {
            // A plain diff's other names count when its `+++` path does not exist.
@@ -400,7 +400,7 @@ async fn apply_op(call: &Call, op: FileOp, notes: &mut Vec<String>) -> IdeResult
                edit.files.push(FileEdit::Rename { from: path.into(), to: to.into() });
            }
            let edit = crate::ops::lsp::prepare_workspace_edit(&host, call.window(), edit).await?;
-            crate::ops::lsp::apply_workspace_edit(&host, call.window(), edit).await?;
+            crate::ops::lsp::apply_agent_workspace_edit(&host, call.window(), edit).await?;
            if dirty {
                notes.push(format!("{shown}: patched the unsaved editor buffer"));
            }
@@ -385,7 +385,7 @@ targetIndex, or narrow the call with a contextSnippet that shows the one you mea
        _ => None,
    });
    let (h, w) = (host.clone(), window.to_owned());
-    let written = crate::ops::lsp::apply_workspace_edit(&h, &w, edit).await;
+    let written = crate::ops::lsp::apply_agent_workspace_edit(&h, &w, edit).await;
    if let Err(e) = written {
        let hint = format!("The rename stopped while it wrote. {} Read the files again before you retry.", e.message);
        return Ok(RenameResult::failed("write_failed", hint).with_symbol(symbol));
@@ -2,6 +2,7 @@
 //! window they run on the host, next to the project they work on.
 use super::{Channel, Emit};
 use crate::Host;
+use crate::agent_secrets::{AgentSecrets, Kept};
 use crate::rpc::Dispatcher;
 use ide_agent::registry::{AgentRegistry, RegistryPaths};
 use ide_agent::{
@@ -342,8 +343,77 @@ pub async fn accept_changes(

 type McpServerMap = std::collections::BTreeMap<String, ide_core::settings::AgentMcpServer>;

+/// Where the values of the user's MCP servers are kept in [`AgentSecrets`]. A project's own
+/// servers keep their values in the project's file, where the project shares them.
+const USER_MCP_VALUES: &str = "mcp/user/";
+
+/// Every environment variable and header value of `map`, by its key in [`AgentSecrets`].
+fn mcp_values(map: &mut McpServerMap) -> Vec<(String, &mut String)> {
+    let part = |s: &str| s.replace('%', "%25").replace('/', "%2F");
+    let mut values = Vec::new();
+    for (server, cfg) in map.iter_mut() {
+        for (kind, entries) in [("env", &mut cfg.env), ("header", &mut cfg.headers)] {
+            for (name, value) in entries.iter_mut() {
+                values.push((format!("{USER_MCP_VALUES}{}/{kind}/{}", part(server), part(name)), value));
+            }
+        }
+    }
+    values
+}
+
+fn has_mcp_values(map: &McpServerMap) -> bool {
+    map.values().any(|s| s.env.values().chain(s.headers.values()).any(|v| !v.is_empty()))
+}
+
+/// Fills in the saved values. A value written in the settings file wins: an empty one stands for the saved one.
+fn fill_mcp_values(secrets: &AgentSecrets, map: &mut McpServerMap) {
+    for (key, value) in mcp_values(map) {
+        if value.is_empty()
+            && let Some(saved) = secrets.get(&key)
+        {
+            *value = saved;
+        }
+    }
+}
+
+/// Saves the values of `map` and empties them in it; values of servers and names no
+/// longer in it are forgotten.
+fn take_mcp_values(secrets: &AgentSecrets, map: &mut McpServerMap) -> IdeResult<Kept> {
+    let mut kept = Kept::Store;
+    let mut current = HashSet::new();
+    for (key, value) in mcp_values(map) {
+        if value.is_empty() {
+            secrets.delete(&key);
+        } else if secrets.get(&key).as_deref() != Some(value.as_str()) && secrets.set(&key, value)? == Kept::LocalFile {
+            kept = Kept::LocalFile;
+        }
+        value.clear();
+        current.insert(key);
+    }
+    for key in secrets.keys(USER_MCP_VALUES) {
+        if !current.contains(&key) {
+            secrets.delete(&key);
+        }
+    }
+    Ok(kept)
+}
+
+/// Values written into the user settings (by hand, by an older version, by an import) move to [`AgentSecrets`].
+pub fn move_user_mcp_values(host: &Host) {
+    let mut user = host.global_settings.effective().agents.mcp_servers;
+    if !has_mcp_values(&user) {
+        return;
+    }
+    fill_mcp_values(&host.agent_secrets, &mut user);
+    if let Err(e) = persist_mcp_map(host, None, McpScope::User, &user) {
+        tracing::warn!("MCP servers: could not move values out of the user settings: {}", e.message);
+    }
+}
+
 fn mcp_maps(host: &Host, window: &str) -> (McpServerMap, McpServerMap, Option<std::sync::Arc<crate::Project>>) {
-    let user = host.global_settings.effective().agents.mcp_servers;
+    move_user_mcp_values(host);
+    let mut user = host.global_settings.effective().agents.mcp_servers;
+    fill_mcp_values(&host.agent_secrets, &mut user);
    let project = host.project(window).ok().filter(|p| !p.light);
    let workspace = project
        .as_ref()
@@ -358,10 +428,15 @@ fn persist_mcp_map(
    scope: McpScope,
    map: &McpServerMap,
 ) -> IdeResult<()> {
+    let mut map = map.clone();
+    let kept = match scope {
+        McpScope::User => take_mcp_values(&host.agent_secrets, &mut map)?,
+        McpScope::Workspace => Kept::Store,
+    };
    let value = if map.is_empty() {
        serde_json::Value::Null
    } else {
-        serde_json::to_value(map).map_err(|e| IdeError::invalid(e.to_string()))?
+        serde_json::to_value(&map).map_err(|e| IdeError::invalid(e.to_string()))?
    };
    let event = IdeEvent::SettingsChanged { key: "agents.mcpServers".into() };
    match scope {
@@ -370,6 +445,9 @@ fn persist_mcp_map(
            for p in host.projects() {
                p.settings.reload();
                p.sink.emit(event.clone());
+                if kept == Kept::LocalFile {
+                    host.agent_secrets.notify_kept_locally(&p.sink);
+                }
            }
        }
        McpScope::Workspace => {
@@ -418,15 +496,17 @@ fn listed(
    ide_agent::mcp::servers_from_settings(user, &workspace)
 }

-/// The MCP servers agent sessions of the project at `root` get: the user's, and the project's the
-/// user turned on.
+/// The MCP servers agent sessions of the project at `root` get: the user's, values filled in, and
+/// the project's the user turned on.
 pub(crate) fn session_mcp_servers(
    settings: &ide_workspace::SettingsStore,
    approvals: &crate::trust::McpServerApprovals,
+    secrets: &AgentSecrets,
    root: &std::path::Path,
 ) -> Vec<McpServer> {
    use ide_workspace::settings::SettingsScope;
-    let user = settings.layer(SettingsScope::Global).agents.mcp_servers;
+    let mut user = settings.layer(SettingsScope::Global).agents.mcp_servers;
+    fill_mcp_values(secrets, &mut user);
    let workspace = approvals.apply(root, settings.layer(SettingsScope::Project).agents.mcp_servers);
    ide_agent::mcp::servers_from_settings(&user, &workspace)
 }
@@ -593,6 +673,7 @@ mod tests {

    #[test]
    fn sessions_get_the_users_servers_and_the_projects_turned_on_ones() {
+        ide_ssh::secrets::testing::use_memory_store();
        let tmp = tempfile::tempdir().unwrap();
        let (config, root) = (tmp.path().join("config"), tmp.path().join("project"));
        std::fs::create_dir_all(&config).unwrap();
@@ -605,6 +686,7 @@ mod tests {
        .unwrap();
        let settings = ide_workspace::SettingsStore::load(&config, Some(&root));
        let approvals = crate::trust::McpServerApprovals::load(&tmp.path().join("data"));
+        let secrets = AgentSecrets::new(&tmp.path().join("data"));
        let on = |servers: Vec<McpServer>| -> Vec<(McpScope, String, String)> {
            servers
                .into_iter()
@@ -613,13 +695,27 @@ mod tests {
                .collect()
        };
        assert_eq!(
-            on(session_mcp_servers(&settings, &approvals, &root)),
+            on(session_mcp_servers(&settings, &approvals, &secrets, &root)),
            [(McpScope::User, "shared".to_owned(), "user-cmd".to_owned())]
        );

+        // A user server's saved values reach the session; the file keeps only the names.
+        std::fs::write(
+            config.join("settings.toml"),
+            "[agents.mcpServers.keyed]\ncommand = \"k\"\nenv = { TOKEN = \"\" }\n",
+        )
+        .unwrap();
+        secrets.set("mcp/user/keyed/env/TOKEN", "saved-user").unwrap();
+        settings.reload();
+        let keyed = session_mcp_servers(&settings, &approvals, &secrets, &root);
+        let keyed = keyed.iter().find(|s| s.name == "keyed").unwrap();
+        assert_eq!(keyed.env[0].value, "saved-user");
+        std::fs::write(config.join("settings.toml"), "[agents.mcpServers.shared]\ncommand = \"user-cmd\"\n").unwrap();
+        settings.reload();
+
        let extra = settings.layer(ide_workspace::settings::SettingsScope::Project).agents.mcp_servers["extra"].clone();
        approvals.approve(&root, "extra", &extra).unwrap();
-        assert!(on(session_mcp_servers(&settings, &approvals, &root)).contains(&(
+        assert!(on(session_mcp_servers(&settings, &approvals, &secrets, &root)).contains(&(
            McpScope::Workspace,
            "extra".to_owned(),
            "extra".to_owned()
@@ -15,6 +15,7 @@ use ide_build::{BuildModel, BuildTool, SyncOptions, SyncProgress};
 use ide_core::settings::Settings;
 use ide_core::{DocId, FileEdit, IdeError, IdeEvent, IdeResult, Location, Pos, Range, RequestId, WorkspaceEdit};
 use std::path::Path;
+use std::sync::Arc;

 fn join_err(e: tokio::task::JoinError) -> IdeError {
    IdeError::internal(e.to_string())
@@ -330,21 +331,61 @@ pub async fn build_sync(
    // holds for Gradle: it reuses its cached classpath on restart, so a
    // dependency added to `build.gradle` stays unresolved until told to sync.
    let lsp = project.lsp.clone();
+    let documents = project.documents.clone();
    tokio::spawn(async move {
        if profiles_changed {
            // jdtls takes the profiles from its Maven settings (see `ide_sdk::maven_profiles`).
            lsp.reconfigure().await;
        }
+        let first = updates.first().cloned();
        for file in updates {
            let uri = ide_lsp::path_to_uri_string(&file);
            if let Err(e) = lsp.java_update_project_configs(&file, vec![uri]).await {
                tracing::debug!("java/projectConfigurationsUpdate: {e}");
            }
        }
+        let changed = {
+            let lsp = lsp.clone();
+            tokio::task::spawn_blocking(move || lsp.changed_library_archives()).await.unwrap_or_default()
+        };
+        if let Some(file) = first
+            && let Err(e) = lsp.java_refresh_archives(&file, &changed).await
+        {
+            tracing::debug!("openidea.java.refreshArchives: {e}");
+        }
+        refresh_library_classes(&lsp, &documents).await;
    });
    Ok(model)
 }

+/// Open library classes whose jar was replaced in place (a SNAPSHOT installed
+/// again keeps its path) show the new contents, like a reopened one.
+async fn refresh_library_classes(lsp: &Arc<ide_lsp::LspManager>, documents: &Arc<ide_workspace::Documents>) {
+    let changed = {
+        let (lsp, documents) = (lsp.clone(), documents.clone());
+        tokio::task::spawn_blocking(move || {
+            documents
+                .open_documents()
+                .into_iter()
+                .filter_map(|doc| Some((doc, documents.virtual_uri(doc).ok().flatten()?)))
+                .filter(|(_, uri)| lsp.library_class_changed(uri))
+                .collect::<Vec<_>>()
+        })
+        .await
+        .unwrap_or_default()
+    };
+    for (doc, uri) in changed {
+        match lsp.virtual_document(&uri).await {
+            Ok(vd) => {
+                if let Err(e) = documents.replace_virtual(doc, &vd.text, &vd.encoding, vd.has_bom) {
+                    tracing::debug!("refreshing {uri}: {e}");
+                }
+            }
+            Err(e) => tracing::debug!("refreshing {uri}: {e}"),
+        }
+    }
+}
+
 /// The POM declaring `dependency` for the Maven module `pom` (project-relative): the
 /// module's own, else its nearest parent in the project; its path, text and declaration.
 fn declaring_pom(
@@ -985,6 +1026,38 @@ mod build_tool_settings_tests {
        }
    }

+    /// Changing Project JDK updates the next Maven build without reopening the project.
+    #[test]
+    fn changing_project_jdk_updates_the_next_maven_build() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = dunce::canonicalize(tmp.path()).unwrap();
+        std::fs::write(
+            root.join("pom.xml"),
+            r#"<project><modelVersion>4.0.0</modelVersion><groupId>test</groupId><artifactId>app</artifactId><version>1</version></project>"#,
+        )
+        .unwrap();
+        for (name, version) in [("jdk8", "1.8"), ("jdk21", "21")] {
+            let home = root.join(name);
+            std::fs::create_dir_all(home.join("bin")).unwrap();
+            std::fs::write(home.join("bin").join(if cfg!(windows) { "java.exe" } else { "java" }), "").unwrap();
+            std::fs::write(home.join("release"), format!("JAVA_VERSION=\"{version}\"\n")).unwrap();
+        }
+
+        let mut settings = Settings::default();
+        settings.languages.java.maven.runner_jre.clear();
+        for name in ["jdk8", "jdk21"] {
+            settings.languages.java.jdk = name.into();
+            let expected = root.join(name);
+            let model = load(&root, &root.join("cache"), &settings);
+            assert_eq!(model.maven.as_ref().unwrap().projects[0].env["JAVA_HOME"], expected.to_string_lossy());
+            let plan = compile::plan(&root, &model, BuildKind::Build, None, None).unwrap();
+            assert!(!plan.steps.is_empty());
+            for step in plan.steps {
+                assert_eq!(step.env["JAVA_HOME"], expected.to_string_lossy());
+            }
+        }
+    }
+
    #[test]
    fn model_for_sync_tasks_and_compile_uses_gradle_settings() {
        let tmp = tempfile::tempdir().unwrap();
@@ -1019,7 +1092,6 @@ mod maven_completion_tests {
    use ide_build::maven::completion::PomCompletionKind;
    use ide_core::CancellationToken;
    use ide_workspace::dependencies::DependencyVersionSource;
-    use std::sync::Arc;

    /// Cache answers the test plants before completing, so the op's Central
    /// lookups hit the session cache and the network is never reached.
@@ -188,8 +188,14 @@ pub async fn remote_download_into(
    r
 }

-pub async fn deploy_test_connection(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
-    state.remote.test_connection(&connection, &path).await
+/// `password`: an FTP password typed in the settings but not applied yet.
+pub async fn deploy_test_connection(
+    state: &Host,
+    connection: FsConnection,
+    path: String,
+    password: Option<String>,
+) -> IdeResult<()> {
+    state.remote.test_connection_with(&connection, &path, password).await
 }

 pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
@@ -231,6 +237,6 @@ pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
        remote_rename(&c.host, c.arg("connection")?, c.arg("from")?, c.arg("to")?).await
    });
    d.add("deploy_test_connection", |c| async move {
-        deploy_test_connection(&c.host, c.arg("connection")?, c.arg("path")?).await
+        deploy_test_connection(&c.host, c.arg("connection")?, c.arg("path")?, c.arg("password")?).await
    });
 }
@@ -96,18 +96,19 @@ async fn resolve_launch(
    let cancel = cancel.clone();
    tokio::task::spawn_blocking(move || {
        let _external_build = external_build;
+        let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
        let built = if delegated {
-            let policy = delegated_policy(policy, prefer_maven, info.error_count);
+            let rebuild_on_jdt_errors = rebuild_on_jdt_errors(policy, prefer_maven, info.error_count);
            let outputs = project.java_launch_snapshots.lock().build(
                &project.root,
                &model,
                &module,
-                cache::BuildOptions { test, policy },
-                ide_sdk::apply::maven_local_repository(&project.root, &settings),
+                cache::BuildOptions { test, policy, rebuild_on_jdt_errors },
+                local_repo.clone(),
                &cancel,
            )?;
            let copies = use_snapshot(&mut info, &outputs.originals, &outputs.snapshot);
-            apply_external_build_result(&mut info, outputs.failure, policy == BuildPolicy::Rebuild);
+            apply_external_build_result(&mut info, outputs.failure, outputs.authoritative);
            copies
        } else if external {
            let built = compile::build_for_launch(&project.root, &model, &module, test, build_kind, &cancel)?;
@@ -123,10 +124,22 @@ async fn resolve_launch(
            Vec::new()
        };
        let mut class_paths: Vec<String> = built.iter().map(|p| p.to_string_lossy().into_owned()).collect();
-        for p in std::mem::take(&mut info.class_paths) {
-            if !class_paths.iter().any(|c| same_entry(c, &p, cfg!(windows))) {
-                class_paths.push(p);
-            }
+        if delegated {
+            // m2e runs inside jdtls on the server JDK and can resolve a different
+            // Maven profile/classifier than the module build. Ask the same Maven
+            // process that built the module for its runtime/test dependencies.
+            let maven_cp = compile::module_classpath(
+                &project.root,
+                &model,
+                &module,
+                test,
+                local_repo,
+                &project.build_cache_dir(),
+                &cancel,
+            );
+            merge_maven_launch_classpath(&mut class_paths, &mut info, maven_cp)?;
+        } else {
+            append_unique_class_paths(&mut class_paths, std::mem::take(&mut info.class_paths));
        }
        info.class_paths = class_paths;
        apply_library_classpath(&mut info, &project.root, &settings.project_structure.libraries, test);
@@ -191,21 +204,18 @@ async fn resolve_launch(
 /// With Settings › Maven › Delegate IDE build/run actions to Maven, javac's verdict replaces
 /// JDT's. Classes JDT wrote for sources with errors look up to date to Maven's incremental
 /// compiler, so a launch JDT reports errors for recompiles everything.
-fn delegated_policy(policy: BuildPolicy, prefer_maven: bool, jdt_errors: u32) -> BuildPolicy {
-    if prefer_maven && jdt_errors > 0 && matches!(policy, BuildPolicy::Automatic | BuildPolicy::Make) {
-        BuildPolicy::Rebuild
-    } else {
-        policy
-    }
+fn rebuild_on_jdt_errors(policy: BuildPolicy, prefer_maven: bool, jdt_errors: u32) -> bool {
+    prefer_maven && jdt_errors > 0 && matches!(policy, BuildPolicy::Automatic | BuildPolicy::Make)
 }

-fn apply_external_build_result(info: &mut JavaLaunchInfo, failure: Option<String>, clean: bool) {
+fn apply_external_build_result(info: &mut JavaLaunchInfo, failure: Option<String>, authoritative: bool) {
    info.build = Some(if let Some(failure) = failure {
        info.hints.push(failure);
        JavaBuildStatus::Failed
-    } else if clean {
-        // A clean external build recompiled every source; JDT's diagnostics still describe
-        // the previous output (and reject sources javac accepts, e.g. a package mismatch).
+    } else if authoritative {
+        // A clean rebuild or a fingerprint-verified snapshot is authoritative. JDT diagnostics
+        // may describe an older output or its own classpath, so they must not mark this launch
+        // as failed after Maven has produced usable classes.
        info.errors.clear();
        info.error_count = 0;
        JavaBuildStatus::Succeeded
@@ -286,6 +296,44 @@ fn same_entry(a: &str, b: &str, windows: bool) -> bool {
    a == b || entry_key(a, windows) == entry_key(b, windows)
 }

+/// Merge the Maven launch classpath without turning a recoverable probe failure into a
+/// failed launch. Cancellation still propagates; ordinary failures keep jdtls' classpath
+/// and leave the reason in the run console.
+fn merge_maven_launch_classpath(
+    class_paths: &mut Vec<String>,
+    info: &mut JavaLaunchInfo,
+    classpath: IdeResult<String>,
+) -> IdeResult<()> {
+    match classpath {
+        Ok(classpath) => {
+            append_unique_class_paths(
+                class_paths,
+                std::env::split_paths(&classpath).map(|path| path.to_string_lossy().into_owned()),
+            );
+            Ok(())
+        }
+        Err(error) if error.kind == ErrorKind::Cancelled => Err(error),
+        Err(error) => {
+            info.hints.push(format!(
+                "Maven launch classpath resolution failed; using the Java language server classpath instead:\n{}",
+                error.message
+            ));
+            append_unique_class_paths(class_paths, std::mem::take(&mut info.class_paths));
+            Ok(())
+        }
+    }
+}
+
+/// Append entries without changing their precedence; `same_entry` also catches
+/// Windows case-insensitive duplicates that would otherwise lengthen the command.
+fn append_unique_class_paths(class_paths: &mut Vec<String>, entries: impl IntoIterator<Item = String>) {
+    for entry in entries {
+        if !class_paths.iter().any(|existing| same_entry(existing, &entry, cfg!(windows))) {
+            class_paths.push(entry);
+        }
+    }
+}
+
 fn use_snapshot(info: &mut JavaLaunchInfo, built: &[PathBuf], snapshot: &std::path::Path) -> Vec<PathBuf> {
    use_snapshot_on(info, built, snapshot, cfg!(windows))
 }
@@ -410,14 +458,36 @@ mod tests {

    #[test]
    fn delegated_launches_with_jdt_errors_recompile_with_maven() {
-        assert_eq!(delegated_policy(BuildPolicy::Make, true, 1), BuildPolicy::Rebuild);
-        assert_eq!(delegated_policy(BuildPolicy::Automatic, true, 2), BuildPolicy::Rebuild);
-        assert_eq!(delegated_policy(BuildPolicy::Make, true, 0), BuildPolicy::Make);
-        assert_eq!(delegated_policy(BuildPolicy::Make, false, 1), BuildPolicy::Make);
-        assert_eq!(
-            delegated_policy(BuildPolicy::MakeAndContinueOnErrors, true, 1),
-            BuildPolicy::MakeAndContinueOnErrors
-        );
+        assert!(rebuild_on_jdt_errors(BuildPolicy::Make, true, 1));
+        assert!(rebuild_on_jdt_errors(BuildPolicy::Automatic, true, 2));
+        assert!(!rebuild_on_jdt_errors(BuildPolicy::Make, true, 0));
+        assert!(!rebuild_on_jdt_errors(BuildPolicy::Make, false, 1));
+        assert!(!rebuild_on_jdt_errors(BuildPolicy::MakeAndContinueOnErrors, true, 1));
+    }
+
+    #[test]
+    fn maven_classpath_probe_failure_falls_back_to_jdtls_classpaths() {
+        let maven = std::env::join_paths(["maven.jar", "snapshot.jar"]).unwrap().to_string_lossy().into_owned();
+        let mut class_paths = vec!["snapshot.jar".to_owned()];
+        let mut info =
+            JavaLaunchInfo { class_paths: vec!["snapshot.jar".into(), "jdtls.jar".into()], ..Default::default() };
+        merge_maven_launch_classpath(&mut class_paths, &mut info, Ok(maven)).unwrap();
+        assert_eq!(class_paths, ["snapshot.jar", "maven.jar"]);
+
+        merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::internal("offline dependency")))
+            .unwrap();
+        assert_eq!(class_paths, ["snapshot.jar", "maven.jar", "jdtls.jar"]);
+        assert!(info.hints[0].contains("offline dependency"), "{:?}", info.hints);
+    }
+
+    #[test]
+    fn cancelled_maven_classpath_probe_propagates_without_fallback() {
+        let mut class_paths = vec!["snapshot.jar".to_owned()];
+        let mut info = JavaLaunchInfo { class_paths: vec!["jdtls.jar".into()], ..Default::default() };
+        let error = merge_maven_launch_classpath(&mut class_paths, &mut info, Err(IdeError::cancelled())).unwrap_err();
+        assert_eq!(error.kind, ErrorKind::Cancelled);
+        assert_eq!(class_paths, ["snapshot.jar"]);
+        assert!(info.hints.is_empty());
    }

    #[test]
@@ -461,7 +531,7 @@ mod tests {
    }

    #[test]
-    fn clean_external_build_clears_stale_jdt_errors() {
+    fn authoritative_external_result_clears_stale_jdt_errors() {
        let mut info = JavaLaunchInfo {
            error_count: 7,
            errors: vec![ide_lsp::jdtls::JavaCompileError {
@@ -14,6 +14,10 @@ pub(super) struct Outputs {
    pub originals: Vec<PathBuf>,
    #[serde(skip)]
    pub failure: Option<String>,
+    /// Whether this result replaces jdtls diagnostics with a clean Maven build or a
+    /// verified snapshot. It is runtime-only because reuse is determined per launch.
+    #[serde(skip)]
+    pub authoritative: bool,
 }

 impl Outputs {
@@ -42,6 +46,9 @@ pub(super) fn has_record(root: &Path, cache: &Path, module: &Path) -> bool {
 pub(super) struct BuildOptions {
    pub test: bool,
    pub policy: BuildPolicy,
+    /// A JDT error makes a cache miss rebuild, but it must not prevent an unchanged
+    /// snapshot from being reused on the next launch.
+    pub rebuild_on_jdt_errors: bool,
 }

 /// Owned by Project: running JVMs may still load superseded outputs until it drops.
@@ -75,7 +82,7 @@ impl Session {
        cancel: &CancellationToken,
    ) -> IdeResult<Outputs> {
        self.initialize();
-        let BuildOptions { test, policy } = options;
+        let BuildOptions { test, policy, rebuild_on_jdt_errors } = options;
        let cache = &self.cache;
        let record =
            record_path(root, cache, module, test).ok_or_else(|| IdeError::internal("launch outside project"))?;
@@ -115,8 +122,14 @@ impl Session {
            && outputs.reusable(&before, &snapshots)
        {
            tracing::info!(module = %module.display(), test, "Reusing Maven launch snapshot");
-            return Ok(previous.unwrap());
+            let mut outputs = previous.unwrap();
+            outputs.authoritative = true;
+            return Ok(outputs);
        }
+        // JDT can report errors from its own classpath while the last Maven snapshot is
+        // still valid. Reuse that snapshot first; only a cache miss needs the expensive
+        // clean rebuild that replaces JDT's error-stub classes.
+        let policy = if rebuild_on_jdt_errors { BuildPolicy::Rebuild } else { policy };
        // Retain a non-reusable record even on failure, so removing the final mixed
        // source still delegates to Maven to clean its old classes on the next launch.
        fs::create_dir_all(record.parent().unwrap())?;
@@ -156,7 +169,13 @@ impl Session {
        if cancel.is_cancelled() {
            return Err(IdeError::cancelled());
        }
-        let mut outputs = Outputs { fingerprint: None, snapshot, originals, failure: built.failure };
+        let mut outputs = Outputs {
+            fingerprint: None,
+            snapshot,
+            originals,
+            failure: built.failure,
+            authoritative: policy == BuildPolicy::Rebuild,
+        };
        if outputs.failure.is_none() && before.is_some() && before == after {
            outputs.fingerprint = before;
            fs::create_dir_all(record.parent().unwrap())?;
@@ -334,6 +353,48 @@ mod tests {
        );
    }

+    #[test]
+    fn jdt_errors_reuse_an_unchanged_snapshot_and_rebuild_only_on_a_cache_miss() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        let model = fixture(root);
+        let cancel = CancellationToken::new();
+        let mut session = Session::new(root.join("cache"));
+        let first = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
+        assert!(!first.authoritative);
+
+        let reused = session
+            .build(
+                root,
+                &model,
+                root,
+                BuildOptions { rebuild_on_jdt_errors: true, ..Default::default() },
+                None,
+                &cancel,
+            )
+            .unwrap();
+        assert_eq!(reused.snapshot, first.snapshot);
+        assert!(reused.authoritative);
+        assert_eq!(fs::read_to_string(root.join("calls")).unwrap().lines().count(), 1);
+
+        fs::write(root.join("src/main/kotlin/Main.kt"), "updated").unwrap();
+        let rebuilt = session
+            .build(
+                root,
+                &model,
+                root,
+                BuildOptions { rebuild_on_jdt_errors: true, ..Default::default() },
+                None,
+                &cancel,
+            )
+            .unwrap();
+        assert_ne!(rebuilt.snapshot, first.snapshot);
+        assert!(rebuilt.authoritative);
+        let calls = fs::read_to_string(root.join("calls")).unwrap();
+        assert_eq!(calls.lines().count(), 2);
+        assert!(calls.lines().last().unwrap().contains("clean"));
+    }
+
    #[test]
    fn successful_snapshots_reuse_across_close_and_rebuild_for_changes_missing_outputs_or_failure() {
        let dir = tempfile::tempdir().unwrap();
@@ -483,7 +544,13 @@ mod tests {
        fs::write(snapshots.join("launch-file"), "keep").unwrap();
        let record = cache.join("java-launch/records/deep/module/test.json");
        fs::create_dir_all(record.parent().unwrap()).unwrap();
-        let outputs = Outputs { fingerprint: None, snapshot: retained.clone(), originals: Vec::new(), failure: None };
+        let outputs = Outputs {
+            fingerprint: None,
+            snapshot: retained.clone(),
+            originals: Vec::new(),
+            failure: None,
+            authoritative: false,
+        };
        fs::write(record, serde_json::to_vec(&outputs).unwrap()).unwrap();
        let mut session = Session::new(cache);
        session.initialize();
@@ -1483,23 +1483,38 @@ pub async fn lsp_restart_named(host: &Host, name: &str) -> IdeResult<()> {
 pub async fn apply_workspace_edit(host: &Host, window: &str, edit: WorkspaceEdit) -> IdeResult<()> {
    let project = host.project(window)?;
    blocking(move || {
-        // Multi-file refactorings leave a Local History point to go back to.
-        let paths: Vec<&std::path::Path> = edit
-            .files
-            .iter()
-            .filter_map(|f| match f {
-                ide_core::FileEdit::Edit { path, .. } => Some(&**path),
-                _ => None,
-            })
-            .collect();
-        if edit.files.len() > 1 {
-            project.record_before_refactoring(&paths, "Apply changes");
-        }
+        record_before_multi_file_edit(&project, &edit);
        apply_edit(&project.documents, &edit)
    })
    .await
 }

+/// [`apply_workspace_edit`] for the MCP server's tools: undoable the same way, but the UI does
+/// not announce it as a refactoring.
+pub async fn apply_agent_workspace_edit(host: &Host, window: &str, edit: WorkspaceEdit) -> IdeResult<()> {
+    let project = host.project(window)?;
+    blocking(move || {
+        record_before_multi_file_edit(&project, &edit);
+        project.documents.apply_agent_workspace_edit(&edit)
+    })
+    .await
+}
+
+/// Multi-file edits leave a Local History point to go back to.
+fn record_before_multi_file_edit(project: &crate::Project, edit: &WorkspaceEdit) {
+    let paths: Vec<&std::path::Path> = edit
+        .files
+        .iter()
+        .filter_map(|f| match f {
+            ide_core::FileEdit::Edit { path, .. } => Some(&**path),
+            _ => None,
+        })
+        .collect();
+    if edit.files.len() > 1 {
+        project.record_before_refactoring(&paths, "Apply changes");
+    }
+}
+
 pub async fn prepare_workspace_edit(host: &Host, window: &str, mut edit: WorkspaceEdit) -> IdeResult<WorkspaceEdit> {
    let project = host.project(window)?;
    blocking(move || {
@@ -61,13 +61,16 @@ pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeRe
    host.require_trust(window)?;
    let current = host.project(window).ok().map(|p| p.root.clone());
    let config = host.config_dir.clone();
+    // Probing runs the project's interpreter (and its settings may name any program): only
+    // projects trusted in their own right, not ones last opened in Restricted Mode.
+    let roots: Vec<PathBuf> = ide_workspace::RecentProjects::load(&config)
+        .list()
+        .into_iter()
+        .map(|p| p.path.into_path_buf())
+        .filter(|root| current.as_deref() != Some(root.as_path()))
+        .filter(|root| host.trust.window_trusted(root).unwrap_or(false))
+        .collect();
    tokio::task::spawn_blocking(move || {
-        let roots: Vec<PathBuf> = ide_workspace::RecentProjects::load(&config)
-            .list()
-            .into_iter()
-            .map(|p| p.path.into_path_buf())
-            .filter(|root| current.as_deref() != Some(root.as_path()))
-            .collect();
        // Each project resolves its configured interpreter, else its own virtualenv. The
        // probes run `python`, so keep them off the async runtime and bound how many run at
        // once: the recent list can hold ~30 projects, and each probe starts a process.
@@ -521,6 +524,10 @@ mod tests {
        host.trust.decide(&root, true, false).unwrap();
        host.open_project("main", &root).unwrap();

+        // A project last opened in Restricted Mode: its interpreter is never run.
+        host.trust.decide(&other, false, false).unwrap();
+        assert!(sdk_python_project_interpreters(&host, "main").await.unwrap().is_empty());
+        host.trust.decide(&other, true, false).unwrap();
        let list = sdk_python_project_interpreters(&host, "main").await.unwrap();
        assert_eq!(list.len(), 1, "{list:?}");
        assert_eq!(&*list[0].project, other.as_path());
@@ -4125,6 +4125,11 @@ impl PluginApi {
        if items.len() > 10_000 || file.as_ref().and_then(|f| f.badge.as_ref()).is_some_and(|b| b.chars().count() > 2) {
            return Err(HostError::Invalid("decoration limit exceeded".into()));
        }
+        if let Some(note) = file.as_ref().and_then(|f| f.note.as_ref())
+            && (note.trim().is_empty() || note.chars().count() > 200 || note.contains(['\n', '\r']))
+        {
+            return Err(HostError::Invalid("a file note is one non-empty line of at most 200 characters".into()));
+        }
        items.retain(|d| decoration_style(&d.style));
        if items.iter().any(|d| d.range.start > d.range.end) {
            return Err(HostError::Invalid("reversed decoration range".into()));
@@ -4143,7 +4148,7 @@ impl PluginApi {
                set_id: set.into(),
                tree,
                items,
-                file: file.filter(|f| decoration_style(&f.style)),
+                file: file.filter(|f| f.note.is_some() || decoration_style(&f.style)),
            })
        } else {
            None
@@ -4315,10 +4320,33 @@ mod workbench_tests {
            api.file_decorations(
                Some(&path),
                "tree",
-                Some(ide_plugin::FileDecoration { badge: Some("abc".into()), style: "info".into(), tooltip: None })
+                Some(ide_plugin::FileDecoration {
+                    badge: Some("abc".into()),
+                    style: "info".into(),
+                    tooltip: None,
+                    note: None
+                })
            )
            .is_err()
        );
+        let note = |text: &str| ide_plugin::FileDecoration {
+            badge: None,
+            style: String::new(),
+            tooltip: Some("why".into()),
+            note: Some(text.into()),
+        };
+        api.file_decorations(Some(&path), "notes", Some(note("entry point"))).unwrap();
+        let notes = |api: &PluginApi| {
+            api.shared.decoration_sets()["test"]
+                .iter()
+                .filter(|s| s.tree && s.set_id == "notes")
+                .map(|s| s.file.as_ref().and_then(|f| f.note.clone()))
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(notes(&api), [Some("entry point".to_string())], "kept without a style");
+        for bad in ["", "two\nlines", &"x".repeat(201)] {
+            assert!(api.file_decorations(Some(&path), "notes", Some(note(bad))).is_err(), "{bad:?}");
+        }
        api.shared.clear_plugin("test", true);
        assert!(api.shared.decoration_sets().is_empty());
    }
@@ -675,9 +675,10 @@ impl Host {
            agents.set_new_task_approvals_hook(Arc::new(move || settings.effective().agents.new_task_approvals));
        }
        let approvals = self.mcp_approvals.clone();
+        let secrets = self.agent_secrets.clone();
        let root = root.to_path_buf();
        agents.set_mcp_servers_hook(Box::new(move || {
-            crate::ops::agent::session_mcp_servers(&settings, &approvals, &root)
+            crate::ops::agent::session_mcp_servers(&settings, &approvals, &secrets, &root)
        }));
        (db, http_history, agents)
    }
@@ -231,7 +231,11 @@ async fn mutations_preserve_unsaved_text_and_reject_metadata_and_escapes() {
        .iter()
        .rev()
        .find_map(|event| match event {
-            IdeEvent::WorkspaceEditApplied { id, .. } => Some(*id),
+            // Undoable like a refactoring, but marked as the agent's, so it isn't announced as one.
+            IdeEvent::WorkspaceEditApplied { id, by_agent, .. } => {
+                assert!(*by_agent, "an MCP edit is the agent's");
+                Some(*id)
+            }
            _ => None,
        })
        .unwrap();
@@ -0,0 +1,133 @@
+//! Values of the user's MCP servers' environment variables and HTTP headers live in the
+//! credential store; `settings.toml` keeps only their names. A project's own servers keep
+//! their values in the project's file, where the project shares them.
+
+use ide_agent::{McpKeyValue, McpScope, McpServer, McpServerInput};
+use ide_core::NullSink;
+use ide_core::settings::McpTransport;
+use ide_host::{Host, HostConfig};
+use ide_ssh::secrets::testing::{files_containing, use_memory_store};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+const VALUE: &str = "mcp-value-0f3c9a";
+
+fn host(dir: &Path) -> Arc<Host> {
+    Arc::new(Host::new(HostConfig {
+        config_dir: dir.join("config"),
+        data_dir: dir.join("data"),
+        local_data_dir: dir.join("data"),
+        languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
+        syntax: Arc::default(),
+        sink_for: Box::new(|_| Arc::new(NullSink)),
+        owner: |w| w,
+        runtime: tokio::runtime::Handle::current(),
+        project_environment: false,
+    }))
+}
+
+fn project(tmp: &tempfile::TempDir) -> PathBuf {
+    let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
+    std::fs::create_dir_all(root.join(".openidea")).unwrap();
+    root
+}
+
+fn open(host: &Host, root: &Path) {
+    host.trust.decide(root, true, false).unwrap();
+    host.open_project("main", root).unwrap();
+}
+
+fn header(servers: &[McpServer], id: &str) -> String {
+    let server = servers.iter().find(|s| s.id == id).unwrap_or_else(|| panic!("{id} in {servers:?}"));
+    server.headers.iter().find(|h| h.name == "Authorization").map(|h| h.value.clone()).unwrap_or_default()
+}
+
+fn input(name: &str, scope: McpScope) -> McpServerInput {
+    McpServerInput {
+        id: None,
+        name: name.into(),
+        scope,
+        transport: McpTransport::Http,
+        enabled: true,
+        command: None,
+        args: vec![],
+        env: vec![],
+        url: Some("https://mcp.example/v1".into()),
+        headers: vec![McpKeyValue { name: "Authorization".into(), value: format!("Bearer {VALUE}") }],
+        agents: vec![],
+    }
+}
+
+const SERVER_WITH_VALUE: &str = r#"
+[agents.mcpServers.remote]
+transport = "http"
+enabled = true
+url = "https://mcp.example/v1"
+headers = { Authorization = "Bearer mcp-value-0f3c9a" }
+"#;
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn user_server_values_stay_out_of_the_user_settings() {
+    use_memory_store();
+    let tmp = tempfile::tempdir().unwrap();
+    let root = project(&tmp);
+    let host = host(tmp.path());
+    open(&host, &root);
+    for (name, scope) in [("user-server", McpScope::User), ("repo-server", McpScope::Workspace)] {
+        ide_host::ops::agent::mcp_save(&host, "main", input(name, scope)).unwrap();
+    }
+    host.close_project("main");
+
+    // Only the project's own file holds a value; nothing in the user's config or data does.
+    let found = files_containing(tmp.path(), VALUE);
+    assert!(found.len() == 1 && found[0].ends_with(Path::new(".openidea/settings.toml")), "{found:?}");
+
+    let host = self::host(tmp.path());
+    open(&host, &root);
+    let servers = ide_host::ops::agent::mcp_list(&host, "main").unwrap();
+    assert_eq!(header(&servers, "user::user-server"), format!("Bearer {VALUE}"));
+    assert_eq!(header(&servers, "workspace::repo-server"), format!("Bearer {VALUE}"));
+    host.close_project("main");
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn values_in_user_settings_move_to_the_credential_store() {
+    use_memory_store();
+    let tmp = tempfile::tempdir().unwrap();
+    let root = project(&tmp);
+    std::fs::create_dir_all(tmp.path().join("config")).unwrap();
+    let saved = SERVER_WITH_VALUE.replace("Authorization =", "X-Saved = \"\", Authorization =");
+    std::fs::write(tmp.path().join("config/settings.toml"), saved).unwrap();
+    ide_host::agent_secrets::AgentSecrets::new(&tmp.path().join("data"))
+        .set("mcp/user/remote/header/X-Saved", "saved-earlier")
+        .unwrap();
+    let host = host(tmp.path());
+    assert_eq!(files_containing(tmp.path(), VALUE), Vec::<PathBuf>::new());
+    open(&host, &root);
+    let servers = ide_host::ops::agent::mcp_list(&host, "main").unwrap();
+    assert_eq!(header(&servers, "user::remote"), format!("Bearer {VALUE}"));
+    let remote = servers.iter().find(|s| s.id == "user::remote").unwrap();
+    assert!(remote.headers.iter().any(|h| h.name == "X-Saved" && h.value == "saved-earlier"), "{remote:?}");
+    host.close_project("main");
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn a_projects_own_values_stay_in_its_file() {
+    use_memory_store();
+    let tmp = tempfile::tempdir().unwrap();
+    let root = project(&tmp);
+    let file = root.join(".openidea/settings.toml");
+    std::fs::write(&file, SERVER_WITH_VALUE).unwrap();
+    let host = host(tmp.path());
+    open(&host, &root);
+    let servers = ide_host::ops::agent::mcp_list(&host, "main").unwrap();
+    assert_eq!(header(&servers, "workspace::remote"), format!("Bearer {VALUE}"));
+    assert_eq!(std::fs::read_to_string(&file).unwrap(), SERVER_WITH_VALUE, "reading leaves the project file alone");
+
+    // Saving the servers keeps the project's values in the project's file for everyone else.
+    let servers = ide_host::ops::agent::mcp_set_enabled(&host, "main", "workspace::remote".into(), false).unwrap();
+    assert_eq!(header(&servers, "workspace::remote"), format!("Bearer {VALUE}"));
+    assert!(std::fs::read_to_string(&file).unwrap().contains(VALUE));
+    assert_eq!(files_containing(&tmp.path().join("data"), VALUE), Vec::<PathBuf>::new());
+    host.close_project("main");
+}
@@ -2609,6 +2609,82 @@ fn git_toolbox_does_not_fetch_untrusted_projects() {
    assert!(err.contains("Restricted Mode"), "{err}");
 }

+/// Git Toolbox in a workspace window whose container folder is not a
+/// repository (every member is its own clone): the status bar follows the
+/// focused file's repository, and the scheduled fetch covers every member.
+#[test]
+fn official_git_toolbox_follows_members_in_a_workspace() {
+    let f = fixture(Limits { idle_timeout: Some(Duration::from_millis(50)), ..Limits::default() });
+    let tmp = tempfile::tempdir().unwrap();
+    // A remote with `main`, cloned by member `a` (at `main`) and member `b`
+    // (on its own branch, to tell the two apart in the status bar).
+    let remote = tmp.path().join("remote.git");
+    std::fs::create_dir(&remote).unwrap();
+    git(&remote, &["init", "--bare", "-b", "main"]);
+    let seed = tmp.path().join("seed");
+    std::fs::create_dir(&seed).unwrap();
+    git(&seed, &["init", "-b", "main"]);
+    std::fs::write(seed.join("seed.txt"), "seed\n").unwrap();
+    git(&seed, &["add", "."]);
+    git(&seed, &["commit", "-m", "one"]);
+    git(&seed, &["remote", "add", "origin", remote.to_str().unwrap()]);
+    git(&seed, &["push", "-u", "origin", "main"]);
+    let member_a = tmp.path().join("member-a");
+    git(tmp.path(), &["clone", remote.to_str().unwrap(), member_a.to_str().unwrap()]);
+    let member_a = dunce::canonicalize(member_a).unwrap();
+    let member_b = tmp.path().join("member-b");
+    git(tmp.path(), &["clone", remote.to_str().unwrap(), member_b.to_str().unwrap()]);
+    let member_b = dunce::canonicalize(member_b).unwrap();
+    git(&member_b, &["checkout", "-b", "feature"]);
+    git(&member_b, &["push", "-u", "origin", "feature"]);
+    // The window's project is the container; the members are attached to it.
+    f.workspace.other_roots.lock().extend([member_a.clone(), member_b.clone()]);
+
+    f.install(&official("git-toolbox"));
+    let item = |host: &PluginHost| {
+        host.status_items().into_iter().find(|(p, id, _)| p == "openidea.git-toolbox" && id == "branch")
+    };
+    let now = Instant::now();
+    let focus = |path: &Path| {
+        f.host
+            .post_events(Some("main"), vec![WorkbenchEvent::EditorFocused(Some(path.to_string_lossy().into_owned()))]);
+        f.host.flush_events_at(now + Duration::from_secs(3));
+        f.host.wait_events(Duration::from_secs(10));
+    };
+    // Focusing a file of member `a` shows that member's branch: the window's
+    // project is the container, which is no repository.
+    focus(&member_a.join("seed.txt"));
+    assert_eq!(item(&f.host).map(|(_, _, i)| i.text), Some("main".into()));
+    // Fetch Now fetches the shown member; the container is not a repository.
+    f.run("openidea.git-toolbox", "fetch", None).unwrap();
+    let fetched = stored(&f, "openidea.git-toolbox");
+    assert!(
+        fetched.iter().any(|(key, _)| key == &format!("last-fetch:{}", to_ipc(&member_a))),
+        "{member_a:?}: {fetched:?}"
+    );
+    assert_eq!(fetched.iter().filter(|(key, _)| key.starts_with("last-fetch:")).count(), 1, "{fetched:?}");
+    // Switching to the other member follows it.
+    focus(&member_b.join("seed.txt"));
+    assert_eq!(item(&f.host).map(|(_, _, i)| i.text), Some("feature".into()));
+
+    // Idle: reclaimed; the schedule then wakes it to fetch every member (the
+    // container is skipped: it has no repository).
+    std::thread::sleep(Duration::from_millis(100));
+    f.host.tick();
+    assert_eq!(item(&f.host).map(|(_, _, i)| i.text), Some("feature".into()), "the item stays while it sleeps");
+    f.take_events();
+    f.host.tick_at(Instant::now() + Duration::from_secs(301));
+    assert!(f.host.wait_events(Duration::from_secs(30)));
+    let fetched = stored(&f, "openidea.git-toolbox");
+    for member in [&member_a, &member_b] {
+        assert!(
+            fetched.iter().any(|(key, _)| key == &format!("last-fetch:{}", to_ipc(member))),
+            "{member:?}: {fetched:?}"
+        );
+    }
+    assert_eq!(item(&f.host).map(|(_, _, i)| i.text), Some("feature".into()));
+}
+
 /// A tiny HTTP server: each request is answered after `delay(n)` (n counts
 /// requests) with `body`. Returns its port and the request bodies it got.
 fn http_server(
@@ -252,6 +252,77 @@ async fn maven_sync() {
    assert!(!junit.children.is_empty(), "{junit:?}");
 }

+/// The launch classpath must come from the runner JDK, not the JDK that happened
+/// to load the language-server model: JDK-activated profiles can select a
+/// different dependency classifier. Use real Maven so this covers the scenario
+/// rather than only the probe arguments.
+#[test]
+#[ignore = "project smoke: needs Maven and a JDK"]
+fn maven_launch_classpath_uses_the_runner_jdk_classifier() {
+    let tmp = tempfile::tempdir().unwrap();
+    let root = tmp.path();
+    let java_home = PathBuf::from(std::env::var("JAVA_HOME").expect("JAVA_HOME"));
+    let release = std::fs::read_to_string(java_home.join("release")).unwrap();
+    let version = release
+        .lines()
+        .find_map(|line| line.strip_prefix("JAVA_VERSION=\""))
+        .and_then(|line| line.strip_suffix('"'))
+        .expect("JAVA_VERSION in release");
+    let major = version.strip_prefix("1.").unwrap_or(version).split(['.', '_']).next().unwrap().parse::<u32>().unwrap();
+    let jar = java_home.join(if cfg!(windows) { "bin/jar.exe" } else { "bin/jar" });
+    let jars = root.join("libs");
+    let staging = root.join("empty");
+    std::fs::create_dir_all(&jars).unwrap();
+    std::fs::create_dir_all(&staging).unwrap();
+    for name in ["api-jdk8.jar", "api-jdk9.jar"] {
+        let status = std::process::Command::new(&jar)
+            .args(["cf"])
+            .arg(jars.join(name))
+            .arg(".")
+            .current_dir(&staging)
+            .status()
+            .unwrap();
+        assert!(status.success());
+    }
+    std::fs::write(
+        root.join("pom.xml"),
+        r#"<project xmlns="http://maven.apache.org/POM/4.0.0">
+          <modelVersion>4.0.0</modelVersion>
+          <groupId>demo</groupId><artifactId>jdk-classifier</artifactId><version>1</version>
+          <profiles>
+            <profile><id>jdk8</id><activation><jdk>1.8</jdk></activation><dependencies>
+              <dependency><groupId>demo</groupId><artifactId>api</artifactId><version>1</version><classifier>jdk8</classifier>
+                <scope>system</scope><systemPath>${project.basedir}/libs/api-jdk8.jar</systemPath></dependency>
+            </dependencies></profile>
+            <profile><id>jdk9</id><activation><jdk>[9,)</jdk></activation><dependencies>
+              <dependency><groupId>demo</groupId><artifactId>api</artifactId><version>1</version><classifier>jdk9</classifier>
+                <scope>system</scope><systemPath>${project.basedir}/libs/api-jdk9.jar</systemPath></dependency>
+            </dependencies></profile>
+          </profiles>
+        </project>"#,
+    )
+    .unwrap();
+    let cache = root.join("cache");
+    let mut model = ide_build::load(root, &cache, None);
+    for project in &mut model.maven.as_mut().unwrap().projects {
+        project.env.insert("JAVA_HOME".into(), java_home.to_string_lossy().into_owned());
+    }
+    let classpath = ide_build::compile::module_classpath(
+        root,
+        &model,
+        root,
+        false,
+        None,
+        &root.join("classpath-cache"),
+        &ide_core::CancellationToken::new(),
+    )
+    .unwrap();
+    let expected = if major <= 8 { "api-jdk8.jar" } else { "api-jdk9.jar" };
+    let other = if major <= 8 { "api-jdk9.jar" } else { "api-jdk8.jar" };
+    assert!(classpath.contains(expected), "{classpath}");
+    assert!(!classpath.contains(other), "{classpath}");
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 #[ignore = "project smoke: needs Gradle and a JDK"]
 async fn gradle_sync() {
@@ -183,7 +183,7 @@ async fn welcome_window_browses_selected_ssh_host_without_executing_commands() {
    host.remote.test_connection(&connection, "/projects").await.unwrap();
    let local = tmp.path().join("local-deployment");
    std::fs::create_dir(&local).unwrap();
-    ide_host::ops::deploy::deploy_test_connection(&host, FsConnection::Local, local.to_str().unwrap().into())
+    ide_host::ops::deploy::deploy_test_connection(&host, FsConnection::Local, local.to_str().unwrap().into(), None)
        .await
        .unwrap();
    assert_eq!(std::fs::read_dir(local).unwrap().count(), 0, "write probe is cleaned up");
@@ -223,6 +223,8 @@ impl ClientHandler {
        if self.server.running_gen(self.generation).is_some_and(|run| !run.caps.read().restriction.diagnostics()) {
            return;
        }
+        let mut params = params;
+        crate::virtual_doc::normalize_uris(&mut params);
        let params: lsp::PublishDiagnosticsParams = match serde_json::from_value(params) {
            Ok(p) => p,
            Err(e) => {
@@ -250,7 +252,14 @@ impl ClientHandler {
        {
            return;
        }
-        let shown = self.server.set_diagnostics(path.clone(), params.diagnostics);
+        // A late answer for an older version of the text is shown, but isn't fresh (`check_files`).
+        let obsolete =
+            params.version.is_some_and(|v| mgr.docs.lock().values().any(|d| d.path == path && d.version > v));
+        let shown = if obsolete {
+            self.server.set_obsolete_diagnostics(path.clone(), params.diagnostics)
+        } else {
+            self.server.set_diagnostics(path.clone(), params.diagnostics)
+        };
        mgr.emit_diagnostics(&self.server, path, shown, self.encoding());
    }

@@ -315,11 +324,13 @@ impl ClientHandler {
    }

    fn apply_edit(&self, mgr: &LspManager, params: Value) -> Result<Value, (i64, String)> {
-        let edit: lsp::WorkspaceEdit = params
-            .get("edit")
-            .cloned()
-            .ok_or_else(|| (codes::INVALID_PARAMS, "missing edit".to_owned()))
-            .and_then(|e| serde_json::from_value(e).map_err(|e| (codes::INVALID_PARAMS, e.to_string())))?;
+        let edit: lsp::WorkspaceEdit =
+            params.get("edit").cloned().ok_or_else(|| (codes::INVALID_PARAMS, "missing edit".to_owned())).and_then(
+                |mut e| {
+                    crate::virtual_doc::normalize_uris(&mut e);
+                    serde_json::from_value(e).map_err(|e| (codes::INVALID_PARAMS, e.to_string()))
+                },
+            )?;
        // Convert before calling the hook: it re-enters document sync.
        let edit = convert::workspace_edit(&mgr.conv(self.encoding()), edit);
        let applied = match mgr.apply_edit_hook() {
@@ -239,6 +239,9 @@ impl LspManager {
        cancel: &CancellationToken,
    ) -> IdeResult<DocumentCheck> {
        let snap = self.snapshot(doc)?;
+        // The text may have changed before this call synced it (the file watcher reloaded it):
+        // only diagnostics published after the servers got the current text are fresh.
+        let changed = Some(changed.map_or(snap.changed, |c| c.max(snap.changed)));
        let deadline = tokio::time::Instant::now() + timeout;
        let left = || deadline.saturating_duration_since(tokio::time::Instant::now());
        let ready = tokio::select! {
@@ -809,6 +809,21 @@ impl LspManager {
            .map_err(|e| crate::rpc_err(&server.name, "java/projectConfigurationsUpdate", e))
    }

+    /// Asks jdtls to re-read library archives replaced in place (`openidea.java.refreshArchives`):
+    /// a SNAPSHOT installed again keeps its path, and JDT would keep showing the classes it read
+    /// from the old archive. Best-effort: skipped while jdtls is not already running.
+    pub async fn java_refresh_archives(&self, path: &Path, archives: &[PathBuf]) -> IdeResult<()> {
+        let java = LanguageId::new("java");
+        let Some(server) = self.servers_for(&java, path).into_iter().find(|s| s.name == SERVER) else {
+            return Ok(());
+        };
+        if server.running().is_none() {
+            return Ok(());
+        }
+        let archives = archives.iter().map(|a| Value::String(a.to_string_lossy().into_owned())).collect();
+        self.jdtls_command(path, "openidea.java.refreshArchives", archives).await.map(|_| ())
+    }
+
    /// Pause autobuild before resolving the launch classpath. That query takes the
    /// Java project's workspace scheduling rule, draining the interrupted autobuild.
    /// Keep this guard until Maven outputs have been copied out of JDT's reach.
@@ -120,6 +120,8 @@ struct DocState {
    compose_detected: bool,
    /// The notebook a code cell belongs to: synced through `notebookDocument/*`, not as a file.
    notebook: Option<PathBuf>,
+    /// When the servers last got new text (open or change): diagnostics published before are stale.
+    changed: std::time::Instant,
 }

 impl DocState {
@@ -158,6 +160,8 @@ struct DocSnap {
    language: LanguageId,
    text: Arc<DocText>,
    servers: Vec<Arc<Server>>,
+    /// [`DocState::changed`].
+    changed: std::time::Instant,
 }

 impl DocSnap {
@@ -237,6 +241,9 @@ pub struct LspManager {
    virtual_origins: Mutex<HashMap<String, ide_core::ServerId>>,
    /// Contents fetched for virtual URIs.
    virtual_docs: Mutex<HashMap<String, VirtualDocument>>,
+    /// Modification time of the archive behind a cached library class, so a jar
+    /// replaced in place (a SNAPSHOT installed again) is read again.
+    virtual_stamps: Mutex<HashMap<String, std::time::SystemTime>>,
    injections: injections::State,
    /// Open notebooks by path. Locked before `docs` when both are.
    notebooks: Mutex<HashMap<PathBuf, notebook::NotebookState>>,
@@ -504,6 +511,7 @@ impl LspManager {
            go_mod_checked: Mutex::new(HashSet::new()),
            virtual_origins: Mutex::new(HashMap::new()),
            virtual_docs: Mutex::new(HashMap::new()),
+            virtual_stamps: Mutex::new(HashMap::new()),
            injections: injections::State::default(),
            notebooks: Mutex::new(HashMap::new()),
        })
@@ -1170,6 +1178,7 @@ impl LspManager {
            servers: servers.iter().map(|s| Attached { server: s.clone(), opened_gen: None }).collect(),
            compose_detected,
            notebook: None,
+            changed: std::time::Instant::now(),
        };
        let compose_added = {
            let mut docs = self.docs.lock();
@@ -1217,6 +1226,7 @@ impl LspManager {
        let mut docs = self.docs.lock();
        let Some(d) = docs.get_mut(&doc) else { return };
        d.version = version as i32;
+        d.changed = std::time::Instant::now();

        // Servers that have this document open on their current instance.
        let targets: Vec<(Arc<Server>, Running, SyncKind, Encoding)> = d
@@ -1392,6 +1402,7 @@ impl LspManager {
            language: d.language.clone(),
            text: d.text.clone(),
            servers,
+            changed: d.changed,
        })
    }

@@ -1433,13 +1444,9 @@ impl LspManager {
        let params = serde_json::to_value(params).map_err(|e| IdeError::internal(e.to_string()))?;
        let stamp = self.injected_request_stamp(&params);
        let fut = async {
-            if t.server.name == "csharp-ls" {
-                let mut value = t.run.peer.request::<Value, Value>(method, params, cancel.cloned()).await?;
-                virtual_doc::normalize_csharp_uris(&mut value);
-                serde_json::from_value(value).map_err(|e| RpcError::Protocol(format!("{method}: {e}")))
-            } else {
-                t.run.peer.request::<Value, R>(method, params, cancel.cloned()).await
-            }
+            let mut value = t.run.peer.request::<Value, Value>(method, params, cancel.cloned()).await?;
+            virtual_doc::normalize_uris(&mut value);
+            serde_json::from_value(value).map_err(|e| RpcError::Protocol(format!("{method}: {e}")))
        };
        let result = match tokio::time::timeout(timeout, fut).await {
            Ok(r) => r.map_err(|e| rpc_err(&t.server.name, method, e)),
@@ -3199,14 +3206,44 @@ impl LspManager {
        Ok(found)
    }

+    /// Whether the archive behind a cached library class changed since it was read.
+    /// Stats the archive: call from a blocking worker.
+    pub fn library_class_changed(&self, uri: &str) -> bool {
+        let Some(stamp) = self.virtual_stamps.lock().get(uri).copied() else { return false };
+        virtual_doc::archive_modified(uri) != Some(stamp)
+    }
+
+    /// Archives behind cached library classes that changed since they were read.
+    /// Stats each archive: call from a blocking worker.
+    pub fn changed_library_archives(&self) -> Vec<PathBuf> {
+        let uris: Vec<String> = self.virtual_stamps.lock().keys().cloned().collect();
+        let mut archives: Vec<PathBuf> = uris
+            .iter()
+            .filter(|uri| self.library_class_changed(uri))
+            .filter_map(|uri| virtual_doc::archive(uri))
+            .collect();
+        archives.sort();
+        archives.dedup();
+        archives
+    }
+
    /// Contents of a virtual document, from the server that owns `uri`:
    /// `workspace/textDocumentContent` (LSP 3.18) when the server serves the
    /// scheme, jdtls' `java/classFileContents` for `jdt:` URIs. A `jar:` entry
    /// is read from its archive, a `jar:` class shown as its library source
    /// (see [`library_source`]) or else decompiled by the server. Cached.
    pub async fn virtual_document(&self, uri: &str) -> IdeResult<VirtualDocument> {
-        if let Some(d) = self.virtual_docs.lock().get(uri) {
-            return Ok(d.clone());
+        let cached = self.virtual_docs.lock().get(uri).cloned();
+        if let Some(d) = cached {
+            let stamp = self.virtual_stamps.lock().get(uri).copied();
+            let current = {
+                let uri = uri.to_owned();
+                tokio::task::spawn_blocking(move || virtual_doc::archive_modified(&uri)).await.ok().flatten()
+            };
+            if stamp.is_none() || stamp == current {
+                return Ok(d);
+            }
+            self.virtual_docs.lock().remove(uri);
        }
        let scheme = virtual_doc::scheme(uri).to_owned();
        let jar_class = scheme == "jar" && library_source::parse(uri).is_some_and(|e| e.entry.ends_with(".class"));
@@ -3350,11 +3387,18 @@ impl LspManager {
        if let Some(server) = server {
            self.virtual_origins.lock().entry(uri.to_owned()).or_insert(server);
        }
+        let stamp = virtual_doc::archive_modified(uri);
        let mut cache = self.virtual_docs.lock();
+        let mut stamps = self.virtual_stamps.lock();
        if cache.len() >= VIRTUAL_CACHE_LIMIT {
            cache.clear();
+            stamps.clear();
        }
        cache.insert(uri.to_owned(), doc.clone());
+        match stamp {
+            Some(stamp) => stamps.insert(uri.to_owned(), stamp),
+            None => stamps.remove(uri),
+        };
        doc
    }

@@ -213,6 +213,7 @@ impl LspManager {
            {
                if d.text.as_str() != cell.source {
                    Arc::make_mut(&mut d.text).set(&cell.source);
+                    d.changed = std::time::Instant::now();
                }
                d.version += 1;
                state.cells.push((cell.id.clone(), doc));
@@ -234,6 +235,7 @@ impl LspManager {
                    servers: state.servers.iter().map(|s| Attached { server: s.clone(), opened_gen: None }).collect(),
                    compose_detected: false,
                    notebook: Some(path.to_owned()),
+                    changed: std::time::Instant::now(),
                },
            );
            state.cells.push((cell.id.clone(), doc));
@@ -259,6 +261,7 @@ impl LspManager {
            }
            Arc::make_mut(&mut d.text).set(&cell.source);
            d.version += 1;
+            d.changed = std::time::Instant::now();
            content.push(json!({
                "document": { "uri": d.uri, "version": d.version },
                "changes": [{ "text": cell.source }],
@@ -770,6 +770,20 @@ impl Server {
        self.combine(path)
    }

+    /// [`Server::set_diagnostics`] for a publication tagged with a document version older than
+    /// the text the server has now: shown, but not an answer for the current text, so
+    /// [`Server::last_published`] keeps its time.
+    pub fn set_obsolete_diagnostics(&self, path: PathBuf, items: Vec<lsp::Diagnostic>) -> Vec<lsp::Diagnostic> {
+        let before = self.last_published(&path);
+        let shown = self.set_diagnostics(path.clone(), items);
+        let mut published = self.published.lock();
+        match before {
+            Some(at) => published.insert(path, at),
+            None => published.remove(&path),
+        };
+        shown
+    }
+
    /// Records a pulled report for `path` (`None` items: unchanged since `result_id`'s
    /// predecessor); returns what the file now shows.
    pub fn set_pulled(
@@ -18,23 +18,36 @@ const URI_ESCAPES: &AsciiSet = &CONTROLS
    .add(b'|')
    .add(b'}');

-/// csharp-ls uses .NET Uri.ToString(), which can leave spaces and Unicode unescaped.
-/// Normalize only document URI fields, before lsp-types' strict URI deserialization.
-pub(crate) fn normalize_csharp_uris(value: &mut serde_json::Value) {
+/// Servers can leave spaces and Unicode unescaped in document URIs: csharp-ls uses .NET
+/// `Uri.ToString()`, and Java servers build some URIs with `java.net.URI.toString()` (which keeps
+/// non-ASCII characters), e.g. jdtls in a refactoring's edit for a project under a Chinese path.
+/// Escape them in document URI fields (and `WorkspaceEdit.changes` keys) before lsp-types' strict
+/// URI deserialization, which otherwise rejects the whole response.
+pub(crate) fn normalize_uris(value: &mut serde_json::Value) {
    match value {
-        serde_json::Value::Array(values) => values.iter_mut().for_each(normalize_csharp_uris),
+        serde_json::Value::Array(values) => values.iter_mut().for_each(normalize_uris),
        serde_json::Value::Object(fields) => {
-            for (key, value) in fields {
+            for (key, value) in fields.iter_mut() {
                // Opaque payloads must survive resolve/execute round trips unchanged.
                if matches!(key.as_str(), "data" | "arguments") {
                    continue;
                }
-                if matches!(key.as_str(), "uri" | "targetUri")
-                    && let Some(uri) = value.as_str().filter(|s| s.starts_with("csharp:"))
+                if matches!(key.as_str(), "uri" | "targetUri" | "oldUri" | "newUri")
+                    && let Some(uri) = value.as_str().and_then(escaped_uri)
                {
-                    *value = utf8_percent_encode(uri, URI_ESCAPES).to_string().into();
+                    *value = uri.into();
+                } else if key == "changes"
+                    && let serde_json::Value::Object(changes) = value
+                {
+                    *changes = std::mem::take(changes)
+                        .into_iter()
+                        .map(|(uri, mut edits)| {
+                            normalize_uris(&mut edits);
+                            (escaped_uri(&uri).unwrap_or(uri), edits)
+                        })
+                        .collect();
                } else {
-                    normalize_csharp_uris(value);
+                    normalize_uris(value);
                }
            }
        }
@@ -42,6 +55,16 @@ pub(crate) fn normalize_csharp_uris(value: &mut serde_json::Value) {
    }
 }

+/// `uri` with the characters a URI can't hold escaped; `None` when nothing changes or it is
+/// not a document URI this applies to (other schemes are passed back to servers as given).
+fn escaped_uri(uri: &str) -> Option<String> {
+    if !(uri.starts_with("file:") || uri.starts_with("csharp:")) {
+        return None;
+    }
+    let escaped = utf8_percent_encode(uri, URI_ESCAPES).to_string();
+    (escaped != uri).then_some(escaped)
+}
+
 #[derive(serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct CSharpMetadata {
@@ -149,6 +172,20 @@ pub fn description(uri: &str) -> Option<String> {
    }
 }

+/// The archive a `jar:` or `jdt:` library class comes from.
+pub(crate) fn archive(uri: &str) -> Option<std::path::PathBuf> {
+    match scheme(uri) {
+        "jar" => Some(crate::library_source::parse(uri)?.jar),
+        "jdt" => description(uri).filter(|p| p.ends_with(".jar") || p.ends_with(".jmod")).map(Into::into),
+        _ => None,
+    }
+}
+
+/// Modification time of the archive a `jar:` or `jdt:` library class comes from.
+pub(crate) fn archive_modified(uri: &str) -> Option<std::time::SystemTime> {
+    std::fs::metadata(archive(uri)?).and_then(|m| m.modified()).ok()
+}
+
 /// Check both the package and actual archive, so duplicate type names never pick another jar.
 pub(crate) fn matches_class(uri: &str, jar: &std::path::Path, package: &str, name: &str) -> bool {
    let segs = segments(uri);
@@ -202,7 +239,7 @@ mod tests {
            { "data": { "uri": uri }, "command": { "arguments": [{ "targetUri": uri }] } }
        ]);
        let original = response.clone();
-        normalize_csharp_uris(&mut response);
+        normalize_uris(&mut response);
        assert_eq!(response[0]["uri"], encoded);
        assert_eq!(response[0]["source"], uri);
        assert_eq!(response[1]["location"]["targetUri"], encoded);
@@ -210,6 +247,31 @@ mod tests {
        assert!(encoded.parse::<lsp_types::Uri>().is_ok());
    }

+    /// #3089: jdtls's Introduce Variable edit for a project under a Chinese path names the file
+    /// with the characters unescaped, and the resolved code action failed to deserialize.
+    #[test]
+    fn file_uris_with_unicode_and_spaces_deserialize_in_workspace_edits() {
+        let uri = "file:///C:/项目/my app/src/A.java";
+        let encoded = "file:///C:/%E9%A1%B9%E7%9B%AE/my%20app/src/A.java";
+        let edit = serde_json::json!([{ "range": { "start": { "line": 0, "character": 0 }, "end": { "line": 0, "character": 0 } }, "newText": "x" }]);
+        let mut action = serde_json::json!({
+            "title": "Extract to local variable",
+            "edit": {
+                "documentChanges": [{ "textDocument": { "uri": uri, "version": 3 }, "edits": edit }],
+                "changes": { (uri): edit },
+            },
+            "data": { "uri": uri },
+        });
+        assert!(serde_json::from_value::<lsp_types::CodeAction>(action.clone()).is_err());
+        normalize_uris(&mut action);
+        let action: lsp_types::CodeAction = serde_json::from_value(action.clone()).unwrap();
+        let edit = action.edit.unwrap();
+        let Some(lsp_types::DocumentChanges::Edits(edits)) = edit.document_changes else { panic!() };
+        assert_eq!(edits[0].text_document.uri.as_str(), encoded);
+        assert_eq!(edit.changes.unwrap().keys().next().unwrap().as_str(), encoded);
+        assert_eq!(action.data.unwrap()["uri"], uri, "opaque data is passed back unchanged");
+    }
+
    #[test]
    fn jdt_titles() {
        assert_eq!(title(JDT, true), "SpringApplication.class");
@@ -256,6 +318,29 @@ mod tests {
        assert_eq!(description("foo://x/y"), None);
    }

+    #[test]
+    fn finds_the_archive_behind_a_library_class() {
+        assert_eq!(archive(JDT), Some("/Users/me/.m2/repository/spring-boot-4.1.1.jar".into()));
+        assert_eq!(
+            archive("jdt://contents/java.base/java.lang/String.class?=p/%5C/jdk%5C/lib%5C/jrt-fs.jar%60java.base=x"),
+            None
+        );
+        assert_eq!(archive("jdt://contents/a.jar/p/C.class"), None);
+        assert_eq!(archive("file:///a/C.java"), None);
+
+        let dir = tempfile::tempdir().unwrap();
+        let jar = dir.path().join("lib-1.0-SNAPSHOT.jar");
+        std::fs::write(&jar, b"PK").unwrap();
+        let uri = format!("jar:file://{}!/p/C.class", jar.display());
+        assert_eq!(archive(&uri), Some(jar.clone()));
+        let before = archive_modified(&uri).unwrap();
+        let file = std::fs::File::options().write(true).open(&jar).unwrap();
+        file.set_modified(before + std::time::Duration::from_secs(5)).unwrap();
+        assert_ne!(archive_modified(&uri), Some(before));
+        std::fs::remove_file(&jar).unwrap();
+        assert_eq!(archive_modified(&uri), None);
+    }
+
    #[test]
    fn detects_generated_code() {
        assert!(is_decompiled(
@@ -2204,6 +2204,25 @@ async fn checking_a_document_saves_it_and_waits_for_fresh_diagnostics() {
    let stale = h.mgr.check_document(doc, changed, Duration::from_millis(800), &cancel).await.unwrap();
    assert!(stale.servers[0].checked && stale.servers[0].incomplete, "{:?}", stale.servers);
    assert_eq!(stale.diagnostics.len(), 1);
+
+    // The text changed before the call (the file watcher reloaded it), so the caller saw no
+    // change of its own: the old publication is still not fresh.
+    h.mgr.did_change(doc, 2, &[change(rng(0, 0, 0, 3), "good")], &|| "good\n".to_owned());
+    let reloaded = h.mgr.check_document(doc, None, Duration::from_millis(800), &cancel).await.unwrap();
+    assert!(reloaded.servers[0].incomplete, "{:?}", reloaded.servers);
+
+    // A late publication tagged with the old version is no answer for the current text.
+    s.peer()
+        .notify("textDocument/publishDiagnostics", json!({ "uri": uri_of(&path), "version": 1, "diagnostics": [] }))
+        .unwrap();
+    let late = h.mgr.check_document(doc, None, Duration::from_millis(800), &cancel).await.unwrap();
+    assert!(late.servers[0].incomplete, "{:?}", late.servers);
+    // One for the current version is.
+    s.peer()
+        .notify("textDocument/publishDiagnostics", json!({ "uri": uri_of(&path), "version": 2, "diagnostics": [] }))
+        .unwrap();
+    let fresh = h.mgr.check_document(doc, None, Duration::from_secs(5), &cancel).await.unwrap();
+    assert!(fresh.servers[0].checked && !fresh.servers[0].incomplete, "{:?}", fresh.servers);
 }

 #[tokio::test(flavor = "multi_thread")]
@@ -1,6 +1,7 @@
 //! `<app-data>/mcp/server.json`: where the running IDE's server listens and
 //! its token, for the stdio bridge. Readable only by the user; removed when
-//! the server stops.
+//! the server stops. `<app-data>/mcp/token` keeps the token across runs when
+//! the user chose a fixed token.

 use serde::{Deserialize, Serialize};
 use std::io;
@@ -14,6 +15,28 @@ pub fn discovery_path(app_data: &Path) -> PathBuf {
    app_data.join(DISCOVERY_FILE)
 }

+/// The kept token, relative to the app data directory.
+pub const TOKEN_FILE: &str = "mcp/token";
+
+/// The kept token of the IDE whose app data directory is `app_data`.
+pub fn token_path(app_data: &Path) -> PathBuf {
+    app_data.join(TOKEN_FILE)
+}
+
+/// The token kept at `path`; a new one is made and kept there when there is none (or the
+/// file doesn't hold one). Readable only by the user.
+pub fn kept_token(path: &Path) -> io::Result<String> {
+    if let Ok(text) = std::fs::read_to_string(path) {
+        let token = text.trim();
+        if token.len() == 64 && token.bytes().all(|b| b.is_ascii_hexdigit()) {
+            return Ok(token.to_owned());
+        }
+    }
+    let token = crate::server::new_token()?;
+    write_atomic(path, token.as_bytes())?;
+    Ok(token)
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Discovery {
    pub port: u16,
@@ -32,15 +55,8 @@ impl Discovery {

    /// Writes the file atomically, readable only by the user.
    pub fn write(&self, path: &Path) -> io::Result<()> {
-        let dir = path.parent().ok_or_else(|| io::Error::other("no parent directory"))?;
-        std::fs::create_dir_all(dir)?;
-        let tmp = path.with_extension(format!("tmp{}", std::process::id()));
        let bytes = serde_json::to_vec_pretty(self).map_err(io::Error::other)?;
-        let written = write_private(&tmp, &bytes).and_then(|()| std::fs::rename(&tmp, path));
-        if written.is_err() {
-            let _ = std::fs::remove_file(&tmp);
-        }
-        written
+        write_atomic(path, &bytes)
    }

    /// Removes the file at `path` if it still describes this process's server.
@@ -51,6 +67,18 @@ impl Discovery {
    }
 }

+/// Writes `bytes` to `path` atomically, readable only by the user.
+fn write_atomic(path: &Path, bytes: &[u8]) -> io::Result<()> {
+    let dir = path.parent().ok_or_else(|| io::Error::other("no parent directory"))?;
+    std::fs::create_dir_all(dir)?;
+    let tmp = path.with_extension(format!("tmp{}", std::process::id()));
+    let written = write_private(&tmp, bytes).and_then(|()| std::fs::rename(&tmp, path));
+    if written.is_err() {
+        let _ = std::fs::remove_file(&tmp);
+    }
+    written
+}
+
 #[cfg(unix)]
 fn write_private(path: &Path, bytes: &[u8]) -> io::Result<()> {
    use std::io::Write;
@@ -91,4 +119,23 @@ mod tests {
        Discovery::remove_if_ours(&path);
        assert!(!path.exists());
    }
+
+    #[test]
+    fn keeps_one_token_until_its_file_is_removed() {
+        let tmp = tempfile::tempdir().unwrap();
+        let path = token_path(tmp.path());
+        let first = kept_token(&path).unwrap();
+        assert_eq!(first.len(), 64);
+        assert_eq!(kept_token(&path).unwrap(), first, "the same token on the next run");
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
+        }
+        std::fs::write(&path, "not a token").unwrap();
+        let replaced = kept_token(&path).unwrap();
+        assert_ne!(replaced, first);
+        std::fs::remove_file(&path).unwrap();
+        assert_ne!(kept_token(&path).unwrap(), replaced, "a removed token is made anew");
+    }
 }
@@ -22,8 +22,8 @@ mod protocol;
 mod server;
 pub mod stdio;

-pub use discovery::{DISCOVERY_FILE, Discovery, discovery_path};
-pub use server::McpServer;
+pub use discovery::{DISCOVERY_FILE, Discovery, TOKEN_FILE, discovery_path, kept_token, token_path};
+pub use server::{McpServer, ServerOptions};
 pub use tokio_util::sync::CancellationToken;

 use std::path::{Path, PathBuf};
@@ -49,12 +49,25 @@ struct Shared {
 /// removes its discovery file.
 pub struct McpServer {
    port: u16,
+    /// Why the port asked for in [`ServerOptions::port`] was not used.
+    port_unavailable: Option<String>,
    token: String,
    discovery: Option<PathBuf>,
    shutdown: watch::Sender<bool>,
    cancel: CancellationToken,
 }

+/// How [`McpServer::start_with`] listens.
+#[derive(Clone, Debug, Default)]
+pub struct ServerOptions {
+    /// Listen on `127.0.0.1:<port>`. When it can't be bound (in use, or reserved by the
+    /// system), a free port is taken instead and [`McpServer::port_unavailable`] says why.
+    /// `None`: a free port.
+    pub port: Option<u16>,
+    /// The bearer token; `None`: a new one.
+    pub token: Option<String>,
+}
+
 impl McpServer {
    /// Starts listening on `127.0.0.1:<random port>` with a new token, on
    /// `runtime`, and writes the discovery file at `discovery` if given.
@@ -63,10 +76,32 @@ impl McpServer {
        discovery: Option<PathBuf>,
        runtime: &tokio::runtime::Handle,
    ) -> std::io::Result<Self> {
-        let listener = std::net::TcpListener::bind(("127.0.0.1", 0))?;
+        Self::start_with(registry, discovery, runtime, ServerOptions::default())
+    }
+
+    /// [`Self::start`] on the port and with the token of `options`.
+    pub fn start_with(
+        registry: Arc<dyn ToolRegistry>,
+        discovery: Option<PathBuf>,
+        runtime: &tokio::runtime::Handle,
+        options: ServerOptions,
+    ) -> std::io::Result<Self> {
+        let (listener, port_unavailable) = match options.port {
+            Some(port) => match std::net::TcpListener::bind(("127.0.0.1", port)) {
+                Ok(listener) => (listener, None),
+                Err(e) => {
+                    tracing::warn!("MCP server: port {port} unavailable ({e}); taking a free one");
+                    (std::net::TcpListener::bind(("127.0.0.1", 0))?, Some(format!("port {port}: {e}")))
+                }
+            },
+            None => (std::net::TcpListener::bind(("127.0.0.1", 0))?, None),
+        };
        listener.set_nonblocking(true)?;
        let port = listener.local_addr()?.port();
-        let token = new_token()?;
+        let token = match options.token {
+            Some(token) => token,
+            None => new_token()?,
+        };
        let listener = {
            let _entered = runtime.enter();
            tokio::net::TcpListener::from_std(listener)?
@@ -91,13 +126,18 @@ impl McpServer {
        });
        runtime.spawn(accept(listener, shared, stopped));
        tracing::info!("MCP server on 127.0.0.1:{port}");
-        Ok(Self { port, token, discovery, shutdown, cancel })
+        Ok(Self { port, port_unavailable, token, discovery, shutdown, cancel })
    }

    pub fn port(&self) -> u16 {
        self.port
    }

+    /// Why the port of [`ServerOptions::port`] is not the one listened on.
+    pub fn port_unavailable(&self) -> Option<&str> {
+        self.port_unavailable.as_deref()
+    }
+
    /// The bearer token of this run.
    pub fn token(&self) -> &str {
        &self.token
@@ -1,7 +1,7 @@
 //! The server over real HTTP, and the stdio bridge in front of it, with a
 //! registry standing in for the IDE host.

-use ide_mcp::{Discovery, McpServer, Tool, ToolCallError, ToolRegistry, discovery_path, stdio};
+use ide_mcp::{Discovery, McpServer, ServerOptions, Tool, ToolCallError, ToolRegistry, discovery_path, stdio};
 use serde_json::{Value, json};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
@@ -366,3 +366,30 @@ async fn a_cancellation_that_arrives_before_the_call_is_remembered() {
    let (_, body) = post(&s, "/mcp", &headers, &call).await;
    assert_eq!(serde_json::from_str::<Value>(&body).unwrap()["result"]["isError"], true);
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn a_fixed_port_and_token_are_used_and_a_taken_port_falls_back_to_a_free_one() {
+    let mut s = setup();
+    s.server.take().unwrap().stop();
+    let free = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap().local_addr().unwrap().port();
+    let token = "ab".repeat(32);
+    let options = ServerOptions { port: Some(free), token: Some(token.clone()) };
+    let registry = Arc::new(Registry { project: s.project.clone() });
+    let runtime = tokio::runtime::Handle::current();
+    s.server =
+        Some(McpServer::start_with(registry.clone(), Some(s.discovery.clone()), &runtime, options.clone()).unwrap());
+    assert_eq!((s.server().port(), s.server().token()), (free, token.as_str()));
+    assert!(s.server().port_unavailable().is_none());
+    assert_eq!(Discovery::read(&s.discovery).unwrap().port, free);
+    let list = rpc(&s, "tools/list", json!({})).await;
+    assert_eq!(list["result"]["tools"][0]["name"], "echo");
+
+    // The port is taken (by the first server): a second one listens elsewhere and says why.
+    let second = McpServer::start_with(registry, None, &runtime, options).unwrap();
+    assert_ne!(second.port(), free);
+    assert!(
+        second.port_unavailable().is_some_and(|why| why.contains(&free.to_string())),
+        "{:?}",
+        second.port_unavailable()
+    );
+}
@@ -922,6 +922,9 @@ pub struct FileDecoration {
    pub badge: Option<String>,
    pub style: String,
    pub tooltip: Option<String>,
+    /// Text shown after the name (API 1.7 `set-file-note`).
+    #[serde(default)]
+    pub note: Option<String>,
 }
 /// Commit metadata, date in Unix seconds.
 #[derive(Clone, Debug, Serialize, Deserialize, Type)]
@@ -2497,7 +2497,7 @@ impl bindings::openidea::plugin::decorations::Host for StoreData {
            .file_decorations(
                Some(&real),
                &set_id,
-                Some(crate::FileDecoration { badge: item.badge, style: item.style, tooltip: item.tooltip }),
+                Some(crate::FileDecoration { badge: item.badge, style: item.style, tooltip: item.tooltip, note: None }),
            )
            .map_err(to_wit))
    }
@@ -2507,6 +2507,17 @@ impl bindings::openidea::plugin::decorations::Host for StoreData {
        }
        Ok(self.host.file_decorations(None, &set_id, None).map_err(to_wit))
    }
+    fn set_file_note(&mut self, path: String, set_id: String, note: String, tooltip: Option<String>) -> Fallible<()> {
+        if let Err(e) = self.require(Capability::ProjectRead) {
+            return Ok(Err(e));
+        }
+        let real = match self.decoration_path(&path) {
+            Ok(real) => real,
+            Err(e) => return Ok(Err(e)),
+        };
+        let item = crate::FileDecoration { badge: None, style: String::new(), tooltip, note: Some(note) };
+        Ok(self.host.file_decorations(Some(&real), &set_id, Some(item)).map_err(to_wit))
+    }
 }

 pub(crate) mod language_features_bindings {
@@ -1 +1 @@
-3c7f35facd15ee8380ccb6475b7c051d500e38346b711e1805077becd0c75f75
+d6c855f1f91aeb02eec5d6c8a07be4eb64bae0704619f44cb67f3b832daf01ee
@@ -1 +1 @@
-3879822d975695c6258e95286b0e64c5ee1e3265876501efaf0e577b38f8222b
+51d00702c42c7167083caea70cf2df022e512bcaf89af8addf526421ff45a15f
@@ -1 +1 @@
-228ae888bf556ce5cedc7843eb20e92f221d9e1f640f3c6c595bed3fd6be6051
+40d2fd76ba96b0c93ea0a034c6749709ddc00fc119046e653a50b180a9c4718d
@@ -1 +1 @@
-41de239b6f723020b38eb2b67f642b7c88cc88c79117c3072ba122633afc418c
+08822287f3649412340f9dbbe2f0ea5a5cd2f543a3c242c5d0a29c422c4c5367
@@ -1 +1 @@
-78c5ed3c756498c7619b46c3622ae7a59461c61c747b45caecd79b341ee654de
+43eba23cc14cf3c74bfc934099cd58df20f07ee5df96cc10100b90016c544a7a
@@ -1 +1 @@
-ee848321e53cb181536e6158570dbb4ab02a6fd2a1a064b068803ac7da7f3448
+520d9a95328dc772bbb913a2e5e22af8243c95ca45744cbb65b25747653d2a34
@@ -1 +1 @@
-b587de945875a98f1d4ca20fab7cf94fb4dc6d848136aa19ab0e0e5319155a80
+acd3d0ee3f886c6a271ce3139200ce5bdb46e40f9c68e495c5ff9b4db98a88ac
@@ -1 +1 @@
-1c8776dcae35d2d49dd6c1e32b0cdd354de1eb0f72a473245a2c47368b89ec30
+0cf3bc2197f0bd5339fe3c2199bd973e68b3637b8c5ae07902e62659160275e3
@@ -1 +1 @@
-2a517cbffd6d3cdda37117d8ca8815978a09995923fc3d5aa5af7020afdac56a
+17f837c8d6f58800728e00060afe68b2a093085d816d809c9e67065fdd165352
@@ -1 +1 @@
-dbd912b1f8488ecd446af07b5dcaef55d44bce57c1a55be5c0b0fb33e2697903
+2cca80220fab6764a8e1f51db8ed2f55b603000c8d0dbf5913a441876b7857ba
@@ -1 +1 @@
-efdc84cd2bedb3989b03d19b569d09958f26e502db65db4dd786eb3438a7c407
+54211437002ad83a9d3d642f2dca5f37cadd89d7d77ddc7de545db87b99fb8b7
@@ -1 +1 @@
-be6bc15ee42a5e21781ba54f548007351a46b669882ee4491da20ff556927a06
+4326d9cdefe71f4bb9aab043ccef883abbd13145b1579352b97c66889f514c68
@@ -1 +1 @@
-e5c3a3beda750dff27d7b823676d53f15b7c76b8ad539594cd913bd178d750da
+2469023f4f29b9abdaa27c9d96774229c4dd002366421dc508926c3fed1fba1b
@@ -1 +1 @@
-322de3299f0413101c02358836e7df7e06e58cbb22c11897664564abbb8af090
+233461ab52a12e27fa600e108e83cab1b930b3e61812e0c048c99c1e18c6d646
@@ -1 +1 @@
-d768ff6a4a466cc6f1d72499df3ccb4ae76872436b8eddff27f62aa156331a37
+bfc654523da608bbc008ea6a15a0cfd0b129ffab70088bf6b610786b63b5352e
@@ -1 +1 @@
-57aea107b2c10e4d30fa3785ac4c6566f1b40908a18a3859aca8be047fac9518
+c8536be072d27aa89f5e92b5b96e38ed65b7f06c35c05ecbd4a151218203c5f7
@@ -1 +1 @@
-c98bcc89750e26e738d7115a7c0454fde25367a0a23bdc2ff95fb5a5dacc9f98
+7c0c1f5035e12c794d48cb75a8fc259d11dd99ba3188030fe1d9956720ee6ad5
@@ -1 +1 @@
-a4c23b93a14eda705cb18c88bbc2373d1ef3f96031ff2df21b8b092b50633996
+3cf5fd6ab0ce909b806230e20a7fa46264f85937018cfa68865ec0eeb92d4b72
@@ -1 +1 @@
-aec002b3dd310068e69a6ae67a49d30655bf8baea9153a110a407e9d408e6880
+d349977fd3cbfba92d1d953ac09f65dae5b83b7070723b59553d791c638acf81
@@ -1 +1 @@
-08ece563c3b55c2b86e68fbb0815ddcbb63beb6f1f6c32b8dbdbee558a4a66c1
+e796039ae2f8e534ffc8c2ed2e47e910aaf593c464525287699cf1daf3e195ef
@@ -1 +1 @@
-450845edf234a1cc78cd6cfc0b812a89f3a2e41484689cc1e1b05be66873d4eb
+5e084fa409bb0641409110d91f203a6f99b451b95cd8067bd1ee68140bf8a892
@@ -1 +1 @@
-61b735de5ef61dcd0ea8e640c2ad004e84a63fe4dfd7872ffb5e04d6d81dc9a9
+521557c1a062a9b82afa14547bc54b57255cdbed3b2ab4b1b86424dfb8accbdc
@@ -1 +1 @@
-36776367782eaa4b8b8121f4a665dd8e68525a4836bff1c92bc16770cce14929
+5280990269e944aef81ec91b356fadf4aa2fc7e7bb10e4b6842e1dc1c669704a
@@ -1 +1 @@
-f6311d232a99356b02a398b2ce3db0865c425f435a8d201157719178ba2b97c7
+ff1391d3c9338b6270fef8af7d7c4a5bc595c391997c220a3a827b4b8a068de8
@@ -1 +1 @@
-fe1d26665e3c816ed43fc720acabad03a37b7924bccd4dd8c357fd156947b3c7
+b78ac0b6fa14401a6379f3e6d07d1398a63d70e882930b3747ec843c0fdb5de7
@@ -1 +1 @@
-76bab8e48235f9f066f5b9bbfdd9398916b6c3ed73c072c543d80595130519f7
+55331477c1d5322b0dc35d13fc7f8223bf697f5f21328d340f75519dd1098727
@@ -1 +1 @@
-f9ed2eac306229f76b05d0c4a4fb2f0ed8d81a1dfc5eb50d044bbe10c9206a5f
+0ae6b7edd0d7cd5025ead4a4afacf0fbe3ebc9548d847f94be0e63585a19747e
@@ -1 +1 @@
-f2d83d9f56da072d38a1552195af8a9d4edc11888c645627d5dd1e4a46afc4df
+5d909d6ab2e73fabba2d213a944546ef7e425552852cf7f74e00eb94c9d167ac
@@ -80,6 +80,11 @@ impl RemoteService {
    }

    async fn fs(&self, connection: &FsConnection) -> IdeResult<RemoteFs> {
+        self.fs_with(connection, None).await
+    }
+
+    /// Like [`Self::fs`], with an FTP password typed but not saved yet (`None`: the saved one).
+    async fn fs_with(&self, connection: &FsConnection, password: Option<String>) -> IdeResult<RemoteFs> {
        match connection {
            FsConnection::Local => Ok(RemoteFs::Local),
            FsConnection::Sftp { ssh } => {
@@ -90,14 +95,24 @@ impl RemoteService {
                Ok(RemoteFs::new(session.sftp().await?).with_shell(session))
            }
            FsConnection::Ftp { server, secure, ftp } => {
-                let password = self.ssh.password(&ide_ssh::ftp::secret_key(server));
+                let password = password.or_else(|| self.ssh.password(&ide_ssh::ftp::secret_key(server)));
                Ok(RemoteFs::Ftp(ide_ssh::ftp::FtpFs::connect(ftp, *secure, password).await?))
            }
        }
    }

    pub async fn test_connection(&self, connection: &FsConnection, path: &str) -> IdeResult<()> {
-        let fs = self.fs(connection).await?;
+        self.test_connection_with(connection, path, None).await
+    }
+
+    /// Tests `connection` with an FTP password the settings have not saved yet.
+    pub async fn test_connection_with(
+        &self,
+        connection: &FsConnection,
+        path: &str,
+        password: Option<String>,
+    ) -> IdeResult<()> {
+        let fs = self.fs_with(connection, password).await?;
        let result = fs.test(path).await;
        fs.close().await;
        result
@@ -323,6 +323,18 @@ fn resolve_gradle_command(root: &Path, build_dir: &Path, s: &Settings, use_wrapp
    }
    let wrapper = build_dir.join(if cfg!(windows) { "gradlew.bat" } else { "gradlew" });
    if use_wrapper && wrapper.is_file() {
+        // `gradlew` can't start without its jar, which `.gitignore`s with `*.jar` often leave
+        // out: run the distribution the wrapper already unpacked instead.
+        if build_dir.join("gradle/wrapper/gradle-wrapper.jar").is_file() {
+            return wrapper;
+        }
+        let home = setting_path(root, &g.user_home)
+            .or_else(|| std::env::var_os("GRADLE_USER_HOME").map(PathBuf::from))
+            .or_else(|| Some(crate::home_dir()?.join(".gradle")));
+        if let Some(gradle) = home.and_then(|home| unpacked_wrapper_distribution(build_dir, &home)) {
+            return gradle;
+        }
+        // Nothing to run instead: the wrapper's failure explains what is missing.
        return wrapper;
    }
    pinned::pinned_install(build_dir, Tool::Gradle)
@@ -330,6 +342,21 @@ fn resolve_gradle_command(root: &Path, build_dir: &Path, s: &Settings, use_wrapp
        .unwrap_or_else(|| name.into())
 }

+/// `bin/gradle` of the distribution `gradle/wrapper/gradle-wrapper.properties` names, once the
+/// wrapper has unpacked it in `<gradle_user_home>/wrapper/dists` (and marked it complete).
+fn unpacked_wrapper_distribution(build_dir: &Path, gradle_user_home: &Path) -> Option<PathBuf> {
+    let properties = std::fs::read_to_string(build_dir.join("gradle/wrapper/gradle-wrapper.properties")).ok()?;
+    let url = properties.lines().find_map(|line| line.trim().strip_prefix("distributionUrl="))?;
+    let zip = url.trim().replace("\\:", ":").rsplit('/').next()?.to_owned();
+    let name = zip.strip_suffix(".zip")?;
+    let gradle = if cfg!(windows) { "gradle.bat" } else { "gradle" };
+    // One directory per distribution URL hash, each holding the unpacked `gradle-<version>`.
+    let hashes = std::fs::read_dir(gradle_user_home.join("wrapper/dists").join(name)).ok()?;
+    hashes.flatten().map(|e| e.path()).filter(|dir| dir.join(format!("{zip}.ok")).is_file()).find_map(|dir| {
+        std::fs::read_dir(&dir).ok()?.flatten().map(|e| e.path().join("bin").join(gradle)).find(|p| p.is_file())
+    })
+}
+
 fn gradle_run_jdk<'a>(
    release: Option<u32>,
    configured: Option<&'a crate::java::Jdk>,
@@ -350,6 +377,11 @@ fn gradle_run_jdk<'a>(
    })
 }

+/// The newest installed JDK that Gradle `gradle` runs on.
+fn newest_gradle_jdk(gradle: (u32, u32), installed: &[crate::java::Jdk]) -> Option<&crate::java::Jdk> {
+    installed.iter().filter(|jdk| gradle_supports_java(gradle, jdk.major)).max_by_key(|jdk| jdk.major)
+}
+
 /// Default environment shared by Gradle model builds and Run configurations.
 pub fn gradle_build_env(
    root: &Path,
@@ -466,7 +498,17 @@ pub fn configure_gradle_runtime(cfg: &mut LanguageServerConfig, root: &Path, bui
        .any(|f| build_dir.join(f).is_file());
    let env = if gradle_build {
        let command = gradle_command(root, build_dir, s);
-        gradle_build_env(root, build_dir, &command.to_string_lossy(), s, None)
+        let command = command.to_string_lossy();
+        let mut env = gradle_build_env(root, build_dir, &command, s, None);
+        // No Project JDK and no Java version the build declares: jdtls would import on its own
+        // runtime, which an older Gradle cannot run on. Use an installed JDK this Gradle supports.
+        if !env.contains_key("JAVA_HOME")
+            && let Some(gradle) = gradle_distribution_version(build_dir, &command)
+            && let Some(jdk) = newest_gradle_jdk(gradle, &crate::java::installed_jdks())
+        {
+            env.insert("JAVA_HOME".into(), jdk.home.to_string_lossy().into_owned());
+        }
+        env
    } else {
        gradle_env(root, s, Default::default())
    };
@@ -2001,6 +2043,11 @@ mod gradle_runtime_tests {
        assert_eq!(gradle_run_jdk(Some(21), None, &installed, None).unwrap().major, 21);
        assert_eq!(gradle_run_jdk(Some(19), None, &installed, None).unwrap().major, 21);
        assert!(gradle_run_jdk(None, None, &installed, None).is_none());
+        // The Java import of a build that declares no Java version still needs a JVM its Gradle runs on.
+        assert_eq!(newest_gradle_jdk((8, 4), &installed).unwrap().major, 17);
+        assert_eq!(newest_gradle_jdk((7, 2), &installed).unwrap().major, 11);
+        assert_eq!(newest_gradle_jdk((9, 1), &installed).unwrap().major, 25);
+        assert!(newest_gradle_jdk((9, 0), &installed[4..]).is_none());
    }

    #[test]
@@ -1547,7 +1547,7 @@ pub fn usages_bundle(data_dir: &Path) -> Option<PathBuf> {
    install_bundle(
        data_dir,
        "java-usages",
-        "1.13.0",
+        "1.14.0",
        include_bytes!("../../../java/java-usages/openidea-java-usages.jar"),
    )
 }
@@ -1866,6 +1866,37 @@ fn max_java_picks_an_older_jdk() {
    assert_eq!(free.env["JAVA_HOME"], j25.home.to_string_lossy());
 }

+/// #3086: `gradle-wrapper.jar` excluded by a `*.jar` rule in `.gitignore`: `gradlew` can't
+/// start, so the distribution the wrapper already unpacked runs instead.
+#[test]
+fn gradle_wrapper_without_its_jar_runs_the_unpacked_distribution() {
+    use crate::apply::gradle_command;
+    let tmp = tempfile::tempdir().unwrap();
+    let root = tmp.path();
+    let plain = if cfg!(windows) { "gradle.bat" } else { "gradle" };
+    let wrapper = root.join(if cfg!(windows) { "gradlew.bat" } else { "gradlew" });
+    std::fs::write(&wrapper, "").unwrap();
+    std::fs::create_dir_all(root.join("gradle/wrapper")).unwrap();
+    std::fs::write(
+        root.join("gradle/wrapper/gradle-wrapper.properties"),
+        "distributionUrl=https\\://services.gradle.org/distributions/gradle-4.10-bin.zip\n",
+    )
+    .unwrap();
+    let mut settings = Settings::default();
+    settings.languages.java.gradle.user_home = "user-home".into();
+    let hash = root.join("user-home/wrapper/dists/gradle-4.10-bin/7ddd1b3f");
+    let gradle = hash.join("gradle-4.10/bin").join(plain);
+    std::fs::create_dir_all(gradle.parent().unwrap()).unwrap();
+    std::fs::write(&gradle, "").unwrap();
+    // Not marked complete: possibly half unpacked.
+    assert_eq!(gradle_command(root, root, &settings), wrapper);
+    std::fs::write(hash.join("gradle-4.10-bin.zip.ok"), "").unwrap();
+    assert_eq!(gradle_command(root, root, &settings), gradle);
+    // With its jar the wrapper runs as usual.
+    std::fs::write(root.join("gradle/wrapper/gradle-wrapper.jar"), "").unwrap();
+    assert_eq!(gradle_command(root, root, &settings), wrapper);
+}
+
 #[test]
 fn gradle_settings_precedence() {
    use crate::apply::{gradle_command, gradle_env};
@@ -110,6 +110,11 @@ impl SshManager {
        self.entered.lock().get(key).cloned().or_else(|| self.saved.get(key))
    }

+    /// Whether a password is saved under `key` (not one only entered this session).
+    pub fn password_saved(&self, key: &str) -> bool {
+        self.saved.get(key).is_some()
+    }
+
    /// The known password / passphrase of configuration `id`.
    pub fn secret(&self, config: &SshConfiguration) -> Option<String> {
        if let Some(s) = self.entered.lock().get(&config.id) {
@@ -281,6 +281,9 @@ impl Repo {
        let commitish = arg(commitish, "revision")?;
        let mut args: Vec<String> = vec!["worktree".into(), "add".into()];
        if let Some(b) = new_branch.map(str::trim).filter(|b| !b.is_empty()) {
+            if crate::write::renamed_remote_start(self, b, &commitish) {
+                args.push("--no-track".into());
+            }
            args.extend(["-b".into(), arg(b, "branch name")?]);
        }
        args.extend(["--".into(), path, commitish]);
@@ -800,16 +800,41 @@ pub(crate) fn create_branch(
        let repo = r.gix()?;
        resolve(&repo, s)?;
    }
+    let no_track = start.is_some_and(|s| renamed_remote_start(r, name, s));
    let mut args = match (checkout, overwrite) {
        (true, false) => vec!["switch", "-c", name],
        (true, true) => vec!["switch", "-C", name],
-        (false, false) => vec!["branch", "--", name],
-        (false, true) => vec!["branch", "--force", "--", name],
+        (false, false) => vec!["branch"],
+        (false, true) => vec!["branch", "--force"],
    };
+    if no_track {
+        args.push("--no-track");
+    }
+    if !checkout {
+        args.extend(["--", name]);
+    }
    args.extend(start);
    run(r.root(), &args, None).map(|_| ())
 }

+/// Whether `start` is a remote-tracking branch with another name than the new branch
+/// `name`. Git would make it the upstream, so pushing the new branch would go to the
+/// start branch (`feature` from `origin/main` pushes to `main`); such a branch is left
+/// without upstream and gets its own one on the first push. A remote branch under the
+/// same name stays tracked.
+pub(crate) fn renamed_remote_start(r: &Repo, name: &str, start: &str) -> bool {
+    let Ok(out) = cli::run_raw(r.root(), &["rev-parse", "--verify", "--quiet", "--symbolic-full-name", start], None)
+    else {
+        return false;
+    };
+    let full = out.stdout_str().trim().to_string();
+    let Some(rest) = full.strip_prefix("refs/remotes/").filter(|_| out.code == Some(0)) else { return false };
+    let Ok(repo) = r.gix() else { return false };
+    let names = repo.remote_names();
+    let branch = names.iter().find_map(|remote| rest.strip_prefix(&format!("{remote}/")));
+    branch.is_some_and(|b| b != name)
+}
+
 /// Undo Commit: moves the current branch back to the parent of `commit` (which must be
 /// HEAD), keeping its changes staged. Returns the undone commit's message.
 /// Edit Commit Message: writes `commit` again with `message`, and its descendants on top
@@ -984,15 +984,41 @@ fn branch_overwrite_preserves_the_ref_if_checkout_fails() {
 }

 #[test]
-fn new_branch_from_remote_branch_tracks_it() {
-    let (fx, _bare) = Fixture::with_origin();
+fn new_branch_from_remote_branch_tracks_it_only_under_the_same_name() {
+    let (fx, bare) = Fixture::with_origin();
    fx.git(&["push", "-q", "origin", "main:release"]);
    fx.git(&["fetch", "-q"]);
    let repo = fx.repo();
+    let upstream = |name: &str| {
+        repo.branches().unwrap().into_iter().find(|b| b.name == name && !b.remote).and_then(|b| b.upstream)
+    };
+
+    repo.create_branch("release", Some("origin/release"), false).unwrap();
+    assert_eq!(upstream("release").as_deref(), Some("origin/release"));
+
+    // Another name: no upstream, whether switched to or not, created plainly or overwritten.
+    repo.create_branch("other", Some("origin/release"), false).unwrap();
+    assert_eq!(upstream("other"), None);
+    repo.create_branch_with_overwrite("other", Some("origin/main"), false, true).unwrap();
+    assert_eq!(upstream("other"), None);
    repo.create_branch("my-release", Some("origin/release"), true).unwrap();
    let info = repo.branch_info().unwrap();
    assert_eq!(info.head.as_deref(), Some("my-release"));
-    assert_eq!(info.upstream.as_deref(), Some("origin/release"));
+    assert_eq!(info.upstream, None);
+
+    // The first push then goes to a branch of its own name and tracks it.
+    fx.write("a.txt", "mine\n");
+    let tip = fx.commit_all("mine");
+    let (cancel, out) = quiet();
+    repo.push(false, true, &cancel, &out).unwrap();
+    assert_eq!(git_in(&bare, &["rev-parse", "my-release"]), tip);
+    assert_ne!(git_in(&bare, &["rev-parse", "release"]), tip);
+    assert_eq!(fx.git(&["config", "branch.my-release.merge"]), "refs/heads/my-release");
+
+    // New worktree on a new branch from a remote branch: the same rule.
+    let wt = fx.tmp.path().join("wt");
+    repo.add_worktree(&wt, "origin/release", Some("wt-branch")).unwrap();
+    assert_eq!(upstream("wt-branch"), None);
 }

 #[test]
@@ -61,8 +61,9 @@ pub fn artifacts_url(group: &str, prefix: &str) -> Option<String> {

 /// The published version metadata of one artifact on Central.
 pub fn metadata_url(group: &str, artifact: &str) -> Option<String> {
-    (part(group, 200) && part(artifact, 100)).then(|| {
-        let path = group.split('.').chain(artifact.split('.')).collect::<Vec<_>>().join("/");
+    // The group's dots are directories; an artifact id is one directory, dots and all.
+    (part(group, 200) && part(artifact, 100) && artifact != "." && artifact != "..").then(|| {
+        let path = group.split('.').chain([artifact]).collect::<Vec<_>>().join("/");
        format!("https://repo1.maven.org/maven2/{path}/maven-metadata.xml")
    })
 }
@@ -146,6 +147,11 @@ mod tests {
            metadata_url("org.apache.maven", "maven-core").as_deref(),
            Some("https://repo1.maven.org/maven2/org/apache/maven/maven-core/maven-metadata.xml")
        );
+        assert_eq!(
+            metadata_url("org.eclipse.platform", "org.eclipse.core.runtime").as_deref(),
+            Some("https://repo1.maven.org/maven2/org/eclipse/platform/org.eclipse.core.runtime/maven-metadata.xml")
+        );
+        assert_eq!(metadata_url("org.example", ".."), None);
    }

    #[test]
@@ -389,6 +389,12 @@ impl Documents {
        self.apply_workspace_edit_inner(edit, true, &mut |_| Ok(()))
    }

+    /// [`Self::apply_workspace_edit`] for an agent's edit (the MCP server's tools): undoable the
+    /// same way, announced as an agent's (`by_agent`) rather than as a refactoring.
+    pub fn apply_agent_workspace_edit(&self, edit: &WorkspaceEdit) -> IdeResult<()> {
+        self.apply_workspace_edit_as(edit, true, true, &mut |_| Ok(()))
+    }
+
    /// File moves already own a combined move/reference undo record.
    pub fn apply_file_move_edits(&self, edit: &WorkspaceEdit) -> IdeResult<()> {
        self.apply_workspace_edit_inner(edit, false, &mut |_| Ok(()))
@@ -399,6 +405,16 @@ impl Documents {
        edit: &WorkspaceEdit,
        remember: bool,
        before_operation: &mut dyn FnMut(usize) -> IdeResult<()>,
+    ) -> IdeResult<()> {
+        self.apply_workspace_edit_as(edit, remember, false, before_operation)
+    }
+
+    fn apply_workspace_edit_as(
+        &self,
+        edit: &WorkspaceEdit,
+        remember: bool,
+        by_agent: bool,
+        before_operation: &mut dyn FnMut(usize) -> IdeResult<()>,
    ) -> IdeResult<()> {
        let _operation = self.operations.lock();
        if edit.files.is_empty() {
@@ -485,7 +501,7 @@ impl Documents {
                });
            }
            history.prune(SystemTime::now(), MAX_HISTORY_BYTES, MAX_HISTORY_AGE);
-            self.sink.emit(IdeEvent::WorkspaceEditApplied { id, paths: affected });
+            self.sink.emit(IdeEvent::WorkspaceEditApplied { id, paths: affected, by_agent });
        }
        Ok(())
    }