fix(vcs): remove redundant commit message expansion

fix(ruby): Ruby LSP no longer crash-loops on dead shims or a spaced gem home (#1534 )
Ruby LSP showed Crashed and restarted for two reasons. A version-manager shim for ruby-lsp exists for every Ruby that ever had the gem, so when the active Ruby lacked it the shim exited on every start while the IDE counted the server as installed. And the IDE-managed copy lived in a gem home under Application Support, whose space broke ruby-lsp's re-exec through Bundler. Shims that can't run the tool now count as missing. ruby-lsp is installed with the project's own Ruby (gem install in the project, so a version manager picks its Ruby). Its executable is looked up in that Ruby's gem bindir and user bin when they are off PATH (Homebrew), and those directories are added to the server's PATH. Co-authored-by: kjeldahl <[email protected]>
2026-11-07 17:22:55 -10:00 · 2026-11-06 09:10:07 +08:00 · 2026-11-05 22:38:10 +08:00 · 2026-11-05 22:32:09 +08:00 · 2026-11-05 22:29:41 +08:00 · 2026-11-05 22:04:49 +08:00
384 changed files with 14659 additions and 1714 deletions
@@ -9,7 +9,8 @@

 <!-- Required. Commands you actually ran and their results; what else this could
     affect and how you checked it still works.
-     UI changes: before/after screenshots. Multi-step interactions: a recording.
+     Visible UI changes: before/after screenshots (not for removed UI or copy-only
+     changes). Multi-step interactions: a recording.
     Backend changes: logs or command output. -->

 ## Review focus
@@ -7,6 +7,9 @@ on:
    types: [opened, synchronize, reopened]
  workflow_dispatch:

+permissions:
+  contents: read
+
 concurrency:
  group: ci-${{ github.ref }}
  # A newer push supersedes the run in progress, on main too.
@@ -19,8 +22,50 @@ env:
  CARGO_PROFILE_DEV_DEBUG: line-tables-only

 jobs:
+  # Which parts a pull request touches, so jobs it can't affect skip and leave the
+  # shared runners to others. Pushes and manual runs always run everything.
+  changes:
+    name: Changes
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      pull-requests: read
+    outputs:
+      rust: ${{ steps.classify.outputs.rust }}
+      frontend: ${{ steps.classify.outputs.frontend }}
+    steps:
+      - id: classify
+        env:
+          GH_TOKEN: ${{ github.token }}
+          PR: ${{ github.event.pull_request.number }}
+        run: |
+          set -euo pipefail
+          if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
+            echo "rust=true" >> "$GITHUB_OUTPUT"
+            echo "frontend=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
+            --jq '.[] | .filename, (.previous_filename // empty)' > files.txt
+          cat files.txt
+          docs='^(docs/|\.agents/|\.claude/|\.idea/|\.github/ISSUE_TEMPLATE/|\.github/pull_request_template\.md$|[^/]+\.md$|LICENSE$|NOTICE$)'
+          # Frontend-only paths. The Rust code embeds a few files under src/; those stay out.
+          web='^(src/|e2e/|perf/|public/|scripts/|smoke/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
+          embedded='^src/(bindings\.ts|styles/tokens\.css|features/plugins/views/frame-bridge\.js|platform/keymaps/)'
+          # A job runs when any changed file falls outside the paths that can't affect it.
+          rust=false
+          if grep -Ev "$docs|$web" files.txt | grep -q . || grep -Eq "$embedded" files.txt; then rust=true; fi
+          frontend=false
+          if grep -Ev "$docs" files.txt | grep -q .; then frontend=true; fi
+          echo "rust=$rust frontend=$frontend"
+          echo "rust=$rust" >> "$GITHUB_OUTPUT"
+          echo "frontend=$frontend" >> "$GITHUB_OUTPUT"
+
  rust:
    name: Rust (${{ matrix.os }})
+    needs: changes
+    if: needs.changes.outputs.rust == 'true'
+    timeout-minutes: 60
    strategy:
      fail-fast: false
      matrix:
@@ -62,6 +107,9 @@ jobs:
  # keep that build working.
  server:
    name: Remote server (linux musl)
+    needs: changes
+    if: needs.changes.outputs.rust == 'true'
+    timeout-minutes: 40
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v5
@@ -77,6 +125,9 @@ jobs:
  # own workspaces (the root excludes them), so the jobs above don't see them.
  plugins:
    name: Plugins (SDK, official, fixtures)
+    needs: changes
+    if: needs.changes.outputs.rust == 'true'
+    timeout-minutes: 30
    runs-on: ubuntu-22.04
    env:
      CARGO_TARGET_DIR: ${{ github.workspace }}/target-plugins
@@ -126,6 +177,9 @@ jobs:

  deny:
    name: Cargo deny
+    needs: changes
+    if: needs.changes.outputs.rust == 'true'
+    timeout-minutes: 15
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
@@ -135,6 +189,9 @@ jobs:

  frontend:
    name: Frontend
+    needs: changes
+    if: needs.changes.outputs.frontend == 'true'
+    timeout-minutes: 30
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v5
@@ -152,6 +209,9 @@ jobs:

  e2e:
    name: E2E
+    needs: changes
+    if: needs.changes.outputs.frontend == 'true'
+    timeout-minutes: 30
    runs-on: ubuntu-24.04
    # Browsers and their system libraries are preinstalled; keep the tag in step with @playwright/test.
    container: mcr.microsoft.com/playwright:v1.64.1-noble
@@ -11,10 +11,7 @@ name: Language smoke
 on:
  push:
    branches: [main]
-  pull_request:
-    branches: [main]
-    types: [opened, synchronize, reopened]
-    paths:
+    paths: &paths
      - "crates/**"
      - "languages/**"
      - "fixtures/**"
@@ -27,6 +24,10 @@ on:
      - "package.json"
      - "pnpm-lock.yaml"
      - ".github/workflows/language-smoke.yml"
+  pull_request:
+    branches: [main]
+    types: [opened, synchronize, reopened]
+    paths: *paths
  workflow_dispatch:

 concurrency:
@@ -37,6 +37,16 @@ jobs:
            echo "::error::tag $TAG does not match tauri.conf.json version $app"
            exit 1
          fi
+      # A shipped plugin API is frozen: its WIT must be the snapshot api_frozen.rs checks later
+      # versions against (plugins/README.md, "Evolving the plugin API").
+      - name: Plugin API snapshot matches wit/
+        run: |
+          api() { sed -n 's/^package openidea:plugin@\(.*\);$/\1/p' "$1/plugin.wit"; }
+          snapshot=sdk/rust/openidea-plugin/tests/api/released
+          if [ "$(api wit)" != "$(api "$snapshot")" ]; then
+            echo "::error::plugin API $(api wit) ships without a snapshot ($snapshot is $(api "$snapshot")): copy wit/*.wit to $snapshot/"
+            exit 1
+          fi
      # The official plugins' public key (from PLUGIN_SIGNING_KEY, the seed
      # `openidea-plugin keygen` writes), built into the app: their packages
      # must carry its signature whatever the marketplace index lists. Without
@@ -51,7 +51,8 @@ Visual style: dark, low-contrast greys, one cool accent

 Follow `CONTRIBUTING.md` and `.github/pull_request_template.md`: one problem per PR
 (`Closes #<n>` when it resolves an issue), reproduce first, keep the diff focused, short plain description, and a
-**How it was verified** section with commands run, results and (for UI) before/after screenshots.
+**How it was verified** section with commands run, results and, when the change alters what users
+see, before/after screenshots (not for UI removed along with a feature, copy-only or non-visual changes).
 Unclear product decisions → `needs-decision` and stop.

 ## Skills
@@ -25,8 +25,9 @@ Project layout, coding rules, commands and checks are in [AGENTS.md](AGENTS.md).
 - Fill in the template. Keep the description short and in plain words. If it
  doesn't fit in a few sentences, the PR is probably too big.
 - **How it was verified** is required: the commands you ran and their results,
-  and what else the change could affect. UI changes need before/after screenshots;
-  multi-step interactions need a recording.
+  and what else the change could affect. Changes to what users see need before/after
+  screenshots; multi-step interactions need a recording. UI that goes away with a removed
+  feature, copy-only and non-visual changes don't; say what you checked instead.
 - If a change needs a product decision you can't make, ask in the issue and stop
  rather than guessing.

@@ -1496,7 +1496,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d045de693cb712d0b22c6a64be5b953f67b3ce00ab5ad3dd5d8b441886ab8e1a"
 dependencies = [
 "quote",
- "syn 3.0.9",
+ "syn 2.0.119",
 ]

 [[package]]
@@ -3001,7 +3001,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c48eccd894bd15555b0346470e63491ded94aefe76b3fcb1052084b5a393238"
 dependencies = [
 "bstr",
- "hashbrown 0.17.1",
+ "hashbrown 0.16.1",
 ]

 [[package]]
@@ -4071,7 +4071,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"

 [[package]]
 name = "ide-agent"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "dunce",
 "encoding_rs",
@@ -4094,7 +4094,7 @@ dependencies = [

 [[package]]
 name = "ide-analysis"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ast-grep-core",
 "ide-core",
@@ -4106,9 +4106,20 @@ dependencies = [
 "tree-sitter",
 ]

+[[package]]
+name = "ide-android"
+version = "0.1.37"
+dependencies = [
+ "ide-core",
+ "serde",
+ "specta",
+ "tempfile",
+ "which",
+]
+
 [[package]]
 name = "ide-build"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "dirs 6.0.0",
 "dunce",
@@ -4123,7 +4134,7 @@ dependencies = [

 [[package]]
 name = "ide-clipboard"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "objc2 0.6.5",
 "objc2-app-kit 0.3.2",
@@ -4132,7 +4143,7 @@ dependencies = [

 [[package]]
 name = "ide-core"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "dunce",
 "encoding_rs",
@@ -4149,7 +4160,7 @@ dependencies = [

 [[package]]
 name = "ide-coverage"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "ide-run",
@@ -4163,7 +4174,7 @@ dependencies = [

 [[package]]
 name = "ide-dap"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "ide-jsonrpc",
@@ -4181,7 +4192,7 @@ dependencies = [

 [[package]]
 name = "ide-db"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "bb8",
 "dirs 6.0.0",
@@ -4207,7 +4218,7 @@ dependencies = [

 [[package]]
 name = "ide-docker"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "serde",
@@ -4220,7 +4231,7 @@ dependencies = [

 [[package]]
 name = "ide-extension"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "base64 0.22.1",
 "blake3",
@@ -4240,7 +4251,7 @@ dependencies = [

 [[package]]
 name = "ide-fonts"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "objc2-core-foundation",
 "objc2-core-text",
@@ -4252,7 +4263,7 @@ dependencies = [

 [[package]]
 name = "ide-github"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "ide-vcs",
@@ -4265,7 +4276,7 @@ dependencies = [

 [[package]]
 name = "ide-host"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "base64 0.22.1",
 "criterion",
@@ -4326,7 +4337,7 @@ dependencies = [

 [[package]]
 name = "ide-http"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "parking_lot",
@@ -4344,7 +4355,7 @@ dependencies = [

 [[package]]
 name = "ide-index"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "blake3",
 "criterion",
@@ -4366,7 +4377,7 @@ dependencies = [

 [[package]]
 name = "ide-jsonrpc"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "encoding_rs",
 "futures",
@@ -4383,7 +4394,7 @@ dependencies = [

 [[package]]
 name = "ide-language"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "blake3",
 "criterion",
@@ -4439,7 +4450,7 @@ dependencies = [

 [[package]]
 name = "ide-lsp"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "dunce",
 "futures",
@@ -4465,7 +4476,7 @@ dependencies = [

 [[package]]
 name = "ide-notebook"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "futures",
 "ide-core",
@@ -4488,7 +4499,7 @@ dependencies = [

 [[package]]
 name = "ide-plugin"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "blake3",
 "ide-core",
@@ -4504,11 +4515,12 @@ dependencies = [
 "tracing",
 "wasmtime",
 "wasmtime-wasi",
+ "wat",
 ]

 [[package]]
 name = "ide-profiler"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "ide-run",
@@ -4521,7 +4533,7 @@ dependencies = [

 [[package]]
 name = "ide-remote"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "globset",
 "ide-core",
@@ -4538,7 +4550,7 @@ dependencies = [

 [[package]]
 name = "ide-run"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "dunce",
 "encoding_rs",
@@ -4561,7 +4573,7 @@ dependencies = [

 [[package]]
 name = "ide-sdk"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "dunce",
 "ide-core",
@@ -4580,7 +4592,7 @@ dependencies = [

 [[package]]
 name = "ide-search"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "criterion",
 "globset",
@@ -4600,7 +4612,7 @@ dependencies = [

 [[package]]
 name = "ide-spell"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "parking_lot",
@@ -4613,7 +4625,7 @@ dependencies = [

 [[package]]
 name = "ide-ssh"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "dirs 6.0.0",
 "flate2",
@@ -4635,7 +4647,7 @@ dependencies = [

 [[package]]
 name = "ide-syntax"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "ide-language",
@@ -4650,7 +4662,7 @@ dependencies = [

 [[package]]
 name = "ide-terminal"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "libc",
@@ -4663,7 +4675,7 @@ dependencies = [

 [[package]]
 name = "ide-text"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "criterion",
 "ide-core",
@@ -4676,7 +4688,7 @@ dependencies = [

 [[package]]
 name = "ide-tools"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "flate2",
 "hex",
@@ -4697,7 +4709,7 @@ dependencies = [

 [[package]]
 name = "ide-vcs"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "blake3",
 "dunce",
@@ -4718,7 +4730,7 @@ dependencies = [

 [[package]]
 name = "ide-vfs"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "chardetng",
 "dunce",
@@ -4740,7 +4752,7 @@ dependencies = [

 [[package]]
 name = "ide-web"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "ide-core",
 "open",
@@ -4756,7 +4768,7 @@ dependencies = [

 [[package]]
 name = "ide-workspace"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "blake3",
 "dunce",
@@ -6297,7 +6309,7 @@ dependencies = [

 [[package]]
 name = "openidea"
-version = "0.1.36"
+version = "0.1.37"
 dependencies = [
 "base64 0.22.1",
 "blake3",
@@ -6307,6 +6319,7 @@ dependencies = [
 "gtk",
 "ide-agent",
 "ide-analysis",
+ "ide-android",
 "ide-build",
 "ide-clipboard",
 "ide-core",
@@ -6361,10 +6374,12 @@ dependencies = [
 "tauri-plugin-updater",
 "tauri-plugin-window-state",
 "tauri-specta",
+ "tempfile",
 "tokio",
 "tracing",
 "tracing-appender",
 "tracing-subscriber",
+ "windows",
 "windows-sys 0.61.2",
 ]

@@ -8362,7 +8377,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d204abcbdf8e88729306a8d0ca01a79d8a49969fe1f84696909d6dbc4321c1a"
 dependencies = [
 "foldhash",
- "hashbrown 0.17.1",
+ "hashbrown 0.16.1",
 ]

 [[package]]
@@ -10305,6 +10320,12 @@ version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"

+[[package]]
+name = "unicode-width"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca718471876992059f251e33aafc334346ada08042b7661dd1fe313a9bced557"
+
 [[package]]
 name = "universal-hash"
 version = "0.6.1"
@@ -10825,6 +10846,28 @@ dependencies = [
 "wasmtime",
 ]

+[[package]]
+name = "wast"
+version = "258.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b912cfe5696dfaae736e344fc82082dbd63609abbaeca3926466c0b10d9fecc"
+dependencies = [
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder",
+]
+
+[[package]]
+name = "wat"
+version = "1.258.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3069154948f5737a8bcd5c55dcdf2c2b59ca776057732e49821167bde268ec6e"
+dependencies = [
+ "wast",
+]
+
 [[package]]
 name = "wayland-backend"
 version = "0.3.17"
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
 exclude = ["sdk", "plugins"]

 [workspace.package]
-version = "0.1.36"
+version = "0.1.37"
 edition = "2024"
 rust-version = "1.96"
 license = "Apache-2.0"
@@ -16,7 +16,7 @@
  &nbsp;·&nbsp;
  <a href="#plugins">Plugins</a>
  &nbsp;·&nbsp;
-  <a href="https://discord.gg/2Zy4yn7gP">Discord</a>
+  <a href="#community">Community</a>
 </p>

 https://github.com/user-attachments/assets/234dd54c-1255-4b3a-b35c-533d78d737c0
@@ -57,6 +57,13 @@ Install them from Settings › Plugins, or start your own with
 `openidea-plugin new` — see [Writing OpenIDEA plugins](plugins/README.md) and
 the [official plugins](plugins/official). The plugin API is still a preview.

+## Community
+
+- [Discord](https://discord.gg/2Zy4yn7gP) — questions, feedback and release news.
+- WeChat group — scan to join:
+
+  <img src="docs/assets/wechat-group.png" alt="WeChat group QR code" width="200">
+
 ## License

 [Apache 2.0](LICENSE). Bundled third-party assets are listed in [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md).
@@ -0,0 +1,15 @@
+[package]
+name = "ide-android"
+description = "Android devices and logcat for the Logcat tool window, driven through the adb CLI"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+ide-core.workspace = true
+serde.workspace = true
+specta.workspace = true
+which = "8"
+
+[dev-dependencies]
+tempfile.workspace = true
@@ -0,0 +1,222 @@
+//! Android devices and their logs, driven through the `adb` CLI (like git is
+//! driven through its CLI).
+//!
+//! The Logcat tool window needs two things from a device: that it is there, and
+//! what it prints. Both come from `adb`, which the Android SDK installs — the
+//! IDE does not bundle it.
+//!
+//! Every function blocks; callers run them off the UI / command threads.
+
+mod model;
+mod process;
+
+pub use model::*;
+
+use ide_core::{CancellationToken, IdeError, IdeResult};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::OnceLock;
+use std::time::Duration;
+
+/// `adb devices` is quick unless it starts the daemon, which can take a moment.
+const DEVICES: Duration = Duration::from_secs(20);
+/// `adb logcat -c` only truncates the buffers.
+const CLEAR: Duration = Duration::from_secs(15);
+/// How much of the buffer to show before following, so opening the window is not empty.
+const TAIL_LINES: u32 = 200;
+/// Logcat can print thousands of lines a second: batches keep the IPC channel sane,
+/// while `IDLE` makes sure a quiet stream still shows its last line promptly.
+const BATCH_IDLE: Duration = Duration::from_millis(60);
+const BATCH_MAX: usize = 300;
+
+fn exe(name: &str) -> String {
+    if cfg!(windows) { format!("{name}.exe") } else { name.to_owned() }
+}
+
+/// Android SDK locations, most specific first: the environment, then the usual
+/// per-platform installs (a GUI app on macOS does not see a shell's `ANDROID_HOME`).
+fn sdk_roots() -> Vec<PathBuf> {
+    let mut roots: Vec<PathBuf> = ["ANDROID_HOME", "ANDROID_SDK_ROOT"]
+        .iter()
+        .filter_map(|key| std::env::var_os(key).map(PathBuf::from))
+        .collect();
+    let home = std::env::var_os(if cfg!(windows) { "USERPROFILE" } else { "HOME" }).map(PathBuf::from);
+    if let Some(home) = home.filter(|_| !cfg!(windows)) {
+        roots.push(home.join("Library/Android/sdk"));
+        roots.push(home.join("Android/Sdk"));
+    }
+    if cfg!(windows)
+        && let Some(local) = std::env::var_os("LOCALAPPDATA").map(PathBuf::from)
+    {
+        roots.push(local.join("Android/Sdk"));
+    }
+    roots
+}
+
+/// Locates the adb executable once per process; `OPENIDEA_ADB` overrides.
+pub fn adb_executable() -> Option<PathBuf> {
+    static ADB: OnceLock<Option<PathBuf>> = OnceLock::new();
+    ADB.get_or_init(|| {
+        if let Some(explicit) = std::env::var_os("OPENIDEA_ADB").map(PathBuf::from).filter(|p| p.is_file()) {
+            return Some(explicit);
+        }
+        let name = exe("adb");
+        if let Some(found) =
+            sdk_roots().into_iter().map(|root| root.join("platform-tools").join(&name)).find(|p| p.is_file())
+        {
+            return Some(found);
+        }
+        if let Ok(found) = which::which("adb") {
+            return Some(found);
+        }
+        let mut candidates: Vec<PathBuf> = if cfg!(windows) {
+            vec![PathBuf::from(r"C:\platform-tools\adb.exe")]
+        } else {
+            ["/usr/local/bin/adb", "/opt/homebrew/bin/adb", "/usr/bin/adb"].iter().map(PathBuf::from).collect()
+        };
+        candidates.extend([
+            PathBuf::from("/opt/android-sdk/platform-tools/adb"),
+            PathBuf::from("/usr/lib/android-sdk/platform-tools/adb"),
+        ]);
+        candidates.into_iter().find(|p: &PathBuf| p.is_file())
+    })
+    .clone()
+}
+
+fn executable() -> IdeResult<PathBuf> {
+    adb_executable().ok_or_else(|| {
+        IdeError::unavailable(
+            "adb was not found: install the Android SDK platform-tools, or set ANDROID_HOME (or OPENIDEA_ADB)",
+        )
+    })
+}
+
+/// The directory holding adb, for command lines that expect `adb` on `PATH`.
+pub fn platform_tools_dir() -> Option<&'static Path> {
+    static DIR: OnceLock<Option<PathBuf>> = OnceLock::new();
+    DIR.get_or_init(|| adb_executable().as_deref().and_then(Path::parent).map(Path::to_path_buf)).as_deref()
+}
+
+/// Connected devices, online ones first; starting the adb daemon when needed.
+pub fn devices() -> IdeResult<Vec<AndroidDevice>> {
+    let adb = executable()?;
+    let mut cmd = Command::new(adb);
+    cmd.args(["devices", "-l"]);
+    let out = process::run(cmd, DEVICES, None)?;
+    if !out.success {
+        let message = out.stderr.trim();
+        return Err(IdeError::unavailable(if message.is_empty() {
+            "adb devices failed".to_owned()
+        } else {
+            format!("adb devices failed: {message}")
+        }));
+    }
+    Ok(parse_devices(&out.stdout))
+}
+
+/// Empties the device's log buffers (`adb logcat -c`).
+pub fn clear_log(serial: &str, cancel: &CancellationToken) -> IdeResult<()> {
+    let adb = executable()?;
+    let mut cmd = Command::new(adb);
+    cmd.args(["-s", serial, "logcat", "-c"]);
+    let out = process::run(cmd, CLEAR, Some(cancel))?;
+    if out.success {
+        Ok(())
+    } else {
+        Err(IdeError::unavailable(format!("adb logcat -c failed: {}", out.stderr.trim())))
+    }
+}
+
+fn command(adb: &Path, serial: &str, tail: Option<u32>) -> Command {
+    let mut cmd = Command::new(adb);
+    cmd.args(["-s", serial, "logcat", "-v", "threadtime"]);
+    if let Some(lines) = tail {
+        // Recent history first, then follow: `-T <count>` is lines, not an exit.
+        cmd.arg("-T").arg(lines.to_string());
+    }
+    cmd
+}
+
+/// Follows `serial`'s log until `cancel` fires, handing lines over in batches.
+/// With `clear`, the buffers are emptied first so the window starts clean.
+pub fn logcat(
+    serial: &str,
+    clear: bool,
+    cancel: &CancellationToken,
+    on_batch: &mut dyn FnMut(Vec<LogcatLine>),
+) -> IdeResult<()> {
+    let adb = executable()?;
+    if clear {
+        clear_log(serial, cancel)?;
+    }
+    let mut parse = |line: &str| Some(parse_line(line));
+    let (ok, stderr) = match process::stream_batched(
+        command(&adb, serial, Some(TAIL_LINES)),
+        cancel,
+        BATCH_IDLE,
+        BATCH_MAX,
+        &mut parse,
+        on_batch,
+    ) {
+        Ok(result) => result,
+        // The window closed or switched devices: stopping is the expected end.
+        Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => return Ok(()),
+        Err(e) => return Err(e),
+    };
+    if ok || cancel.is_cancelled() {
+        return Ok(());
+    }
+    // `-T` is old (API 21) but adb forwards logcat options it does not know on
+    // very old devices; retry without the history rather than showing nothing.
+    let unsupported = stderr.iter().any(|line| {
+        line.contains("Unrecognized option") || line.contains("unknown option") || line.contains("Invalid option")
+    });
+    if unsupported {
+        let (ok, stderr) = match process::stream_batched(
+            command(&adb, serial, None),
+            cancel,
+            BATCH_IDLE,
+            BATCH_MAX,
+            &mut parse,
+            on_batch,
+        ) {
+            Ok(result) => result,
+            Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => return Ok(()),
+            Err(e) => return Err(e),
+        };
+        if ok || cancel.is_cancelled() {
+            return Ok(());
+        }
+        return Err(failure(serial, &stderr));
+    }
+    Err(failure(serial, &stderr))
+}
+
+fn failure(serial: &str, stderr: &[String]) -> IdeError {
+    let message = stderr.join("\n");
+    IdeError::unavailable(if message.trim().is_empty() {
+        format!("adb logcat on {serial} stopped")
+    } else {
+        format!("adb logcat on {serial} stopped: {message}")
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn adb_candidates_are_absolute() {
+        for root in sdk_roots() {
+            assert!(root.is_absolute(), "{root:?}");
+        }
+    }
+
+    #[test]
+    fn executable_is_absolute_when_found() {
+        if let Some(adb) = adb_executable() {
+            assert!(adb.is_absolute());
+            assert!(adb.is_file());
+        }
+    }
+}
@@ -0,0 +1,276 @@
+//! What the Logcat tool window shows: the devices `adb` reports and the lines
+//! `adb logcat` prints, parsed from its `threadtime` format.
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+/// One entry of `adb devices -l`.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct AndroidDevice {
+    /// `adb -s` value: a USB serial number, `emulator-5554`, or `host:port`.
+    pub serial: String,
+    /// `device` (usable), `offline`, `unauthorized` or `no permissions`.
+    pub state: String,
+    pub model: Option<String>,
+    pub product: Option<String>,
+    /// The device's own name from the build (`ro.product.device`).
+    pub device: Option<String>,
+    pub transport_id: Option<String>,
+}
+
+impl AndroidDevice {
+    /// Ready for `logcat` / `install`.
+    pub fn is_online(&self) -> bool {
+        self.state == "device"
+    }
+
+    /// What the picker calls it: the model when known, the serial otherwise.
+    pub fn label(&self) -> &str {
+        self.model.as_deref().filter(|m| !m.trim().is_empty()).unwrap_or(&self.serial)
+    }
+}
+
+/// The single-letter logcat priority, in increasing severity.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum LogcatLevel {
+    Verbose,
+    Debug,
+    Info,
+    Warn,
+    Error,
+    Fatal,
+    /// A line logcat prints outside the message format (`--------- beginning of main`).
+    Unknown,
+}
+
+impl LogcatLevel {
+    pub fn letter(self) -> char {
+        match self {
+            Self::Verbose => 'V',
+            Self::Debug => 'D',
+            Self::Info => 'I',
+            Self::Warn => 'W',
+            Self::Error => 'E',
+            Self::Fatal => 'F',
+            Self::Unknown => '?',
+        }
+    }
+
+    fn parse(c: char) -> Self {
+        match c.to_ascii_uppercase() {
+            'V' => Self::Verbose,
+            'D' => Self::Debug,
+            'I' => Self::Info,
+            'W' => Self::Warn,
+            'E' => Self::Error,
+            'F' | 'A' => Self::Fatal,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+/// One [`LogcatLevel`]-tagged line of `adb logcat -v threadtime`.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct LogcatLine {
+    /// `MM-DD HH:MM:SS.mmm`, as logcat prints it (no year, device time zone).
+    pub time: String,
+    pub pid: i32,
+    pub tid: i32,
+    pub level: LogcatLevel,
+    pub tag: String,
+    pub message: String,
+}
+
+impl LogcatLine {
+    /// A line logcat printed outside the message format, kept so nothing is lost.
+    fn unparsed(text: &str) -> Self {
+        Self {
+            time: String::new(),
+            pid: 0,
+            tid: 0,
+            level: LogcatLevel::Unknown,
+            tag: String::new(),
+            message: text.to_owned(),
+        }
+    }
+}
+
+/// Parses `adb devices -l` output; the daemon's chatter on stderr is not included.
+pub fn parse_devices(output: &str) -> Vec<AndroidDevice> {
+    let mut devices: Vec<AndroidDevice> = Vec::new();
+    for line in output.lines() {
+        let line = line.trim_end();
+        if line.trim().is_empty() || line.starts_with("List of devices") || line.starts_with('*') {
+            continue;
+        }
+        let mut fields = line.split_whitespace();
+        let (Some(serial), Some(state)) = (fields.next(), fields.next()) else {
+            continue;
+        };
+        // "no permissions (user in plugdev group; are your udev rules wrong?)"
+        // is the one state that carries spaces; the rest is a `key:value` list.
+        let mut device = AndroidDevice {
+            serial: serial.to_owned(),
+            state: state.to_owned(),
+            model: None,
+            product: None,
+            device: None,
+            transport_id: None,
+        };
+        if device.state == "no" {
+            device.state = "no permissions".to_owned();
+            devices.push(device);
+            continue;
+        }
+        for field in fields {
+            let Some((key, value)) = field.split_once(':') else {
+                continue;
+            };
+            match key {
+                "model" => device.model = Some(value.to_owned()),
+                "product" => device.product = Some(value.to_owned()),
+                "device" => device.device = Some(value.to_owned()),
+                "transport_id" => device.transport_id = Some(value.to_owned()),
+                _ => {}
+            }
+        }
+        devices.push(device);
+    }
+    // Online first, then by name, so the picker's default is the device in hand.
+    devices.sort_by(|a, b| b.is_online().cmp(&a.is_online()).then_with(|| a.serial.cmp(&b.serial)));
+    devices
+}
+
+/// Parses one `logcat -v threadtime` line:
+///
+/// ```text
+/// 11-04 12:52:39.123  3048  3059 I WindowManager: displayed
+/// ```
+///
+/// Text that does not follow the format still becomes a line, so a device that
+/// prints something unexpected does not look like a dead stream.
+pub fn parse_line(text: &str) -> LogcatLine {
+    let Some(line) = parse_formatted(text) else {
+        return LogcatLine::unparsed(text);
+    };
+    line
+}
+
+fn parse_formatted(text: &str) -> Option<LogcatLine> {
+    // "MM-DD HH:MM:SS.mmm" is 18 bytes; logcat pads the rest with spaces.
+    let stamp = text.get(..18)?;
+    if !looks_like_stamp(stamp) {
+        return None;
+    }
+    let mut rest = text.get(18..)?;
+    let pid: i32 = take_field(&mut rest)?.parse().ok()?;
+    let tid: i32 = take_field(&mut rest)?.parse().ok()?;
+    let level = LogcatLevel::parse(take_field(&mut rest)?.chars().next()?);
+    let tail = rest.trim_start();
+    // "Tag            : message": logcat pads the tag to 8 columns, and the tag
+    // itself never contains a colon followed by a space.
+    let (tag, message) = match tail.split_once(": ") {
+        Some((tag, message)) => (tag.trim_end(), message),
+        None => (tail.trim_end(), ""),
+    };
+    Some(LogcatLine { time: stamp.to_owned(), pid, tid, level, tag: tag.to_owned(), message: message.to_owned() })
+}
+
+/// Consumes the next space-separated field of `rest`, leaving the remainder.
+fn take_field<'a>(rest: &mut &'a str) -> Option<&'a str> {
+    *rest = rest.trim_start();
+    if rest.is_empty() {
+        return None;
+    }
+    let end = rest.find(char::is_whitespace).unwrap_or(rest.len());
+    let field = &rest[..end];
+    *rest = &rest[end..];
+    Some(field)
+}
+
+fn looks_like_stamp(s: &str) -> bool {
+    let bytes = s.as_bytes();
+    bytes.len() == 18
+        && bytes[2] == b'-'
+        && bytes[5] == b' '
+        && bytes[8] == b':'
+        && bytes[11] == b':'
+        && bytes[14] == b'.'
+        && bytes.iter().enumerate().all(|(i, b)| matches!(i, 2 | 5 | 8 | 11 | 14) || b.is_ascii_digit())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_adb_devices_with_attributes() {
+        let out = "\
+List of devices attached
+HT7A1B2C3D4           device product:generic model:Generic_Phone device:generic transport_id:1
+emulator-5554          offline transport_id:2
+0123456789ABCDEF       unauthorized usb:1-1 transport_id:3
+
+";
+        let devices = parse_devices(out);
+        assert_eq!(devices.len(), 3);
+        // Online first, then by serial.
+        assert_eq!(devices[0].serial, "HT7A1B2C3D4");
+        assert_eq!(devices[0].state, "device");
+        assert_eq!(devices[0].model.as_deref(), Some("Generic_Phone"));
+        assert_eq!(devices[0].transport_id.as_deref(), Some("1"));
+        assert!(devices[0].is_online());
+        assert_eq!(devices[1].serial, "0123456789ABCDEF");
+        assert_eq!(devices[1].state, "unauthorized");
+        assert_eq!(devices[1].label(), "0123456789ABCDEF");
+        assert_eq!(devices[2].serial, "emulator-5554");
+        assert!(!devices[2].is_online());
+    }
+
+    #[test]
+    fn reads_adb_devices_when_the_list_is_empty() {
+        assert!(parse_devices("List of devices attached\n\n").is_empty());
+    }
+
+    #[test]
+    fn reads_no_permissions() {
+        let devices = parse_devices("ABC\tno permissions (user in plugdev group; are your udev rules wrong?)\n");
+        assert_eq!(devices.len(), 1);
+        assert_eq!(devices[0].state, "no permissions");
+    }
+
+    #[test]
+    fn parses_a_threadtime_line() {
+        let line = parse_line("11-04 12:52:39.123  3048  3059 I WindowManager: Displayed activity");
+        assert_eq!(line.time, "11-04 12:52:39.123");
+        assert_eq!(line.pid, 3048);
+        assert_eq!(line.tid, 3059);
+        assert_eq!(line.level, LogcatLevel::Info);
+        assert_eq!(line.tag, "WindowManager");
+        assert_eq!(line.message, "Displayed activity");
+    }
+
+    #[test]
+    fn keeps_colons_in_the_message() {
+        let line = parse_line("11-04 12:52:39.123  3048  3059 E flutter : java.lang.IllegalStateException: boom");
+        assert_eq!(line.tag, "flutter");
+        assert_eq!(line.level, LogcatLevel::Error);
+        assert_eq!(line.message, "java.lang.IllegalStateException: boom");
+    }
+
+    #[test]
+    fn keeps_lines_outside_the_format() {
+        let line = parse_line("--------- beginning of main");
+        assert_eq!(line.level, LogcatLevel::Unknown);
+        assert_eq!(line.message, "--------- beginning of main");
+    }
+
+    #[test]
+    fn levels_order_by_severity() {
+        assert!(LogcatLevel::Warn > LogcatLevel::Info);
+        assert!(LogcatLevel::Fatal > LogcatLevel::Error);
+    }
+}
@@ -0,0 +1,206 @@
+//! Child processes of the `adb` CLI: bounded runs, and cancellable line streams
+//! that are handed over in batches (logcat is far too chatty for one message a line).
+
+use ide_core::process::terminate_tree;
+use ide_core::{CancellationToken, IdeError, IdeResult};
+use std::io::Read;
+use std::process::{Child, Command, Stdio};
+use std::sync::mpsc;
+use std::time::{Duration, Instant};
+
+/// How long a cancelled child gets to exit on `SIGTERM` (and flush) before `SIGKILL`.
+const KILL_GRACE: Duration = Duration::from_millis(20);
+
+pub(crate) struct Output {
+    pub stdout: String,
+    pub stderr: String,
+    pub success: bool,
+}
+
+fn prepare(cmd: &mut Command) {
+    cmd.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
+    ide_core::process::prepare(ide_core::process::own_group(cmd));
+}
+
+fn spawn(cmd: &mut Command) -> IdeResult<Child> {
+    cmd.spawn().map_err(|e| IdeError::unavailable(format!("could not run adb: {e}")))
+}
+
+fn read_all(mut pipe: impl Read + Send + 'static) -> std::thread::JoinHandle<String> {
+    std::thread::spawn(move || {
+        let mut buf = Vec::new();
+        let _ = pipe.read_to_end(&mut buf);
+        ide_core::output_encoding::decode_tool_output(&buf)
+    })
+}
+
+/// Runs `cmd` to completion. Fails when it outlives `timeout` or `cancel` fires;
+/// a non-zero exit is reported in [`Output::success`], not as an error.
+pub(crate) fn run(mut cmd: Command, timeout: Duration, cancel: Option<&CancellationToken>) -> IdeResult<Output> {
+    prepare(&mut cmd);
+    let mut child = spawn(&mut cmd)?;
+    let out = child.stdout.take().map(read_all);
+    let err = child.stderr.take().map(read_all);
+    let deadline = Instant::now() + timeout;
+    let status = loop {
+        if let Some(status) = child.try_wait()? {
+            break status;
+        }
+        if cancel.is_some_and(CancellationToken::is_cancelled) {
+            terminate_tree(&mut child, KILL_GRACE);
+            return Err(IdeError::cancelled());
+        }
+        if Instant::now() >= deadline {
+            terminate_tree(&mut child, KILL_GRACE);
+            return Err(IdeError::unavailable("adb did not respond in time"));
+        }
+        std::thread::sleep(Duration::from_millis(10));
+    };
+    Ok(Output {
+        stdout: out.map(|t| t.join().unwrap_or_default()).unwrap_or_default(),
+        stderr: err.map(|t| t.join().unwrap_or_default()).unwrap_or_default(),
+        success: status.success(),
+    })
+}
+
+enum Event {
+    Line(bool, String),
+    Closed,
+}
+
+fn spawn_reader(mut pipe: impl Read + Send + 'static, tx: mpsc::Sender<Event>, stdout: bool) {
+    std::thread::spawn(move || {
+        let mut buf = [0u8; 8192];
+        let mut pending: Vec<u8> = Vec::new();
+        let flush = |pending: &mut Vec<u8>| {
+            if !pending.is_empty() {
+                let line = ide_core::output_encoding::decode_tool_output(pending);
+                pending.clear();
+                let _ = tx.send(Event::Line(stdout, line.trim_end().to_string()));
+            }
+        };
+        loop {
+            match pipe.read(&mut buf) {
+                Ok(0) | Err(_) => break,
+                Ok(n) => {
+                    for &b in &buf[..n] {
+                        if b == b'\n' {
+                            flush(&mut pending);
+                        } else if b != b'\r' {
+                            pending.push(b);
+                        }
+                    }
+                }
+            }
+        }
+        flush(&mut pending);
+        let _ = tx.send(Event::Closed);
+    });
+}
+
+fn flush<T>(batch: &mut Vec<T>, on_batch: &mut dyn FnMut(Vec<T>)) {
+    if !batch.is_empty() {
+        on_batch(std::mem::take(batch));
+    }
+}
+
+/// Runs `cmd`, parsing every stdout line with `parse` and handing the results to
+/// `on_batch` — as soon as `max` are ready, or once the oldest waiting line is `idle`
+/// old, so neither a quiet nor a steady stream holds lines back. Stderr is kept as a
+/// tail for the error message. Returns whether the child exited successfully.
+pub(crate) fn stream_batched<T>(
+    mut cmd: Command,
+    cancel: &CancellationToken,
+    idle: Duration,
+    max: usize,
+    mut parse: impl FnMut(&str) -> Option<T>,
+    on_batch: &mut dyn FnMut(Vec<T>),
+) -> IdeResult<(bool, Vec<String>)> {
+    if cancel.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
+    prepare(&mut cmd);
+    let mut child = spawn(&mut cmd)?;
+    let (tx, rx) = mpsc::channel::<Event>();
+    let mut open = 0;
+    if let Some(out) = child.stdout.take() {
+        spawn_reader(out, tx.clone(), true);
+        open += 1;
+    }
+    if let Some(err) = child.stderr.take() {
+        spawn_reader(err, tx.clone(), false);
+        open += 1;
+    }
+    drop(tx);
+    let mut stderr_tail: Vec<String> = Vec::new();
+    let mut batch: Vec<T> = Vec::with_capacity(max);
+    // When the first line of the waiting batch arrived.
+    let mut since = Instant::now();
+    while open > 0 {
+        if cancel.is_cancelled() {
+            terminate_tree(&mut child, KILL_GRACE);
+            return Err(IdeError::cancelled());
+        }
+        let wait = if batch.is_empty() { idle } else { idle.saturating_sub(since.elapsed()) };
+        match rx.recv_timeout(wait) {
+            Ok(Event::Line(true, line)) => {
+                if let Some(item) = parse(&line) {
+                    if batch.is_empty() {
+                        since = Instant::now();
+                    }
+                    batch.push(item);
+                    if batch.len() >= max || since.elapsed() >= idle {
+                        flush(&mut batch, on_batch);
+                    }
+                }
+            }
+            Ok(Event::Line(false, line)) => {
+                if !line.trim().is_empty() {
+                    stderr_tail.push(line);
+                    if stderr_tail.len() > 20 {
+                        stderr_tail.remove(0);
+                    }
+                }
+            }
+            Ok(Event::Closed) => open -= 1,
+            Err(mpsc::RecvTimeoutError::Timeout) => flush(&mut batch, on_batch),
+            Err(mpsc::RecvTimeoutError::Disconnected) => break,
+        }
+    }
+    flush(&mut batch, on_batch);
+    let status = loop {
+        if let Some(status) = child.try_wait()? {
+            break status;
+        }
+        if cancel.is_cancelled() {
+            terminate_tree(&mut child, KILL_GRACE);
+            return Err(IdeError::cancelled());
+        }
+        std::thread::sleep(Duration::from_millis(10));
+    };
+    Ok((status.success(), stderr_tail))
+}
+
+#[cfg(all(test, unix))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_steady_stream_is_handed_over_while_it_runs() {
+        let mut cmd = Command::new("sh");
+        cmd.args(["-c", "for i in $(seq 1 20); do echo $i; sleep 0.02; done"]);
+        let mut sizes = Vec::new();
+        let (ok, _) = stream_batched(
+            cmd,
+            &CancellationToken::new(),
+            Duration::from_millis(60),
+            300,
+            |line| Some(line.to_owned()),
+            &mut |batch| sizes.push(batch.len()),
+        )
+        .unwrap();
+        assert!(ok);
+        assert_eq!(sizes.iter().sum::<usize>(), 20);
+        assert!(sizes.len() >= 3, "lines arriving every 20 ms waited for the end: {sizes:?}");
+    }
+}
@@ -0,0 +1,65 @@
+//! Drives a real device through `adb`, checking what the Logcat tool window does:
+//! that the device list parses, that the stream delivers batches, and that
+//! cancelling stops both the stream and its `adb` process.
+//!
+//! Ignored by default (needs a connected device). Run with
+//! `OPENIDEA_ADB_DEVICE=<serial> cargo test -p ide-android --test device -- --ignored --nocapture`
+//! — without the variable, the connected device is used when there is exactly one.
+
+use ide_android::*;
+use ide_core::CancellationToken;
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+fn serial() -> Option<String> {
+    if let Ok(serial) = std::env::var("OPENIDEA_ADB_DEVICE") {
+        return Some(serial);
+    }
+    let online = devices().ok()?.into_iter().filter(AndroidDevice::is_online).collect::<Vec<_>>();
+    (online.len() == 1).then(|| online[0].serial.clone())
+}
+
+#[test]
+#[ignore]
+fn finds_the_adb_executable() {
+    let adb = adb_executable().expect("adb (set ANDROID_HOME or OPENIDEA_ADB)");
+    println!("adb: {}", adb.display());
+    assert!(adb.is_file());
+}
+
+#[test]
+#[ignore]
+fn lists_connected_devices() {
+    let devices = devices().expect("adb devices");
+    for device in &devices {
+        println!("{:<16} {:<14} {} ({:?})", device.serial, device.state, device.label(), device.transport_id);
+    }
+    assert!(!devices.is_empty(), "no devices connected");
+}
+
+#[test]
+#[ignore]
+fn streams_batches_and_stops_on_cancel() {
+    let serial = serial().expect("a single connected device, or OPENIDEA_ADB_DEVICE");
+    let cancel = CancellationToken::new();
+    let stop = cancel.clone();
+    let received = Arc::new(Mutex::new(Vec::<LogcatLine>::new()));
+    let sink = received.clone();
+    let started = Instant::now();
+    let stream = std::thread::spawn(move || {
+        ide_android::logcat(&serial, false, &stop, &mut |batch| {
+            sink.lock().unwrap().extend(batch);
+        })
+    });
+    // Enough to see the tail seed and a few live lines from a device that idles.
+    std::thread::sleep(Duration::from_secs(4));
+    cancel.cancel();
+    stream.join().unwrap().expect("logcat stops cleanly when cancelled");
+    let lines = received.lock().unwrap();
+    println!("{} lines in {:?}", lines.len(), started.elapsed());
+    for line in lines.iter().rev().take(5) {
+        println!("{:<14} {:>6} {}", line.tag, line.pid, line.message);
+    }
+    assert!(!lines.is_empty(), "no lines within 4s");
+    assert!(lines.iter().any(|l| l.level != LogcatLevel::Unknown), "every line failed to parse");
+}
@@ -821,13 +821,14 @@ fn launch_class_dirs(system: BuildSystem, module: &Path, test: bool) -> Vec<Path
 mod tests {
    #[test]
    fn independent_gradle_builds_keep_their_launchers_and_task_paths() {
+        let wrapper = if cfg!(windows) { "gradlew.bat" } else { "gradlew" };
        let temp = tempfile::tempdir().unwrap();
        let root = temp.path();
        for dir in ["a", "b"] {
            std::fs::create_dir_all(root.join(dir).join("app/src/main/java")).unwrap();
            std::fs::write(root.join(dir).join("settings.gradle"), "include 'app'").unwrap();
            std::fs::write(root.join(dir).join("app/build.gradle"), "plugins { id 'java' }").unwrap();
-            std::fs::write(root.join(dir).join("gradlew"), "").unwrap();
+            std::fs::write(root.join(dir).join(wrapper), "").unwrap();
        }
        let settings = ide_core::settings::GradleSettings {
            linked_projects: Some(vec!["a".into(), "b".into()]),
@@ -842,7 +843,7 @@ mod tests {
        assert_eq!(all.steps[1].cwd, root.join("b"));
        let module = super::plan(root, &model, super::BuildKind::Rebuild, Some(&root.join("b/app")), None).unwrap();
        assert_eq!(module.steps.len(), 1);
-        assert_eq!(module.steps[0].program, root.join("b/gradlew").to_string_lossy());
+        assert_eq!(module.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
        assert_eq!(module.steps[0].cwd, root.join("b"));
        assert_eq!(module.steps[0].env["JAVA_HOME"], "/jdk-b");
        assert_eq!(module.steps[0].args, ["--console=plain", ":app:clean", ":app:classes", ":app:testClasses"]);
@@ -854,7 +855,7 @@ mod tests {
        nested.path = ":b:app".into();
        model.gradle[0].projects.push(nested);
        let nested = super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).unwrap();
-        assert_eq!(nested.steps[0].program, root.join("b/gradlew").to_string_lossy());
+        assert_eq!(nested.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
        assert_eq!(nested.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
        model.gradle.clear();
        assert!(super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).is_err());
@@ -862,6 +863,7 @@ mod tests {

    #[test]
    fn absolute_linked_roots_build_the_project_and_external_source_module() {
+        let wrapper = if cfg!(windows) { "gradlew.bat" } else { "gradlew" };
        let temp = tempfile::tempdir().unwrap();
        let base = dunce::canonicalize(temp.path()).unwrap();
        let root = base.join("workspace");
@@ -871,7 +873,7 @@ mod tests {
        std::fs::write(external.join("settings.gradle"), "include 'app'").unwrap();
        let source = external.join("app/src/main/java/App.java");
        std::fs::write(&source, "class App {}").unwrap();
-        std::fs::write(external.join("gradlew"), "").unwrap();
+        std::fs::write(external.join(wrapper), "").unwrap();
        let settings = ide_core::settings::GradleSettings {
            linked_projects: Some(vec![external.to_string_lossy().into_owned()]),
            ..Default::default()
@@ -880,7 +882,7 @@ mod tests {
        model.gradle[0].env.insert("JAVA_HOME".into(), "/external-jdk".into());
        let all = super::plan(&root, &model, super::BuildKind::Build, None, None).unwrap();
        assert_eq!(all.steps[0].cwd, external);
-        assert_eq!(all.steps[0].program, external.join("gradlew").to_string_lossy());
+        assert_eq!(all.steps[0].program, external.join(wrapper).to_string_lossy());
        let module = super::plan(&root, &model, super::BuildKind::Rebuild, Some(&source), None).unwrap();
        assert_eq!(module.steps[0].cwd, external);
        assert_eq!(module.steps[0].env["JAVA_HOME"], "/external-jdk");
@@ -440,7 +440,9 @@ pub fn load(root: &Path) -> Option<GradleModel> {

 /// Loads exactly this build, without searching its child folders.
 pub fn load_build(root: &Path, dir: &Path) -> Option<GradleModel> {
-    let dir = root.join(dir);
+    // Linked builds are saved with forward slashes; rebuild the path so the launcher
+    // and module folders use the platform's separators.
+    let dir: PathBuf = root.join(dir).components().collect();
    if !SETTINGS_FILES.iter().chain(BUILD_FILES).any(|name| dir.join(name).is_file()) {
        return None;
    }
@@ -481,6 +483,15 @@ pub fn normalize_linked_projects(root: &Path, dirs: &[String]) -> ide_core::IdeR
    Ok(out)
 }

+/// The form `normalize_linked_projects` saves `dir` in, also for a folder that no longer
+/// exists, so a path the UI sends (`C:\…` on Windows) matches the saved entry.
+pub fn linked_project_key(root: &Path, dir: &str) -> String {
+    match (dunce::canonicalize(root), dunce::canonicalize(root.join(dir))) {
+        (Ok(root), Ok(path)) => rel(&root, &path),
+        _ => dir.replace('\\', "/"),
+    }
+}
+
 /// Linked build identities without reading their scripts (also used by index hot paths).
 pub(crate) fn linked_dirs(root: &Path, settings: &ide_core::settings::GradleSettings) -> Vec<String> {
    match &settings.linked_projects {
@@ -675,6 +686,30 @@ pub(crate) fn has_war_plugin(script: &str) -> bool {

 #[cfg(test)]
 mod tests {
+    #[test]
+    fn a_path_from_the_ui_finds_the_saved_link() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join("workspace");
+        let external = temp.path().join("external");
+        for dir in [root.join("a"), external.clone()] {
+            std::fs::create_dir_all(&dir).unwrap();
+            std::fs::write(dir.join("settings.gradle"), "").unwrap();
+        }
+        let native = |p: &std::path::Path| p.to_string_lossy().into_owned();
+        // Saved by linking; unlinking may send a native, absolute or non-canonical spelling.
+        for (dir, sent) in [
+            ("a", native(&root.join("a"))),
+            ("a", "a".to_owned()),
+            ("a", native(&root.join("a").join("..").join("a"))),
+            ("../external", native(&external)),
+        ] {
+            let saved = super::normalize_linked_projects(&root, &[dir.into()]).unwrap();
+            assert_eq!(super::linked_project_key(&root, &sent), saved[0], "{sent}");
+        }
+        // A folder deleted since it was linked still matches its saved entry.
+        assert_eq!(super::linked_project_key(&root, r"gone\build"), "gone/build");
+    }
+
    #[test]
    fn explicit_linkage_preserves_default_discovery_and_can_unlink_every_build() {
        let temp = tempfile::tempdir().unwrap();
@@ -80,6 +80,12 @@ pub fn load_linked(
        let repo = maven_repo.or_else(maven::default_local_repo);
        let mut m = maven::load_with_linked(root, repo, &profiles, &settings.linked_projects);
        maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
+        // The user settings' profiles can be chosen too (`-P` applies to them as well).
+        for p in maven::user_settings_file(root, settings).map(|f| maven::settings_profiles(&f)).unwrap_or_default() {
+            if !m.profiles.iter().any(|x| x.id == p.id) {
+                m.profiles.push(p);
+            }
+        }
        sync::apply_maven_cache(root, cache_dir, &mut m);
        m
    });
@@ -210,7 +216,7 @@ mod tests {
        };
        assert_eq!(
            gradle_external_roots(&root, &temp.path().join("cache"), &settings),
-            [external.canonicalize().unwrap()]
+            [dunce::canonicalize(&external).unwrap()]
        );
        settings.linked_projects = Some(vec![]);
        assert!(gradle_external_roots(&root, &temp.path().join("cache"), &settings).is_empty());
@@ -472,6 +472,41 @@ pub(crate) fn default_local_repo() -> Option<PathBuf> {
    local_repository_of(&m2.join("settings.xml")).or(Some(m2.join("repository")))
 }

+/// The user `settings.xml` a build reads: the configured one (`~/` and project-relative
+/// paths allowed), else `~/.m2/settings.xml`.
+pub fn user_settings_file(root: &Path, settings: &ide_core::settings::MavenSettings) -> Option<PathBuf> {
+    let configured = settings.user_settings.trim();
+    if configured.is_empty() {
+        return Some(dirs::home_dir()?.join(".m2").join("settings.xml"));
+    }
+    let path = match configured.strip_prefix("~/") {
+        Some(rest) => dirs::home_dir()?.join(rest),
+        None => PathBuf::from(configured),
+    };
+    Some(if path.is_absolute() { path } else { root.join(path) })
+}
+
+/// The profiles a `settings.xml` defines, for the Profiles list beside the POMs' own (as
+/// IDEA lists them): checked by default when `<activeProfiles>` names them or they are
+/// `activeByDefault`.
+pub fn settings_profiles(settings: &Path) -> Vec<MavenProfile> {
+    let Some(root) = std::fs::read_to_string(settings).ok().and_then(|text| xml::parse(&text)) else {
+        return Vec::new();
+    };
+    let active: Vec<String> =
+        root.list("activeProfiles", "activeProfile").iter().map(|e| e.text.trim().to_owned()).collect();
+    let mut profiles: Vec<MavenProfile> = Vec::new();
+    for profile in root.list("profiles", "profile") {
+        let Some(id) = profile.text_of("id") else { continue };
+        if profiles.iter().any(|p| p.id == id) {
+            continue;
+        }
+        let by_default = profile.at("activation/activeByDefault").is_some_and(|e| e.text.trim() == "true");
+        profiles.push(MavenProfile { active_by_default: by_default || active.contains(&id), id });
+    }
+    profiles
+}
+
 /// `<localRepository>` of a settings file, when it names one: the repository a build
 /// with `-s <file>` resolves into, which is not necessarily the user's default.
 pub fn local_repository_of(settings: &Path) -> Option<PathBuf> {
@@ -1536,6 +1571,37 @@ mod tests {
        assert_eq!(p.prefix, "checkstyle");
    }

+    #[test]
+    fn settings_profiles_are_listed_with_the_active_ones_checked() {
+        let tmp = tempfile::tempdir().unwrap();
+        let file = tmp.path().join("settings.xml");
+        std::fs::write(
+            &file,
+            r#"<settings>
+  <profiles>
+    <profile><id>nexus</id></profile>
+    <profile><id>jdk21</id><activation><activeByDefault>true</activeByDefault></activation></profile>
+    <profile><id>release</id></profile>
+    <profile><id>nexus</id></profile>
+    <profile><activation/></profile>
+  </profiles>
+  <activeProfiles><activeProfile>nexus</activeProfile></activeProfiles>
+</settings>"#,
+        )
+        .unwrap();
+        let p = |id: &str, active| MavenProfile { id: id.into(), active_by_default: active };
+        assert_eq!(settings_profiles(&file), [p("nexus", true), p("jdk21", true), p("release", false)]);
+        assert!(settings_profiles(&tmp.path().join("missing.xml")).is_empty());
+
+        let mut s = ide_core::settings::MavenSettings::default();
+        let home = dirs::home_dir().unwrap();
+        assert_eq!(user_settings_file(tmp.path(), &s), Some(home.join(".m2/settings.xml")));
+        s.user_settings = "conf/settings.xml".into();
+        assert_eq!(user_settings_file(tmp.path(), &s), Some(tmp.path().join("conf/settings.xml")));
+        s.user_settings = "~/work/settings.xml".into();
+        assert_eq!(user_settings_file(tmp.path(), &s), Some(home.join("work/settings.xml")));
+    }
+
    #[test]
    fn a_settings_file_names_the_repository_to_read_goals_from() {
        let tmp = tempfile::tempdir().unwrap();
@@ -24,6 +24,7 @@ pub mod text;
 pub mod tool_path;
 pub mod version_managers;
 pub mod workflow_settings;
+pub mod wsl;

 pub use error::{IdeError, IdeResult};
 pub use event::{EventSink, IdeEvent, NullSink, SharedSink};
@@ -722,6 +722,10 @@ pub struct PhpSettings {
    /// Intelephense stub sets loaded on top of its defaults and the `ext-*` entries of
    /// `composer.json` (`wordpress`).
    pub stubs: Vec<String>,
+    /// PHPStan configuration file for checking saved files; empty = the `phpstan.neon`,
+    /// `phpstan.neon.dist` or `phpstan.dist.neon` PHPStan finds in the project root. Absolute,
+    /// `~/`, or relative to the project.
+    pub phpstan_config: String,
 }

 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
@@ -30,6 +30,21 @@ pub fn search_path() -> OsString {
    std::env::join_paths(dirs).unwrap_or_default()
 }

+/// Ruby code printing where `gem install` puts executables: the Ruby's own `Gem.bindir`, which
+/// Homebrew's Ruby keeps off `PATH`, and the `--user-install` one.
+pub const RUBY_GEM_BIN_SCRIPT: &str = "puts Gem.bindir, File.join(Gem.user_dir, 'bin')";
+
+/// The directories [`RUBY_GEM_BIN_SCRIPT`] printed that exist.
+pub fn gem_bin_dirs(output: &str) -> Vec<PathBuf> {
+    let mut dirs: Vec<PathBuf> = Vec::new();
+    for dir in output.lines().map(str::trim).map(PathBuf::from) {
+        if dir.is_absolute() && dir.is_dir() && !dirs.contains(&dir) {
+            dirs.push(dir);
+        }
+    }
+    dirs
+}
+
 /// Resolves a command on the shared path, or an explicit path relative to `root`.
 pub fn find_command(command: &str, search: &OsStr, root: &Path) -> Option<PathBuf> {
    let path = Path::new(command);
@@ -0,0 +1,137 @@
+//! Projects that live inside a WSL distro are reached from Windows through the
+//! `\\wsl.localhost\<distro>` (or legacy `\\wsl$\<distro>`) share.
+
+use std::path::Path;
+
+/// The WSL launcher on Windows.
+pub const EXE: &str = "wsl.exe";
+
+/// A location inside a WSL distro.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct WslPath {
+    pub distro: String,
+    /// Absolute Linux path, e.g. `/home/me/app`.
+    pub path: String,
+}
+
+/// Splits a WSL share path into distro and Linux path. Pure string work, so it
+/// accepts every spelling the UI and the OS produce: `\\wsl.localhost\X\a`,
+/// `//wsl$/X/a` and the verbatim `\\?\UNC\wsl.localhost\X\a`.
+pub fn parse(path: &Path) -> Option<WslPath> {
+    let s = path.to_string_lossy().replace('\\', "/");
+    let s = match s.strip_prefix("//?/UNC/") {
+        Some(rest) => format!("//{rest}"),
+        None => s,
+    };
+    let rest = s.strip_prefix("//")?;
+    let (host, rest) = rest.split_once('/')?;
+    if !host.eq_ignore_ascii_case("wsl.localhost") && !host.eq_ignore_ascii_case("wsl$") {
+        return None;
+    }
+    let (distro, tail) = rest.split_once('/').unwrap_or((rest, ""));
+    if distro.is_empty() {
+        return None;
+    }
+    Some(WslPath { distro: distro.to_owned(), path: format!("/{}", tail.trim_end_matches('/')) })
+}
+
+/// A distro name `wsl.exe -d` can be given safely: Windows creates them from letters, digits,
+/// `.`, `_` and `-`. A leading `-` would be read as an option, so it is refused too.
+pub fn is_valid_distro(name: &str) -> bool {
+    !name.is_empty()
+        && name.len() <= 64
+        && !name.starts_with('-')
+        && name.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-'))
+}
+
+/// Text of `wsl.exe`'s own output: UTF-16LE (with or without BOM) for its management commands
+/// and its error messages, UTF-8 for what a command inside the distro prints.
+pub fn decode_output(raw: &[u8]) -> String {
+    if raw.starts_with(&[0xff, 0xfe]) || raw.get(1) == Some(&0) {
+        let units: Vec<u16> = raw.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect();
+        String::from_utf16_lossy(&units)
+    } else {
+        String::from_utf8_lossy(raw).into_owned()
+    }
+}
+
+/// Distro names from the output of `wsl.exe -l -q`. That output is UTF-16LE (UTF-8 when
+/// `WSL_UTF8=1`), one name per line; names that fail [`is_valid_distro`] are dropped, which also
+/// removes the localized "no installed distributions" message `wsl.exe` prints when there are none.
+pub fn parse_distro_list(raw: &[u8]) -> Vec<String> {
+    let text = decode_output(raw);
+    let mut names: Vec<String> = Vec::new();
+    for line in text.lines() {
+        let name = line.trim_matches(|c: char| c.is_whitespace() || c == '\u{feff}');
+        if is_valid_distro(name) && !names.iter().any(|n| n == name) {
+            names.push(name.to_owned());
+        }
+    }
+    names
+}
+
+/// Installed WSL distros. Empty off Windows, when WSL is not installed or when `wsl.exe` fails.
+pub fn list_distros() -> Vec<String> {
+    #[cfg(windows)]
+    {
+        let mut cmd = std::process::Command::new(EXE);
+        cmd.args(["-l", "-q"]);
+        crate::process::prepare(&mut cmd);
+        match cmd.output() {
+            Ok(out) if out.status.success() => parse_distro_list(&out.stdout),
+            _ => Vec::new(),
+        }
+    }
+    #[cfg(not(windows))]
+    Vec::new()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn p(s: &str) -> Option<(String, String)> {
+        parse(Path::new(s)).map(|w| (w.distro, w.path))
+    }
+
+    #[test]
+    fn every_spelling_of_the_share_is_recognised() {
+        let want = Some(("Ubuntu-24.04".to_owned(), "/home/me/app".to_owned()));
+        assert_eq!(p(r"\\wsl.localhost\Ubuntu-24.04\home\me\app"), want);
+        assert_eq!(p("//wsl.localhost/Ubuntu-24.04/home/me/app"), want);
+        assert_eq!(p(r"\\wsl$\Ubuntu-24.04\home\me\app\"), want);
+        assert_eq!(p(r"\\?\UNC\WSL.LOCALHOST\Ubuntu-24.04\home\me\app"), want);
+    }
+
+    #[test]
+    fn distro_root_and_foreign_paths() {
+        assert_eq!(p(r"\\wsl.localhost\Debian"), Some(("Debian".to_owned(), "/".to_owned())));
+        assert_eq!(p(r"\\server\share\a"), None);
+        assert_eq!(p(r"\\wsl.localhost\"), None);
+        assert_eq!(p("C:/Users/me"), None);
+        assert_eq!(p("/home/me"), None);
+    }
+
+    fn utf16(s: &str) -> Vec<u8> {
+        std::iter::once(0xfeffu16).chain(s.encode_utf16()).flat_map(u16::to_le_bytes).collect()
+    }
+
+    #[test]
+    fn distro_list_is_decoded_from_utf16_and_utf8() {
+        let want = vec!["Ubuntu-24.04".to_owned(), "Debian".to_owned()];
+        assert_eq!(parse_distro_list(&utf16("Ubuntu-24.04\r\nDebian\r\n\r\n")), want);
+        assert_eq!(parse_distro_list(b"Ubuntu-24.04\nDebian\nDebian\n"), want);
+        assert!(
+            parse_distro_list(&utf16("Windows Subsystem for Linux has no installed distributions.\r\n")).is_empty()
+        );
+        assert!(parse_distro_list(b"").is_empty());
+    }
+
+    #[test]
+    fn distro_names_cannot_smuggle_options_or_paths() {
+        for bad in ["", "-d", "--exec", "a b", "a/b", r"a\b", "a;b", "a$(x)", "a\"b"] {
+            assert!(!is_valid_distro(bad), "{bad}");
+        }
+        assert!(is_valid_distro("Ubuntu-22.04") && is_valid_distro("docker_desktop"));
+    }
+}
@@ -1,8 +1,8 @@
 //! "Import a report collected in CI from disk": the format is sniffed from the
-//! content (lcov, Go cover profile, JaCoCo XML) and paths recorded on another
+//! content (lcov, Go cover profile, JaCoCo XML, SimpleCov resultset) and paths recorded on another
 //! machine are mapped into the project by their longest existing suffix.

-use crate::{Accumulator, CoverageSuite, goprofile, jacoco, lcov};
+use crate::{Accumulator, CoverageSuite, goprofile, jacoco, lcov, simplecov};
 use ide_core::{IdeError, IdeResult};
 use std::path::{Component, Path, PathBuf};

@@ -11,6 +11,7 @@ pub(crate) enum Format {
    Lcov,
    GoProfile,
    Jacoco,
+    SimpleCov,
 }

 pub(crate) fn detect(text: &str) -> Option<Format> {
@@ -18,6 +19,9 @@ pub(crate) fn detect(text: &str) -> Option<Format> {
    if head.starts_with('<') {
        return head.contains("<report").then_some(Format::Jacoco);
    }
+    if head.starts_with('{') {
+        return head.contains("\"coverage\"").then_some(Format::SimpleCov);
+    }
    let first = head.lines().next().unwrap_or_default();
    if first.starts_with("mode:") {
        return Some(Format::GoProfile);
@@ -30,6 +34,7 @@ pub fn import(path: &Path, root: &Path) -> IdeResult<CoverageSuite> {
    let text = std::fs::read_to_string(path)?;
    let mut suite = match detect(&text) {
        Some(Format::Lcov) => lcov::parse(&text, root).finish("lcov"),
+        Some(Format::SimpleCov) => simplecov::parse(&text, root)?.finish("SimpleCov"),
        Some(Format::GoProfile) => {
            let (module, module_dir) = go_module_for(root, &text);
            goprofile::parse(&text, &module, &module_dir).finish("go test -cover")
@@ -50,7 +55,7 @@ pub fn import(path: &Path, root: &Path) -> IdeResult<CoverageSuite> {
        }
        None => {
            return Err(IdeError::invalid(format!(
-                "{} is not an lcov tracefile, Go cover profile or JaCoCo XML report",
+                "{} is not an lcov tracefile, Go cover profile, JaCoCo XML report or SimpleCov resultset",
                path.display()
            )));
        }
@@ -125,9 +130,29 @@ mod tests {
            Some(Format::Jacoco)
        );
        assert_eq!(detect("<?xml version=\"1.0\"?><coverage/>"), None);
+        assert_eq!(detect("{\"RSpec\": {\"coverage\": {}}}"), Some(Format::SimpleCov));
+        assert_eq!(detect("{\"name\": \"package.json\"}"), None);
        assert_eq!(detect("hello"), None);
    }

+    #[test]
+    fn imports_ci_simplecov_with_foreign_paths() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path().join("app");
+        std::fs::create_dir_all(root.join("lib")).unwrap();
+        std::fs::write(root.join("lib/a.rb"), "").unwrap();
+        let report = tmp.path().join(".resultset.json");
+        std::fs::write(
+            &report,
+            r#"{"RSpec":{"coverage":{"/home/runner/work/app/app/lib/a.rb":{"lines":[null,1,0]}}}}"#,
+        )
+        .unwrap();
+        let suite = import(&report, &root).unwrap();
+        assert_eq!(suite.runner, "SimpleCov");
+        assert_eq!(suite.files[0].path.as_ref() as &Path, root.join("lib/a.rb"));
+        assert_eq!((suite.files[0].lines_total, suite.files[0].lines_covered), (2, 1));
+    }
+
    #[test]
    fn imports_ci_lcov_with_foreign_paths() {
        let tmp = tempfile::tempdir().unwrap();
@@ -10,6 +10,7 @@
 //! | JS / TS (vitest, jest scripts) | the runner's `--coverage` | lcov |
 //! | Node.js scripts | `c8` | lcov |
 //! | Python (pytest, scripts) | coverage.py (`coverage run`, then `coverage lcov`) | lcov |
+//! | Ruby (rspec, minitest, rake, scripts) | SimpleCov (`coverage/.resultset.json`) | SimpleCov resultset |
 //! | Go (`go test`) | `-coverprofile` | Go cover profile |
 //! | Maven / Gradle tests | JaCoCo (plugin goals / an init script) | JaCoCo XML |
 //!
@@ -20,6 +21,7 @@ mod import;
 mod jacoco;
 mod lcov;
 mod plan;
+mod simplecov;

 pub use import::import;
 pub use plan::prepare;
@@ -83,6 +85,8 @@ pub enum CoverageReportSpec {
    Lcov { runner: String, path: IpcPath, base: IpcPath },
    /// `go test -coverprofile`; import paths under `module` map to `module_dir`.
    GoProfile { path: IpcPath, module: String, module_dir: IpcPath },
+    /// SimpleCov's `.resultset.json`; relative paths resolve against `base`.
+    SimpleCov { path: IpcPath, base: IpcPath },
    /// Every JaCoCo XML report (Maven `target/site/jacoco`, Gradle `build/reports/jacoco`) under `dir`.
    Jacoco { dir: IpcPath },
    /// The tool's raw data is exported to lcov by `argv` first (coverage.py: `… -m coverage lcov -o <lcov>`).
@@ -185,6 +189,10 @@ pub fn collect(spec: &CoverageReportSpec) -> IdeResult<CoverageSuite> {
            let text = read_report(path)?;
            Ok(lcov::parse(&text, base).finish(runner))
        }
+        CoverageReportSpec::SimpleCov { path, base } => {
+            let text = read_report(path)?;
+            Ok(simplecov::parse(&text, base)?.finish("SimpleCov"))
+        }
        CoverageReportSpec::GoProfile { path, module, module_dir } => {
            let text = read_report(path)?;
            Ok(goprofile::parse(&text, module, module_dir).finish("go test -cover"))
@@ -67,6 +67,7 @@ pub fn prepare(root: &Path, config: &RunConfig, out: &Path) -> CoveragePrepared
        "gradle" | "gradlew" => gradle(config, &dir, out),
        "npm" | "pnpm" | "yarn" | "bun" => npm(root, config, &dir, out),
        "node" | "npx" | "tsx" | "ts-node" => c8(root, config, &dir, out),
+        "ruby" | "bundle" | "rake" | "rspec" | "rails" => ruby(root, config, &dir, out),
        "deno" => unsupported("Coverage of Deno tasks is not supported yet."),
        "java" => unsupported(
            "Coverage of Java applications needs the JaCoCo agent; run a Maven or Gradle test configuration with coverage.",
@@ -234,6 +235,65 @@ fn c8(root: &Path, config: &RunConfig, dir: &Path, out: &Path) -> CoveragePrepar
    ready("c8", config, path(&c8), args, report)
 }

+/// Loaded first (`ide_run::ruby_preload`) when the project never starts SimpleCov itself.
+const SIMPLECOV_PRELOAD: &str = r#"# Written by OpenIDEA for Run with Coverage.
+begin
+  require "simplecov"
+rescue LoadError
+  # `bundle exec` is a Ruby process too and loads this before Bundler puts the project's gems on
+  # the load path; the Ruby it starts loads bundler/setup first and finds SimpleCov.
+  return
+end
+SimpleCov.coverage_dir(ENV.fetch("OPENIDEA_COVERAGE_DIR"))
+SimpleCov.start do
+  add_filter %r{^/(test|spec|features)/}
+  enable_coverage :branch
+end
+"#;
+
+/// Files where a project conventionally starts SimpleCov.
+const SIMPLECOV_STARTERS: &[&str] =
+    &[".simplecov", "spec/spec_helper.rb", "spec/rails_helper.rb", "test/test_helper.rb", "test/minitest_helper.rb"];
+
+fn ruby(root: &Path, config: &RunConfig, dir: &Path, out: &Path) -> CoveragePrepared {
+    let bundled = [dir, root].iter().any(|d| d.join("Gemfile").is_file());
+    let mentions = |file: &str| {
+        [dir, root].iter().any(|d| std::fs::read_to_string(d.join(file)).is_ok_and(|t| t.contains("simplecov")))
+    };
+    if bundled && !mentions("Gemfile.lock") && !mentions("Gemfile") {
+        return missing(
+            "simplecov",
+            "Ruby coverage needs the simplecov gem in the project's Gemfile.",
+            Some((vec![s("bundle"), s("add"), s("simplecov"), s("--group"), s("test")], dir)),
+        );
+    }
+    let starts = |d: &Path| {
+        SIMPLECOV_STARTERS.iter().any(|f| {
+            std::fs::read_to_string(d.join(f))
+                .is_ok_and(|t| t.contains("SimpleCov.start") || f.starts_with(".simplecov"))
+        })
+    };
+    let mut config = config.clone();
+    let resultset = if [dir, root].iter().any(|d| starts(d)) {
+        // The project's own configuration decides where the report goes (default `coverage/`).
+        // Drop the previous run's data: SimpleCov merges into it.
+        let results = dir.join("coverage");
+        let _ = std::fs::remove_file(results.join(".resultset.json"));
+        results.join(".resultset.json")
+    } else {
+        let preload = out.join("openidea_simplecov.rb");
+        if let Err(e) = std::fs::write(&preload, SIMPLECOV_PRELOAD) {
+            return unsupported(format!("Cannot write the SimpleCov preload: {e}"));
+        }
+        config.env.insert(s("OPENIDEA_COVERAGE_DIR"), path(out));
+        // `out` lives under the IDE's data directory, which may have spaces (RUBYOPT cannot take them).
+        ide_run::ruby_preload::add(&mut config.env, out, "openidea_simplecov", true);
+        out.join(".resultset.json")
+    };
+    let report = CoverageReportSpec::SimpleCov { path: resultset.into(), base: dir.to_path_buf().into() };
+    ready("SimpleCov", &config, config.command.clone(), config.args.clone(), report)
+}
+
 fn python(config: &RunConfig, dir: &Path, out: &Path, py: wrap::PythonCommand) -> CoveragePrepared {
    if py.target.is_empty() {
        return unsupported("Coverage needs a Python script or module to run.");
@@ -398,6 +458,74 @@ mod tests {
        ));
    }

+    /// `bundle exec` loads the preload before Bundler sets up the project's gems: without SimpleCov
+    /// on the load path it must step aside instead of failing the launcher.
+    #[test]
+    fn simplecov_preload_tolerates_a_ruby_without_the_gem() {
+        let dir = tempfile::tempdir().unwrap();
+        let out = dir.path().join("out dir");
+        std::fs::create_dir_all(&out).unwrap();
+        std::fs::write(out.join("openidea_simplecov.rb"), SIMPLECOV_PRELOAD).unwrap();
+        let status = std::process::Command::new("ruby")
+            .args(["-e", "exit 0"])
+            .env("RUBYLIB", &out)
+            .env("RUBYOPT", "-ropenidea_simplecov")
+            .env("OPENIDEA_COVERAGE_DIR", &out)
+            .env("GEM_HOME", dir.path().join("empty gems"))
+            .env("GEM_PATH", dir.path().join("empty gems"))
+            .status();
+        // No Ruby on this machine: nothing to check.
+        let Ok(status) = status else { return };
+        assert!(status.success());
+    }
+
+    #[test]
+    fn ruby_runs_get_simplecov() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        // The IDE's data directory has spaces on macOS (`Application Support`).
+        let out = root.join("out dir");
+        std::fs::create_dir_all(&out).unwrap();
+        std::fs::write(root.join("Gemfile"), "source 'https://rubygems.org'\n").unwrap();
+        let config = cfg("rspec", "bundle", &["exec", "rspec"]);
+        // Bundler project without the gem: install hint.
+        match prepare(root, &config, &out) {
+            CoveragePrepared::MissingTool { tool, install: Some(i), .. } => {
+                assert_eq!(tool, "simplecov");
+                assert_eq!(i.args, ["add", "simplecov", "--group", "test"]);
+            }
+            other => panic!("{other:?}"),
+        }
+        // Gem present, never started: preloaded through RUBYOPT, report in `out`.
+        std::fs::write(root.join("Gemfile"), "gem 'simplecov'\n").unwrap();
+        let p = prepare(root, &config, &out);
+        let (l, report) = launch(&p);
+        assert_eq!(
+            (l.command.as_str(), l.args.as_slice()),
+            ("bundle", ["exec".to_owned(), "rspec".to_owned()].as_slice())
+        );
+        assert!(l.env["RUBYOPT"].contains("-ropenidea_simplecov"));
+        assert!(std::env::split_paths(&l.env["RUBYLIB"]).any(|d| d == out));
+        assert_eq!(l.env["OPENIDEA_COVERAGE_DIR"], out.to_string_lossy());
+        assert!(out.join("openidea_simplecov.rb").is_file());
+        assert!(
+            matches!(report, CoverageReportSpec::SimpleCov { path, .. } if (path.as_ref() as &Path).starts_with(&out))
+        );
+        // Started by the project: untouched environment, stale data dropped, report in `coverage/`.
+        std::fs::create_dir_all(root.join("test")).unwrap();
+        std::fs::create_dir_all(root.join("coverage")).unwrap();
+        std::fs::write(root.join("coverage/.resultset.json"), "{}").unwrap();
+        std::fs::write(root.join("test/test_helper.rb"), "require 'simplecov'\nSimpleCov.start\n").unwrap();
+        let p = prepare(root, &cfg("ruby", "ruby", &["-Ilib", "test/a_test.rb"]), &out);
+        let (l, report) = launch(&p);
+        assert!(!l.env.contains_key("RUBYOPT"));
+        assert_eq!(l.args, ["-Ilib", "test/a_test.rb"]);
+        assert!(!root.join("coverage/.resultset.json").exists());
+        assert!(
+            matches!(report, CoverageReportSpec::SimpleCov { path, .. } if (path.as_ref() as &Path).ends_with("coverage/.resultset.json"))
+        );
+    }
+
    #[test]
    fn unknown_commands_are_unsupported() {
        let dir = tempfile::tempdir().unwrap();
@@ -0,0 +1,74 @@
+//! SimpleCov's `coverage/.resultset.json`:
+//!
+//! ```json
+//! { "RSpec": { "timestamp": 1, "coverage": {
+//!     "/abs/lib/a.rb": { "lines": [null, 1, 0],
+//!                        "branches": { "[:if, 0, 3, 4, 3, 20]": { "[:then, 1, 4, 6, 4, 9]": 1, "[:else, 2, 6, 6, 6, 9]": 0 } } },
+//!     "/abs/lib/legacy.rb": [null, 1] } } }
+//! ```
+//!
+//! `lines[i]` is line `i + 1` (`null` = not relevant), so the index is already 0-based.
+//! A branch belongs to the line its condition starts on (third number of its key).
+
+use crate::Accumulator;
+use ide_core::{IdeError, IdeResult};
+use serde_json::Value;
+use std::path::Path;
+
+/// Start line (1-based) of a `"[:if, 0, 3, 4, 3, 20]"` branch key.
+fn start_line(key: &str) -> Option<u32> {
+    key.trim_matches(['[', ']']).split(',').nth(2)?.trim().parse().ok()
+}
+
+pub(crate) fn parse(text: &str, base: &Path) -> IdeResult<Accumulator> {
+    let json: Value = serde_json::from_str(text).map_err(|e| IdeError::invalid(format!("SimpleCov resultset: {e}")))?;
+    let mut acc = Accumulator::default();
+    // One entry per test command ("RSpec", "Minitest", …); their coverage is merged.
+    for suite in json.as_object().into_iter().flat_map(|o| o.values()) {
+        let Some(files) = suite.get("coverage").and_then(Value::as_object) else { continue };
+        for (name, data) in files {
+            let p = Path::new(name);
+            let path = if p.is_absolute() { p.to_path_buf() } else { base.join(p) };
+            acc.file(&path);
+            let lines = data.get("lines").or(Some(data)).and_then(Value::as_array);
+            for (i, hits) in lines.into_iter().flatten().enumerate() {
+                if let Some(hits) = hits.as_u64() {
+                    acc.line(&path, i as u32, hits);
+                }
+            }
+            for (cond, branches) in data.get("branches").and_then(Value::as_object).into_iter().flatten() {
+                let Some(line) = start_line(cond) else { continue };
+                for (branch, hits) in branches.as_object().into_iter().flatten() {
+                    acc.has_branches = true;
+                    acc.branch(&path, line.saturating_sub(1), format!("{cond}/{branch}"), hits.as_u64() > Some(0));
+                }
+            }
+        }
+    }
+    Ok(acc)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_lines_branches_and_merges_suites() {
+        let text = r#"{
+          "RSpec": {"coverage": {"/p/lib/a.rb": {"lines": [null, 1, 0],
+            "branches": {"[:if, 0, 2, 4, 2, 20]": {"[:then, 1, 2, 6, 2, 9]": 1, "[:else, 2, 2, 6, 2, 9]": 0}}}}},
+          "Minitest": {"coverage": {"/p/lib/a.rb": {"lines": [null, 2, 3]}, "lib/old.rb": [1, null]}}
+        }"#;
+        let suite = parse(text, Path::new("/p")).unwrap().finish("SimpleCov");
+        assert_eq!(suite.files.len(), 2);
+        let a = suite.files.iter().find(|f| (f.path.as_ref() as &Path).ends_with("a.rb")).unwrap();
+        assert_eq!(a.lines.iter().map(|l| (l.line, l.hits)).collect::<Vec<_>>(), [(1, 3), (2, 3)]);
+        assert_eq!((a.branches_total, a.branches_covered), (2, 1));
+        assert_eq!(a.lines[0].branches_total, 2);
+        let old = suite.files.iter().find(|f| (f.path.as_ref() as &Path).ends_with("lib/old.rb")).unwrap();
+        assert_eq!(old.path.as_ref() as &Path, Path::new("/p/lib/old.rb"));
+        assert_eq!(old.lines[0].hits, 1);
+        assert!(suite.has_branches);
+        assert!(parse("nope", Path::new("/p")).is_err());
+    }
+}
@@ -302,6 +302,23 @@ pub struct DebugManager {
    data_breakpoints: Mutex<Vec<DataBreakpoint>>,
 }

+/// Whether the debugged project depends on the Flutter SDK, so it must go
+/// through `flutter debug_adapter` instead of the plain Dart one.
+///
+/// `dart debug_adapter` cannot start a program that imports `dart:ui`, and only
+/// the Flutter adapter answers `hotReload` / `hotRestart`. `dir` is the launch
+/// `cwd`; the program's own directory is tried first because a module inside a
+/// larger repository has its `pubspec.yaml` above the program, not above `cwd`.
+fn is_flutter_project(dir: &Path, program: Option<&Path>) -> bool {
+    let mut start: Vec<&Path> = program.and_then(Path::parent).into_iter().collect();
+    start.push(dir);
+    start
+        .iter()
+        .filter_map(|d| d.ancestors().take(6).find(|a| a.join("pubspec.yaml").is_file()))
+        .filter_map(|root| std::fs::read_to_string(root.join("pubspec.yaml")).ok())
+        .any(|s| s.contains("sdk: flutter"))
+}
+
 fn no_session(s: DebugSessionId) -> IdeError {
    IdeError::not_found(format!("no debug session {}", s.0))
 }
@@ -570,6 +587,10 @@ impl DebugManager {
        custom_command: impl FnOnce(&str) -> Option<String>,
    ) -> IdeResult<DebugSessionId> {
        let mut arguments = launch_arguments(&config)?;
+        // An IDE-side marker (never sent to the adapter): the session is a Flutter
+        // one regardless of what the working directory holds.
+        let force_flutter =
+            arguments.as_object_mut().and_then(|o| o.remove("__flutter")).and_then(|v| v.as_bool()).unwrap_or(false);
        let cwd = config
            .cwd
            .clone()
@@ -601,6 +622,15 @@ impl DebugManager {
                spec.command = python;
            }
        }
+        // Flutter: a project depending on the Flutter SDK needs `flutter debug_adapter`
+        // (the Dart adapter cannot start a program importing `dart:ui`, and hot reload
+        // is Flutter-only). Plain Dart projects keep the configured `dart`.
+        if config.adapter == "dart" && spec.command == "dart" {
+            let program = arguments.get("program").and_then(Value::as_str).map(Path::new);
+            if force_flutter || is_flutter_project(&cwd, program) {
+                spec.command = "flutter".into();
+            }
+        }
        let id = DebugSessionId::next();
        let debug_server = take_debug_server(&mut arguments)?;
        if let Some(server) = &debug_server {
@@ -1236,6 +1266,19 @@ impl DebugManager {
        Ok(())
    }

+    /// Flutter's DAP adapter: injects the changed sources into the running app.
+    /// Not part of the DAP standard; adapters that do not know the request reject it.
+    pub async fn hot_reload(&self, s: DebugSessionId) -> IdeResult<()> {
+        self.session(s)?.conn.request_timeout("hotReload", json!({ "reason": "manual" }), REQUEST_TIMEOUT).await?;
+        Ok(())
+    }
+
+    /// Flutter's DAP adapter: restarts the app without preserving state.
+    pub async fn hot_restart(&self, s: DebugSessionId) -> IdeResult<()> {
+        self.session(s)?.conn.request_timeout("hotRestart", json!({ "reason": "manual" }), REQUEST_TIMEOUT).await?;
+        Ok(())
+    }
+
    pub async fn step(&self, s: DebugSessionId, thread_id: i64, kind: StepKind) -> IdeResult<()> {
        let command = match kind {
            StepKind::Over => "next",
@@ -1269,3 +1269,19 @@ async fn a_plugin_language_runs_its_debug_adapter_from_the_approved_program() {
    assert_eq!(err.kind, ide_core::error::ErrorKind::PermissionDenied, "{}", err.message);
    let _ = std::fs::remove_dir_all(&dir);
 }
+
+#[test]
+fn flutter_projects_are_found_from_the_program_or_the_working_directory() {
+    let root = std::env::temp_dir().join(format!("openidea-flutter-{}", std::process::id()));
+    let app = root.join("app");
+    let tool = root.join("tool");
+    std::fs::create_dir_all(app.join("lib")).unwrap();
+    std::fs::create_dir_all(tool.join("bin")).unwrap();
+    std::fs::write(app.join("pubspec.yaml"), "name: app\ndependencies:\n  flutter:\n    sdk: flutter\n").unwrap();
+    std::fs::write(tool.join("pubspec.yaml"), "name: tool\ndependencies:\n  args: ^2.0.0\n").unwrap();
+    assert!(is_flutter_project(&app, None));
+    assert!(is_flutter_project(&root, Some(&app.join("lib/main.dart"))));
+    assert!(!is_flutter_project(&tool, Some(&tool.join("bin/main.dart"))));
+    assert!(!is_flutter_project(&root, None));
+    std::fs::remove_dir_all(&root).unwrap();
+}
@@ -79,7 +79,9 @@ impl Capability {
            Self::Secrets => "Store secrets in the system keychain".into(),
            Self::Events => "Observe workbench events (files opened, saved, focus)".into(),
            Self::InputEvents => "Observe keystrokes and editor input".into(),
-            Self::Clipboard => "Read and write the clipboard from its web views".into(),
+            Self::Clipboard => {
+                "Copy to the clipboard from its commands, and read and write it from its web views".into()
+            }
            Self::Net(host) => format!("Connect to {host} (from the machine the project is on)"),
            Self::Process(bin) => format!("Run {bin} — equivalent to running arbitrary code on this machine"),
            Self::FsRead(path) => format!("Read files under {path}, outside the project"),
@@ -32,7 +32,7 @@ use std::path::{Component, Path, PathBuf};

 pub const MANIFEST_FILE: &str = "plugin.toml";
 /// The plugin API (engine) version this host implements.
-pub const ENGINE_VERSION: &str = "1.0.0";
+pub const ENGINE_VERSION: &str = "1.1.0";
 /// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
 pub const LEGACY_API: &str = "0.1";
 /// Marketplace categories, in the order they are shown.
@@ -10,6 +10,7 @@ mod java_runtime;
 mod kotlin_bridge;
 pub mod notebook;
 pub mod ops;
+mod phpstan;
 pub mod plugins;
 mod project;
 mod proxy;
@@ -86,6 +87,8 @@ pub struct Host {
    project_requests: RwLock<HashMap<String, Vec<RequestId>>>,
    /// Shutdowns of projects closed with [`Host::close_project_detached`].
    closing: parking_lot::Mutex<Vec<std::thread::JoinHandle<()>>>,
+    /// One open at a time per window (see [`Host::opening`]).
+    open_locks: parking_lot::Mutex<HashMap<String, Arc<parking_lot::Mutex<()>>>>,
 }

 /// How long exit waits for project shutdown before giving up.
@@ -135,6 +138,7 @@ impl Host {
            requests: Default::default(),
            project_requests: RwLock::default(),
            closing: Default::default(),
+            open_locks: Default::default(),
        };
        host.apply_proxy();
        host
@@ -225,6 +229,9 @@ impl Host {
        if let Some(bridge) = &project.kotlin_bridge {
            bridge.stop();
        }
+        if let Some(phpstan) = &project.phpstan {
+            phpstan.stop();
+        }
        project.documents.clear_workspace_edit_history();
        project.agents.shutdown();
        project.notebooks.stop_admission();
@@ -346,6 +353,9 @@ impl Host {
            if let Some(bridge) = &project.kotlin_bridge {
                bridge.stop();
            }
+            if let Some(phpstan) = &project.phpstan {
+                phpstan.stop();
+            }
            project.documents.clear_workspace_edit_history();
            project.notebooks.stop_admission();
            project.agents.shutdown();
@@ -401,6 +411,13 @@ impl Host {
        self.requests.cancel(id);
    }

+    /// The lock an open of `window` holds from its check for the current project to its
+    /// insert: two opens racing (a double click, a launch path and a restore) would each start
+    /// an index, language servers and watchers, and the second would replace the first unclosed.
+    pub(crate) fn opening(&self, window: &str) -> Arc<parking_lot::Mutex<()>> {
+        self.open_locks.lock().entry(window.to_owned()).or_default().clone()
+    }
+
    pub(crate) fn insert_project(&self, window: &str, project: Arc<Project>) {
        self.projects.write().insert(window.to_owned(), project);
    }
@@ -1,7 +1,7 @@
 //! Project-incarnation notebook ownership and whole-batch execution admission.
 use crate::ops::Channel;
 use ide_core::error::ErrorKind;
-use ide_core::{CancellationToken, IdeError, IdeEvent, IdeResult, SharedSink};
+use ide_core::{CancellationToken, IdeError, IdeEvent, IdeResult, IpcPath, SharedSink};
 use ide_notebook::kernel::{KernelManager, KernelOutput};
 use ide_notebook::{NotebookDocument, NotebookEdit, NotebookSnapshot};
 use parking_lot::Mutex;
@@ -17,7 +17,7 @@ use tokio::sync::{Mutex as AsyncMutex, watch};
 #[serde(rename_all = "camelCase")]
 pub struct NotebookOutputEvent {
    pub id: String,
-    pub path: String,
+    pub path: IpcPath,
    pub cell: String,
    pub msg_id: String,
    pub kind: String,
@@ -536,7 +536,7 @@ fn commit_output(
    };
    Ok(Some(NotebookOutputEvent {
        id: document.id.clone(),
-        path: document.path.to_string_lossy().into_owned(),
+        path: document.path.clone().into(),
        cell: cell.to_owned(),
        msg_id: output.msg_id,
        kind: output.kind,
@@ -592,6 +592,16 @@ mod tests {
        other.shutdown().await;
    }

+    #[tokio::test]
+    async fn the_notebook_path_reaches_the_ui_as_the_project_tree_names_it() {
+        let (dir, service, _) = fixture();
+        let ui_path =
+            format!("{}/session.ipynb", ide_core::ipc_path::to_ipc(&dunce::canonicalize(dir.path()).unwrap()));
+        let snapshot = service.open(Path::new(&ui_path)).unwrap();
+        assert_eq!(serde_json::to_value(&snapshot).unwrap()["path"], ui_path);
+        service.shutdown().await;
+    }
+
    #[tokio::test(start_paused = true)]
    async fn failed_close_keeps_the_incarnation_recoverable_until_a_retry_succeeds() {
        let (dir, service, initial) = fixture();
@@ -137,7 +137,8 @@ fn linked_gradle_paths(
            }
        }
    } else {
-        linked.retain(|path| !paths.contains(path));
+        let unlinked: Vec<String> = paths.iter().map(|p| ide_build::gradle::linked_project_key(root, p)).collect();
+        linked.retain(|path| !paths.contains(path) && !unlinked.contains(path));
    }
    Ok(linked)
 }
@@ -32,7 +32,7 @@ pub async fn coverage_collect(host: &Host, window: &str, report: CoverageReportS
    blocking(move || ide_coverage::collect(&report)).await
 }

-/// Reads a report collected elsewhere (CI): lcov, a Go cover profile or JaCoCo XML,
+/// Reads a report collected elsewhere (CI): lcov, a Go cover profile, JaCoCo XML or a SimpleCov resultset,
 /// with paths mapped into this project.
 pub async fn coverage_import(host: &Host, window: &str, path: IpcPath) -> IdeResult<CoverageSuite> {
    let root = host.project(window)?.root.clone();
@@ -162,6 +162,14 @@ pub async fn debug_pause(host: &Host, _window: &str, session: DebugSessionId, th
    host.debugger.pause(session, thread_id).await
 }

+pub async fn debug_hot_reload(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
+    host.debugger.hot_reload(session).await
+}
+
+pub async fn debug_hot_restart(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
+    host.debugger.hot_restart(session).await
+}
+
 pub async fn debug_step(
    host: &Host,
    _window: &str,
@@ -198,6 +198,7 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit
    let options = StartOptions {
        encoding: Some(encoding).filter(|e| !e.trim().is_empty()),
        python_paths: if *root != project.root { vec![root.clone()] } else { super::python::paths(&project) },
+        ruby_reporter: ruby_reporter_dir(host, &config),
    };
    project.require_trust()?;
    let mut sink = project.sink.clone();
@@ -214,6 +215,21 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit
    host.processes.start(&project.root, &config, &options, sink, Box::new(move |c| on_output(c)))
 }

+/// The Ruby test reporter's directory, installed on demand, for runs that take it.
+fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathBuf> {
+    if !ide_run::ruby_reporter::applies(config) {
+        return None;
+    }
+    let dir = host.local_data_dir.join("ruby-reporter");
+    match ide_run::ruby_reporter::install(&dir) {
+        Ok(()) => Some(dir),
+        Err(e) => {
+            tracing::warn!("cannot install the Ruby test reporter in {}: {e}", dir.display());
+            None
+        }
+    }
+}
+
 /// Stops a run (interrupt, then kill after Settings › Run's termination timeout).
 pub fn stop(host: &Host, window: &str, id: RunId) -> IdeResult<()> {
    let settings = match host.project(window) {
@@ -24,7 +24,11 @@ fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
        .collect();
    // Godot is usually an app bundle / Flatpak outside the search path.
    let found = ide_sdk::godot::find(None).map(|p| (ide_sdk::godot::COMMAND.to_owned(), p));
-    Ok(Tools::new(&data).with_custom_paths(custom).with_found_paths(found.into_iter().collect()))
+    let work_dir = (!root.as_os_str().is_empty()).then_some(root);
+    Ok(Tools::new(&data)
+        .with_custom_paths(custom)
+        .with_found_paths(found.into_iter().collect())
+        .with_work_dir(work_dir))
 }

 /// The language definitions plus the servers defined in the window's settings.
@@ -405,28 +405,6 @@ pub async fn vcs_log_details_batch(
    result
 }

-pub async fn vcs_log_index(
-    host: &Host,
-    window: &str,
-    repo: Option<PathBuf>,
-    request: Option<RequestId>,
-) -> IdeResult<LogIndexProgress> {
-    let project = LogAccess::new(host, window, repo.as_deref());
-    let cancel =
-        request.map_or_else(ide_core::CancellationToken::new, |id| host.begin_project_read_request(window, id));
-    let result = blocking(move || {
-        project.with_log_repo_at(repo.as_deref(), |r| {
-            r.enable_log_index(&project.cache);
-            if request.is_some() { r.index_log(&cancel) } else { Ok(r.log_index_progress()) }
-        })
-    })
-    .await;
-    if let Some(request) = request {
-        host.end_request(request);
-    }
-    result
-}
-
 pub async fn vcs_revision_children(
    host: &Host,
    window: &str,
@@ -1222,10 +1200,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
    d.add("vcs_log_details_batch", |c| async move {
        vcs_log_details_batch(&c.host, &c.window, c.arg("repo")?, c.arg("revisions")?, c.arg("request")?).await
    });
-    d.add(
-        "vcs_log_index",
-        |c| async move { vcs_log_index(&c.host, &c.window, c.arg("repo")?, c.arg("request")?).await },
-    );
    d.add("vcs_revision_children", |c| async move {
        vcs_revision_children(&c.host, &c.window, c.arg("repo")?, c.arg("revision")?, c.arg("directory")?).await
    });
@@ -0,0 +1,850 @@
+//! Saved PHP files -> `vendor/bin/phpstan analyse` -> `phpstan` diagnostics.
+
+use ide_core::event::NotifyLevel;
+use ide_core::output_encoding::decode_tool_output;
+use ide_core::{CancellationToken, Diagnostic, IdeEvent, Pos, Range, Severity, SharedSink};
+use ide_workspace::SettingsStore;
+use ide_workspace::documents::DocumentObserver;
+use parking_lot::Mutex;
+use serde_json::Value;
+use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::path::{Path, PathBuf};
+use std::process::{Command, Output, Stdio};
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+};
+use std::time::Duration;
+use tokio::sync::Notify;
+
+const DELAY: Duration = Duration::from_millis(750);
+const SOURCE: &str = "phpstan";
+
+/// Saved files waiting for a check. Each save cancels the wait or the check in progress.
+#[derive(Default)]
+struct Queue {
+    generation: u64,
+    cancel: CancellationToken,
+    files: BTreeSet<PathBuf>,
+}
+
+impl Queue {
+    fn push(&mut self, files: impl IntoIterator<Item = PathBuf>) {
+        self.files.extend(files);
+        self.cancel.cancel();
+        self.generation += 1;
+        self.cancel = CancellationToken::new();
+    }
+    fn current(&self, generation: u64) -> bool {
+        self.generation == generation && !self.cancel.is_cancelled()
+    }
+}
+
+pub(crate) struct Phpstan {
+    root: PathBuf,
+    config_dir: PathBuf,
+    settings: Arc<SettingsStore>,
+    sink: SharedSink,
+    trusted: Arc<AtomicBool>,
+    lifetime: CancellationToken,
+    queue: Mutex<Queue>,
+    changed: Notify,
+    /// Files with PHPStan diagnostics, the only ones a clean result or a removal clears.
+    shown: Mutex<HashSet<PathBuf>>,
+}
+
+impl Phpstan {
+    pub(crate) fn new(
+        root: PathBuf,
+        config_dir: PathBuf,
+        settings: Arc<SettingsStore>,
+        sink: SharedSink,
+        trusted: Arc<AtomicBool>,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            root,
+            config_dir,
+            settings,
+            sink,
+            trusted,
+            lifetime: CancellationToken::new(),
+            queue: Mutex::new(Queue::default()),
+            changed: Notify::new(),
+            shown: Mutex::new(HashSet::new()),
+        })
+    }
+
+    pub(crate) fn start(self: &Arc<Self>, runtime: &tokio::runtime::Handle) {
+        let checker = self.clone();
+        runtime.spawn(async move { checker.run().await });
+    }
+
+    pub(crate) fn stop(&self) {
+        self.lifetime.cancel();
+        self.queue.lock().cancel.cancel();
+    }
+
+    /// Stops the check in progress (trust changed); its files wait for the next one, which drops
+    /// them while the project is in Restricted Mode.
+    pub(crate) fn interrupt(&self) {
+        self.queue.lock().push([]);
+        self.changed.notify_one();
+    }
+
+    fn files_saved(&self, paths: impl IntoIterator<Item = PathBuf>) {
+        let mut files = paths.into_iter().filter(|p| p.extension().is_some_and(|e| e == "php")).peekable();
+        if self.lifetime.is_cancelled() || files.peek().is_none() {
+            return;
+        }
+        self.queue.lock().push(files);
+        self.changed.notify_one();
+    }
+
+    /// Deleted files and folders lose their diagnostics.
+    pub(crate) fn files_removed<'a>(&self, removed: impl Iterator<Item = &'a PathBuf>) {
+        let removed: Vec<&PathBuf> = removed.collect();
+        let gone: Vec<PathBuf> =
+            self.shown.lock().iter().filter(|p| removed.iter().any(|r| p.starts_with(r))).cloned().collect();
+        for path in gone {
+            self.publish(path, Vec::new());
+        }
+    }
+
+    fn publish(&self, path: PathBuf, items: Vec<Diagnostic>) {
+        let mut shown = self.shown.lock();
+        if items.is_empty() {
+            if !shown.remove(&path) {
+                return;
+            }
+        } else {
+            shown.insert(path.clone());
+        }
+        // Under the lock, so a removal and a result for one file reach the UI in the order decided here.
+        self.sink.emit(IdeEvent::Diagnostics { path: path.into(), source: SOURCE.into(), items });
+    }
+
+    async fn run(self: Arc<Self>) {
+        // The failure last reported per root: each is reported once, until a run succeeds.
+        let mut failures: BTreeMap<PathBuf, String> = BTreeMap::new();
+        loop {
+            tokio::select! {
+                _ = self.lifetime.cancelled() => return,
+                _ = self.changed.notified() => {},
+            }
+            let (generation, cancel) = {
+                let queue = self.queue.lock();
+                (queue.generation, queue.cancel.clone())
+            };
+            if !debounce(&cancel, &self.lifetime).await {
+                continue;
+            }
+            let files = {
+                let mut queue = self.queue.lock();
+                if !queue.current(generation) {
+                    continue;
+                }
+                std::mem::take(&mut queue.files)
+            };
+            if !self.trusted.load(Ordering::Acquire) {
+                continue;
+            }
+            let (root, config_dir, settings) = (self.root.clone(), self.config_dir.clone(), self.settings.clone());
+            let Ok((checks, unchecked)) =
+                tokio::task::spawn_blocking(move || plan(&root, &config_dir, &settings, files)).await
+            else {
+                continue;
+            };
+            for path in unchecked {
+                self.publish(path, Vec::new());
+            }
+            let mut checks = checks.into_iter();
+            while let Some(check) = checks.next() {
+                let started = std::time::Instant::now();
+                let program = check.command.get_program().to_string_lossy().into_owned();
+                let output = analyse(check.command, &cancel).await;
+                let Some(output) = output.filter(|_| self.queue.lock().current(generation)) else {
+                    // A newer save: these files are checked again with it.
+                    let mut queue = self.queue.lock();
+                    queue.files.extend(check.files);
+                    queue.files.extend(checks.by_ref().flat_map(|c| c.files));
+                    break;
+                };
+                tracing::debug!(
+                    "phpstan checked {} file(s) in {} ms",
+                    check.files.len(),
+                    started.elapsed().as_millis()
+                );
+                // Files deleted meanwhile make the result (or the failure) moot: check the rest again.
+                let (present, missing): (Vec<PathBuf>, Vec<PathBuf>) =
+                    check.files.iter().cloned().partition(|f| f.is_file());
+                if !missing.is_empty() {
+                    for path in missing {
+                        self.publish(path, Vec::new());
+                    }
+                    self.files_saved(present);
+                    continue;
+                }
+                let report = match output {
+                    Ok(output) => {
+                        let parsed = parse(&decode_tool_output(&output.stdout), &decode_tool_output(&output.stderr));
+                        parsed.map_err(|text| {
+                            if text.is_empty() {
+                                let status = output.status;
+                                format!("PHPStan ended with {status} and no report")
+                            } else {
+                                text
+                            }
+                        })
+                    }
+                    Err(error) => Err(format!("Cannot run {program}: {error}")),
+                };
+                let failure = match report {
+                    Ok(report) => {
+                        let files = check.files.clone();
+                        let results = tokio::task::spawn_blocking(move || diagnostics(&files, report.files))
+                            .await
+                            .unwrap_or_default();
+                        for (path, items) in results {
+                            // Severe errors (a syntax error) stop the analysis of the other files.
+                            if report.complete || !items.is_empty() {
+                                self.publish(path, items);
+                            }
+                        }
+                        report.errors.join("\n")
+                    }
+                    Err(text) => {
+                        // Without a report the earlier errors of these files may be stale.
+                        for path in check.files {
+                            self.publish(path, Vec::new());
+                        }
+                        text
+                    }
+                };
+                if failure.is_empty() {
+                    failures.remove(&check.root);
+                } else {
+                    self.failure(&check.root, failure, &mut failures);
+                }
+            }
+        }
+    }
+
+    fn failure(&self, root: &Path, text: String, failures: &mut BTreeMap<PathBuf, String>) {
+        if failures.get(root) == Some(&text) {
+            return;
+        }
+        self.sink.emit(IdeEvent::Notify {
+            level: NotifyLevel::Error,
+            title: "PHPStan check failed".into(),
+            body: Some(text.clone()),
+        });
+        failures.insert(root.to_path_buf(), text);
+    }
+}
+
+impl DocumentObserver for Phpstan {
+    fn saved(&self, _doc: ide_core::DocId, path: &Path, _text: &str) {
+        self.files_saved([path.to_path_buf()]);
+    }
+}
+
+async fn debounce(cancel: &CancellationToken, lifetime: &CancellationToken) -> bool {
+    tokio::select! {
+        _ = lifetime.cancelled() => false,
+        _ = cancel.cancelled() => false,
+        _ = tokio::time::sleep(DELAY) => true,
+    }
+}
+
+/// One `vendor/bin/phpstan` run: the saved files below one PHP project.
+struct Check {
+    root: PathBuf,
+    files: Vec<PathBuf>,
+    command: Command,
+}
+
+/// The runs that check `files`, and the files not checked, whose earlier diagnostics no longer
+/// apply. A file belongs to the innermost linked project (with its own settings) that contains it,
+/// else to the project; deleted files, files in `vendor` or in excluded folders, and files of a
+/// project without PHPStan are not checked.
+fn plan(
+    project: &Path,
+    config_dir: &Path,
+    settings: &SettingsStore,
+    files: BTreeSet<PathBuf>,
+) -> (Vec<Check>, Vec<PathBuf>) {
+    let members =
+        ide_workspace::workspace::Workspace::load(project).ok().flatten().map(|w| w.projects).unwrap_or_default();
+    let mut groups: BTreeMap<PathBuf, Vec<PathBuf>> = BTreeMap::new();
+    let mut unchecked = Vec::new();
+    for file in files {
+        let member = members.iter().filter(|m| file.starts_with(m)).max_by_key(|m| m.components().count());
+        let root = member.cloned().or_else(|| file.starts_with(project).then(|| project.to_path_buf()));
+        match root {
+            Some(root) if file.is_file() => groups.entry(root).or_default().push(file),
+            _ => unchecked.push(file),
+        }
+    }
+    let mut checks = Vec::new();
+    for (root, files) in groups {
+        let effective = if root == project {
+            settings.effective()
+        } else {
+            SettingsStore::load(config_dir, Some(&root)).effective()
+        };
+        let excludes = ide_vfs::ExcludeMatcher::new(&effective.exclude_globs());
+        let (files, skipped): (Vec<PathBuf>, Vec<PathBuf>) = files.into_iter().partition(|f| {
+            f.strip_prefix(&root).is_ok_and(|rel| !rel.starts_with("vendor") && !excludes.is_excluded(rel))
+        });
+        unchecked.extend(skipped);
+        match ide_sdk::php::phpstan_command(&root, &effective, &files).filter(|_| !files.is_empty()) {
+            Some(command) => checks.push(Check { root, files, command }),
+            None => unchecked.extend(files),
+        }
+    }
+    (checks, unchecked)
+}
+
+/// Runs `cmd` to its end; `None` when `cancel` fires first, which kills it.
+async fn analyse(mut cmd: Command, cancel: &CancellationToken) -> Option<std::io::Result<Output>> {
+    if cancel.is_cancelled() {
+        return None;
+    }
+    ide_core::process::prepare(&mut cmd);
+    ide_core::process::own_group(&mut cmd);
+    cmd.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
+    let mut cmd = tokio::process::Command::from(cmd);
+    cmd.kill_on_drop(true);
+    let child = match cmd.spawn() {
+        Ok(child) => child,
+        Err(error) => return Some(Err(error)),
+    };
+    let pid = child.id();
+    // PHPStan may start workers of its own.
+    let cancelled = async {
+        cancel.cancelled().await;
+        if let Some(pid) = pid {
+            let _ = tokio::task::spawn_blocking(move || ide_core::process::kill_tree_of(pid)).await;
+        }
+    };
+    tokio::select! {
+        output = child.wait_with_output() => Some(output),
+        () = cancelled => None,
+    }
+}
+
+/// A PHPStan message: 0-based line, text with its tip, identifier.
+#[derive(Debug, PartialEq)]
+struct Message {
+    line: u32,
+    text: String,
+    identifier: Option<String>,
+}
+
+/// A JSON report: messages per file as PHPStan names it, the errors of the run itself, and
+/// whether every file was analysed (severe errors such as a syntax error stop the others).
+#[derive(Debug, PartialEq)]
+struct Report {
+    files: BTreeMap<String, Vec<Message>>,
+    errors: Vec<String>,
+    complete: bool,
+}
+
+impl Default for Report {
+    fn default() -> Self {
+        Self { files: BTreeMap::new(), errors: Vec::new(), complete: true }
+    }
+}
+
+/// PHPStan's `--error-format=json` report, or the text to report when there is none (an
+/// invalid configuration, a crash). PHP warnings, or a byte order mark a bootstrap file prints,
+/// may precede the report on stdout.
+fn parse(stdout: &str, stderr: &str) -> Result<Report, String> {
+    let json = serde_json::from_str::<Value>(stdout.trim().trim_start_matches('\u{feff}')).ok().or_else(|| {
+        stdout.lines().rev().find_map(|l| l.find('{').and_then(|start| serde_json::from_str(&l[start..]).ok()))
+    });
+    let Some(Value::Object(json)) = json else {
+        // Every saved file is excluded by the configuration (`excludePaths`).
+        if stderr.contains("No files found to analyse") {
+            return Ok(Report::default());
+        }
+        return Err(failure_text(stdout, stderr));
+    };
+    let mut report = Report::default();
+    if let Some(Value::Object(files)) = json.get("files") {
+        for (file, result) in files {
+            let messages = result.get("messages").and_then(Value::as_array).into_iter().flatten();
+            report.files.insert(file.clone(), messages.filter_map(message).collect());
+        }
+    }
+    let errors = json.get("errors").and_then(Value::as_array).into_iter().flatten();
+    report.errors = errors.map(|e| e.as_str().map_or_else(|| e.to_string(), str::to_owned)).collect();
+    report.complete = !stderr.contains("Result is incomplete");
+    Ok(report)
+}
+
+fn message(m: &Value) -> Option<Message> {
+    let mut text = m.get("message")?.as_str()?.to_owned();
+    if let Some(tip) = m.get("tip").and_then(Value::as_str).filter(|t| !t.trim().is_empty()) {
+        text = format!("{text}\n{}", strip_console_tags(tip));
+    }
+    let line = m.get("line").and_then(Value::as_u64).unwrap_or(1).max(1) - 1;
+    Some(Message {
+        line: u32::try_from(line).unwrap_or(u32::MAX),
+        text,
+        identifier: m.get("identifier").and_then(Value::as_str).map(str::to_owned),
+    })
+}
+
+/// Tips may carry console styling (`<fg=cyan>…</>`).
+fn strip_console_tags(text: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let mut rest = text;
+    while let Some(i) = rest.find('<') {
+        out.push_str(&rest[..i]);
+        rest = &rest[i..];
+        let tag = rest.find('>').map(|end| &rest[..=end]);
+        match tag {
+            Some(tag)
+                if tag == "</>"
+                    || tag.starts_with("<fg=")
+                    || tag.starts_with("<bg=")
+                    || tag.starts_with("<options=") =>
+            {
+                rest = &rest[tag.len()..];
+            }
+            _ => {
+                out.push('<');
+                rest = &rest[1..];
+            }
+        }
+    }
+    out.push_str(rest);
+    out
+}
+
+/// What PHPStan printed instead of a report, without its notes and blank lines.
+fn failure_text(stdout: &str, stderr: &str) -> String {
+    let lines: Vec<&str> = stderr
+        .lines()
+        .chain(stdout.lines())
+        .map(str::trim)
+        .filter(|l| !l.is_empty() && !l.starts_with("Note: Using configuration file"))
+        .collect();
+    lines.iter().take(20).copied().collect::<Vec<_>>().join("\n")
+}
+
+/// The diagnostics of each checked file (none for a clean one), matched to the report's files
+/// by their real paths. Errors PHPStan reports in a trait name the class using it
+/// (`Trait.php (in context of class Foo)`).
+fn diagnostics(files: &[PathBuf], reported: BTreeMap<String, Vec<Message>>) -> Vec<(PathBuf, Vec<Diagnostic>)> {
+    let real = |p: &Path| dunce::canonicalize(p).unwrap_or_else(|_| p.to_path_buf());
+    let mut messages: BTreeMap<PathBuf, Vec<Message>> = BTreeMap::new();
+    for (name, list) in reported {
+        let name = name.split(" (in context of ").next().unwrap_or(&name);
+        messages.entry(real(Path::new(name))).or_default().extend(list);
+    }
+    files
+        .iter()
+        .map(|file| {
+            let list = messages.remove(&real(file)).unwrap_or_default();
+            // Columns only: a file in another encoding than UTF-8 still gives the right lines.
+            let text = if list.is_empty() {
+                None
+            } else {
+                std::fs::read(file).ok().map(|bytes| String::from_utf8_lossy(&bytes).into_owned())
+            };
+            let items = list.into_iter().map(|m| diagnostic(m, text.as_deref())).collect();
+            (file.clone(), items)
+        })
+        .collect()
+}
+
+fn diagnostic(m: Message, text: Option<&str>) -> Diagnostic {
+    Diagnostic {
+        range: line_range(text, m.line),
+        severity: Severity::Warning,
+        message: m.text,
+        source: Some("PHPStan".into()),
+        server: Some(SOURCE.into()),
+        code: m.identifier,
+        unnecessary: false,
+        deprecated: false,
+    }
+}
+
+/// PHPStan reports lines only: the line from its first non-blank character to its end (UTF-16).
+fn line_range(text: Option<&str>, line: u32) -> Range {
+    let text = text.map(|t| t.strip_prefix('\u{feff}').unwrap_or(t));
+    let content = text.and_then(|t| t.split('\n').nth(line as usize)).unwrap_or("").trim_end();
+    let indent = content.len() - content.trim_start().len();
+    let col = |s: &str| u32::try_from(s.encode_utf16().count()).unwrap_or(u32::MAX);
+    Range { start: Pos { line, col: col(&content[..indent]) }, end: Pos { line, col: col(content) } }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const REPORT: &str = r#"{"totals":{"errors":0,"file_errors":3},"files":{
+        "/p/src/A.php":{"errors":2,"messages":[
+            {"message":"Constant UNKNOWN not found.","line":11,"ignorable":true,
+             "tip":"Learn more at https://phpstan.org/user-guide/discovering-symbols","identifier":"constant.notFound"},
+            {"message":"Access to an undefined property.","line":3,"ignorable":true,
+             "tip":"Learn more: <fg=cyan>https://phpstan.org/blog/solving</> for array<int, string>","identifier":"property.notFound"}]},
+        "/p/src/T.php (in context of class App\\A)":{"errors":1,"messages":[
+            {"message":"Syntax error","line":null,"ignorable":false,"identifier":"phpstan.parse"}]}},
+        "errors":[]}"#;
+
+    fn message(line: u32, text: &str, identifier: &str) -> Message {
+        Message { line, text: text.into(), identifier: Some(identifier.into()) }
+    }
+
+    #[test]
+    fn messages_keep_their_line_tip_and_identifier() {
+        let report = parse(REPORT, "Note: Using configuration file /p/phpstan.neon.").unwrap();
+        assert!(report.errors.is_empty());
+        assert_eq!(
+            report.files["/p/src/A.php"],
+            [
+                message(
+                    10,
+                    "Constant UNKNOWN not found.\nLearn more at https://phpstan.org/user-guide/discovering-symbols",
+                    "constant.notFound"
+                ),
+                message(
+                    2,
+                    "Access to an undefined property.\nLearn more: https://phpstan.org/blog/solving for array<int, string>",
+                    "property.notFound"
+                ),
+            ]
+        );
+        assert_eq!(
+            report.files["/p/src/T.php (in context of class App\\A)"],
+            [message(0, "Syntax error", "phpstan.parse")]
+        );
+    }
+
+    #[test]
+    fn errors_of_the_run_are_not_file_messages() {
+        let stdout =
+            r#"{"totals":{"errors":1,"file_errors":0},"files":[],"errors":["Invalid entries in excludePaths"]}"#;
+        let report = parse(stdout, "").unwrap();
+        assert!(report.files.is_empty());
+        assert_eq!(report.errors, ["Invalid entries in excludePaths"]);
+        // PHP warnings ahead of the report, or a byte order mark printed by a bootstrap file.
+        let warned = format!("Deprecated: something in /p/x.php on line 3\n{stdout}");
+        assert_eq!(parse(&warned, "").unwrap().errors, ["Invalid entries in excludePaths"]);
+        let marked = format!("\u{feff}{stdout}");
+        assert_eq!(parse(&marked, "").unwrap().errors, ["Invalid entries in excludePaths"]);
+        assert_eq!(parse(&format!("Notice: x{stdout}"), "").unwrap().errors, ["Invalid entries in excludePaths"]);
+        assert!(parse(stdout, "").unwrap().complete);
+        let severe = " Result is incomplete because of severe errors.";
+        assert!(!parse(stdout, severe).unwrap().complete);
+    }
+
+    #[test]
+    fn output_without_a_report_is_a_failure() {
+        let stderr = "Note: Using configuration file /p/phpstan.neon.\n\n  Invalid entry in excludePaths:\n  Path \"/p/nothere\" is neither a directory\n\n";
+        assert_eq!(
+            parse("", stderr),
+            Err("Invalid entry in excludePaths:\nPath \"/p/nothere\" is neither a directory".to_string())
+        );
+        assert_eq!(
+            parse("Fatal error: Allowed memory size exhausted", ""),
+            Err("Fatal error: Allowed memory size exhausted".into())
+        );
+        assert_eq!(parse("", ""), Err(String::new()));
+        // Excluded files are no failure: nothing to report.
+        assert_eq!(parse("", " [ERROR] No files found to analyse.\n"), Ok(Report::default()));
+    }
+
+    #[test]
+    fn checked_files_get_their_messages_and_clean_files_none() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dunce::canonicalize(dir.path()).unwrap();
+        let (a, t, clean) = (root.join("A.php"), root.join("T.php"), root.join("Clean.php"));
+        std::fs::write(&a, "<?php\n\n    echo $é;  \r\n").unwrap();
+        std::fs::write(&t, "<?php\n").unwrap();
+        std::fs::write(&clean, "<?php\n").unwrap();
+        let reported = BTreeMap::from([
+            (a.to_string_lossy().into_owned(), vec![message(2, "Undefined variable", "variable.undefined")]),
+            (format!("{} (in context of class A)", t.display()), vec![message(0, "In a trait", "trait.x")]),
+            ("/elsewhere/B.php".to_string(), vec![message(0, "Not checked", "x")]),
+        ]);
+        let out = diagnostics(&[a.clone(), t.clone(), clean.clone()], reported);
+        assert_eq!(
+            out.iter().map(|(p, items)| (p.clone(), items.len())).collect::<Vec<_>>(),
+            [(a, 1), (t, 1), (clean, 0)]
+        );
+        let d = &out[0].1[0];
+        // From the first non-blank character to the end of the line, in UTF-16 columns.
+        assert_eq!(d.range, Range { start: Pos { line: 2, col: 4 }, end: Pos { line: 2, col: 12 } });
+        assert_eq!(
+            (d.code.as_deref(), d.source.as_deref(), d.server.as_deref(), d.severity),
+            (Some("variable.undefined"), Some("PHPStan"), Some("phpstan"), Severity::Warning)
+        );
+        assert_eq!(line_range(None, 7), Range { start: Pos { line: 7, col: 0 }, end: Pos { line: 7, col: 0 } });
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn burst_saves_give_one_check_of_all_files() {
+        let mut queue = Queue::default();
+        queue.push([PathBuf::from("/p/A.php")]);
+        let token = queue.cancel.clone();
+        let lifetime = CancellationToken::new();
+        let pending_lifetime = lifetime.clone();
+        let waiting = tokio::spawn(async move { debounce(&token, &pending_lifetime).await });
+        tokio::task::yield_now().await;
+        tokio::time::advance(DELAY - Duration::from_millis(1)).await;
+        assert!(!waiting.is_finished());
+        for i in 0..20 {
+            queue.push([PathBuf::from(format!("/p/{}.php", i % 3))]);
+        }
+        assert!(!waiting.await.unwrap());
+        let current = queue.generation;
+        assert!(debounce(&queue.cancel, &lifetime).await);
+        assert!(queue.current(current));
+        assert_eq!(queue.files.len(), 4);
+        lifetime.cancel();
+        assert!(!debounce(&queue.cancel, &lifetime).await);
+    }
+
+    /// A project with PHPStan whose PHP logs each run, waits `pause` seconds, prints `stderr` and
+    /// reports `report`.
+    #[cfg(unix)]
+    struct Fixture {
+        _dir: tempfile::TempDir,
+        root: PathBuf,
+        events: Arc<Mutex<Vec<IdeEvent>>>,
+        trusted: Arc<AtomicBool>,
+        checker: Arc<Phpstan>,
+    }
+
+    #[cfg(unix)]
+    impl Fixture {
+        fn new() -> Self {
+            use std::os::unix::fs::PermissionsExt;
+            let dir = tempfile::tempdir().unwrap();
+            let base = dunce::canonicalize(dir.path()).unwrap();
+            let root = base.join("project");
+            std::fs::create_dir_all(root.join("vendor/bin")).unwrap();
+            std::fs::create_dir_all(root.join("src")).unwrap();
+            std::fs::write(root.join("vendor/bin/phpstan"), "<?php\n").unwrap();
+            // Named php8.5: the selected PHP runs vendor/bin/phpstan, whatever its name.
+            let php = base.join("php/php8.5");
+            std::fs::create_dir_all(php.parent().unwrap()).unwrap();
+            let script = "#!/bin/sh\nshift\necho \"$XDEBUG_MODE $*\" >> runs.log\n\
+                sleep \"$(cat pause 2>/dev/null || echo 0)\"\ncat stderr >&2 2>/dev/null\ncat report\n";
+            std::fs::write(&php, script).unwrap();
+            std::fs::set_permissions(&php, std::fs::Permissions::from_mode(0o755)).unwrap();
+            std::fs::create_dir_all(root.join(".openidea")).unwrap();
+            let settings = format!("[languages.php]\ninterpreter = {:?}\n", php.to_string_lossy());
+            std::fs::write(root.join(".openidea/settings.toml"), settings).unwrap();
+            let config = base.join("config");
+            let settings = Arc::new(SettingsStore::load(&config, Some(&root)));
+            let events = Arc::new(Mutex::new(Vec::new()));
+            let sink_events = events.clone();
+            let sink: SharedSink = Arc::new(move |e| sink_events.lock().push(e));
+            let trusted = Arc::new(AtomicBool::new(true));
+            let checker = Phpstan::new(root.clone(), config, settings, sink, trusted.clone());
+            checker.start(&tokio::runtime::Handle::current());
+            Self { _dir: dir, root, events, trusted, checker }
+        }
+
+        fn file(&self, name: &str) -> PathBuf {
+            let path = self.root.join("src").join(name);
+            std::fs::write(&path, "<?php\necho UNKNOWN;\n").unwrap();
+            path
+        }
+
+        fn report(&self, path: &Path, identifiers: &[&str]) {
+            let messages: Vec<Value> = identifiers
+                .iter()
+                .map(|id| serde_json::json!({"message": "Bad", "line": 2, "identifier": id, "ignorable": true}))
+                .collect();
+            let files = if messages.is_empty() {
+                serde_json::json!({})
+            } else {
+                serde_json::json!({ path.to_string_lossy(): {"errors": messages.len(), "messages": messages} })
+            };
+            std::fs::write(self.root.join("report"), serde_json::json!({"files": files, "errors": []}).to_string())
+                .unwrap();
+        }
+
+        fn runs(&self) -> Vec<String> {
+            std::fs::read_to_string(self.root.join("runs.log")).unwrap_or_default().lines().map(str::to_owned).collect()
+        }
+
+        async fn until(&self, what: &str, done: impl Fn(&Self) -> bool) {
+            for _ in 0..200 {
+                if done(self) {
+                    return;
+                }
+                tokio::time::sleep(Duration::from_millis(25)).await;
+            }
+            panic!("timed out waiting for {what}: runs {:?}, events {:?}", self.runs(), self.events.lock());
+        }
+
+        fn diagnostics(&self) -> Vec<(PathBuf, Vec<Option<String>>)> {
+            self.events
+                .lock()
+                .iter()
+                .filter_map(|e| match e {
+                    IdeEvent::Diagnostics { path, source, items } if source == SOURCE => {
+                        Some((path.to_path_buf(), items.iter().map(|d| d.code.clone()).collect()))
+                    }
+                    _ => None,
+                })
+                .collect()
+        }
+
+        fn notifications(&self) -> Vec<String> {
+            let events = self.events.lock();
+            events.iter().filter(|e| matches!(e, IdeEvent::Notify { .. })).map(|e| format!("{e:?}")).collect()
+        }
+    }
+
+    #[cfg(unix)]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn saves_are_checked_together_and_a_newer_save_cancels_the_check() {
+        let f = Fixture::new();
+        let a = f.file("A.php");
+        f.report(&a, &["constant.notFound"]);
+        for _ in 0..5 {
+            f.checker.files_saved([a.clone(), f.root.join("src/readme.txt")]);
+        }
+        f.until("one check", |f| f.diagnostics().len() == 1).await;
+        assert_eq!(f.runs(), [format!("off analyse --error-format=json --no-progress {}", a.display())]);
+        assert_eq!(f.diagnostics(), [(a.clone(), vec![Some("constant.notFound".to_string())])]);
+
+        // A save during a check kills it; the next check covers both files.
+        std::fs::write(f.root.join("pause"), "30").unwrap();
+        f.checker.files_saved([a.clone()]);
+        f.until("the slow check", |f| f.runs().len() == 2).await;
+        std::fs::write(f.root.join("pause"), "0").unwrap();
+        let b = f.file("B.php");
+        f.report(&a, &[]);
+        f.checker.files_saved([b.clone()]);
+        f.until("the check of both", |f| f.runs().len() == 3 && f.diagnostics().len() == 2).await;
+        assert!(f.runs()[2].ends_with(&format!("{} {}", a.display(), b.display())), "{:?}", f.runs());
+        // A clean result clears A; B never had diagnostics, so nothing is sent for it.
+        assert_eq!(f.diagnostics()[1], (a, vec![]));
+        f.checker.stop();
+    }
+
+    #[cfg(unix)]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn a_failing_run_is_reported_once_and_projects_without_phpstan_stay_quiet() {
+        let f = Fixture::new();
+        let a = f.file("A.php");
+        f.report(&a, &["constant.notFound"]);
+        f.checker.files_saved([a.clone()]);
+        f.until("the first check", |f| f.diagnostics().len() == 1).await;
+
+        std::fs::write(f.root.join("report"), "").unwrap();
+        for run in 2..=3 {
+            f.checker.files_saved([a.clone()]);
+            f.until("the failing check", |f| f.runs().len() == run).await;
+        }
+        tokio::time::sleep(Duration::from_millis(200)).await;
+        let notes = f.notifications();
+        assert_eq!(notes.len(), 1, "{notes:?}");
+        assert!(notes[0].contains("PHPStan check failed") && notes[0].contains("no report"), "{notes:?}");
+        // The failed check leaves no stale errors.
+        assert_eq!(f.diagnostics(), [(a.clone(), vec![Some("constant.notFound".to_string())]), (a.clone(), vec![])]);
+
+        std::fs::remove_file(f.root.join("vendor/bin/phpstan")).unwrap();
+        let events = f.events.lock().len();
+        f.checker.files_saved([a.clone()]);
+        tokio::time::sleep(DELAY * 2).await;
+        assert_eq!(f.events.lock().len(), events);
+        f.checker.stop();
+    }
+
+    #[cfg(unix)]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn files_a_severe_error_left_unchecked_keep_their_diagnostics() {
+        let f = Fixture::new();
+        let (a, b) = (f.file("A.php"), f.file("B.php"));
+        f.report(&a, &["constant.notFound"]);
+        f.checker.files_saved([a.clone()]);
+        f.until("the check of A", |f| f.diagnostics().len() == 1).await;
+        // A syntax error in B: PHPStan reports B only and says the result is incomplete.
+        f.report(&b, &["phpstan.parse"]);
+        std::fs::write(f.root.join("stderr"), "Result is incomplete because of severe errors.").unwrap();
+        f.checker.files_saved([a.clone(), b.clone()]);
+        f.until("the check of both", |f| f.diagnostics().len() == 2).await;
+        tokio::time::sleep(Duration::from_millis(200)).await;
+        assert_eq!(f.diagnostics()[1], (b, vec![Some("phpstan.parse".to_string())]));
+        assert_eq!(f.diagnostics().len(), 2, "A is not cleared");
+        f.checker.stop();
+    }
+
+    #[cfg(unix)]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn a_file_deleted_during_its_check_gets_no_result_and_no_failure() {
+        let f = Fixture::new();
+        let (a, b) = (f.file("A.php"), f.file("B.php"));
+        f.report(&a, &["constant.notFound"]);
+        std::fs::write(f.root.join("pause"), "1").unwrap();
+        f.checker.files_saved([a.clone(), b.clone()]);
+        f.until("the check", |f| f.runs().len() == 1).await;
+        std::fs::remove_file(&a).unwrap();
+        // B is checked again on its own.
+        f.until("the check of B", |f| f.runs().len() == 2).await;
+        assert!(f.runs()[1].ends_with(&format!("--no-progress {}", b.display())), "{:?}", f.runs());
+        tokio::time::sleep(Duration::from_millis(300)).await;
+        assert!(f.events.lock().is_empty(), "{:?}", f.events.lock());
+        f.checker.stop();
+    }
+
+    #[cfg(unix)]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn restricted_mode_stops_the_check_in_progress() {
+        let f = Fixture::new();
+        let a = f.file("A.php");
+        f.report(&a, &["constant.notFound"]);
+        std::fs::write(f.root.join("pause"), "30").unwrap();
+        f.checker.files_saved([a.clone()]);
+        f.until("the check", |f| f.runs().len() == 1).await;
+        f.trusted.store(false, Ordering::Release);
+        f.checker.interrupt();
+        tokio::time::sleep(DELAY * 2).await;
+        assert_eq!(f.runs().len(), 1);
+        assert!(f.events.lock().is_empty());
+        f.checker.stop();
+    }
+
+    #[cfg(unix)]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn files_no_longer_checked_lose_their_diagnostics() {
+        let f = Fixture::new();
+        let a = f.file("A.php");
+        f.report(&a, &["constant.notFound"]);
+        f.checker.files_saved([a.clone()]);
+        f.until("the check", |f| f.diagnostics().len() == 1).await;
+        // PHPStan removed from the project: saving A no longer checks it and drops its errors.
+        std::fs::remove_file(f.root.join("vendor/bin/phpstan")).unwrap();
+        f.checker.files_saved([a.clone()]);
+        f.until("the clear", |f| f.diagnostics().len() == 2).await;
+        assert_eq!(f.diagnostics()[1], (a, vec![]));
+        assert_eq!(f.runs().len(), 1);
+        f.checker.stop();
+    }
+
+    #[cfg(unix)]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn removed_files_lose_their_diagnostics() {
+        let f = Fixture::new();
+        let a = f.file("A.php");
+        f.report(&a, &["constant.notFound"]);
+        f.checker.files_saved([a.clone()]);
+        f.until("the check", |f| f.diagnostics().len() == 1).await;
+        f.checker.files_removed([f.root.join("src/other")].iter());
+        assert_eq!(f.diagnostics().len(), 1);
+        f.checker.files_removed([f.root.join("src")].iter());
+        assert_eq!(f.diagnostics()[1], (a, vec![]));
+        f.checker.stop();
+    }
+}
@@ -2,6 +2,7 @@
 //! Capabilities were checked by the runtime before any of this runs.

 use super::{PluginEvent, PluginEventSink};
+use ide_core::ipc_path::to_ipc;
 use ide_core::{CancellationToken, TextEdit};
 use ide_extension::Package;
 use ide_language::ProgramPin;
@@ -324,6 +325,18 @@ impl HostApi for PluginApi {
            .emit(client, PluginEvent::Notification { plugin_id: self.id().to_owned(), level, title, body });
    }

+    fn copy_to_clipboard(&self, client: Option<&str>, text: String) -> Result<(), HostError> {
+        let client = from_window(client, "copy to the clipboard")?;
+        self.shared.sink.emit(Some(client), PluginEvent::CopyToClipboard { plugin_id: self.id().to_owned(), text });
+        Ok(())
+    }
+
+    fn open_url(&self, client: Option<&str>, url: String) -> Result<(), HostError> {
+        let client = from_window(client, "open a URL")?;
+        self.shared.sink.emit(Some(client), PluginEvent::OpenUrl { plugin_id: self.id().to_owned(), url });
+        Ok(())
+    }
+
    fn status_item(&self, id: &str, item: Option<StatusItem>) {
        let key = (self.id().to_owned(), id.to_owned());
        {
@@ -407,7 +420,7 @@ impl HostApi for PluginApi {
        let info = repo.branch_info().map_err(failed)?;
        let changed = repo.status().map_err(failed)?.len();
        Ok(Some(RepositoryStatus {
-            root: repo.root().to_string_lossy().into_owned(),
+            root: to_ipc(repo.root()),
            branch: info.head,
            commit: info.head_commit,
            upstream: info.upstream,
@@ -418,6 +431,12 @@ impl HostApi for PluginApi {
        }))
    }

+    fn vcs_remotes(&self, root: &Path) -> Result<Vec<(String, String)>, HostError> {
+        let Some(repo) = ide_vcs::Repo::discover(root).map_err(failed)? else { return Ok(Vec::new()) };
+        let remotes = repo.remotes().map_err(failed)?;
+        Ok(remotes.into_iter().map(|r| (r.name, without_credentials(&r.url))).collect())
+    }
+
    fn vcs_fetch(&self, root: &Path, cancel: &CancellationToken) -> Result<(), HostError> {
        let workspace = self.shared.workspace();
        if !workspace.is_some_and(|w| w.trusted(root)) {
@@ -449,7 +468,7 @@ impl HostApi for PluginApi {
            }
            let Ok(rel) = entry.path().strip_prefix(root) else { continue };
            if matcher.is_match(rel) {
-                out.push(entry.path().to_string_lossy().into_owned());
+                out.push(to_ipc(entry.path()));
            }
        }
        out.sort();
@@ -788,6 +807,19 @@ mod tests {
        PluginApi { pkg: Package::new(manifest, dir.to_path_buf()), shared }
    }

+    #[test]
+    fn repository_and_search_paths_match_ipc_events() {
+        let tmp = tempfile::tempdir().unwrap();
+        assert!(std::process::Command::new("git").args(["init", "-q"]).arg(tmp.path()).status().unwrap().success());
+        let root = tmp.path().canonicalize().unwrap();
+        std::fs::create_dir(root.join("src")).unwrap();
+        let file = root.join("src/Example.java");
+        std::fs::write(&file, "class Example {}\n").unwrap();
+        let api = api(&root, Arc::default());
+        assert_eq!(api.find_files(&root, "**/*.java", 8).unwrap(), [to_ipc(&file)]);
+        assert_eq!(api.vcs_status(&root).unwrap().unwrap().root, to_ipc(&root));
+    }
+
    #[test]
    fn programs_run_only_as_approved() {
        let tmp = tempfile::tempdir().unwrap();
@@ -812,3 +844,42 @@ mod tests {
        );
    }
 }
+
+/// The window a user action invoked the plugin from: browser tabs and clipboard writes
+/// follow what the user did, never background work (which would reach every window).
+fn from_window<'a>(client: Option<&'a str>, what: &str) -> Result<&'a str, HostError> {
+    client.ok_or_else(|| HostError::Invalid(format!("can only {what} from a command the user invoked")))
+}
+
+/// `url` without the `user:password@` a remote may carry (`https://user:token@host/…`):
+/// `vcs.read` must not hand out credentials. scp-style `git@host:path` has no password.
+fn without_credentials(url: &str) -> String {
+    let Some((scheme, rest)) = url.split_once("://") else { return url.to_owned() };
+    let authority_end = rest.find('/').unwrap_or(rest.len());
+    match rest[..authority_end].rfind('@') {
+        Some(at) => format!("{scheme}://{}", &rest[at + 1..]),
+        None => url.to_owned(),
+    }
+}
+
+#[cfg(test)]
+mod credential_tests {
+    use super::*;
+
+    #[test]
+    fn remote_urls_lose_their_credentials() {
+        for (url, expected) in [
+            ("https://user:[email protected]/o/r.git", "https://github.com/o/r.git"),
+            ("https://[email protected]/o/r", "https://gitlab.com/o/r"),
+            ("ssh://git@host:2222/o/r.git", "ssh://host:2222/o/r.git"),
+            ("https://github.com/o/r.git", "https://github.com/o/r.git"),
+            ("https://github.com/o/r@v1", "https://github.com/o/r@v1"),
+            ("[email protected]:o/r.git", "[email protected]:o/r.git"),
+            ("/srv/git/r.git", "/srv/git/r.git"),
+        ] {
+            assert_eq!(without_credentials(url), expected, "{url}");
+        }
+        assert!(matches!(from_window(None, "open a URL"), Err(HostError::Invalid(_))));
+        assert_eq!(from_window(Some("main"), "open a URL").unwrap(), "main");
+    }
+}
@@ -422,7 +422,8 @@ struct IdeDir {
    plugins: PathBuf,
 }

-/// The settings folders of JetBrains IDEs and Android Studio (2020.1 and later), newest first.
+/// The settings folders of JetBrains IDEs and Android Studio (2020.1 and later), newest first, one
+/// per product: its newest version's (an upgrade leaves the older ones behind).
 fn ide_dirs(layout: Layout, home: &Path, env: impl Fn(&str) -> Option<OsString>) -> Vec<IdeDir> {
    let var = |key: &str| env(key).filter(|v| !v.is_empty()).map(PathBuf::from);
    let (config_root, data_root) = match layout {
@@ -462,6 +463,8 @@ fn ide_dirs(layout: Layout, home: &Path, env: impl Fn(&str) -> Option<OsString>)
        }
    }
    out.sort_by(|a, b| b.version.cmp(&a.version).then_with(|| a.label.cmp(&b.label)));
+    let mut products = std::collections::HashSet::new();
+    out.retain(|ide| products.insert(ide.product.clone()));
    out
 }

@@ -784,6 +787,13 @@ mod tests {
        };
        let mac = mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.2"));
        mk(home.join("Library/Application Support/JetBrains/Toolbox"));
+        // An upgrade leaves the older version's folder behind: only the newest of a product counts.
+        mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2024.3"));
+        mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.10"));
+        let dirs = ide_dirs(Layout::Mac, home, |_| None);
+        assert_eq!(dirs.len(), 1);
+        assert_eq!(dirs[0].label, "IntelliJ IDEA 2025.10");
+        std::fs::remove_dir(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.10")).unwrap();
        let dirs = ide_dirs(Layout::Mac, home, |_| None);
        assert_eq!(dirs.len(), 1);
        assert_eq!(dirs[0].label, "IntelliJ IDEA 2025.2");
@@ -115,6 +115,8 @@ pub fn forwarded(event: &PluginEvent) -> bool {
            | PluginEvent::ViewMessage { .. }
            | PluginEvent::OpenTerminal { .. }
            | PluginEvent::OpenLocation { .. }
+            | PluginEvent::CopyToClipboard { .. }
+            | PluginEvent::OpenUrl { .. }
    )
 }

@@ -197,6 +197,12 @@ pub enum PluginEvent {
    /// Plugin languages, or the servers they may start, changed: re-fetch
    /// `languages` (the host re-detects open documents: [`crate::Host::plugin_languages_changed`]).
    LanguagesChanged,
+    /// Copy `text` to the system clipboard.
+    #[serde(rename_all = "camelCase")]
+    CopyToClipboard { plugin_id: String, text: String },
+    /// Open `url` (`http(s)://`) in the system browser.
+    #[serde(rename_all = "camelCase")]
+    OpenUrl { plugin_id: String, url: String },
 }

 /// Delivers events to the UI. `client` is the window that invoked the plugin
@@ -55,6 +55,7 @@ pub struct Project {
    /// Native notebooks and owned kernels, scoped to this project incarnation.
    pub notebooks: Arc<crate::notebook::NotebookService>,
    pub(crate) kotlin_bridge: Option<Arc<crate::kotlin_bridge::KotlinBridge>>,
+    pub(crate) phpstan: Option<Arc<crate::phpstan::Phpstan>>,
    pub(crate) watcher: Watcher,
    /// Watchers of the Project Structure content roots outside the project folder.
    pub(crate) content_watchers: Mutex<Vec<(PathBuf, Watcher)>>,
@@ -77,6 +78,8 @@ impl Host {
            lap = std::time::Instant::now();
        };
        let root = dunce::canonicalize(root)?;
+        let opening = self.opening(window);
+        let _opening = opening.lock();
        // Reject a damaged manifest before replacing the currently open project.
        ide_workspace::workspace::Workspace::load(&root)?;
        // The window reloaded (or asked again) for the project it already has: keep
@@ -290,12 +293,21 @@ impl Host {
            trusted.clone(),
        );
        documents.add_observer(kotlin_bridge.clone());
+        let phpstan = crate::phpstan::Phpstan::new(
+            root.clone(),
+            self.config_dir.clone(),
+            settings.clone(),
+            sink.clone(),
+            trusted.clone(),
+        );
+        documents.add_observer(phpstan.clone());
        let repos = Arc::new(RwLock::new(Repos::enclosing(&root)?));
        for repo in repos.read().all() {
            repo.set_execution_allowed(trusted.load(Ordering::Acquire));
        }
        let watcher = {
            let kotlin_bridge = kotlin_bridge.clone();
+            let phpstan = phpstan.clone();
            let repos = repos.clone();
            let settings = settings.clone();
            let index = index.clone();
@@ -319,6 +331,7 @@ impl Host {
                    let (ignored, ignored_gone) = ignored_changes(batch);
                    index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());
                    kotlin_bridge.files_changed(changed.iter().chain(&batch.removed));
+                    phpstan.files_removed(batch.removed.iter());
                    lsp.project_files_changed(batch.created.iter().chain(&batch.removed));
                    lsp.watched_files_changed(&batch.created, &batch.modified, &batch.removed, &batch.excluded_dirs);
                    if composer_changed(&root, changed.iter().chain(&batch.removed)) {
@@ -438,6 +451,7 @@ impl Host {
                    &history,
                    &lsp,
                    Some(&kotlin_bridge),
+                    Some(&phpstan),
                )?;
                Some((r.clone(), w))
            })
@@ -484,6 +498,7 @@ impl Host {
            agents,
            notebooks,
            kotlin_bridge: Some(kotlin_bridge),
+            phpstan: Some(phpstan),
            watcher,
            content_watchers: Mutex::new(content_watchers),
            lsp_watchers: Mutex::new(Vec::new()),
@@ -514,6 +529,9 @@ impl Host {
        if let Some(bridge) = &project.kotlin_bridge {
            bridge.start(&self.runtime);
        }
+        if let Some(phpstan) = &project.phpstan {
+            phpstan.start(&self.runtime);
+        }
        if let Some(cmd) = post_start {
            self.environment.spawn_post_start(cmd, project.root.clone(), project.sink.clone());
        }
@@ -569,6 +587,8 @@ impl Host {
            return Err(IdeError::invalid(format!("{} is a folder", file.display())));
        }
        let dir = file.parent().map(Path::to_path_buf).ok_or_else(|| IdeError::invalid("no parent folder"))?;
+        let opening = self.opening(window);
+        let _opening = opening.lock();
        if let Ok(current) = self.project(window)
            && current.light
        {
@@ -622,6 +642,7 @@ impl Host {
            agents,
            notebooks,
            kotlin_bridge: None,
+            phpstan: None,
            watcher,
            content_watchers: Mutex::new(Vec::new()),
            lsp_watchers: Mutex::new(Vec::new()),
@@ -998,6 +1019,7 @@ impl Project {
                &self.history,
                &self.lsp,
                self.kotlin_bridge.as_ref(),
+                self.phpstan.as_ref(),
            ) {
                watchers.push((r, w));
            }
@@ -1133,8 +1155,9 @@ fn content_root_watcher(
    history: &Arc<LocalHistory>,
    lsp: &Arc<LspManager>,
    kotlin_bridge: Option<&Arc<crate::kotlin_bridge::KotlinBridge>>,
+    phpstan: Option<&Arc<crate::phpstan::Phpstan>>,
 ) -> Option<Watcher> {
-    let kotlin_bridge = kotlin_bridge.cloned();
+    let (kotlin_bridge, phpstan) = (kotlin_bridge.cloned(), phpstan.cloned());
    let (index, documents, history, lsp) = (index.clone(), documents.clone(), history.clone(), lsp.clone());
    let root = dir.to_path_buf();
    Watcher::start(
@@ -1152,6 +1175,9 @@ fn content_root_watcher(
            if let Some(bridge) = &kotlin_bridge {
                bridge.files_changed(changed.iter().chain(&batch.removed));
            }
+            if let Some(phpstan) = &phpstan {
+                phpstan.files_removed(batch.removed.iter());
+            }
            documents.on_disk_changed(&[&changed[..], &ignored].concat());
            record_external_changes(&history, &changed, &batch.removed);
        }),
@@ -109,6 +109,9 @@ impl crate::Host {
            if let Some(bridge) = &project.kotlin_bridge {
                bridge.schedule();
            }
+            if let Some(phpstan) = &project.phpstan {
+                phpstan.interrupt();
+            }
            if !trusted {
                project.lsp.set_execution_allowed(false);
            }
@@ -251,6 +254,8 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
            | "remote_disconnect"
            | "remote_connect"
            | "remote_bootstrap_list"
+            | "wsl_distros"
+            | "wsl_resolve"
            | "remote_list"
            | "remote_open"
            | "remote_of"
@@ -314,7 +319,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
            | "vcs_log_users"
            | "vcs_log_details"
            | "vcs_log_details_batch"
-            | "vcs_log_index"
            | "vcs_revision_children"
            | "vcs_revision_files"
            | "vcs_open_external_log"
@@ -0,0 +1,46 @@
+//! Opening the project a window is already opening reuses it: racing opens (a double
+//! click, a launch path and a restore) must not start a second index and language servers.
+
+use ide_core::NullSink;
+use ide_host::{Host, HostConfig};
+use std::sync::{Arc, Barrier};
+
+#[test]
+fn racing_opens_of_one_window_share_one_project() {
+    let tmp = tempfile::tempdir().unwrap();
+    let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
+    std::fs::create_dir_all(root.join("src")).unwrap();
+    std::fs::write(root.join("src/Main.java"), "class Main {}\n").unwrap();
+    let runtime = tokio::runtime::Builder::new_multi_thread().worker_threads(2).enable_all().build().unwrap();
+    let _guard = runtime.enter();
+    let host = Arc::new(Host::new(HostConfig {
+        config_dir: tmp.path().join("config"),
+        data_dir: tmp.path().join("data"),
+        local_data_dir: tmp.path().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: runtime.handle().clone(),
+        project_environment: false,
+    }));
+    host.trust.decide(&root, true, false).unwrap();
+
+    let start = Arc::new(Barrier::new(4));
+    let opens: Vec<_> = (0..4)
+        .map(|_| {
+            let (host, root, start) = (host.clone(), root.clone(), start.clone());
+            std::thread::spawn(move || {
+                start.wait();
+                host.open_project("main", &root).unwrap()
+            })
+        })
+        .collect();
+    let projects: Vec<_> = opens.into_iter().map(|t| t.join().unwrap()).collect();
+
+    let current = host.project("main").unwrap();
+    for project in &projects {
+        assert!(Arc::ptr_eq(project, &current), "every open returns the window's one project");
+    }
+    host.close_project("main");
+}
@@ -6,6 +6,7 @@
 //! `plugins/build.sh <dir>` after changing their source or `wit/`.

 use ide_core::error::ErrorKind;
+use ide_core::ipc_path::to_ipc;
 use ide_host::plugins::*;
 use ide_plugin::{EditorContext, HostError, Invocation, Limits};
 use parking_lot::Mutex;
@@ -214,7 +215,7 @@ fn fixture(limits: Limits) -> Fixture {
    std::fs::create_dir_all(project.join("src")).unwrap();
    std::fs::write(project.join("src/notes.txt"), "one two three\nfour five\n").unwrap();
    std::fs::write(tmp.path().join("secret.txt"), "top secret").unwrap();
-    let project = project.canonicalize().unwrap();
+    let project = dunce::canonicalize(project).unwrap();
    let events: Events = Arc::default();
    let sink = {
        let events = events.clone();
@@ -359,7 +360,7 @@ fn read_file_is_confined_to_the_project() {
    let inv = Invocation { client: None, workspace_root: None, editor: None };
    let err = f.host.run_command("misbehave", "read", Some("src/notes.txt"), inv).unwrap_err().message;
    assert!(err.contains("no project is open"), "{err}");
-    assert_eq!(f.run("misbehave", "root", None).unwrap().unwrap(), f.project.to_string_lossy());
+    assert_eq!(f.run("misbehave", "root", None).unwrap().unwrap(), to_ipc(&f.project));
    assert_eq!(f.status("misbehave"), PluginStatus::Active);
 }

@@ -1740,7 +1741,7 @@ fn official_checkstyle_checks_on_save() {
    let java = f.project.join("src/A.java");
    std::fs::write(&java, "class A {\n\tint x;\n}\n").unwrap();
    let saved = |f: &Fixture| {
-        f.host.post_events(Some("main"), vec![WorkbenchEvent::FileSaved(java.to_string_lossy().into_owned())]);
+        f.host.post_events(Some("main"), vec![WorkbenchEvent::FileSaved(to_ipc(&java))]);
        f.host.flush_events_at(Instant::now() + Duration::from_secs(3));
    };
    saved(&f);
@@ -1793,7 +1794,7 @@ fn official_license_header_reports_fixes_and_scans() {
        f.workspace.diagnostics.lock().get(&("openidea.license-header".into(), path.to_path_buf())).cloned()
    };

-    f.host.post_events(Some("main"), vec![WorkbenchEvent::FileOpened(a.to_string_lossy().into_owned())]);
+    f.host.post_events(Some("main"), vec![WorkbenchEvent::FileOpened(to_ipc(&a))]);
    f.host.flush_events_at(Instant::now() + Duration::from_secs(3));
    assert!(f.host.wait_events(Duration::from_secs(20)));
    let d = diagnostics(&a).expect("published on open");
@@ -1818,7 +1819,7 @@ fn official_license_header_reports_fixes_and_scans() {
    f.host.run_command("openidea.license-header", "scan", None, f.inv()).unwrap();
    assert_eq!(diagnostics(&b).map(|d| d.len()), Some(1), "found by the scan");
    std::fs::write(&a, "// Copyright (c) 2026 X\nfn a() {}\n").unwrap();
-    f.host.post_events(Some("main"), vec![WorkbenchEvent::FileSaved(a.to_string_lossy().into_owned())]);
+    f.host.post_events(Some("main"), vec![WorkbenchEvent::FileSaved(to_ipc(&a))]);
    f.host.flush_events_at(Instant::now() + Duration::from_secs(3));
    assert!(f.host.wait_events(Duration::from_secs(20)));
    assert_eq!(diagnostics(&a).map(|d| d.len()), Some(0), "cleared once the header is there");
@@ -2077,6 +2078,62 @@ fn views_open_project_files_at_a_line() {
    assert!(opened.is_none());
 }

+#[test]
+fn vcs_remotes_clipboard_and_open_url() {
+    let f = fixture(Limits::default());
+    let info = f.install(&sample("jobs"));
+    assert_eq!(info.status, PluginStatus::Inactive, "{:?}", info.error);
+
+    // Not a git repository yet: `vcs-remotes` returns an empty list.
+    assert_eq!(f.run("jobs", "remotes", None).unwrap().as_deref(), Some(""));
+
+    git(&f.project, &["init", "-b", "main"]);
+    git(&f.project, &["remote", "add", "origin", "[email protected]:l0ng-ai/openidea.git"]);
+    git(&f.project, &["remote", "add", "upstream", "https://github.com/org/openidea"]);
+    assert_eq!(
+        f.run("jobs", "remotes", None).unwrap().as_deref(),
+        Some("[email protected]:l0ng-ai/openidea.git\nupstream=https://github.com/org/openidea")
+    );
+
+    f.host.set_capability("jobs", "vcs.read", false).unwrap();
+    assert!(f.run("jobs", "remotes", None).unwrap_err().contains("vcs.read"), "needs vcs.read");
+
+    // `ui.copy-to-clipboard` requires `clipboard` and addresses the calling window.
+    f.take_events();
+    f.run("jobs", "copy", Some("https://github.com/l0ng-ai/openidea")).unwrap();
+    let copied = f.take_events().into_iter().find_map(|(client, e)| match e {
+        PluginEvent::CopyToClipboard { plugin_id, text } => Some((client, plugin_id, text)),
+        _ => None,
+    });
+    assert_eq!(copied, Some((Some("main".into()), "jobs".into(), "https://github.com/l0ng-ai/openidea".into())));
+
+    f.host.set_capability("jobs", "clipboard", false).unwrap();
+    f.take_events();
+    assert!(f.run("jobs", "copy", Some("secret")).unwrap_err().contains("clipboard"), "needs clipboard");
+    assert!(f.take_events().iter().all(|(_, e)| !matches!(e, PluginEvent::CopyToClipboard { .. })));
+
+    // `ui.open-url` accepts http(s) URLs and rejects other schemes.
+    f.take_events();
+    f.run("jobs", "open-url", Some("https://github.com/l0ng-ai/openidea/blob/main/README.md#L1")).unwrap();
+    let opened = f.take_events().into_iter().find_map(|(client, e)| match e {
+        PluginEvent::OpenUrl { plugin_id, url } => Some((client, plugin_id, url)),
+        _ => None,
+    });
+    assert_eq!(
+        opened,
+        Some(
+            (Some("main".into()), "jobs".into(), "https://github.com/l0ng-ai/openidea/blob/main/README.md#L1".into(),)
+        )
+    );
+
+    for bad in ["javascript:alert(1)", "file:///etc/passwd", ""] {
+        f.take_events();
+        let err = f.run("jobs", "open-url", Some(bad)).unwrap_err();
+        assert!(err.contains("http:// or https://"), "{bad:?}: {err}");
+        assert!(f.take_events().iter().all(|(_, e)| !matches!(e, PluginEvent::OpenUrl { .. })));
+    }
+}
+
 #[test]
 fn views_can_use_an_svg_icon_from_the_package() {
    let f = fixture(Limits::default());
@@ -49,6 +49,10 @@ pub mod framing {
                }
                return Ok(None);
            }
+            // A UTF-16LE line break is `\n\0`: the cut after `\n` leaves a NUL at the start of the
+            // next line, which would turn the `Content-Length` after it into noise.
+            let nuls = line.iter().take_while(|&&b| b == 0).count();
+            line.drain(..nuls);
            if line.last() != Some(&b'\n') {
                if n as u64 >= MAX_HEADER_LINE {
                    return Err(Error::new(ErrorKind::InvalidData, "header line too long"));
@@ -69,6 +69,21 @@ mod framing_tests {
        assert_eq!(noise[2], "Picked up JAVA_TOOL_OPTIONS: -Dx");
    }

+    #[tokio::test]
+    async fn utf16_output_of_wsl_exe_before_a_message_does_not_swallow_it() {
+        // `wsl.exe` reports its own errors as UTF-16LE with a BOM; the real server only starts
+        // after it, so the first message must still be read whole.
+        let notice = "The Windows Subsystem for Linux instance has terminated.";
+        let mut input: Vec<u8> = [0xff, 0xfe].into();
+        input.extend(format!("{notice}\r\n").encode_utf16().flat_map(u16::to_le_bytes));
+        input.extend(b"Content-Length: 2\r\n\r\n{}");
+        let (msgs, noise) = read_with_noise(&input).await;
+        assert_eq!(msgs.unwrap(), vec![b"{}".to_vec()]);
+        // The text is kept for the error shown to the user, whatever the BOM decodes to.
+        let ascii: String = noise.concat().chars().filter(char::is_ascii).filter(|c| *c != '\0').collect();
+        assert_eq!(ascii.trim(), notice);
+    }
+
    #[tokio::test]
    async fn unterminated_output_then_eof_is_reported() {
        // `pause` prints its prompt without a newline and the process is gone.
@@ -162,7 +162,8 @@ pub fn client_capabilities() -> Value {
            "callHierarchy": { "dynamicRegistration": false },
            "typeHierarchy": { "dynamicRegistration": false }
        },
-        "experimental": {}
+        // rust-analyzer: report when the project has loaded (`quiescent`).
+        "experimental": { "serverStatusNotification": true }
    })
 }

@@ -234,6 +234,11 @@ impl Handler for ClientHandler {
        let Some(mgr) = self.mgr.upgrade() else { return };
        match method {
            "$/progress" => self.progress(&mgr, params),
+            "experimental/serverStatus" => {
+                if let Some(quiescent) = params.get("quiescent").and_then(Value::as_bool) {
+                    self.server.set_loading(mgr.sink(), !quiescent);
+                }
+            }
            "textDocument/publishDiagnostics" => self.publish_diagnostics(&mgr, params),
            "window/showMessage" => self.show_message(&mgr, &params),
            "window/logMessage" => {
@@ -4,7 +4,7 @@ use ide_core::CancellationToken;
 use ide_core::tool_path::search_path;
 use ide_jsonrpc::{Handler, Peer};
 use ide_language::LanguageServerConfig;
-use std::ffi::OsString;
+use std::ffi::{OsStr, OsString};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;

@@ -100,7 +100,8 @@ impl Launcher for ProcessLauncher {
            // A plugin's server: the approved program, unchanged since.
            Some(pin) => Some(pin.verify().map_err(LaunchError::Failed)?.to_path_buf()),
            None => ide_core::tool_path::find_command(&config.command, &search, root)
-                .and_then(|b| resolve_rustup_proxy(&config.command, b)),
+                .and_then(|b| resolve_rustup_proxy(&config.command, b))
+                .and_then(|b| reject_dead_shim(b, &search, root)),
        };
        let mut env: Vec<(String, String)> = vec![("PATH".into(), search.to_string_lossy().into_owned())];
        env.extend(config.env.iter().filter(|(k, _)| *k != "PATH").map(|(k, v)| (k.clone(), v.clone())));
@@ -136,6 +137,60 @@ fn server_search_path(config: &LanguageServerConfig) -> OsString {
    config.env.get("PATH").map(OsString::from).unwrap_or_else(search_path)
 }

+/// What a version manager's shim says when the active version has no such tool.
+const DEAD_SHIM_MESSAGES: &[&str] =
+    &["no version is set for", "no preset version", "command not found", "exists in these", "is not installed"];
+
+/// `~/.local/share/mise/shims/ruby-lsp` exists for every version of the runtime that ever
+/// had the tool, but exits with an error when the version active in `root` lacks it. A
+/// server that dies like that on every start is missing (an install hint), not crashing.
+/// Anything but a clear "not installed" answer from the shim counts as working.
+fn reject_dead_shim(binary: PathBuf, search: &OsStr, root: &Path) -> Option<PathBuf> {
+    if !binary.parent().is_some_and(|d| d.file_name().is_some_and(|n| n == "shims")) {
+        return Some(binary);
+    }
+    let Ok(mut child) = ide_core::process::prepare(&mut std::process::Command::new(&binary))
+        .arg("--version")
+        .current_dir(root)
+        .env("PATH", search)
+        .stdin(std::process::Stdio::null())
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+    else {
+        return Some(binary);
+    };
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+    let status = loop {
+        match child.try_wait() {
+            Ok(Some(status)) => break status,
+            Ok(None) if std::time::Instant::now() < deadline => {
+                std::thread::sleep(std::time::Duration::from_millis(20))
+            }
+            // Slow or unwaitable: let the real start decide.
+            _ => {
+                let _ = child.kill();
+                let _ = child.wait();
+                return Some(binary);
+            }
+        }
+    };
+    if status.success() {
+        return Some(binary);
+    }
+    let mut stderr = String::new();
+    if let Some(mut pipe) = child.stderr.take() {
+        let _ = std::io::Read::read_to_string(&mut pipe, &mut stderr);
+    }
+    let stderr = stderr.to_lowercase();
+    if DEAD_SHIM_MESSAGES.iter().any(|m| stderr.contains(m)) {
+        tracing::info!("{} is a version-manager shim without the tool: {}", binary.display(), stderr.trim());
+        None
+    } else {
+        Some(binary)
+    }
+}
+
 /// `~/.cargo/bin/<tool>` is usually a rustup proxy that fails when the active
 /// toolchain lacks the component (common for rust-analyzer). In that case use
 /// the newest installed toolchain that ships the binary; with none, the tool is
@@ -219,6 +274,34 @@ mod tests {
        std::fs::remove_dir_all(&tmp).unwrap();
    }

+    #[cfg(unix)]
+    #[test]
+    fn shims_without_the_tool_are_missing() {
+        use std::os::unix::fs::PermissionsExt;
+        let tmp = tempfile::tempdir().unwrap();
+        let shims = tmp.path().join("mise/shims");
+        std::fs::create_dir_all(&shims).unwrap();
+        let script = |name: &str, body: &str| {
+            let p = shims.join(name);
+            std::fs::write(&p, format!("#!/bin/sh\n{body}\n")).unwrap();
+            std::fs::set_permissions(&p, std::fs::Permissions::from_mode(0o755)).unwrap();
+            p
+        };
+        let search = OsString::from("/usr/bin:/bin");
+        let dead = script("ruby-lsp", "echo 'mise ERROR No version is set for shim: ruby-lsp' >&2; exit 1");
+        assert_eq!(reject_dead_shim(dead, &search, tmp.path()), None);
+        let works = script("good", "echo 1.0");
+        assert_eq!(reject_dead_shim(works.clone(), &search, tmp.path()), Some(works));
+        // A tool with no `--version` that fails for its own reasons still starts.
+        let odd = script("odd", "echo 'usage: odd' >&2; exit 2");
+        assert_eq!(reject_dead_shim(odd.clone(), &search, tmp.path()), Some(odd));
+        // Only shims are probed.
+        let plain = tmp.path().join("ruby-lsp");
+        std::fs::write(&plain, "#!/bin/sh\necho 'No version is set for' >&2; exit 1\n").unwrap();
+        std::fs::set_permissions(&plain, std::fs::Permissions::from_mode(0o755)).unwrap();
+        assert_eq!(reject_dead_shim(plain.clone(), &search, tmp.path()), Some(plain));
+    }
+
    #[test]
    fn marked_root_needs_a_marker() {
        let tmp = tempfile::tempdir().unwrap();
@@ -18,6 +18,7 @@ mod inspect;
 pub mod jdtls;
 mod launch;
 mod library_source;
+mod loading;
 mod pull;
 mod scope;
 mod server;
@@ -216,6 +217,15 @@ fn runtime_handle() -> tokio::runtime::Handle {
    })
 }

+fn goto_is_empty(r: &Option<lsp::GotoDefinitionResponse>) -> bool {
+    match r {
+        None => true,
+        Some(lsp::GotoDefinitionResponse::Scalar(_)) => false,
+        Some(lsp::GotoDefinitionResponse::Array(v)) => v.is_empty(),
+        Some(lsp::GotoDefinitionResponse::Link(v)) => v.is_empty(),
+    }
+}
+
 fn rpc_err(server: &str, method: &str, e: RpcError) -> IdeError {
    match e {
        RpcError::Cancelled => IdeError::cancelled(),
@@ -1163,8 +1173,13 @@ impl LspManager {
        let mut out = Outcome::new();
        for t in targets.iter().filter(|t| snap.asks(t, pos)) {
            let r: IdeResult<Option<lsp::Hover>> =
-                self.call(t, "textDocument/hover", snap.pos_params(t, pos), Some(&cancel), DEFAULT_TIMEOUT).await;
+                loading::while_loading(&t.server, Some(&cancel), loading::LOADING_WAIT, Option::is_none, || {
+                    self.call(t, "textDocument/hover", snap.pos_params(t, pos), Some(&cancel), DEFAULT_TIMEOUT)
+                })
+                .await;
            match r {
+                // Still loading: no documentation yet, not an error.
+                Err(e) if e.kind == ErrorKind::TimedOut && t.server.is_loading() => out.value = Some(None),
                Ok(Some(h)) => {
                    if let Some(h) = convert::hover(&self.conv(t.enc()), &snap.path, h) {
                        return Ok(Some(h));
@@ -1254,16 +1269,17 @@ impl LspManager {
    ) -> IdeResult<Vec<Location>> {
        let mut out = Outcome::new();
        for t in targets.iter().filter(|t| snap.asks(t, pos)) {
-            match self
-                .call::<_, Option<lsp::GotoDefinitionResponse>>(
+            let r = loading::while_loading(&t.server, cancel, loading::LOADING_WAIT, goto_is_empty, || {
+                self.call::<_, Option<lsp::GotoDefinitionResponse>>(
                    t,
                    method,
                    snap.pos_params(t, pos),
                    cancel,
                    DEFAULT_TIMEOUT,
                )
-                .await
-            {
+            })
+            .await;
+            match r {
                Ok(Some(r)) => {
                    let locs = convert::goto_response(&self.conv(t.enc()), r);
                    let locs = library_sources(snap, pos, locs).await;
@@ -0,0 +1,76 @@
+//! Requests answered while a server is still loading the project.
+//!
+//! rust-analyzer answers navigation with nothing until it has read the project's
+//! files, misses macro-generated items until build scripts and proc macros are
+//! built, and withdraws answers (`ContentModified`) when loading changes its
+//! data. Such an answer is not final: the request runs again as loading
+//! progresses, so ⌘B right after opening a project lands once the server can
+//! answer instead of reporting "not found". Only servers that report loading
+//! through `experimental/serverStatus` wait; for others nothing changes.
+
+use crate::server::Server;
+use ide_core::error::ErrorKind;
+use ide_core::{CancellationToken, IdeError, IdeResult};
+use std::future::Future;
+use std::time::Duration;
+
+/// How long an explicit request waits for a server that is still loading.
+pub(crate) const LOADING_WAIT: Duration = Duration::from_secs(30);
+/// Retry interval while it loads, for phases that end without a notification.
+const POLL: Duration = Duration::from_secs(3);
+
+/// Runs `query` on `server`. While the server is loading, an empty answer or a
+/// withdrawn one (`ContentModified`; not a cancellation of `cancel`) runs again
+/// whenever a loading phase ends, until it answers, loading ends, or `wait`
+/// passes; then a still-loading server yields a `TimedOut` error saying so.
+pub(crate) async fn while_loading<R, F, Fut>(
+    server: &Server,
+    cancel: Option<&CancellationToken>,
+    wait: Duration,
+    is_empty: impl Fn(&R) -> bool,
+    query: F,
+) -> IdeResult<R>
+where
+    F: Fn() -> Fut,
+    Fut: Future<Output = IdeResult<R>>,
+{
+    let cancelled = || cancel.is_some_and(CancellationToken::is_cancelled);
+    let deadline = tokio::time::Instant::now() + wait;
+    loop {
+        let phase = server.phase_notified();
+        tokio::pin!(phase);
+        phase.as_mut().enable();
+        let asked_while_loading = server.is_loading();
+        let result = query().await;
+        let retry = match &result {
+            Ok(r) => is_empty(r),
+            Err(e) => e.kind == ErrorKind::Cancelled && !cancelled(),
+        };
+        if !retry || cancelled() || server.running().is_none() {
+            return result;
+        }
+        if !server.is_loading() {
+            // Loading ended while the server answered from its old state: ask once more.
+            if asked_while_loading {
+                continue;
+            }
+            return result;
+        }
+        let now = tokio::time::Instant::now();
+        if now >= deadline {
+            return Err(IdeError::new(ErrorKind::TimedOut, format!("{} is still loading the project", server.name)));
+        }
+        let until = deadline.min(now + POLL);
+        let stop = async {
+            match cancel {
+                Some(c) => c.cancelled().await,
+                None => std::future::pending().await,
+            }
+        };
+        tokio::select! {
+            () = phase => {}
+            () = tokio::time::sleep_until(until) => {}
+            () = stop => return Err(IdeError::cancelled()),
+        }
+    }
+}
@@ -110,6 +110,11 @@ pub struct Server {
    pub published_notify: Notify,
    /// Woken when the last `$/progress` task ends.
    idle_notify: Notify,
+    /// `experimental/serverStatus` (rust-analyzer): `None` until the server sends
+    /// one, then whether it is still loading the project.
+    loading: Mutex<Option<bool>>,
+    /// Woken whenever a `$/progress` task ends or the server's loading state changes.
+    phase_notify: Notify,
    transient: Mutex<HashMap<PathBuf, Transient>>,
    pub java_build_lock: Arc<tokio::sync::Mutex<()>>,
    pub java_autobuild_suspended: std::sync::atomic::AtomicBool,
@@ -144,6 +149,8 @@ impl Server {
            published: Mutex::new(HashMap::new()),
            published_notify: Notify::new(),
            idle_notify: Notify::new(),
+            loading: Mutex::new(None),
+            phase_notify: Notify::new(),
            transient: Mutex::new(HashMap::new()),
            java_build_lock: Arc::new(tokio::sync::Mutex::new(())),
            java_autobuild_suspended: std::sync::atomic::AtomicBool::new(false),
@@ -389,22 +396,48 @@ impl Server {
        if self.running().is_none() {
            return;
        }
-        let busy = !self.progress.lock().is_empty();
+        let busy = self.is_busy();
        self.set_status(sink, if busy { ServerStatus::Busy } else { ServerStatus::Ready }, None);
    }

    /// Whether the server reports work in progress (indexing, analysis).
    pub fn is_busy(&self) -> bool {
-        !self.progress.lock().is_empty()
+        !self.progress.lock().is_empty() || *self.loading.lock() == Some(true)
+    }
+
+    /// Whether the server says it is still loading the project, so an empty
+    /// answer may not be final. Only `serverStatus` tells: `$/progress` also
+    /// covers background work (indexing, builds) during which answers are final.
+    pub fn is_loading(&self) -> bool {
+        *self.loading.lock() == Some(true)
+    }
+
+    /// Records `experimental/serverStatus`: `quiescent` false while the project loads.
+    pub fn set_loading(&self, sink: &SharedSink, loading: bool) {
+        if self.loading.lock().replace(loading) == Some(loading) {
+            return;
+        }
+        self.refresh_busy_status(sink);
+        self.phase_ended();
    }

    /// Called after a `$/progress` task ended.
    pub fn progress_ended(&self) {
+        self.phase_ended();
+    }
+
+    fn phase_ended(&self) {
+        self.phase_notify.notify_waiters();
        if !self.is_busy() {
            self.idle_notify.notify_waiters();
        }
    }

+    /// Woken when the next loading phase ends.
+    pub fn phase_notified(&self) -> tokio::sync::futures::Notified<'_> {
+        self.phase_notify.notified()
+    }
+
    /// Waits until no `$/progress` task is active; false on timeout or cancellation.
    pub async fn wait_idle(&self, timeout: Duration, cancel: &CancellationToken) -> bool {
        let deadline = tokio::time::Instant::now() + timeout;
@@ -499,6 +532,7 @@ impl Server {
    }

    pub fn take_progress(&self) -> Vec<(TaskId, String)> {
+        *self.loading.lock() = None;
        self.progress.lock().drain().map(|(_, p)| (p.task, p.title)).collect()
    }

@@ -1009,6 +1009,78 @@ async fn progress_tasks_and_busy_status() {
    assert!(tasks[2].3);
 }

+/// While a server says it is loading the project (rust-analyzer: `serverStatus`
+/// not quiescent) an empty or withdrawn answer is asked again once loading moves
+/// on. `$/progress` alone (background indexing, `cargo check`) doesn't wait.
+#[tokio::test(flavor = "multi_thread")]
+async fn navigation_waits_for_a_server_that_is_still_loading() {
+    #[derive(Clone, Copy, Debug)]
+    enum Answer {
+        Empty,
+        ContentModified,
+    }
+    for answer in [Answer::Empty, Answer::ContentModified] {
+        let h = harness(&[("mock", incremental_caps())]);
+        let (doc, path) = h.open("a.mk", "fn foo() {}\nfoo();\n");
+        h.wait_status("mock", ServerStatus::Ready).await;
+        let s = h.launcher.state("mock");
+        let peer = s.peer();
+        peer.notify("experimental/serverStatus", json!({ "health": "ok", "quiescent": false })).unwrap();
+        h.wait_status("mock", ServerStatus::Busy).await;
+        if let Answer::ContentModified = answer {
+            s.errors.lock().insert("textDocument/definition".into(), (-32801, "content modified".into()));
+        }
+        let mgr = h.mgr.clone();
+        let goto = tokio::spawn(async move { mgr.goto(doc, Pos::new(1, 1), GotoKind::Definition).await });
+        eventually(|| !s.requested("textDocument/definition").is_empty()).await;
+        assert!(!goto.is_finished(), "{answer:?}: an answer while loading is not final");
+
+        s.errors.lock().clear();
+        let r = json!({"start":{"line":0,"character":3},"end":{"line":0,"character":6}});
+        s.respond("textDocument/definition", json!({ "uri": uri_of(&path), "range": r }));
+        peer.notify("experimental/serverStatus", json!({ "health": "ok", "quiescent": true })).unwrap();
+        let defs = tokio::time::timeout(Duration::from_secs(10), goto).await.unwrap().unwrap().unwrap();
+        assert_eq!(defs, vec![ide_core::Location::file(path.clone(), rng(0, 3, 0, 6))], "{answer:?}");
+        h.wait_status("mock", ServerStatus::Ready).await;
+    }
+
+    // Hover documentation the same way.
+    let h = harness(&[("mock", incremental_caps())]);
+    let (doc, _) = h.open("a.mk", "x");
+    h.wait_status("mock", ServerStatus::Ready).await;
+    let s = h.launcher.state("mock");
+    s.peer().notify("experimental/serverStatus", json!({ "health": "ok", "quiescent": false })).unwrap();
+    h.wait_status("mock", ServerStatus::Busy).await;
+    let mgr = h.mgr.clone();
+    let hover = tokio::spawn(async move { mgr.hover(doc, Pos::new(0, 0), Default::default()).await });
+    eventually(|| !s.requested("textDocument/hover").is_empty()).await;
+    s.respond("textDocument/hover", json!({ "contents": "docs" }));
+    s.peer().notify("experimental/serverStatus", json!({ "health": "ok", "quiescent": true })).unwrap();
+    let hover = tokio::time::timeout(Duration::from_secs(10), hover).await.unwrap().unwrap().unwrap();
+    assert!(hover.is_some());
+
+    // "Nothing here" is the answer at once: rust-analyzer loaded with `cargo check`
+    // running, and a server without `serverStatus` indexing in the background.
+    for quiescent in [Some(true), None] {
+        let h = harness(&[("mock", incremental_caps())]);
+        let (doc, _) = h.open("a.mk", "x");
+        h.wait_status("mock", ServerStatus::Ready).await;
+        let s = h.launcher.state("mock");
+        let peer = s.peer();
+        if let Some(q) = quiescent {
+            peer.notify("experimental/serverStatus", json!({ "health": "ok", "quiescent": q })).unwrap();
+        }
+        peer.notify("$/progress", json!({ "token": "bg", "value": { "kind": "begin", "title": "Indexing" } })).unwrap();
+        h.wait_status("mock", ServerStatus::Busy).await;
+        let defs = tokio::time::timeout(Duration::from_secs(2), h.mgr.goto(doc, Pos::new(0, 0), GotoKind::Definition))
+            .await
+            .unwrap_or_else(|_| panic!("{quiescent:?}: no wait for background work"))
+            .unwrap();
+        assert!(defs.is_empty());
+        assert_eq!(s.requested("textDocument/definition").len(), 1, "{quiescent:?}");
+    }
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn progress_titled_with_an_executable_path_shows_the_program_name() {
    let h = harness(&[("mock", incremental_caps())]);
@@ -3333,7 +3405,8 @@ async fn interactive_capability_is_scoped_to_gopls() {
    let (doc, _) = h.open("probe.mk", "x\n");
    h.wait_status("mock", ServerStatus::Ready).await;
    let s = h.launcher.state("mock");
-    assert_eq!(s.requested("initialize")[0]["capabilities"]["experimental"], json!({}));
+    let experimental = &s.requested("initialize")[0]["capabilities"]["experimental"];
+    assert!(experimental.get("interactiveResolve").is_none(), "{experimental}");
    let form = h
        .mgr
        .resolve_command(
@@ -9,7 +9,7 @@ use std::{
    time::{Duration, Instant},
 };

-use ide_core::{IdeError, IdeResult, error::ErrorKind};
+use ide_core::{IdeError, IdeResult, IpcPath, error::ErrorKind};
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use specta::Type;
@@ -22,7 +22,7 @@ use crate::kernel::KernelOutput;
 #[serde(rename_all = "camelCase")]
 pub struct NotebookSnapshot {
    pub id: String,
-    pub path: String,
+    pub path: IpcPath,
    pub version: u32,
    pub dirty: bool,
    pub can_undo: bool,
@@ -188,7 +188,7 @@ impl NotebookDocument {
    pub fn snapshot(&self) -> NotebookSnapshot {
        NotebookSnapshot {
            id: self.id.clone(),
-            path: self.path.to_string_lossy().into_owned(),
+            path: self.path.clone().into(),
            version: self.version,
            dirty: self.is_dirty(),
            can_undo: !self.execution_active && !self.undo.is_empty(),
@@ -22,3 +22,4 @@ wasmtime-wasi = { version = "49.0.4", default-features = false, features = ["p2"
 [dev-dependencies]
 tempfile.workspace = true
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "time"] }
+wat = "1.258"
@@ -13,6 +13,7 @@ use crate::types::{
 };
 use crate::wit_host::{bindings, providers_bindings, syntax_bindings, views_bindings};
 use ide_core::CancellationToken;
+use ide_core::ipc_path::to_ipc;
 use ide_extension::Capability;
 use parking_lot::Mutex;
 use std::path::Path;
@@ -32,7 +33,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
 use views_bindings::openidea::plugin::view_types as wit_vt;

 /// The API version of the world above, `major.minor` of [`host_api`].
-pub const API_VERSION: &str = "1.0";
+pub const API_VERSION: &str = "1.1";
 const EPOCH_TICK: Duration = Duration::from_millis(10);
 pub(crate) const MAX_TEXT: usize = 1 << 20;
 pub(crate) const MAX_TITLE: usize = 256;
@@ -45,6 +46,14 @@ pub const CANCELLED: &str = "was cancelled";
 /// documents. Capabilities are already checked when these are called.
 pub trait HostApi: Send + Sync {
    fn notify(&self, client: Option<&str>, level: NotificationLevel, title: String, body: String);
+    fn copy_to_clipboard(&self, client: Option<&str>, text: String) -> Result<(), HostError> {
+        let _ = (client, text);
+        Ok(())
+    }
+    fn open_url(&self, client: Option<&str>, url: String) -> Result<(), HostError> {
+        let _ = (client, url);
+        Ok(())
+    }
    /// Sets (`Some`) or removes the plugin's status bar item `id`.
    fn status_item(&self, id: &str, item: Option<StatusItem>);
    /// Roots of the open projects.
@@ -66,6 +75,10 @@ pub trait HostApi: Send + Sync {
    fn storage_set(&self, key: &str, value: Option<String>) -> Result<(), HostError>;
    fn storage_keys(&self, prefix: &str) -> Result<Vec<String>, HostError>;
    fn vcs_status(&self, root: &Path) -> Result<Option<RepositoryStatus>, HostError>;
+    fn vcs_remotes(&self, root: &Path) -> Result<Vec<(String, String)>, HostError> {
+        let _ = root;
+        Ok(Vec::new())
+    }
    fn vcs_fetch(&self, root: &Path, cancel: &CancellationToken) -> Result<(), HostError>;
    /// Subscribes to (or unsubscribes from) a kind of workbench event.
    /// Project files matching `glob` (root-relative), at most `limit`.
@@ -199,8 +212,10 @@ impl PluginEngine {
    /// Rejects a component this host can't run, with a message that says what
    /// to do: one importing interfaces outside the plugin API and WASI, or one
    /// built for a plugin API this host doesn't implement (another major, or a
-    /// newer minor). Returns the API version the component was built for
-    /// (`None`: it uses no plugin interface).
+    /// newer minor), or one that doesn't link: an import the host lacks or
+    /// declares with another type (same API version, different WIT), or a
+    /// missing plugin export. Returns the API version the component was built
+    /// for (`None`: it uses no plugin interface).
    pub fn check_component(&self, component: &Component) -> Result<Option<semver::Version>, String> {
        let ty = component.component_type();
        let imports: Vec<String> = ty.imports(&self.engine).map(|(name, _)| name.to_owned()).collect();
@@ -217,10 +232,20 @@ impl PluginEngine {
        if let Some(v) = &built_for {
            check_api(v, &host_api())?;
        }
+        let pre = self.linker.instantiate_pre(component).map_err(|e| link_error(&format!("{e:#}")))?;
+        bindings::PluginIndices::new(&pre).map_err(|e| link_error(&format!("{e:#}")))?;
        Ok(built_for)
    }
 }

+/// Explains a component that doesn't link against this host's plugin API.
+fn link_error(detail: &str) -> String {
+    format!(
+        "the component doesn't match the plugin API of this IDE ({API_VERSION}): {detail}. \
+         If it was built for a newer OpenIDEA, update OpenIDEA; otherwise rebuild it with the {API_VERSION} SDK"
+    )
+}
+
 /// Interface names of the plugin API start with this (`openidea:plugin/[email protected]`).
 const PLUGIN_PACKAGE_PREFIX: &str = "openidea:plugin/";

@@ -530,11 +555,7 @@ impl Runtime {
        arm(&mut store, &setup.limits, setup.limits.timeout).map_err(|e| e.to_string())?;
        let api_hint = |e: wasmtime::Error| {
            let msg = describe_trap(&e, &setup.limits);
-            if msg.contains("openidea:plugin/") {
-                format!("{msg} (the component was built for a different plugin API; this IDE runs API {API_VERSION})")
-            } else {
-                msg
-            }
+            if msg.contains("openidea:plugin/") { link_error(&msg) } else { msg }
        };
        let pre = engine.linker.instantiate_pre(component).map_err(api_hint)?;
        let plugin_indices = bindings::PluginIndices::new(&pre).map_err(api_hint)?;
@@ -915,12 +936,7 @@ fn location_from_wit(l: wit_types::Location) -> Location {
 }

 fn doc_to_wit(d: &ProviderDocument) -> wit_prov::Document {
-    wit_prov::Document {
-        path: d.path.to_string_lossy().into_owned(),
-        language: d.language.clone(),
-        version: d.version,
-        text: d.text.clone(),
-    }
+    wit_prov::Document { path: to_ipc(&d.path), language: d.language.clone(), version: d.version, text: d.text.clone() }
 }

 /// Resets the budgets for the next call: fuel, deadline, cancellation.
@@ -992,7 +1008,7 @@ fn code_action_to_wit(a: &CodeAction) -> wit_prov::CodeAction {
            .edits
            .iter()
            .map(|(path, edits)| wit_prov::FileEdit {
-                path: path.to_string_lossy().into_owned(),
+                path: to_ipc(path),
                edits: edits
                    .iter()
                    .map(|e| wit_types::TextEdit { range: range_to_wit(e.range), text: e.new_text.clone() })
@@ -1111,6 +1127,27 @@ fn event_to_wit_view(e: ViewEvent) -> wit_vt::ViewEvent {
 mod tests {
    use super::*;

+    #[cfg(windows)]
+    #[test]
+    fn provider_and_resolved_action_paths_match_ipc_events() {
+        for (path, expected) in [
+            (r"C:\project\Example.java", "C:/project/Example.java"),
+            (r"\\?\C:\project\Example.java", "C:/project/Example.java"),
+            (r"\\server\share\Example.java", "//server/share/Example.java"),
+        ] {
+            let doc = ProviderDocument { path: path.into(), ..Default::default() };
+            assert_eq!(doc_to_wit(&doc).path, expected);
+            let action = CodeAction {
+                title: "Fix".into(),
+                kind: None,
+                preferred: false,
+                edits: vec![(path.into(), Vec::new())],
+                data: None,
+            };
+            assert_eq!(code_action_to_wit(&action).edits[0].path, expected);
+        }
+    }
+
    fn ext(kind: &str) -> wit_types::Extension {
        wit_types::Extension { kind: kind.into(), data: "{}".into() }
    }
@@ -5,6 +5,7 @@
 use crate::runtime::{StoreData, clip};
 use crate::sandbox;
 use crate::types::{EditorContext, EventKind, HostError, HttpRequest, NotificationLevel, StatusItem, net_host};
+use ide_core::ipc_path::to_ipc;
 use ide_extension::Capability;
 use std::path::{Path, PathBuf};
 use std::time::{Duration, Instant};
@@ -242,6 +243,24 @@ impl ui::Host for StoreData {
        self.host.status_item(&clip(id, 64), None);
        Ok(())
    }
+
+    fn copy_to_clipboard(&mut self, text: String) -> Fallible<()> {
+        if let Err(e) = self.require(Capability::Clipboard) {
+            return Ok(Err(e));
+        }
+        let client = self.invocation.client.clone();
+        Ok(self.host.copy_to_clipboard(client.as_deref(), clip(text, crate::runtime::MAX_TEXT)).map_err(to_wit))
+    }
+
+    fn open_url(&mut self, url: String) -> Fallible<()> {
+        let trimmed = url.trim();
+        let valid = (trimmed.starts_with("https://") || trimmed.starts_with("http://")) && trimmed.len() <= 8192;
+        if !valid {
+            return Ok(Err(wit::Error::Invalid(format!("{url:?}: expected an http:// or https:// URL"))));
+        }
+        let client = self.invocation.client.clone();
+        Ok(self.host.open_url(client.as_deref(), trimmed.to_owned()).map_err(to_wit))
+    }
 }

 impl storage::Host for StoreData {
@@ -292,7 +311,8 @@ impl workspace::HostProject for StoreData {
        if let Err(e) = self.require(Capability::ProjectRead) {
            return Ok(Err(e));
        }
-        Ok(Ok(self.table.get(&this)?.root.to_string_lossy().into_owned()))
+        // Paths reach plugins in IPC form (`/` on Windows), as the UI's event paths do, so they compare as text.
+        Ok(Ok(to_ipc(&self.table.get(&this)?.root)))
    }

    fn read_file(&mut self, this: Resource<ProjectRes>, path: String) -> Fallible<String> {
@@ -328,7 +348,7 @@ impl editor::Host for StoreData {}

 impl editor::HostTextEditor for StoreData {
    fn path(&mut self, this: Resource<EditorRes>) -> wasmtime::Result<String> {
-        Ok(self.table.get(&this)?.ctx.path.to_string_lossy().into_owned())
+        Ok(to_ipc(&self.table.get(&this)?.ctx.path))
    }

    fn language(&mut self, this: Resource<EditorRes>) -> wasmtime::Result<String> {
@@ -438,6 +458,14 @@ impl vcs::Host for StoreData {
        let token = self.cancel.token();
        Ok(self.host.vcs_fetch(&root, &token).map_err(to_wit))
    }
+
+    fn remotes(&mut self, project: Resource<ProjectRes>) -> Fallible<Vec<(String, String)>> {
+        if let Err(e) = self.require(Capability::VcsRead) {
+            return Ok(Err(e));
+        }
+        let root = self.table.get(&project)?.root.clone();
+        Ok(self.host.vcs_remotes(&root).map_err(to_wit))
+    }
 }

 impl events::Host for StoreData {
@@ -0,0 +1,43 @@
+//! `PluginEngine::check_component` (what installing and `openidea-plugin check`
+//! run) refuses a component the IDE could not start: every import has to link
+//! against the host, function by function, and the plugin world's exports have
+//! to be there, not only the interface names and their API version.
+
+use ide_plugin::PluginEngine;
+
+fn check(wat: &str) -> Result<Option<semver::Version>, String> {
+    let engine = PluginEngine::new().unwrap();
+    let component = engine.compile_bytes(&wat::parse_str(wat).unwrap()).unwrap();
+    engine.check_component(&component)
+}
+
+#[test]
+fn components_the_host_cannot_link_are_refused() {
+    let cases = [
+        // As dengliu.gitlink 0.1.0 was: built from unreleased WIT that added functions under the same version.
+        (
+            "a function the host's interface lacks",
+            r#"(component (import "openidea:plugin/ui@1.0.0" (instance
+                (export "not-a-host-function" (func (param "text" string))))))"#,
+            "not-a-host-function",
+        ),
+        (
+            "a function with another signature",
+            r#"(component (import "openidea:plugin/ui@1.0.0" (instance
+                (export "show-notification" (func (param "title" string))))))"#,
+            "show-notification",
+        ),
+        (
+            "an interface the host lacks",
+            r#"(component (import "openidea:plugin/clipboard@1.0.0" (instance
+                (export "copy" (func (param "text" string))))))"#,
+            "openidea:plugin/[email protected]",
+        ),
+        ("no plugin exports", r#"(component (import "openidea:plugin/[email protected]" (instance)))"#, "lifecycle"),
+    ];
+    for (case, wat, names) in cases {
+        let err = check(wat).expect_err(case);
+        assert!(err.contains(names), "{case}: {err}");
+        assert!(err.contains("update OpenIDEA") && err.contains("rebuild"), "{case}: {err}");
+    }
+}
@@ -1 +1 @@
-1f7402e2b1b4602e4073eb61837c3dc8840f9a4f7275d800dbd6fcf6ce5e40c3
+455d848dd27f242bb3e9bf420558cbc8c200853f51ada3d481635ac9771803f3
@@ -1 +1 @@
-4f6cd5b5e0c12e7dcbccf66a6ad97276bf968bc3ad26f0fd08e1f7765cbfee14
+f7e1ae06a90460ed1d2319bfc51f848654df145fa451f3d959b32776b2b25ce3
@@ -12,7 +12,7 @@ activation = ["on-view:jobs", "on-command:*"]

 [capabilities]
 required = ["process:jobs"]
-optional = ["project.read"]
+optional = ["project.read", "vcs.read", "clipboard"]

 [[contributes.views]]
 id = "jobs"
@@ -32,9 +32,22 @@ impl Jobs {
 }

 impl Plugin for Jobs {
-    fn run_command(&mut self, id: &str, _ctx: &Invocation, _arg: Option<&str>) -> Result<Option<String>, Error> {
+    fn run_command(&mut self, id: &str, ctx: &Invocation, arg: Option<&str>) -> Result<Option<String>, Error> {
        match id {
            "follow" => self.follow().map(|()| None),
+            "remotes" => {
+                let project = ctx.project().ok_or("no project is open")?;
+                let remotes = project.vcs_remotes()?;
+                Ok(Some(remotes.into_iter().map(|(n, u)| format!("{n}={u}")).collect::<Vec<_>>().join("\n")))
+            }
+            "copy" => {
+                host::copy_to_clipboard(arg.unwrap_or_default())?;
+                Ok(None)
+            }
+            "open-url" => {
+                host::open_url(arg.unwrap_or_default())?;
+                Ok(None)
+            }
            _ => Err(Error::NotFound(format!("command {id}"))),
        }
    }
@@ -1 +1 @@
-3d4dd1b6365c7fbafdd3c1f99f4405e5ee40fc5e56c97da960adfe7af2e7edb8
+12973c7ca7330fc50eb16718fd769d412401b5a92bd014f4804659e4a272122f
@@ -5,8 +5,8 @@ wit_bindgen::generate!({
    inline: "
        package fixture:misbehave;
        world misbehave {
-            include openidea:plugin/plugin-syntax@1.0.0;
-            export openidea:plugin/providers@1.0.0;
+            include openidea:plugin/plugin-syntax@1.1.0;
+            export openidea:plugin/providers@1.1.0;
        }
    ",
    path: "../../../../../wit",
@@ -564,9 +564,8 @@ fn spring_boot_apps(root: &Path, build: &Path, out: &mut Vec<RunConfig>) {
                Some(m) => format!("application:{m}:{class}"),
                None => format!("application:{class}"),
            };
-            let mut app = config(id, simple, "spring-boot", "java", &["-cp", "${classpath}", &class])
-                .in_dir(module_rel.as_ref().map(PathBuf::from))
-                .debug("java-debug");
+            let mut app =
+                config(id, simple, "spring-boot", "java", &["-cp", "${classpath}", &class]).debug("java-debug");
            app.extras.module = Some(module_rel.clone().unwrap_or_default());
            out.push(app);
        }
@@ -1060,6 +1059,10 @@ fn ruby_config(
    c
 }

+/// Loads the test files of the directories (or files) named in `ARGV`, default `test`, the way `rake test`
+/// does; options such as `-v` stay in `ARGV` for Minitest.
+const MINITEST_RUNNER: &str = r#"paths, opts = ARGV.partition { |a| !a.start_with?("-") }; ARGV.replace(opts); (paths.empty? ? ["test"] : paths).flat_map { |d| File.file?(d) ? [d] : Dir[File.join(d, "**", "{*_test,test_*}.rb")] }.sort.each { |f| require File.expand_path(f) }"#;
+
 fn uses_rspec(root: &Path) -> bool {
    root.join("spec").is_dir()
        || root.join(".rspec").is_file()
@@ -1102,6 +1105,17 @@ fn detect_ruby(root: &Path, out: &mut Vec<RunConfig>) {
    }
    if uses_rspec(root) {
        out.push(ruby_config("rspec".into(), "rspec".into(), "rspec", ruby_tool(root, "rspec"), &[]).test());
+    } else if root.join("test").is_dir() && !out.iter().any(|c| c.id == "rake:test") {
+        // Minitest / Test::Unit without a `test` Rake task: load every test file under `test/`.
+        let mut args = Vec::new();
+        for dir in ["lib", "test"] {
+            if root.join(dir).is_dir() {
+                args.push(format!("-I{dir}"));
+            }
+        }
+        args.extend(["-e".to_owned(), MINITEST_RUNNER.to_owned(), "test".to_owned()]);
+        let extra: Vec<&str> = args.iter().map(String::as_str).collect();
+        out.push(ruby_config("minitest".into(), "minitest".into(), "ruby", ruby_tool(root, "ruby"), &extra).test());
    }
 }

@@ -3,8 +3,9 @@
 //! its templates (`default="true"`) and temporary configurations. A configuration found in more
 //! than one place is taken from the first, in that order.
 //!
-//! Python, Django server, Django tests, pytest, npm, Jest, Vitest, Node.js, Shell Script and
-//! compound configurations become the matching kinds; other types are skipped with their type.
+//! Python, Django server, Django tests, pytest, npm, Jest, Vitest, Node.js, Shell Script,
+//! Application, Spring Boot and compound configurations become the matching kinds; other types
+//! are skipped with their type.
 //! `$PROJECT_DIR$` (and `$MODULE_DIR$`, `$MODULE_WORKING_DIR$`, `$ContentRoot$`,
 //! `$ProjectFileDir$`, all the project directory here) and `$USER_HOME$` are replaced; another
 //! path variable skips the configuration.
@@ -162,6 +163,8 @@ const VITEST: &str = "JavaScriptTestRunnerVitest";
 const NODE: &str = "NodeJSConfigurationType";
 const SHELL: &str = "ShConfigurationType";
 const COMPOUND: &str = "CompoundRunConfigurationType";
+const APPLICATION: &str = "Application";
+const SPRING_BOOT: &str = "SpringBootApplicationConfigurationType";

 type Res<T> = Result<T, SkipReason>;

@@ -329,6 +332,8 @@ impl Cx<'_> {
            JEST | VITEST => self.js_tests(name, c, ty == VITEST, &mut ignored)?,
            NODE => self.node(name, c, &mut ignored)?,
            SHELL => self.shell(name, c)?,
+            APPLICATION => self.java_app(name, c, false, &mut ignored)?,
+            SPRING_BOOT => self.java_app(name, c, true, &mut ignored)?,
            COMPOUND => {
                members = c.children_named("toRun").filter_map(|t| t.attr("name")).map(str::to_owned).collect();
                config(name, "compound", String::new(), Vec::new(), None)
@@ -695,6 +700,54 @@ impl Cx<'_> {
        Ok(rc)
    }

+    // ------------------------------------------------------------- Java
+
+    /// IDEA's Application and Spring Boot types, as the `application` / `spring-boot` forms run
+    /// them: `java <vm options> -cp ${classpath} <main> [--spring.profiles.active=…] <arguments>`
+    /// with the module's runtime classpath.
+    fn java_app(&self, name: &str, c: &El, spring: bool, ignored: &mut Vec<String>) -> Res<RunConfig> {
+        let main = if spring { "SPRING_BOOT_MAIN_CLASS" } else { "MAIN_CLASS_NAME" };
+        let Some(main) = self.text(c.option(main))? else { return Err(SkipReason::NothingToRun) };
+        let (_, cwd) = self.cwd(c.option("WORKING_DIRECTORY"))?;
+        let mut args = self.words(c.option("VM_PARAMETERS"))?;
+        args.extend(["-cp".to_owned(), "${classpath}".to_owned(), main]);
+        if spring && let Some(profiles) = self.text(c.option("ACTIVE_PROFILES"))? {
+            args.push(format!("--spring.profiles.active={profiles}"));
+        }
+        args.extend(self.words(c.option("PROGRAM_PARAMETERS"))?);
+        let mut rc =
+            config(name, if spring { "spring-boot" } else { "application" }, "java".into(), args, Some("java-debug"));
+        rc.cwd = cwd.map(Into::into);
+        self.envs(c, &mut rc);
+        if let Some(module) = c.child("module").and_then(|m| m.attr("name")).filter(|m| !m.is_empty()) {
+            match module_dir(self.root, module) {
+                Some(dir) => rc.extras.module = Some(dir),
+                None => ignored.push(format!("module {module}")),
+            }
+        }
+        // Options the forms have no field for.
+        if c.flag("ALTERNATIVE_JRE_PATH_ENABLED") {
+            ignored.push("JRE".into());
+        }
+        if c.flag("INCLUDE_PROVIDED_SCOPE") {
+            ignored.push("provided scope".into());
+        }
+        if c.child("classpathModifications").is_some_and(|m| !m.children.is_empty()) {
+            ignored.push("classpath modifications".into());
+        }
+        if spring {
+            for (option, label) in [("HIDE_BANNER", "hide banner"), ("DEBUG_MODE", "debug output")] {
+                if c.flag(option) {
+                    ignored.push(label.into());
+                }
+            }
+            if c.child("additionalParameters").is_some_and(|p| !p.children.is_empty()) {
+                ignored.push("override configuration properties".into());
+            }
+        }
+        Ok(rc)
+    }
+
    // ------------------------------------------------------------- Shell

    /// A script file (with its interpreter) or script text, kept as the Shell Script form's fields.
@@ -835,6 +888,56 @@ fn module_count(root: &Path) -> usize {
        .sum()
 }

+/// The folder (relative, `""` for the project's own) of IDEA module `name`: a Maven module is
+/// named after its `artifactId` (usually its folder), a Gradle one `<project>.<path>.<source set>`.
+fn module_dir(root: &Path, name: &str) -> Option<String> {
+    let folder = |dir: &Path| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+    let exact = |dir: &Path| folder(dir) == name || pom_artifact(dir).is_some_and(|a| a == name);
+    if let Some(dir) = find_module(root, &exact) {
+        return Some(dir);
+    }
+    let gradle = name.strip_suffix(".main").or_else(|| name.strip_suffix(".test")).unwrap_or(name);
+    let last = gradle.rsplit('.').next().filter(|last| *last != name)?;
+    find_module(root, &|dir: &Path| folder(dir) == last)
+}
+
+/// The shallowest build folder under `root` (itself included) that `names` accepts.
+fn find_module(root: &Path, names: &dyn Fn(&Path) -> bool) -> Option<String> {
+    const BUILDS: [&str; 3] = ["pom.xml", "build.gradle", "build.gradle.kts"];
+    let mut level = vec![root.to_path_buf()];
+    for _ in 0..5 {
+        if let Some(found) = level.iter().find(|d| BUILDS.iter().any(|b| d.join(b).is_file()) && names(d)) {
+            let rel = found.strip_prefix(root).ok()?;
+            return Some(rel.to_string_lossy().replace('\\', "/"));
+        }
+        let mut next: Vec<PathBuf> = level
+            .iter()
+            .filter_map(|d| std::fs::read_dir(d).ok())
+            .flat_map(|entries| entries.flatten().map(|e| e.path()))
+            .filter(|p| p.is_dir())
+            .filter(|p| {
+                let n = p.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+                !n.starts_with('.') && !["node_modules", "target", "build", "out", "src"].contains(&n.as_str())
+            })
+            .collect();
+        next.sort();
+        level = next;
+    }
+    None
+}
+
+/// The `artifactId` of the module's own `pom.xml` (not its parent's).
+fn pom_artifact(dir: &Path) -> Option<String> {
+    let pom = std::fs::read_to_string(dir.join("pom.xml")).ok()?;
+    let own = match (pom.find("<parent>"), pom.find("</parent>")) {
+        (Some(start), Some(end)) if start < end => format!("{}{}", &pom[..start], &pom[end..]),
+        _ => pom,
+    };
+    let start = own.find("<artifactId>")? + "<artifactId>".len();
+    let end = start + own[start..].find("</artifactId>")?;
+    Some(own[start..end].trim().to_owned())
+}
+
 /// `--settings` from PyCharm's "Settings" field: a file (`mysite/settings/dev.py`, relative to
 /// the project) becomes its module relative to the working directory; a module stays as it is.
 fn settings_module(value: &str, root: &Path, dir: &Path) -> String {
@@ -12,6 +12,8 @@ pub mod java_cmdline;
 pub mod junit;
 mod process;
 pub mod python_path;
+pub mod ruby_preload;
+pub mod ruby_reporter;
 pub mod tomcat;
 mod utf8;
 pub mod which;
@@ -80,6 +80,8 @@ pub struct StartOptions {
    pub encoding: Option<String>,
    /// Project content and source roots added to Python launch environments.
    pub python_paths: Vec<PathBuf>,
+    /// Where the Ruby test reporter is installed (see [`crate::ruby_reporter`]); Ruby test runs load it.
+    pub ruby_reporter: Option<PathBuf>,
 }

 #[derive(Default)]
@@ -355,6 +357,10 @@ impl ProcessManager {
        if matches!(config.kind.as_str(), "python" | "pytest" | "django-test") {
            crate::python_path::extend(&mut env.vars, &options.python_paths, !env.clear)?;
        }
+        if let Some(dir) = options.ruby_reporter.as_deref().filter(|_| crate::ruby_reporter::applies(config)) {
+            crate::ruby_preload::add(&mut env.vars, dir, crate::ruby_reporter::FEATURE, !env.clear);
+            env.vars.insert("OPENIDEA_TEST_REPORT".into(), "1".into());
+        }
        let on_output: OutputFn = Arc::from(on_output);
        let on_output = match extras.output_file.as_deref() {
            Some(file) => tee_output(&resolve_cwd(root, Some(Path::new(file))), on_output)?,
@@ -0,0 +1,61 @@
+//! Loads a Ruby file into a launched process without touching the project: the directory goes on
+//! `RUBYLIB` and `RUBYOPT` gets the bare feature name (`-ropenidea_hook`).
+//!
+//! `RUBYOPT` is split at spaces with no quoting, so an absolute path in it (`-r/…/Application
+//! Support/…/hook.rb`, where the IDE keeps its data) makes Ruby fail with `invalid switch in RUBYOPT`.
+//! `RUBYLIB` is a path list and takes spaces.
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+/// Makes `feature` (a file `<dir>/<feature>.rb`) load first in every Ruby the process starts.
+/// `inherit`: the process also sees the IDE's own environment, whose `RUBYLIB` / `RUBYOPT` stay.
+pub fn add(env: &mut BTreeMap<String, String>, dir: &Path, feature: &str, inherit: bool) {
+    let mut inherited = if inherit { crate::system_env() } else { BTreeMap::new() };
+    let mut existing = |name: &str| env.get(name).cloned().or_else(|| inherited.remove(name)).filter(|v| !v.is_empty());
+
+    let mut dirs: Vec<PathBuf> = vec![dir.to_path_buf()];
+    if let Some(lib) = existing("RUBYLIB") {
+        for d in std::env::split_paths(&lib) {
+            if !dirs.contains(&d) {
+                dirs.push(d);
+            }
+        }
+    }
+    let rubyopt = existing("RUBYOPT");
+    if let Ok(joined) = std::env::join_paths(dirs) {
+        env.insert("RUBYLIB".into(), joined.to_string_lossy().into_owned());
+    }
+    let option = format!("-r{feature}");
+    let value = match rubyopt {
+        Some(e) if e.split_whitespace().any(|o| o == option) => e,
+        Some(e) => format!("{e} {option}"),
+        None => option,
+    };
+    env.insert("RUBYOPT".into(), value);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_directory_with_spaces_goes_on_rubylib_not_into_rubyopt() {
+        let dir = Path::new("/Users/me/Library/Application Support/ide/ruby");
+        let mut env = BTreeMap::new();
+        add(&mut env, dir, "openidea_hook", false);
+        assert_eq!(env["RUBYLIB"], dir.to_string_lossy());
+        assert_eq!(env["RUBYOPT"], "-ropenidea_hook");
+        assert!(!env["RUBYOPT"].contains(' '));
+    }
+
+    #[test]
+    fn keeps_existing_settings_and_adds_once() {
+        // Path lists use the platform's separator (`;` on Windows).
+        let list = |dirs: &[&str]| std::env::join_paths(dirs).unwrap().to_string_lossy().into_owned();
+        let mut env = BTreeMap::from([("RUBYLIB".into(), list(&["/a", "/b"])), ("RUBYOPT".into(), "-w".into())]);
+        add(&mut env, Path::new("/hook"), "h", false);
+        add(&mut env, Path::new("/hook"), "h", false);
+        assert_eq!(env["RUBYLIB"], list(&["/hook", "/a", "/b"]));
+        assert_eq!(env["RUBYOPT"], "-w -rh");
+    }
+}
@@ -0,0 +1,52 @@
+//! A Minitest reporter the IDE loads into test runs (see `ruby_reporter/`): it prints one record per
+//! test on stdout, which the IDE strips from the console and turns into the test tree. Tests then
+//! report their real source file and line, and the output no longer needs `-v` to be parsed.
+use crate::RunConfig;
+use std::io;
+use std::path::Path;
+
+/// The Ruby file `RUBYOPT` loads first (`<dir>/openidea_test_hook.rb`).
+pub const FEATURE: &str = "openidea_test_hook";
+
+const FILES: [(&str, &str); 2] = [
+    ("openidea_test_hook.rb", include_str!("ruby_reporter/openidea_test_hook.rb")),
+    ("openidea/minitest_reporter.rb", include_str!("ruby_reporter/minitest_reporter.rb")),
+];
+
+/// Whether a run takes the reporter: Minitest-style test runs through `ruby` or `rake`, with their output
+/// in the console (a terminal would show the records).
+pub fn applies(config: &RunConfig) -> bool {
+    config.is_test && matches!(config.kind.as_str(), "ruby" | "rake") && !config.extras.emulate_terminal
+}
+
+/// Writes the reporter files under `dir` (unchanged files stay).
+pub fn install(dir: &Path) -> io::Result<()> {
+    for (name, text) in FILES {
+        let path = dir.join(name);
+        if std::fs::read_to_string(&path).is_ok_and(|current| current == text) {
+            continue;
+        }
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        std::fs::write(&path, text)?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn installs_the_files_once_and_only_for_ruby_test_runs() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path().join("ruby reporter");
+        install(&dir).unwrap();
+        install(&dir).unwrap();
+        for (name, text) in FILES {
+            assert_eq!(std::fs::read_to_string(dir.join(name)).unwrap(), text);
+        }
+        assert!(FILES[0].1.contains("OPENIDEA_TEST_REPORT") && FILES[1].1.contains("@@OPENIDEA@@"));
+    }
+}
@@ -0,0 +1,78 @@
+# Written by OpenIDEA for test runs; registered by `openidea_test_hook.rb` once Minitest is loaded.
+# Nothing in the project is changed.
+#
+# One record per line on stdout, which the IDE strips from the console again:
+#   @@OPENIDEA@@{"t":"start","c":"MyTest","n":"test_x","f":"/abs/test.rb","l":12}
+#   @@OPENIDEA@@{"t":"result","c":"MyTest","n":"test_x","s":"passed","d":0.001,"f":...,"l":...,"m":"failure text"}
+#   @@OPENIDEA@@{"t":"summary","runs":7,"failures":1,"errors":1,"skips":1,"d":0.4}
+require "json"
+
+module Minitest
+  class OpenIdeaReporter < AbstractReporter
+    MARK = "@@OPENIDEA@@"
+
+    def initialize(io)
+      super()
+      @io = io
+      @cwd = Dir.pwd
+      @lock = Mutex.new
+      @runs = @failures = @errors = @skips = 0
+      @started = nil
+    end
+
+    def start
+      @started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def prerecord(klass, name)
+      emit(t: "start", c: klass.to_s, n: name.to_s, **where(klass, name))
+    end
+
+    def record(result)
+      @runs += 1
+      status = result.skipped? ? "skipped" : result.passed? ? "passed" : "failed"
+      @skips += 1 if status == "skipped"
+      if status == "failed"
+        result.failures.any? { |f| f.is_a?(UnexpectedError) } ? @errors += 1 : @failures += 1
+      end
+      loc = result.source_location
+      emit(t: "result", c: result.klass.to_s, n: result.name.to_s, s: status, d: result.time,
+           f: loc && absolute(loc[0]), l: loc && loc[1], m: result.failures.map(&:message).join("\n"))
+    end
+
+    def report
+      d = @started ? Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started : nil
+      emit(t: "summary", runs: @runs, failures: @failures, errors: @errors, skips: @skips, d: d)
+    end
+
+    private
+
+    # Where the test is defined, known before it runs (so the tree can show it while running).
+    def where(klass, name)
+      f, l = klass.instance_method(name).source_location
+      { f: absolute(f), l: l }
+    rescue StandardError
+      {}
+    end
+
+    # Test files are often loaded by a path relative to the working directory.
+    def absolute(file)
+      File.expand_path(file, @cwd)
+    end
+
+    def emit(record)
+      line = "#{MARK}#{JSON.generate(record)}\n"
+      @lock.synchronize { @io.write(line) }
+    rescue StandardError
+      nil # reporting must never fail a test run
+    end
+  end
+
+  def self.plugin_openidea_init(options)
+    return unless ENV["OPENIDEA_TEST_REPORT"]
+
+    io = options[:io] || $stdout
+    io.sync = true if io.respond_to?(:sync=)
+    reporter << OpenIdeaReporter.new(io)
+  end
+end
@@ -0,0 +1,32 @@
+# Written by OpenIDEA for test runs. Loaded first in every Ruby the run starts
+# (RUBYLIB=<this directory>, RUBYOPT=-ropenidea_test_hook).
+#
+# Registers the test reporter once a test framework is loaded. Minitest 5 would find a plugin on
+# its own, Minitest 6 does not load plugins any more, so both are registered the same way.
+if ENV["OPENIDEA_TEST_REPORT"]
+  module OpenIdeaTestHook
+    @registered = false
+
+    def self.register
+      return if @registered
+      return unless defined?(::Minitest) && ::Minitest.respond_to?(:extensions) && defined?(::Minitest::AbstractReporter)
+
+      @registered = true
+      require "openidea/minitest_reporter"
+      ::Minitest.extensions << "openidea" unless ::Minitest.extensions.include?("openidea")
+    rescue StandardError, LoadError
+      nil # reporting must never break a test run
+    end
+
+    # `require "minitest/autorun"` loads Minitest through require_relative, so look after every require.
+    module Watch
+      def require(path)
+        result = super
+        OpenIdeaTestHook.register
+        result
+      end
+    end
+  end
+
+  Kernel.prepend(OpenIdeaTestHook::Watch)
+end
@@ -204,7 +204,7 @@ pub fn explode(war: &Path, destination: &Path, resources_only: bool) -> IdeResul
 }

 /// Updates the exploded artifact deployment from the module's own class output directories and
-/// its web resources (`src/main/webapp`), file by file and only what changed, instead of
+/// its web resources ([`web_sources`]), file by file and only what changed, instead of
 /// rebuilding and re-exploding the WAR. `module` and `class_paths` are absolute.
 /// `Ok(false)`: not possible this way (not deployed from the artifact yet, the module's output
 /// isn't on the classpath, or a module it depends on was compiled since the last update, whose
@@ -232,9 +232,10 @@ pub fn sync_outputs(base: &Path, module: &Path, class_paths: &[PathBuf], resourc
    for dir in own {
        sync_tree(dir, dir, &classes, Path::new("WEB-INF/classes"), resources_only, &mut current)?;
    }
-    let webapp = module.join("src/main/webapp");
-    if webapp.is_dir() {
-        sync_tree(&webapp, &webapp, &dest, Path::new(""), resources_only, &mut current)?;
+    for (dir, target) in web_sources(module) {
+        if dir.is_dir() {
+            sync_tree(&dir, &dir, &dest.join(&target), &target, resources_only, &mut current)?;
+        }
    }
    for rel in previous.iter().filter(|p| !current.contains(*p)) {
        let path = dest.join(rel);
@@ -246,6 +247,59 @@ pub fn sync_outputs(base: &Path, module: &Path, class_paths: &[PathBuf], resourc
    Ok(true)
 }

+/// The folders whose files the WAR puts at its root (or under the second path): the web app
+/// folder (`src/main/webapp`, maven-war-plugin's `warSourceDirectory`, Gradle's
+/// `webAppDirName` / `webAppDirectory`), then maven-war-plugin's `webResources`.
+pub fn web_sources(module: &Path) -> Vec<(PathBuf, PathBuf)> {
+    let rel = |dir: &str| {
+        let dir = ["${project.basedir}/", "${basedir}/"].iter().find_map(|p| dir.strip_prefix(p)).unwrap_or(dir);
+        module.join(dir.trim())
+    };
+    if let Ok(pom) = fs::read_to_string(module.join("pom.xml"))
+        && let Some(war) = war_plugin(&pom)
+    {
+        let mut out = vec![(rel(tag(war, "warSourceDirectory").unwrap_or("src/main/webapp")), PathBuf::new())];
+        let mut rest = tag_block(war, "webResources").unwrap_or_default();
+        while let Some(start) = rest.find("<resource>") {
+            let end = rest[start..].find("</resource>").map_or(rest.len(), |e| start + e);
+            let resource = &rest[start..end];
+            if let Some(dir) = tag(resource, "directory") {
+                out.push((rel(dir), PathBuf::from(tag(resource, "targetPath").unwrap_or_default())));
+            }
+            rest = &rest[end..];
+        }
+        return out;
+    }
+    let gradle = ["build.gradle", "build.gradle.kts"].iter().find_map(|f| fs::read_to_string(module.join(f)).ok());
+    let web_app_dir = gradle.as_deref().and_then(|text| {
+        text.lines()
+            .filter(|l| !l.trim_start().starts_with("//"))
+            .find(|l| l.contains("webAppDirName") || l.contains("webAppDirectory"))
+            .and_then(|l| l.split(['"', '\'']).nth(1).map(str::to_owned))
+    });
+    vec![(rel(web_app_dir.as_deref().unwrap_or("src/main/webapp")), PathBuf::new())]
+}
+
+/// The `<plugin>` element of maven-war-plugin in `pom`, if it is configured there.
+fn war_plugin(pom: &str) -> Option<&str> {
+    let at = pom.find("<artifactId>maven-war-plugin</artifactId>")?;
+    let start = pom[..at].rfind("<plugin>")?;
+    let end = pom[at..].find("</plugin>").map_or(pom.len(), |e| at + e);
+    Some(&pom[start..end])
+}
+
+/// The text of the first `<name>` element in `xml`.
+fn tag<'a>(xml: &'a str, name: &str) -> Option<&'a str> {
+    tag_block(xml, name).map(str::trim).filter(|t| !t.is_empty())
+}
+
+fn tag_block<'a>(xml: &'a str, name: &str) -> Option<&'a str> {
+    let open = format!("<{name}>");
+    let start = xml.find(&open)? + open.len();
+    let end = start + xml[start..].find(&format!("</{name}>"))?;
+    Some(&xml[start..end])
+}
+
 fn modified_since(dir: &Path, since: std::time::SystemTime) -> bool {
    let Ok(entries) = fs::read_dir(dir) else { return false };
    entries.flatten().any(|e| match e.file_type() {
@@ -574,6 +628,83 @@ mod tests {
        fs::File::create(dep.join("Core.class")).unwrap().set_modified(later).unwrap();
        assert!(!sync_outputs(&base, &module, &paths, false).unwrap());
    }
+    #[test]
+    fn web_sources_follow_the_war_plugin_and_gradle_settings() {
+        let tmp = tempfile::tempdir().unwrap();
+        let module = tmp.path();
+        let rel = |sources: Vec<(PathBuf, PathBuf)>| -> Vec<(String, String)> {
+            sources
+                .into_iter()
+                .map(|(d, t)| {
+                    let d = d.strip_prefix(module).unwrap().to_string_lossy().replace('\\', "/");
+                    (d, t.to_string_lossy().into_owned())
+                })
+                .collect()
+        };
+        assert_eq!(rel(web_sources(module)), [("src/main/webapp".to_owned(), String::new())]);
+
+        // An Eclipse-style layout: the JSPs come in through webResources.
+        fs::write(
+            module.join("pom.xml"),
+            r#"<project><build><plugins>
+              <plugin><artifactId>maven-compiler-plugin</artifactId></plugin>
+              <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-war-plugin</artifactId>
+                <configuration>
+                  <warSourceDirectory>${basedir}/web</warSourceDirectory>
+                  <webResources>
+                    <resource><directory>WebContent</directory><includes><include>**/*</include></includes></resource>
+                    <resource><directory>extra</directory><targetPath>static</targetPath></resource>
+                  </webResources>
+                </configuration>
+              </plugin>
+            </plugins></build></project>"#,
+        )
+        .unwrap();
+        assert_eq!(
+            rel(web_sources(module)),
+            [
+                ("web".to_owned(), String::new()),
+                ("WebContent".to_owned(), String::new()),
+                ("extra".to_owned(), "static".to_owned())
+            ]
+        );
+
+        fs::remove_file(module.join("pom.xml")).unwrap();
+        fs::write(
+            module.join("build.gradle"),
+            "plugins { id 'war' }\n// webAppDirName = 'old'\nwebAppDirName = 'WebContent'\n",
+        )
+        .unwrap();
+        assert_eq!(rel(web_sources(module)), [("WebContent".to_owned(), String::new())]);
+    }
+
+    #[test]
+    fn updates_web_resources_outside_src_main_webapp() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let (base, module) = (root.join("base"), root.join("web"));
+        let (dest, out) = (base.join("deployment"), module.join("target/classes"));
+        for dir in [dest.join("WEB-INF/classes"), out.clone(), module.join("WebContent/jsp")] {
+            fs::create_dir_all(dir).unwrap();
+        }
+        fs::write(
+            module.join("pom.xml"),
+            "<project><plugin><artifactId>maven-war-plugin</artifactId><configuration><webResources>\
+             <resource><directory>WebContent</directory></resource></webResources></configuration></plugin></project>",
+        )
+        .unwrap();
+        fs::write(dest.join("index.jsp"), "old").unwrap();
+        fs::write(module.join("WebContent/jsp/list.jsp"), "new").unwrap();
+        fs::write(base.join("artifact-path.txt"), "web.war").unwrap();
+
+        assert!(sync_outputs(&base, &module, std::slice::from_ref(&out), true).unwrap());
+        assert_eq!(fs::read_to_string(dest.join("jsp/list.jsp")).unwrap(), "new");
+        // Files the WAR brought that no source here maps to stay.
+        assert_eq!(fs::read_to_string(dest.join("index.jsp")).unwrap(), "old");
+    }
+
    #[test]
    fn deployment_errors_identify_the_checked_path() {
        let tmp = tempfile::tempdir().unwrap();
@@ -215,7 +215,7 @@ fn builds_nested_in_a_folder_of_repositories() {
    assert_eq!(app.name, "DromaraApplication");
    assert_eq!(app.kind, "spring-boot");
    assert_eq!(cmdline(app), "java -cp ${classpath} org.dromara.DromaraApplication");
-    assert_eq!(app.cwd.as_deref(), Some(Path::new("RuoYi-Vue-Plus/ruoyi-admin")));
+    assert_eq!(app.cwd, None);
    assert_eq!(app.extras.module.as_deref(), Some("RuoYi-Vue-Plus/ruoyi-admin"));
    assert_eq!(app.debug_adapter.as_deref(), Some("java-debug"));
    let package = find(&c, "maven:package:RuoYi-Vue-Plus");
@@ -258,7 +258,7 @@ fn spring_boot_application_of_a_repository_nested_one_or_two_levels_down() {
        let module = format!("{prefix}ruoyi-ai/ruoyi-admin");
        let app = find(&c, &format!("application:{module}:org.ruoyi.RuoYiAIApplication"));
        assert_eq!((app.name.as_str(), app.kind.as_str()), ("RuoYiAIApplication", "spring-boot"), "{prefix}");
-        assert_eq!(app.cwd.as_deref(), Some(Path::new(&module)));
+        assert_eq!((app.cwd.as_deref(), app.extras.module.as_deref()), (None, Some(module.as_str())), "{prefix}");
        assert!(ids(&c).contains(&format!("maven:spring-boot:run:{prefix}ruoyi-ai").as_str()), "{prefix}");
    }
 }
@@ -295,9 +295,9 @@ fn nested_builds_of_every_kind_and_depth() {
    }
    assert!(find(&c, "gradle:test:services/api").is_test);
    let api = find(&c, "application:services/api/app:com.acme.ApiKt");
-    assert_eq!(api.cwd.as_deref(), Some(Path::new("services/api/app")));
+    assert_eq!((api.cwd.as_deref(), api.extras.module.as_deref()), (None, Some("services/api/app")));
    let billing = find(&c, "application:billing:Billing");
-    assert_eq!(billing.cwd.as_deref(), Some(Path::new("billing")));
+    assert_eq!((billing.cwd.as_deref(), billing.extras.module.as_deref()), (None, Some("billing")));
    let builds: Vec<&str> =
        ids(&c).into_iter().filter(|id| id.starts_with("maven:package") || id.starts_with("gradle:build")).collect();
    assert_eq!(builds, ["gradle:build:services/api", "maven:package:billing"]);
@@ -820,6 +820,25 @@ task default: :build
    assert_eq!(find(&c, "rake:build").extras.folder.as_deref(), Some("Rake"));
 }

+#[test]
+fn ruby_minitest_projects_get_a_test_runner() {
+    let dir = project(&[("Gemfile", "source 'https://rubygems.org'\n"), ("lib/a.rb", ""), ("test/a_test.rb", "")]);
+    let c = detect(dir.path());
+    let m = find(&c, "minitest");
+    assert!(m.is_test);
+    assert_eq!(m.kind, "ruby");
+    assert_eq!(
+        (m.command.as_str(), &m.args[..4]),
+        ("bundle", &["exec", "ruby", "-Ilib", "-Itest"].map(String::from)[..])
+    );
+    assert_eq!(m.args.last().map(String::as_str), Some("test"));
+    // A `test` Rake task or RSpec already runs the tests.
+    let dir = project(&[("Rakefile", "task :test\n"), ("test/a_test.rb", "")]);
+    assert!(!ids(&detect(dir.path())).contains(&"minitest"));
+    let dir = project(&[("Gemfile", "gem 'rspec'\n"), ("test/a_test.rb", "")]);
+    assert!(!ids(&detect(dir.path())).contains(&"minitest"));
+}
+
 #[test]
 fn ruby_without_bundler_runs_bare_tools() {
    let dir = project(&[("Rakefile", "task :test\n")]);
@@ -239,8 +239,8 @@ fn workspace_run_manager_skips_templates_and_temporary_configurations() {
      <envs><env name="VITE_API" value="http://localhost:8000" /></envs>
      <method v="2" />
    </configuration>
-    <configuration name="Main" type="Application" factoryName="Application">
-      <option name="MAIN_CLASS_NAME" value="shop.Main" />
+    <configuration name="Main" type="JUnit" factoryName="JUnit">
+      <option name="MAIN_CLASS_NAME" value="shop.MainTest" />
      <method v="2" />
    </configuration>"#
        )),
@@ -272,7 +272,7 @@ fn workspace_run_manager_skips_templates_and_temporary_configurations() {
    assert_eq!(get(&r, "Custom").args, s(&["-m", "pytest", "tests/a.py", "--maxfail=2"]));

    assert_eq!(reason(&r, "Unittests in tests"), &SkipReason::UnsupportedType { type_: "tests (Unittests)".into() });
-    assert_eq!(reason(&r, "Main"), &SkipReason::UnsupportedType { type_: "Application".into() });
+    assert_eq!(reason(&r, "Main"), &SkipReason::UnsupportedType { type_: "JUnit".into() });

    let dev = get(&r, "dev");
    assert_eq!((dev.kind.as_str(), dev.command.as_str()), ("npm", "pnpm"));
@@ -526,14 +526,11 @@ fn sources_are_offered_when_their_files_exist() {
        ),
    );
    assert!(available(dir.path()).is_empty());
-    write(dir.path(), ".idea/workspace.xml", &workspace(r#"<configuration name="App" type="Application" />"#));
+    write(dir.path(), ".idea/workspace.xml", &workspace(r#"<configuration name="App" type="JUnit" />"#));
    assert_eq!(available(dir.path()), [RunImportSource::Jetbrains]);
    write(dir.path(), ".vscode/launch.json", "{}");
    assert_eq!(available(dir.path()), [RunImportSource::Vscode, RunImportSource::Jetbrains]);
-    assert_eq!(
-        reason(&import_from(dir.path(), &[]), "App"),
-        &SkipReason::UnsupportedType { type_: "Application".into() }
-    );
+    assert_eq!(reason(&import_from(dir.path(), &[]), "App"), &SkipReason::UnsupportedType { type_: "JUnit".into() });
 }

 #[test]
@@ -702,3 +699,91 @@ fn flags_defaults_inherited_variables_and_nested_django_tests() {
    assert_eq!((tests.kind.as_str(), tests.is_test), ("python", true));
    assert_eq!(tests.args[..3], s(&["backend/manage.py", "test", "orders"]));
 }
+
+#[test]
+fn java_applications_and_spring_boot_keep_their_module() {
+    let dir = tempfile::tempdir().unwrap();
+    let root = dunce::canonicalize(dir.path()).unwrap();
+    write(&root, "pom.xml", "<project><artifactId>shop</artifactId><packaging>pom</packaging></project>");
+    write(
+        &root,
+        "example-service/pom.xml",
+        "<project><parent><artifactId>shop</artifactId></parent><artifactId>example-service</artifactId></project>",
+    );
+    // IDEA names a Maven module after its artifactId, which needn't be its folder.
+    write(
+        &root,
+        "services/api/pom.xml",
+        "<project><parent><artifactId>shop</artifactId></parent><artifactId>api-service</artifactId></project>",
+    );
+    write(
+        &root,
+        ".idea/workspace.xml",
+        &workspace(
+            r#"    <configuration name="ExampleApplication" type="SpringBootApplicationConfigurationType" factoryName="Spring Boot">
+      <module name="example-service" />
+      <option name="SPRING_BOOT_MAIN_CLASS" value="com.example.ExampleApplication" />
+      <option name="ACTIVE_PROFILES" value="dev,local" />
+      <option name="VM_PARAMETERS" value="-Xmx512m -Dfile.encoding=UTF-8" />
+      <option name="PROGRAM_PARAMETERS" value="--server.port=8081" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/example-service" />
+      <option name="HIDE_BANNER" value="true" />
+      <envs>
+        <env name="TZ" value="UTC" />
+      </envs>
+      <method v="2">
+        <option name="Make" enabled="true" />
+      </method>
+    </configuration>
+    <configuration name="Api" type="Application" factoryName="Application">
+      <option name="MAIN_CLASS_NAME" value="com.example.api.Main" />
+      <module name="api-service" />
+      <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
+      <option name="ALTERNATIVE_JRE_PATH" value="17" />
+      <method v="2" />
+    </configuration>
+    <configuration name="Gone" type="Application" factoryName="Application">
+      <option name="MAIN_CLASS_NAME" value="Gone" />
+      <module name="removed-module" />
+    </configuration>
+    <configuration name="NoMain" type="SpringBootApplicationConfigurationType" factoryName="Spring Boot">
+      <module name="example-service" />
+    </configuration>"#,
+        ),
+    );
+
+    let r = import_from(&root, &[]);
+
+    let boot = get(&r, "ExampleApplication");
+    assert_eq!(boot.kind, "spring-boot");
+    assert_eq!(boot.command, "java");
+    assert_eq!(
+        boot.args,
+        s(&[
+            "-Xmx512m",
+            "-Dfile.encoding=UTF-8",
+            "-cp",
+            "${classpath}",
+            "com.example.ExampleApplication",
+            "--spring.profiles.active=dev,local",
+            "--server.port=8081",
+        ])
+    );
+    assert_eq!(boot.extras.module.as_deref(), Some("example-service"));
+    assert_eq!(cwd(boot), Some(PathBuf::from("example-service")));
+    assert_eq!(boot.env.get("TZ").map(String::as_str), Some("UTC"));
+    assert_eq!(boot.debug_adapter.as_deref(), Some("java-debug"));
+    assert_eq!(ignored(&r, "ExampleApplication"), ["before launch", "hide banner"]);
+
+    let api = get(&r, "Api");
+    assert_eq!(api.kind, "application");
+    assert_eq!(api.args, s(&["-cp", "${classpath}", "com.example.api.Main"]));
+    assert_eq!(api.extras.module.as_deref(), Some("services/api"));
+    assert_eq!(ignored(&r, "Api"), ["JRE"]);
+
+    // A module that isn't here any more: the form finds it by the main class.
+    assert_eq!(get(&r, "Gone").extras.module, None);
+    assert_eq!(ignored(&r, "Gone"), ["module removed-module"]);
+
+    assert_eq!(reason(&r, "NoMain"), &SkipReason::NothingToRun);
+}
@@ -479,6 +479,36 @@ fn python_scripts_import_sibling_packages_and_preserve_env_file_paths() {
    }
 }

+#[test]
+fn ruby_test_runs_load_the_reporter_and_other_runs_do_not() {
+    let reporter = std::env::temp_dir().join("ruby reporter");
+    let run = |kind: &str, is_test: bool| {
+        let h = harness();
+        let mut config =
+            cfg("ruby-env", "/bin/sh", &["-c", r#"echo "lib=$RUBYLIB opt=$RUBYOPT report=$OPENIDEA_TEST_REPORT""#]);
+        config.kind = kind.into();
+        config.is_test = is_test;
+        let options = StartOptions { ruby_reporter: Some(reporter.clone()), ..Default::default() };
+        let chunks: Chunks = Arc::default();
+        let sink = chunks.clone();
+        let info =
+            h.pm.start(h.root.path(), &config, &options, h.sink.clone(), Box::new(move |c| sink.lock().push(c)))
+                .unwrap();
+        assert_eq!(wait_exit(&h, info.id, Duration::from_secs(10)), Some(0));
+        text(&chunks, stdout)
+    };
+    for kind in ["ruby", "rake"] {
+        let out = run(kind, true);
+        // The directory has a space: it is on RUBYLIB and only the bare feature name is in RUBYOPT.
+        assert!(out.contains(&format!("lib={}", reporter.display())), "{out}");
+        assert!(out.contains("-ropenidea_test_hook") && !out.contains(&format!("-r{}", reporter.display())), "{out}");
+        assert!(out.contains("report=1"), "{out}");
+    }
+    for (kind, is_test) in [("ruby", false), ("rspec", true), ("pytest", true)] {
+        assert!(run(kind, is_test).contains("report=\n"), "{kind} {is_test}");
+    }
+}
+
 #[test]
 fn revoking_one_project_stops_only_its_runs() {
    let h = harness();
@@ -691,6 +691,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
        path_dirs.push(dir);
    }

+    // Gems install to the Ruby's bindir, which is not always on `PATH` (Homebrew).
+    if name == "ruby-lsp"
+        && let Some(ruby) = ruby_interpreter(root, s)
+    {
+        path_dirs.extend(crate::ruby::gem_bin_dirs(&ruby, server_root));
+    }
+
    if !path_dirs.is_empty() {
        let dirs: Vec<&Path> = path_dirs.iter().map(PathBuf::as_path).collect();
        cfg.env.insert("PATH".into(), path_with(&dirs));
@@ -1301,3 +1308,29 @@ mod maven_linkage_tests {
        assert!(serde_json::to_value(cfg.initialization_options).unwrap().get("projectConfigurations").is_none());
    }
 }
+
+#[cfg(all(test, unix))]
+mod ruby_lsp_tests {
+    use super::*;
+    use std::os::unix::fs::PermissionsExt;
+
+    #[test]
+    fn ruby_lsp_is_found_in_the_rubys_gem_bindir_when_that_is_off_path() {
+        let tmp = tempfile::tempdir().unwrap();
+        let bindir = tmp.path().join("gems/bin");
+        std::fs::create_dir_all(&bindir).unwrap();
+        // Homebrew's Ruby: `Gem.bindir` is not on `PATH`.
+        let ruby = tmp.path().join("ruby");
+        std::fs::write(&ruby, format!("#!/bin/sh\necho '{}'\necho '/nonexistent/user/bin'\n", bindir.display()))
+            .unwrap();
+        std::fs::set_permissions(&ruby, std::fs::Permissions::from_mode(0o755)).unwrap();
+        let mut s = Settings::default();
+        s.languages.ruby.interpreter = ruby.to_string_lossy().into_owned();
+        let mut cfg = custom_server("ruby-lsp", &LanguageServerSettings::default());
+        configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
+        let path = cfg.env.get("PATH").expect("PATH set");
+        let dirs: Vec<PathBuf> = std::env::split_paths(path).collect();
+        assert!(dirs.contains(&bindir), "{dirs:?}");
+        assert!(!dirs.iter().any(|d| d.starts_with("/nonexistent")), "{dirs:?}");
+    }
+}
@@ -1,12 +1,14 @@
 //! The PHP language level: the one chosen in Settings › PHP, else the one the root
 //! `composer.json` declares (`config.platform.php`, else the lowest version `require.php` allows);
-//! the Intelephense storage that goes with it; and the stub sets and include paths Intelephense indexes.
+//! the Intelephense storage that goes with it; the stub sets and include paths Intelephense indexes;
+//! and the PHPStan run that checks saved files.

 use crate::apply::{merge, merge_init_options, setting_path};
 use ide_core::settings::Settings;
 use ide_language::LanguageServerConfig;
 use serde_json::{Value, json};
-use std::path::Path;
+use std::path::{Path, PathBuf};
+use std::process::Command;

 /// A PHP version and where it comes from.
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, specta::Type)]
@@ -139,6 +141,33 @@ pub fn include_paths(root: &Path, s: &Settings) -> Vec<String> {
        .collect()
 }

+/// `vendor/bin/phpstan analyse` of `files` with a JSON report and the configuration file of
+/// Settings › PHP, run from `root` with Xdebug off: in debug mode it would try to reach a
+/// debugger on every run. The selected PHP runs the script itself (and is first on `PATH`, as for
+/// PHPUnit), so a `php8.1` is not replaced by the `php` its `#!/usr/bin/env php` finds, and
+/// Windows needs no `phpstan.bat`, whose `cmd` limits the command line. `None` when the project
+/// has no PHPStan.
+pub fn phpstan_command(root: &Path, s: &Settings, files: &[PathBuf]) -> Option<Command> {
+    let bin = root.join("vendor/bin/phpstan");
+    if !bin.is_file() {
+        return None;
+    }
+    let php = setting_path(root, &s.languages.php.interpreter)
+        .or_else(|| crate::exec::which("php"))
+        .unwrap_or_else(|| PathBuf::from("php"));
+    let mut cmd = Command::new(php);
+    cmd.current_dir(root).arg(bin).args(["analyse", "--error-format=json", "--no-progress"]);
+    if let Some(config) = setting_path(root, &s.languages.php.phpstan_config) {
+        cmd.arg("--configuration").arg(config);
+    }
+    cmd.args(files);
+    cmd.env("XDEBUG_MODE", "off");
+    if let Some(dir) = crate::apply::php_dir(root, s) {
+        cmd.env("PATH", crate::exec::path_with(&[&dir]));
+    }
+    Some(cmd)
+}
+
 type Version = (u32, u32, u32);

 impl PhpLanguageLevel {
@@ -350,6 +379,78 @@ mod tests {
        );
    }

+    fn phpstan(root: &Path, s: &Settings) -> Option<Command> {
+        let cmd = phpstan_command(root, s, &[root.join("src").join("A.php"), root.join("src").join("B.php")])?;
+        assert_eq!(cmd.get_current_dir(), Some(root));
+        Some(cmd)
+    }
+
+    fn text(s: &std::ffi::OsStr) -> String {
+        s.to_string_lossy().into_owned()
+    }
+
+    fn env(cmd: &Command) -> Vec<(String, Option<String>)> {
+        cmd.get_envs().map(|(k, v)| (text(k), v.map(text))).collect()
+    }
+
+    #[test]
+    fn phpstan_checks_the_files_on_the_selected_php_without_xdebug() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let mut s = Settings::default();
+        assert!(phpstan(root, &s).is_none(), "no vendor/bin/phpstan, no run");
+
+        let bin = root.join("vendor/bin/phpstan");
+        std::fs::create_dir_all(bin.parent().unwrap()).unwrap();
+        std::fs::write(&bin, "").unwrap();
+        let cmd = phpstan(root, &s).unwrap();
+        // The PHP on PATH unless one is selected.
+        assert_eq!(Path::new(cmd.get_program()).file_stem(), Some("php".as_ref()));
+        let file = |name: &str| root.join("src").join(name).to_string_lossy().into_owned();
+        assert_eq!(
+            cmd.get_args().map(text).collect::<Vec<_>>(),
+            [
+                &*bin.to_string_lossy(),
+                "analyse",
+                "--error-format=json",
+                "--no-progress",
+                &file("A.php"),
+                &file("B.php")
+            ]
+        );
+        assert_eq!(env(&cmd), [("XDEBUG_MODE".to_string(), Some("off".to_string()))]);
+
+        // A selected PHP runs PHPStan whatever its name, and is first on PATH for what PHPStan starts.
+        let php = root.join("php85/bin").join(crate::exe("php8.5"));
+        s.languages.php.interpreter = php.to_string_lossy().into_owned();
+        let cmd = phpstan(root, &s).unwrap();
+        assert_eq!(cmd.get_program(), php.as_os_str());
+        let env = env(&cmd);
+        let path = env.iter().find(|(k, _)| k == "PATH").and_then(|(_, v)| v.clone()).expect("PATH");
+        assert_eq!(std::env::split_paths(&path).next(), Some(root.join("php85/bin")));
+        assert!(env.contains(&("XDEBUG_MODE".to_string(), Some("off".to_string()))));
+    }
+
+    #[test]
+    fn phpstan_uses_the_configuration_file_of_the_settings() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let bin = root.join("vendor/bin/phpstan");
+        std::fs::create_dir_all(bin.parent().unwrap()).unwrap();
+        std::fs::write(&bin, "").unwrap();
+        let args = |config: &str| {
+            let mut s = Settings::default();
+            s.languages.php.phpstan_config = config.into();
+            phpstan(root, &s).unwrap().get_args().map(text).collect::<Vec<_>>()
+        };
+        let resolved = root.join("build/phpstan.ci.neon").to_string_lossy().into_owned();
+        assert_eq!(args(" build/phpstan.ci.neon ")[4..6], ["--configuration".to_string(), resolved]);
+        let absolute = if cfg!(windows) { "C:/etc/phpstan.neon" } else { "/etc/phpstan.neon" };
+        assert_eq!(args(absolute)[4..6], ["--configuration", absolute]);
+        // Empty: PHPStan finds phpstan.neon, phpstan.neon.dist or phpstan.dist.neon itself.
+        assert!(!args(" ").iter().any(|a| a.starts_with("--configuration")));
+    }
+
    #[test]
    fn each_level_names_its_source() {
        let found = |version: &str, source| Some(PhpLanguageLevel { version: version.into(), source });
@@ -140,6 +140,14 @@ pub fn bin_dir_of(ruby: &Path) -> Option<PathBuf> {
    ruby.parent().map(Path::to_path_buf)
 }

+/// Where `ruby` installs gem executables (`Gem.bindir`, the `--user-install` one) that exist, asked
+/// of the Ruby that version managers select in `root`: Homebrew's keeps its bindir off `PATH`.
+pub fn gem_bin_dirs(ruby: &Path, root: &Path) -> Vec<PathBuf> {
+    query_in(ruby, &["-e", ide_core::tool_path::RUBY_GEM_BIN_SCRIPT], Some(root), &[], QUERY_TIMEOUT)
+        .map(|out| ide_core::tool_path::gem_bin_dirs(&out))
+        .unwrap_or_default()
+}
+
 type NamedRoots = Vec<(String, PathBuf)>;

 /// Standard-library / site directories (`ruby/3.3.0`) and the gems Bundler resolves
@@ -60,6 +60,9 @@ struct Session {
    writer: Mutex<Box<dyn Write + Send>>,
    killer: Mutex<Box<dyn ChildKiller + Send + Sync>>,
    exited: Arc<AtomicBool>,
+    started: Instant,
+    /// The first input was logged (startup diagnostics, see `spawn`).
+    input_logged: AtomicBool,
 }

 type Sessions = Arc<Mutex<HashMap<TerminalId, Arc<Session>>>>;
@@ -92,7 +95,8 @@ impl TerminalManager {
        let size = pty_size(options.cols, options.rows);
        let pair = native_pty_system().openpty(size).map_err(|e| IdeError::internal(format!("openpty failed: {e}")))?;

-        let (shell, mut args) = resolve_shell(options.shell.as_deref(), &options.args);
+        let wsl = if cfg!(windows) { wsl_shell(&options) } else { None };
+        let (shell, mut args) = wsl.clone().unwrap_or_else(|| resolve_shell(options.shell.as_deref(), &options.args));
        let mut env = terminal_env(&options.env);
        if let Some(msystem) = default_msystem(&shell, &options.env, std::env::var("MSYSTEM").ok().as_deref()) {
            env.insert("MSYSTEM".to_owned(), msystem.to_owned());
@@ -105,7 +109,8 @@ impl TerminalManager {
        }
        let mut cmd = CommandBuilder::new(&shell);
        cmd.args(&args);
-        cmd.cwd(resolve_cwd(&options.cwd));
+        // wsl.exe takes the directory through `--cd`; a UNC share is no valid process cwd.
+        cmd.cwd(if wsl.is_some() { resolve_cwd(Path::new("")) } else { resolve_cwd(&options.cwd) });
        for (k, v) in ide_core::process::host_env_fixes() {
            match v {
                Some(v) => cmd.env(k, v),
@@ -136,25 +141,34 @@ impl TerminalManager {
            writer: Mutex::new(writer),
            killer: Mutex::new(child.clone_killer()),
            exited: exited.clone(),
+            started: Instant::now(),
+            input_logged: AtomicBool::new(false),
        });
        self.sessions.lock().insert(id, session);

        let (tx, rx) = mpsc::channel::<Msg>();
        let spawned = spawn_reader(id, reader, tx.clone())
            .and_then(|_| spawn_waiter(id, child, tx))
-            .and_then(|_| spawn_pump(id, rx, on_output, exited, self.sessions.clone(), sink));
+            .and_then(|_| spawn_pump(id, rx, on_output, exited, self.sessions.clone(), sink, Instant::now()));
        if let Err(e) = spawned {
            if let Some(s) = self.sessions.lock().remove(&id) {
                let _ = s.killer.lock().kill();
            }
            return Err(IdeError::internal(format!("failed to start terminal threads: {e}")));
        }
-        tracing::debug!(%id, shell, pid = ?info.pid, "terminal spawned");
+        // Info level, with the first output and input below: a session that starts but never shows a
+        // prompt can then be told apart in a user's log (no output, or no reply to the shell's query).
+        tracing::info!(%id, shell, pid = ?info.pid, cols = size.cols, rows = size.rows, "terminal spawned");
        Ok(info)
    }

    pub fn write(&self, id: TerminalId, data: &str) -> IdeResult<()> {
        let session = self.session(id)?;
+        if !session.input_logged.swap(true, Ordering::Relaxed) {
+            let cursor_report = data.starts_with("\x1b[") && data.ends_with('R');
+            let ms = session.started.elapsed().as_millis();
+            tracing::info!(%id, ms, bytes = data.len(), cursor_report, "terminal first input");
+        }
        let mut w = session.writer.lock();
        w.write_all(data.as_bytes())?;
        w.flush()?;
@@ -387,8 +401,19 @@ fn spawn_pump(
    exited: Arc<AtomicBool>,
    sessions: Sessions,
    sink: SharedSink,
+    started: Instant,
 ) -> std::io::Result<()> {
    std::thread::Builder::new().name(format!("openidea-term-pump-{}", id.0)).spawn(move || {
+        let first_output = std::cell::Cell::new(true);
+        let on_output = move |text: String| {
+            if first_output.replace(false) {
+                // ConPTY asks for the cursor position (`ESC[6n`) and waits for the answer.
+                let cursor_query = text.contains("\x1b[6n");
+                let ms = started.elapsed().as_millis();
+                tracing::info!(%id, ms, bytes = text.len(), cursor_query, "terminal first output");
+            }
+            on_output(text)
+        };
        let mut decoder = Utf8Decoder::new();
        let mut pending = String::new();
        let mut batch_started: Option<Instant> = None;
@@ -456,6 +481,16 @@ fn pty_size(cols: u16, rows: u16) -> PtySize {
    }
 }

+/// `wsl.exe` in the distro of a `\\wsl.localhost\...` folder, so its terminal is a Linux
+/// shell and not PowerShell (#925). An explicitly chosen shell or arguments win.
+fn wsl_shell(options: &TerminalOptions) -> Option<(String, Vec<String>)> {
+    if options.shell.as_deref().is_some_and(|s| !s.trim().is_empty()) || !options.args.is_empty() {
+        return None;
+    }
+    let w = ide_core::wsl::parse(&options.cwd)?;
+    Some((ide_core::wsl::EXE.into(), vec!["-d".into(), w.distro, "--cd".into(), w.path]))
+}
+
 fn resolve_cwd(cwd: &Path) -> PathBuf {
    if cwd.is_dir() {
        return cwd.to_path_buf();
@@ -504,7 +539,7 @@ pub fn available_shells() -> Vec<String> {
    }
    #[cfg(windows)]
    {
-        for exe in ["pwsh.exe", "powershell.exe", "cmd.exe", "wsl.exe"] {
+        for exe in ["pwsh.exe", "powershell.exe", "cmd.exe", ide_core::wsl::EXE] {
            if let Some(p) = find_in_path(exe) {
                add(p);
            }
@@ -859,6 +894,24 @@ mod tests {
        assert!(h.events.try_recv().is_err() && other_events.try_recv().is_err(), "no cross delivery");
    }

+    #[test]
+    fn wsl_folder_gets_the_distro_shell_unless_one_is_chosen() {
+        let mut o = sh("true");
+        o.shell = None;
+        o.args = vec![];
+        let (distro, linux_path) = ("Debian-12", "/srv/app");
+        let want = (ide_core::wsl::EXE.to_owned(), vec!["-d".into(), distro.into(), "--cd".into(), linux_path.into()]);
+        for host in ["wsl.localhost", "wsl$"] {
+            o.cwd = PathBuf::from(format!(r"\\{host}\{distro}{}", linux_path.replace('/', r"\"))).into();
+            assert_eq!(wsl_shell(&o), Some(want.clone()), "{host}");
+        }
+        o.shell = Some("pwsh.exe".into());
+        assert_eq!(wsl_shell(&o), None);
+        o.shell = None;
+        o.cwd = PathBuf::from("/tmp").into();
+        assert_eq!(wsl_shell(&o), None);
+    }
+
    #[test]
    fn shell_resolution() {
        let (shell, args) = resolve_shell(Some("/bin/zsh"), &[]);
@@ -154,7 +154,11 @@ fn managed_bin_dir(root: &Path, spec: &ToolSpec, platform: Platform) -> Option<P
        Method::PipVenv { .. } => {
            Some(root.join(spec.name).join("venv").join(if platform.os == Os::Windows { "Scripts" } else { "bin" }))
        }
-        Method::Bundled { .. } | Method::Rustup { .. } | Method::PipUser { .. } | Method::PipTarget { .. } => None,
+        Method::Bundled { .. }
+        | Method::Rustup { .. }
+        | Method::PipUser { .. }
+        | Method::PipTarget { .. }
+        | Method::GemActive { .. } => None,
    }
 }

@@ -429,6 +433,9 @@ pub struct Tools {
    /// Executables found outside the search path (app bundles), by command.
    found: BTreeMap<String, PathBuf>,
    version_timeout: Duration,
+    /// The project the tools are used for: tools that install into "the active runtime" (gems) run here,
+    /// so a version manager picks the project's Ruby.
+    work_dir: Option<PathBuf>,
 }

 impl Tools {
@@ -450,6 +457,7 @@ impl Tools {
            custom: BTreeMap::new(),
            found: BTreeMap::new(),
            version_timeout: Duration::from_secs(4),
+            work_dir: None,
        }
    }

@@ -465,10 +473,25 @@ impl Tools {
        self
    }

+    /// Runs per-project installs (see [`registry::Method::GemActive`]) in `dir`.
+    pub fn with_work_dir(mut self, dir: Option<PathBuf>) -> Self {
+        self.work_dir = dir.filter(|d| d.is_dir());
+        self
+    }
+
    pub fn root(&self) -> &Path {
        &self.root
    }

+    /// [`Tools::command`] in the project directory.
+    fn command_in_project(&self, program: impl AsRef<std::ffi::OsStr>) -> Command {
+        let mut cmd = self.command(program);
+        if let Some(dir) = &self.work_dir {
+            cmd.current_dir(dir);
+        }
+        cmd
+    }
+
    fn which(&self, cmd: &str) -> Option<PathBuf> {
        ide_core::tool_path::find_command(cmd, &self.system_path, &self.root)
    }
@@ -614,7 +637,9 @@ impl Tools {
                "npm or pnpm is required: install Node.js (https://nodejs.org)",
            ),
            Method::Go { .. } => need(self.which("go").is_some(), "Go is required (https://go.dev/dl)"),
-            Method::Gem { .. } => need(self.which("gem").is_some(), "Ruby is required (https://www.ruby-lang.org)"),
+            Method::Gem { .. } | Method::GemActive { .. } => {
+                need(self.which("gem").is_some(), "Ruby is required (https://www.ruby-lang.org)")
+            }
            Method::DotnetTool { .. } => {
                need(self.which("dotnet").is_some(), ".NET SDK is required (https://dotnet.microsoft.com/download)")
            }
@@ -772,6 +797,22 @@ impl Tools {
                    _ => (ToolStatus::Missing, None, None),
                }
            }
+            Method::GemActive { gem } => {
+                // Installed for the Ruby active in the project, not merely a shim of some other version's.
+                let Some(gem_cmd) = self.which("gem") else { return (ToolStatus::Missing, None, None) };
+                let mut c = self.command_in_project(&gem_cmd);
+                c.args(["list", "--exact", gem]);
+                match run_quiet(c, Duration::from_secs(10)) {
+                    Some((true, out)) if out.contains(&format!("{gem} (")) => {
+                        // Homebrew's Ruby keeps its gem bindir off PATH: ask the Ruby where it is.
+                        match self.gem_executable(main) {
+                            Some(path) => (ToolStatus::OnPath, Some(path), parse_version(&out)),
+                            None => (ToolStatus::Missing, None, None),
+                        }
+                    }
+                    _ => (ToolStatus::Missing, None, None),
+                }
+            }
            _ => match self.which(main) {
                Some(path) => {
                    let version = self.query_version(spec, &path);
@@ -868,6 +909,7 @@ impl Tools {
                Method::Npm { packages } => self.install_npm(packages, cancel, emit)?,
                Method::Go { module } => self.install_go(spec, module, cancel, emit)?,
                Method::Gem { gem } => self.install_gem(spec, gem, cancel, emit)?,
+                Method::GemActive { gem } => self.install_gem_active(gem, cancel, emit)?,
                Method::DotnetTool { package } => self.install_dotnet_tool(spec, package, cancel, emit)?,
                Method::PipVenv { package } => self.install_venv(spec, package, cancel, emit)?,
                Method::PipUser { package, .. } => self.install_pip_user(package, cancel, emit)?,
@@ -953,6 +995,41 @@ impl Tools {
        self.write_manifest(spec.name, &Manifest { version, source: Some(module.to_string()) })
    }

+    /// Where the project's Ruby installs gem executables (`Gem.bindir`, `Gem.user_dir`'s `bin`).
+    fn gem_bin_dirs(&self) -> Vec<PathBuf> {
+        let Some(ruby) = self.which("ruby") else { return Vec::new() };
+        let mut c = self.command_in_project(ruby);
+        c.args(["-e", ide_core::tool_path::RUBY_GEM_BIN_SCRIPT]);
+        match run_quiet(c, Duration::from_secs(10)) {
+            Some((true, out)) => ide_core::tool_path::gem_bin_dirs(&out),
+            _ => Vec::new(),
+        }
+    }
+
+    /// An installed gem's executable: on the search path, else in one of the Ruby's gem bin directories.
+    fn gem_executable(&self, cmd: &str) -> Option<PathBuf> {
+        self.which(cmd).or_else(|| self.gem_bin_dirs().iter().find_map(|d| self.exe_in(d, cmd)))
+    }
+
+    /// `gem install` into the active Ruby, then makes version-manager shims see the new executable.
+    fn install_gem_active(&self, gem: &str, cancel: &CancellationToken, emit: Emit) -> IdeResult<()> {
+        let mut c = self.command_in_project(self.which("gem").expect("checked"));
+        c.args(["install", "--no-document", gem]);
+        run_streamed(c, cancel, emit)?;
+        // mise / asdf / rbenv list executables in shims written at install time; a gem installed
+        // afterwards has none until they are regenerated. Best effort: the tool may not be installed.
+        for (manager, args) in
+            [("mise", &["reshim"][..]), ("asdf", &["reshim", "ruby"][..]), ("rbenv", &["rehash"][..])]
+        {
+            if let Some(path) = self.which(manager) {
+                let mut c = self.command_in_project(path);
+                c.args(args);
+                let _ = run_quiet(c, Duration::from_secs(30));
+            }
+        }
+        Ok(())
+    }
+
    fn install_gem(&self, spec: &ToolSpec, gem: &str, cancel: &CancellationToken, emit: Emit) -> IdeResult<()> {
        let dir = self.root.join(spec.name);
        let _ = std::fs::remove_dir_all(&dir);
@@ -1310,6 +1387,18 @@ impl Tools {
                    run_streamed(c, &cancel, &quiet)?;
                }
            }
+            Method::GemActive { gem } => {
+                if let Some(gem_cmd) = self.which("gem") {
+                    let mut c = self.command_in_project(&gem_cmd);
+                    c.args(["uninstall", "--all", "--executables", "--ignore-dependencies", gem]);
+                    run_streamed(c, &cancel, &quiet)?;
+                }
+                // A copy an older version installed under the tools directory.
+                let dir = self.root.join(spec.name);
+                if dir.exists() {
+                    std::fs::remove_dir_all(&dir)?;
+                }
+            }
            Method::Go { .. }
            | Method::Gem { .. }
            | Method::DotnetTool { .. }
@@ -49,6 +49,11 @@ pub enum Method {
    PipTarget { package: &'static str, module: &'static str },
    /// `gem install` into `<tools>/<name>/gems`, launched through `GEM_HOME` wrappers in `bin/`.
    Gem { gem: &'static str },
+    /// `gem install <gem>` into the active Ruby (the project's, installed from a project window),
+    /// launched through that Ruby's own executables. For tools that re-launch themselves under
+    /// Bundler (ruby-lsp), which breaks in a gem home under a path with spaces
+    /// (`~/Library/Application Support`: Bundler `exec`s a lone path string, and Ruby splits it).
+    GemActive { gem: &'static str },
    /// `dotnet tool install --tool-path <tools>/<name>/tool <package>`, launched
    /// through `DOTNET_ROOT` wrappers in `bin/`.
    DotnetTool { package: &'static str },
@@ -64,6 +69,7 @@ impl Method {
            Method::Npm { .. } => "npm",
            Method::Go { .. } => "go install",
            Method::Gem { .. } => "gem",
+            Method::GemActive { .. } => "gem (project Ruby)",
            Method::DotnetTool { .. } => "dotnet tool",
            Method::PipVenv { .. } => "pip (virtualenv)",
            Method::PipUser { .. } => "pip --user",
@@ -940,7 +946,7 @@ pub static TOOLS: &[ToolSpec] = &[
        display: "Ruby LSP (Shopify)",
        kind: LanguageServer,
        commands: &["ruby-lsp"],
-        method: Method::Gem { gem: "ruby-lsp" },
+        method: Method::GemActive { gem: "ruby-lsp" },
        fallback: None,
        version: V,
        homepage: "https://shopify.github.io/ruby-lsp",
@@ -590,6 +590,51 @@ printf '#!/bin/sh\necho "$GEM_HOME"\n' > "$bin/solargraph"; /bin/chmod +x "$bin/
    assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), env.root.join("solargraph/gems").to_string_lossy());
 }

+#[cfg(unix)]
+#[test]
+fn ruby_lsp_installs_into_the_project_ruby_not_a_private_gem_home() {
+    let env = Env::new();
+    let project = env._tmp.path().join("project");
+    fs::create_dir_all(&project).unwrap();
+    let marker = env._tmp.path().join("installed");
+    // Homebrew's Ruby: the gem bindir is not on the search path; only the Ruby knows it.
+    let bindir = env._tmp.path().join("gems/bin");
+    fs::create_dir_all(&bindir).unwrap();
+    env.script(&env.sys, "ruby", &format!("echo '{}'", bindir.display()));
+    // `gem list --exact ruby-lsp` knows the gem once `gem install ruby-lsp` ran, in the cwd it was given.
+    env.script(
+        &env.sys,
+        "gem",
+        &format!(
+            r#"case "$1" in
+install) echo "$PWD $@" > '{m}'; printf '#!/bin/sh\n' > '{b}/ruby-lsp'; /bin/chmod +x '{b}/ruby-lsp' ;;
+list) [ -f '{m}' ] && echo "ruby-lsp (0.26.11)" ;;
+uninstall) /bin/rm -f '{m}' ;;
+esac"#,
+            m = marker.display(),
+            b = bindir.display()
+        ),
+    );
+    let tools = env.tools().with_work_dir(Some(project.clone()));
+    assert_eq!(find(&tools.list(&langs()), "ruby-lsp").status, ToolStatus::Missing);
+    let info = tools.install("ruby-lsp", &langs(), &CancellationToken::new(), &|_| {}).unwrap();
+    assert_eq!(info.status, ToolStatus::OnPath);
+    assert_eq!(info.version.as_deref(), Some("0.26.11"));
+    // Found in the Ruby's own bindir, not reported as the `gem` command.
+    assert_eq!(info.path.as_deref(), Some(bindir.join("ruby-lsp").as_path()));
+    // Run in the project (so a version manager picks its Ruby), into the Ruby's own gem home.
+    let log = fs::read_to_string(&marker).unwrap();
+    assert!(log.starts_with(&*project.canonicalize().unwrap().to_string_lossy()), "{log}");
+    assert!(log.contains("install --no-document ruby-lsp") && !log.contains("--install-dir"), "{log}");
+    // No private gem home, no wrapper directory on the search path.
+    assert!(!env.root.join("ruby-lsp").exists());
+    // Uninstalling removes the gem, and an older managed copy.
+    fs::create_dir_all(env.root.join("ruby-lsp/gems")).unwrap();
+    let info = tools.uninstall("ruby-lsp", &langs()).unwrap();
+    assert_eq!(info.status, ToolStatus::Missing);
+    assert!(!env.root.join("ruby-lsp").exists());
+}
+
 #[cfg(unix)]
 #[test]
 fn dotnet_tool_install_into_tool_path() {
@@ -9,44 +9,88 @@ use std::collections::{HashMap, HashSet};

 /// Log "Text or hash" filter: the message (substring or regex), or a hash prefix.
 enum TextFilter {
-    Plain { needle: String, match_case: bool },
+    /// Commits `git log --grep` selected, or whose id starts with `hash`.
+    Selected {
+        ids: HashSet<ObjectId>,
+        hash: Option<String>,
+    },
+    /// Case-insensitive non-ASCII text: git folds case only for ASCII under the C locale.
+    Folded(String),
    Regex(regex_lite::Regex),
 }

 impl TextFilter {
-    fn new(text: &str, regex: bool, match_case: bool) -> IdeResult<Option<Self>> {
+    fn new(
+        r: &Repo,
+        scopes: &[String],
+        q: &LogQuery,
+        text: &str,
+        cancel: &CancellationToken,
+    ) -> IdeResult<Option<Self>> {
        let text = text.trim();
        if text.is_empty() {
            return Ok(None);
        }
-        if regex {
+        if q.text_regex {
            let re = regex_lite::RegexBuilder::new(text)
-                .case_insensitive(!match_case)
+                .case_insensitive(!q.text_match_case)
                .multi_line(true)
                .build()
                .map_err(|e| IdeError::invalid(format!("invalid regular expression: {e}")))?;
            return Ok(Some(Self::Regex(re)));
        }
-        let needle = if match_case { text.to_string() } else { text.to_lowercase() };
-        Ok(Some(Self::Plain { needle, match_case }))
+        if !q.text_match_case && !text.is_ascii() {
+            return Ok(Some(Self::Folded(text.to_lowercase())));
+        }
+        let mut filter = vec!["--fixed-strings".to_string(), format!("--grep={text}")];
+        if !q.text_match_case {
+            filter.push("--regexp-ignore-case".into());
+        }
+        let ids = git_select(r, scopes, &filter, &[], q.first_parent, cancel)?;
+        let hash = (text.len() >= 4 && text.bytes().all(|b| b.is_ascii_hexdigit())).then(|| text.to_ascii_lowercase());
+        Ok(Some(Self::Selected { ids, hash }))
    }

-    fn matches(&self, message: &str, id: &ObjectId) -> bool {
-        match self {
-            Self::Regex(re) => re.is_match(message),
-            Self::Plain { needle, match_case } => {
-                let hash = needle.len() >= 4 && needle.bytes().all(|b| b.is_ascii_hexdigit());
-                if hash && id.to_string().starts_with(&needle.to_ascii_lowercase()) {
-                    return true;
-                }
-                if *match_case {
-                    message.contains(needle.as_str())
-                } else {
-                    message.to_lowercase().contains(needle.as_str())
-                }
+    fn matches(&self, repo: &gix::Repository, index: &mut crate::log_index::LogIndex, id: ObjectId) -> IdeResult<bool> {
+        Ok(match self {
+            Self::Regex(re) => re.is_match(&index.message(repo, id)?),
+            Self::Folded(needle) => index.message(repo, id)?.to_lowercase().contains(needle.as_str()),
+            Self::Selected { ids, hash } => {
+                ids.contains(&id) || hash.as_ref().is_some_and(|h| id.to_string().starts_with(h.as_str()))
            }
+        })
+    }
+}
+
+/// Commits git selects from each scope with `filter`. Path limiting uses git's history
+/// simplification and, when the repository has them, changed-path Bloom filters.
+fn git_select(
+    r: &Repo,
+    scopes: &[String],
+    filter: &[String],
+    paths: &[String],
+    first_parent: bool,
+    cancel: &CancellationToken,
+) -> IdeResult<HashSet<ObjectId>> {
+    let mut ids = HashSet::new();
+    for scope in scopes {
+        let mut args =
+            vec!["log".to_string(), "--format=%H".into(), "--no-show-signature".into(), "--no-follow".into()];
+        if first_parent {
+            args.push("--first-parent".into());
+        }
+        args.extend(filter.iter().cloned());
+        args.push("--end-of-options".into());
+        args.extend(scope.split_whitespace().map(str::to_string));
+        args.push("--".into());
+        args.extend(paths.iter().map(|p| format!(":(literal){p}")));
+        let output =
+            crate::cli::run_cancellable(r.root(), &args.iter().map(String::as_str).collect::<Vec<_>>(), cancel)?;
+        for line in output.stdout_str().lines() {
+            ids.insert(ObjectId::from_hex(line.as_bytes()).map_err(gx)?);
        }
    }
+    Ok(ids)
 }

 pub(crate) fn log(r: &Repo, q: &LogQuery, cancel: &CancellationToken) -> IdeResult<Vec<Commit>> {
@@ -173,87 +217,71 @@ fn log_indexed(
    } else {
        None
    };
+    let scopes = if let Some(range) = range {
+        vec![range.to_string()]
+    } else {
+        let mut scopes = ranges.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+        if !tips.is_empty() {
+            scopes.push(tips.iter().map(ToString::to_string).collect::<Vec<_>>().join(" "));
+        }
+        scopes
+    };
    let mut history_paths = HashMap::new();
    let path_ids = if paths.is_empty() {
        None
-    } else {
+    } else if q.follow && paths.len() == 1 {
        let mut ids = HashSet::new();
-        if q.follow && paths.len() == 1 {
-            let rel = &paths[0];
-            let mut args = vec![
-                "log".to_string(),
-                "--format=%x00%H".into(),
-                "--name-status".into(),
-                "-z".into(),
-                "--follow".into(),
-                "--topo-order".into(),
-            ];
-            if q.first_parent {
-                args.push("--first-parent".into());
-            }
-            args.push("--end-of-options".into());
-            let scopes = if let Some(range) = range {
-                vec![range.to_string()]
-            } else {
-                let mut scopes = ranges.iter().map(|s| s.to_string()).collect::<Vec<_>>();
-                if !tips.is_empty() {
-                    scopes.push(tips.iter().map(ToString::to_string).collect::<Vec<_>>().join(" "));
-                }
-                scopes
-            };
-            for scope in scopes {
-                let mut args = args.clone();
-                args.extend(scope.split_whitespace().map(str::to_string));
-                args.extend(["--".into(), rel.clone()]);
-                let output = crate::cli::run_cancellable(
-                    r.root(),
-                    &args.iter().map(String::as_str).collect::<Vec<_>>(),
-                    cancel,
-                )?;
-                let text = output.stdout_str();
-                let mut tokens = text.split('\0').peekable();
-                let mut current_path = rel.clone();
-                while let Some(token) = tokens.next() {
-                    let token = token.trim_start_matches('\n');
-                    if let Ok(id) = ObjectId::from_hex(token.as_bytes()) {
-                        ids.insert(id);
-                        history_paths.insert(id, current_path.clone());
-                    } else if token.starts_with('R') && token[1..].bytes().all(|b| b.is_ascii_digit()) {
-                        if let (Some(old), Some(new)) = (tokens.next(), tokens.next())
-                            && new == current_path
-                        {
-                            current_path = old.to_string();
-                        }
-                    } else if ["A", "D", "M", "T", "U"].contains(&token) {
-                        tokens.next();
+        let rel = &paths[0];
+        let mut args = vec![
+            "log".to_string(),
+            "--format=%x00%H".into(),
+            "--name-status".into(),
+            "-z".into(),
+            "--follow".into(),
+            "--topo-order".into(),
+        ];
+        if q.first_parent {
+            args.push("--first-parent".into());
+        }
+        args.push("--end-of-options".into());
+        for scope in &scopes {
+            let mut args = args.clone();
+            args.extend(scope.split_whitespace().map(str::to_string));
+            args.extend(["--".into(), rel.clone()]);
+            let output =
+                crate::cli::run_cancellable(r.root(), &args.iter().map(String::as_str).collect::<Vec<_>>(), cancel)?;
+            let text = output.stdout_str();
+            let mut tokens = text.split('\0').peekable();
+            let mut current_path = rel.clone();
+            while let Some(token) = tokens.next() {
+                let token = token.trim_start_matches('\n');
+                if let Ok(id) = ObjectId::from_hex(token.as_bytes()) {
+                    ids.insert(id);
+                    history_paths.insert(id, current_path.clone());
+                } else if token.starts_with('R') && token[1..].bytes().all(|b| b.is_ascii_digit()) {
+                    if let (Some(old), Some(new)) = (tokens.next(), tokens.next())
+                        && new == current_path
+                    {
+                        current_path = old.to_string();
                    }
+                } else if ["A", "D", "M", "T", "U"].contains(&token) {
+                    tokens.next();
                }
            }
-        } else {
-            let starts = range_ids.as_ref().cloned().unwrap_or_else(|| tips.clone());
-            ids.extend(
-                PathWalk::new(&repo, starts, paths.clone(), q.first_parent, cancel, index)?
-                    .map(|item| item.map(|(id, _)| id))
-                    .collect::<IdeResult<HashSet<_>>>()?,
-            );
        }
        Some(ids)
+    } else {
+        Some(git_select(r, &scopes, &[], &paths, q.first_parent, cancel)?)
    };
    let authors: Vec<_> =
        q.author.iter().chain(&q.authors).map(|a| a.trim().to_lowercase()).filter(|a| !a.is_empty()).collect();
-    let user_candidates = if q.authors_exact && !authors.is_empty() { index.user_candidates(&authors) } else { None };
-    let path_candidates = if !q.follow && !paths.is_empty() { index.path_candidates(&paths) } else { None };
-    let text_candidates = q.text.as_deref().filter(|_| !q.text_regex).and_then(|s| index.message_candidates(s));
    let mut visibility = Visibility {
        speed_refs: &decorations,
-        text_candidates,
-        user_candidates,
-        path_candidates,
        query: q,
        path_ids,
        range_ids: range_ids.as_ref().map(|ids| ids.iter().copied().collect()),
        authors,
-        text: q.text.as_deref().map(|t| TextFilter::new(t, q.text_regex, q.text_match_case)).transpose()?.flatten(),
+        text: q.text.as_deref().map(|t| TextFilter::new(r, &scopes, q, t, cancel)).transpose()?.flatten(),
        matches: HashMap::new(),
        projected: HashMap::new(),
        cancel,
@@ -584,9 +612,6 @@ struct Visibility<'a> {
    range_ids: Option<HashSet<ObjectId>>,
    authors: Vec<String>,
    text: Option<TextFilter>,
-    text_candidates: Option<HashSet<String>>,
-    user_candidates: Option<HashSet<String>>,
-    path_candidates: Option<HashSet<String>>,
    matches: HashMap<ObjectId, bool>,
    projected: HashMap<ObjectId, Vec<ObjectId>>,
    cancel: &'a CancellationToken,
@@ -602,10 +627,7 @@ impl Visibility<'_> {
        if let Some(shown) = self.matches.get(&id) {
            return Ok(*shown);
        }
-        let indexed = self.index.indexed(&id.to_string());
-        let shown = if (indexed && self.user_candidates.as_ref().is_some_and(|ids| !ids.contains(&id.to_string())))
-            || (indexed && self.path_candidates.as_ref().is_some_and(|ids| !ids.contains(&id.to_string())))
-            || !repo.has_object(id)
+        let shown = if !repo.has_object(id)
            || self.path_ids.as_ref().is_some_and(|ids| !ids.contains(&id))
            || self.range_ids.as_ref().is_some_and(|ids| !ids.contains(&id))
        {
@@ -648,15 +670,7 @@ impl Visibility<'_> {
                        }
                    }))
                && match &self.text {
-                    Some(text) => {
-                        self.text_candidates.as_ref().is_none_or(|ids| {
-                            ids.contains(&id.to_string())
-                                || !self.index.indexed(&id.to_string())
-                                || id.to_string().starts_with(
-                                    self.query.text.as_deref().unwrap_or("").trim().to_ascii_lowercase().as_str(),
-                                )
-                        }) && text.matches(&self.index.message(repo, id)?, &id)
-                    }
+                    Some(text) => text.matches(repo, self.index, id)?,
                    None => true,
                }
        };
@@ -865,113 +879,6 @@ pub(crate) fn decorations(repo: &gix::Repository) -> IdeResult<HashMap<ObjectId,
    Ok(map)
 }

-/// Commits touching a path, newest first, with git's default history simplification:
-/// a commit is shown when its entry for the path differs from every parent, and at a
-/// merge that kept one parent's version only that parent's line of history is followed.
-struct PathWalk<'r> {
-    repo: &'r gix::Repository,
-    paths: Vec<String>,
-    queue: std::collections::BinaryHeap<(i64, u64, ObjectId)>,
-    seen: HashSet<ObjectId>,
-    index: &'r mut crate::log_index::LogIndex,
-    seq: u64,
-    first_parent: bool,
-    cancel: &'r CancellationToken,
-    shallow: HashSet<ObjectId>,
-}
-
-impl<'r> PathWalk<'r> {
-    fn new(
-        repo: &'r gix::Repository,
-        tips: Vec<ObjectId>,
-        paths: Vec<String>,
-        first_parent: bool,
-        cancel: &'r CancellationToken,
-        index: &'r mut crate::log_index::LogIndex,
-    ) -> IdeResult<Self> {
-        let mut walk = PathWalk {
-            repo,
-            paths,
-            queue: Default::default(),
-            seen: Default::default(),
-            index,
-            seq: 0,
-            first_parent,
-            cancel,
-            shallow: repo.shallow_commits().map_err(gx)?.map(|ids| ids.iter().copied().collect()).unwrap_or_default(),
-        };
-        for tip in tips {
-            walk.push(tip)?;
-        }
-        Ok(walk)
-    }
-
-    fn push(&mut self, id: ObjectId) -> IdeResult<()> {
-        if self.cancel.is_cancelled() {
-            return Err(IdeError::cancelled());
-        }
-        if !self.seen.insert(id) || !self.repo.has_object(id) {
-            return Ok(());
-        }
-        let time = self.repo.find_commit(id).map_err(gx)?.time().map(|t| t.seconds).unwrap_or(0);
-        // Max-heap on time; among equal times, earlier insertion first.
-        self.seq += 1;
-        self.queue.push((time, u64::MAX - self.seq, id));
-        Ok(())
-    }
-
-    fn step(&mut self) -> IdeResult<Option<(ObjectId, Vec<ObjectId>)>> {
-        while let Some((_, _, id)) = self.queue.pop() {
-            let commit = self.repo.find_commit(id).map_err(gx)?;
-            let parents: Vec<ObjectId> = commit.parent_ids().map(|p| p.detach()).collect();
-            // Parents cut off by a shallow boundary are treated as absent.
-            let present: Vec<ObjectId> = parents
-                .iter()
-                .copied()
-                .take(if self.shallow.contains(&id) { 0 } else { usize::MAX })
-                .filter(|p| self.repo.has_object(p))
-                .take(if self.first_parent { 1 } else { usize::MAX })
-                .collect();
-            let mine = self
-                .paths
-                .iter()
-                .map(|path| self.index.path_entry(self.repo, id, path))
-                .collect::<IdeResult<Vec<_>>>()?;
-            let mut same_parent = None;
-            for p in &present {
-                let theirs = self
-                    .paths
-                    .iter()
-                    .map(|path| self.index.path_entry(self.repo, *p, path))
-                    .collect::<IdeResult<Vec<_>>>()?;
-                if theirs == mine {
-                    same_parent = Some(*p);
-                    break;
-                }
-            }
-            match same_parent {
-                Some(p) => self.push(p)?,
-                None => {
-                    for p in &present {
-                        self.push(*p)?;
-                    }
-                    if !present.is_empty() || mine.iter().any(Option::is_some) {
-                        return Ok(Some((id, parents)));
-                    }
-                }
-            }
-        }
-        Ok(None)
-    }
-}
-
-impl Iterator for PathWalk<'_> {
-    type Item = IdeResult<(ObjectId, Vec<ObjectId>)>;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.step().transpose()
-    }
-}
-
 pub(crate) fn commit_files(r: &Repo, rev: &str) -> IdeResult<Vec<ChangedFile>> {
    let repo = r.gix()?;
    Ok(first_parent_changes(&repo, rev)?.files)
@@ -162,14 +162,6 @@ pub struct LogDetails {
    pub fingerprint: String,
 }

-#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct LogIndexProgress {
-    pub indexed: u32,
-    pub total: u32,
-    pub running: bool,
-}
-
 /// Order of the Git Log (Graph Options › Sort).
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
@@ -672,7 +664,6 @@ pub struct Repo {
    inner: std::sync::Mutex<repo::Cache>,
    ignored: std::sync::RwLock<IgnoredNames>,
    log_index: std::sync::Mutex<log_index::LogIndex>,
-    index_progress: std::sync::Mutex<LogIndexProgress>,
    log_signatures: std::sync::Mutex<std::collections::HashMap<String, LogDetails>>,
 }

@@ -844,59 +835,6 @@ impl Repo {
            .into_iter()
            .collect())
    }
-    pub fn log_index_progress(&self) -> LogIndexProgress {
-        self.index_progress.lock().unwrap_or_else(|p| p.into_inner()).clone()
-    }
-
-    /// Incremental persistent inverted index; completed objects survive cancellation/restart.
-    pub fn index_log(&self, cancel: &CancellationToken) -> IdeResult<LogIndexProgress> {
-        {
-            let mut progress = self.index_progress.lock().unwrap_or_else(|p| p.into_inner());
-            if progress.running {
-                return Ok(progress.clone());
-            }
-            progress.running = true;
-        }
-        let result = (|| {
-            let repo = self.gix()?;
-            let out = cli::run_cancellable(self.root(), &["rev-list", "--all", "--topo-order"], cancel)?;
-            let ids: Vec<_> = out
-                .stdout_str()
-                .lines()
-                .map(|id| gix::ObjectId::from_hex(id.as_bytes()).map_err(repo::gx))
-                .collect::<IdeResult<_>>()?;
-            {
-                let mut p = self.index_progress.lock().unwrap_or_else(|p| p.into_inner());
-                p.total = ids.len() as u32;
-                p.indexed = 0;
-            }
-            for (i, id) in ids.iter().enumerate() {
-                if cancel.is_cancelled() {
-                    return Err(ide_core::IdeError::cancelled());
-                }
-                let indexed = self.log_index.lock().unwrap_or_else(|p| p.into_inner()).indexed(&id.to_string());
-                if !indexed {
-                    let files = self.commit_files(&id.to_string())?;
-                    let paths =
-                        files.into_iter().flat_map(|f| std::iter::once(f.path).chain(f.old_path)).collect::<Vec<_>>();
-                    let mut index = self.log_index.lock().unwrap_or_else(|p| p.into_inner());
-                    let c = index.get(&repo, *id)?;
-                    let message = index.message(&repo, *id)?;
-                    index.index_commit(&c.id, &message, &c.author, &c.email, &paths);
-                    if i % 100 == 0 {
-                        index.flush();
-                    }
-                }
-                self.index_progress.lock().unwrap_or_else(|p| p.into_inner()).indexed = i as u32 + 1;
-            }
-            Ok(())
-        })();
-        self.log_index.lock().unwrap_or_else(|p| p.into_inner()).flush();
-        self.index_progress.lock().unwrap_or_else(|p| p.into_inner()).running = false;
-        result?;
-        Ok(self.log_index_progress())
-    }
-
    pub fn log_details(&self, revision: &str) -> IdeResult<LogDetails> {
        self.log_details_cancellable(revision, &CancellationToken::new())
    }
@@ -6,7 +6,7 @@ use crate::repo::{gx, to_string};
 use gix::ObjectId;
 use gix::bstr::ByteSlice;
 use ide_core::IdeResult;
-use redb::{Database, MultimapTableDefinition, ReadableDatabase, TableDefinition};
+use redb::{Database, ReadableDatabase, TableDefinition};
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
 use std::sync::{Arc, Mutex, OnceLock, Weak};
@@ -14,9 +14,6 @@ use std::time::SystemTime;

 const COMMITS: TableDefinition<&str, &[u8]> = TableDefinition::new("summaries-v2");
 const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1");
-const PATHS: TableDefinition<&str, &[u8]> = TableDefinition::new("paths-v2");
-const POSTINGS: MultimapTableDefinition<&str, &str> = MultimapTableDefinition::new("search-v1");
-const INDEXED: TableDefinition<&str, bool> = TableDefinition::new("indexed-v1");

 pub(crate) struct IndexedView {
    pub commits: Vec<Commit>,
@@ -36,9 +33,6 @@ pub(crate) struct LogIndex {
    memory: HashMap<ObjectId, Arc<Commit>>,
    dirty: Vec<Arc<Commit>>,
    dirty_messages: Vec<(String, String)>,
-    dirty_search: Vec<(String, Vec<String>)>,
-    path_memory: HashMap<(ObjectId, String), Option<(ObjectId, u16)>>,
-    dirty_paths: Vec<(String, Option<(String, u16)>)>,
    pub head: Option<(ObjectId, Option<SystemTime>)>,
    pub reachable: HashSet<ObjectId>,
    pub views: HashMap<String, Arc<IndexedView>>,
@@ -92,91 +86,6 @@ impl LogIndex {
        }
        Ok(ids)
    }
-    pub fn indexed(&self, id: &str) -> bool {
-        self.db
-            .as_ref()
-            .and_then(|db| {
-                let txn = db.begin_read().ok()?;
-                let table = txn.open_table(INDEXED).ok()?;
-                Some(table.get(id).ok()??.value())
-            })
-            .unwrap_or(false)
-    }
-
-    pub fn index_commit(&mut self, id: &str, message: &str, author: &str, email: &str, paths: &[String]) {
-        let mut keys: HashSet<String> = Self::grams(message).into_iter().map(|s| format!("m:{s}")).collect();
-        for user in [author, email, email.split('@').next().unwrap_or(email)] {
-            keys.insert(format!("u:{}", normalize_user(user)));
-        }
-        for path in paths {
-            keys.insert(format!("p:{path}"));
-        }
-        self.dirty_search.push((id.into(), keys.into_iter().collect()));
-    }
-
-    fn grams(text: &str) -> Vec<String> {
-        let chars: Vec<_> = text.to_lowercase().chars().collect();
-        chars.windows(3).map(|s| s.iter().collect()).collect::<HashSet<_>>().into_iter().collect()
-    }
-
-    /// Missing/unindexed commits are always checked directly by the caller.
-    pub fn message_candidates(&self, text: &str) -> Option<HashSet<String>> {
-        let grams = Self::grams(text);
-        if grams.is_empty() {
-            return None;
-        }
-        let db = self.db.as_ref()?;
-        let txn = db.begin_read().ok()?;
-        let table = txn.open_multimap_table(POSTINGS).ok()?;
-        let mut candidates: Option<HashSet<String>> = None;
-        for gram in grams {
-            let values = table.get(format!("m:{gram}").as_str()).ok()?;
-            let ids: HashSet<_> = values.filter_map(Result::ok).map(|s| s.value().to_string()).collect();
-            candidates = Some(match candidates {
-                Some(old) => old.intersection(&ids).cloned().collect(),
-                None => ids,
-            });
-            if candidates.as_ref().is_some_and(HashSet::is_empty) {
-                break;
-            }
-        }
-        Some(candidates.unwrap_or_default())
-    }
-
-    pub fn user_candidates(&self, authors: &[String]) -> Option<HashSet<String>> {
-        let txn = self.db.as_ref()?.begin_read().ok()?;
-        let table = txn.open_multimap_table(POSTINGS).ok()?;
-        let mut ids = HashSet::new();
-        for author in authors {
-            let name = author.split('<').next().unwrap_or(author).trim();
-            let email = author.split('<').nth(1).map(|s| s.trim_end_matches('>')).unwrap_or(author);
-            for alias in [name, email, email.split('@').next().unwrap_or(email)] {
-                for value in table.get(format!("u:{}", normalize_user(alias)).as_str()).ok()?.filter_map(Result::ok) {
-                    ids.insert(value.value().to_string());
-                }
-            }
-        }
-        Some(ids)
-    }
-
-    pub fn path_candidates(&self, paths: &[String]) -> Option<HashSet<String>> {
-        let txn = self.db.as_ref()?.begin_read().ok()?;
-        let table = txn.open_multimap_table(POSTINGS).ok()?;
-        let mut ids = HashSet::new();
-        for path in paths {
-            for value in table.get(format!("p:{path}").as_str()).ok()?.filter_map(Result::ok) {
-                ids.insert(value.value().to_string());
-            }
-            let prefix = format!("p:{path}/");
-            let end = format!("{prefix}{}", char::MAX);
-            for row in table.range(prefix.as_str()..end.as_str()).ok()?.filter_map(Result::ok) {
-                for value in row.1.filter_map(Result::ok) {
-                    ids.insert(value.value().to_string());
-                }
-            }
-        }
-        Some(ids)
-    }
    pub fn open(&mut self, dir: &Path) {
        if self.opened {
            return;
@@ -272,11 +181,7 @@ impl LogIndex {
    }

    pub fn flush(&mut self) {
-        if self.dirty.is_empty()
-            && self.dirty_paths.is_empty()
-            && self.dirty_messages.is_empty()
-            && self.dirty_search.is_empty()
-        {
+        if self.dirty.is_empty() && self.dirty_messages.is_empty() {
            return;
        }
        let result = (|| -> Result<(), Box<dyn std::error::Error>> {
@@ -291,29 +196,12 @@ impl LogIndex {
                    table.insert(commit.id.as_str(), bytes.as_slice())?;
                }
            }
-            {
-                let mut table = txn.open_table(PATHS)?;
-                for (key, value) in &self.dirty_paths {
-                    let bytes = serde_json::to_vec(value)?;
-                    table.insert(key.as_str(), bytes.as_slice())?;
-                }
-            }
            {
                let mut table = txn.open_table(MESSAGES)?;
                for (id, message) in &self.dirty_messages {
                    table.insert(id.as_str(), message.as_str())?;
                }
            }
-            {
-                let mut postings = txn.open_multimap_table(POSTINGS)?;
-                let mut indexed = txn.open_table(INDEXED)?;
-                for (id, keys) in &self.dirty_search {
-                    for key in keys {
-                        postings.insert(key.as_str(), id.as_str())?;
-                    }
-                    indexed.insert(id.as_str(), true)?;
-                }
-            }
            txn.commit()?;
            Ok(())
        })();
@@ -321,52 +209,7 @@ impl LogIndex {
            tracing::warn!("Git log cache write failed: {error}");
        }
        self.dirty_messages.clear();
-        self.dirty_search.clear();
        self.dirty.clear();
-        self.dirty_paths.clear();
-    }
-
-    pub fn path_entry(
-        &mut self,
-        repo: &gix::Repository,
-        id: ObjectId,
-        path: &str,
-    ) -> IdeResult<Option<(ObjectId, u16)>> {
-        let memory_key = (id, path.to_string());
-        if let Some(value) = self.path_memory.get(&memory_key) {
-            return Ok(*value);
-        }
-        let key = format!("{id}\0{path}");
-        let cached = self.db.as_ref().and_then(|db| {
-            let txn = db.begin_read().ok()?;
-            let table = txn.open_table(PATHS).ok()?;
-            let value = table.get(key.as_str()).ok()??;
-            serde_json::from_slice::<Option<(String, u16)>>(value.value()).ok()
-        });
-        let cached = match cached {
-            Some(None) => Some(None),
-            Some(Some((hex, mode))) => ObjectId::from_hex(hex.as_bytes()).ok().map(|id| Some((id, mode))),
-            None => None,
-        };
-        let value = if let Some(value) = cached {
-            value
-        } else {
-            let tree = repo.find_commit(id).map_err(gx)?.tree().map_err(gx)?;
-            let value = tree
-                .lookup_entry_by_path(Path::new(path))
-                .map_err(gx)?
-                .map(|entry| (entry.object_id(), entry.mode().value()));
-            if self.db.is_some() {
-                self.dirty_paths.push((key, value.map(|(id, mode)| (id.to_string(), mode))));
-            }
-            value
-        };
-        if self.path_memory.len() >= 4096 {
-            self.flush();
-            self.path_memory.clear();
-        }
-        self.path_memory.insert(memory_key, value);
-        Ok(value)
    }
 }

@@ -65,7 +65,6 @@ pub(crate) fn discover(path: &Path) -> IdeResult<Option<Repo>> {
        inner: std::sync::Mutex::new(cache),
        ignored: Default::default(),
        log_index: Default::default(),
-        index_progress: Default::default(),
        log_signatures: Default::default(),
    }))
 }
@@ -99,8 +99,6 @@ fn lazy_summaries_seek_and_index_survive_refresh_and_restart() {
    let cancel = ide_core::CancellationToken::new();
    cancel.cancel();
    assert!(repo.log_cancellable(&query, &cancel).is_err());
-    let progress = repo.index_log(&ide_core::CancellationToken::new()).unwrap();
-    assert_eq!((progress.indexed, progress.total, progress.running), (70, 70, false));
    assert_eq!(repo.log(&LogQuery { text: Some("needle body 5".into()), ..query.clone() }).unwrap().len(), 5);
    let new = commit(dir, "b", "new head");
    let refreshed = repo.log(&LogQuery { retain_until: Some(ids[0].clone()), ..query.clone() }).unwrap();
@@ -436,3 +434,31 @@ fn multiple_paths_are_simplified_together_at_merges() {
        assert_eq!(log[0].graph_parents.as_ref().unwrap().len(), 2);
    }
 }
+
+#[test]
+fn paths_are_literal_and_text_matches_bodies_or_hash_prefixes() {
+    let tmp = tempfile::tempdir().unwrap();
+    let dir = tmp.path();
+    git(dir, &["init", "-q"]);
+    let star = commit(dir, "[a]", "star\n\nBody Needle");
+    let plain = commit(dir, "a", "plain");
+    let repo = Repo::discover(dir).unwrap().unwrap();
+    let ids = |q: LogQuery| repo.log(&q).unwrap().into_iter().map(|c| c.id).collect::<Vec<_>>();
+    assert_eq!(ids(LogQuery { path: Some("[a]".into()), ..Default::default() }), vec![star.clone()]);
+    assert_eq!(ids(LogQuery { text: Some("body needle".into()), ..Default::default() }), vec![star.clone()]);
+    assert!(ids(LogQuery { text: Some("body needle".into()), text_match_case: true, ..Default::default() }).is_empty());
+    assert_eq!(ids(LogQuery { text: Some(plain[..7].to_uppercase()), ..Default::default() }), vec![plain]);
+}
+
+#[test]
+fn case_insensitive_text_folds_non_ascii() {
+    let tmp = tempfile::tempdir().unwrap();
+    let dir = tmp.path();
+    git(dir, &["init", "-q"]);
+    let hit = commit(dir, "a", "Ärger ПРИВЕТ");
+    commit(dir, "a", "other");
+    let repo = Repo::discover(dir).unwrap().unwrap();
+    let ids = |q: LogQuery| repo.log(&q).unwrap().into_iter().map(|c| c.id).collect::<Vec<_>>();
+    assert_eq!(ids(LogQuery { text: Some("ärger привет".into()), ..Default::default() }), vec![hit.clone()]);
+    assert!(ids(LogQuery { text: Some("ärger".into()), text_match_case: true, ..Default::default() }).is_empty());
+}
@@ -124,7 +124,7 @@ pub fn read_dir(dir: &Path, excludes: &[String]) -> IdeResult<Vec<FileEntry>> {
    if !fs::metadata(dir)?.is_dir() {
        return Err(IdeError::invalid(format!("{} is not a directory", dir.display())));
    }
-    let gitignore = rules::GitignoreStack::new(dir);
+    let gitignore = rules::GitignoreStack::cached(dir);
    let base = gitignore.repo_root().unwrap_or(dir).to_path_buf();
    let excludes = ExcludeMatcher::new(excludes);

@@ -8,6 +8,7 @@ use parking_lot::{Mutex, RwLock};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
+use std::time::{Duration, Instant, SystemTime};

 /// Exclude globs from settings (`files.exclude`), e.g. `**/node_modules`.
 ///
@@ -72,6 +73,14 @@ pub(crate) fn find_repo_root(start: &Path) -> Option<PathBuf> {
    start.ancestors().find(|dir| dir.join(".git").exists()).map(Path::to_path_buf)
 }

+/// `info/exclude` of the repository at `root` (shared by its worktrees).
+fn exclude_path(root: &Path) -> PathBuf {
+    gix::discover(root)
+        .ok()
+        .map(|r| r.common_dir().join("info/exclude"))
+        .unwrap_or_else(|| root.join(".git/info/exclude"))
+}
+
 /// Layered gitignore matching: per-directory `.gitignore` / `.ignore` from the
 /// path's directory up to the repository root (or the file system root when
 /// not in a repository), then `.git/info/exclude` and the global excludes file.
@@ -83,6 +92,29 @@ pub(crate) struct GitignoreStack {
    nested: Mutex<HashMap<PathBuf, Option<Arc<GitignoreStack>>>>,
 }

+/// How long [`GitignoreStack::cached`] reuses the repository lookup of a directory.
+const REPO_LEVEL_TTL: Duration = Duration::from_secs(3);
+
+/// What changes when `.git/info/exclude` is edited.
+type Stamp = Option<(SystemTime, u64)>;
+
+struct RepoLevel {
+    at: Instant,
+    repo_root: Option<PathBuf>,
+    /// `<common dir>/info/exclude`, found by a repository discovery.
+    exclude: Option<PathBuf>,
+    stamp: Stamp,
+    rules: Vec<Gitignore>,
+}
+
+/// Repo-level rules by the directory they were looked up for.
+static REPO_LEVEL: Mutex<Option<HashMap<PathBuf, Arc<RepoLevel>>>> = Mutex::new(None);
+
+fn stamp_of(file: Option<&Path>) -> Stamp {
+    let meta = std::fs::metadata(file?).ok()?;
+    Some((meta.modified().ok()?, meta.len()))
+}
+
 impl GitignoreStack {
    pub fn new(near: &Path) -> Self {
        let repo_root = find_repo_root(near);
@@ -90,15 +122,52 @@ impl GitignoreStack {
        Self { repo_root, repo_level, cache: Mutex::default(), nested: Mutex::default() }
    }

+    /// [`new`](Self::new) for listing a directory over and over (expanding a tree, a slow share):
+    /// the walk up to the repository root and the repository discovery are reused for
+    /// [`REPO_LEVEL_TTL`]. An edit of `.git/info/exclude` is still seen at once (its mtime and size
+    /// are checked), as is any `.gitignore` / `.ignore`, which are read fresh. Only a repository
+    /// created in the directory, or a change of the global excludes file, can lag by the TTL.
+    pub fn cached(near: &Path) -> Self {
+        let now = Instant::now();
+        let hit = REPO_LEVEL
+            .lock()
+            .as_ref()
+            .and_then(|m| m.get(near))
+            .cloned()
+            .filter(|e| now.duration_since(e.at) < REPO_LEVEL_TTL && stamp_of(e.exclude.as_deref()) == e.stamp);
+        let entry = hit.unwrap_or_else(|| {
+            let repo_root = find_repo_root(near);
+            let exclude = repo_root.as_deref().map(exclude_path);
+            let entry = Arc::new(RepoLevel {
+                at: now,
+                stamp: stamp_of(exclude.as_deref()),
+                rules: Self::load_repo_level_from(repo_root.as_deref(), exclude.as_deref()),
+                repo_root,
+                exclude,
+            });
+            let mut guard = REPO_LEVEL.lock();
+            let map = guard.get_or_insert_with(HashMap::new);
+            map.retain(|_, e| now.duration_since(e.at) < REPO_LEVEL_TTL);
+            map.insert(near.to_path_buf(), entry.clone());
+            entry
+        });
+        Self {
+            repo_root: entry.repo_root.clone(),
+            repo_level: RwLock::new(entry.rules.clone()),
+            cache: Mutex::default(),
+            nested: Mutex::default(),
+        }
+    }
+
    fn load_repo_level(repo_root: Option<&Path>) -> Vec<Gitignore> {
+        Self::load_repo_level_from(repo_root, repo_root.map(exclude_path).as_deref())
+    }
+
+    fn load_repo_level_from(repo_root: Option<&Path>, exclude: Option<&Path>) -> Vec<Gitignore> {
        let mut repo_level = Vec::new();
        if let Some(root) = repo_root {
            let mut builder = GitignoreBuilder::new(root);
-            let exclude = gix::discover(root)
-                .ok()
-                .map(|r| r.common_dir().join("info/exclude"))
-                .unwrap_or_else(|| root.join(".git/info/exclude"));
-            if exclude.is_file() {
+            if let Some(exclude) = exclude.filter(|f| f.is_file()) {
                builder.add(exclude);
            }
            if let Ok(gi) = builder.build()
@@ -119,6 +188,9 @@ impl GitignoreStack {

    /// Re-reads `.git/info/exclude` and the global excludes file.
    pub fn reload_repo_level(&self) {
+        if let (Some(root), Some(map)) = (&self.repo_root, REPO_LEVEL.lock().as_mut()) {
+            map.retain(|dir, _| !dir.starts_with(root));
+        }
        self.nested.lock().clear();
        *self.repo_level.write() = Self::load_repo_level(self.repo_root.as_deref());
    }
@@ -298,4 +370,39 @@ mod tests {
        assert!(anchored.is_excluded(Path::new("build/out.o")));
        assert!(!anchored.is_excluded(Path::new("web/build/out.o")));
    }
+
+    fn repo_with_exclude(rule: &str) -> tempfile::TempDir {
+        let tmp = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(tmp.path().join(".git/info")).unwrap();
+        std::fs::create_dir_all(tmp.path().join("src")).unwrap();
+        std::fs::write(tmp.path().join(".git/info/exclude"), rule).unwrap();
+        tmp
+    }
+
+    #[test]
+    fn cached_stack_sees_every_edit_of_the_ignore_files_at_once() {
+        let tmp = repo_with_exclude("secret.txt\n");
+        let (src, secret, note) =
+            (tmp.path().join("src"), tmp.path().join("src/secret.txt"), tmp.path().join("src/note.md"));
+        assert!(GitignoreStack::cached(&src).is_ignored(&secret, false));
+        assert!(!GitignoreStack::cached(&src).is_ignored(&note, false));
+        std::fs::write(src.join(".gitignore"), "*.md\n").unwrap();
+        assert!(GitignoreStack::cached(&src).is_ignored(&note, false), "directory .gitignore");
+        std::fs::write(tmp.path().join(".git/info/exclude"), "").unwrap();
+        assert!(!GitignoreStack::cached(&src).is_ignored(&secret, false), "info/exclude");
+        std::fs::write(tmp.path().join(".git/info/exclude"), "note.md\nsecret.txt\n").unwrap();
+        assert!(GitignoreStack::cached(&src).is_ignored(&secret, false), "info/exclude again");
+    }
+
+    #[test]
+    fn cached_stack_reuses_the_repository_lookup() {
+        let tmp = repo_with_exclude("");
+        let src = tmp.path().join("src");
+        let first = GitignoreStack::cached(&src);
+        let entry = REPO_LEVEL.lock().as_ref().unwrap().get(&src).unwrap().clone();
+        let again = GitignoreStack::cached(&src);
+        assert!(Arc::ptr_eq(&entry, REPO_LEVEL.lock().as_ref().unwrap().get(&src).unwrap()));
+        assert_eq!(first.repo_root(), again.repo_root());
+        assert_eq!(again.repo_root(), Some(tmp.path()));
+    }
 }
@@ -537,9 +537,15 @@ impl Documents {
    pub fn edit(&self, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
        self.with_doc(doc, |st| {
            if st.read_only {
+                tracing::warn!("edit rejected: {} is read-only", st.path.display());
                return Err(read_only_error(&st.path));
            }
-            let (applied, edits) = st.doc.apply_detailed(base_version, &changes)?;
+            let (applied, edits) = st.doc.apply_detailed(base_version, &changes).inspect_err(|e| {
+                // A stale version is routine (the UI rebases); anything else makes the editor drop the edit.
+                if e.kind != ErrorKind::OutOfSync {
+                    tracing::warn!("edit of {} rejected: {e}", st.path.display());
+                }
+            })?;
            self.set_dirty(doc, st, true);
            self.notify_changed(doc, st, &applied, &edits);
            Ok(st.doc.version())
@@ -1,6 +1,7 @@
 //! Window grouping is independent of a window's project or workspace.
 use ide_core::{IdeError, IdeResult};
 use serde::{Deserialize, Serialize};
+use std::path::PathBuf;

 /// Platform adapters supply the system's tab preference and active project state.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -117,6 +118,43 @@ impl WindowGroups {
    }
 }

+/// One entry of the window session reopened at the next start (`window-groups.json`): a
+/// window group, or a single project window (one project).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SavedWindows {
+    pub projects: Vec<PathBuf>,
+    /// Index into `projects` of the group's selected tab.
+    pub selected: usize,
+}
+
+/// The project windows open now, to reopen at the next start: every group with its selected
+/// tab, then each window outside a group, in the order of `windows`. `project_of` gives a
+/// window's project (`None` for the welcome screen or LightEdit). `None` while a grouped
+/// window has no project yet (a restored member still opening): keep the previous session.
+pub fn session(
+    groups: &[WindowGroup],
+    windows: &[String],
+    project_of: impl Fn(&str) -> Option<PathBuf>,
+) -> Option<Vec<SavedWindows>> {
+    let mut saved = Vec::new();
+    for group in groups {
+        let projects: Option<Vec<PathBuf>> = group.members.iter().map(|label| project_of(label)).collect();
+        let selected = group.members.iter().position(|l| l == &group.selected).unwrap_or(0);
+        saved.push(SavedWindows { projects: projects?, selected });
+    }
+    for label in windows {
+        if groups.iter().any(|g| g.members.contains(label)) {
+            continue;
+        }
+        if let Some(project) = project_of(label)
+            && !saved.iter().any(|s| s.projects.contains(&project))
+        {
+            saved.push(SavedWindows { projects: vec![project], selected: 0 });
+        }
+    }
+    Some(saved)
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -186,4 +224,28 @@ mod tests {
        groups.reorder("a", members(&["d", "c", "b", "a"])).unwrap();
        assert_eq!(groups.group("a").unwrap().members[0], "d");
    }
+
+    #[test]
+    fn the_session_keeps_groups_and_every_ungrouped_project_window() {
+        let groups = vec![WindowGroup { members: members(&["project-1", "project-2"]), selected: "project-2".into() }];
+        let windows = members(&["main", "project-1", "project-2", "project-3", "project-4"]);
+        let project_of = |label: &str| match label {
+            "main" => Some(PathBuf::from("/a")),
+            "project-1" => Some(PathBuf::from("/b")),
+            "project-2" => Some(PathBuf::from("/c")),
+            "project-3" => Some(PathBuf::from("/d")),
+            // The welcome screen or LightEdit.
+            _ => None,
+        };
+        assert_eq!(
+            session(&groups, &windows, project_of).unwrap(),
+            [
+                SavedWindows { projects: vec!["/b".into(), "/c".into()], selected: 1 },
+                SavedWindows { projects: vec!["/a".into()], selected: 0 },
+                SavedWindows { projects: vec!["/d".into()], selected: 0 },
+            ]
+        );
+        // A grouped window still opening its project: keep the previous session.
+        assert_eq!(session(&groups, &windows, |l| (l != "project-2").then(|| PathBuf::from(l))), None);
+    }
 }
@@ -130,14 +130,15 @@ install it from disk.
 Only port themes whose licence allows redistribution, keep their licence file,
 and credit the original authors in `authors` and `description`.

-### From IntelliJ IDEA (automatic)
+### From JetBrains IDEs (automatic)

-To use a theme you already have in IntelliJ, open **Settings › Plugins**, gear
+To use a theme you already have in a JetBrains IDE, open **Settings › Plugins**, gear
 menu:

- **Import Theme from IntelliJ IDE…** lists the theme plugins installed in the
-  JetBrains IDEs (and Android Studio) on this computer, the theme each IDE uses
-  first. It reads their settings folders: `~/Library/Application Support/JetBrains`
+- **Import Theme from JetBrains IDE…** lists the theme plugins installed in the
+  JetBrains IDEs (and Android Studio) on this computer, one row per plugin of
+  each IDE, the plugins of the themes the IDEs use first. It reads the settings
+  folder of each IDE's newest version: `~/Library/Application Support/JetBrains`
  (macOS), `%APPDATA%\JetBrains` (Windows), `~/.config/JetBrains` and
  `~/.local/share/JetBrains` (Linux).
 - **Import IntelliJ Theme from File…** takes a theme plugin downloaded from the
@@ -146,8 +147,8 @@ menu:

 The whole plugin becomes one OpenIDEA theme plugin, `intellij.<plugin id>`, with
 each of its themes and their editor schemes; it is installed through the usual
-install page and the chosen theme (otherwise the first) is applied. Importing
-the plugin again replaces it. Both are actions too (`plugins.importIntellijTheme`,
+install page, and the theme in use stays as it is: choose one of its themes in
+**Settings › Appearance › Theme**. Importing the plugin again replaces it. Both are actions too (`plugins.importIntellijTheme`,
 `plugins.importInstalledIntellijTheme`). The conversion is the one described
 below.

@@ -323,7 +324,7 @@ a token.

 <!-- BEGIN GENERATED TOKEN REFERENCE: pnpm gen:theme-docs -->

-224 themeable tokens: 117 in the UI theme file, 107 in the editor colour scheme file.
+235 themeable tokens: 121 in the UI theme file, 114 in the editor colour scheme file.

 ### Surfaces (UI theme)

@@ -406,6 +407,10 @@ a token.
 | `--diff-modified` | `#385570` | `#c2d8f2` |
 | `--diff-inserted` | `#294436` | `#bee6be` |
 | `--diff-deleted` | `#484a4a` | `#d6d6d6` |
+| `--diff-modified-stripe` | `#43698d` | `#b6d2f2` |
+| `--diff-inserted-stripe` | `#447152` | `#aadeaa` |
+| `--diff-deleted-stripe` | `#656e76` | `#c8c8c8` |
+| `--diff-conflict-stripe` | `#8f5247` | `#ffc8bd` |

 ### Syntax (editor scheme)

@@ -429,6 +434,13 @@ a token.
 | `--syn-param` | `#bcbec4` | `#080808` |
 | `--syn-property` | `#c77dbb` | `#871094` |
 | `--syn-constant` | `#c77dbb` | `#871094` |
+| `--syn-python-local-variable` | `var(--syn-variable)` | `var(--syn-variable)` |
+| `--syn-python-global-variable` | `var(--syn-global)` | `var(--syn-global)` |
+| `--syn-python-instance-attribute` | `var(--syn-property)` | `var(--syn-property)` |
+| `--syn-python-class-attribute` | `var(--syn-property)` | `var(--syn-property)` |
+| `--syn-python-constant` | `var(--syn-constant)` | `var(--syn-constant)` |
+| `--syn-python-property` | `var(--syn-property)` | `var(--syn-property)` |
+| `--syn-python-type-parameter` | `var(--syn-type)` | `var(--syn-type)` |
 | `--syn-builtin` | `#8888c6` | `#000080` |
 | `--syn-self` | `#94558d` | `#94558d` |
 | `--syn-keyword-arg` | `#aa4926` | `#660099` |